1. ReLu函数
2. 最大池化
3. 随机丢弃
4. 数据扩增
5. GPU并行训练

首先，我们来看看什么是ALEXNET：

1. AlexNet 的基本情况

• 作者：Alex Krizhevsky、Ilya Sutskever（Hinton 的学生们）
• 提出时间：2012 年
• 数据集：ImageNet（120 万张图像，1000 个类别）
• 规模：约 650,000 个神经元、6000 万参数、6500 万连接

2. 网络结构（典型版）

输入是 227×227×3彩色图像，网络包含 8 层可训练的层（5 个卷积层 + 3 个全连接层）：

1. Conv1：96 个 11×11 卷积核，stride=4 → 输出 55×55×96
2. Max Pooling：3×3, stride=2 → 27×27×96
3. Conv2：256 个 5×5 卷积核 → 27×27×256
4. Max Pooling：3×3, stride=2 → 13×13×256
5. Conv3：384 个 3×3 卷积核 → 13×13×384
6. Conv4：384 个 3×3卷积核 → 13×13×384
7. Conv5：256 个 3×3卷积核 → 13×13×256
8. Max Pooling：3×3, stride=2 → 6×6×256
9. FC1：全连接层，4096 个神经元
10. FC2：全连接层，4096 个神经元
11. FC3：全连接层，1000 个神经元（对应 1000 个类别，Softmax 输出）

3. AlexNet 的关键创新

• 使用 ReLU 激活函数（代替传统的 Sigmoid/Tanh，加快收敛速度）。
• 使用 Dropout（随机丢弃神经元，防止过拟合）。
• 数据增强（图像平移、翻转、颜色扰动，扩大训练集有效规模）。
• GPU 并行训练（首次把 GPU 引入大规模卷积神经网络训练，大大提高训练速度）。
• 最大池化（突出最显著的特征，对背景噪声更鲁棒）。

4. 影响

• 在 2012 ILSVRC 比赛中，Top-5 错误率仅 15.3%，而第二名是 26.2%，差距非常大。
• AlexNet 的成功让业界认识到：深度卷积神经网络在大规模数据和 GPU 加速下，能远超传统方法。
• 后续的 VGG、GoogLeNet、ResNet 都是在 AlexNet 的基础上发展起来的。

接下来让我们分别看看每一个创新点

1.ReLu函数

在 AlexNet 里用的 ReLU（Rectified Linear Unit，修正线性单元），是它最重要的创新之一。

1. 传统激活函数的问题

在 AlexNet 之前，常见的非线性激活函数是 Sigmoid 和 tanh：

Sigmoid：

，输出在(0,1) 之间

tanh：

，输出在 (−1,1)之间

这两种函数的主要缺点：

1. 计算复杂：涉及指数运算，早期计算资源有限，效率不高。
2. 梯度消失：在输入很大或很小时，函数会饱和（趋近于常数），导数接近 0，导致梯度几乎传不下去 → 深层网络难以训练。

2. ReLU 的定义

f(x)=max⁡(0,x)

非常简单：小于 0 的直接变成 0，大于 0 的保持原值。

3. ReLU 的优点

• 计算高效：只需比较和截断，比 sigmoid/tanh 快得多。
• 缓解梯度消失：在 x>0 区域，梯度恒为 1，可以把误差有效传递到深层。
• 稀疏激活：当 x<0 时输出 0，很多神经元不激活，使网络稀疏化，减少参数依赖，提高泛化能力。
• 收敛速度快：在 AlexNet 的实验里，ReLU 网络的收敛速度比 tanh 快 6 倍以上。

4. ReLU 的小问题与变种

• “神经元死亡”：如果某个神经元长期输入为负，就一直输出 0，不再更新。
• 解决办法：出现了 Leaky ReLU、Parametric ReLU、ELU 等变体，在负半轴给一个小斜率，而不是完全为 0。

2.最大池化MaxPooling

1. 什么是池化？

池化就是在 特征图的局部区域 内，按照某种规则把多个像素“聚合”为一个值，从而：

• 缩小特征图尺寸（降采样）
• 减少计算量
• 增强模型对平移和局部变化的鲁棒性

简单理解就是：

把邻近像素看作一个“小池子”，然后用池化函数（如取最大值/平均值）来代表这一片区域。

2. 常见池化方法

(1) 平均池化 (Average Pooling)

• 输出 = 窗口内所有像素的平均值
• LeNet-5 使用的就是这种方式
• 特点：保留整体趋势，但细节容易被“冲淡”

(2) 最大池化 (Max Pooling)

• 输出 = 窗口内像素的最大值
• AlexNet 采用的方式
• 特点：突出最显著的特征（如边缘、角点），对背景噪声更鲁棒

(3) 全局平均池化 (Global Average Pooling, GAP)

• 对整个特征图取平均，得到单个数值
• GoogLeNet 开始流行，用于代替全连接层，减少参数

3. 池化的作用

1. 降采样：减少特征图大小和参数量
2. 平移不变性：即使目标在图像里稍微移动，池化后的特征变化不大
3. 抑制噪声：尤其是最大池化，能忽略弱特征，强化显著特征

4. LeNet vs AlexNet 的对比

• LeNet (1998)：用 平均池化 (average pooling)，更偏“平滑”
• AlexNet (2012)：改用 最大池化 (max pooling)，保留了更强的边缘和纹理特征，识别效果显著提升。

3.随机丢弃Dropout

Dropout（随机失活/随机丢弃） 是 AlexNet 中首次大规模应用的一种正则化方法，提出的动机是为了缓解深度神经网络容易出现的 过拟合 问题。它的做法很直观：在训练过程中，按照一定概率 p（通常取 0.5）随机“丢弃”部分神经元及其连接，不让它们参与本次前向传播和反向传播，相当于临时把这些神经元屏蔽掉。这样每一次训练迭代时，网络结构都不完全一样，更像是训练了很多不同的子网络。由于这些子网络共享权重，最后整体效果相当于在做一种“模型集成”，能显著提高网络的泛化能力。

在实际实现时，Dropout 只在训练阶段起作用，测试阶段则恢复所有神经元，但会把权重按丢弃概率缩放，使得输出的期望保持一致。AlexNet 正是因为采用了 Dropout，有效缓解了当时训练大规模网络时严重的过拟合问题，才能在 ImageNet 上取得远超传统方法的表现。

4.数据扩增Data Augumentation

AlexNet 用的 ImageNet 数据集已经有 120 万张标注图片，在当时算是非常庞大的训练集了。但即便如此，这样一个 拥有 6000 万参数 的深度卷积神经网络，依然容易 过拟合。原因有两个：

第一，网络容量太大。
AlexNet 的参数规模比以往的模型大得多，它有能力“记住”训练数据里的很多细节甚至噪声。如果没有更多样化的数据，它在测试集上就会表现下降。

第二，样本分布不够“丰富”。
虽然 ImageNet 总量大，但对每个类别来说，图片的采集场景有限：

• 大部分照片拍摄角度类似
• 光照条件相对单一
• 物体位置、比例变化不够多

这会导致网络学习到的特征偏向于这些“训练集特定的分布”，泛化能力不足。

因此，数据增强（Data Augmentation）就显得非常重要。AlexNet 里采用的增强方法主要有：

• 随机裁剪：从原始 256×256 图像中随机裁出 224×224 的区域，增加平移与缩放的变化。
• 水平翻转：随机把图片左右翻转，让模型学会对称性。
• RGB 通道扰动：对颜色做轻微变化，模拟不同光照环境。

这些操作能在 不增加人工标注成本 的前提下，成倍地产生新的训练样本。这样一来，网络不仅见过“猫的正面照片”，也见过“猫的翻转照片”；不仅见过“光线好的苹果”，也见过“偏暗的苹果”。最终效果就是 提升泛化性能，降低过拟合。

5.GPU并行训练

在 2012 年的时候，深度神经网络的规模已经远远超出了普通 CPU 的承载能力。AlexNet 大约有 6000 万参数、6.5 亿连接，如果完全用 CPU 训练，可能要几个月甚至更久，几乎不可行。

Alex Krizhevsky 当时采用了 两块 NVIDIA GTX 580 GPU（每块显存 3GB） 来加速训练，并设计了一种 跨 GPU 的分工机制：

• 通道切分（channel split）：每一层的特征图通道数被 平均分成两份，上面一半分配给 GPU1，下面一半分配给 GPU2。
• 卷积局部计算：大多数卷积操作只在“本 GPU 的通道子集”上完成，减少跨卡通信量。
• 有限的跨 GPU 连接：在某些层（如 Conv3、Conv4、Conv5）引入少量跨 GPU 的连接，用来保持特征的一致性。

这样做的好处是：

1. 分担显存压力：当时的显存有限，把通道拆分能保证网络能放下。
2. 并行计算：两个 GPU 同时运算，大幅缩短训练时间。AlexNet 最终用了 5~6 天 就在 ImageNet 上完成训练，而不是几个月。
3. 工程上的突破：这是深度学习第一次真正利用 GPU 进行大规模卷积神经网络的训练，奠定了后面“GPU 是深度学习核心算力”的基础。

思考题：根据LeNet参数个数为61706个，计算ALEXNET每层参数的个数。

卷积层

• Conv1：11×11×3×96+96=34944
• Conv2（groups=2）：每个核只连到上一层的一半通道 48
  5×5×48×256+256=307456
• Conv3（不分组）：3×3×256×384+384=885120
• Conv4（groups=2）：3×3×192×384+384=663936
• Conv5（groups=2）：3×3×192×256+256=442624

全连接层

• FC6（6×6×256=9216→4096）：9216×4096+4096=37752832
• FC7（4096→4096）：4096×4096+4096=16781312
• FC8（4096→1000）：4096×1000+1000=4097000

总计

60965224

（≈ 6,096 万参数）

1. LeNet-5 的基本结构

LeNet-5 由 7 层（不包括输入层）组成，包括卷积层、池化层、全连接层：

1. 输入层
   • 输入图像大小：32 × 32 像素灰度图。
   • （MNIST 是 28 × 28，LeNet 会在周围补白到 32 × 32）。
2. C1：第1个卷积层
   • 卷积核大小：5 × 5
   • 卷积核数量：6
   • 输出特征图大小：28 × 28 × 6
   • 作用：提取局部边缘、线条等低级特征。
3. S2：第1个下采样层（平均池化）
   • 池化核：2 × 2，步长 2
   • 输出特征图大小：14 × 14 × 6
   • 作用：减少参数，增强特征平移不变性。
4. C3：第2个卷积层
   • 卷积核大小：5 × 5
   • 卷积核数量：16
   • 输出特征图大小：10 × 10 × 16
   • 作用：提取更复杂的形状（如角点、组合结构）。
5. S4：第2个下采样层（平均池化）
   • 池化核：2 × 2，步长 2
   • 输出特征图大小：5 × 5 × 16
   • 作用：进一步压缩特征图。
6. C5：第3个卷积层（特殊，全连接卷积）
   • 卷积核大小：5 × 5
   • 卷积核数量：120
   • 因为输入是 5 × 5，卷积后得到 1 × 1 × 120
   • 作用：相当于“全连接层”，整合所有特征。
7. F6：全连接层
   • 节点数：84
   • 使用 sigmoid 激活函数（当时没有 ReLU）。
   • 作用：作为分类前的特征整合层。
8. 输出层
   • 节点数：10（对应 0~9 的手写数字类别）。
   • 使用 Softmax 作为输出。

2. LeNet-5 的特点

• 局部连接：不同于全连接层，卷积层只和输入的一小块区域相连。
• 权值共享：同一个卷积核在不同位置共享权重，大幅减少参数数量。
• 分层特征提取：从边缘 → 局部组合 → 整体形状 → 分类结果。
• 池化机制：增强模型对位置变化的鲁棒性。

3. LeNet-5 的影响

• 是 第一个被广泛应用的卷积神经网络，在银行支票识别中取得成功。
• 奠定了现代 CNN 的基本框架（Conv → Pooling → Conv → Pooling → FC → Softmax）。
• 后续的 AlexNet (2012) 在此基础上引入了 ReLU、Dropout、GPU 训练，才真正引爆了深度学习浪潮。

那么我们如何求解卷积核中参数的梯度呢？

P1（左上）： P1=ω₁X₁+ω₂X₂+ω₃X₄+ω₄X₅

P2（右上）：  P2=ω₁X₂+ω₂X₃+ω₃X₅+ω₄X₆

P3（左下）：  P3=ω₁X₄+ω₂X₅+ω₃X₇+ω₄X₈

P4（右下）：  P4=ω₁X₅+ω₂X₆+ω₃X₈+ω₄X₉

积核参数的梯度（反向传播）

若损失为 LLL，上游梯度记为

​（k=1,2,3,4），则每个权重的梯度是“对应位置输入的加权和”：

（若有偏置 b，则 ∂L/∂b=δ₁+δ₂+δ₃+δ₄）

记忆方法：哪个输出位置用了某个权重乘了哪一个输入像素，反传时就把该输出的上游梯度乘回那像素并累加到该权重的梯度上。
推广到更大核/更大特征图/多通道完全一样：对所有位置求和即可。

降采样层（引入）

1. 为什么需要降采样层？

在卷积网络的早期设计（LeNet-5、AlexNet）里，降采样的动机主要有：

• 减少数据量：降低特征图空间尺寸，减少计算量和参数量。
• 防止过拟合：通过压缩信息，减少模型过度拟合细节噪声的风险。
• 增强平移不变性：在小范围平移、旋转下，池化能保持特征稳定（例如猫耳朵往左移一点，特征依然能被识别）。

2. 常见的降采样方式

(1) 最大池化（Max Pooling）

• 公式：从窗口内取最大值作为输出。
• 特点：保留最显著的特征，丢弃背景或弱特征。
• 常用参数：2×2 窗口，stride=2。
• 优点：效果直观，表现好。

(2) 平均池化（Average Pooling）

• 公式：对窗口内所有值取平均值。
• 特点：保留整体趋势，平滑特征。
• LeNet-5 就用了平均池化（叫“subsampling”）。

(3) 全局平均池化（Global Average Pooling, GAP）

• 公式：直接对整个特征图取平均，得到 1 个值。
• 应用：现代 CNN（如 GoogLeNet）用 GAP 来代替全连接层，减少参数并提升泛化。

(4) 随机池化 / Lp 池化

• 一些研究提出过随机选择、或者 Lp 范数池化，但应用没有前两种普遍。

import platform

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
system = platform.system()
if system == "Windows":
    matplotlib.rcParams['font.family'] = 'Microsoft YaHei'
elif system == "Darwin":
    matplotlib.rcParams['font.family'] = 'Arial Unicode MS'
else:
    matplotlib.rcParams['font.family'] = 'SimHei'
matplotlib.rcParams['axes.unicode_minus'] = False
# 构造一个4x4的输入特征图
input_matrix = np.array([
    [1, 3, 2, 4],
    [5, 6, 7, 8],
    [9, 2, 0, 1],
    [3, 4, 5, 6]
])

# 最大池化 2x2 stride=2
output_matrix = np.array([
    [np.max(input_matrix[0:2, 0:2]), np.max(input_matrix[0:2, 2:4])],
    [np.max(input_matrix[2:4, 0:2]), np.max(input_matrix[2:4, 2:4])]
])

fig, axes = plt.subplots(1, 2, figsize=(8,4))

# 输入矩阵可视化
axes[0].imshow(input_matrix, cmap="Blues", vmin=0, vmax=9)
for i in range(4):
    for j in range(4):
        axes[0].text(j, i, input_matrix[i,j], ha="center", va="center", color="black")
axes[0].set_title("输入特征图 (4x4)")

# 输出矩阵可视化
axes[1].imshow(output_matrix, cmap="Oranges", vmin=0, vmax=9)
for i in range(2):
    for j in range(2):
        axes[1].text(j, i, output_matrix[i,j], ha="center", va="center", color="black")
axes[1].set_title("池化输出 (2x2)")

plt.tight_layout()
plt.show()

效果图：

计算LeNet待估计参数个数：61684个

这个 61684 的总数，是把 C1 和 C3 不计偏置，其余层计了偏置 的“混合口径”算出来的。
逐项对应你给的公式：

• C1：5×5×6=150（只算权重，没加 6 个 bias）
• S2：0（现代实现里池化无可学习参数）
• C3：5×5×6×16=2400（只算权重，没加 16 个 bias）
• S4：0
• C5：120×(16×5×5+1)=48,120（含 bias）
• F6：120×84+84=10,164（含 bias）
• 输出：84×10+10=850（含 bias）

把这些相加：150+0+2400+0+48120+10164+850=61684

三种常见口径对齐：

61,684 = 上表“加上偏置”的总数 61,706 −（C1 的 6 + C3 的 16）= 61,706 − 22。

思考题请见下一页

1. 背景

• 在深度学习早期（2000 年前后），深层神经网络训练很难：
  • 随机初始化 → 反向传播时梯度消失 / 爆炸；
  • 没有足够标注数据，深层网络容易陷入局部最优。
• Hinton 提出利用 自编码器 逐层无监督训练网络，把深度模型拆解成若干层来初始化参数。

2. 分层初始化的核心思想

逐层训练 + 自底向上堆叠：

1. 先训练一个浅层自编码器（输入层 → 隐层 → 重构输出层），学到第一层特征。
2. 固定第一层权重，只保留隐层表示，作为“输入”去训练第二个自编码器，得到第二层特征。
3. 重复以上过程，层层堆叠，直到得到多层网络的参数。
4. 最后把这些预训练好的权重作为深度神经网络的 初始化参数，再用有监督的目标（分类/回归）进行 整体微调（fine-tuning）。

3. 为什么有效？

• 缓解梯度消失问题：每一层都先单独学会“有用的特征”，不依赖深层反向传播。
• 更好的初始化：比随机初始化更接近“合适区域”，微调时更容易收敛。
• 利用无标签数据：自编码器训练不需要标签，可以充分利用海量未标注农作物图像。

Matlab代码

3.function sae= sae create(SIZE)
    sae =nn create([SIZE(1),SIZE(2),SIZE(1)]) %输入和输出都是SIZE1,中间层是SIZE2 这是各层训练初始化的过程
4.function sae =sae train(sae,option,train_x)
    sae.encoder = 1;
    sae=nn train(sae,option,train_x,train_x)
end

(1)一般情况下，在训练集上的目标函数的平均值(cost)会随着训练的深入而不断减小，如果这个指标有增大情况，停下来。
有两种情况:

• 采用的模型不够复杂，以致于不能在训练集上完全拟合;
• 已经训练很好了。

(2)分出一些验证集Validation Set，训练本质目标是在验证集上获取最大识别率。因此训练一段时间后，必须在验证集上测试识别率，保存使验证集上识别率最大的模型参数作为最后的结果。

(3)注意调整学习率Learning Rate，如果刚训练几步损失函数就增加，一般来说是学习率太高；反之如果每次cost变化很小，说明学习率太低。

一点人生的经验：

（1）目标函数可以加入正则项

Minimize E(ω，b)=L(ω，b)+λ/2 ||ω||²

L(ω，b)为原来的目标函数，λ/2 ||ω||²为正则项。λ为权值衰减系数

参考前向传播nn_forward.m

if strcmp(nn.objective_function,'MSE')
            nn.cost(s) = 0.5 / m * sum(sum((nn.a{k} - batch_y).^2)) + 0.5 * nn.weight_decay * cost2;
        elseif strcmp(nn.objective_function,'Cross Entropy')
            nn.cost(s) = -0.5*sum(sum(batch_y.*log(nn.a{k})))/m + 0.5 * nn.weight_decay * cost2;

后向传播nn_backpropagation.m

nn.W_grad{nn.depth-1} = nn.theta{nn.depth}*nn.a{nn.depth-1}'/m + nn.weight_decay*nn.W{nn.depth-1};
nn.b_grad{nn.depth-1} = sum(nn.theta{nn.depth},2)/m;

（2）训练数据归一化

newX=[X-mean(X)]/ std(X)

（3）参数ω和b的初始化

一种比较简单有效的方法：

（ω，b）初始化从区间（-1/sqrt(d),1/sqrt(d)）均匀随机取值，其中d为（ω，b）所在层的神经元个数。

可以证明如果X服从均值0方差1的正态分布，且各个维度无关，而（ω，b）是区间（-1/sqrt(d),1/sqrt(d)）的均匀分布，则ω^TX+b是均值0，方差为1/3的正态分布

nn_create.m

nn.W{k} = 2*rand(height, width)/sqrt(width)-1/sqrt(width);%rand产生伪随机数矩阵，即W权重矩阵初始化
nn.b{k} = 2*rand(height, 1)/sqrt(width)-1/sqrt(width);%b阈值的初始化

避免一开始梯度趋近于0的现象。

（4）BATCH NORMALIZATION

论文:Batch normalization accelerating deep network training by reducing internal covariate shift(2015)

在这可以看：

基本思想:既然我们希望每一层获得的值都在0附近，从而避免梯度消失现象，那么我们为什么不直接把每一层的值做基于均值和方差的归一化呢?

（5）参数的更新策略

ADAGRAD的方法

if strcmp(nn.optimization_method,'AdaGrad')
nn.rW{k}= nn.rW{k}+nn.W_grad{k}.^2;nn.rb{k}= nn.rb{k}+nn.b_grad{k}.^2;
nn.W{k}=nn.W{k}-nn.learning_rate*nn.W_grad{k}./(sqrt(nn.rW{k})+0.001);
nn.b{k}=nn.b{k}-nn.learning_rate*nn.b_qrad{k}./(sqrt(nn.rb{k})+0.001);

解决梯度随机性的问题：引入Momentum

同时结合：Adam-解决梯度绝对值分量不平衡和梯度方向随机性的问题，也引入了逐渐降低梯度搜索步长的机制。

算法步骤解释

1. Require
   • Step size (ϵ，学习率)，推荐默认值 0.001。
   • Exponential decay rates (ρ1,ρ2​)：分别控制一阶、二阶动量的衰减速率。推荐默认值 ρ1=0.9，ρ2=0.999。
   • Small constant δ：数值稳定常数，防止分母为零，默认 10⁻⁸。
   • Initial parameters θ：模型初始参数。

2. Initialize
   • 一阶动量变量 s=0（存放梯度的指数加权平均，类似 Momentum）。
   • 二阶动量变量 r=0（存放梯度平方的指数加权平均，类似 RMSProp）。
   • 时间步 t=0。
3. 循环过程 (直到满足停止条件，例如迭代次数用完或收敛)
   • Step A. 采样一个 minibatch
     • 从训练集取出一个小批量样本 {x⁽¹⁾,...,x^(m)} 和对应标签。
   • Step B. 计算梯度

即小批量平均梯度。

Step C. 时间步递增

t←t+1

Step D. 更新一阶动量（偏置的）

s←ρ1s+(1−ρ1)g

——这是梯度的指数滑动平均（类似 Momentum）。

Step E. 更新二阶动量（偏置的）

r←ρ2r+(1−ρ2)(g⊙g)

——这里 ⊙表示逐元素乘法。即对梯度平方取指数滑动平均（类似 RMSProp）。

Step F. 偏差修正
由于初始化 s=0,r=0，前期会有向零偏移，需要修正：

​Step G. 计算更新量

Step H. 更新参数

θ←θ+Δθ

总结

• sss：梯度的一阶动量（方向 + 平滑）。
• rrr：梯度的二阶动量（幅度 + 自适应缩放）。
• 偏差修正：解决初期 (s,r≈0)的估计偏差问题。
• 更新公式：学习率会根据梯度历史动态调整，每个参数有自己独立的学习率。

Adam 的更新可以理解为：
用 Momentum 决定方向，再 用 RMSProp 决定步长大小。

Python代码示例（一阶动量用 s，二阶动量用 r，含偏差修正；并给了一个最小化二次函数的小示例）：

import numpy as np

class Adam:
    """
    Adam 优化器（Algorithm 8.7）
    s: 一阶动量（biased）
    r: 二阶动量（biased）
    """
    def __init__(self, shape, lr=1e-3, rho1=0.9, rho2=0.999, eps=1e-8):
        self.lr   = lr        # ε (step size)
        self.rho1 = rho1      # ρ1
        self.rho2 = rho2      # ρ2
        self.eps  = eps       # δ
        self.s    = np.zeros(shape)  # 初始化一阶动量 s=0
        self.r    = np.zeros(shape)  # 初始化二阶动量 r=0
        self.t    = 0                  # 初始化时间步 t=0

    def step(self, theta, g):
        """
        单次更新：
        theta: 参数
        g:     当前梯度（对 minibatch 的平均梯度）
        return: 更新后的参数
        """
        # t ← t + 1
        self.t += 1

        # Update biased first moment estimate: s ← ρ1 s + (1-ρ1) g
        self.s = self.rho1 * self.s + (1.0 - self.rho1) * g

        # Update biased second moment estimate: r ← ρ2 r + (1-ρ2) (g ⊙ g)
        self.r = self.rho2 * self.r + (1.0 - self.rho2) * (g * g)

        # Correct bias:
        # ŝ = s / (1 - ρ1^t),   r̂ = r / (1 - ρ2^t)
        s_hat = self.s / (1.0 - self.rho1 ** self.t)
        r_hat = self.r / (1.0 - self.rho2 ** self.t)

        # Compute update: Δθ = -ε * ŝ / (sqrt(r̂) + δ)
        delta_theta = - self.lr * s_hat / (np.sqrt(r_hat) + self.eps)

        # Apply update: θ ← θ + Δθ
        theta = theta + delta_theta
        return theta

# ================= 示例：最小化 f(θ)=∑ θ_i^2 =================
# 真梯度：∇f(θ)=2θ
np.random.seed(0)
theta = np.random.randn(3) * 5.0        # 初始参数
opt   = Adam(shape=theta.shape, lr=1e-2) # 用默认 ρ1=0.9, ρ2=0.999, δ=1e-8

for k in range(1, 501):
    g = 2.0 * theta                      # 计算梯度 (小批量平均梯度在真实任务里替换这里)
    theta = opt.step(theta, g)           # 按图中流程更新
    if k % 100 == 0:
        fval = (theta**2).sum()
        print(f"iter {k:3d}  f(theta)={fval:.6f}  theta={theta}")

# 输出会看到 f(θ) 单调下降，θ 收敛到 0 附近

输出：

iter 100  f(theta)=78.124320  theta=[7.84011204 1.09919008 3.93048901]
iter 200  f(theta)=57.552498  theta=[6.91704488 0.49699096 3.07570938]
iter 300  f(theta)=42.152403  theta=[6.0541767  0.17936161 2.33819949]
iter 400  f(theta)=30.556370  theta=[5.25288565 0.05091135 1.72074696]
iter 500  f(theta)=21.872385  theta=[4.51437396 0.01130478 1.22175496]

结果逐行解释

输出是每 100 次迭代打印一次：

Iter 100

f(theta)=78.124320  
theta=[7.84011204 1.09919008 3.93048901]

• 初始 θ 很大（一开始是 np.random.randn(3)*5 随机出来的）。
• 经过 100 步更新后，参数值比初始小了一些，但还比较大。目标函数 f(θ) 还在 78 左右。

Iter 200

f(theta)=57.552498  
theta=[6.91704488 0.49699096 3.07570938]

• θ 的数值进一步下降了（尤其是第二个分量从 ~1.1 → 0.49）。
• 函数值 f(θ) 从 78 降到了 57，说明 Adam 在往 0 的方向走。

Iter 300

f(theta)=42.152403  
theta=[6.0541767  0.17936161 2.33819949]

• 继续下降，f 值变成 ~42。
• 第二个分量（0.179）几乎快收敛到 0 了。

Iter 400

f(theta)=30.556370  
theta=[5.25288565 0.05091135 1.72074696]

• 三个分量继续减小，函数值也继续下降。
• 可以看出来参数在逐步往 0 收缩。

Iter 500

f(theta)=21.872385  
theta=[4.51437396 0.01130478 1.22175496]

• 此时 f 值还在下降（21），但下降速度变慢了。
• 第二个参数已经基本到 0（0.01），其他两个参数也明显比最开始小了很多。

总结

1. 趋势：函数值从 78 → 57 → 42 → 30 → 21，说明优化器 Adam 确实在不断让目标函数下降。
2. 参数收敛：θ 在逐步往 0 收敛（最终最优解）。
3. 下降速度：一开始下降快，后面越来越慢，这是正常的，因为越靠近最优点，梯度越小。
4. 未到 0：500 步还没完全到 0，是因为学习率比较小（lr=0.01），如果继续迭代或适当调大学习率，θ 会更快逼近 0。

画图验证Adam 能不断减小损失函数，并逐渐收敛到最优解的python代码请到第2页查看

读入数据（one-hot两类情形）：

if string(13) == 100
            yapp = [yapp,[1,0]'];
        else
            yapp = [yapp,[0,1]'];
        end;

划分数据集分配：

ratioTraining = 0.15;    % 15%训练
ratioValidation = 0.05;  % 5%验证
ratioTesting = 0.8;      % 80%测试

分别对训练、验证、测试数据集进行归一化：

xTraining = (xTraining - repmat(avgX,U,1))./repmat(sigma,U,1);
xValidation = (xValidation - repmat(avgX,U,1))./repmat(sigma,U,1);
xTesting = (xTesting - repmat(avgX,U,1))./repmat(sigma,U,1);

整个神经网络的构建、训练和测试：

nn = nn_create([6,10,10,10,10,10,10,10,10,10,10,2],'active function','relu','learning rate',0.005, 'batch normalization',1,'optimization method','Adam', 'objective function', 'Cross Entropy');
%数组代表了神经网络每一层中的神经元个数。学习率α：learning rate、目标函数：objective function、神经网络的激活函数：active function；输入是6个维度，输出是2个维度，10层，每层有10个神经元。

其他解读：

option.batch_size = 100;%每个mini-batch中有100个训练样本
maxIteration = 10000; %最大训练轮次10000轮
nn = nn_train(nn,option,xTraining,yTraining);%训练
totalCost(iteration) = sum(nn.cost)/length(nn.cost);%测试平均的损失函数
[wrongs,accuracy] = nn_test(nn,xValidation,yValidation); %在验证集测试识别率

深入程序内部：

nn_forward.m

前向计算：

从第K-1层到第K层的输出过程：K-1层输出*权重矩阵ω+偏置

y = nn.W{k-1} * nn.a{k-1} + repmat(nn.b{k-1},1,m);
%repmat(A,m,n)将A复制m×n块
        %由于进行批处理，将m组数据存在矩阵同时处理，而对每组数据来说阈值设定是相同的，故将b复制m次
        %此处y即为所给推导方法中的z.

经过非线性函数获得第K层输出：

 switch nn.active_function%隐层激活函数选择
                case 'sigmoid'
                    nn.a{k} = sigmoid(y);
                case 'tanh'
                    nn.a{k} = tanh(y);
                case 'relu'
                    nn.a{k} = max(y,0);
            end

后向传播（根据前面学过的SIGMOID,TANH,SOFTMAX+CROSSENTROPY）：

nn_backpropagation.m

switch nn.output_function 
        case 'sigmoid'
            nn.theta{nn.depth} = -(batch_y-nn.a{nn.depth}) .* nn.a{nn.depth} .* (1 - nn.a{nn.depth});
        case 'tanh'
            nn.theta{nn.depth} = -(batch_y-nn.a{nn.depth}) .* (1 - nn.a{nn.depth}.^2);
        case 'softmax'
            nn.theta{nn.depth} = nn.a{nn.depth} - batch_y;
    end

多层神经网络参数的更新过程：

nn_applygradient.m

if strcmp(nn.optimization_method, 'normal')
            nn.W{k} = nn.W{k} - nn.learning_rate*nn.W_grad{k};
            nn.b{k} = nn.b{k} - nn.learning_rate*nn.b_grad{k};

与3.7第2页中总结（4）迭代公式一样。

忘记了？看看

这个可以用来代替阶跃函数。

常用的非线性函数双曲正切tah函数表达式如下：

这个tanh的导数有：

对于目标函数，可以用预测值y和真实值Y差的模的平方：

但通常用基于softmax和交叉熵（cross-entropy）的目标函数。

这些是什么东西？

一、Softmax 函数是什么？

定义：

Softmax 是一个将实数向量变换为概率分布的函数。设输入为向量 z = [z₁, z₂, ......, z_n]，Softmax 输出为：

特点：

• 输出值范围在 (0, 1) 之间；
• 所有输出值加起来是 1，所以可以看作是一个概率分布；
• 最大值对应的类的概率最大，适用于分类问题。

应用场景：

• 多分类神经网络的输出层；
• 强化学习中的策略分布；
• 注意力机制中的归一化权重（softmax attention）。

二、交叉熵函数是什么？

定义：

交叉熵衡量的是两个概率分布之间的差异，常用于度量模型输出的概率分布与真实标签之间的距离。

设真实标签为 one-hot 编码的向量 Y，预测输出为 softmax 概率 y，交叉熵损失函数定义为：

实际效果：

• 如果预测 y_i 趋近于真实标签对应的 1，则损失趋近于 0；
• 如果预测错误（即真实标签对应的 y_i 趋近于 0），则损失趋近于 +∞；
• 因此它鼓励模型“自信且正确”地做出分类。

↓那么就可以用softmax+交叉熵来证明一个非常简洁的求偏导公式↓

三、Softmax + CrossEntropy 的组合：为什么要一起用？

在 PyTorch、TensorFlow 等框架中，这两个通常合并为一个函数（如 F.cross_entropy()），原因如下：

1. 数值稳定性：单独计算 softmax 后再计算 log，容易造成梯度爆炸或 underflow；
2. 优化效率：合并后的函数可以直接用更快更稳定的算法实现；
3. 梯度简洁：反向传播时，Softmax + CrossEntropy 的梯度简洁优雅，便于学习和实现。

反向传播的梯度（多分类）：

设 L 为交叉熵损失，z_i 为 softmax 输入，Y_i 为真实标签（one-hot），则：

这意味着反向传播时，只需预测概率 - 实际标签，非常高效！

四、举个例子

假设我们有三个类别，模型输出 logits 是： z=[2.0,1.0,0.1]

用 softmax 得到： y=Softmax(z)=[0.659,0.242,0.099]

假设真实标签是第一类（即 Y = [1, 0, 0]），那么交叉熵损失是： −log⁡(0.659)≈0.417

而对于此处的【三】，推理证明过程如下：

这个简洁优雅的偏导公式：

或者向量形式：

是 Softmax + CrossEntropy 的组合在反向传播中的黄金公式，我们下面用逐步推导法来详细证明它，逻辑清晰，结果精确。

前提定义

设：

模型输出 logits 向量为 z = [z₁, z₂, ......, z_n]

softmax 输出为

真实标签为 one-hot 向量 Y = [Y₁, Y₂, ......., Y_n]

损失函数为交叉熵：

目标：求 E对z_k的偏导

第一步：链式法则分步计算

第二步：分别求导

① 交叉熵对 softmax 输出的导数

② softmax 输出对 z 的偏导

分情况讨论（这是关键）：

第三步：合并两部分

将上面两项相乘并相加：

我们将它拆分为两部分：

当 i = k：

当 i ≠ k：

而 one-hot 编码下

，因此：

总结结果

这个推导成立的前提是使用 softmax + cross entropy 的组合，并且标签是 one-hot 向量。

延伸说明：为什么这很重要？

• 这个公式使得反向传播极其高效，避免了显式求导和链式展开；
• 框架如 PyTorch、TensorFlow 在 CrossEntropyLoss 中自动融合了 softmax 和 log 操作，实现了这个精确求导；
• 也说明了 softmax 输出已经是概率分布，损失的梯度本质上就是“预测误差”。

上面就是多层神经网络的第二个改进，这个是比原来的E要好的（↓）

多层神经网络的第三个改进是随机梯度下降法SGD，要点如下：

1. 不用输入每个样本就去更新参数；而是输入一批样本（BATCH/MINI-MATCH)，求出这些样本的梯度平均值后，根据平均值来改变参数。
2. 在神经网络训练中，样本数（BATCH-SIZE）大概设置在50-200之间
   • 按照BATCH遍历所有训练样本一次，这一次称为一个EPOCH。
3. 对于所有训练数据，根据BATCH-SIZE分割为不同的BATCH。

实际训练中，根据BATCH多次遍历所有训练样本，即训练不止一个EPOCH，增加BATCH中训练样本的随机性。

本章节的思考部分，请至第二页继续阅读

梯度下降算法的具体求解过程，或称 链式求导法

∵

∴

接着根据偏导数的链式求导法则：

继续用链式求导法则：

根据上式，有：

因为已经有：

又因为y=ω₁z₁+ω₂z₂+b₃

所以：

同理因为z₁=φ(α₁)

综合可得

经过相似推导，有：

通过三个枢纽位置的偏导数求出九个偏导数：

由于：y=ω₁z₁+ω₂z₂+b₃

有：

由于a₁=ω₁₁x₁+ω₂₁x₂+b₁

总结（第1部分）

1.对神经网络每一层各个神经元，随机选取相应的ω，b的值

2.设置目标函数E，例如E=1/2 (y-Y)² 用后向传播算法对每一个ω，b计算

3.然后用

更新ω和b的值。

4.回到2.不断循环，直到所有

很小为止，退出循环。

本部分的后向传播算法结束。请点击【第2页】来看一种更一般的神经网络

假定神经网络是某一种结构

将一堆训练数据输入到这个网络中

估计这个网络的待求参数

算法模型的复杂度要和训练样本的复杂度匹配=>对于训练样本很多的情况->增加神经网络的层数和神经元的个数

统一式子表达：y=(ω₁ω₁₁+ω₂ω₂₁)x₁+(ω₁ω₁₂+ω₂ω₂₂)x₂+(ω₁b₁+ω₂b₂+b₃)【上一章的东西】

使小y和标签Y尽可能接近：

Min：E(ω，b)=E（X,Y）[(Y-y)²]

遍历训练样本及标签的数学期望

由于y=>ω，b的非凸函数

用梯度下降法（Gradient Descent Method）求解局部极小值

（1）随机选取ω和b的初始值（ω⁽⁰⁾,b⁽⁰⁾）

（2）应用迭代算法发求目标函数的局部极值

在第n步迭代中，ω和b的更新公式如下：

α₁=ω₁₁x₁+ω₁₂x₂+b₁（第一个神经元）

α₂=ω₂₁x₁+ω₂₂x₂+b₂（第二个神经元）

z₁=φ(α₁)（非线性函数）

z₂=φ(α₂)（非线性函数）

y=ω₁z₁+ω₂z₂+b₃（第三个神经元）

展开y=(ω₁ω₁₁+ω₂ω₂₁)x₁+(ω₁ω₁₂+ω₂ω₂₂)x₂+(ω₁b₁+ω₂b₂+b₃)

层与层之间不加非线性函数=>多层神经网络将会退化到一个神经元的感知器模型状态。

加入非线性函数：阶跃函数

φ(x)={1(x>0); 0(x<0)

为什么？

如果非线性函数采用阶跃函数，那么三层神经网络可以模拟任何的非线性函数。

定理：三层神经网络可以模拟所有的决策面。

设y=-1表示X是非连通图。

用 反证法 证明 识别连通图问题是非线性可分的：

假设：

这个问题是线性可分的，那么一定存在（ω，b）：

当y=+1时，ω^Tx+b≥0；

当y=-1是，ω^Tx+b＜0

图1连通：y=+1

2（1）1+2+3+5+6+b≥0

5（2）1+2+3+4+7+b≥0

口-（3）1+2+3+4+5+b＜0

-口（4）1+2+3+6+7+b＜0

公式1+2，有2[1+2+3+b]+4+5+6+7≥0

公式3+4，有2[1+2+3+b]+4+5+6+7<0

那么两个新公式相同，不可能同时＞0，＜0.

所以识别连通图的问题是非线性可分的。

思考：请证明【一笔画问题】是【非线性可分】问题。即区分两类二值图像，一种可以用一笔画出，另一种不能一笔画出。要证明这个问题的非线性可分问题。

结论

“能否一笔画完”的判定 不是线性可分的。
下面给出一种 构造-反证：把经典的 XOR（奇偶）问题 嵌入到“一笔画”判定里；因为 XOR 本身在任何原始特征空间都不可线性分离，一旦它是“一笔画”问题的子问题，就说明整题也必然非线性可分。

1 预备：一笔画⇔顶点奇偶性

对无向图 G=(V,E) 来说

G 可一笔画  ⟺  ∣{v∈V∣deg⁡(v) 为奇}∣  =0 或 2.

于是只要我们能构造一个极小图，使

• 偶数条边 ⇒ 奇点数为 0 或 2 (阳性)
• 奇数条边 ⇒ 奇点数 > 2 (阴性)

就形成了 “边数奇偶＝类别标签” 的 奇偶判定。

2 构造一个 3 条边的“星形”子问题

      A
      |
     x1
      |
      O —— x2 —— B
      |
     x3
      |
      C

• 顶点：中心 O和三个端点 A,B,C。
• 可选边（特征） x₁=OA,  x₂=OB,  x₃=OC ∈{0,1}.

数据集 D（8 个可能图，用 (x1,x2,x3) 表示）

边的组合	奇点个数	是否一笔画	类别
(0,0,0)	0		+1
(1,0,0)	2		+1
(0,1,0)	2		+1
(0,0,1)	2		+1
(1,1,0)	2		+1
(1,0,1)	2		+1
(0,1,1)	2		+1
(1,1,1)	4		–1

观察可知：

类别  =  {

• +1,若 x1+x2+x3 为偶数,
• −1,若 x1+x2+x3 为奇数

这正是三维 偶／奇 (Parity) 函数——它是经典的 XOR 在 3 维的推广。

3 XOR / 奇偶函数为什么线性不可分？

给出一种简洁的几何论证（Minsky & Papert 1969 同款）：

• 正样本集合
  P={(0,0,0),(1,1,0),(1,0,1),(0,1,1)} 的 凸包
  含有点 (1/2,1/2,1/2)。
• 负样本集合
  N={(1,0,0),(0,1,0),(0,0,1),(1,1,1)} 的凸包
  同样 含有该点(1/2,1/2,1/2)。

若两类能被一条超平面分开，则其凸包必须互不相交；
但这里两凸包 相交，故不存在任何线性分割面。
因此 Parity / XOR 非线性可分。

4 归结到一笔画问题

• 我们已经把“一笔画”中的一个小子集 D映射成 Parity；
• 若整体问题可被一个超平面分割，则 D 也必能被同一超平面分割——与上一节矛盾。

所以：区分“一笔画图”和“非一笔画图”的整体二分类任务 不存在 任何基于原始 0/1 像素（边存在与否）的线性判别函数；即它是 非线性可分问题。

5 结论与启示

• 证明思路：把已知的 XOR 难题嵌入目标任务
  → 找到凸包相交
  → 否定线性可分性。
• 工程意义
  • 想要自动判别一笔画图片，必须借助 核技巧 / 深度模型 / 非线性特征；
  • 单层感知器或任何纯线性模型都无法完成该区分。