线性回归代码带写：用NumPy从零实现梯度下降

1. 先别急着写代码：2.2 linear到底在解决什么问题

很多学机器学习的朋友都会遇到这样一个场景：翻开某本教材或者打开某个课程的目录，第2.2节赫然写着"linear"（线性回归或线性模型）。讲义上的推导看了三遍，公式也抄下来了，但合上书想自己写一段能跑的代码，脑子里就一片空白。这个标题里的"2.2 linear代码带写"，本质上就是解决这个"公式懂、代码不会"的断层问题。

我接触过不少初学者，面对linear这个知识点时最大的困惑不是"什么是线性回归"，而是"我该怎么从零把它写出来"。查资料时搜到的示例代码，要么直接调sklearn一行搞定，要么就是一个几百行的完整工程文件，根本不知道哪些是核心、哪些是辅助。这种状态下的学习效率是很低的，因为代码一旦被封装起来，你对内部发生了什么就没有感知了。

所以我一直坚持一个观点：像linear这种基础模型，第一次接触时一定要亲手用NumPy从零实现一遍，而不是直接调工具库。这不是说工具库不好，而是说在入门阶段，手写一遍能让你把"模型表达式、损失函数、梯度下降"这条主线完完整整地经历一次。等你亲手把这条主线跑通了，以后看任何框架的线性回归实现，都会觉得非常轻松。

这篇文章就是一个"带写"向的教程。我会带着你从数据准备开始，一行一行把线性回归的核心代码写出来。全程只用NumPy，不调sklearn里的LinearRegression，不调PyTorch或TensorFlow的线性层，就靠python的基础语法和矩阵运算把整个训练流程跑通。文章里每一段代码我都会说明"这一行在干什么""为什么必须这么写""少了它会出什么问题"。

这个教程适合谁？一是正在学机器学习基础、被各种公式搞得头晕的初学者，二是已经会用调库但想弄清内部原理的开发者，三是准备面试、需要手推手写线性模型的求职者。看完之后，你不仅能跑出一个收敛的线性回归模型，还能自己画出损失曲线、验证梯度正确性，甚至顺着这个思路去理解后面的逻辑回归和神经网络。

2. 动手前的三个关键选择：数据、模型与损失函数

写代码之前，必须先把三件事想清楚：用什么样的数据来实验、用什么样的模型表达方式来写、用什么样的损失函数来度量好坏。这三件事决定了代码的整体结构，很多人在这一步草草略过，直接就开始写训练循环，结果后面调试的时候到处出问题。

2.1 准备一份"能讲清楚问题"的实验数据

我见过太多人上来就用UCI或者Kaggle的真实数据集练手。真实数据集当然好，但对于一个刚学线性回归的人来说，它有两个致命的问题：一是数据分布未知，你不知道理想的拟合结果长什么样；二是特征维度多、量纲差异大，一上来就要处理标准化、缺失值之类的麻烦事。所以我建议，带写阶段的第一份数据，应该自己生成。

这里我们用最简单的单变量线性数据：自变量x从-1到1均匀取100个数，对应的y由一条直线加上高斯噪声生成。噪声的作用是模拟真实场景中的随机干扰，让数据不是完美落在直线上，否则我们的模型几乎不需要学习。

python复制import numpy as np

# 固定随机种子，保证每次运行结果一致
np.random.seed(42)

# 生成100个均匀分布的x，范围[-1, 1]
x = np.linspace(-1, 1, 100)

# 真实参数：w = 2.0, b = 1.0
true_w = 2.0
true_b = 1.0

# y = 2x + 1 + 高斯噪声（标准差0.2）
y = true_w * x + true_b + np.random.normal(0, 0.2, size=x.shape)

# 转化成列向量，方便矩阵运算
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)

print(x.shape, y.shape)  # (100, 1) (100, 1)

这里有一个很多新手会忽略的细节：为什么要reshape成列向量？因为后面我们要做矩阵乘法，NumPy对一维数组和二维矩阵的广播规则不一样。如果x保持一维数组，x.shape是(100,)，x和某个(2,1)形状的矩阵相乘时，广播规则会自动给你补维度，但补出来的形状往往不是你想要的那个。统一reshape成(100,1)的列向量，后续所有矩阵运算的维度关系就清晰了。

固定随机种子（seed）也是一个好习惯。噪声是随机生成的，不固定种子的话，你每次运行得到的数据都不一样，复现实验结果的时候就说不清楚了。设了seed之后，无论你跑多少次，生成的x和y都是一份固定的数据。

2.2 模型表达式的两种写法：循环求和还是矩阵运算

线性回归的模型表达式很简单：f(x) = w*x + b。在代码里写出来有两种方式。

第一种是标量循环的方式，把每个样本单独拿出来算一次预测值：

python复制# 初始参数
w = 0.0
b = 0.0

def predict_scalar(x, w, b):
    return w * x + b

这种方式直观，但循环速度慢，而且当特征维度多的时候，代码会变得很长。更关键的是，它和后面梯度下降的向量化更新方式不好衔接。

第二种是矩阵运算的方式，这也是我们实际要用的：

python复制# 把参数矩阵化：W为一维向量，这里只有一个特征
W = np.zeros((1, 1))  # 形状(1,1)
b = np.zeros((1,))    # 形状(1,)

def predict(X, W, b):
    return X @ W + b

这里的X形状是(100,1)，W形状是(1,1)，X @ W的结果是(100,1)，也就是每个样本的预测值。为什么用矩阵乘法而不是直接X * W？矩阵乘法在计算内积/线性组合时是标准操作，后续扩展多元线性回归时，X @ W会自动帮你把特征和权重的对应关系处理好，而逐元素乘法只能用于单特征。

再说损失函数。线性回归最常用的损失函数是均方误差（MSE），公式为：L(w,b) = (1/(2m)) * sum((y_pred - y)^2)。注意，有的地方会写成除以2m而不是m，这是为了后面求导时消掉平方项的系数2，纯粹是数学上的便利，不影响优化结果。

对应的代码：

python复制def compute_loss(y_pred, y_true):
    # 均方误差，注意除以2是为了梯度表达更简洁
    loss = np.mean(0.5 * (y_pred - y_true) ** 2)
    return loss

这里有一个细节：np.mean是在所有样本上取平均，这相当于把公式里的1/m项实现掉了。那么0.5哪来的？就是公式里"除以2m"的2。后面求导的时候你就会看到，0.5和平方项的2正好抵消，梯度表达式会非常干净。

3. 逐行带写核心训练逻辑：从初始化到更新参数

这一节是整个"代码带写"的重点。我们按照"初始化→前向传播→计算损失→反向计算梯度→更新参数→循环"这条标准流程，一步步把训练逻辑写出来。每一行代码我都会拆开讲，确保你不仅能跑通，还能在面试时把这段逻辑清晰地讲给别人听。

3.1 初始化：参数从哪里开始

梯度下降需要一个起点，这个起点就是初始化。对于线性回归来说，初始化通常很简单：权重W设为全0或很小的随机数，偏置b设为0。

python复制# 初始化参数
W = np.zeros((1, 1))  # 权重，形状(1,1)
b = np.zeros((1,))    # 偏置，形状(1,)

# 超参数
learning_rate = 0.1     # 学习率
n_iterations = 1000     # 迭代次数

有很多教程喜欢把W初始化为随机数（np.random.randn），但对于线性回归这种凸优化问题，全0初始化和随机初始化最终会收敛到同一个最优解，区别只是收敛速度略有不同。所以这里用全0初始化，目的是让代码更简单、更可控。

学习率取0.1是我基于这个实验数据范围选择的。我们的数据x在[-1,1]之间，特征值不大，梯度也不会特别大，0.1这个量级通常会稳定收敛。如果x的取值范围变成[0, 1000]，那0.1的学习率可能会导致梯度爆炸，后面我会专门讲这个坑。

3.2 前向传播：计算预测值

前向传播就是让数据通过模型得到预测值，在代码里就是一个函数的事。

python复制def predict(X, W, b):
    Z = X @ W + b
    return Z

这里X @ W + b的形状是(100,1)。注意偏置b的形状是(1,)，当它和(100,1)的矩阵相加时，NumPy的广播机制会自动把b填充成(100,1)，即每个样本都加上同一个偏置。这就是"广播"的典型应用。

用我们初始化好的参数跑一次前向传播，得到的预测值一定是全0，因为W和b都是0。接下来要做的就是让预测值逐步逼近真实y。

3.3 反向计算梯度：这是最容易写错的一步

梯度下降的核心是"通过损失函数对参数的导数，告诉参数该往哪个方向调整"。对于线性回归的MSE损失，梯度可以解析推导，不需要像神经网络那样使用复杂的反向传播算法。但即使如此，代码层面还是有很多人写错。

首先，我们要计算损失对参数W和b的梯度。损失函数为L = (1/(2m)) * sum((y_pred - y)^2)，其中y_pred = X @ W + b。对W求偏导得：dL/dW = (1/m) * X.T @ (y_pred - y)。对b求偏导得：dL/db = (1/m) * sum(y_pred - y)。

这两个公式看起来很简单，但实现时有几个容易出错的点。一是X.T要放在乘法左边，因为我们的约定是"每个样本的影响累加"，X.T @ (y_pred - y)的形状是(1,1)，正好和W形状一致。如果写成(y_pred - y) @ X，形状可能不对或者语义不同。二是除以样本数量m，这在np.mean中已经体现了，所以直接用np.mean会得到1/m的因子。

python复制# 计算预测值
y_pred = predict(X, W, b)

# 计算误差
error = y_pred - y

# 计算梯度（向量化形式）
grad_W = X.T @ error / len(X)
grad_b = np.mean(error)

注意grad_W = X.T @ error / len(X)这一步。X.T形状是(1,100)，error形状是(100,1)，两者点乘得到(1,1)矩阵，除以样本数100后就是真实的梯度值。grad_b那里用np.mean(error)是等价的写法。

我见过很多人在这一步犯的一个典型错误：直接写grad_W = np.mean(X * error)，这在数学上是错的。X * error是逐元素乘法，结果仍是一个(100,1)的向量，再取mean就变成了一个标量，丢失了每个特征对应的梯度信息。在单特征情况下碰巧形状还能对上，但一旦扩展到多特征，这个错误就会导致梯度完全不对。

3.4 参数更新：学习率的角色

拿到梯度之后，参数更新就很简单了：W = W - learning_rate * grad_W，b = b - learning_rate * grad_b。

python复制# 参数更新
W = W - learning_rate * grad_W
b = b - learning_rate * grad_b

这里为什么是减号？因为梯度指向的是损失函数上升最快的方向，我们要找的是下降最快的方向，所以要沿着梯度的反方向走。learning_rate控制的是"每一步走多远"。太小的学习率会让收敛极慢，太大的学习率会让损失值震荡甚至发散，这个trade-off是几乎每个调参教程都会提到的核心问题。

3.5 训练循环：把上述步骤组合起来

把前面所有步骤组合进一个循环里，就是完整的训练流程。

python复制# 记录每轮loss，便于后续画图
loss_history = []

for i in range(n_iterations):
    # 前向传播
    y_pred = predict(X, W, b)

    # 计算损失
    loss = compute_loss(y_pred, y)
    loss_history.append(loss)

    # 计算误差与梯度
    error = y_pred - y
    grad_W = X.T @ error / len(X)
    grad_b = np.mean(error)

    # 更新参数
    W = W - learning_rate * grad_W
    b = b - learning_rate * grad_b

# 查看最终结果
print(f"W: {W.item():.4f}, b: {b.item():.4f}")

我这里的损失是用compute_loss函数计算的，也就是带0.5系数的MSE。每次迭代把loss存到列表里，是为了后面可视化损失曲线。如果你用的是真实数据集，会发现损失曲线下降得不像这里这么平滑，但整体的下降趋势应该是明确的。

运行这段代码，你会得到类似W: 1.9887, b: 0.9974的结果。真实值是w=2.0, b=1.0，差距非常小。这个差距主要来自噪声的影响，而不是模型没学到位。把它放到预测函数里，对新的x做预测，就能看到一条接近原始数据的直线。

注意：这里每轮都全量计算所有样本的误差，属于批量梯度下降（Batch Gradient Descent）。学习率在这种全量计算下可以选择相对大一些，因为梯度的方向是全样本的"共识方向"，噪音较小。

3.6 完整代码汇总

为了避免读者复制散落各处的代码片段，我把完整的带写版代码整理出来，你可以直接保存为一个python脚本运行：

python复制import numpy as np

# 1. 生成实验数据
np.random.seed(42)
x = np.linspace(-1, 1, 100)
y = 2.0 * x + 1.0 + np.random.normal(0, 0.2, size=x.shape)
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)

# 2. 模型与超参数
W = np.zeros((1, 1))
b = np.zeros((1,))
learning_rate = 0.1
n_iterations = 1000

def predict(X, W, b):
    return X @ W + b

def compute_loss(y_pred, y_true):
    return np.mean(0.5 * (y_pred - y_true) ** 2)

# 3. 训练循环
loss_history = []
for i in range(n_iterations):
    y_pred = predict(X, W, b)
    loss = compute_loss(y_pred, y)
    loss_history.append(loss)

    error = y_pred - y
    grad_W = X.T @ error / len(X)
    grad_b = np.mean(error)

    W = W - learning_rate * grad_W
    b = b - learning_rate * grad_b

    if i % 100 == 0:
        print(f"Iteration {i}: loss = {loss:.4f}, W = {W.item():.4f}, b = {b.item():.4f}")

print(f"Final: W = {W.item():.4f}, b = {b.item():.4f}")

4. 跑通不代表学会：三类检查让代码真正可靠

代码跑完、看到损失下降了，很多人就觉得自己已经会了。但说实话，"跑通"和"学会"之间还有一段距离。我在带新人的时候，一定会让他们做三类额外检查，每一类都能暴露出不同的隐藏问题。这里也分享给大家。

4.1 检查一：损失曲线判断学习率是否合理

损失函数的值在训练过程中应该快速下降，然后逐渐收敛到一个平稳值。如果你画出loss_history，正常情况下应该是一条单调递减、最后趋于水平的曲线。

python复制import matplotlib.pyplot as plt

plt.figure(figsize=(8, 5))
plt.plot(range(n_iterations), loss_history)
plt.xlabel("Iteration")
plt.ylabel("Loss")
plt.title("Loss Curve")
plt.grid(True)
plt.show()

这三个典型情况对应不同的调参方向：

在刚才的实验里，学习率0.1得到的损失曲线是平滑下降的，说明这个学习率选得合理。如果你换一组数据，x的取值范围变成[0, 10000]，同样的学习率很可能直接导致损失发散到几百万，因为梯度被放大了好几个数量级。这就是数据缩放重要的原因之一。

4.2 检查二：数值梯度验证手写梯度是否正确

手写梯度最大的风险是公式抄错或维度写错。一旦梯度算错，训练也能跑，但结果会越跑越偏。很多同学遇到这类问题，看半天代码发现不了bug。这时候最有效的验证手段就是数值梯度（Numerical Gradient）。

数值梯度的思想很简单：直接按导数的定义去逼近，即把参数微调一点点，看损失函数变化了多少，并用这个变化量近似梯度：

python复制def numerical_gradient(X, y_true, W, b, epsilon=1e-6):
    # 对W的数值梯度
    grad_W_num = np.zeros_like(W)
    for i in range(W.shape[0]):
        for j in range(W.shape[1]):
            W_plus = W.copy()
            W_minus = W.copy()
            W_plus[i, j] += epsilon
            W_minus[i, j] -= epsilon

            loss_plus = compute_loss(predict(X, W_plus, b), y_true)
            loss_minus = compute_loss(predict(X, W_minus, b), y_true)
            grad_W_num[i, j] = (loss_plus - loss_minus) / (2 * epsilon)

    # 对b的数值梯度
    grad_b_num = np.zeros_like(b)
    for i in range(b.shape[0]):
        b_plus = b.copy()
        b_minus = b.copy()
        b_plus[i] += epsilon
        b_minus[i] -= epsilon

        loss_plus = compute_loss(predict(X, W, b_plus), y_true)
        loss_minus = compute_loss(predict(X, W, b_minus), y_true)
        grad_b_num[i] = (loss_plus - loss_minus) / (2 * epsilon)

    return grad_W_num, grad_b_num

然后在训练前用初始参数调用一次，和解析梯度对比：

python复制grad_W_num, grad_b_num = numerical_gradient(X, y, W, b)
y_pred = predict(X, W, b)
error = y_pred - y
grad_W_analytic = X.T @ error / len(X)
grad_b_analytic = np.mean(error)

print("数值梯度 W:", grad_W_num.ravel())
print("解析梯度 W:", grad_W_analytic.ravel())
print("数值梯度 b:", grad_b_num.ravel())
print("解析梯度 b:", grad_b_analytic.ravel())

如果两个结果在小数点后4位内匹配，说明你的解析梯度就是对的。这里用(2 * epsilon)做成中心差分（Central Difference），比单侧差分(f(x+eps)-f(x))/eps的精度要高一个量级，也是业界做梯度检查的标准做法。

提示：数值梯度验证在深度学习框架中也有内置实现，比如PyTorch的torch.autograd.gradcheck。但原理和我们这里写的一模一样，就是把解析梯度和数值梯度做对比。学会这个小工具，对后面学习任何手写模型都有帮助。

4.3 检查三：与解析解对比，确认模型已经收敛到全局最优

线性回归有一个不需要迭代的解析解——正规方程（Normal Equation）：W* = (X.T X)^{-1} X.T y。这个公式可以直接算出使得损失最小的参数。

当然前提是加偏置项。注意我们上面的模型表达式只有X @ W + b，严格来说正规方程形式应该是构造增广矩阵[X, 1]，然后对X_aug做计算：

python复制X_aug = np.hstack([X, np.ones((len(X), 1))])  # (100, 2)
W_star = np.linalg.pinv(X_aug.T @ X_aug) @ X_aug.T @ y
print(f"正规方程解: W = {W_star[0].item():.4f}, b = {W_star[1].item():.4f}")

正规方程的结果理论上就是全局最优解。你可以拿我们训练出来的W和b跟它对比，差距如果在0.01以内，说明梯度下降确实收敛到了正确的解附近。这个检查能直接证明你的训练逻辑没有问题，而不是"看起来差不多"。

这里我用np.linalg.pinv而不是np.linalg.inv，是因为伪逆（pinv）在矩阵不可逆时也能给出一个最小二乘解，更稳健。

5. 从2.2 linear延伸出去：下一步的扩展方向

写完单变量线性回归之后，这个技能不应该停留在"我会写一个简单示例"的层面。它是一块基石，接下来可以往很多方向延伸。我挑几个最实用的方向讲讲，每个都可以作为你下一个练手项目。

5.1 多元线性回归与特征工程

单变量线性回归的代码改成多元版本，核心代码基本不用动。假设有3个特征，那么X的形状从(100,1)变成(100,3)，W的形状从(1,1)变成(3,1)。predict函数里的X @ W + b依然成立，grad_W = X.T @ error / len(X)也保持不变。

也就是说，你写的这段代码天然支持多元特征，因为矩阵运算把特征的维度内化掉了。这是向量化的最大好处。真正需要额外考虑的是特征标准化（Standardization）。当特征量纲差异很大时，梯度下降对W各个分量的更新速度会严重不一致，导致收敛缓慢。解决方式是对每个特征做标准化：

python复制def standardize(X):
    mean = np.mean(X, axis=0)
    std = np.std(X, axis=0)
    # 防止除零
    std[std == 0] = 1
    return (X - mean) / std, mean, std

在训练前调用standardize，训练得到参数后，对新样本做预测时也要用训练时的mean和std做同样的变换。这个细节如果忘了，模型在新数据上的表现会一塌糊涂。

5.2 从线性回归到逻辑回归：损失函数的变化是关键

线性回归做的是回归任务，预测连续值。如果任务变成了二分类，比如判断一封邮件是否为垃圾邮件，那就不能直接用线性回归了，因为它的输出值域是整个实数域。这时需要在线性回归的基础上加一个Sigmoid函数，把输出压缩到(0,1)之间，并换成交叉熵损失。整个过程其实和线性回归的代码结构非常像：前向传播、计算损失、反向计算梯度、更新参数。

很多人学逻辑回归觉得难，是因为把它当成新知识从零学起。实际上如果你把线性回归吃透了，逻辑回归只需要改三个地方：模型输出加Sigmoid、损失函数换成交叉熵、梯度公式跟着损失变化。代码结构几乎一模一样。这也是为什么我说第2.2节的linear一定要亲手写一遍的原因——它后面几乎所有的分类模型都在复用这套训练骨架。

5.3 从线性模型到神经网络：参数的矩阵化思想

神经网络的最基本单元——全连接层（Fully Connected Layer）——本质上就是"多个线性变换的组合再加上非线性激活函数"。一个全连接层的数学表达是Z = WX + b，和我们这里的predict函数完全一致。只是W从(1,1)或(3,1)变成了(输入维度, 输出维度)的矩阵，X从单个样本的向量变成了批量样本的矩阵，中间穿插了激活函数。

当你在写线性回归时理解了"X @ W"是在做特征线性组合，那你在看神经网络中的矩阵乘法时，就不会觉得它是什么神秘的东西。它就是在多个输出神经元上重复做线性组合。

如果你想继续深入，可以试着把单变量线性回归扩展成一个简单的单层神经网络，激活函数用线性激活。你会发现它的训练效果和线性回归完全等价，但代码写法已经完全不同——这个对比能帮你理解框架到底帮你做了什么、没做什么。

参考图：完整代码和输出效果

这里把最终的预测效果和真实数据点放在同一张图上，可以看到拟合直线穿过了数据点分布的中间区域，这正是线性回归的直观效果：

python复制plt.figure(figsize=(8, 5))
plt.scatter(x, y, alpha=0.7, label='Data points')
plt.plot(x, W.item() * x + b.item(), color='red', linewidth=2, label='Fitted line')
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.grid(True)
plt.show()

在拟合直线那一行代码中，W.item()的作用是把形状为(1,1)的矩阵提取成标量，便于直接和x做逐元素乘法，这是NumPy中一个很实用的小细节。如果你不转成标量，直接用W * x，会因为形状不匹配触发广播规则，虽然结果可能对，但可读性很差。

我在实际带写过程中发现，80%的学员做完这步后都很有成就感，因为一个"能自己控制的模型"从无到有地跑通了。剩下的20%会遇到各种奇怪的问题，比如损失不减反增、维度不匹配、画图报错。这些问题几乎都能从前面提到的三类检查中找到线索。

最后再分享一个小技巧：如果你不小心把学习率调得太大，导致损失发散，先不要急着改代码。把learning_rate打印出来看一眼，然后用10的倍数一点点缩小，直到损失曲线重新变得平滑下降。这个方法我用了很多年，虽然听起来很笨，但在调参阶段比任何理论计算都管用。