07 模型选择与正则化

# 为“第1步：生成我们的“玩具”数据集”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 为“第1步：生成我们的“玩具”数据集”导入 `matplotlib.pyplot` 并绑定 `plt`，用于构建当前任务的坐标轴并呈现比较结果。
import matplotlib.pyplot as plt
# 导入 Matplotlib 样式接口并绑定为 `style`，用于给正则化机制图设置一致的白底网格主题。
import matplotlib.style as style

# 为“第1步：生成我们的“玩具”数据集”，固定随机数序列，使课堂示例可重复。
np.random.seed(42)
# 建立 `X_sample` 的有序取值网格，用于展示“带有噪声的正弦波数据”随参数变化的比较结果。
X_sample = np.linspace(0, 10, 20)
# 在正弦曲线上叠加标准差 0.3 的噪声，得到用于阶数比较的观测响应。
y_sample = np.sin(X_sample) + np.random.normal(0, 0.3, len(X_sample))
# 建立 `X_true` 的有序取值网格，用于展示“带有噪声的正弦波数据”随参数变化的比较结果。
X_true = np.linspace(0, 10, 100)
# 用正弦信号叠加噪声得到回归目标，演示模型复杂度差异。
y_true = np.sin(X_true)

# 创建 `fig, ax` 画布，承载“带有噪声的正弦波数据”的并排视觉比较。
fig, ax = plt.subplots(figsize=(9, 6))
# 以 `X_sample` 为横轴、`y_sample` 为纵轴绘制散点，展示“带有噪声的正弦波数据”。
ax.scatter(X_sample, y_sample, label='观测数据 (带噪声)', color='black', zorder=5)
# 以 `X_true` 为横轴、`y_true` 为纵轴绘制曲线，展示“带有噪声的正弦波数据”。
ax.plot(X_true, y_true, label='真实规律 (无噪声)', color='crimson', lw=2.5)
# 将图题设为“我们的“玩具”数据集”，直接说明当前图形的比较目的。
ax.set_title('我们的“玩具”数据集', fontsize=16)
# 为“第1步：生成我们的“玩具”数据集”，将横轴标为“X”，明确横向编码的变量。
ax.set_xlabel('X', fontsize=12)
# 为“第1步：生成我们的“玩具”数据集”，将纵轴标为“y”，明确纵向编码的变量。
ax.set_ylabel('y', fontsize=12)
# 显示“第1步：生成我们的“玩具”数据集”图例，使颜色或线型与比较对象一一对应。
ax.legend(fontsize=11)
# 显示玩具样本及真实非线性关系，检查噪声水平和线性模型将面对的欠拟合结构。
plt.show()

# 为“第2步：简单模型（1阶）的欠拟合”，从 `sklearn.preprocessing` 导入`PolynomialFeatures` 用于由原始特征展开多项式项。
from sklearn.preprocessing import PolynomialFeatures
# 为“第2步：简单模型（1阶）的欠拟合”，从 `sklearn.linear_model` 导入`LinearRegression` 用于拟合普通最小二乘线性回归。
from sklearn.linear_model import LinearRegression
# 为“第2步：简单模型（1阶）的欠拟合”，从 `sklearn.pipeline` 导入`make_pipeline` 用于按给定顺序创建预处理与估计器流程。
from sklearn.pipeline import make_pipeline

# 封装指定阶数的多项式拟合与绘图，使欠拟合、适度拟合和过拟合使用同一数据口径比较。
def plot_poly_fit(degree, X_sample, y_sample, X_true, y_true, title_suffix):
    # 组装“多项式展开—线性回归”Pipeline，使变换与估计共享同一次拟合调用。
    model = make_pipeline(PolynomialFeatures(degree), LinearRegression())
    # 用抽样训练点估计由 `degree` 指定阶数的多项式系数，供三个复杂度页面复用。
    model.fit(X_sample[:, np.newaxis], y_sample)
    # 在共同网格上生成当前 `degree` 阶模型预测，用同一真函数比较欠拟合、适度拟合与过拟合。
    y_pred = model.predict(X_true[:, np.newaxis])

    # 创建 `fig, ax` 画布，承载“1阶多项式模型：欠拟合”的并排视觉比较。
    fig, ax = plt.subplots(figsize=(9, 6))
    # 以 `X_sample` 为横轴、`y_sample` 为纵轴绘制散点，展示“1阶多项式模型：欠拟合”。
    ax.scatter(X_sample, y_sample, label='观测数据', color='black', zorder=5)
    # 以 `X_true` 为横轴、`y_true` 为纵轴绘制曲线，展示“1阶多项式模型：欠拟合”。
    ax.plot(X_true, y_true, label='真实规律', color='crimson', lw=2.5, alpha=0.4)
    # 以 `X_true` 为横轴、`y_pred` 为纵轴绘制曲线，展示“1阶多项式模型：欠拟合”。
    ax.plot(X_true, y_pred, label=f'{degree}阶多项式拟合', color='cornflowerblue', lw=3)
    # 用图题概括“第2步：简单模型（1阶）的欠拟合”的比较对象与当前计算结果。
    ax.set_title(f'模型复杂度 (阶数 = {degree}): {title_suffix}', fontsize=16)
    # 为“第2步：简单模型（1阶）的欠拟合”，将横轴标为“X”，明确横向编码的变量。
    ax.set_xlabel('X', fontsize=12)
    # 为“第2步：简单模型（1阶）的欠拟合”，将纵轴标为“y”，明确纵向编码的变量。
    ax.set_ylabel('y', fontsize=12)
    # 为“第2步：简单模型（1阶）的欠拟合”，限定纵轴范围，使比较对象使用一致尺度。
    ax.set_ylim(-2, 2)
    # 显示“第2步：简单模型（1阶）的欠拟合”图例，使颜色或线型与比较对象一一对应。
    ax.legend(fontsize=11)
    # 显示当前 `degree` 阶拟合、观测点与真实规律，检查该复杂度对应的拟合形态。
    plt.show()

# 拟合并绘制当前阶数的多项式，比较欠拟合、适度拟合与过拟合。
plot_poly_fit(1, X_sample, y_sample, X_true, y_true, "欠拟合 (高偏差)")

# 拟合并绘制当前阶数的多项式，比较欠拟合、适度拟合与过拟合。
plot_poly_fit(3, X_sample, y_sample, X_true, y_true, "良好拟合")

# 拟合并绘制当前阶数的多项式，比较欠拟合、适度拟合与过拟合。
plot_poly_fit(15, X_sample, y_sample, X_true, y_true, "过拟合 (高方差)")

from pathlib import Path  # 管理跨平台公开数据路径
from urllib.request import urlretrieve  # 复用本章隐藏设置单元安装的浏览器标识下载器
import numpy as np  # 计算对数收益率
import pandas as pd  # 整理多只股票的日行情

# 按 Linux 共享数据、Windows 共享数据、项目缓存的顺序选择行情文件。
price_data_path = next((candidate_path for candidate_path in [Path('/home/ubuntu/r2_data_mount/data/stock/stock_price_pre_adjusted.h5'), Path('C:/qiufei/data/stock/stock_price_pre_adjusted.h5'), Path('data/course/stock_price_pre_adjusted.h5')] if candidate_path.exists()), Path('data/course/stock_price_pre_adjusted.h5'))
if not price_data_path.exists():
    price_data_path.parent.mkdir(parents=True, exist_ok=True)
    urlretrieve('https://assets.qiufei.site/data/stock/stock_price_pre_adjusted.h5', price_data_path)
order_book_ids = ['600276.XSHG', '002415.XSHE', '600009.XSHG', '603259.XSHG']  # 固定长三角公司样本
price_frames = []  # 收集各公司的选择性读取结果
for order_book_id in order_book_ids:  # 逐只股票避免载入全市场大文件
    company_prices = pd.read_hdf(price_data_path, key='data', where=f'order_book_id == "{order_book_id}"', columns=['order_book_id', 'date', 'close']).reset_index()  # 将 HDF 索引恢复为公司与日期列
    price_frames.append(company_prices)  # 保存当前公司行情
local_prices = pd.concat(price_frames, ignore_index=True)  # 合并四只股票的行情
local_prices = local_prices.query("'2020-01-01' <= date <= '2024-12-31'")  # 固定教学样本期
close_prices = local_prices.pivot(index='date', columns='order_book_id', values='close').sort_index().dropna()  # 对齐共同交易日
returns = np.log(close_prices / close_prices.shift(1)).dropna()  # 计算前复权对数收益率
X_df = returns[['002415.XSHE', '600009.XSHG', '603259.XSHG']].copy()  # 使用同日市场信息构造特征
X_df.columns = ['hikvision_return', 'shanghai_airport_return', 'wuxi_apptec_return']  # 使用业务含义明确的列名
Y = returns['600276.XSHG'].shift(-1).dropna().to_numpy()  # 将恒瑞下一交易日收益作为目标
X_df = X_df.iloc[:-1]  # 与向前移动后的目标保持日期对齐
X = X_df.to_numpy()  # 转为后续模型所需数组
X_df.head()  # 核对公开数据与列顺序

# 为“步骤2：数据标准化与训练/测试集划分”，导入 `StandardScaler`，供训练期按特征列估计均值与尺度后外推到未来测试期。
from sklearn.preprocessing import StandardScaler

# 检查输入样本非空
# 当任一输入为空时立即拒绝拟合，避免在空样本上估计系数。
if len(X) == 0 or len(Y) == 0:
    # 主动抛出数据说明错误，阻止缺列样本继续进入模型。
    raise ValueError("No data available for training")

split_index = int(len(X) * 0.7)  # 按日期确定训练期终点
X_train, X_test = X[:split_index], X[split_index:]  # 保持过去训练、未来测试
y_train, y_test = Y[:split_index], Y[split_index:]  # 对齐时间有序目标
# 建立缩放器；其统计量将在下一步只由时间靠前的训练样本按特征列估计。
scaler = StandardScaler()
# 逐特征估计时间靠前训练样本的均值与标准差，并转换训练特征。
X_train_scaled = scaler.fit_transform(X_train)
# 使用确定的训练样本逐特征统计量转换未来测试特征。
X_test_scaled = scaler.transform(X_test)

# 报告“训练集大小: {X_train_scaled.shape}”中的 `X_train_scaled`，核对“步骤2：数据标准化与训练/测试集划分”的样本形状。
print(f'训练集大小: {X_train_scaled.shape}')
# 报告“测试集大小: {X_test_scaled.shape}”中的 `X_test_scaled`，核对“步骤2：数据标准化与训练/测试集划分”的样本形状。
print(f'测试集大小: {X_test_scaled.shape}')

# 为“步骤3：岭回归系数路径”，从 `sklearn.linear_model` 导入`Ridge` 用于拟合带 L2 惩罚的线性回归。
from sklearn.linear_model import Ridge

# 建立 `alphas` 的有序取值网格，用于展示“岭回归系数随惩罚强度(alpha)的变化路径”随参数变化的比较结果。
alphas = 10**np.linspace(4, -2, 100)
# 初始化岭回归系数路径容器，按 alpha 顺序保存每个特征的收缩比较结果。
coefs = []

# 遍历 `a in alphas` 的候选超参数，逐个拟合并记录“步骤3：岭回归系数路径”的评价量。
for a in alphas:
    # 创建 `Ridge` 实例 `ridge`，用于拟合带 L2 惩罚的线性回归。
    ridge = Ridge(alpha=a, fit_intercept=True)
    # 在标准化训练集上拟合当前 alpha 的岭回归，估计各特征的 L2 收缩系数。
    ridge.fit(X_train_scaled, y_train)
    # 把 `ridge.coef_` 加入 `coefs`，形成惩罚强度与系数向量一一对应的路径。
    coefs.append(ridge.coef_)

# 创建 `fig, ax` 画布，承载“岭回归系数随惩罚强度(alpha)的变化路径”的并排视觉比较。
fig, ax = plt.subplots(figsize=(10, 6))
feature_labels = ['海康威视', '上海机场', '药明康德']
line_styles = ['-', '--', '-.']
for feature_position, feature_label in enumerate(feature_labels):
    ax.plot(alphas, np.asarray(coefs)[:, feature_position], linestyle=line_styles[feature_position], linewidth=2.4, label=feature_label)
# 将 `ax` 的横轴切换到代码指定的尺度。
ax.set_xscale('log')
# 将横轴标为“Alpha (惩罚强度)”，明确横向编码的变量。
ax.set_xlabel('Alpha (惩罚强度)', fontsize=12)
# 将纵轴标为“系数大小 (Coefficients)”，明确纵向编码的变量。
ax.set_ylabel('系数大小 (Coefficients)', fontsize=12)
# 将图题设为“岭回归系数路径”，直接说明当前图形的比较目的。
ax.set_title('岭回归系数路径', fontsize=16)
ax.legend()
# 反转当前横轴的显示方向。
plt.gca().invert_xaxis()
# 为“步骤3：岭回归系数路径”添加辅助网格，便于比较位置、斜率或组间差异。
plt.grid(True, which="both", ls="--")
# 显示岭路径，从运行图读取具体形状，不预设每个坐标的绝对值单调。
plt.show()

# 为“步骤4：Lasso回归系数路径”，从 `sklearn.linear_model` 导入`Lasso` 用于拟合带 L1 惩罚的线性回归。
from sklearn.linear_model import Lasso
# 导入绘图接口，在当前文档中生成 Lasso 系数路径。
import matplotlib.pyplot as plt

# 建立 `alphas_lasso` 的有序取值网格，用于展示“Lasso回归系数随惩罚强度(alpha)的变化路径”随参数变化的比较结果。
alphas_lasso = 10**np.linspace(-2, -5, 100)
# 初始化 Lasso 系数路径容器，按 alpha 顺序保存稀疏化比较结果。
coefs_lasso = []

# 遍历 `a in alphas_lasso` 的候选超参数，逐个拟合并记录“步骤4：Lasso回归系数路径”的评价量。
for a in alphas_lasso:
    # 创建 `Lasso` 实例 `lasso`，用于拟合带 L1 惩罚的线性回归。
    lasso = Lasso(alpha=a, fit_intercept=True)
    # 在标准化训练集上拟合当前 alpha 的 Lasso，估计可能精确归零的 L1 系数。
    lasso.fit(X_train_scaled, y_train)
    # 把 `lasso.coef_` 加入 `coefs_lasso`，形成惩罚强度与系数向量一一对应的路径。
    coefs_lasso.append(lasso.coef_)

# 创建 `fig, ax` 画布，承载“Lasso回归系数随惩罚强度(alpha)的变化路径”的并排视觉比较。
fig, ax = plt.subplots(figsize=(10, 6))
# 使用与岭回归相同的中文公司名和线型，便于两页对照。
for feature_position, feature_label in enumerate(feature_labels):
    ax.plot(alphas_lasso, np.asarray(coefs_lasso)[:, feature_position], linestyle=line_styles[feature_position], linewidth=2.4, label=feature_label)
# 将 `ax` 的横轴切换到代码指定的尺度。
ax.set_xscale('log')
# 将横轴标为“Alpha (惩罚强度)”，明确横向编码的变量。
ax.set_xlabel('Alpha (惩罚强度)', fontsize=12)
# 将纵轴标为“系数大小 (Coefficients)”，明确纵向编码的变量。
ax.set_ylabel('系数大小 (Coefficients)', fontsize=12)
# 将图题设为“Lasso回归系数路径”，直接说明当前图形的比较目的。
ax.set_title('Lasso回归系数路径', fontsize=16)
ax.legend()
# 反转当前横轴的显示方向。
plt.gca().invert_xaxis()
# 为“步骤4：Lasso回归系数路径”添加辅助网格，便于比较位置、斜率或组间差异。
plt.grid(True, which="both", ls="--")
# 显示 Lasso 路径，从运行图读取坐标进入、退出、变号或归零的实际顺序。
plt.show()

from sklearn.model_selection import GridSearchCV, TimeSeriesSplit  # 建立训练期扩展窗口验证
from sklearn.pipeline import Pipeline  # 将缩放约束在每个验证折的训练窗口内

lasso_pipeline = Pipeline([('scaler', StandardScaler()), ('lasso', Lasso(max_iter=10000))])  # 每个时间训练折逐特征估计缩放统计量并拟合 Lasso
time_series_split = TimeSeriesSplit(n_splits=5)  # 保证每折训练观测早于验证观测
lasso_cv = GridSearchCV(lasso_pipeline, {'lasso__alpha': alphas_lasso}, cv=time_series_split, scoring='neg_mean_squared_error')  # 只用训练期选alpha
lasso_cv.fit(X_train, y_train)  # 在训练期扩展窗口完成选择并重拟合
best_alpha = lasso_cv.best_params_['lasso__alpha']  # 读取训练期验证选择的惩罚强度
print(f'扩展窗口验证找到的最优 alpha: {best_alpha:.6f}')  # 报告选择结果
best_coefs = pd.Series(lasso_cv.best_estimator_.named_steps['lasso'].coef_, index=X_df.columns)  # 使用真实特征名标注系数
# 标出交叉验证所选 alpha 对应的 Lasso 系数。
print('\n最优alpha下的系数:')
# 输出交叉验证所选 alpha 对应的系数，检查正则化后保留的变量。
print(best_coefs)

from sklearn.metrics import mean_squared_error  # 计算各确定候选在同一最终测试切片的均方误差
from sklearn.linear_model import LinearRegression  # 显式导入 OLS 基准，使当前文档可直接运行
y_pred_test = lasso_cv.predict(X_test)  # 使用开发期确定的完整Pipeline预测最终测试行
ols = LinearRegression().fit(X_train_scaled, y_train)  # 仅用训练期拟合未正则化线性基准
y_pred_ols = ols.predict(X_test_scaled)  # 对同一最终测试行生成OLS基准预测
zero_predictions = np.zeros(len(y_test))  # 事先确定零收益作为金融预测朴素基线
mean_predictions = np.repeat(y_train.mean(), len(y_test))  # 事先确定训练期均值作为数据驱动朴素基线
sealed_predictions = {'OLS': y_pred_ols, '零收益': zero_predictions, '训练均值': mean_predictions}  # 确定三条对照预测
lasso_squared_errors = np.square(y_test - y_pred_test)  # 保存Lasso逐行平方误差供配对比较
paired_differences = pd.DataFrame({name: lasso_squared_errors - np.square(y_test - predictions) for name, predictions in sealed_predictions.items()})  # 计算Lasso减基线的逐行误差差
bootstrap_rng = np.random.default_rng(20260829)  # 固定不确定性程序的随机种子
bootstrap_indices = bootstrap_rng.integers(0, len(y_test), size=(5000, len(y_test)))  # 在行可交换假设下配对重抽测试行
bootstrap_means = paired_differences.to_numpy()[bootstrap_indices].mean(axis=1)  # 不重拟合地计算每次平均误差差
bootstrap_intervals = np.quantile(bootstrap_means, [0.025, 0.975], axis=0)  # 形成逐基线95%百分位区间
lasso_mse = mean_squared_error(y_test, y_pred_test)  # 固定Lasso在最终测试切片上的点估计
baseline_mses = [mean_squared_error(y_test, predictions) for predictions in sealed_predictions.values()]  # 固定三条事先确定基线的同窗点估计
audit_table = pd.DataFrame({'基线': list(sealed_predictions), 'Lasso MSE': lasso_mse, '基线 MSE': baseline_mses, '差': paired_differences.mean().to_numpy(), '95%区间': [f'[{lo:.8f}, {hi:.8f}]' for lo, hi in zip(bootstrap_intervals[0], bootstrap_intervals[1])]})  # 每条基线一行汇总点估计与配对区间
display(audit_table.round(8))  # 负差代表Lasso误差更低；单表保留完整检查证据
has_conditional_increment = bool((bootstrap_intervals[1] < 0).all())  # 只有所有区间上界均低于零才通过预设增量门槛
sealed_conclusion = '条件性增量证据：在行可交换假设下，Lasso相对三条基线的区间均低于0；不据此重选模型。' if has_conditional_increment else 'no-increment / no-deploy：当前最终测试切片未同时越过三条基线门槛；保留失败结果且不重开测试。'  # 确定通过与失败两条路径
print(sealed_conclusion)  # 报告与事先确定门槛一致的条件性结论

alphas_to_test = [0.001, 0.005, 0.01]  # 固定题目要求的惩罚强度
exercise_feature_names = X_df.columns.tolist()  # 保留与模型列顺序一致的业务特征名
zero_tolerance = 1e-10  # 预先声明数值归零容差，避免把浮点噪声误判为活跃特征
exercise_rows = []  # 保存各扩展窗口的验证证据
exercise_splitter = TimeSeriesSplit(n_splits=3)  # 生成三个过去训练、未来验证窗口
for alpha_value in alphas_to_test:  # 对每个候选值做相同验证
    for window_id, (train_indices, validation_indices) in enumerate(exercise_splitter.split(X_train), start=1):  # 遍历扩展窗口
        exercise_model = Pipeline([('scaler', StandardScaler()), ('lasso', Lasso(alpha=alpha_value, max_iter=10000))])  # 只由当前训练窗逐特征估计均值与标准差
        exercise_model.fit(X_train[train_indices], y_train[train_indices])  # 仅用当前窗口较早数据拟合
        validation_predictions = exercise_model.predict(X_train[validation_indices])  # 预测随后验证窗
        validation_mse = mean_squared_error(y_train[validation_indices], validation_predictions)  # 计算窗口验证误差
        zero_baseline_mse = mean_squared_error(y_train[validation_indices], np.zeros(len(validation_indices)))  # 计算同期零收益基准
        fitted_coefficients = exercise_model.named_steps['lasso'].coef_  # 提取与业务特征顺序一致的折内系数
        coefficient_fields = {f'{feature_name}_coef': coefficient_value for feature_name, coefficient_value in zip(exercise_feature_names, fitted_coefficients)}  # 保存逐特征数值系数
        zero_state_fields = {f'{feature_name}_zero': bool(abs(coefficient_value) <= zero_tolerance) for feature_name, coefficient_value in zip(exercise_feature_names, fitted_coefficients)}  # 按确定容差标记逐特征零状态
        nonzero_count = int(np.count_nonzero(np.abs(fitted_coefficients) > zero_tolerance))  # 按同一容差汇总活跃特征数
        exercise_rows.append({'alpha': alpha_value, '窗口': window_id, '验证MSE': validation_mse, '零收益MSE': zero_baseline_mse, '非零特征数': nonzero_count, **coefficient_fields, **zero_state_fields})  # 保存完整逐窗答案
exercise_results = pd.DataFrame(exercise_rows)  # 整理为可检查表格
exercise_coefficient_delivery = exercise_results[['alpha', '窗口', 'hikvision_return_coef', 'hikvision_return_zero', 'shanghai_airport_return_coef', 'shanghai_airport_return_zero', 'wuxi_apptec_return_coef', 'wuxi_apptec_return_zero']].rename(columns={'hikvision_return_coef': '海康系数', 'hikvision_return_zero': '海康为零', 'shanghai_airport_return_coef': '机场系数', 'shanghai_airport_return_zero': '机场为零', 'wuxi_apptec_return_coef': '药明系数', 'wuxi_apptec_return_zero': '药明为零'})  # 用紧凑列名完成内容逐特征系数与零状态
display(exercise_coefficient_delivery.round(8))  # 输出九个 alpha×窗口的逐特征答案

exercise_summary = exercise_results.groupby('alpha').agg(mean_validation_mse=('验证MSE', 'mean'), worst_validation_mse=('验证MSE', 'max'), mean_zero_baseline_mse=('零收益MSE', 'mean'), all_windows_beat_baseline=('验证MSE', lambda validation_errors: bool((validation_errors.to_numpy() < exercise_results.loc[validation_errors.index, '零收益MSE'].to_numpy()).all())), nonzero_count_min=('非零特征数', 'min'), nonzero_count_max=('非零特征数', 'max')).reset_index()  # 汇总误差、基线和选择稳定性
eligible_exercise_candidates = exercise_summary.query('all_windows_beat_baseline').copy()  # 只保留每窗均胜基线的候选
best_exercise_mse = np.nan if eligible_exercise_candidates.empty else eligible_exercise_candidates['mean_validation_mse'].min()  # 找到完成要求候选的最低平均误差
near_best_exercise_candidates = eligible_exercise_candidates.query('mean_validation_mse <= @best_exercise_mse + 1e-12') if not eligible_exercise_candidates.empty else eligible_exercise_candidates  # 按事先确定容差识别并列候选
frozen_exercise_alpha = None if near_best_exercise_candidates.empty else float(near_best_exercise_candidates['alpha'].min())  # 并列时动态确定较小 alpha
exercise_decision = '保留简单模型' if frozen_exercise_alpha is None else f'确定 alpha={frozen_exercise_alpha:g}'  # 输出暂不采用或确定结论
exercise_summary_delivery = exercise_summary.assign(非零数范围=exercise_summary['nonzero_count_min'].astype(str) + '–' + exercise_summary['nonzero_count_max'].astype(str)).rename(columns={'mean_validation_mse': '平均MSE', 'worst_validation_mse': '最差MSE', 'mean_zero_baseline_mse': '平均零基线', 'all_windows_beat_baseline': '每窗胜基线'})[['alpha', '平均MSE', '最差MSE', '平均零基线', '每窗胜基线', '非零数范围']]  # 用六列紧凑完成内容避免宽表截断
display(exercise_summary_delivery.round(8))  # 展示三项候选的误差、基线与非零数范围
print({'tie_break': '平均MSE在1e-12内并列时取较小alpha', 'decision': exercise_decision})  # 报告事先确定并列规则与动态决策