10 神经网络：金融大数据学习

import numpy as np  # 生成激活函数网格并计算对应数值

# 生成 Sigmoid 与 ReLU 的同尺度 SVG 曲线，供本章比较饱和区与分段线性响应。
def generate_activations_svg():
    # 建立 `z` 的有序取值网格，用于展示“Sigmoid 与 ReLU 激活函数的可视化比较”随参数变化的比较结果。
    z = np.linspace(-6, 6, 300)
    # 把线性得分映射为 `sigmoid` 概率曲线，展示 Sigmoid 的区间压缩作用。
    sigmoid = 1 / (1 + np.exp(-z))
    # 将负输入截断为零得到 ReLU 曲线，与平滑 Sigmoid 并排比较。
    relu = np.maximum(0, z)

    # 将数据点坐标转换为 SVG 路径字符串
    # 把连续坐标编码为 SVG 路径 `sigmoid_path`，用于绘制“Sigmoid 与 ReLU 激活函数的可视化比较”的曲线。
    sigmoid_path = "M " + " ".join([f"{80+(x+6)/12*280},{250-y*180}" for x, y in zip(z, sigmoid)])
    # 把连续坐标编码为 SVG 路径 `relu_path`，用于绘制“Sigmoid 与 ReLU 激活函数的可视化比较”的曲线。
    relu_path = "M " + " ".join([f"{440+(x+6)/12*280},{250-np.clip(y,0,6)/6*180}" for x, y in zip(z, relu)])

    # 把两条激活函数路径嵌入完整 SVG 字符串，交给浏览器渲染。
    svg = f'''
    <svg viewBox="0 0 800 320" style="max-width: 100%; height: auto;">

      <title>Sigmoid 与 ReLU 激活函数</title>
      <desc>Sigmoid函数呈S形，将值压缩到0和1之间。ReLU函数在输入小于0时为0，大于0时呈线性增长。</desc>
  <g id="bf10-activations">
      <style>
        #bf10-activations .axis {{ stroke: #3c4043; stroke-width: 2; }}
        #bf10-activations .grid {{ stroke: #e0e0e0; stroke-width: 1; stroke-dasharray: 4,4; }}
        #bf10-activations .label {{ font-family: "Source Han Serif SC", "Noto Serif CJK SC", serif; font-size: 20px; text-anchor: middle; fill: #3c4043; }}
        #bf10-activations .title {{ font-size: 20px; font-weight: bold; }}
        #bf10-activations .sigmoid-line {{ stroke: #4285F4; stroke-width: 3.5; fill: none; }}
        #bf10-activations .relu-line {{ stroke: #EA4335; stroke-width: 3.5; fill: none; }}
      </style>

      <text x="220" y="38" class="label title">Sigmoid：两端饱和</text><text x="580" y="38" class="label title">ReLU：正半轴不饱和</text>
      <line x1="80" y1="250" x2="360" y2="250" class="axis"/><line x1="220" y1="70" x2="220" y2="270" class="axis"/>
      <line x1="440" y1="250" x2="720" y2="250" class="axis"/><line x1="580" y1="70" x2="580" y2="270" class="axis"/>
      <text x="365" y="270" class="label">z</text><text x="725" y="270" class="label">z</text>

      <!-- Curves -->
      <path d="{sigmoid_path}" class="sigmoid-line"/>
      <path d="{relu_path}" class="relu-line"/>

  </g>
</svg>
    '''
    # 返回 `svg`，把“激活函数可视化比较”的计算结果交给调用方。
    return svg

from IPython.display import HTML, display  # 让 Jupyter 将字符串解析为内联 HTML/SVG DOM
display(HTML(generate_activations_svg()))  # 在成品中显示真实 SVG DOM 而非原始 HTML 文本

import numpy as np  # 生成一维参数网格并计算非凸代价

# 生成含两个局部极小值的非凸损失 SVG，解释初始化为何可能落入不同盆地。
def generate_nonconvex_svg():
    # 建立 `x` 的有序取值网格，用于展示“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”随参数变化的比较结果。
    x = np.linspace(-4.5, 3.5, 200)
    # 在参数网格上计算四次非凸代价 `y`，形成含两个局部谷底的曲线。
    y = 0.1*x**4 + 0.2*x**3 - 2*x**2 - 2*x + 10

    # 把数值缩放到 SVG 视图框坐标
    # 将数值映射为画布坐标 `x_svg`，使“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”按统一尺度绘制。
    x_svg = (x + 4.5) / 8 * 600 + 100
    # 将数值映射为画布坐标 `y_svg`，使“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”按统一尺度绘制。
    y_svg = 280 - (y - np.min(y)) / (np.max(y) - np.min(y)) * 220

    # 把连续坐标编码为 SVG 路径 `path_data`，用于绘制“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”的曲线。
    path_data = "M " + " ".join([f"{px:.2f},{py:.2f}" for px, py in zip(x_svg, y_svg)])

    # 计算两个局部极小值点
    # 在 x=-3.2 处代入非凸函数，取得左侧局部极小值坐标。
    min1_x, min1_y = -3.2, 0.1*(-3.2)**4 + 0.2*(-3.2)**3 - 2*(-3.2)**2 - 2*(-3.2) + 10
    # 在 x=2.0 处代入同一函数，取得右侧局部极小值坐标。
    min2_x, min2_y = 2.0, 0.1*(2.0)**4 + 0.2*(2.0)**3 - 2*(2.0)**2 - 2*(2.0) + 10

    # 将数值映射为画布坐标 `min1_x_svg`，使“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”按统一尺度绘制。
    min1_x_svg = (-3.2 + 4.5) / 8 * 600 + 100
    # 将数值映射为画布坐标 `min1_y_svg`，使“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”按统一尺度绘制。
    min1_y_svg = 280 - (min1_y - np.min(y)) / (np.max(y) - np.min(y)) * 220
    # 将数值映射为画布坐标 `min2_x_svg`，使“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”按统一尺度绘制。
    min2_x_svg = (2.0 + 4.5) / 8 * 600 + 100
    # 将数值映射为画布坐标 `min2_y_svg`，使“神经网络代价函数是一个复杂的非凸函数，存在多个局部最小值。”按统一尺度绘制。
    min2_y_svg = 280 - (min2_y - np.min(y)) / (np.max(y) - np.min(y)) * 220

    # 把非凸损失曲线与两个局部极小值坐标写入完整 SVG。
    svg = f'''
    <svg viewBox="0 0 800 320" style="max-width: 100%; height: auto;">

      <title>非凸代价函数</title>
      <desc>一条具有多个局部最小值的曲线，说明了优化问题的复杂性。</desc>
  <g id="bf10-nonconvex">
      <style>
        #bf10-nonconvex .curve {{ fill: none; stroke: #4285F4; stroke-width: 3.5; }}
        #bf10-nonconvex .axis {{ stroke: #3c4043; stroke-width: 2; }}
        #bf10-nonconvex .label {{ font-family: "Source Han Serif SC", "Noto Serif CJK SC", serif; font-size: 20px; text-anchor: middle; fill: #3c4043; }}
        #bf10-nonconvex .title {{ font-size: 20px; font-weight: bold; }}
        #bf10-nonconvex .min-point {{ fill: #EA4335; }}
        #bf10-nonconvex .min-label {{ fill: #c0392b; font-size: 20px; }}
        #bf10-nonconvex .global-min-label {{ fill: #16713A; font-weight: bold; }}
      </style>

      <text x="400" y="40" class="label title">非凸代价函数的地形</text>
      <!-- Axes -->
      <line x1="80" y1="280" x2="720" y2="280" class="axis" />
      <line x1="80" y1="50" x2="80" y2="280" class="axis" />
      <text x="400" y="305" class="label">参数值 (例如某个 w)</text>
      <text x="50" y="165" transform="rotate(-90, 50, 165)" class="label">代价 J(w)</text>

      <!-- Curve -->
      <path d="{path_data}" class="curve"/>

      <!-- Minima -->
      <circle cx="{min1_x_svg}" cy="{min1_y_svg}" r="7" class="min-point"/>
      <text x="{min1_x_svg}" y="{min1_y_svg + 25}" class="label min-label">局部最小值</text>
      <circle cx="{min2_x_svg}" cy="{min2_y_svg}" r="7" class="min-point"/>
      <text x="{min2_x_svg}" y="{min2_y_svg + 25}" class="label min-label">局部最小值</text>

      <text x="{min2_x_svg}" y="{min2_y_svg - 20}" class="label global-min-label">全局最小值</text>
      <path d="M {min2_x_svg} {min2_y_svg - 15} L {min2_x_svg} {min2_y_svg-5}" stroke="#16713A" stroke-width="2"/>
  </g>
</svg>
    '''
    # 返回 `svg`，把“如何寻找最优参数？”的计算结果交给调用方。
    return svg

display(HTML(generate_nonconvex_svg()))  # 将非凸损失曲线作为内联 SVG DOM 输出

# 为“Step 1：读取公开指数数据”导入 `pandas` 并绑定 `pd`，用于整理当前任务的表格、字段与时间索引。
import pandas as pd
# 为“Step 1：读取公开指数数据”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
from pathlib import Path  # 管理下载后的课程数据路径
from urllib.request import urlretrieve  # 复用本章隐藏设置单元安装的浏览器标识下载器

# 按 Linux 共享数据、Windows 共享数据、项目缓存的顺序选择指数行情文件。
index_data_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_data_path.exists():
    index_data_path.parent.mkdir(parents=True, exist_ok=True)
    urlretrieve('https://assets.qiufei.site/data/index/hs300_index_only.h5', index_data_path)
raw_df = pd.read_hdf(index_data_path, key='hs300')[['datetime', 'close', 'high', 'low', 'total_turnover']]  # 只保留建模字段
raw_df['date'] = pd.to_datetime(raw_df['datetime'].astype(str), format='%Y%m%d%H%M%S')  # 将交易时间转换为可排序日期
raw_df = raw_df.sort_values('date').set_index('date')  # 按真实交易顺序建立时间索引
print(raw_df.head())  # 核对公开数据版本的字段与时间顺序

df_model = raw_df.copy()  # 保留原始数据版本以便检查特征构造
df_model['market_return'] = df_model['close'].pct_change()  # 计算 t 日收盘收益率
df_model['intraday_range'] = (df_model['high'] - df_model['low']) / df_model['close']  # 度量 t 日振幅
df_model['turnover_change'] = df_model['total_turnover'].pct_change()  # 度量 t 日成交额变化
df_model['next_return'] = df_model['market_return'].shift(-1)  # 将 t+1 日收益设为预测目标
df_model = df_model.replace([np.inf, -np.inf], np.nan).dropna()  # 删除比率计算产生的无效观测
feature_names = ['market_return', 'intraday_range', 'turnover_change']  # 固定可检查的特征顺序
X = df_model[feature_names]  # 构建特征矩阵
y = df_model['next_return']  # 构建下一交易日目标
print(X.head())  # 核对预测时点可得特征
print(y.head())  # 核对目标与特征错开一日

development_end = int(len(X) * 0.8)  # 确定开发期与最终测试期边界
X_development = X.iloc[:development_end].copy()  # 保留前80%作为开发期
y_development = y.iloc[:development_end].copy()  # 对齐开发期目标
X_test = X.iloc[development_end:].copy()  # 最终测试最后20%的特征，选择完成前不读取其结果
y_test = y.iloc[development_end:].copy()  # 最终测试最后20%的目标
architecture_end = int(len(X_development) * 0.8)  # 在开发期内部确定架构验证边界
X_architecture_train = X_development.iloc[:architecture_end].copy()  # 较早窗口拟合候选架构
y_architecture_train = y_development.iloc[:architecture_end].copy()  # 对齐架构训练目标
X_architecture_validation = X_development.iloc[architecture_end:].copy()  # 较晚开发窗口只用于架构选择
y_architecture_validation = y_development.iloc[architecture_end:].copy()  # 对齐架构验证目标
print({'架构训练期': (X_architecture_train.index.min().date(), X_architecture_train.index.max().date()), '架构验证期': (X_architecture_validation.index.min().date(), X_architecture_validation.index.max().date()), '最终测试期': (X_test.index.min().date(), X_test.index.max().date())})  # 报告三段时间边界

from sklearn.preprocessing import StandardScaler  # 为神经网络建立只由架构训练样本逐特征拟合的缩放器
architecture_scaler = StandardScaler()  # 创建候选比较专用的逐特征缩放器
X_architecture_train_scaled = architecture_scaler.fit_transform(X_architecture_train)  # 只从较早架构训练样本逐特征估计均值与标准差
X_architecture_validation_scaled = architecture_scaler.transform(X_architecture_validation)  # 用确定的训练样本逐特征统计量转换较晚验证窗
print({'scaler拟合样本': len(X_architecture_train_scaled), '验证样本': len(X_architecture_validation_scaled), '测试状态': '仍最终测试'})  # 明确选择阶段未打开测试期

from sklearn.metrics import mean_squared_error  # 统一计算逐观测均方误差
from sklearn.neural_network import MLPRegressor  # 构建可复算的多层感知器候选
candidate_architectures = {'小型': (16,), '中型': (32, 16), '深型': (10, 20, 20, 10)}  # 事先确定三种网络容量
candidate_models = {}  # 保存每个训练完成的候选模型
validation_mse_by_architecture = {}  # 保存同一验证窗上的选择指标
for architecture_name, hidden_layers in candidate_architectures.items():  # 对事先确定候选使用相同训练预算
    candidate_model = MLPRegressor(hidden_layer_sizes=hidden_layers, activation='relu', random_state=42, max_iter=500)  # 固定随机种子与优化预算
    candidate_model.fit(X_architecture_train_scaled, y_architecture_train)  # 仅在较早架构训练窗拟合
    validation_predictions = candidate_model.predict(X_architecture_validation_scaled)  # 只生成较晚开发窗预测
    candidate_models[architecture_name] = candidate_model  # 保留候选供训练曲线检查
    validation_mse_by_architecture[architecture_name] = mean_squared_error(y_architecture_validation, validation_predictions)  # 计算同窗验证MSE
validation_baseline_mse = {'零收益基准': mean_squared_error(y_architecture_validation, np.zeros(len(y_architecture_validation))), '训练均值基准': mean_squared_error(y_architecture_validation, np.full(len(y_architecture_validation), y_architecture_train.mean()))}  # 事先确定两个同级朴素候选
selected_architecture_name = min(validation_mse_by_architecture, key=validation_mse_by_architecture.get)  # 找到 MLP 集合内部的验证赢家
selected_hidden_layers = candidate_architectures[selected_architecture_name]  # 确定后续重训所需层宽
nn_sklearn = candidate_models[selected_architecture_name]  # 指向已确定候选以展示训练曲线
best_baseline_name = min(validation_baseline_mse, key=validation_baseline_mse.get)  # 确定验证期表现最佳的朴素基准
is_mlp_deployable = validation_mse_by_architecture[selected_architecture_name] < validation_baseline_mse[best_baseline_name]  # 执行事先确定增量价值门槛
frozen_decision = f'MLP:{selected_architecture_name}' if is_mlp_deployable else f'保留简单模型:{best_baseline_name}'  # 在打开测试期前确定实际使用或暂不采用决策
print({'MLP候选': validation_mse_by_architecture, '朴素候选': validation_baseline_mse})  # 完整报告选择集合与基准
print({'确定决策': frozen_decision, '隐藏层': selected_hidden_layers if is_mlp_deployable else None, '测试状态': '仍最终测试'})  # 记录门槛结果

selected_validation_predictions = nn_sklearn.predict(X_architecture_validation_scaled)  # 复算确定候选的验证预测
selected_validation_mse = mean_squared_error(y_architecture_validation, selected_validation_predictions)  # 报告选择阶段指标
print(f'确定候选的验证 MSE: {selected_validation_mse:.8f}')  # 避免把验证结果称为最终测试证据

# 将同一坐标说明封装成可复用的损失曲线 SVG。
def generate_loss_curve_svg(loss_curve, title, color):
    # 固定 `epochs` 的训练轮数，界定本次教学运行的计算预算。
    epochs = len(loss_curve)
    # 取得损失序列上界，把数值归一到 SVG 画布的纵向范围。
    max_loss = max(loss_curve)
    # 取得损失序列下界，与上界共同定义 SVG 坐标变换。
    min_loss = min(loss_curve)

    # 将数值映射为画布坐标 `x_coords`，使“Scikit-learn MLPRegressor 的训练损失曲线”按统一尺度绘制。
    x_coords = [100 + (i / (epochs - 1)) * 600 for i in range(epochs)]
    # 将数值映射为画布坐标 `y_coords`，使“Scikit-learn MLPRegressor 的训练损失曲线”按统一尺度绘制。
    y_coords = [280 - ((loss - min_loss) / (max_loss - min_loss + 1e-9)) * 220 for loss in loss_curve]

    # 把连续坐标编码为 SVG 路径 `path_data`，用于绘制“Scikit-learn MLPRegressor 的训练损失曲线”的曲线。
    path_data = "M " + " ".join([f"{x:.2f},{y:.2f}" for x, y in zip(x_coords, y_coords)])

    # 把逐轮损失路径写入 SVG，显示训练误差随 epoch 的下降比较结果。
    svg = f'''
    <svg viewBox="0 0 800 320" style="max-width: 100%; height: auto;">

      <title>{title}</title>
      <desc>显示训练过程中损失函数值随迭代次数变化的曲线。</desc>
  <g class="bf10-loss">
      <style>
        .bf10-loss .axis {{ stroke: #3c4043; stroke-width: 2; }}
        .bf10-loss .grid {{ stroke: #e0e0e0; stroke-width: 1; stroke-dasharray: 4,4; }}
        .bf10-loss .label {{ font-family: "Source Han Serif SC", "Noto Serif CJK SC", serif; font-size: 20px; text-anchor: middle; fill: #3c4043; }}
        .bf10-loss .title {{ font-size: 20px; font-weight: bold; }}
        .bf10-loss .loss-curve {{ stroke: {color}; stroke-width: 3; fill: none; }}
      </style>

      <text x="400" y="35" class="label title">{title}</text>

      <!-- Axes -->
      <line x1="100" y1="280" x2="700" y2="280" class="axis"/>
      <line x1="100" y1="50" x2="100" y2="280" class="axis"/>
      <text x="400" y="305" class="label">训练迭代次数 (Epochs)</text>
      <text x="60" y="165" transform="rotate(-90, 60, 165)" class="label">训练目标（半平方误差 + L2）</text>

      <!-- Curve -->
      <path d="{path_data}" class="loss-curve" />
  </g>
</svg>
    '''
    # 返回 `svg`，把“Scikit-learn: 训练过程可视化”的计算结果交给调用方。
    return svg

# 将 MLP 的逐轮 `loss_curve_` 转成内联 SVG 字符串，供下一行嵌入幻灯片。
sklearn_svg = generate_loss_curve_svg(nn_sklearn.loss_curve_, 'Scikit-learn 神经网络训练损失下降情况', '#4285F4')
display(HTML(sklearn_svg))  # 将训练损失曲线作为内联 SVG DOM 输出

import torch  # 使用张量与自动求导实现神经网络
from torch.utils.data import DataLoader, TensorDataset  # 管理训练和验证小批量
X_train_tensor = torch.tensor(X_architecture_train_scaled.astype(np.float32))  # 转换较早架构训练特征
y_train_tensor = torch.tensor(y_architecture_train.to_numpy(dtype=np.float32)).view(-1, 1)  # 对齐架构训练目标
X_validation_tensor = torch.tensor(X_architecture_validation_scaled.astype(np.float32))  # 转换较晚架构验证特征
y_validation_tensor = torch.tensor(y_architecture_validation.to_numpy(dtype=np.float32)).view(-1, 1)  # 对齐架构验证目标
train_data = TensorDataset(X_train_tensor, y_train_tensor)  # 建立架构训练数据集
validation_data = TensorDataset(X_validation_tensor, y_validation_tensor)  # 建立只读验证数据集
batch_size = 16  # 确定课堂演示的小批评分标准模
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)  # 仅在训练窗内部打乱小批量
validation_loader = DataLoader(validation_data, batch_size=batch_size, shuffle=False)  # 保持验证窗时间顺序
print({'PyTorch训练样本': len(train_data), 'PyTorch验证样本': len(validation_data), '测试张量': '未创建'})  # 核对隔离状态

# 导入 PyTorch 神经网络接口并绑定为 `nn`，用于定义线性层、激活函数与模块基类。
import torch.nn as nn

# 定义 `IndexReturnPredictorNN`，封装本节使用的模型结构。
class IndexReturnPredictorNN(nn.Module):
    # 按输入特征数搭建两层隐藏表示和单输出回归头，确定本页网络拓扑。
    def __init__(self, input_features=3):
        # 调用父类初始化方法，为当前模型建立 `nn.Module` 基础状态。
        super(IndexReturnPredictorNN, self).__init__()
        # 设置 network，明确其在神经网络收益预测中的用途并保留复算入口。
        self.network = nn.Sequential(
            # 将 3 项输入映射到 64 个隐层单元，并用 ReLU 引入非线性。
            nn.Linear(input_features, 64), nn.ReLU(),
            # 将 64 个单元扩展到 128 个单元，增加网络表达容量。
            nn.Linear(64, 128), nn.ReLU(),
            # 训练时随机屏蔽 20% 隐层激活，缓解网络对训练样本的过度依赖。
            nn.Dropout(0.2),
            # 将 128 个单元压缩到 64 个单元，形成预测前的紧凑表示。
            nn.Linear(128, 64), nn.ReLU(),
            # 将 64 维表示映射为单一连续收益预测值。
            nn.Linear(64, 1)
        # 完成 `self.network` 的顺序层定义，使前向传播按上述层次依次执行。
        )

    # 规定批次特征依次经过隐藏层与 ReLU，再输出连续收益预测值。
    def forward(self, x):
        # 返回 `self.network(x)`，把“PyTorch 实践(2): 定义网络结构”的计算结果交给调用方。
        return self.network(x)

# 选择可用的 CPU/GPU 设备 `device`，使张量与网络位于同一计算环境。
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 打印本机选择的 `cpu` 或 `cuda` 设备，明确后续张量和模型应放置的训练设备。
print(f'将使用 {device} 设备进行训练')

torch.manual_seed(42)  # 固定 CPU 训练的参数初始化以便复算
if torch.cuda.is_available():  # 仅在 GPU 可用时固定其随机状态
    torch.cuda.manual_seed_all(42)  # 固定 GPU 训练的参数初始化
model = IndexReturnPredictorNN().to(device)  # 建立沪深 300 下一日收益预测网络
# 输出网络结构，核对各线性层维度、ReLU 与 Dropout 的排列。
print(model)

# 把均方误差设为 `criterion`，使网络训练直接最小化收益预测偏差。
criterion = nn.MSELoss()
# 配置 `optimizer` 更新网络权重，固定优化算法与学习率。
optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)

# 固定 `num_epochs` 的训练轮数，界定本次教学运行的计算预算。
num_epochs = 200
# 初始化逐轮训练损失历史；此时尚未执行任何优化步骤。
train_losses = []

# 将 `model` 切换到训练模式。
model.train()
# 遍历 `range(num_epochs)` 的候选或观测，为“训练循环：代码详解”逐项更新结果。
for epoch in range(num_epochs):
    # 将本轮批次损失累积器清零，避免不同 epoch 相互混入。
    epoch_loss = 0.0
    # 遍历 `train_loader` 的候选或观测，为“训练循环：代码详解”逐项更新结果。
    for inputs, targets in train_loader:
        # 将当前批次特征与目标同时移到模型所在设备，避免跨设备运算错误。
        inputs, targets = inputs.to(device), targets.to(device)
        # 清空优化器中上一批次累积的参数梯度。
        optimizer.zero_grad()
        # 前向传播当前批次，得到连续收益预测值用于损失计算。
        outputs = model(inputs)
        # 计算 `loss`（损失），量化“训练循环：代码详解”的模型表现。
        loss = criterion(outputs, targets)
        # 从当前损失反向传播并计算参数梯度。
        loss.backward()
        # 根据当前梯度更新优化器管理的参数。
        optimizer.step()
        # 提取当前批次损失的 Python 标量，用于累计整轮训练损失。
        epoch_loss += loss.item()

    # 计算 `avg_epoch_loss`（损失），量化“训练循环：代码详解”的模型表现。
    avg_epoch_loss = epoch_loss / len(train_loader)
    # 把 `avg_epoch_loss` 加入 `train_losses`，保留“训练循环：代码详解”本次循环的实际结果。
    train_losses.append(avg_epoch_loss)
    # 每完成 20 个训练轮次打印一次损失，控制课堂输出频率。
    if (epoch + 1) % 20 == 0:
        # 每 20 轮报告当前轮次与平均训练损失，观察优化是否收敛。
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {avg_epoch_loss:.4f}')

pytorch_svg = generate_loss_curve_svg(train_losses, 'PyTorch 神经网络训练损失下降情况', '#EA4335')  # 把已记录训练损失转成可投影曲线
display(HTML(pytorch_svg))  # 将 PyTorch 损失曲线作为内联 SVG DOM 输出

model.eval()  # 关闭 Dropout 并进入验证模式
pytorch_validation_batches = []  # 收集较晚开发窗的逐批预测
with torch.no_grad():  # 验证阶段不构建梯度图
    for validation_inputs, validation_targets in validation_loader:  # 只遍历架构验证窗
        validation_outputs = model(validation_inputs.to(device))  # 生成同窗验证预测
        pytorch_validation_batches.append(validation_outputs.cpu().numpy().ravel())  # 移回CPU统一计量
pytorch_validation_predictions = np.concatenate(pytorch_validation_batches)  # 按原顺序拼接验证预测
pytorch_validation_mse = mean_squared_error(y_architecture_validation, pytorch_validation_predictions)  # 计算PyTorch验证MSE
print(f'PyTorch 教学实现验证 MSE: {pytorch_validation_mse:.8f}')  # 明确该数字不是测试结果

validation_zero_mse = mean_squared_error(y_architecture_validation, np.zeros(len(y_architecture_validation)))  # 计算零收益验证基准
validation_mean_mse = mean_squared_error(y_architecture_validation, np.full(len(y_architecture_validation), y_architecture_train.mean()))  # 计算训练均值验证基准
validation_comparison = pd.DataFrame({'模型': [*[f'Sklearn {name}' for name in candidate_architectures], '零收益基准', '训练均值基准', 'PyTorch教学实现（不参与选择）'], '验证MSE': [*[validation_mse_by_architecture[name] for name in candidate_architectures], validation_zero_mse, validation_mean_mse, pytorch_validation_mse]})  # 展示完整候选、基准与排除项
display(validation_comparison.sort_values('验证MSE').reset_index(drop=True).round(8))  # 展示选择阶段完整比较

final_scaler = StandardScaler()  # 为最终重训创建全新的逐特征缩放器
X_development_scaled = final_scaler.fit_transform(X_development)  # 只用完整开发样本逐特征重新估计均值与标准差
X_test_scaled = final_scaler.transform(X_test)  # 用确定的开发样本逐特征统计量首次转换最终测试特征
if is_mlp_deployable:  # 只有通过基准门槛才允许重训复杂模型
    final_model = MLPRegressor(hidden_layer_sizes=selected_hidden_layers, activation='relu', random_state=2026, max_iter=500).fit(X_development_scaled, y_development)  # 从新种子重训确定架构
    sealed_test_predictions = final_model.predict(X_test_scaled)  # 对最终测试期生成一次 MLP 预测
else:  # 验证期未胜基准时执行暂不采用规则
    sealed_test_predictions = np.zeros(len(y_test)) if best_baseline_name == '零收益基准' else np.full(len(y_test), y_development.mean())  # 使用确定朴素基准检查测试期
sealed_test_mse = mean_squared_error(y_test, sealed_test_predictions)  # 计算唯一一次模型测试指标
zero_test_mse = mean_squared_error(y_test, np.zeros(len(y_test)))  # 计算事先确定零收益测试基准
mean_test_mse = mean_squared_error(y_test, np.full(len(y_test), y_development.mean()))  # 计算开发期均值测试基准
sealed_test_table = pd.DataFrame({'模型': [frozen_decision, '零收益基准', '开发期均值基准'], '最终测试MSE': [sealed_test_mse, zero_test_mse, mean_test_mse]})  # 汇总确定决策的一次性检查
display(sealed_test_table.round(8))  # 如实展示模型是否胜过朴素基准