从零实现梯度下降算法：NumPy可视化SGD、Momentum、Adam等优化器原理

1. 项目概述与核心价值

如果你曾经好奇过像TensorFlow或PyTorch这样的深度学习框架，其内部的优化器（比如SGD、Adam）究竟是如何一步步更新模型参数的，那么今天这个项目就是为你准备的。我们不依赖任何现成的深度学习库，仅使用Python的基础科学计算库NumPy，从零开始实现梯度下降及其多个主流变种算法。这不仅仅是写几行代码，而是通过构建一个完整的Sigmoid神经元模型作为“试验场”，亲手将数学公式翻译成可运行的逻辑，并利用Matplotlib制作出直观的动画，亲眼见证参数如何在损失函数的“地形图”上滚动、跳跃，最终找到最低点。

很多人学习优化算法时，止步于理解公式。但公式是静态的，优化过程却是动态的。为什么Momentum（动量法）会“冲过头”又在山谷间振荡？为什么Adam（自适应矩估计）通常收敛得更快更稳？仅仅看数学推导很难获得这种直觉。本项目的目的，就是打通从理论到视觉感知的最后一公里。通过亲手实现并可视化，你将深刻理解每个超参数（如学习率、动量系数）的实际影响，掌握算法在面临不同初始化点、不同数据特征时的“脾气”。这对于后续在实际项目中调试模型、选择优化器有着不可替代的价值。

无论你是机器学习初学者，想夯实优化这块基石，还是有一定经验的从业者，希望深入框架底层原理，这个项目都能提供一次绝佳的“动手学”体验。我们将覆盖从最基础的批量梯度下降（Batch GD），到带动量的Momentum、Nesterov加速梯度（NAG），再到自适应学习率的AdaGrad、RMSProp，以及集大成的Adam算法。每个算法我们都会拆解其代码实现，并生成对应的优化路径动画，让抽象的概念变得触手可及。

2. 项目整体设计与环境搭建

2.1 核心思路与架构设计

本项目的核心思路是“分而治之”和“可视化驱动”。我们不会直接去实现一个复杂的神经网络，而是选择一个结构最简单但功能完备的模型——Sigmoid神经元（或称逻辑斯蒂回归单元）。它拥有权重w和偏置b两个参数，足以构成一个二维的损失函数曲面（误差关于w和b），这正是我们进行三维和等高线可视化的完美场景。

整个项目架构围绕一个核心类SN（Sigmoid Neuron）展开。这个类将封装：

1. 模型本身：Sigmoid激活函数、前向计算、损失计算。
2. 参数与历史记录：存储当前的w,b，以及记录它们在整个训练过程中变化的列表w_h,b_h,e_h（误差历史）。
3. 多种优化算法：在fit方法中，通过一个algo参数来选择执行哪种梯度下降变体。每种算法的更新规则都将在其中独立实现。

可视化部分则完全独立于模型类。我们将编写通用的绘图函数，它们只负责从训练好的SN对象中读取历史记录(w_h, b_h, e_h)，然后生成静态图像或动态动画。这种设计使得模型训练和结果展示解耦，非常清晰。

2.2 环境准备与工具选型

实现这个项目，你只需要一个标准的Python科学计算环境。以下是具体的库和其作用解析：

• NumPy (1.21+):项目的计算核心。所有涉及数组的操作、数学运算（如指数、平方、开方）都依赖它。它的广播机制能让我们轻松计算整个参数网格上的损失值，为绘图提供数据。
• Matplotlib (3.5+):可视化的绝对主力。我们将用到它的几个关键子模块：
  • matplotlib.pyplot: 用于创建图形和坐标轴，进行基本的2D绘图。
  • mpl_toolkits.mplot3d.Axes3D: 用于创建3D坐标系，绘制损失函数曲面。
  • matplotlib.animation.FuncAnimation: 这是制作动画的关键。它通过逐帧更新图形元素（如散点、线条）的位置，来模拟优化过程的动态路径。
  • matplotlib.cm和matplotlib.colors: 用于为曲面和等高线图配置颜色映射，使图像更美观。

为什么选择它们？NumPy是Python科学计算的基石，效率与易用性兼备。Matplotlib虽然在某些3D特性上不是最强大的，但它与NumPy无缝集成，且功能完全满足本项目需求——绘制曲面、等高线和路径动画。更重要的是，它的API对于大多数Python开发者来说非常熟悉，降低了学习成本。

安装非常简单，使用pip即可：

pip install numpy matplotlib

注意：建议在Jupyter Notebook或类似交互式环境中运行本项目代码，因为FuncAnimation生成的动画可以直接嵌入到Notebook单元格中播放，体验最佳。如果你使用脚本，可能需要将动画保存为GIF或MP4文件。

3. Sigmoid神经元类的深度实现

3.1 类结构与初始化设计

我们首先构建SN类。它的构造函数__init__除了接收初始参数w_init,b_init，还有一个关键的algo参数，用于指定后续训练使用的算法。

import numpy as np class SN: def __init__(self, w_init, b_init, algo): self.w = w_init # 权重初始值 self.b = b_init # 偏置初始值 self.w_h = [] # 权重历史记录 self.b_h = [] # 偏置历史记录 self.e_h = [] # 损失历史记录 self.algo = algo # 算法类型，如 'GD', 'Momentum', 'Adam'等 self.X = None # 训练数据特征（内部存储） self.Y = None # 训练数据标签（内部存储）

这里的设计有几个考量：

1. 显式初始化：我们不采用随机初始化，而是要求传入确定的w_init和b_init。这至关重要，因为可视化就是为了对比不同起点下算法的行为。固定起点能保证实验的可复现性。
2. 历史记录器：w_h,b_h,e_h这三个列表是可视化的“数据源”。在每次参数更新后，我们都会调用一个append_log方法将当前状态快照下来。没有它们，动画就无从谈起。
3. 算法标识：algo是一个字符串，它将在fit方法中驱动不同的条件分支，执行对应的更新逻辑。这是一种清晰且易于扩展的设计。

3.2 核心计算函数：激活、损失与梯度

接下来是模型的核心数学部分。

Sigmoid激活函数：它接收输入x、权重w和偏置b，计算σ(w*x + b)。这里w和b被设为可选参数，默认使用对象自身的self.w和self.b。这个设计妙处在于，当我们在可视化中需要计算整个参数网格(WW, BB)上的损失时，可以直接传入网格矩阵，利用NumPy的广播一次性算出所有点的输出，而无需循环。

def sigmoid(self, x, w=None, b=None): if w is None: w = self.w if b is None: b = self.b return 1.0 / (1.0 + np.exp(-(w * x + b)))

损失函数：我们采用均方误差（MSE）。同样，w和b是可选的，这方便我们计算任意参数点下的损失值，从而绘制出完整的损失曲面。

def error(self, X, Y, w=None, b=None): if w is None: w = self.w if b is None: b = self.b err = 0 for x, y in zip(X, Y): err += 0.5 * (self.sigmoid(x, w, b) - y) ** 2 return err / len(X) # 注意：这里是平均误差，更标准

实操心得：在计算整个网格的损失Z = sn.error(X, Y, WW, BB)时，WW和BB是meshgrid生成的矩阵。由于sigmoid和误差计算都支持NumPy广播，这个操作会非常高效，直接生成一个二维数组Z，对应网格上每个(w,b)点的损失值。这是向量化计算的典型优势。

梯度计算：这是优化算法的引擎。我们需要计算损失函数关于权重w和偏置b的梯度（偏导数）。对于单个样本(x, y)，其预测值为y_pred = σ(w*x + b)，损失为L = 0.5*(y_pred - y)^2。通过链式法则可以推导出：

• grad_w = (y_pred - y) * y_pred * (1 - y_pred) * x
• grad_b = (y_pred - y) * y_pred * (1 - y_pred)

def grad_w(self, x, y, w=None, b=None): if w is None: w = self.w if b is None: b = self.b y_pred = self.sigmoid(x, w, b) return (y_pred - y) * y_pred * (1 - y_pred) * x def grad_b(self, x, y, w=None, b=None): if w is None: w = self.w if b is None: b = self.b y_pred = self.sigmoid(x, w, b) return (y_pred - y) * y_pred * (1 - y_pred)

注意grad_w中乘以了x，这正是梯度与输入特征相关的体现。偏置b可以看作是一个永远输入为1的权重，所以它的梯度不乘以x。

3.3 训练流程与日志记录

fit方法是整个类最复杂的部分，它根据self.algo的值，执行不同的优化循环。但其骨架是一致的：迭代指定的轮数（epochs），在每轮中计算梯度并更新参数，最后记录日志。

一个简单的批量梯度下降（Batch GD）分支如下：

def fit(self, X, Y, epochs=100, eta=0.01, gamma=0.9, mini_batch_size=100, eps=1e-8, beta=0.9, beta1=0.9, beta2=0.9): self.X, self.Y = X, Y self.w_h, self.b_h, self.e_h = [], [], [] # 清空历史 if self.algo == 'GD': for i in range(epochs): dw, db = 0, 0 # 遍历所有样本，累积梯度 for x, y in zip(X, Y): dw += self.grad_w(x, y) db += self.grad_b(x, y) # 参数更新：梯度下降核心步骤 self.w -= (eta / len(X)) * dw # 除以样本数，得到平均梯度 self.b -= (eta / len(X)) * db self.append_log() # 记录当前状态 # ... 其他算法分支（Momentum, Adam等）

append_log方法极其简单但不可或缺：

def append_log(self): self.w_h.append(self.w) self.b_h.append(self.b) self.e_h.append(self.error(self.X, self.Y))

它捕获了每一轮迭代后参数的空间位置(w, b)以及该位置对应的损失值e。这三条轨迹就是动画中那个移动的“小球”的路径。

4. 可视化系统的构建

4.1 静态图像生成：3D曲面与2D等高线

可视化分为两部分：静态的背景图和动态的路径动画。背景图展示了损失函数在整个参数空间的全貌。

创建参数网格与计算损失场： 这是绘制任何背景图的第一步。我们需要在w和b的定义域内生成密集的网格点，并计算每个点的损失。

# 定义参数范围 w_min, w_max = -7, 5 b_min, b_max = -7, 5 # 生成网格 W = np.linspace(w_min, w_max, 256) # 在w范围内生成256个点 B = np.linspace(b_min, b_max, 256) # 在b范围内生成256个点 WW, BB = np.meshgrid(W, B) # 生成256x256的网格坐标矩阵 # 计算网格上每一点的损失值 Z = sn.error(X, Y, WW, BB) # 利用广播，一次性计算所有点

Z是一个与WW,BB同形的矩阵，构成了我们的“损失地形”。

绘制3D曲面图： 使用Axes3D可以创建一个三维坐标系，将(WW, BB, Z)绘制成曲面。

from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt fig = plt.figure(dpi=100) ax = fig.add_subplot(111, projection='3d') # 绘制曲面，rstride和cstride控制曲面网格的密度，alpha控制透明度 surf = ax.plot_surface(WW, BB, Z, rstride=3, cstride=3, alpha=0.5, cmap='coolwarm', linewidth=0, antialiased=False) # 在底部绘制等高线投影 cset = ax.contourf(WW, BB, Z, zdir='z', offset=np.min(Z)-1, alpha=0.6, cmap='coolwarm') ax.set_xlabel('Weight (w)') ax.set_ylabel('Bias (b)') ax.set_zlabel('Loss') ax.set_title('3D Loss Surface')

cmap='coolwarm'使得低损失区域显示为蓝色（冷），高损失区域显示为红色（暖），非常直观。

绘制2D等高线图： 对于更喜欢二维视图的读者，等高线图能更清晰地展示“地形”的陡峭与平缓区域。

fig, ax = plt.subplots(dpi=100) # 绘制填充等高线图，levels控制等高线的数量或具体值 cp = ax.contourf(WW, BB, Z, levels=25, alpha=0.8, cmap='bwr') ax.set_xlabel('Weight (w)') ax.set_ylabel('Bias (b)') ax.set_title('2D Loss Contour') plt.colorbar(cp) # 添加颜色条，显示损失值与颜色的对应关系

等高线越密集的地方，梯度越陡峭；越稀疏则越平缓。这有助于理解为什么在某些区域算法更新快，某些区域更新慢。

4.2 动态动画制作：追踪优化路径

静态图展示了战场，动画则展示士兵（参数点）如何探索这个战场。我们使用FuncAnimation。

核心是定义一个更新函数animate(i)，其中i是帧索引。我们需要将帧索引映射到训练的历史记录索引。

import matplotlib.animation as animation from IPython.display import HTML def animate_2d(i): # 将帧索引映射到历史记录索引。假设总帧数20，总epoch数200，则每帧对应10个epoch。 idx = int(i * (len(sn.w_h) / animation_frames)) # 更新路径线：从起点到当前点的所有历史位置 line.set_data(sn.w_h[:idx+1], sn.b_h[:idx+1]) # 更新标题，显示当前epoch和损失 ax.set_title(f'Epoch: {idx}, Loss: {sn.e_h[idx]:.4f}') return line, # 必须返回一个可迭代的艺术对象序列 # 初始化图形和路径线 fig, ax = plt.subplots(dpi=100) # 先绘制静态的等高线背景 cp = ax.contourf(WW, BB, Z, levels=25, alpha=0.8, cmap='bwr') # 初始化一个空的路径线对象，颜色为黑色，点标记为圆点 line, = ax.plot([], [], 'ko-', markersize=4, linewidth=1.5) # 创建动画，frames指定总帧数，interval指定帧间隔（毫秒），blit=True优化渲染 anim = animation.FuncAnimation(fig, animate_2d, frames=animation_frames, interval=200, blit=True) # 在Jupyter中内嵌显示 plt.close(fig) # 防止重复显示静态图 HTML(anim.to_jshtml())

animate_2d函数在每一帧被调用，它更新line对象的数据为截止到当前epoch的所有(w, b)点，并更新标题。FuncAnimation会连续调用这个函数，并将结果组合成动画。

注意事项：动画的流畅度和历史记录的长度（epoch数）、总帧数有关。如果epoch数很大（如1000），而帧数很少（如20），那么每一帧的“跳跃”会很大。通常可以设置frames=epochs来让每一帧对应一个epoch，但这可能会生成非常大的动画文件。一个折中的办法是每隔N个epoch记录一次历史，或者在动画函数中进行下采样。

5. 梯度下降算法变种的实现与对比

现在，我们进入最核心的部分：在SN.fit()方法中实现各种梯度下降变体。我们将逐一剖析其代码、原理和可视化表现。

5.1 批量梯度下降（Batch Gradient Descent）

这是最原始的形式，也是我们理解其他变体的基础。

if self.algo == 'GD': for i in range(epochs): dw, db = 0, 0 # 1. 遍历全部数据，计算平均梯度 for x, y in zip(X, Y): dw += self.grad_w(x, y) db += self.grad_b(x, y) # 2. 参数更新：朝着负梯度方向移动 self.w -= (eta / len(X)) * dw # eta是学习率 self.b -= (eta / len(X)) * db self.append_log()

原理：在每一轮迭代中，它使用整个训练集来计算损失函数关于参数的梯度。这个梯度方向是当前点处使得损失函数增长最快的方向，因此向其反方向移动（乘以学习率eta）可以减小损失。特点与可视化：更新方向稳定，直接指向当前点的最速下降方向。在动画中，路径通常是一条相对平滑的曲线，径直滑向谷底。但它的缺点是，每次更新都需要遍历全部数据，计算成本高；且在山谷狭窄的“之”字形沟壑中，下降会非常缓慢，产生大量振荡。

5.2 带动量的梯度下降（Momentum）

为了缓解“之”字形振荡，动量法引入了“惯性”的概念。

elif self.algo == 'Momentum': v_w, v_b = 0, 0 # 初始化速度（动量）为0 for i in range(epochs): dw, db = 0, 0 for x, y in zip(X, Y): dw += self.grad_w(x, y) db += self.grad_b(x, y) # 核心更新：速度 = 衰减率 * 旧速度 + 学习率 * 当前梯度 v_w = gamma * v_w + eta * dw v_b = gamma * v_b + eta * db # 参数更新：使用速度而非原始梯度 self.w -= v_w self.b -= v_b self.append_log()

原理：引入速度变量v。其更新是上一时刻速度的衰减（gamma通常取0.9，称为动量系数）加上当前梯度的加权。参数更新时直接使用这个速度。这好比球滚下山坡，不仅受当前坡度（梯度）影响，还保有之前滚动的方向（动量）。特点与可视化：在动画中，当梯度方向变化时，由于动量的存在，参数更新方向不会立即剧烈改变，这有助于：

1. 加速在平坦区域的收敛（因为动量会累积）。
2. 减少在“之”字形沟壑中的横向振荡，使其更倾向于沿着沟壑的轴线方向前进。 但是，动量也可能导致“冲过头”，在最小值点附近来回震荡，甚至暂时冲出山谷。

5.3 Nesterov加速梯度下降（NAG）

NAG是对Momentum的一个“前瞻性”改进。

elif self.algo == 'NAG': v_w, v_b = 0, 0 for i in range(epochs): dw, db = 0, 0 # 关键区别：先根据动量“展望”一步，在展望点计算梯度 v_w_prev = gamma * v_w # 临时保存未加当前梯度的动量 v_b_prev = gamma * v_b for x, y in zip(X, Y): # 在 (w - v_w_prev, b - v_b_prev) 处计算梯度 dw += self.grad_w(x, y, self.w - v_w_prev, self.b - v_b_prev) db += self.grad_b(x, y, self.w - v_w_prev, self.b - v_b_prev) # 用展望点的梯度来更新速度 v_w = v_w_prev + eta * dw v_b = v_b_prev + eta * db # 参数更新 self.w -= v_w self.b -= v_b self.append_log()

原理：普通的Momentum是“先计算梯度，再结合动量更新”。NAG则是“先根据动量向前看一步（w - gamma*v），在这个‘展望点’计算梯度，然后用这个梯度来修正动量”。可以理解为，它用了一个更聪明的梯度估计，这个估计不仅考虑了当前坡度，还预判了下一步的位置。特点与可视化：在动画中，NAG的路径通常比Momentum更“果断”。当快要到达谷底时，如果Momentum会因为速度太快而冲出去，NAG在“展望点”计算到的梯度可能会指向谷底内侧，从而产生一个刹车效应，使收敛更稳定，振荡幅度更小。

5.4 小批量梯度下降（Mini-batch GD）与随机梯度下降（SGD）

在实际大数据场景下，Batch GD不可行。我们使用数据的一个子集（小批量）来估计梯度。

elif self.algo == 'MiniBatch': for i in range(epochs): dw, db = 0, 0 points_seen = 0 for x, y in zip(X, Y): dw += self.grad_w(x, y) db += self.grad_b(x, y) points_seen += 1 # 每当看够一个mini-batch的数据，就更新一次参数 if points_seen % mini_batch_size == 0: self.w -= (eta / mini_batch_size) * dw self.b -= (eta / mini_batch_size) * db self.append_log() # 在小批量级别记录日志，动画会更密集 dw, db = 0, 0 # 重置梯度累积器 # 处理最后不足一个batch的数据 if points_seen % mini_batch_size != 0: self.w -= (eta / points_seen) * dw self.b -= (eta / points_seen) * db self.append_log()

原理：将整个数据集分成若干个小批量（batch）。每次迭代，只使用一个批量的数据计算梯度并更新参数。这本质上是使用部分数据梯度作为全数据梯度的无偏估计。

• 当mini_batch_size = 1：这就是随机梯度下降（SGD）。每次只用一个样本，更新非常频繁，路径极其嘈杂，但有时能跳出局部极小点。
• 当mini_batch_size = len(X)：这就是批量梯度下降（Batch GD）。
• 通常取值（如32, 64, 128）：这是小批量梯度下降，在更新速度和梯度估计稳定性之间取得平衡。特点与可视化：在动画中，Mini-batch GD的路径不再是Batch GD那样每轮一个点的平滑移动，而是在一轮内可能更新多次，路径点更密集。SGD的路径则像“布朗运动”，充满了随机跳跃，但整体趋势仍向最小值靠近。噪声既是缺点（收敛不稳定），也是优点（有助于逃离局部最优或鞍点）。

5.5 自适应学习率算法：AdaGrad、RMSProp、Adam

这类算法的核心思想是：为每个参数自适应地调整学习率。

AdaGrad：为每个参数累积历史梯度的平方，学习率除以这个累积量的平方根。对于频繁更新的参数（大梯度），累积量变大，学习率减小；对于不频繁更新的参数（小梯度），累积量小，学习率相对较大。

elif self.algo == 'AdaGrad': v_w, v_b = 0, 0 # 累积平方梯度 for i in range(epochs): dw, db = 0, 0 for x, y in zip(X, Y): dw += self.grad_w(x, y) db += self.grad_b(x, y) # 累积平方梯度（分母项） v_w += dw**2 v_b += db**2 # 参数更新：学习率除以(平方根累积量 + 极小值eps，防止除零) self.w -= (eta / (np.sqrt(v_w) + eps)) * dw self.b -= (eta / (np.sqrt(v_b) + eps)) * db self.append_log()

问题：随着训练进行，分母v会单调递增，导致学习率过早、过度衰减，可能在训练后期失去更新能力。

RMSProp：针对AdaGrad的改进，将累积平方梯度改为指数移动平均，让久远的历史梯度影响衰减。

elif self.algo == 'RMSProp': v_w, v_b = 0, 0 for i in range(epochs): dw, db = 0, 0 for x, y in zip(X, Y): dw += self.grad_w(x, y) db += self.grad_b(x, y) # 指数移动平均：beta通常取0.9 v_w = beta * v_w + (1 - beta) * (dw**2) v_b = beta * v_b + (1 - beta) * (db**2) self.w -= (eta / (np.sqrt(v_w) + eps)) * dw self.b -= (eta / (np.sqrt(v_b) + eps)) * db self.append_log()

这样，学习率不会一直衰减，可以持续学习。

Adam（Adaptive Moment Estimation）：结合了Momentum（一阶矩估计）和RMSProp（二阶矩估计）的思想，并进行了偏差校正（Bias Correction），是当前最流行、默认推荐的优化器。

elif self.algo == 'Adam': m_w, m_b = 0, 0 # 一阶矩（动量） v_w, v_b = 0, 0 # 二阶矩（自适应学习率分母） t = 0 # 时间步 for i in range(epochs): dw, db = 0, 0 for x, y in zip(X, Y): dw += self.grad_w(x, y) db += self.grad_b(x, y) t += 1 # 更新一阶矩和二阶矩的指数移动平均 m_w = beta1 * m_w + (1 - beta1) * dw m_b = beta1 * m_b + (1 - beta1) * db v_w = beta2 * v_w + (1 - beta2) * (dw**2) v_b = beta2 * v_b + (1 - beta2) * (db**2) # 偏差校正：解决初始时刻m和v偏向于0的问题 m_w_hat = m_w / (1 - np.power(beta1, t)) m_b_hat = m_b / (1 - np.power(beta1, t)) v_w_hat = v_w / (1 - np.power(beta2, t)) v_b_hat = v_b / (1 - np.power(beta2, t)) # 参数更新：结合校正后的动量和平滑后的二阶矩 self.w -= (eta / (np.sqrt(v_w_hat) + eps)) * m_w_hat self.b -= (eta / (np.sqrt(v_b_hat) + eps)) * m_b_hat self.append_log()

特点与可视化：自适应算法在动画中表现非常智能。在损失曲面平坦（梯度小）的区域，由于分母sqrt(v)也小，有效学习率较大，更新步伐加快。在陡峭（梯度大）的区域，分母变大，步伐放缓，避免震荡。Adam的路径通常看起来是“快速接近，然后精细调整”，收敛过程平滑而高效。偏差校正确保了在训练初期，当m和v接近0时，更新不会太小。

6. 实验配置、结果分析与调参心得

6.1 实验设置与超参数选择

为了公平对比算法，我们需要一套统一的实验配置。核心是定义一个配置字典或变量组：

# 1. 数据：一个简单的二分类玩具数据集 X = np.array([0.5, 2.5, 0.2, 0.9]) Y = np.array([0.2, 0.9, 0.5, 0.5]) # 2. 算法与初始点 algo = 'Adam' # 可替换为 'GD', 'Momentum', 'NAG', 'MiniBatch', 'AdaGrad', 'RMSProp' w_init, b_init = -2.0, -2.0 # 故意选择一个非最优的起点 # 3. 超参数（需根据算法调整） epochs = 200 eta = 0.5 # 学习率：对GD/Momentum/NAG敏感，对Adam等相对鲁棒 gamma = 0.9 # 动量系数 (Momentum/NAG) beta = 0.9 # RMSProp的衰减率 beta1 = 0.9 # Adam一阶矩衰减率 beta2 = 0.999 # Adam二阶矩衰减率（通常接近1） eps = 1e-8 # 数值稳定项，防止除零 mini_batch_size = 2 # 小批量大小 # 4. 可视化范围 w_min, w_max = -7, 5 b_min, b_max = -7, 5

超参数选择经验：

• 学习率 (eta/learning_rate)：这是最重要的超参数。对于Batch GD，通常需要较小值（如0.01）以防振荡。对于Adam，可以使用较大的默认值（如0.001）。一个实用的方法是尝试[0.1, 0.01, 0.001, 0.0001]等数量级。
• 动量系数 (gamma/beta1)：通常设为0.9。对于非常嘈杂的问题，可以尝试0.99。
• Adam的beta2：通常设为0.999，这使得二阶矩估计更加平滑。
• 批量大小 (mini_batch_size)：通常选择2的幂次（32, 64, 128, 256），与计算机内存和缓存机制更契合。越大，梯度估计越准，但更新越慢；越小，噪声越大，可能泛化更好（正则化效果）。

6.2 结果对比与典型行为分析

运行不同算法并生成动画后，你可以观察到以下典型模式：

1. Batch GD：路径最直，但可能在“峡谷”中缓慢 zig-zag。学习率设置过高会严重振荡甚至发散。
2. Momentum：路径更平滑，能更快穿过平坦区域。但在最小值点附近可能产生衰减的振荡。动画中可以看到“过冲”和“回调”的现象。
3. NAG：与Momentum类似，但在接近最小值时振荡幅度通常更小，看起来更“聪明”地提前减速。
4. SGD/Mini-batch GD：路径充满噪声。SGD的路径像随机游走，但整体趋势向下。Mini-batch是噪声和稳定性的折中。
5. AdaGrad：初期更新步伐大，后期步伐迅速减小直至几乎停止（分母单调增长）。在动画中，路径初期移动快，后期几乎停滞在一个点附近微调。
6. RMSProp：解决了AdaGrad学习率衰减过快的问题。路径在整个训练过程中保持相对稳定的更新节奏，能很好地适应不同方向的不同曲率。
7. Adam：结合了Momentum的“冲劲”和RMSProp的“自适应”，通常收敛最快、最平稳。在动画中，它往往能画出一条干净利落、直奔主题的路径。

6.3 常见问题与调试技巧实录

在实现和实验过程中，你肯定会遇到各种问题。以下是我踩过的一些坑和解决方法：

问题1：动画不更新或只显示最后一帧。

• 排查：检查append_log是否在每次参数更新后被正确调用。在Mini-batch GD中，是在每个batch后调用还是每个epoch后调用？这会影响动画的帧数。
• 解决：确保历史记录列表w_h,b_h,e_h在每次有意义的更新后都被追加。在动画函数animate中，确保索引映射idx = int(i * (len(sn.w_h) / animation_frames))是正确的，且idx不会超出列表范围。

问题2：损失爆炸（变成NaN）或完全不下降。

• 排查：首先怀疑学习率eta过大。对于Batch GD或Momentum，过大的学习率会导致在陡峭区域更新步伐太大，直接“飞”出损失曲面。
• 解决：将学习率调小1到2个数量级再试。对于自适应方法如Adam，可以尝试默认的0.001。另外，检查梯度计算grad_w和grad_b的公式是否正确，特别是Sigmoid导数y_pred*(1-y_pred)部分。

问题3：自适应算法（AdaGrad/RMSProp/Adam）初期更新极其缓慢。

• 排查：这是偏差校正（Bias Correction）未正确实施导致的典型问题。在训练初期，二阶矩估计v接近0，导致更新步长eta / sqrt(v+eps)的分母很小，但分子m也接近0，且未校正，使得更新量极小。
• 解决：在Adam实现中，务必加入偏差校正步骤（m_hat = m / (1 - beta1^t)）。对于RMSProp，虽然没有严格意义上的偏差校正，但可以通过使用较小的eps（如1e-8）和适当调大初始学习率来缓解。

问题4：不同算法在同一初始点收敛到不同的最终点。

• 排查：损失函数可能存在多个局部最小值或鞍点。SGD/Mini-batch由于其噪声，可能跳出某个浅坑；而Batch GD可能陷在里面。动量法也可能凭借“惯性”冲过一些浅坑。
• 解决：这是正常现象，也是我们比较算法的意义所在。你可以尝试多个不同的随机初始点，观察算法的平均表现。对于非凸问题，没有哪个算法能保证找到全局最优，Adam通常是实践中的稳健选择。

问题5：3D图渲染卡顿或模糊。

• 排查：网格分辨率过高（np.linspace点数太多）会导致计算和渲染压力大。动画帧数太多也会导致文件巨大。
• 解决：将网格点数从256降低到128或64。减少动画总帧数animation_frames，或通过在animate函数中跳帧（如idx = int(i * step)）来绘制更稀疏的路径。

7. 项目扩展与进阶思考

完成基础实现和可视化后，你可以从以下几个方向深化理解或扩展项目：

1. 实现更多优化器：尝试实现AdaDelta、Nadam、AMSGrad等更现代的优化器变种。对比它们与Adam在收敛速度和稳定性上的差异。
2. 在更复杂的模型上测试：将SN类扩展为一个单隐藏层的神经网络。损失曲面将从3D（w, b, loss）变为高维空间中的超曲面，无法直接可视化全部。但你可以固定其他参数，可视化某两个参数构成的切片，或者绘制损失随epoch下降的曲线来比较算法。
3. 系统性的超参数扫描：编写脚本，针对某个算法（如Adam），自动化地遍历一组学习率、beta1、beta2的组合，在多个随机初始点上运行，记录最终的损失值和收敛epoch数。用热力图来展示超参数的影响。
4. 研究学习率调度（Learning Rate Schedule）：实现并对比静态学习率、步进衰减（Step Decay）、指数衰减、余弦退火等策略。观察它们如何帮助模型在后期更精细地收敛。
5. 探索损失函数的影响：将均方误差（MSE）改为交叉熵损失（Cross-Entropy），这是分类任务更常用的损失。观察损失曲面的形状变化以及不同算法在其上的表现。

这个项目的真正价值不在于代码本身，而在于亲手搭建并观察这个“微观世界”的运行。每一次参数更新，每一次损失下降，都通过动画变得可见可感。这种直觉是阅读十篇论文也难以获得的。当你下次在Keras或PyTorch中写下model.compile(optimizer='adam')时，你脑海中浮现的将不再是一个黑盒，而是一幅参数在损失地形上自适应滚动的生动画面。这才是深入理解一个技术的正确方式——拆开它，重建它，最后再欣赏它。