06 模型验证

# 为“模型复杂度与偏差-方差的关系”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 为“模型复杂度与偏差-方差的关系”导入 `matplotlib.pyplot` 并绑定 `plt`，用于构建当前任务的坐标轴并呈现比较结果。
import matplotlib.pyplot as plt
# 导入 Matplotlib 顶层配置接口并绑定为 `mpl`，用于统一偏差—方差图的中文字体与投影样式。
import matplotlib as mpl

# 设置中文字体
# 注意：这需要在您的环境中安装支持中文的字体，例如 "Source Han Serif SC"
# 如果没有，matplotlib会回退到默认字体，中文可能显示为方框
mpl.rcParams['font.sans-serif'] = ['Source Han Serif SC', 'Noto Serif CJK SC']  # 固定开源中文字体栈并移除专有字体回退
mpl.rcParams['axes.unicode_minus'] = False # 解决负号显示问题



# 建立 `x` 的有序取值网格，用于展示“模型复杂度与偏差-方差权衡”随参数变化的比较结果。
x = np.linspace(0.1, 1, 100)
# 用随复杂度递减的反比曲线表示偏差平方。
bias_sq = 0.8 / (x * 10)
# 用随复杂度递增的直线表示估计方差。
variance = x * 0.4
# 将不可约噪声固定为 0.1，作为总误差曲线的水平下界。
noise = np.full_like(x, 0.1)
# 将偏差平方、方差与不可约噪声相加，得到总误差曲线。
total_error = bias_sq + variance + noise

# 找到总误差曲线的最小值索引，用于标注偏差—方差平衡点。
min_error_idx = np.argmin(total_error)
# 将最小误差索引映射回复杂度横坐标，取得图中最优复杂度位置。
optimal_complexity = x[min_error_idx]

# 创建 `fig, ax` 画布，承载“模型复杂度与偏差-方差权衡”的并排视觉比较。
fig, ax = plt.subplots(figsize=(10, 3.4))
# 以 `x` 为横轴、`bias_sq` 为纵轴绘制曲线，展示“模型复杂度与偏差-方差权衡”。
ax.plot(x, bias_sq, 'r-', label='偏差平方 (Bias²)')
# 以 `x` 为横轴、`variance` 为纵轴绘制曲线，展示“模型复杂度与偏差-方差权衡”。
ax.plot(x, variance, 'b--', label='方差 (Variance)')
# 以 `x` 为横轴、`noise` 为纵轴绘制曲线，展示“模型复杂度与偏差-方差权衡”。
ax.plot(x, noise, 'orange', linestyle=':', label='噪声 (Irreducible Error)')
# 以 `x` 为横轴、`total_error` 为纵轴绘制曲线，展示“模型复杂度与偏差-方差权衡”。
ax.plot(x, total_error, 'k-.', label='总误差 (Total Error)', linewidth=2)
# 在 `optimal_complexity` 处添加垂直参考线，标出“模型复杂度与偏差-方差权衡”的基准或阈值。
ax.axvline(optimal_complexity, color='grey', linestyle='--', label='最佳复杂度')

# 在 `ax` 上填充两条边界之间的区域。
ax.fill_between(x, 0, 1.2, where=x < optimal_complexity, color='lightblue', alpha=0.3, label='欠拟合区域')
# 在 `ax` 上填充两条边界之间的区域。
ax.fill_between(x, 0, 1.2, where=x > optimal_complexity, color='lightcoral', alpha=0.3, label='过拟合区域')

# 将横轴标为“模型复杂度”，明确横向编码的变量。
ax.set_xlabel('模型复杂度', fontsize=16)
# 将纵轴标为“误差”，明确纵向编码的变量。
ax.set_ylabel('误差', fontsize=16)
# 将图题设为“偏差-方差权衡”，直接说明当前图形的比较目的。
ax.set_title('偏差-方差权衡', fontsize=18)
# 显示“模型复杂度与偏差-方差的关系”图例，使颜色或线型与比较对象一一对应。
ax.legend(fontsize=16)
# 为“模型复杂度与偏差-方差的关系”，限定纵轴范围，使比较对象使用一致尺度。
ax.set_ylim(0, 1.2)
# 为“模型复杂度与偏差-方差的关系”，限定横轴范围，使比较对象使用一致尺度。
ax.set_xlim(0, 1)

# 在图中标注“欠拟合 (Underfitting)”，解释“模型复杂度与偏差-方差权衡”的关键位置。
ax.text(optimal_complexity - 0.25, 1.1, '欠拟合\n(Underfitting)', ha='center', fontsize=16)
# 在图中标注“过拟合 (Overfitting)”，解释“模型复杂度与偏差-方差权衡”的关键位置。
ax.text(optimal_complexity + 0.25, 1.1, '过拟合\n(Overfitting)', ha='center', fontsize=16)
# 以 `optimal_complexity` 为横轴、`total_error[min_error_idx]` 为纵轴绘制曲线，展示“模型复杂度与偏差-方差权衡”。
ax.plot(optimal_complexity, total_error[min_error_idx], 'ko', markersize=8)
# 以箭头标注“平衡点”，指出“模型复杂度与偏差-方差权衡”中的候选拐点或阈值。
ax.annotate('平衡点',
            # 把注释箭头锚定在总误差最低的复杂度与误差坐标。
            xy=(optimal_complexity, total_error[min_error_idx]),
            # 将文字置于最低点上方 0.2，避免箭头与误差曲线重叠。
            xytext=(optimal_complexity, total_error[min_error_idx] + 0.2),
            # 指定 `arrowprops` 为注释箭头样式，细化“模型复杂度与偏差-方差权衡”的输出。
            arrowprops=dict(facecolor='black', shrink=0.05),
            # 将标注水平居中并设为 12pt，使文字与最优点对齐。
            ha='center', fontsize=12)

# 显示偏差平方、方差、不可约噪声与总误差曲线，检查总误差最低点两侧的欠拟合和过拟合区域。
plt.show()

# 为“可视化案例：在训练集上的表现”导入 `matplotlib.pyplot` 并绑定 `plt`，用于构建当前任务的坐标轴并呈现比较结果。
import matplotlib.pyplot as plt
# 为“可视化案例：在训练集上的表现”，从 `sklearn.pipeline` 导入`Pipeline` 用于把预处理与估计器串成同一拟合流程。
from sklearn.pipeline import Pipeline
# 为“可视化案例：在训练集上的表现”，从 `sklearn.preprocessing` 导入`PolynomialFeatures` 用于由原始特征展开多项式项。
from sklearn.preprocessing import PolynomialFeatures
# 为“可视化案例：在训练集上的表现”，从 `sklearn.linear_model` 导入`LinearRegression` 用于拟合普通最小二乘线性回归。
from sklearn.linear_model import LinearRegression

# 创建训练集三面板画布，按相同坐标尺度比较一、四、十五阶模型的样本内拟合。
plt.figure(figsize=(14, 5))
# 将图题设为“模型在训练集上的表现”，直接说明当前图形的比较目的。
plt.suptitle('模型在训练集上的表现', fontsize=16)
# 为“可视化案例：在训练集上的表现”，遍历 `i, degree in enumerate(degrees)` 的多项式阶数，比较欠拟合、适度拟合与过拟合。
for i, degree in enumerate(degrees):
    # 把当前多项式阶数放入对应子图，便于横向比较三种复杂度。
    ax = plt.subplot(1, len(degrees), i + 1)
    # 将当前 Matplotlib 元素集合的文字旋转角度与对齐方式设为给定值。
    plt.setp(ax, xticks=(), yticks=())

    # 创建 `PolynomialFeatures` 实例 `polynomial_features`，用于由原始特征展开多项式项。
    polynomial_features = PolynomialFeatures(degree=degree, include_bias=False)
    # 建立线性回归器，用于估计当前多项式基展开后的系数。
    linear_regression = LinearRegression()
    # 将当前阶数的多项式展开与线性回归串联，确保预测复用相同特征映射。
    pipeline = Pipeline([("poly", polynomial_features), ("lr", linear_regression)])
    # 用训练样本估计当前阶数的多项式系数，随后在训练域网格上检查拟合程度。
    pipeline.fit(X_train[:, np.newaxis], y_train)

    # 建立 `X_plot` 的有序取值网格，用于展示“不同复杂度模型在训练集上的表现”随参数变化的比较结果。
    X_plot = np.linspace(0, 1, 100)
    # 用已拟合模型生成预测值。
    plt.plot(X_plot, pipeline.predict(X_plot[:, np.newaxis]), label="模型")
    # 以 `X_train` 为横轴、`y_train` 为纵轴绘制散点，展示“不同复杂度模型在训练集上的表现”。
    plt.scatter(X_train, y_train, edgecolor='b', s=20, label="训练样本")
    # 为“可视化案例：在训练集上的表现”，将横轴标为“x”，明确横向编码的变量。
    plt.xlabel("x")
    # 为“可视化案例：在训练集上的表现”，将纵轴标为“y”，明确纵向编码的变量。
    plt.ylabel("y")
    # 限定横轴显示范围，聚焦教学区间。
    plt.xlim((0, 1))
    # 为“可视化案例：在训练集上的表现”，限定纵轴显示范围，避免比例差异误导比较。
    plt.ylim((-2, 2))
    # 显示“可视化案例：在训练集上的表现”图例，使颜色或线型与比较对象一一对应。
    plt.legend(loc="best")
    # 一次多项式只画直线，作为欠拟合对照。
    if degree == 1:
        # 将图题设为“欠拟合 (d={degree})”，直接说明当前图形的比较目的。
        plt.title(f'欠拟合 (d={degree})')
    # 四次多项式提供适中弯曲度，作为当前机制样本的平衡对照。
    elif degree == 4:
        # 将图题设为“适当拟合 (d={degree})”，直接说明当前图形的比较目的。
        plt.title(f'适当拟合 (d={degree})')
    # 其余高阶情形作为过拟合对照。
    else:
        # 将图题设为“过拟合 (d={degree})”，直接说明当前图形的比较目的。
        plt.title(f'过拟合 (d={degree})')
# 为“可视化案例：在训练集上的表现”，压缩子图留白，避免标题和坐标标签相互遮挡。
plt.tight_layout(rect=[0, 0, 1, 0.95])
# 显示三个阶数在训练样本上的拟合曲线，比较欠拟合与高阶模型追随噪声的程度。
plt.show()

# 创建验证集三面板画布，检查同一批训练模型在未参与拟合的数据上的误差。
plt.figure(figsize=(14, 5))
# 将图题设为“模型在验证集上的表现”，直接说明当前图形的比较目的。
plt.suptitle('模型在验证集上的表现', fontsize=16)
# 为“可视化案例：在验证集上的表现”，遍历 `i, degree in enumerate(degrees)` 的多项式阶数，比较欠拟合、适度拟合与过拟合。
for i, degree in enumerate(degrees):
    # 把当前多项式阶数放入对应子图，便于比较验证期泛化误差。
    ax = plt.subplot(1, len(degrees), i + 1)
    # 将当前 Matplotlib 元素集合的文字旋转角度与对齐方式设为给定值。
    plt.setp(ax, xticks=(), yticks=())

    # 创建 `PolynomialFeatures` 实例 `polynomial_features`，用于由原始特征展开多项式项。
    polynomial_features = PolynomialFeatures(degree=degree, include_bias=False)
    # 建立当前阶数的线性回归器，只从训练样本估计多项式系数。
    linear_regression = LinearRegression()
    # 串联多项式展开与回归器，使验证预测严格复用训练期特征映射和系数。
    pipeline = Pipeline([("poly", polynomial_features), ("lr", linear_regression)])
    # 仅在训练样本上拟合当前阶数模型，验证点不参与参数估计。
    pipeline.fit(X_train[:, np.newaxis], y_train)

    # 建立 `X_plot` 的有序取值网格，用于展示“不同复杂度模型在验证集上的表现”随参数变化的比较结果。
    X_plot = np.linspace(0, 1, 100)
    # 用已拟合模型生成预测值。
    plt.plot(X_plot, pipeline.predict(X_plot[:, np.newaxis]), label="模型")
    # 以 `X_test` 为横轴、`y_test` 为纵轴绘制散点，展示“不同复杂度模型在验证集上的表现”。
    plt.scatter(X_test, y_test, edgecolor='r', s=20, label="验证样本")
    # 为“可视化案例：在验证集上的表现”，将横轴标为“x”，明确横向编码的变量。
    plt.xlabel("x")
    # 为“可视化案例：在验证集上的表现”，将纵轴标为“y”，明确纵向编码的变量。
    plt.ylabel("y")
    # 限定横轴显示范围，聚焦教学区间。
    plt.xlim((0, 1))
    # 为“可视化案例：在验证集上的表现”，限定纵轴显示范围，避免比例差异误导比较。
    plt.ylim((-2, 2))
    # 显示“可视化案例：在验证集上的表现”图例，使颜色或线型与比较对象一一对应。
    plt.legend(loc="best")
    # 一次多项式对应左侧欠拟合面板。
    if degree == 1:
        # 将图题设为“欠拟合 (高误差)”，直接说明当前图形的比较目的。
        plt.title(f'欠拟合 (高误差)')
    # 四次多项式对应中间的适度复杂度面板。
    elif degree == 4:
        # 将图题设为“适当拟合 (低误差)”，直接说明当前图形的比较目的。
        plt.title(f'适当拟合 (低误差)')
    # 其余高阶模型对应右侧过拟合面板。
    else:
        # 将图题设为“过拟合 (高误差)”，直接说明当前图形的比较目的。
        plt.title(f'过拟合 (高误差)')
# 为“可视化案例：在验证集上的表现”，压缩子图留白，避免标题和坐标标签相互遮挡。
plt.tight_layout(rect=[0, 0, 1, 0.95])
# 显示训练拟合曲线与独立验证点，检查高阶模型的训练优势是否转化为验证表现。
plt.show()

# 为“步骤1: 导入库并创建模拟数据”导入 `pandas` 并绑定 `pd`，用于整理当前任务的表格、字段与时间索引。
import pandas as pd
# 为“步骤1: 导入库并创建模拟数据”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 为“步骤1: 导入库并创建模拟数据”，导入 `StandardScaler`，供每个交叉验证训练折按特征列估计均值与尺度。
from sklearn.preprocessing import StandardScaler
# 为“步骤1: 导入库并创建模拟数据”，从 `sklearn.linear_model` 导入`LinearRegression` 用于拟合普通最小二乘线性回归。
from sklearn.linear_model import LinearRegression
# 为“步骤1: 导入库并创建模拟数据”，从 `sklearn.metrics` 导入`mean_squared_error` 用于计算真实值与预测值的均方误差。
from sklearn.metrics import mean_squared_error

# 为了示例的可重复性，我们在这里创建模拟数据
# 设定种子以确保结果可复现
np.random.seed(42)
# 将机制演示的训练样本数固定为 100，控制训练期覆盖范围。
train_size = 100
# 将后段验证样本数固定为 50，保留独立于训练期的时间区间。
test_size = 50

# 假设的真实关系: eps_basic ~ 2*log(pps) + 3*bm - 1*roa + noise

# 创建训练数据
training_data = pd.DataFrame({
    # 生成训练期证券编号，保留面板标识字段。
    'stkcd': np.random.randint(1, 1000, train_size),
    # 生成从 2010 年起的训练期月末时间索引。
    'date': pd.to_datetime(pd.date_range(start='2010-01-01', periods=train_size, freq='M')),
    # 生成训练期每股股价占位特征，用于划分机制演示。
    'pps': np.random.uniform(5, 50, train_size),
    # 生成训练期账面市值比占位特征。
    'bm': np.random.uniform(0.2, 2, train_size),
    # 生成训练期资产收益率占位特征。
    'roa': np.random.uniform(0.01, 0.1, train_size)
# 完成 `training_data` 的字段定义，形成较早时期的训练面板。
})
# 按对数股价、账面市值比与 ROA 的设定关系生成训练期 EPS。
training_data['eps_basic'] = (2 * np.log(training_data['pps']) +
                              # 加入 3 倍账面市值比项，构造训练期 EPS 的正向价值效应。
                              3 * training_data['bm'] -
                              # 减去 1 倍资产收益率项，保持本段既定的教学生成公式。
                              1 * training_data['roa'] +
                              np.random.normal(0, 0.5, train_size)) # 训练集噪声较小

# 创建时间更晚的验证数据
validation_data = pd.DataFrame({
    # 生成验证期证券编号，保持与训练表相同字段结构。
    'stkcd': np.random.randint(1, 1000, test_size),
    # 生成从 2018 年起的后段月末时间索引。
    'date': pd.to_datetime(pd.date_range(start='2018-01-01', periods=test_size, freq='M')),
    # 生成验证期每股股价占位特征。
    'pps': np.random.uniform(5, 50, test_size),
    # 生成验证期账面市值比占位特征。
    'bm': np.random.uniform(0.2, 2, test_size),
    # 生成验证期资产收益率占位特征。
    'roa': np.random.uniform(0.01, 0.1, test_size)
# 完成 `validation_data` 的字段定义，形成时间上晚于训练期的验证面板。
})
# 沿用相同信号关系并放大噪声，生成后段验证期 EPS。
validation_data['eps_basic'] = (2 * np.log(validation_data['pps']) +
                                # 沿用训练期的 3 倍账面市值比项，使前后时期共享同一信号机制。
                                3 * validation_data['bm'] -
                                # 沿用负向资产收益率项，只让验证期噪声结构发生变化。
                                1 * validation_data['roa'] +
                                np.random.normal(0, 1.5, test_size)) # 验证窗噪声更大，仅演示分布变化

# 报告前段训练表与后段验证表已经构造完毕。
print("模拟数据创建完成。")

# 删除不需要的列
training_data_clean = training_data.drop(columns=['date', 'stkcd'])
# 从验证表移除日期与证券代码，只保留与训练模型一致的数值字段。
validation_data_clean = validation_data.drop(columns=['date', 'stkcd'])

# 训练集分割
X_train = training_data_clean.drop('eps_basic', axis=1)
# 从训练表提取 EPS 作为回归目标。
y_train = training_data_clean['eps_basic']

# 验证集分割
X_validation = validation_data_clean.drop('eps_basic', axis=1)
# 提取验证期 EPS 目标列，保持与训练目标相同的单位和行索引。
y_validation = validation_data_clean['eps_basic']

# 标出训练特征矩阵的维度检查结果。
print('--- 训练特征维度 ---')
# 输出训练特征矩阵形状，核对样本数和三项预测变量。
print(X_train.shape)
# 标出验证特征矩阵的维度检查结果。
print('\n--- 验证特征维度 ---')
# 输出验证特征矩阵形状，确认字段数与训练矩阵一致。
print(X_validation.shape)

# 创建只由训练样本逐特征估计统计量的 StandardScaler。
scaler_X = StandardScaler()

# 在训练样本上逐特征估计均值与标准差并完成转换。
X_train_scaled = scaler_X.fit_transform(X_train)

# 使用确定的训练样本逐特征均值与标准差转换验证数据。
X_validation_scaled = scaler_X.transform(X_validation)

# 报告标准化器只在训练期拟合，验证期仅复用训练参数。
print("特征标准化完成，且未发生数据泄露。")

# 创建并训练模型
ols_model = LinearRegression()
# 用标准化训练期特征估计 OLS 系数，验证期仅用于一次样本外误差评估。
ols_model.fit(X_train_scaled, y_train)

# 在训练集上进行预测和评估
train_predictions = ols_model.predict(X_train_scaled)
# 计算 `train_mse`（均方误差），量化“步骤4: 模型训练与评估”的模型表现。
train_mse = mean_squared_error(y_train, train_predictions)
train_rmse = np.sqrt(train_mse) # 计算RMSE

# 在验证集上进行预测和评估
validation_predictions = ols_model.predict(X_validation_scaled)
# 计算 `validation_mse`（均方误差），量化“步骤4: 模型训练与评估”的模型表现。
validation_mse = mean_squared_error(y_validation, validation_predictions)
validation_rmse = np.sqrt(validation_mse) # 计算RMSE

# 报告“训练集 RMSE: {train_rmse:.4f}”中的 `train_rmse`，评价“步骤4: 模型训练与评估”的模型表现。
print(f'训练集 RMSE: {train_rmse:.4f}')
# 报告“验证集 RMSE: {validation_rmse:.4f}”中的 `validation_rmse`，评价“步骤4: 模型训练与评估”的模型表现。
print(f'验证集 RMSE: {validation_rmse:.4f}')

if validation_rmse > train_rmse * 1.5: # 一个简单的课堂诊断规则
    # 当验证 RMSE 超过训练 RMSE 的 1.5 倍时，报告描述性经验信号并保留多种解释。
    print('\n结论: 验证 RMSE 超过训练 RMSE 的 1.5 倍经验阈值；可能来自过拟合或分布变化，这不是统计显著性检验。')
# 当验证 RMSE 未超过训练 RMSE 的 1.5 倍时，不触发本页的描述性经验阈值。
else:
    # 当经验阈值未触发时，仅报告误差接近，并保留最终测试集验证要求。
    print('\n结论: 模型在训练集和验证集上表现接近；仍须用最终测试集作一次最终评估。')

# 为“步骤1: 导入库并创建模拟数据”导入 `pandas` 并绑定 `pd`，用于整理当前任务的表格、字段与时间索引。
import pandas as pd
# 为“步骤1: 导入库并创建模拟数据”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 为“步骤1: 导入库并创建模拟数据”导入 `matplotlib.pyplot` 并绑定 `plt`，用于构建当前任务的坐标轴并呈现比较结果。
import matplotlib.pyplot as plt
# 为“步骤1: 导入库并创建模拟数据”，从 `sklearn.impute` 导入`SimpleImputer` 用于按指定统计量填补缺失值。
from sklearn.impute import SimpleImputer
# 为“步骤1: 导入库并创建模拟数据”，导入 `StandardScaler`，把缩放统计量限制在每个训练折内按特征列估计。
from sklearn.preprocessing import StandardScaler
# 为“步骤1: 导入库并创建模拟数据”，从 `sklearn.linear_model` 导入`LogisticRegression` 用于拟合逻辑回归分类器。
from sklearn.linear_model import LogisticRegression
# 为“步骤1: 导入库并创建模拟数据”，从 `sklearn.model_selection` 导入`StratifiedKFold` 用于调用 `StratifiedKFold` 的专用接口。
from sklearn.model_selection import StratifiedKFold
# 为“步骤1: 导入库并创建模拟数据”，从 `sklearn.metrics` 导入`roc_auc_score` 用于计算分类得分的 ROC AUC，`roc_curve` 用于计算不同分类阈值下的 ROC 坐标。
from sklearn.metrics import roc_auc_score, roc_curve

# 为“步骤1: 导入库并创建模拟数据”，创建模拟数据
np.random.seed(123)
# 将分类机制演示规模固定为 500 条贷款记录。
data_size = 500
# 建立 500 条贷款机制记录的表格，集中保存工龄、收入、负债率和标签生成字段。
data = pd.DataFrame({
    # 生成带约 10% 缺失的就业年限特征。
    'employmentYear': np.random.randint(1, 10, data_size) + np.random.choice([np.nan, 0], size=data_size, p=[0.1, 0.9]),
    # 生成右偏且带约 10% 缺失的年收入特征。
    'annualIncome': np.random.lognormal(11, 0.5, data_size) + np.random.choice([np.nan, 0], size=data_size, p=[0.1, 0.9]),
    # 生成带约 10% 缺失的债务收入比特征。
    'dti': np.random.uniform(5, 35, data_size) + np.random.choice([np.nan, 0], size=data_size, p=[0.1, 0.9])
# 完成 `data` 的三个贷款特征字段，随后按同一观测顺序生成违约标签。
})
# 创建一个不平衡的目标变量 (约20%违约率)
noise = np.random.normal(0, 5, data_size)
# 按三项贷款特征与噪声构造潜在风险分数，仅用于生成不平衡分类标签。
y_score = 0.5*data['employmentYear'] - 0.0001*data['annualIncome'] + 0.1*data['dti'] + noise
# 固定 `data['isDefault']` 的业务取值与顺序，作为“步骤1: 导入库并创建模拟数据”的可复算输入。
data['isDefault'] = (y_score > np.percentile(np.nan_to_num(y_score), 80)).astype(int)

# 为“步骤1: 导入库并创建模拟数据”，定义特征和目标
X = data.drop('isDefault', axis=1).values
# 提取不平衡违约标签作为分层交叉验证目标。
y = data['isDefault'].values

# 报告贷款特征中的缺失值与少数违约类已按练习设定生成。
print("模拟数据创建完成，包含缺失值和不平衡类别。")
# 输出生成标签的正类比例，检查约 20% 的不平衡设定是否成立。
print(f"违约样本比例: {np.mean(y):.2%}")

# 初始化逻辑回归模型
logreg = LogisticRegression(solver='liblinear', random_state=42)

# 初始化分层K折交叉验证
# n_splits=5: 分成5折
# shuffle=True: 在分割前打乱数据
# random_state=42: 确保每次运行的随机分割都一样，便于结果复现
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# 创建 `fig, ax` 画布，承载“5折交叉验证的ROC曲线”的并排视觉比较。
fig, ax = plt.subplots(figsize=(10, 8))
# 初始化跨折 AUC 累积器；此时尚未产生任何评价分数。
aucs = []

# 交叉验证循环
line_styles = ['-', '--', '-.', ':', (0, (5, 2, 1, 2))]
for i, (train_index, test_index) in enumerate(cv.split(X, y)):
    # 按当前随机分层折索引切出训练子集与验证子集，保持两类标签比例近似一致。
    X_train, X_test = X[train_index], X[test_index]
    # 按当前折索引同步提取训练与验证标签，保持与特征行一一对应。
    y_train, y_test = y[train_index], y[test_index]

    # 在当前训练折内建立中位数填补器，避免验证信息进入缺失值统计量。
    imputer = SimpleImputer(strategy='median')
    # 提取 `X_train_imputed` 的插补结果，用于与原始非缺失分布和离散程度比较。
    X_train_imputed = imputer.fit_transform(X_train)
    # 沿用训练期已拟合的转换器生成 `X_test_imputed`，保持训练与评估口径一致。
    X_test_imputed = imputer.transform(X_test)

    # 为当前训练折建立缩放器，随后仅由该折样本按特征列估计均值与尺度。
    scaler = StandardScaler()
    # 在当前交叉验证训练折逐特征估计均值与标准差并转换该折训练特征。
    X_train_scaled = scaler.fit_transform(X_train_imputed)
    # 用当前训练折确定的逐特征统计量转换该折验证特征。
    X_test_scaled = scaler.transform(X_test_imputed)

    # 用当前折已缩放训练数据估计逻辑回归系数，验证段不参与拟合。
    logreg.fit(X_train_scaled, y_train)

    # 生成当前验证折正类概率，供 ROC 曲线和 AUC 计算。
    y_test_proba = logreg.predict_proba(X_test_scaled)[:, 1]

    # 由当前随机分层验证折的标签和概率计算 ROC 坐标，记录该折的排序表现。
    fpr, tpr, _ = roc_curve(y_test, y_test_proba)
    # 计算本折测试概率对应的 ROC AUC 标量，供跨折汇总排序能力。
    auc = roc_auc_score(y_test, y_test_proba)
    # 把本折 AUC `auc` 加入 `aucs`，用于汇总交叉验证的均值和离散度。
    aucs.append(auc)

    # 以 `fpr` 为横轴、`tpr` 为纵轴绘制曲线，展示“5折交叉验证的ROC曲线”。
    ax.plot(fpr, tpr, linewidth=2.2, linestyle=line_styles[i], label=f'第 {i+1} 折（AUC={auc:.3f}）')

# 美化图形
ax.plot([0, 1], [0, 1], color='navy', linestyle='--', label='随机猜测')
# 计算 `mean_auc`（曲线下面积），量化“步骤3: 执行交叉验证循环并绘图”的模型表现。
mean_auc = np.mean(aucs)
# 用图题概括“步骤3: 执行交叉验证循环并绘图”的比较对象与当前计算结果。
ax.set_title(f'k折交叉验证的ROC曲线 (平均AUC = {mean_auc:.3f})', fontsize=16)
# 将横轴标为“假正例率 (FPR)”，明确横向编码的变量。
ax.set_xlabel('假正例率 (FPR)', fontsize=14)
# 将纵轴标为“真正例率 (TPR)”，明确纵向编码的变量。
ax.set_ylabel('真正例率 (TPR)', fontsize=14)
# 显示“步骤3: 执行交叉验证循环并绘图”图例，使颜色或线型与比较对象一一对应。
ax.legend(loc='lower right', fontsize=11)
# 为“步骤3: 执行交叉验证循环并绘图”添加辅助网格，便于比较位置、斜率或组间差异。
plt.grid(True)
# 显示五个随机分层验证折的 ROC 曲线、各折 AUC 与对角随机基线，检查排序表现的折间差异。
plt.show()

from pathlib import Path  # 指向固定沪深300指数数据版本
from urllib.request import urlretrieve  # 复用本章隐藏设置单元安装的浏览器标识下载器
import numpy as np  # 计算收益率与基线预测
import pandas as pd  # 读取并整理时间序列特征
exercise_seed = 42  # 固定所有可能使用随机初始化的步骤
np.random.seed(exercise_seed)  # 统一 NumPy 随机状态以便复算
# 按 Linux 共享数据、Windows 共享数据、项目缓存的顺序选择指数行情文件。
exercise_index_path = next((candidate_path for candidate_path in [Path('/home/ubuntu/r2_data_mount/data/index/hs300_index_only.h5'), Path('C:/qiufei/data/index/hs300_index_only.h5'), Path('data/course/hs300_index_only.h5')] if candidate_path.exists()), Path('data/course/hs300_index_only.h5'))
if not exercise_index_path.exists():
    exercise_index_path.parent.mkdir(parents=True, exist_ok=True)
    urlretrieve('https://assets.qiufei.site/data/index/hs300_index_only.h5', exercise_index_path)
exercise_index = pd.read_hdf(exercise_index_path, key='hs300')[['datetime', 'close']].copy()  # 只读取日期与收盘价字段
exercise_index['date'] = pd.to_datetime(exercise_index['datetime'], format='%Y%m%d%H%M%S')  # 解析交易时间戳
exercise_index = exercise_index.sort_values('date').query("'2018-01-01' <= date <= '2024-12-31'").copy()  # 确定样本期并保持时间顺序
exercise_index['daily_return'] = exercise_index['close'].pct_change()  # 由连续交易日收盘价计算日收益率
for lag_day in range(1, 6):  # 只使用预测时点之前五个交易日的信息
    exercise_index[f'return_lag_{lag_day}'] = exercise_index['daily_return'].shift(lag_day)  # 构造具名滞后收益特征
exercise_index['target_date'] = exercise_index['date'].shift(-1)  # 保留下一交易日标签的实际实现日期
exercise_index['next_return'] = exercise_index['daily_return'].shift(-1)  # 将目标实现日的收益设为回归目标
exercise_index['next_up'] = (exercise_index['next_return'] > 0).astype(int)  # 将下一交易日正收益设为分类标签
exercise_feature_names = [f'return_lag_{lag_day}' for lag_day in range(1, 6)]  # 固定五项特征及其顺序
exercise_panel = exercise_index.dropna(subset=exercise_feature_names + ['target_date', 'next_return']).copy()  # 删除滞后和前移产生的边界缺失

from sklearn.linear_model import LinearRegression  # 建立可解释的线性回归基准
from sklearn.metrics import mean_squared_error  # 计算逐折均方根误差
from sklearn.model_selection import TimeSeriesSplit  # 保证每折训练早于验证
from sklearn.pipeline import make_pipeline  # 将缩放与回归绑定在折内
from sklearn.preprocessing import StandardScaler  # 仅用每折训练样本逐特征估计均值与标准差
regression_panel = exercise_panel.query("target_date <= '2023-12-31'").copy()  # 按目标实现日最终测试 2024 年标签
regression_splitter = TimeSeriesSplit(n_splits=5, gap=1)  # 在训练与验证之间清除一行相邻标签重叠
regression_records = []  # 收集模型和训练均值基线的逐折结果
for fold_number, (training_rows, validation_rows) in enumerate(regression_splitter.split(regression_panel), start=1):  # 按时间顺序遍历五折
    assert regression_panel.iloc[training_rows]['target_date'].max() < regression_panel.iloc[validation_rows]['date'].min()  # 保证训练标签在首个验证特征日前已实现
    regression_model = make_pipeline(StandardScaler(), LinearRegression())  # 每折只由训练段逐特征估计缩放统计量并拟合模型
    regression_model.fit(regression_panel.iloc[training_rows][exercise_feature_names], regression_panel.iloc[training_rows]['next_return'])  # 只用该折较早样本估计参数
    regression_predictions = regression_model.predict(regression_panel.iloc[validation_rows][exercise_feature_names])  # 预测紧随训练段之后的验证窗口
    regression_baseline = np.repeat(regression_panel.iloc[training_rows]['next_return'].mean(), len(validation_rows))  # 用训练期均值建立朴素预测
    regression_records.append({'fold': fold_number, 'model_rmse': mean_squared_error(regression_panel.iloc[validation_rows]['next_return'], regression_predictions) ** 0.5, 'baseline_rmse': mean_squared_error(regression_panel.iloc[validation_rows]['next_return'], regression_baseline) ** 0.5})  # 保存同一验证窗的可比 RMSE
regression_results = pd.DataFrame(regression_records)  # 整理五折输出
display(regression_results.round(6))  # 展示每折模型与基线误差
print({'模型RMSE均值': regression_results['model_rmse'].mean(), '模型RMSE标准差': regression_results['model_rmse'].std(ddof=1), '基线RMSE均值': regression_results['baseline_rmse'].mean()})  # 汇总跨折稳定性与基线

from sklearn.linear_model import LogisticRegression  # 建立固定随机种子的方向分类器
from sklearn.metrics import accuracy_score, confusion_matrix, precision_score, recall_score  # 计算分类任务完整指标
classification_training = exercise_panel.query("target_date <= '2022-12-31'").copy()  # 只让不晚于 2022 年末实现的标签进入训练
classification_validation = exercise_panel.query("'2023-01-01' <= target_date <= '2023-12-31'").copy()  # 按目标实现日分配 2023 验证样本
classification_test = exercise_panel.query("'2024-01-01' <= target_date <= '2024-12-31'").copy()  # 按目标实现日最终测试 2024 测试样本
assert len(classification_training) > 0 and len(classification_validation) > 0 and len(classification_test) > 0, '分类训练、验证或最终测试窗口为空'  # 先阻止空窗口真空通过日期断言
assert classification_training['next_up'].nunique() == 2 and classification_test['next_up'].nunique() == 2, '分类训练或最终测试期缺少一个方向类别'  # 保证模型拟合与混淆指标可定义
assert classification_training['target_date'].max() <= pd.Timestamp('2022-12-31')  # 检查训练标签的信息截止日
assert classification_validation['target_date'].between('2023-01-01', '2023-12-31').all()  # 检查验证标签只在 2023 年实现
assert classification_test['target_date'].between('2024-01-01', '2024-12-31').all()  # 检查测试标签只在 2024 年实现
classification_model = make_pipeline(StandardScaler(), LogisticRegression(random_state=exercise_seed, max_iter=1000))  # 只由分类训练窗逐特征估计缩放统计量并固定优化初始状态
classification_model.fit(classification_training[exercise_feature_names], classification_training['next_up'])  # 只用 2022 年末以前标签拟合
validation_predictions = (classification_model.predict_proba(classification_validation[exercise_feature_names])[:, 1] >= 0.5).astype(int)  # 在验证年核对预先固定的 0.5 阈值
test_predictions = (classification_model.predict_proba(classification_test[exercise_feature_names])[:, 1] >= 0.5).astype(int)  # 确定流程后仅评估一次 2024 年
majority_label = int(classification_training['next_up'].mean() >= 0.5)  # 只用训练期确定多数类
majority_predictions = np.repeat(majority_label, len(classification_test))  # 在同一测试样本上形成多数类基线
true_negative, false_positive, false_negative, true_positive = confusion_matrix(classification_test['next_up'], test_predictions, labels=[0, 1]).ravel()  # 展开标准二分类混淆计数
classification_summary = pd.DataFrame([{'validation_accuracy': accuracy_score(classification_validation['next_up'], validation_predictions), 'tn': true_negative, 'fp': false_positive, 'fn': false_negative, 'tp': true_positive, 'precision': precision_score(classification_test['next_up'], test_predictions, zero_division=0), 'recall': recall_score(classification_test['next_up'], test_predictions, zero_division=0), 'test_accuracy': accuracy_score(classification_test['next_up'], test_predictions), 'majority_accuracy': accuracy_score(classification_test['next_up'], majority_predictions)}])  # 汇总验证与最终测试指标
display(classification_summary.round(4))  # 展示可自查的混淆结果、分类指标与基线

from pathlib import Path  # 管理公开沪深300指数路径
from urllib.request import urlretrieve  # 复用本章已安装的浏览器标识下载器
import numpy as np  # 构造训练期均值预测
import pandas as pd  # 读取并按日期排列指数行情
from sklearn.metrics import mean_squared_error  # 评估下一期收益基线
from sklearn.model_selection import TimeSeriesSplit  # 建立不打乱时间的扩展窗口
# 按 Linux 共享数据、Windows 共享数据、项目缓存的顺序选择指数行情文件。
index_path = next((candidate_path for candidate_path in [Path('/home/ubuntu/r2_data_mount/data/index/hs300_index_only.h5'), Path('C:/qiufei/data/index/hs300_index_only.h5'), Path('data/course/hs300_index_only.h5')] if candidate_path.exists()), Path('data/course/hs300_index_only.h5'))
if not index_path.exists():
    index_path.parent.mkdir(parents=True, exist_ok=True)
    urlretrieve('https://assets.qiufei.site/data/index/hs300_index_only.h5', index_path)
index_data = pd.read_hdf(index_path, key='hs300')[['datetime', 'close']].copy()  # 读取日期与收盘价最小字段
index_data['date'] = pd.to_datetime(index_data['datetime'], format='%Y%m%d%H%M%S')  # 解析交易日期
index_data = index_data.sort_values('date').query("date <= '2025-12-31'").copy()  # 确定样本截止日并保持时间顺序
index_returns = index_data['close'].pct_change().dropna().to_numpy()  # 计算不复权指数日收益
splitter = TimeSeriesSplit(n_splits=3)  # 确定三个扩展窗口
fold_records = []  # 收集逐窗样本数量变化与基线误差
for fold_number, (training_index, validation_index) in enumerate(splitter.split(index_returns), start=1):  # 逐窗保证训练早于验证
    baseline_predictions = np.repeat(index_returns[training_index].mean(), len(validation_index))  # 仅用训练期均值预测验证收益
    fold_records.append({'fold': fold_number, 'train_n': len(training_index), 'valid_n': len(validation_index), 'mse': mean_squared_error(index_returns[validation_index], baseline_predictions)})  # 保存无泄漏基线结果
print({'文件': index_path.name, '键': 'hs300', '样本截止': '2025-12-31'})  # 输出数据版本边界
display(pd.DataFrame(fold_records))  # 展示全部扩展窗口而非随机切分