线性回归

线性回归是最基础的机器学习算法，用来学习特征 $x$ 与目标值 $y$ 之间的线性关系：

$y = w \cdot x + b$

其中 $w$ 是权重（斜率）， $b$ 是偏置（截距）。目标是学出一组 $(w, b)$ ，让模型的预测值尽量接近真实值。

本 notebook 用三种方式实现线性回归，方便对比不同工具的使用方法：

PyTorch 实现：利用自动微分和优化器，快速搭建线性模型
NumPy 从零实现：手动推导并实现成本函数、梯度与梯度下降，理解算法原理
scikit-learn 实现：多项式线性回归，一行代码完成训练

学习目标：看懂每一行代码，理解「建模 → 训练 → 评估 → 可视化」的完整流程。

一、使用 PyTorch 实现线性回归

1. 导入库与基础设置

先导入 PyTorch（张量与神经网络）、NumPy（数值计算）和 Matplotlib（绘图），并设置中文字体避免乱码。torch.manual_seed(42) 与 np.random.seed(42) 固定随机种子，保证每次运行结果一致。

# 用pytorch实现线性回归
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
#pyplot隐式实例化,Matplotlib 在背后自动创建并管理了两个核心对象：画布和子图。
# plt 本身并不是一个 “实例对象”，而是一个 模块（module），它内部维护了一套 “全局状态管理机制”


# 设置中文字体，解决中文显示问题
plt.rcParams["font.family"] = ["SimHei"]
# 解决负号显示问题
plt.rcParams['axes.unicode_minus'] = False # 部分中文字体对 Unicode 负号字符的支持不完善，导致负号无法正确渲染。默认值为 True，表示使用 Unicode 编码的负号（−，U+2212）。
# 设置为 False 后，会改用 ASCII 编码的减号（-，U+002D），这种符号在几乎所有字体中都能正常显示，避免了负号乱码问题。

# 设置随机种子，保证结果可复现
torch.manual_seed(42) #设置后，每次运行程序时，PyTorch 生成的随机数序列会完全相同。
np.random.seed(42) #为 NumPy 库设置随机种子

2. 生成模拟数据

用一个已知的线性关系生成训练数据：

$y = 2.5x + 1.8 + \varepsilon,\quad \varepsilon \sim \mathcal{N}(0, 2^2)$

true_w = 2.5、true_b = 1.8 是”真实参数”，用来验证学习结果
$x$ 是 $[0, 10]$ 之间的 100 个随机点， $y$ 上叠加了高斯噪声，模拟真实世界中”数据不完美”的情况
注意 PyTorch 的广播机制：标量 $b$ 会自动扩展成与 $x$ 相同的形状参与逐元素运算

# 1. 生成模拟数据
# 真实的权重和偏置
true_w = 2.5
true_b = 1.8

# 生成输入数据x,将 NumPy 数组（numpy.ndarray）转为 PyTorch 张量（torch.Tensor）
# torch.tensor 是 PyTorch 中用于创建 “张量（Tensor）” 的基础函数。Tensor是 PyTorch 处理数据的基本单位（类似 NumPy 中的 ndarray）。
# 它不仅能存储数值，还支持 自动微分（反向传播的核心）、GPU 加速计算等深度学习必需的功能 
x = torch.tensor(np.random.rand(100, 1) * 10, dtype=torch.float32)

# 生成带有噪声的目标值y。所有参与运算的元素最终都会统一为 torch.float32 类型的张量。
# 广播机制！形状不匹配但 “兼容” 的张量，能进行 element-wise（逐元素）运算
# yTorch 的广播是「逻辑上的扩展」，不会实际复制数据，只是在计算时 “虚拟地” 将标量的数值应用到每个位置
y = true_w * x + true_b + torch.tensor(np.random.randn(100, 1) * 2, dtype=torch.float32)

3. 定义线性回归模型

nn.Module 是所有 PyTorch 模型的基类。我们的模型内部只包含一个 nn.Linear(in_features=1, out_features=1)：输入一个特征，输出一个预测值，即 $y = wx + b$ 。forward 方法定义前向传播，模型会在训练时自动学习层内的 $w$ 和 $b$ 。

# 2. 定义线性回归模型
# nn.Module 是 PyTorch 中 所有神经网络模型的 “基类”（可以理解为 “模板”），它封装了模型训练所需的核心功能，比如：
#自动管理模型中的可训练参数（如线性回归的 w 和 b）；支持前向传播（forward 方法）的调用逻辑；
# 提供参数初始化、模型保存 / 加载、GPU 迁移等工具函数；配合自动微分（autograd）实现反向传播时的梯度计算。
# nn指神经网络
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        # 定义一个线性层，输入维度1，输出维度1
        self.linear = nn.Linear(in_features=1, out_features=1)
    
    def forward(self, x):
        # 前向传播
        return self.linear(x)

# 实例化模型
model = LinearRegressionModel()

4. 定义损失函数与优化器

损失函数：均方误差（MSE） $J = \frac{1}{n}\sum_{i=1}^{n}(\hat{y}_i - y_i)^2$ ，衡量预测与真实的差距
优化器：随机梯度下降（SGD），学习率 lr=0.01，决定每次参数更新的步长

# 3. 定义损失函数和优化器
# 使用均方误差作为损失函数
criterion = nn.MSELoss()

# 使用随机梯度下降(SGD)作为优化器，学习率0.01
# 每次更新参数前，不从全部样本中计算梯度，而是随机挑选部分样本。后面可以指定选取全部。
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

5. 训练模型

训练循环是深度学习的核心套路，共四步：

前向传播：y_pred = model(x) 得到预测值
计算损失：比较预测与真实
反向传播：loss.backward() 自动计算梯度
参数更新：optimizer.step() 沿负梯度方向更新 $w$ 、 $b$

记得每轮先 optimizer.zero_grad() 清零梯度，避免多次累加。每训练 10 轮打印一次损失和参数，观察收敛过程。

# 4. 训练模型
epochs = 30  # 训练轮次
losses = []  # 记录损失变化
for epoch in range(epochs):
    # 前向传播：计算模型预测值
    y_pred = model(x) # 全量
    
    # 计算损失
    loss = criterion(y_pred, y)
    losses.append(loss.item())
    
    # 反向传播和优化
    optimizer.zero_grad()  # 清零梯度
    # 在 PyTorch 中，当调用 loss.backward() 时，计算出的梯度会自动累加到参数的 .grad 属性中（而不是直接覆盖）
    # 自动累加可以节约显存
    loss.backward()        # 反向传播计算梯度
    optimizer.step()       # 更新参数
    
    # 每100轮打印一次损失和参数值
    if (epoch + 1) % 10 == 0:
        # 获取当前的权重和偏置
        w, b = model.parameters()
        # f-string 是 Python 3.6+ 引入的字符串格式化方式，以 f 或 F 开头，字符串内部通过 {变量/表达式} 嵌入动态内容
        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}, w: {w.item():.4f}, b: {b.item():.4f}')

6. 查看学习到的参数

训练结束后，把学习到的 $w$ 、 $b$ 与真实参数对比。学习率合适时，两者应当比较接近（噪声会让结果有轻微偏差）。

# 5. 输出最终学习到的参数和真实参数
# str.format() 是 Python 中用于字符串格式化的经典方法（适用于所有 Python 3 版本，兼容性比 f-string 更广）。其核心逻辑是：
#先定义一个「带占位符的字符串模板」（占位符用 {} 表示）；
# 调用 format() 方法，传入需要填充到占位符的变量；变量会按顺序（或按占位符名称）替换占位符，生成最终的格式化字符串。
print("\n真实参数: w = {:.4f}, b = {:.4f}".format(true_w, true_b))
w_final, b_final = model.parameters()
print("学习到的参数: w = {:.4f}, b = {:.4f}".format(w_final.item(), b_final.item()))

7. 可视化拟合结果

上图：散点展示原始数据，红色直线展示拟合效果
下图：绘制损失随训练轮次下降的曲线，验证模型确实在收敛

detach() 的作用是把张量从计算图中剥离，再用 .numpy() 转成 Matplotlib 可用的 NumPy 数组。

# 6. 可视化结果
# 生成预测值
# .detach()：将张量从计算图中 “剥离”（PyTorch 的张量默认会记录计算历史用于反向传播），此时后续转换为 NumPy 数组时避免因关联计算图而报错。
# .numpy()：将 PyTorch 张量转换为 NumPy 数组（numpy.ndarray），因为 Matplotlib 绘图（plt）仅支持 NumPy 数组或 Python 基本类型的数据绘图。
y_pred = model(x).detach().numpy()

plt.scatter(x.numpy(), y.numpy(), label='原始数据') #Matplotlib 中绘制散点图的函数，用于展示原始数据的分布。
plt.plot(x.numpy(), y_pred, 'r-', label='拟合直线') #plt.plot：Matplotlib 中绘制线图的函数，用于展示模型的预测结果（拟合直线）。
plt.xlabel('x')
plt.ylabel('y')
plt.title('线性回归拟合结果')
plt.legend() #显示图例（legend）
plt.show()

plt.subplot(2,1 , 2) # 是 Matplotlib 中用于创建子图（Subplot） 的核心函数，作用是在同一个画布（Figure）中划分出多个独立的绘图区域，
#并指定当前要绘制的 “子图位置”。1,2,2指 划分为1行2列,当前操作子图编号2
plt.plot(range(epochs), losses)
plt.xlabel('训练轮次')
plt.ylabel('损失值')
plt.title('损失随训练轮次的变化')
plt.tight_layout()
plt.show()

二、使用 NumPy 从零实现线性回归

1. 导入库与基础设置

与第一部分不同，这里不使用任何深度学习框架，只用 NumPy 手工实现线性回归的每一步，真正理解算法内部发生了什么。

# 用纯numpy实现线性回归
import copy
import math
import numpy as np
import matplotlib.pyplot as plt
# 设置中文字体，解决中文显示问题
plt.rcParams["font.family"] = ["SimHei"]
# 解决负号显示问题
plt.rcParams['axes.unicode_minus'] = False 

2. 生成示例数据函数

generate_sample_data 生成 $m$ 个样本、 $n$ 个特征的多维线性回归数据：

$y = X \cdot w + b + \varepsilon$

返回特征矩阵 $X$ 、目标值 $y$ 以及用于生成数据的”真实参数” $(w, b)$ 。

# 生成示例数据（模拟真实世界的多特征数据集）
def generate_sample_data(m=100, n=3, random_state=42):
    """生成用于测试的样本数据
    
    Args:
        m: 样本数量
        n: 特征数量
        random_state: 随机种子，保证结果可复现
        
    Returns:
        X: 特征矩阵 (m, n)
        y: 目标值向量 (m,)
        true_w: 真实权重，用于生成数据
        true_b: 真实偏置，用于生成数据
    """
    np.random.seed(random_state)
    
    # 生成真实参数
    true_w = np.random.randn(n) * 10  # 随机权重
    true_b = np.random.randn() * 5    # 随机偏置
    
    # 生成特征数据（正态分布）
    X = np.random.randn(m, n)
    
    # 生成目标值，加入一些噪声
    y = np.dot(X, true_w) + true_b + np.random.randn(m) * 2
    
    return X, y, true_w, true_b

3. 成本函数（均方误差）

成本函数衡量当前参数 $(w,b)$ 下模型的表现：

$J(w, b) = \frac{1}{2m}\sum_{i=1}^{m}\left(f_{w,b}(x^{(i)}) - y^{(i)}\right)^2$

分母取 $2m$ 是为了让后续求导更简洁。目标是让 $J$ 尽量小。

def compute_cost(X, y, w, b): 
    """
    计算线性回归的成本（均方误差损失）
    
    Args:
      X (ndarray (m,n)): 输入数据，m个样本，每个样本有n个特征
      y (ndarray (m,)) : 目标值向量
      w (ndarray (n,)) : 模型权重参数
      b (scalar)       : 模型偏置参数
      
    Returns:
      cost (scalar): 计算得到的成本值
    """
    m = X.shape[0]  # 获取样本数量
    cost = 0.0
    
    for i in range(m):                                
        # 计算第i个样本的预测值
        f_wb_i = np.dot(X[i], w) + b          
        # 累加平方误差
        cost = cost + (f_wb_i - y[i])**2       
    # 计算平均成本（除以2m是为了后续求导方便）
    cost = cost / (2 * m)                     
    
    return cost

4. 梯度函数

梯度是成本函数对每个参数的偏导数，指向成本增长最快的方向，负梯度就是下降方向：

一、使用 PyTorch 实现线性回归​

1. 导入库与基础设置​

2. 生成模拟数据​

3. 定义线性回归模型​

4. 定义损失函数与优化器​

5. 训练模型​

6. 查看学习到的参数​

7. 可视化拟合结果​

二、使用 NumPy 从零实现线性回归​

1. 导入库与基础设置​

2. 生成示例数据函数​

3. 成本函数（均方误差）​

4. 梯度函数​

一、使用 PyTorch 实现线性回归

1. 导入库与基础设置

2. 生成模拟数据

3. 定义线性回归模型

4. 定义损失函数与优化器

5. 训练模型

6. 查看学习到的参数

7. 可视化拟合结果

二、使用 NumPy 从零实现线性回归

1. 导入库与基础设置

2. 生成示例数据函数

3. 成本函数（均方误差）

4. 梯度函数