1. 训练闭环的整体拆解
1.1 核心需求解析
先说结论再展开：本文要完成的目标，是仅用随机梯度下降（SGD）这个优化算法，配合手写的数据迭代器、线性模型和损失函数，把一份随机生成的合成数据训练成一个可用的线性回归模型。整个流程不借助任何深度学习框架的自动求导和预置层，从数据加载到最后一次参数更新，全部自己动手实现。
李沐的《动手学深度学习》里，线性回归这一章分为“从零开始实现”和“简洁实现”两个版本。很多人跳过前者直接看后者，觉得框架封装好了一切，没必要重复造轮子。我的建议恰恰相反：正是因为后面要学多层感知机、CNN、Transformer，你才必须在最简单的地方把训练闭环的每个环节跑通。线性回归是这个闭环最纯净的载体，没有任何卷积、注意力、归一化等复杂操作的干扰，所有注意力都能集中在“数据-模型-损失-优化器-迭代”这条主线上。
这套训练闭环到底解决什么问题？拿实际场景来说：你想预测明天某个商品的销量，手里有历史价格、促销力度、天气等特征，销量就是标签。线性回归假设销量和各特征之间存在线性关系，训练闭环要做的，就是通过反复迭代找到一组权重，让预测销量尽可能接近真实销量。本文的代码虽然用的是合成数据，但训练流程和真实业务场景完全一致，弄懂它，之后换任何真实数据集、换任何模型，主干代码都不用大改。
适合谁来读？刚入门机器学习、学过Python基础但没系统看过PyTorch或TensorFlow源码的人，这里讲透之后你再看框架封装好的Linear层，一眼就能看穿它内部在做什么。有一定基础但习惯调包的人也可以看看，很多“loss不降”“梯度爆炸”的框架报错，理解了手写版本之后会更容易定位。
1.2 为什么线性回归是理解深度学习的最佳入口
深度学习看起来花哨，但无论模型复杂到什么程度，最底层的训练逻辑始终是四件事：定义模型、定义损失、定义优化器、循环更新参数。线性回归恰好把四件事都压缩到了最简。
模型：y = Xw + b，一个矩阵乘法加一个偏置，没有激活函数，没有通道数概念，没有时间步长。损失：平方损失，预测值和真实值的差的平方，求导之后得到的是简单的线性表达式。优化器：SGD，参数朝梯度反方向挪一小步。循环迭代：固定epoch数跑完所有批次，更新一轮权重。
四件事全部透明可解释。矩阵乘法的每一行输出代表什么，损失函数的梯度是如何传到每个参数上的，学习率调大调小会造成什么后果，这些东西在复杂模型里很难直接观察，但在线性回归里，你可以手动把计算过程展开，甚至自己拿笔算一遍梯度。
这就像学开车先开手动挡，换挡逻辑、离合配合、转速判断全都要自己来一遍，虽然繁琐，但动力传递的每个环节都刻进肌肉记忆了。直接上自动挡确实省事，可一旦遇到爬坡、超车、变速箱故障，你根本不知道问题出在哪儿。深度学习也是如此，张量堆叠得太高，很多人连梯度在哪里断的都不知道。
1.3 纯手写与调库的边界
“从零开始”并不等于不用任何库，numpy、matplotlib这些基础工具还是必要的，没人要求你从比特层面自己实现张量运算。这里所说的手写边界，指的是不用深度学习的自动微分和模型封装，也就是说，不调用torch.nn.Linear，不调用loss.backward()和optimizer.step()，梯度计算、参数更新全部手写。
这个边界的设定非常合理。数据张量化和矩阵乘法让numpy来做，效率和可读性都很好，而且numpy的广播机制本身就是理解深度学习张量运算的基础。但模型的权重初始化、前向传播计算、损失值计算、梯度公式推导、参数更新公式，这些全部要自己写代码实现。
自己在纸上把梯度的解析式推导出来，再把这个解析式翻译成Python代码，这一步做完，你对“反向传播”这个看似玄学的概念会有非常具体的认识。它不过是链式法则的工程化实现，在线性回归里甚至不需要复杂的链式法则——损失对w的梯度就是2 * X.T.dot(X.dot(w) + b - y) / n这样的显式公式。亲手写完这个公式再跑训练，后面看框架自动求导也只是觉得它替你做了体力活，不会再觉得那是黑魔法。
2. 数据准备与批量加载
2.1 合成数据生成的逻辑
线性回归的数据集生成方式，书中给出了标准模板：先设定真实的权重w_true和偏置b_true，再生成随机特征矩阵X，用线性公式算出理想输出，最后加上服从正态分布的噪声模拟真实世界的观测误差。
import numpy as np import matplotlib.pyplot as plt def synthetic_data(w, b, num_examples): """生成 y = Xw + b + 噪声 的合成数据集""" X = np.random.normal(0, 1, (num_examples, len(w))) y = np.dot(X, w) + b y += np.random.normal(0, 0.01, y.shape) return X, y.reshape((-1, 1)) w_true = np.array([2, -3.4]) b_true = 4.2 num_examples = 1000 X, y = synthetic_data(w_true, b_true, num_examples)特征矩阵X的每列是一个特征，每行是一个样本，这里设了两个特征，所以X的形状是(1000, 2)。w_true是二维向量，点积之后得到(1000,)的一维数组，这就是每个样本的线性预测值。加上b_true之后整体平移，再叠加噪声，最终得到带随机误差的y值。
np.random.normal(0, 0.01, y.shape)这行表示噪声均值0、标准差0.01。噪声标准差设得很小，是为了让数据既不完全线性（避免训练过程过于顺利），又让真实参数可以被算法恢复出来。如果噪声设太大，比如5.0，数据点会分散得很厉害，恢复出的参数和真实值的偏差也会很大，初学者容易误以为算法出了问题。
这里有一点容易被忽略：y的初始形状是(1000,)一维数组，reshape成(1000, 1)变成二维列向量，是为了后续和矩阵运算的形状规则对齐。在深度学习中，一切数据都应该显式地保持“样本数 × 特征数”的二维约定，不要依赖numpy的隐式广播去做你想当然的运算，这是后期排查形状报错的好习惯。
2.2 数据迭代器的实现
训练模型不能一次性把所有数据喂进去，原因后面第4章会详细说，这里先实现批量读取的机制。核心需求是：把每个epoch里的数据随机打乱，然后按固定batch大小切分成若干批，每批返回一组特征X_batch和标签y_batch。
def data_iter(batch_size, features, labels): num_examples = len(features) indices = list(range(num_examples)) np.random.shuffle(indices) for i in range(0, num_examples, batch_size): batch_indices = np.array(indices[i: min(i + batch_size, num_examples)]) yield features[batch_indices], labels[batch_indices]这个函数用了生成器（yield）的写法，每次调用返回下一批数据，而不是一次性把所有批次全部生成出来放进内存。epoch的概念在这里就体现为：完整遍历一遍数据集的全部批次，称为一个epoch。外层训练循环每循环一次，就会重新调用一次data_iter，重新打乱数据顺序，再按顺序切出不同批次。
打乱顺序这个操作看似多余，但非常重要。如果数据本身按照某个特征排序过，不打乱就按顺序切批次，会让相邻的样本高度相关，梯度更新方向会有系统性偏差。比如数据按销量从低到高排列，每个batch里的样本销量都很接近，模型在不同batch上学到的模式就会互相冲突，训练过程容易震荡。打乱之后每个batch都能尽量代表整体分布，梯度估计更接近真实梯度。
这里边界情况的处理值得一提：min(i + batch_size, num_examples)保证最后一个batch的样本数不足batch_size时不会越界。numpy的索引传入一个整数数组，返回的是按需挑选的有序行，这个操作等价于PyTorch里features[batch_indices]的索引方式。
2.3 每批数据量对训练的影响
batch_size不是随便设的，它是训练动态的核心参数。设得太大，每个batch的数据量接近全集，梯度方向稳定、收敛平稳，但每轮参数更新的次数太少，总迭代次数变少，训练耗时反倒不一定短。设得太小，每次更新方向抖动剧烈，模型不容易稳定收敛，但更新次数多，如果数据本身噪声小，实际效果反而可能不错。
极端情况值得感受一下：batch_size设为1，就是纯随机梯度下降，每次用一个样本更新参数，更新方向非常不稳定。batch_size设为数据集大小，就是批量梯度下降，每次用全部数据计算梯度，更新最稳但计算代价最高。现实中用得最多的还是mini-batch梯度下降，batch_size在16到256之间居多，本质是折中方案。
这里需要反复提醒自己的是：梯度方向、损失函数的计算方式、数据迭代的组织方式，三者是耦合在一起的。手写代码的每个环节之间没有框架层面的隔离，任何一个环节出错，整个训练都会以不易察觉的方式跑偏。所以接下来实现模型和损失函数时，每一步都要保证形状、数值可验证，才能让整个闭环跑得稳。
3. 模型定义与损失函数
3.1 手写线性层的实现
一个线性层要做的计算极其简单：输入矩阵乘以权重矩阵，再加上偏置。在PyTorch里这是nn.Linear封装好的，几行代码就能调用，但这里我们自己实现。
def linreg(X, w, b): """线性回归模型""" return np.dot(X, w) + b注意这里的维度关系。X形状为(batch_size, 2)，w形状为(2, 1)，点积结果为(batch_size, 1)，加上标量b则通过广播机制对每个样本生效。w为什么设计成(2, 1)而不是(2,)？因为线性层的输出通常习惯保持一个二维形状（样本数, 输出维度），方便后续和其他层拼接，也为损失函数的形状匹配做准备。
权重初始化放在模型定义之前的独立环节，使用均值为0、标准差为0.01的正态分布随机数。这组初始值的选择有讲究：不能全部初始化为0，否则所有特征的梯度在初始阶段完全一样，模型学不到东西；也不能初始化为太大，否则初始loss会非常大，梯度更新的第一轮就可能让参数飞到失控区域。标准差0.01的经验值源自深度网络对“小随机数初始化”的偏好，在线性回归上同样适用。
w = np.random.normal(0, 0.01, (2, 1)) b = np.zeros(1) # 偏置初始化为0偏置可以初始化为0，因为模型总能通过后几轮的梯度更新自动学出合适的偏置值，对称性问题只在所有权重都为0时才会体现，偏置单独为0并不会引发对称困境。
3.2 广播机制和矩阵乘法
广播机制是理解这段代码的关键，也是排查报错的高频坑点。numpy计算X.dot(w) + b时，如果b是一个标量，那么矩阵每个元素都加上b，这很直观。真正容易出错的是b是形状为(1,)的数组时和(batch_size, 1)矩阵相加，numpy按维度对齐规则把b扩展成(batch_size, 1)后再相加。
这种隐式扩展大大简化了代码，但也带来隐患。如果w的形状不对，比如写成(2, )而不是(2, 1)，np.dot(X, w)返回形状是(batch_size,)的一维数组，和(batch_size, 1)的y做差值运算时，numpy会因为形状不同触发更复杂的广播，结果得到(batch_size, batch_size)的矩阵。这种错误不会报异常，但loss计算就完全错误了。
实际操作中一个非常有效的自查方法：每个核心函数写好之后，先用小规模数据手动验证一次。比如取3个样本、2个特征，自己用纸笔算出期望的前向输出，再用代码跑一遍对比。宁可在这个环节多花5分钟，也不要等到整个训练循环跑完才发现损失值大得离谱还不明所以。
另外，Python的numpy点积对二维矩阵和一维向量的运算规则确实容易搞混，我的习惯是在实现任何矩阵运算时先打印.shape确认预期形状，这个习惯在后面积累更多层之后会节约大量排查时间。
3.3 平方损失函数的含义
平方损失（L2 Loss）是回归任务最常用的损失函数，公式为1/2 * (y_pred - y_true)^2的均值。为什么前面加1/2？主要原因在于求导时的化简便利：平方的导数乘以1/2之后恰好为(y_pred - y_true)，形式上更简洁。这只影响损失值的缩放，不影响参数更新的方向。
def squared_loss(y_hat, y): return np.mean((y_hat - y) ** 2) / 2这里使用np.mean对整个batch求均值，得到的损失值是一个标量。这样做的好处是，无论batch_size设成多大，损失值始终处于同一数值范围，学习率的设定不会因为batch_size变化而失效。如果不做均值而做求和，batch_size翻倍后损失值也会大致翻倍，梯度也翻倍，同样学习率下的更新步长相当于翻倍，训练动态会完全被破坏，这是很多自己写训练循环的新手遇到的问题。
为什么回归任务普遍用平方损失而非绝对误差损失？因为平方函数在误差接近0时导数为0，模型在接近预测准确时更新幅度减缓，对已经是正确方向的参数不会过度修正。而绝对误差的导数在0点不可导，在远离0点的地方导数恒定，模型对任何误差的惩罚力度都一样，收敛明显更慢，还容易在最优解附近来回震荡。
如果故意把损失函数换成绝对误差再看看训练表现，会明显感觉到loss曲线下降更慢、末端有锯齿状波动——这个对比实验强烈建议自己做一次，它能让你对损失函数的选择如何影响优化过程有直观认知。
4. 优化器与参数更新
4.1 SGD的原理与一种直觉类比
随机梯度下降做的事情就是：每次根据一个batch的梯度，把参数向梯度相反方向移动一小步。为什么是反方向？梯度的数学含义指向函数值上升最快的方向，想让损失函数变小，自然要朝反方向走。
用一个调音台的类比：假设你在调一台设备的音量旋钮，让它输出的音量和目标音量一致。你听到现在音量太高，就会往低的方向拧一点；太低就往高的方向拧一点。每一次的“判断+调整”就是一次梯度更新，“听到偏差”对应的是计算损失和梯度，“拧一点”对应的是参数更新，而“一点”具体是多少则完全由学习率控制。
def sgd(params, grads, lr, batch_size): num_examples = params[0].shape[0] if len(params) > 0 else 1 for param, grad in zip(params, grads): param[:] = param - lr * grad / batch_size4.2 梯度为什么要除以batch_size
上一章损失函数里用了均值归一，但梯度计算时还需要显式除以batch_size，这个细节集中于一个容易被忽略的问题：我们对每个样本独立计算梯度，累加之后除以batch_size得到平均梯度。
手写SGD的参数更新公式写成param - lr * grad / batch_size，把除法放在更新这一步。很多初学者会疑惑：损失都已经取过均值了，为什么梯度还要再除以batch_size？原因在于梯度的链式结构——线性模型的前向传播是有batch这个维度的，损失对每个参数的梯度是各个样本梯度之和，不管你在损失函数里是否对均值做过归一化，只要代码实现累加梯度时没有平均化，更新时都需要手动补上这个除法。
在PyTorch等框架里，loss.backward()会根据梯度累加到.grad参数字段中，而官方实现里一般会在优化器step()时实现归一化逻辑。这里我们把归一化显式写进SGD函数，和框架行为保持等价。如果漏掉这个除法，batch_size从32换成64，梯度幅值会翻倍，同样的学习率在64的batch下参数更新幅度相当于32的两倍，训练轨迹立刻失控。
4.3 学习率选择的经验法则
学习率是训练闭环里最敏感的超参数，没有之一。学得太小，收敛极慢，跑几百轮loss还在缓慢下降；学得太大，loss直接发散，曲线坐上火箭一样往上飙。在线性回归这个简单模型上，学习率从0.01到0.1基本都能接受，但换成0.5以上就会看到loss曲线变成锯齿状大幅震荡甚至爆炸。
实际调参我习惯这样操作：先从0.1开始跑，观察前几轮loss下降速度。如果loss在前面3个epoch内从个位数下降到0.1以内，说明学习率还没把训练推得太激进，可以继续观察；如果loss在前几轮就出现反弹，直接除以10重来。如果前几轮loss下降得过慢（比如从10只降到9），可以乘以2倍或5倍试试。
有个常被忽略但非常实用的技巧：每一轮epoch结束后打印出当前权重向量w，和真实权重w_true对比。线性回归最大的浪漫在于我们提前知道正确答案，所以训练过程中可以直接观察模型找参数的过程。你会发现权重从初始的零附近一路逼近真实值，方向和速度一目了然。这比单纯监控loss数值更能反映训练状态，loss因为数据噪声可能一直在小幅震荡，权重的收敛轨迹却稳定得多。
5. 训练循环与结果可视化
5.1 完整训练循环的三段式
训练循环看起来简单，但里面每个细节都有它存在的理由。完整代码框架如下：
lr = 0.03 num_epochs = 10 net = linreg loss = squared_loss for epoch in range(num_epochs): for X_batch, y_batch in data_iter(batch_size, X, y): # 前向传播计算预测值 y_hat = net(X_batch, w, b) # 计算损失 l = loss(y_hat, y_batch) # 手动计算梯度 grad_w = np.dot(X_batch.T, (y_hat - y_batch)) / batch_size grad_b = np.mean(y_hat - y_batch) # 更新参数 sgd([w, b], [grad_w, grad_b], lr, batch_size) # 当前epoch结束后的训练损失 train_loss = loss(net(X, w, b), y) print(f'epoch {epoch + 1}, loss {float(train_loss):.6f}')整个循环分成三层结构：外层按epoch遍历，中层按batch遍历，内层完成前向、反向、更新的三步骤。这种嵌套结构此后会一直陪伴你，无论网络深到何种程度，训练主循环都是这个骨架，变的只是forward函数和梯度函数的内容。
epoch这个概念的物理意义是“完整看了一遍数据”。设10个epoch，意味着模型从头到尾把1000条数据各看10遍。为什么不能只看一遍？因为每个batch的数据信息有限，单个batch只能给一个粗略的梯度方向，只有反复遍历数据，让每个样本对权重的贡献被多次累加，模型才能真正学到整体规律。
5.2 手写梯度时需要注意的坑
手动计算梯度如果直接用公式硬算，很容易出现形状不匹配。上面代码里grad_w的公式是np.dot(X_batch.T, (y_hat - y_batch)) / batch_size，这里X_batch.T从(32, 2)变成(2, 32)，y_hat - y_batch形状是(32, 1)，点积结果形状为(2, 1)，恰好和w保持一致。这个公式的含义是：每个特征对损失的贡献按样本求和再取平均。
grad_b则简单得多，直接对残差向量取均值。因为偏置的梯度在损失函数中对应的是对所有样本的残差求和，除以样本数即可。
需要注意的坑有两个。第一是损失函数里已经做了/2，梯度计算时不会再有/2系数，因为平方函数求导是2乘以残差，恰好和1/2约掉——这也是前面说1/2是为了求导简洁的验证。第二是参数更新的写法，必须原地修改（param[:] = ...），不能写成param = param - ...。前者直接修改传入数组引用的内存内容，后者只是把局部变量指向新数组，外部传入的权重根本不会更新。这个错误极其隐蔽，损失值会一直不降，因为每轮参数其实从未动过。
5.3 绘制loss曲线与拟合结果
训练结束后，第一步是检查学到的参数和真实参数的距离。对应前文的w_true为[2, -3.4]，b_true为4.2，训练得到的w应该非常接近[2, -3.4]，b则非常接近4.2。数值上误差通常控制在0.01以内，如果超出这个范围，优先检查噪声标准差是否设得过大，或者学习率、epoch数是否不足。
更直观的验证方式是把预测结果画出来。取若干样本点，在同一坐标系里绘制真实数据点和模型预测点，如果二者基本重合，说明线性模型确实学到了数据生成过程中的线性规律。另一种方式是画残差图，横轴是真实值，纵轴是预测值减真实值的残差，如果模型拟合得好，残差点会均匀分布在零轴附近，没有明显的趋势或弯曲。
loss曲线同样值得仔细看。正常收敛的曲线应该是前几个epoch快速下降，随后下降速度放缓，变成平滑的尾段。如果曲线在后期仍然大步震荡，说明学习率偏大或batch_size偏小；如果曲线下降得异常平缓、没有明显的指数式衰减，那可能是数据没有归一化或学习率偏小。学会看loss曲线形状，对之后调试复杂的模型至关重要。
6. 常见问题、排查技巧与经验沉淀
6.1 训练不收敛时排查的顺序
线性回归这种简单模型训练不收敛，十有八九是代码错误而非算法问题。我的排查顺序严格按照可疑度从高到低排列：
第一，检查梯度形状。打印grad_w.shape和w.shape，如果形状不匹配，param[:] = param - ...会直接报错，这个比较容易发现。更隐蔽的是numpy的广播把形状错误掩盖掉了，结果是训练不报错但loss不降，这时务必手动核对张量形状。
第二，检查参数是否原地更新。在更新代码前后分别打印w的值，如果完全相同，说明更新没生效。把param = param - ...改成param[:] = ...即可。
第三，检查数据迭代是否正确。手动调用一次data_iter，确认返回的X_batch和y_batch长度一致，确认每个epoch都能把全部样本覆盖一遍。如果索引逻辑写错，某些样本永远不被模型看到，训练结果会偏向数据的一部分。
第四，检查学习率是否过小或过大。这个前面已经提过，用从大到小试探的策略快速定位合适区段。
6.2 数据标准化到底什么时候需要
合成数据里特征本身服从标准正态分布，不存在量纲差异问题。但换成真实数据后，比如预测房价，面积特征的取值范围可能是50-200平米，房龄可能是0-30年，周边学校数量可能是0-15个。数值范围大的特征在梯度计算中天然占据主导地位，模型会偏向于调整对应权重来减小损失，范围小的特征对更新的贡献被淹没，最终模型对不同特征的学习速度差别巨大。
处理方案是特征标准化，常用z-score方法：每个特征减去自身均值再除以标准差，让所有特征都分布在0附近、尺度统一。标准化前后的训练效果差异在真实数据上往往非常明显：标准化前loss的曲线又长又震荡，标准化后短时间内就收敛。
在线性回归的场景里，标准化还有一层额外的可解释性优势：标准化后的权重绝对值可以直接比较特征重要程度，某个特征的权重越大，对应的特征对预测结果的线性影响就越强。这个解读在真实业务场景里非常实用，是线性回归优于一堆黑箱模型的核心原因。
6.3 推荐尝试的验证实验组合
从零实现的最大好处在于可以随意做实验，验证自己对训练机制的理解。这里分享几组我做过且收获很大的实验组合，每个组合改动一处变量，其余保持不变，对比结果往往让人印象深刻。
实验一：修改batch_size，分别用1、32、1000跑同样的数据。batch为1时loss曲线震荡剧烈，权重的收敛方向摇摆不定；batch为32时曲线平滑，收敛稳健；batch为1000时每一步都很稳但更新次数少，最终需要更多epoch才能达到同等精度。直观感受下三种更新策略的差别，比背概念有效得多。
实验二：修改学习率，跑0.003、0.03、0.3三组。0.003时loss下降慢如蜗牛，跑10个epoch还在原地徘徊；0.03时平滑收敛，参数逼近真实值；0.3时loss大概率呈现先降后升的典型发散形态，训练动画里会看到参数在真实值附近来回横跳，越跳越远。
实验三：修改噪声标准差，设0.01、1.0、5.0。噪声为0.01时参数几乎可以精确恢复；噪声为5.0时loss的最终值很高，权重和真实值偏差也大，但这并不是训练错误，而是数据本身的可学习信息变少了。这个实验让人深刻理解偏差-方差权衡的直觉含义：信噪比低的数据，再厉害的线性模型也压不住误差。
6.4 从线性回归过渡到复杂模型的承接点
训练闭环的手写经验是理解复杂模型的通用基础设施。后面遇到多层感知机时，你要做的不过是在前向函数里加几个矩阵乘法和激活函数，在反向梯度计算里加几层链式法则，数据迭代、参数更新、训练循环结构一概不变。遇到卷积神经网络时，数据迭代从二维变四维张量，模型从全连接到卷积层，但训练闭环的骨架依然原样保留。
值得特别留意的是，从手写线形回归到框架封装的自动求导，切换时最容易出的问题在于理解梯度累加的机制。PyTorch默认会累加梯度，每轮里必须手动调用optimizer.zero_grad()清零，否则梯度在上一次batch的基础上叠加，参数更新步长会被不断放大。手写版本里没有对应的坑，因为每一步都是重新计算覆盖梯度，没有自动累加的隐式行为。这也是为什么我说手写一遍对整个框架的理解至关重要：等你切换到自动求导时，已经知道每个框架操作背后在做什么，不至于被zero_grad这类约定搞得莫名其妙。
线性回归值得每个人都亲手从零实现一遍的原因，在于它是整个深度学习里最后一个所有细节都能摊开看的模型。参数的更新过程、梯度的传播路径、超参数的影响后果、常见训练问题的成因，全部在几百行代码内清晰可见。把这些体会沉淀成肌肉记忆之后再往上走，学习复杂模型的成本会低非常多。踩过这些最简单数据上的坑之后，将来面对真实场景会少走很多弯路。
实战：SQL语法差异与避坑指南)
