1. 用 Python 代码开发工具手写 AdaGrad:先让脚本跑起来
如果你平时用 Python 写数值实验脚本,大概率遇到过这种场面:手写梯度下降,学习率调大一点损失直接炸,调小一点跑半天不动,换一份数据又得重新调。AdaGrad 就是冲着这个痛点来的——它借 Python、NumPy 这套代码开发工具,把每个参数的历史平方梯度累加起来,让每个维度拿到自己的步长,学习率随着训练自己往下走。这一篇按可照做的顺序走一遍:先把脚本跑通,再逐行拆平方梯度累加、梯度缩放和参数更新,然后把 eta、epsilon、iterations 这几个参数该设多少、改哪个看什么现象讲清楚,最后把几个容易翻车的地方摊开。适合已经在用 NumPy 写训练脚本、但被固定学习率折腾过的人。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. AdaGrad 的平方梯度累加:学习率为什么会自己往下掉
2.1 平方梯度累加:G 到底是什么
AdaGrad 和普通梯度下降最根本的区别,是多了一个和参数同形状的状态量 G。每轮先算梯度 gradient,再把 gradient 的平方逐元素加到 G 上,然后用 gradient / (sqrt(G) + epsilon) 去缩放梯度。这个缩放的意义是:某个参数历史上梯度一直很大,G 就涨得快,sqrt(G) 变大,这个参数的实际步长就被压小;某个参数历史上梯度很小,G 涨得慢,它反而能保留较大的步长。第一轮时 G 从零开始,sqrt(G) 还是零,靠 epsilon 兜底,缩放后的梯度近似是梯度的符号,参数每维正好移动 eta。第二轮开始历史项参与,移动量就小于 eta 了。
| 轮次 | G(第 1 维) | sqrt(G) | 缩放后梯度 | 该维移动量(eta=0.01) |
|---|---|---|---|---|
| 第 1 轮 | 25.5025 | 5.05 | -1 | 0.01 |
| 第 2 轮起 | 继续累加,只增不减 | 变大 | 小于 1 | 小于 0.01 |
这张表里第一轮的数字来自后面示例数据的真实手算,目的不是让你背数,而是让你看清一件事:AdaGrad 的步长上限出现在第一轮,之后一路往下走。这个特性决定了它适合什么、不适合什么,也决定了参数该怎么起手。
2.2 和固定学习率梯度下降的差别
固定学习率的梯度下降,所有参数共享一个 eta,哪个维度尺度大、梯度大,哪个维度就更容易震荡;AdaGrad 把“每个参数走多远”交给历史梯度自己决定。这个差别在特征稀疏或者各列量级差得远的时候特别明显:出现次数少的特征,G 小,步长相对大,不会被整体学习率压死。代价是到了训练后期,G 累积得很大,步长趋近于零,损失曲线容易拉成一条平台线。
| 维度 | 固定学习率梯度下降 | AdaGrad |
|---|---|---|
| 步长来源 | 全局一个 eta | 每个参数按历史平方梯度独立缩放 |
| 调参重心 | 换数据、换尺度都要重调 eta | 初始 eta 仍要调,维度间差异被吸收 |
| 训练后期 | 步长恒定,可能震荡 | 步长单调变小,容易停滞 |
| 适合场景 | 尺度一致、轮次短 | 稀疏特征、各维尺度差异大 |
选型上不用纠结:如果你的数据各列量级差不多、训练轮次也不长,固定学习率够用;如果某些特征出现得很少,或者你不想为每一维单独调学习率,AdaGrad 的自动缩放更省心。但要接受它后期变慢这个事实,别指望它像恒定步长那样一直推进。
2.3 先手算一轮,确认方向没反
在把整段代码抄进脚本之前,我习惯先用示例数据手算一轮,确认梯度符号、G 的累加顺序、theta 的更新方向都对得上。示例数据是 X 两列、y 四个值、theta 两个参数,下面三行是循环体里真正干活的部分:
python复制gradient = -(1 / m) * X.T @ (y - X @ theta) # 最小二乘损失的梯度
G += gradient ** 2 # 逐元素累加平方梯度
adjusted_gradient = gradient / (np.sqrt(G) + epsilon) # 按历史平方梯度缩放
theta -= eta * adjusted_gradient # 沿负梯度方向更新
这里 gradient 前面的负号对应损失 (1/2m) * sum((y - X @ theta) ** 2) 对 theta 求导的结果,少了这个负号,theta 就会往反方向跑。用初始 theta=(0.1, 0.1)、eta=0.01 手算第一轮:
| 量 | 第 1 维 | 第 2 维 |
|---|---|---|
| 初始 theta | 0.1 | 0.1 |
| 梯度 gradient | -5.05 | -16.3 |
| G(平方) | 25.5025 | 265.69 |
| sqrt(G) | 5.05 | 16.3 |
| 缩放后梯度 | -1 | -1 |
| 更新后 theta | 0.11 | 0.11 |
手算结果和代码跑出来对不上,先别怀疑算法,回头查 X 的列顺序、y 的长度、theta 的初始值,这三者任一错位,梯度就会整体偏掉。这一步花五分钟,能省掉后面半小时的瞎调。
2.4 选型边界:什么时候不该硬上 AdaGrad
AdaGrad 的步长单调递减是写在公式里的,不是调参能绕过去的。训练轮次很长、又需要后期保持一定步长继续压损失的任务,用它就容易看到“前面降得快、后面怎么都不动”的曲线。另一种情况是数据各维尺度差异极大,G 在各维上的累积速度差出几个数量级,表现成某一维早早就到位、另一维像被冻住。这两种情况都不是 AdaGrad 的 bug,而是它的设计边界。动手前先跑一百轮,看损失下降主要发生在哪个阶段,再决定是加轮次、放大 eta,还是先回去处理特征尺度。
3. 把代码开发工具落到 NumPy:四段骨架与逐行说明
3.1 数据与形状:X、y、theta 三件套
先把数据段独立出来,形状定死,后面的报错会少一大半。X 的每一行是一个样本,第一列通常是常数列,用来吸收截距;y 的长度必须等于 X 的行数;theta 的长度必须等于 X 的列数。示例数据选的是 y 随第二列线性递减的一组数,解析解是 theta=(9, -1),后面验证收敛时有现成参照。
python复制import numpy as np
# X 每行一个样本,第一列是常数列(截距项),第二列是特征
X = np.array([[1, 2], [1, 3], [1, 4], [1, 5]])
y = np.array([7, 6, 5, 4]) # 目标值,长度必须等于 X 的行数
theta = np.array([0.1, 0.1]) # 待优化参数,长度必须等于 X 的列数
m = len(y) # 样本数,梯度里的 1/m 来自这里
参数说明:m 取 len(y) 而不是 X.shape[0],是因为后面梯度公式里除以样本数,两个值必须一致;如果数据来自外部文件,读进来先断言 X.shape[0] == y.shape[0],不然 X.T @ (y - X @ theta) 会直接报维度不匹配。theta 保持一维数组,G 的形状才能跟着它走,别为了“好看”改成列向量,广播规则会把简单问题变复杂。
3.2 状态初始化:G = np.zeros(theta.shape)
G 必须和 theta 同形状,每个参数一份历史平方梯度。写成标量或者只开一个元素,后面的逐元素累加和除法都会悄悄广播成错误的结果,而且不一定报错,这是比报错更难查的一类问题。
python复制G = np.zeros(theta.shape) # 每个参数一份历史平方梯度,不能写成标量
参数说明:np.zeros 的入参是 theta.shape 而不是 len(theta),这样 theta 以后改成二维也能对上;初始值必须是零,因为 AdaGrad 的定义就是从零开始累加。G 为零意味着第一轮 sqrt(G) 为零,除法全靠 epsilon 兜底,所以 epsilon 不能省,下一章会专门讲这个参数。
3.3 循环体:梯度、累加、调整、更新四步
循环体是整段代码的核心,四步的顺序不能换:先用当前 theta 算梯度,再把平方累加进 G,再用更新后的 G 缩放梯度,最后更新 theta。如果先更新 theta 再累加 G,G 会错位一轮,前期看不出差别,后期收敛结果对不上。
python复制def adagrad(X, y, theta, eta=0.01, epsilon=1e-8, iterations=1000):
m = len(y)
G = np.zeros(theta.shape)
for t in range(iterations):
# 1) 用当前 theta 算残差,再算梯度(负号对应 (1/2m) 最小二乘)
gradient = -(1 / m) * X.T @ (y - X @ theta)
# 2) 逐元素累加平方梯度
G += gradient ** 2
# 3) 按历史平方梯度缩放梯度
adjusted_gradient = gradient / (np.sqrt(G) + epsilon)
# 4) 更新参数
theta -= eta * adjusted_gradient
逐行说明:X @ theta 是当前预测值,y - X @ theta 是残差,X.T @ 残差 把每个特征上的残差加权求和,除以 m 取平均,前面的负号把“残差对参数的导数”翻成下降方向。G += gradient ** 2 是原地累加,不会新建数组,长循环里能省一点内存。adjusted_gradient 里 np.sqrt(G) 是逐元素开方,+ epsilon 防止第一轮除零。theta -= eta * adjusted_gradient 是原地更新,如果后面还要保留每轮 theta,得先 theta.copy() 再存,不然存下来的都是同一个引用。
3.4 打印与返回:t % 100 的观察粒度
打印放在更新之后,这样 t=0 打出来的损失是第一次更新后的值,不是初始值。默认每 100 轮打一次,1000 轮只有 11 个点,前期下降最陡的那一段很可能被漏掉。函数最后返回更新完的 theta,调用处接住再打印。
python复制 if t % 100 == 0:
loss = (1 / (2 * m)) * np.sum((y - X @ theta) ** 2)
print(f"Iteration {t}: Loss = {loss}")
return theta
theta = adagrad(X, y, theta)
print(f"Optimized parameters: {theta}")
参数说明:t % 100 控制打印频率,改小看细节、改大看趋势;loss 用的是更新后的 theta,和打印行号对齐;return theta 在循环外,别缩进到循环里,否则只返回第一轮结果。这套默认参数直接跑示例数据,大概率看不到 theta 靠近 (9, -1),原因在下一章。
4. 参数怎么定:eta、epsilon、iterations 的取值与观察点
4.1 eta:初始步长上限,不是越小越稳
AdaGrad 第一轮每维移动量正好是 eta,之后每轮不超过 eta。这意味着 eta * iterations 是参数能移动的理论上限。示例数据里 theta 第一维要从 0.1 走到 9,距离约 8.9,默认 eta=0.01、1000 轮的理论上限是 10,看似够,但实际步长一路衰减,真正累计的移动量远低于 10,跑完离目标还差一大截。所以 eta 不能按“稳一点”的直觉往小里设,得先算目标距离再定下界。
python复制# 目标第一维约 9,初始 0.1,距离约 8.9;eta=0.5 时第一轮就能走 0.5
theta = adagrad(X, y, theta, eta=0.5, epsilon=1e-8, iterations=1000)
参数说明:eta=0.5 是一个起手量级,不是最优值;跑完看 theta 和 loss 是否还在动,还在动就说明轮次或 eta 不够,早早就平了就说明步长衰减已经压过头。每次只改一个参数,别 eta 和 iterations 一起动,不然说不清是谁起的作用。
4.2 epsilon:只负责兜底除零
epsilon 的职责非常窄:第一轮 G 为零时让除法有定义,顺便在 G 极小时防止数值爆炸。它不该承担“平滑”“正则”之类的角色,设大了会明显压缩步长,设成零则第一轮直接出问题。
python复制# 错误示范:epsilon 设 0,第一轮 sqrt(0) 会把缩放后的梯度变成 inf/nan
# theta = adagrad(X, y, theta, epsilon=0)
# 正确做法:保留 1e-8 量级,只做兜底
theta = adagrad(X, y, theta, epsilon=1e-8)
参数说明:1e-8 是常用兜底量级,比它再小要确认数据类型精度够;如果某轮梯度恰好为零,0 / (0 + epsilon) 得到 0,参数不动,这是正常行为,不是 bug。看到第一轮 loss 打成 nan 或 inf,先查 epsilon 有没有被误传成 0,再查数据里有没有 nan。
4.3 iterations 与打印频率:观察窗口要对齐
iterations 决定跑多久,打印频率决定你能看见什么。1000 轮配 t % 100 只有 11 个采样点,前期最陡的几十轮基本看不见;把打印改密,或者干脆把 loss 收进列表,比盯着控制台猜有用。
python复制# 想看清前期趋势,先把打印频率改密
if t % 10 == 0:
loss = (1 / (2 * m)) * np.sum((y - X @ theta) ** 2)
print(f"Iteration {t}: Loss = {loss}")
# 怀疑轮次不够,先加轮次看 theta 是否还在动
theta = adagrad(X, y, theta, eta=0.5, iterations=5000)
参数说明:打印频率只影响观察,不影响计算;iterations 加大后要看最后几百轮 theta 的变化量,如果几乎为零,说明步长衰减已经把更新压停,继续加轮次意义不大,该回头调 eta 或处理特征尺度。
4.4 一组可复现的起手参数
把上面的取舍收成一张表,下次换数据可以先照这个量级试,再按现象微调。表里的值不是标准答案,是让你有一个能跑起来、能观察的起点。
| 场景 | eta | epsilon | iterations | 重点看什么 |
|---|---|---|---|---|
| 示例数据先跑通 | 0.5 | 1e-8 | 1000 | theta 是否朝 (9, -1) 走,loss 是否还在降 |
| 只看前段趋势 | 0.5 | 1e-8 | 100 | 前 100 轮 loss 下降是否集中在前几十轮 |
| 各维尺度差异大 | 0.1~0.5 | 1e-8 | 1000+ | 每一维的移动量是否均衡 |
| 第一轮就出 nan | 任意 | 必须大于 0 | — | 先查 epsilon 是否被改成 0 |
起手先用第一行跑通,确认方向、形状、打印都对,再改数据。换数据后如果 loss 前几轮就炸,先降 eta 一个量级;如果 loss 一直平,先确认 eta 是不是太小、iterations 是不是不够,别一上来就怀疑算法。
5. 避坑与排查:步长衰减、除零、损失不降的现场处理
5.1 现象:损失前几十轮降得很快,后面拉成一条平台线
原因:G 单调累加,sqrt(G) 只增不减,有效步长 eta / (sqrt(G) + epsilon) 一路往下走。这是 AdaGrad 的固有行为,不是数据没救。解决:先把 eta 放大一个量级试,看平台出现的位置是否后移;如果放大后前期震荡,说明 eta 过了,往回收半档。排查时打印每轮实际移动量,比只看 loss 直观。
python复制delta = eta * adjusted_gradient
print(t, np.abs(delta).max()) # 每轮最大移动量,看它何时趋近于零
参数说明:np.abs(delta).max() 取的是所有维度里移动最大的那个,用来判断整体是否还在动;如果某一维已经不动、另一维还在动,说明问题在维度尺度差异,不是整体步长。
5.2 现象:第一轮 loss 打印 nan 或 inf
原因:epsilon 被设成 0 或小到超过浮点精度,第一轮 G 为零,sqrt(G) 为零,除法直接出 inf/nan。解决:恢复 1e-8 量级,并在函数入口加一句断言,让错误在进循环前就暴露。
python复制assert epsilon > 0, "epsilon 必须大于 0,否则第一轮 sqrt(0) 会除零"
参数说明:断言放在函数最前面,比等到 loss 变 nan 再回头查省时间;如果数据本身有 nan,梯度也会变 nan,那是另一个问题,先清洗数据再跑。
5.3 现象:某一维参数几乎不动,另一维已经到位
原因:各维梯度量级差得远,G 的累积速度差出几个数量级,有效步长被拉得很不均衡。示例数据两列尺度接近,这个问题不明显,换成量级差很大的特征就会出现。解决:先对特征列做标准化,再跑;标准化后 theta 的含义会变,解析解不再是对应 (9, -1),验证时要按新数据重新算。
python复制# 常见做法:对非常数列做标准化,再交给 AdaGrad
feature_cols = X[:, 1:]
X[:, 1:] = (feature_cols - feature_cols.mean(axis=0)) / feature_cols.std(axis=0)
参数说明:只动特征列、不动常数列,常数列标准化会变成全零,截距项就没了;std 为 0 的列要先剔除,否则除零。标准化不是 AdaGrad 的必需步骤,但在尺度差异大的数据上,它比调 eta 更直接。
5.4 现象:跑完 1000 轮 theta 离目标很远
原因:eta 太小,每轮移动量不超过 eta,理论上限就是 eta * iterations,实际还要打折。示例数据目标距离约 8.9,eta=0.01 时上限 10,衰减后根本到不了。解决:先算目标距离,再按距离反推 eta 下界,或者加轮次看是否还在动。
python复制target = np.array([9.0, -1.0])
print("到目标的距离:", np.abs(target - theta))
# 距离还很大且 theta 几乎不动,优先放大 eta,而不是无脑加 iterations
参数说明:target 只在示例数据里有解析参照,换真实数据没有这个参照,就看 loss 是否还在降、每轮移动量是否趋零;两个信号都停了,再考虑改结构,而不是继续加轮次。
5.5 现象:控制台报形状不匹配,或打印出来的损失对不上
原因:X 行数与 y 长度不一致、theta 长度与 X 列数不一致,或者打印用的 theta 不是更新后的那一份。解决:进函数先断言三个形状,打印前确认 theta 已经更新。这类问题多在数据换源、手改数组时出现,和算法无关。
python复制assert X.shape[0] == y.shape[0], "X 行数必须等于 y 长度"
assert X.shape[1] == theta.shape[0], "theta 长度必须等于 X 列数"
参数说明:断言放在函数入口,数据换源时第一时间报出来;如果要在循环里存每轮 theta,用 theta.copy(),直接 append theta 存的是引用,最后看轨迹会发现所有点都一样。
6. 进阶验证:把损失曲线和有效步长当成黑匣子读数
6.1 把每轮 loss 和 theta 存下来
只看控制台打印,信息丢得太多。把打印换成记录,跑完拿数组说话,能同时看损失趋势、参数轨迹和每轮移动量。下面这段是在原有接口上做的最小整理,计算逻辑没变,只是把 print 换成列表。
python复制def adagrad_trace(X, y, theta, eta=0.01, epsilon=1e-8, iterations=1000):
m = len(y)
G = np.zeros(theta.shape)
losses, thetas = [], []
for t in range(iterations):
gradient = -(1 / m) * X.T @ (y - X @ theta)
G += gradient ** 2
adjusted = gradient / (np.sqrt(G) + epsilon)
theta = theta - eta * adjusted
losses.append((1 / (2 * m)) * np.sum((y - X @ theta) ** 2))
thetas.append(theta.copy())
return theta, losses, thetas
参数说明:theta.copy() 不能省,否则所有记录指向同一个数组;losses 记录的是更新后的损失,和训练过程对齐;返回值多两个,调用处按需接。跑完把 losses 画出来,前期陡、后期平是正常形态,如果从头到尾一条直线,先查 eta 和 epsilon。
6.2 三个交叉检查
| 检查项 | 期望 | 异常含义 |
|---|---|---|
| theta 是否朝 (9, -1) 走 | 越跑越近 | 方向反了查梯度负号,走不动查 eta |
| loss 是否整体下降 | 前段陡、后段缓 | 一直平查 eta/iterations,变 nan 查 epsilon |
| 每轮最大移动量 | 单调变小、趋近零 | 不降反升查 G 是否被重置或梯度符号错 |
这三项不用同时完美,有一项明显异常就回头查对应环节。表格里的 (9, -1) 只对示例数据成立,换数据后把第一项换成“参数是否还在有效移动”。
6.3 我的固定动作
从那以后我每次改 eta、epsilon、iterations,都先把第一轮的 gradient、G、adjusted_gradient 和实际移动量打出来,确认 epsilon 没被误传成 0、梯度符号没反、移动量没超过 eta,再跑长循环。这个习惯帮我省掉过好几次“跑了一晚上发现参数根本没动”的后悔药。AdaGrad 不难,难的是把平方梯度累加的顺序和步长衰减的边界放在心里,别等损失拉平了才回头找原因。希望帮到你。
