03 线性回归

# 为“不同参数代表了对数据关系的不同“假设””导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 为“不同参数代表了对数据关系的不同“假设””导入 `matplotlib.pyplot` 并绑定 `plt`，用于构建当前任务的坐标轴并呈现比较结果。
import matplotlib.pyplot as plt

# 设置清晰可区分的投影配色
# 固定 `primary_blue` 的图形配色，使“不同参数 w0 和 w1 定义了不同的线性模型”中的曲线或标记易于区分。
primary_blue = '#007bff'
# 固定 `accent_red` 的图形配色，使“不同参数 w0 和 w1 定义了不同的线性模型”中的曲线或标记易于区分。
accent_red = '#dc3545'
# 固定 `text_color` 的颜色编码，使“不同参数 w0 和 w1 定义了不同的线性模型”中的对象易于区分。
text_color = '#212529'
# 固定 `grid_color` 的颜色编码，使“不同参数 w0 和 w1 定义了不同的线性模型”中的对象易于区分。
grid_color = '#e0e0e0'
# 固定 `background_color` 的颜色编码，使“不同参数 w0 和 w1 定义了不同的线性模型”中的对象易于区分。
background_color = '#f8f9fa'


# 为“不同参数代表了对数据关系的不同“假设””，创建本图所需画布与坐标轴，并保存到 `(fig, (ax1, ax2))`。
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), sharey=True)
# 用浅色底区分总览面板与右侧两个候选模型。
fig.set_facecolor(background_color)

# 模型一使用正斜率 w1 > 0
# 建立 `x1` 的有序取值网格，用于展示“不同参数 w0 和 w1 定义了不同的线性模型”随参数变化的比较结果。
x1 = np.linspace(0, 10, 100)
# 用第一组截距与斜率计算候选直线 A 的预测值。
y1 = 1.5 + 0.6 * x1
# 在左面板绘出正斜率候选线，展示参数符号如何改变预测方向。
ax1.plot(x1, y1, color=accent_red, linewidth=3, label='$f(x) = 1.5 + 0.6x$')
# 将图题设为“$w_1 > 0$ (正相关)”，直接说明当前图形的比较目的。
ax1.set_title('$w_1 > 0$ (正相关)', fontsize=16, color=text_color, pad=10)
# 将横轴标为“特征 (x)”，明确横向编码的变量。
ax1.set_xlabel('特征 (x)', color=text_color, fontsize=12)
# 将纵轴标为“预测值 (y)”，明确纵向编码的变量。
ax1.set_ylabel('预测值 (y)', color=text_color, fontsize=12)
# 为“不同参数代表了对数据关系的不同“假设””，限定横轴范围，使比较对象使用一致尺度。
ax1.set_xlim(0, 10)
# 为“不同参数代表了对数据关系的不同“假设””，限定纵轴范围，使比较对象使用一致尺度。
ax1.set_ylim(0, 10)
# 为“不同参数代表了对数据关系的不同“假设””添加辅助网格，便于比较位置、斜率或组间差异。
ax1.grid(True, linestyle='--', alpha=0.7, color=grid_color)
# 统一刻度文字样式，提升投影可读性。
ax1.tick_params(colors=text_color)
# 用白底突出候选模型 A 的散点与拟合线。
ax1.set_facecolor('white')
# 在图中标注“$f(x) = 1.5 + 0.6x$”，解释“不同参数 w0 和 w1 定义了不同的线性模型”的关键位置。
ax1.text(5, 9, '$f(x) = 1.5 + 0.6x$', ha='center', va='center', fontsize=14, color=accent_red)


# 模型二使用负斜率 w1 < 0
# 建立 `x2` 的有序取值网格，用于展示“不同参数 w0 和 w1 定义了不同的线性模型”随参数变化的比较结果。
x2 = np.linspace(0, 10, 100)
# 用第二组截距与斜率计算候选直线 B 的预测值。
y2 = 8 - 0.5 * x2
# 在右面板绘出负斜率候选线，与左侧模型使用同一坐标尺度比较。
ax2.plot(x2, y2, color=primary_blue, linewidth=3, label='$f(x) = 8.0 - 0.5x$')
# 将图题设为“$w_1 < 0$ (负相关)”，直接说明当前图形的比较目的。
ax2.set_title('$w_1 < 0$ (负相关)', fontsize=16, color=text_color, pad=10)
# 将横轴标为“特征 (x)”，明确横向编码的变量。
ax2.set_xlabel('特征 (x)', color=text_color, fontsize=12)
# 为“不同参数代表了对数据关系的不同“假设””，限定横轴范围，使比较对象使用一致尺度。
ax2.set_xlim(0, 10)
# 为“不同参数代表了对数据关系的不同“假设””，限定纵轴范围，使比较对象使用一致尺度。
ax2.set_ylim(0, 10)
# 为“不同参数代表了对数据关系的不同“假设””添加辅助网格，便于比较位置、斜率或组间差异。
ax2.grid(True, linestyle='--', alpha=0.7, color=grid_color)
# 统一刻度文字样式，提升投影可读性。
ax2.tick_params(colors=text_color)
# 用白底突出候选模型 B 的散点与拟合线。
ax2.set_facecolor('white')
# 在图中标注“$f(x) = 8.0 - 0.5x$”，解释“不同参数 w0 和 w1 定义了不同的线性模型”的关键位置。
ax2.text(5, 2, '$f(x) = 8.0 - 0.5x$', ha='center', va='center', fontsize=14, color=primary_blue)


# 为“不同参数代表了对数据关系的不同“假设””，压缩子图留白，避免标题和坐标标签相互遮挡。
plt.tight_layout(pad=2.0)
# 显示多组截距与斜率对应的回归直线，比较参数变化如何改变水平位置和倾斜方向。
plt.show()

# 为“如何定义“最佳”拟合？——最小化预测误差”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 为“如何定义“最佳”拟合？——最小化预测误差”导入 `matplotlib.pyplot` 并绑定 `plt`，用于构建当前任务的坐标轴并呈现比较结果。
import matplotlib.pyplot as plt

# 生成固定机制样本
# 为“如何定义“最佳”拟合？——最小化预测误差”，固定随机数序列，使课堂示例可重复。
np.random.seed(42)
# 在 [0,2] 区间抽取 20 个单特征观测，构成线性拟合的横坐标。
X = 2 * np.random.rand(20, 1) # 生成单特征输入
# 由截距 4、斜率 3 和单位高斯噪声生成回归目标 `y`。
y = 4 + 3 * X + np.random.randn(20, 1) # 在线性响应中加入随机扰动

# 固定 `x_range` 的数值分量，作为“如何定义“最佳”拟合？——最小化预测误差”的可手算输入。
x_range = np.array([[np.min(X)-0.1], [np.max(X)+0.1]])

# 设置一组较好拟合与一组较差拟合参数
# 取得参数 `w1_good, w0_good`，用于比较不同斜率或学习率对应的损失位置。
w1_good, w0_good = 3.1, 4.2 # 较好拟合的斜率与截距
# 取得参数 `w1_bad, w0_bad`，用于比较不同斜率或学习率对应的损失位置。
w1_bad, w0_bad = -0.5, 8.0  # 较差拟合的斜率与截距

# 在共同横轴网格上计算较好参数组的预测直线，作为残差较小的比较基准。
y_good_pred_line = w0_good + w1_good * x_range
# 在同一横轴网格上计算较差参数组的预测直线，用于展示较大残差。
y_bad_pred_line = w0_bad + w1_bad * x_range

# 设置统一的投影配色
# 固定 `data_point_color` 的颜色编码，使““最佳”模型是使预测值与真实值之间总差距最小的模型”中的对象易于区分。
data_point_color = '#007bff'
# 固定 `good_fit_line_color` 的颜色编码，使““最佳”模型是使预测值与真实值之间总差距最小的模型”中的对象易于区分。
good_fit_line_color = '#166534'
# 固定 `bad_fit_line_color` 的颜色编码，使““最佳”模型是使预测值与真实值之间总差距最小的模型”中的对象易于区分。
bad_fit_line_color = '#dc3545'
# 固定 `error_line_color` 的颜色编码，使““最佳”模型是使预测值与真实值之间总差距最小的模型”中的对象易于区分。
error_line_color = '#6c757d'
# 固定 `text_color` 的颜色编码，使““最佳”模型是使预测值与真实值之间总差距最小的模型”中的对象易于区分。
text_color = '#212529'
# 固定 `grid_color` 的颜色编码，使““最佳”模型是使预测值与真实值之间总差距最小的模型”中的对象易于区分。
grid_color = '#e0e0e0'
# 固定 `background_color` 的颜色编码，使““最佳”模型是使预测值与真实值之间总差距最小的模型”中的对象易于区分。
background_color = '#f8f9fa'


# 为“如何定义“最佳”拟合？——最小化预测误差”，创建本图所需画布与坐标轴，并保存到 `(fig, (ax1, ax2))`。
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 3.6), sharey=True)
# 用浅色底区分成本最小化总览与右侧误差分解面板。
fig.set_facecolor(background_color)

# 绘制较好拟合模型
# 以 `X` 为横轴、`y` 为纵轴绘制散点，展示““最佳”模型是使预测值与真实值之间总差距最小的模型”。
ax1.scatter(X, y, marker='x', color=data_point_color, s=80, label='真实数据点', zorder=5)
# 以 `x_range` 为横轴、`y_good_pred_line` 为纵轴绘制曲线，展示““最佳”模型是使预测值与真实值之间总差距最小的模型”。
ax1.plot(x_range, y_good_pred_line, "-", color=good_fit_line_color, linewidth=3, label='模型预测')
# 遍历 `range(len(X))` 的候选或观测，为“如何定义“最佳”拟合？——最小化预测误差”逐项更新结果。
for i in range(len(X)):
    # 为“如何定义“最佳”拟合？——最小化预测误差”，把投影连接线设为灰色虚线，并用 0.8 线宽弱化其视觉层级。
    ax1.plot([X[i], X[i]], [y[i], w0_good + w1_good * X[i]], '--', color=error_line_color, alpha=0.7)
# 将图题设为“模型 A (较好拟合)”，直接说明当前图形的比较目的。
ax1.set_title(f'模型 A (较好拟合)', fontsize=20, color=text_color, pad=10)
# 为“如何定义“最佳”拟合？——最小化预测误差”，将横轴标为“x”，明确横向编码的变量。
ax1.set_xlabel('x', color=text_color, fontsize=18)
# 为“如何定义“最佳”拟合？——最小化预测误差”，将纵轴标为“y”，明确纵向编码的变量。
ax1.set_ylabel('y', color=text_color, fontsize=18)
# 显示“如何定义“最佳”拟合？——最小化预测误差”图例，使颜色或线型与比较对象一一对应。
ax1.legend(fontsize=18, loc='upper left')
# 为“如何定义“最佳”拟合？——最小化预测误差”添加辅助网格，便于比较位置、斜率或组间差异。
ax1.grid(True, linestyle='--', alpha=0.7, color=grid_color)
# 统一刻度文字样式，提升投影可读性。
ax1.tick_params(colors=text_color, labelsize=18)
# 用白底突出候选斜率与观测点之间的残差。
ax1.set_facecolor('white')

# 绘制较差拟合模型
# 以 `X` 为横轴、`y` 为纵轴绘制散点，展示““最佳”模型是使预测值与真实值之间总差距最小的模型”。
ax2.scatter(X, y, marker='x', color=data_point_color, s=80, label='真实数据点', zorder=5)
# 以 `x_range` 为横轴、`y_bad_pred_line` 为纵轴绘制曲线，展示““最佳”模型是使预测值与真实值之间总差距最小的模型”。
ax2.plot(x_range, y_bad_pred_line, "-", color=bad_fit_line_color, linewidth=3, label='模型预测')
# 遍历 `range(len(X))` 的候选或观测，为“如何定义“最佳”拟合？——最小化预测误差”逐项更新结果。
for i in range(len(X)):
    # 为“如何定义“最佳”拟合？——最小化预测误差”，把投影连接线设为灰色虚线，并用 0.8 线宽弱化其视觉层级。
    ax2.plot([X[i], X[i]], [y[i], w0_bad + w1_bad * X[i]], '--', color=error_line_color, alpha=0.7)
# 将图题设为“模型 B (较差拟合)”，直接说明当前图形的比较目的。
ax2.set_title(f'模型 B (较差拟合)', fontsize=20, color=text_color, pad=10)
# 为“如何定义“最佳”拟合？——最小化预测误差”，将横轴标为“x”，明确横向编码的变量。
ax2.set_xlabel('x', color=text_color, fontsize=18)
# 显示“如何定义“最佳”拟合？——最小化预测误差”图例，使颜色或线型与比较对象一一对应。
ax2.legend(fontsize=18, loc='upper left')
# 为“如何定义“最佳”拟合？——最小化预测误差”添加辅助网格，便于比较位置、斜率或组间差异。
ax2.grid(True, linestyle='--', alpha=0.7, color=grid_color)
# 统一刻度文字样式，提升投影可读性。
ax2.tick_params(colors=text_color, labelsize=18)
# 用白底突出误差平方和随斜率变化的曲线。
ax2.set_facecolor('white')

# 为“如何定义“最佳”拟合？——最小化预测误差”，压缩子图留白，避免标题和坐标标签相互遮挡。
plt.tight_layout(pad=2.0)
# 显示好、差两条拟合线及残差线段，比较平方误差随参数选择的变化。
plt.show()

import numpy as np  # 计算候选斜率对应的均方代价
import matplotlib.pyplot as plt  # 并排绘制拟合线与代价曲线
feature_values = np.array([-1.0, -0.75, -0.45, -0.15, 0.15, 0.45, 0.75, 1.0])  # 固定机制图的横轴取值
observed_targets = np.array([-3.1, -2.0, -1.5, -0.2, 0.7, 1.2, 2.4, 3.2])  # 固定含轻微偏差的目标值
slope_grid = np.linspace(-1, 7, 160)  # 枚举候选斜率以形成平滑代价曲线
cost_curve = np.array([np.mean((slope * feature_values - observed_targets) ** 2) / 2 for slope in slope_grid])  # 逐斜率计算半均方误差
best_slope = slope_grid[np.argmin(cost_curve)]  # 找出固定网格上的最低代价斜率
scenario_records = [(0.5, '斜率过小', '#963900'), (best_slope, '最低代价', '#166534'), (5.5, '斜率过大', '#174F87')]  # 固定三种对照情景
figure, plot_axes = plt.subplots(1, 2, figsize=(11, 3.0))  # 压缩图高并保留两幅大图的投影字号
plot_axes[0].scatter(feature_values, observed_targets, marker='x', s=90, color='#212529', label='固定观测')  # 展示同一组机制观测
plot_axes[1].plot(slope_grid, cost_curve, color='#166534', linewidth=3)  # 绘制斜率—代价曲线
for scenario_slope, scenario_label, scenario_color in scenario_records:  # 让三条拟合线与三个代价点使用一致颜色
    plot_axes[0].plot([-1, 1], [-scenario_slope, scenario_slope], color=scenario_color, linewidth=3, label=rf'{scenario_label}: $w_1$={scenario_slope:.2f}')  # 叠加候选拟合线
    scenario_cost = np.mean((scenario_slope * feature_values - observed_targets) ** 2) / 2  # 计算该候选线的代价
    plot_axes[1].scatter(scenario_slope, scenario_cost, s=100, color=scenario_color, edgecolor='black', zorder=3, label=scenario_label)  # 在代价曲线上标出对应位置
plot_axes[0].set(title='同一观测的三条候选拟合线', xlabel='特征 x', ylabel='目标 y', xlim=(-1.1, 1.1), ylim=(-6, 6))  # 固定左图标题、轴名与尺度
plot_axes[1].set(title=r'代价函数 $J(w_1)$', xlabel=r'候选斜率 $w_1$', ylabel=r'半均方误差 $J(w_1)$')  # 明确右图的参数与评价量
for plot_axis in plot_axes:  # 统一两幅图的投影可读样式
    plot_axis.grid(True, linestyle='--', alpha=0.45)  # 用浅网格辅助读取坐标
    plot_axis.tick_params(labelsize=15)  # 使缩放后的刻度文字仍不低于 18px
    plot_axis.title.set_fontsize(18)  # 使缩放后的子图标题保持投影可读
    plot_axis.xaxis.label.set_size(16)  # 使缩放后的横轴标题保持投影可读
    plot_axis.yaxis.label.set_size(16)  # 使缩放后的纵轴标题保持投影可读
    plot_axis.legend(fontsize=15, loc='best')  # 解释三种情景及其颜色对应关系
plt.tight_layout()  # 为标题、坐标轴和图例保留互不遮挡的边距
plt.show()  # 输出两幅并排机制图

# 为“学习率 $\alpha$ 是决定成败的关键超参数”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 为“学习率 $\alpha$ 是决定成败的关键超参数”导入 `matplotlib.pyplot` 并绑定 `plt`，用于构建当前任务的坐标轴并呈现比较结果。
import matplotlib.pyplot as plt

# 定义 `J`，计算一维参数的平方误差代价。
def J(w): return (w - 5)**2 + 3
# 定义 `dJ`，计算代价函数关于参数的导数。
def dJ(w): return 2 * (w - 5)

# 定义一维梯度下降比较结果计算器，用初值、学习率与迭代次数比较收敛路径。
def gradient_descent(w_start, alpha, n_iterations):
    # 用初始权重建立迭代比较结果列表，后续每轮追加更新值以比较学习率的收敛路径。
    w_path = [w_start]
    # 取得参数 `w`，用于比较不同斜率或学习率对应的损失位置。
    w = w_start
    # 遍历 `range(n_iterations)` 的候选或观测，为“学习率 $\alpha$ 是决定成败的关键超参数”逐项更新结果。
    for _ in range(n_iterations):
        # 取得参数 `w`，用于比较不同斜率或学习率对应的损失位置。
        w = w - alpha * dJ(w)
        # 把 `w` 加入 `w_path`，保留“学习率 $\alpha$ 是决定成败的关键超参数”本次循环的实际结果。
        w_path.append(w)
    # 返回 `np.array(w_path)`，把“学习率 $\alpha$ 是决定成败的关键超参数”的计算结果交给调用方。
    return np.array(w_path)

# 固定 `cost_plot_color` 的颜色编码，使“学习率 α 对梯度下降过程的影响”中的对象易于区分。
cost_plot_color = '#007bff'
# 固定 `path_color_good` 的颜色编码，使“学习率 α 对梯度下降过程的影响”中的对象易于区分。
path_color_good = '#166534'
# 固定 `path_color_bad` 的颜色编码，使“学习率 α 对梯度下降过程的影响”中的对象易于区分。
path_color_bad = '#dc3545'
# 固定 `text_color` 的颜色编码，使“学习率 α 对梯度下降过程的影响”中的对象易于区分。
text_color = '#212529'
# 固定 `grid_color` 的颜色编码，使“学习率 α 对梯度下降过程的影响”中的对象易于区分。
grid_color = '#e0e0e0'
# 固定 `background_color` 的颜色编码，使“学习率 α 对梯度下降过程的影响”中的对象易于区分。
background_color = '#f8f9fa'

# 建立 `w_range` 的有序取值网格，用于展示“学习率 α 对梯度下降过程的影响”随参数变化的比较结果。
w_range = np.linspace(0, 10, 100)
# 在代价函数值域内建立 `j_range` 网格，用作梯度下降比较结果图的纵轴背景。
j_range = J(w_range)

# 保存 `path_small_alpha` 的参数迭代比较结果，用于比较不同学习率的收敛速度与稳定性。
path_small_alpha = gradient_descent(w_start=0.5, alpha=0.1, n_iterations=15)
# 保存 `path_large_alpha` 的参数迭代比较结果，用于比较不同学习率的收敛速度与稳定性。
path_large_alpha = gradient_descent(w_start=0.5, alpha=0.98, n_iterations=15)


# 为“学习率 $\alpha$ 是决定成败的关键超参数”，创建本图所需画布与坐标轴，并保存到 `(fig, (ax1, ax2))`。
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 3.5))
# 用浅色底区分学习率总览与三个下降比较结果面板。
fig.set_facecolor(background_color)

# 绘制适中学习率的更新比较结果
# 以 `w_range` 为横轴、`j_range` 为纵轴绘制曲线，展示“学习率 α 对梯度下降过程的影响”。
ax1.plot(w_range, j_range, color=cost_plot_color, linewidth=2.5, zorder=1)
# 以 `path_small_alpha` 为横轴、`J(path_small_alpha)` 为纵轴绘制曲线，展示“学习率 α 对梯度下降过程的影响”。
ax1.plot(path_small_alpha, J(path_small_alpha), '-o', color=path_color_good, markersize=8, linewidth=2, label=r'学习路径', zorder=2)
# 将图题设为“合适的 α: 平稳收敛”，直接说明当前图形的比较目的。
ax1.set_title(r'合适的 α: 平稳收敛', fontsize=16, color=text_color, pad=10)
# 将横轴标为“$w_1$”，明确横向编码的变量。
ax1.set_xlabel('$w_1$', color=text_color, fontsize=16)
# 将纵轴标为“$J(w_1)$”，明确纵向编码的变量。
ax1.set_ylabel('$J(w_1)$', color=text_color, fontsize=16)
# 显示“学习率 $\alpha$ 是决定成败的关键超参数”图例，使颜色或线型与比较对象一一对应。
ax1.legend(fontsize=16)
# 为“学习率 $\alpha$ 是决定成败的关键超参数”添加辅助网格，便于比较位置、斜率或组间差异。
ax1.grid(True, linestyle='--', alpha=0.7, color=grid_color)
# 统一刻度文字样式，提升投影可读性。
ax1.tick_params(colors=text_color, labelsize=16)
# 用白底突出较小学习率的缓慢下降比较结果。
ax1.set_facecolor('white')

# 绘制过大学习率的更新比较结果
# 以 `w_range` 为横轴、`j_range` 为纵轴绘制曲线，展示“学习率 α 对梯度下降过程的影响”。
ax2.plot(w_range, j_range, color=cost_plot_color, linewidth=2.5, zorder=1)
# 以 `path_large_alpha` 为横轴、`J(path_large_alpha)` 为纵轴绘制曲线，展示“学习率 α 对梯度下降过程的影响”。
ax2.plot(path_large_alpha, J(path_large_alpha), '-o', color=path_color_bad, markersize=8, linewidth=2, label=r'学习路径', zorder=2)
# 将图题设为“过大的 α: 震荡或发散”，直接说明当前图形的比较目的。
ax2.set_title(r'过大的 α: 震荡或发散', fontsize=16, color=text_color, pad=10)
# 将横轴标为“$w_1$”，明确横向编码的变量。
ax2.set_xlabel('$w_1$', color=text_color, fontsize=16)
# 显示“学习率 $\alpha$ 是决定成败的关键超参数”图例，使颜色或线型与比较对象一一对应。
ax2.legend(fontsize=16)
# 为“学习率 $\alpha$ 是决定成败的关键超参数”添加辅助网格，便于比较位置、斜率或组间差异。
ax2.grid(True, linestyle='--', alpha=0.7, color=grid_color)
# 统一刻度文字样式，提升投影可读性。
ax2.tick_params(colors=text_color, labelsize=16)
# 用白底突出适中学习率的稳定收敛比较结果。
ax2.set_facecolor('white')

# 为“学习率 $\alpha$ 是决定成败的关键超参数”，压缩子图留白，避免标题和坐标标签相互遮挡。
plt.tight_layout(pad=2.0)
# 显示不同学习率的权重迭代比较结果，检查缓慢收敛、稳定收敛与发散三种诊断模式。
plt.show()

import pandas as pd  # 组织机制演示数据
import statsmodels.api as sm  # 生成OLS估计与推断摘要
import numpy as np  # 使用固定随机生成机制

# 固定机制样本量与随机种子，构造已知线性关系供 statsmodels 推断演示。
np.random.seed(2024)  # 固定机制演示的随机状态
n_samples = 1000  # 设置足以观察回归输出结构的样本量
# 为 `generated_features` 建立包含 3 项的键值记录。
generated_features = {
    'price_placeholder': np.random.uniform(5, 50, n_samples),  # 生成不对应真实价格的占位特征
    'bm_placeholder': np.random.uniform(0.2, 2.5, n_samples),  # 生成不对应真实B/M的占位特征
    'profitability_placeholder': np.random.uniform(0.01, 0.15, n_samples)  # 生成不对应真实ROA的占位特征
}
df = pd.DataFrame(generated_features)  # 形成仅供机制演示的数据框
df['generated_target'] = 0.1 + 0.02 * df['price_placeholder'] + 0.03 * df['bm_placeholder'] + 0.8 * df['profitability_placeholder'] + np.random.normal(0, 0.5, n_samples)  # 按已知规则生成目标

# 从机制表中提取三项解释变量和响应变量，固定 OLS 设计矩阵口径。
features = ['price_placeholder', 'bm_placeholder', 'profitability_placeholder']  # 固定三个无经济身份的解释变量
y = df['generated_target']  # 指定机制演示目标
X = df[features]  # 构建回归设计矩阵

# 给解释变量矩阵添加常数列，使 statsmodels 显式估计截距。
X = sm.add_constant(X)  # 加入截距列以匹配生成方程

# 用机制样本估计 OLS 系数及模型假设下的标准误。
model = sm.OLS(y, X)  # 定义样本内OLS模型
result = model.fit()  # 估计系数与模型假设下的标准误

# 将系数、标准误、p 值与置信区间压成投影可读表，完整摘要留在折叠代码复现链中。
ols_inference = pd.concat([result.params.rename('coef'), result.bse.rename('std_err'), result.pvalues.rename('p_value'), result.conf_int().rename(columns={0: 'ci_low', 1: 'ci_high'})], axis=1)
# 展示足以支持后续三页解读的推断字段，避免默认输出产生内部滚动。
display(ols_inference.round(4))

# 为“实战2：使用 `scikit-learn` 进行回归分析”导入 `pandas` 并绑定 `pd`，用于整理当前任务的表格、字段与时间索引。
import pandas as pd
from pathlib import Path
from urllib.request import urlretrieve  # 复用本章隐藏设置单元安装的浏览器标识下载器
# 为“实战2：使用 `scikit-learn` 进行回归分析”，导入 `StandardScaler`，用全部机制演示样本按特征列估计均值与尺度；本页不声称样本外验证。
from sklearn.preprocessing import StandardScaler
# 为“实战2：使用 `scikit-learn` 进行回归分析”，从 `sklearn.linear_model` 导入`LinearRegression` 用于拟合普通最小二乘线性回归。
from sklearn.linear_model import LinearRegression
# 为“实战2：使用 `scikit-learn` 进行回归分析”，从 `sklearn.metrics` 导入`mean_squared_error` 用于计算真实值与预测值的均方误差。
from sklearn.metrics import mean_squared_error

# 读取公开练习 CSV，并提取三项解释变量与响应变量供 sklearn 对照。
# 按 Linux 共享数据、Windows 共享数据、项目缓存的顺序选择回归练习文件。
ols_training_path = next((candidate_path for candidate_path in [Path('/home/ubuntu/r2_data_mount/data/course/ols_training.csv'), Path('C:/qiufei/data/course/ols_training.csv'), Path('data/course/ols_training.csv')] if candidate_path.exists()), Path('data/course/ols_training.csv'))
if not ols_training_path.exists():
    ols_training_path.parent.mkdir(parents=True, exist_ok=True)
    urlretrieve('https://assets.qiufei.site/data/course/ols_training.csv', ols_training_path)
df_sklearn = pd.read_csv(ols_training_path)
# 为“实战2：使用 `scikit-learn` 进行回归分析”，固定 `features` 的特征名称，使图表标签与模型输入列一一对应。
features = ['pps', 'bm', 'roa']
y = df_sklearn['eps_basic']  # 指定该示例的真实列名目标
X = df_sklearn[features]  # 仅从该示例数据框提取特征

# 创建缩放器，随后由全部机制演示样本逐特征估计均值与标准差。
scaler = StandardScaler()
# 用机制演示样本逐特征估计均值与标准差并转换；本段不作样本外评价。
X_scaled = scaler.fit_transform(X)

# 建立 sklearn 线性回归器，随后用标准化机制样本估计截距与系数。
model_sk = LinearRegression()
# 用全部机制样本的标准化特征估计 sklearn 线性回归系数，供与手工 OLS 结果对照。
model_sk.fit(X_scaled, y)

# 打印 sklearn 回归截距，开始与手工 OLS 参数逐项对照。
print(f'截距 (w0): {model_sk.intercept_:.4f}')
# 将各标准化特征与对应回归系数配对成可读表格。
coef_df = pd.DataFrame(model_sk.coef_, index=features, columns=['标准化系数'])
# 标出标准化特征的线性回归系数表。
print('特征系数 (w1, w2, ...):')
# 输出回归系数表，比较各财务变量与目标的样本内线性关联。
print(coef_df)

# 用已拟合模型生成机制样本预测数组，供计算同样本 MSE。
y_pred = model_sk.predict(X_scaled)
# 计算 `mse`（均方误差），量化“实战2：使用 scikit-learn 进行回归分析”的模型表现。
mse = mean_squared_error(y, y_pred)
# 报告“模型在训练集上的均方误差 (MSE): {mse:.4f}”中的 `mse`，评价“实战2：使用 scikit-learn 进行回归分析”的模型表现。
print(f'\n模型在训练集上的均方误差 (MSE): {mse:.4f}')

# 为“练习2：参考代码与解答”导入 `pandas` 并绑定 `pd`，用于整理当前任务的表格、字段与时间索引。
import pandas as pd
# 为“练习2：参考代码与解答”导入 `numpy` 并绑定 `np`，用于执行当前任务的数组、数值或随机机制计算。
import numpy as np
# 导入 statsmodels 并绑定为 `sm`，用于添加截距并拟合带推断统计量的 OLS 规格。
import statsmodels.api as sm
# 为“练习2：参考代码与解答”，从 `sklearn.metrics` 导入`mean_squared_error` 用于计算真实值与预测值的均方误差。
from sklearn.metrics import mean_squared_error

df_cleaned = df[(df['generated_target'] > 0) & (df['price_placeholder'] > 0)].copy()  # 只保留可进行对数变换的生成观测
# 记录完整样本数，用原生成顺序划定互斥的三段机制样本。
exercise_sample_count = len(df_cleaned)
# 确定前 60% 为训练窗，所有规格只在此段估计参数。
training_end = int(exercise_sample_count * 0.6)
# 确定中间 20% 为验证窗，所有候选与训练均值基线只在此段比较。
validation_end = int(exercise_sample_count * 0.8)
# 保存训练、验证与末段最终测试索引，后续禁止重新切分。
training_rows, validation_rows, sealed_test_rows = df_cleaned.index[:training_end], df_cleaned.index[training_end:validation_end], df_cleaned.index[validation_end:]
# 汇总三段边界与样本量，作为提交要求中的第一项证据。
split_boundaries = pd.DataFrame({'窗口': ['训练', '验证', '最终测试'], '起始序号': [0, training_end, validation_end], '结束序号': [training_end - 1, validation_end - 1, exercise_sample_count - 1], '样本数': [len(training_rows), len(validation_rows), len(sealed_test_rows)]})
# 展示互斥窗口，证明最终测试没有参与候选比较。
display(split_boundaries)

# 打印原始线性规格标题，将其推断结果与后续变换规格分区展示。
print("--- 原始模型 ---")
# 固定 `features_orig` 的业务取值与顺序，作为“练习2：参考代码与解答”的可复算输入。
features_orig = ['price_placeholder', 'bm_placeholder', 'profitability_placeholder']
# 提取 `X_orig` 作为“练习2：参考代码与解答”的特征矩阵，明确模型可见的输入列。
X_orig = sm.add_constant(df_cleaned[features_orig])
# 提取 EPS 作为三种函数形式共同评价的回归目标。
y_orig = df_cleaned['generated_target']
# 仅用前段训练行拟合原始线性候选，保留验证与测试观测。
model_orig = sm.OLS(y_orig.loc[training_rows], X_orig.loc[training_rows]).fit()
# 提取训练期 R² 只作拟合诊断，不用它替代最终测试比较。
r2_orig = model_orig.rsquared
# 只由训练窗确定常数均值，建立不接触验证目标的朴素基线。
training_mean_prediction = float(y_orig.loc[training_rows].mean())
# 在共同验证窗计算原始线性候选 MSE，作为函数形式比较证据。
mse_orig = mean_squared_error(y_orig.loc[validation_rows], model_orig.predict(X_orig.loc[validation_rows]))
# 在同一验证窗计算训练均值基线 MSE，防止复杂规格只与彼此比较。
mse_training_mean = mean_squared_error(y_orig.loc[validation_rows], np.repeat(training_mean_prediction, len(validation_rows)))
# 同时报告训练拟合、线性候选与训练均值的验证误差。
print({'训练R²': round(r2_orig, 4), '线性验证MSE': round(mse_orig, 4), '训练均值验证MSE': round(mse_training_mean, 4)})

# 打印对数变换规格标题，明确随后结果来自变化后的响应与特征口径。
print("--- 任务1：对数变换模型 ---")
# 对严格为正的目标变量取自然对数，建立对数尺度回归目标。
df_cleaned['log_target'] = np.log(df_cleaned['generated_target'])
# 对严格为正的价格占位变量取自然对数，匹配对数模型的解释尺度。
df_cleaned['log_price_placeholder'] = np.log(df_cleaned['price_placeholder'])
# 固定 `features_log` 的业务取值与顺序，作为“练习2答案：任务1（对数模型）”的可复算输入。
features_log = ['log_price_placeholder', 'bm_placeholder', 'profitability_placeholder']
# 为对数规格加入截距列，使训练矩阵与 OLS 方程一致。
X_log = sm.add_constant(df_cleaned[features_log])
# 提取对数规格的响应变量，与已加截距的共同样本设计矩阵逐行对齐。
y_log = df_cleaned['log_target']
# 仅用共同训练行拟合对数模型，避免读取最终测试目标。
model_log = sm.OLS(y_log.loc[training_rows], X_log.loc[training_rows]).fit()
log_diagnostics = pd.DataFrame({'指标': ['样本数', 'R²', '调整R²', '残差MSE'], '数值': [int(model_log.nobs), model_log.rsquared, model_log.rsquared_adj, model_log.mse_resid]})  # 提取投影所需诊断而不输出整页摘要
display(log_diagnostics.round(4))  # 用紧凑表替代会产生内部滚动的完整 statsmodels 摘要
# 提取 `r2_log` 的 R²，限定在同一目标尺度内评价拟合程度。
r2_log = model_log.rsquared
# 用训练残差估计 Duan smearing 因子，校正对数预测反变换的均值偏差。
smearing_factor = np.exp(model_log.resid).mean()
# 把验证窗对数预测还原到原始目标尺度，与线性候选和基线同窗比较。
log_validation_predictions = np.exp(model_log.predict(X_log.loc[validation_rows])) * smearing_factor
# 在共同验证窗计算原始尺度 MSE，避免跨尺度误判。
mse_log = mean_squared_error(y_orig.loc[validation_rows], log_validation_predictions)
# 报告训练 R² 与同尺度验证 MSE，不提前读取最终测试目标。
print({'对数模型训练R²': round(r2_log, 4), '对数模型验证MSE': round(mse_log, 4), '相对线性验证MSE变化': round(mse_log - mse_orig, 4)})

# 打印多项式规格标题，明确随后结果来自四阶曲率设计。
print("--- 任务2：多项式特征模型 ---")
# 计算股价平方项，允许回归捕捉二阶曲率。
df_cleaned['pps2'] = df_cleaned['price_placeholder']**2
# 计算股价三次项，扩展多项式候选模型。
df_cleaned['pps3'] = df_cleaned['price_placeholder']**3
# 构造价格代理变量的四次项，补齐四阶多项式设计矩阵以检验非线性曲率。
df_cleaned['pps4'] = df_cleaned['price_placeholder']**4
# 固定 `features_poly` 的业务取值与顺序，作为“练习2答案：任务2（多项式模型）”的可复算输入。
features_poly = ['price_placeholder', 'pps2', 'pps3', 'pps4', 'bm_placeholder', 'profitability_placeholder']
# 为四阶多项式规格加入截距列，保留与线性基准相同的常数项。
X_poly = sm.add_constant(df_cleaned[features_poly])
# 提取四阶多项式规格的响应变量，确保与共同最终测试设计的训练行一致。
y_poly = df_cleaned['generated_target']
# 仅用共同训练行拟合四阶多项式规格，最终测试行不参与参数估计。
model_poly = sm.OLS(y_poly.loc[training_rows], X_poly.loc[training_rows]).fit()
polynomial_diagnostics = pd.DataFrame({'指标': ['样本数', 'R²', '调整R²', '残差MSE'], '数值': [int(model_poly.nobs), model_poly.rsquared, model_poly.rsquared_adj, model_poly.mse_resid]})  # 提取投影所需诊断而不输出整页摘要
display(polynomial_diagnostics.round(4))  # 用紧凑表替代会产生内部滚动的完整 statsmodels 摘要
joint_polynomial_test = model_poly.f_test('pps2 = 0, pps3 = 0, pps4 = 0')  # 对预先声明的高次项检验族做联合F检验
print('高次项联合F检验:', joint_polynomial_test)  # 报告整体非线性证据而非逐项筛选p值
# 提取 `r2_poly` 的 R²，限定在同一目标尺度内评价拟合程度。
r2_poly = model_poly.rsquared
# 在共同验证窗计算原始尺度 MSE，把复杂度比较与样本内拟合分开。
mse_poly = mean_squared_error(y_poly.loc[validation_rows], model_poly.predict(X_poly.loc[validation_rows]))
# 报告训练 R² 与同尺度验证 MSE，评估曲率是否带来开发期增量。
print({'多项式训练R²': round(r2_poly, 4), '多项式验证MSE': round(mse_poly, 4), '相对线性验证MSE变化': round(mse_poly - mse_orig, 4)})

# 汇总训练均值与三种候选在完全相同验证窗、原始目标尺度上的 MSE。
validation_mse_table = pd.DataFrame({'规格': ['训练均值基线', '原始线性', '对数', '四阶多项式'], '验证MSE': [mse_training_mean, mse_orig, mse_log, mse_poly]})
# 展示完整验证比较结果，禁止只报告最后赢家。
display(validation_mse_table.round(4))
# 确定候选并列时的简约优先次序，使 tie-break 不受最终测试结果影响。
specification_tie_rank = {'原始线性': 0, '对数': 1, '四阶多项式': 2}
# 仅在三个模型候选中按验证 MSE 与事先确定 tie-break 确定规格。
selected_specification = min(specification_tie_rank, key=lambda name: (dict(zip(validation_mse_table['规格'], validation_mse_table['验证MSE']))[name], specification_tie_rank[name]))
# 在查看测试目标前确定“采用/不采用”，未胜训练均值基线时走基线路径。
adoption_decision = '采用候选' if validation_mse_table.set_index('规格').loc[selected_specification, '验证MSE'] < mse_training_mean else '不采用：未胜训练均值基线'
# 合并开发期索引，只在候选与采用决策确定后用于最终重训。
development_rows = training_rows.append(validation_rows)
if adoption_decision != '采用候选':  # 验证未过门槛时确定开发期均值基线路径
    final_model_name, sealed_predictions = '开发期均值基线', np.repeat(float(y_orig.loc[development_rows].mean()), len(sealed_test_rows))  # 用开发期均值生成最终测试预测
elif selected_specification == '原始线性':  # 线性候选胜出时仅用开发期重拟合
    final_model_name, final_model = '原始线性', sm.OLS(y_orig.loc[development_rows], X_orig.loc[development_rows]).fit()  # 重估确定线性规格
    sealed_predictions = final_model.predict(X_orig.loc[sealed_test_rows])  # 对最终测试末段执行唯一一次预测
elif selected_specification == '对数':  # 对数候选胜出时在开发期重估模型与涂抹因子
    final_model_name, final_model = '对数', sm.OLS(y_log.loc[development_rows], X_log.loc[development_rows]).fit()  # 重估确定对数规格
    sealed_predictions = np.exp(final_model.predict(X_log.loc[sealed_test_rows])) * np.exp(final_model.resid).mean()  # 还原原始目标尺度
else:  # 多项式候选胜出时仅用开发期重拟合事先确定四阶规格
    final_model_name, final_model = '四阶多项式', sm.OLS(y_poly.loc[development_rows], X_poly.loc[development_rows]).fit()  # 重估确定四阶规格
    sealed_predictions = final_model.predict(X_poly.loc[sealed_test_rows])  # 对最终测试末段执行唯一一次预测
# 只在确定规格与不采用路径之后计算一次最终测试 MSE。
sealed_test_mse = mean_squared_error(y_orig.loc[sealed_test_rows], sealed_predictions)
# 报告确定决策、最终路径与唯一测试证据，不据测试结果翻案。
print({'确定候选': selected_specification, '开发期决策': adoption_decision, '最终测试执行路径': final_model_name, '最终测试MSE': round(sealed_test_mse, 4), '高次项联合检验p值': float(joint_polynomial_test.pvalue)})