# 06. CNN 卷积神经网络（MNIST 冲 99%）

> 同一份 MNIST 数据，全连接只能 97.7%，CNN 直接 **99.15%**。
> 这一篇讲清卷积为什么更适合图像。

---

## 一、跑通结果对比

```
全连接 MLP : 97.70%
CNN        : 99.15%   ← 错误率 2.3% → 0.85%，砍掉一大半
CNN 参数量 : 421,642
```

---

## 二、卷积层在算什么？

全连接把图片**拉平**成 784 维 → **丢掉空间信息**（谁挨着谁不知道了）。

CNN 不拉平，保留 2D 结构，用小窗口（卷积核）在图上滑动：

```
卷积核(3×3)滑过图像，每处做"对应相乘再求和"：
  Σ(核 × 覆盖像素) = 1个输出值
滑遍全图 → 一张特征图(feature map)
```

每个核学会检测一种**局部特征**（边缘、笔画、拐角）。

```python
nn.Conv2d(1, 32, kernel_size=3, padding=1)
#         ↑  ↑              ↑
#     输入1通道 32个核    3×3窗口
```

---

## 三、CNN 三大法宝

### ① 局部连接 + 权重共享 → 高效
- 全连接：每个输出连**所有**784像素
- 卷积：每个输出只连 **3×3=9** 个邻近像素，且**同一个核滑遍全图共享权重**
- 一个"检测横线"的核，图片任何位置都能复用 → 参数少、泛化好

### ② 池化 MaxPool → 降采样 + 抗位移
```python
nn.MaxPool2d(2)   # 2×2取最大, 尺寸减半
# [B,32,28,28] -> [B,32,14,14]
```
降维省算力；数字稍微挪动，最大值还在 → 抗位移。

#### 池化到底怎么运作？（具体例子）

和卷积**不同**：池化窗口**不重叠**地跳着走（stride=窗口大小），
而且**没有可学参数**（不加权，纯粹取最大/平均）。

`MaxPool2d(2)`：把图切成不重叠的 2×2 小块，每块只留**最大值**。

```
输入 4×4:                  2×2 MaxPool 后 2×2:
┌─────────────┐
│ 1   3 │ 2  0│            每个2×2块取max:
│ 4   2 │ 1  5│   ──►      ┌─────────┐
├───────┼─────┤            │ 4  │ 5  │   左上块max(1,3,4,2)=4
│ 0   1 │ 6  2│            │ 7  │ 8  │   右上块max(2,0,1,5)=5
│ 7   3 │ 4  8│            └─────────┘   左下max(0,1,7,3)=7
└─────────────┘                          右下max(6,2,4,8)=8
```

**关键特点**：
- **不重叠**：4×4 → 2×2（尺寸减半），通道数不变 [B,32,28,28]→[B,32,14,14]
- **无参数**：不需要学习，直接取最大
- **逐通道独立**：32个通道各自池化，互不干扰

**为什么取最大？**
- 卷积特征图里"值越大"=该位置"越像这个核检测的特征"
- 取最大 = **保留最强响应**，丢掉弱的
- 数字笔画稍微平移/抖动，2×2 窗口里的最大值大概率还在 → **抗位移/抗噪**

> 另有 `AvgPool`（取平均），但图像分类里 MaxPool 更常用（突出强特征）。


### ③ 感受野逐层变大
浅层看局部细节（笔画），深层看整体结构（这是个8）。

---

## 四、整体结构（数据形状变化）

```
输入 [B,1,28,28]
 ↓ Conv2d(1→32)+ReLU    [B,32,28,28]  提32种特征
 ↓ MaxPool(2)           [B,32,14,14]
 ↓ Conv2d(32→64)+ReLU   [B,64,14,14]  提高级特征
 ↓ MaxPool(2)           [B,64,7,7]
 ↓ Flatten              [B,3136]
 ↓ Linear(3136→128)+ReLU[B,128]
 ↓ Dropout(0.25)        防过拟合
 ↓ Linear(128→10)       [B,10]
```

> 结尾还是 **Flatten + 全连接 + CrossEntropyLoss**——CNN 只是前面加了"特征提取器"，分类头还是老一套。

---

## 五、Dropout 防过拟合

```python
nn.Dropout(0.25)   # 训练时随机关闭25%神经元
```
- 强迫网络不依赖单个神经元，更鲁棒
- **只训练时生效**，`model.eval()` 时自动关闭

---

## 六、五步骨架变了吗？没有！

```python
optimizer.zero_grad()          # 1
loss = criterion(model(x), y)  # 2+3
loss.backward()                # 4
optimizer.step()               # 5
```
和 sin、MLP **一模一样**，只有 `model` 内部结构变了。

---

## 七、可视化：CNN 到底学到了什么

### 卷积核（cnn_kernels.png）
第一层 32 个 3×3 核，训练后自发变成**边缘/方向检测器**（红蓝代表权重正负）。没人教，反向传播自己学出来的。

### 特征图（cnn_featuremaps.png）
同一个数字过 32 个核 → 32 张特征图：有的只亮横笔画、有的只亮竖/斜笔画。
**每个核 = 一个专门的笔画探测器**，把数字拆成基本笔画，深层再组合判断。

```
原图(7) → 32核扫描 → 32张特征图(横/竖/斜...) 
       → 第二层组合(转角/闭环) → 全连接 → "这是7"
```

---

## 八、MLP vs CNN 总结

| | 全连接 MLP | CNN |
|---|---|---|
| 输入 | 拉平丢空间 | 保留2D结构 |
| 连接 | 全连接 | 局部+权重共享 |
| 参数 | ~24万 | ~42万(更高效) |
| 准确率 | 97.7% | **99.15%** |
| 适合 | 表格/向量 | **图像** |

代码：`code/mnist_cnn.py`、`code/cnn_visualize.py`
图：`cnn_kernels.png`、`cnn_featuremaps.png`

---
# 卷积负责提取特征，池化负责让特征更稳健
by 小小叶 · OpenClaw

# 04. 损失函数与优化器

> 五步骨架里的第 3 步（算loss）和第 5 步（更新）到底有哪些选择？
> 这一篇把 loss 和 optimizer 讲清楚。

---

## 一、损失函数（Loss）：衡量"预测错多少"

Loss 越小 = 预测越准。不同任务用不同 loss。

### 回归任务（输出连续值）

| Loss | 公式 | 特点 |
|---|---|---|
| **MSE**（均方误差）| $\frac{1}{N}\sum(\hat y-y)^2$ | 最常用；对离群点敏感（平方放大）|
| **MAE**（绝对误差）| $\frac{1}{N}\sum\|\hat y-y\|$ | 抗离群点；但0点不可导 |
| **SmoothL1**(Huber) | 小误差像MSE,大误差像MAE | 两者折中，目标检测常用 |

实测（pred=[2.5,0,2], target=[3,0,1]）：
```
MSE    : 0.4167   = mean((pred-target)^2)
MAE    : 0.5      = mean(|pred-target|)
SmoothL1: 0.2083  小误差平滑、大误差线性
```

### 分类任务（输出类别）

**CrossEntropyLoss（交叉熵）** —— 多分类标配，**内部自带 softmax**：

$$L = -\log p_{\text{正确类}}, \quad p_i=\frac{e^{z_i}}{\sum_j e^{z_j}}$$

实测（logits=[2.0,0.5,0.1]，正确类=0）：
```
softmax概率: [0.728, 0.163, 0.109]
CrossEntropy: 0.3168 = -log(0.728) ✓
```

> ⚠️ 模型最后一层**别加softmax**，CrossEntropyLoss 已经包含了。
> 二分类也可用 `BCEWithLogitsLoss`（含sigmoid）。

---

## 二、优化器（Optimizer）：决定"参数怎么更新"

所有优化器都基于梯度下降，区别在"步子怎么走"。

### ① SGD（随机梯度下降）—— 最基础
$$w \leftarrow w - \text{lr}\cdot g$$
直接沿梯度反方向走。简单，但容易在峡谷里震荡、陷局部最优。

### ② SGD + Momentum（动量）—— 加惯性
$$v \leftarrow \beta v + g,\quad w \leftarrow w - \text{lr}\cdot v$$
像小球滚下山带惯性，能冲过小坑、减少震荡，收敛更稳。

### ③ Adam —— 自适应学习率（最常用）
结合动量 + 每个参数自适应步长（RMSProp思想）。
**默认首选**，对学习率不敏感，开箱即用。

### 实测对比（拟合 y=3x+2，100步）
```
SGD      (lr=0.1) loss = 0.000002
Momentum (lr=0.1) loss = 0.000017
Adam     (lr=0.1) loss = 0.000187
```
> 注：简单凸问题上 SGD 反而最快收敛。但在**深度网络/复杂loss面**上，
> Adam 通常更稳更省心——所以实践默认用 Adam。

---

## 三、学习率（lr）：最重要的超参数

$$w \leftarrow w - \underbrace{\text{lr}}_{\text{步子大小}}\cdot g$$

实测 lr 的影响（SGD，100步）：
```
lr=0.001 -> loss=4.18   太小，学得慢（没收敛）
lr=0.05  -> loss=0.003  合适
lr=0.5   -> loss=0.000  合适
lr=1.5   -> loss=inf    太大，直接发散！
```

| lr | 现象 |
|---|---|
| 太小 | 收敛极慢，半天学不动 |
| 合适 | 稳步下降 |
| 太大 | 震荡甚至 **发散到 inf/nan** |

**经验起点**：Adam 用 `1e-3`，SGD 用 `1e-2`~`1e-1`。

---

## 四、学习率调度（进阶）

训练后期把 lr 调小，能更精细收敛：
```python
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
# 每30轮 lr 乘0.1
for epoch in range(100):
    train_one_epoch()
    scheduler.step()    # 更新学习率
```
常用：StepLR、CosineAnnealingLR、ReduceLROnPlateau。

---

## 五、小结：怎么选

| 场景 | Loss | Optimizer | lr |
|---|---|---|---|
| 回归 | MSE | Adam | 1e-3 |
| 多分类 | CrossEntropyLoss | Adam | 1e-3 |
| 二分类 | BCEWithLogitsLoss | Adam | 1e-3 |
| 追求极致/论文复现 | 视任务 | SGD+Momentum | 1e-2 + 调度 |

代码：`code/loss_optimizer_demo.py`

---
by 小小叶 · OpenClaw

损失函数与优化器

# 03. 激活函数与梯度消失

> 接 02 篇：逐元素激活函数的雅可比是**对角矩阵**，对角线就是逐点导数。
> 这一篇解释「为什么 ReLU 成了默认选择」。

---

## 一、激活函数的雅可比 = 对角矩阵

激活函数是**逐元素**作用的（element-wise），所以输出 $y_i$ 只依赖输入 $x_i$，
雅可比是对角阵：

$$J = \text{diag}\big(f'(x_1), f'(x_2), \dots\big)$$

反向传播时 VJP 退化成**逐元素相乘**：

$$\frac{\partial L}{\partial x_i} = f'(x_i)\cdot g_i$$

---

## 一·补. 具体例子：(B,32) 数据过 ReLU 发生什么？

ReLU 公式极简：$\text{ReLU}(x)=\max(0,x)$ —— **正数不变，负数变0**。

`(B,32)` = B个样本，每样本32个数（fc1输出）。ReLU 对这 B×32 个数
**逐个独立**做 max(0,x)，**形状完全不变**。

例（B=2，取前4维示意）：
```
fc1输出(未激活):
 样本0 [ 1.5, -0.8,  2.1, -3.0 ]
 样本1 [-0.2,  0.9, -1.7,  0.5 ]

过ReLU后(负的清零):
 样本0 [ 1.5,  0.0,  2.1,  0.0 ]
 样本1 [ 0.0,  0.9,  0.0,  0.5 ]
```

代码验证：
```python
x = torch.tensor([[1.5,-0.8,2.1,-3.0],[-0.2,0.9,-1.7,0.5]])
torch.relu(x)
# [[1.5, 0.0, 2.1, 0.0],
#  [0.0, 0.9, 0.0, 0.5]]
```

**两层含义**：
1. **非线性来源**：负的"折一下"归零，让多层不再退化成单纯线性，才能拟合曲线
2. **神经元开关**：每个样本进来，32个神经元一部分点亮(正)、一部分熄灭(负→0)，
   不同样本点亮组合不同 → 网络区分输入的方式

**反向时**（呼应VJP）：用前向正负当掩码过滤梯度
```
前向:    [1.5, 0.0(原-0.8), 2.1, 0.0(原-3.0)]
梯度掩码: [ 1,   0,           1,   0          ]  ← 负的位置梯度=0
```
正数处梯度原样通过(×1)，负数处梯度被掐断(×0)。这也是 Dead ReLU 的成因。

---

## 二、三大激活函数对比

| 函数 | 公式 | 导数 | 导数最大值 |
|---|---|---|---|
| **ReLU** | $\max(0,x)$ | $x>0:1,\ x\le0:0$ | **1**（正区间恒为1）|
| **Sigmoid** | $\frac{1}{1+e^{-x}}$ | $\sigma(1-\sigma)$ | **0.25** |
| **Tanh** | $\tanh(x)$ | $1-\tanh^2$ | **1.0**（仅在0处）|

实测导数（输入 -2~2）：
```
ReLU    | dy/dx=[0.  0.  0.  1. 1. ]   ← 0/1 开关
Sigmoid | dy/dx=[0.105 0.235 0.25 0.235 0.105]  ← 最大0.25
Tanh    | dy/dx=[0.071 0.786 1.0  0.786 0.071]  ← 两端饱和
```

---

## 三、为什么 Sigmoid 会梯度消失？

反向传播是**梯度连乘**。每过一层 sigmoid，梯度最多乘 0.25：

$$\underbrace{0.25 \times 0.25 \times \dots}_{N\text{层}} = 0.25^N \to 0$$

10 层之后梯度就几乎归零，输入端的层**学不动**了。

### 实测：10 层堆叠后输入端梯度
```
Sigmoid : 2.78e-07   ← 几乎消失，前面的层根本训不动
ReLU    : 1.00e+00   ← 完好无损
```

> 这就是深度网络早期训不深的元凶，也是 ReLU 取代 sigmoid 成为默认的根本原因。

---

## 四、ReLU 为什么不梯度消失？

正区间导数**恒为 1**，连乘多少层都是 1，梯度原样传到底：

$$\underbrace{1\times1\times\dots\times1}_{N} = 1$$

代价：负区间导数为 0 → 可能「神经元死亡」（Dead ReLU）。
改进版：LeakyReLU（负区间给个小斜率）、GELU（Transformer 常用，更平滑）。

---

## 五、选型建议

| 场景 | 推荐 |
|---|---|
| 隐藏层默认 | **ReLU** |
| 怕神经元死亡 | LeakyReLU |
| Transformer | **GELU** |
| 二分类输出层 | Sigmoid（压到0~1当概率）|
| 多分类输出层 | Softmax（见 04 篇）|
| RNN 内部 | Tanh |

---

代码：`code/activation_jacobian_demo.py`

---
by 小小叶 · OpenClaw

激活函数

### 介绍
下面是基于pytorch的神经网络基本框架代码，这里的任务是让神经网络拟合sin函数
```
import torch
import torch.nn as nn

# ===== 0. 造数据：拟合 y = sin(x) 这个非线性函数 =====
torch.manual_seed(0)
x = torch.linspace(-3.14, 3.14, 200).unsqueeze(1)   # [200, 1]
y = torch.sin(x)                                     # [200, 1]

# 1.定义模型(万能骨架)
class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(1,32)
        self.fc2 = nn.Linear(32,32)
        self.fc3 = nn.Linear(32,1)
    def forward(self,x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = MLP()

# ===== 2. 损失函数 + 优化器 =====
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 3. 训练循环，经典5步走
for epoch in range(2000):
    optimizer.zero_grad()
    pred = model(x)
    loss = criterion(pred, y)
    loss.backward()
    optimizer.step()
    if epoch%100==0:
        print(f'当前第{epoch}轮，loss为{loss.item():.6f}')

# 4. 检验学习结果
test_x = torch.tensor([[0.0], [1.5708], [-1.5708]]) # 0,π/2, -π/2
test_pred = model(test_x)
print("预测 sin(0)   =", round(test_pred[0].item(), 4), " 真实 =", 0.0)
print("预测 sin(π/2) =", round(test_pred[1].item(), 4), " 真实 =", 1.0)
print("预测 sin(-π/2)=", round(test_pred[2].item(), 4), " 真实 =", -1.0)


```

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefinedcfe38319b25c1bf1d487dc132895df00.image.png)

神经网络基本框架代码

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefined0a7c82ecb2134b4058b9918f8dfdc88c.image.png)

## 一、全连接层在算什么？
一个 `nn.Linear(in, out)` 就是一次矩阵运算：

$$\mathbf{y} = \mathbf{W}\mathbf{x} + \mathbf{b}$$

- $\mathbf{x}$：输入（in 维）
- $\mathbf{W}$：权重矩阵（**out × in**），要学习
- $\mathbf{b}$：偏置（out 维），要学习
- $\mathbf{y}$：输出（out 维）

**单个神经元展开**：

$$y = w_1x_1 + w_2x_2 + \dots + w_nx_n + b$$

> 验证：`nn.Linear(1,32)` 的 `weight.shape = (32,1)`，`bias.shape = (32,)`，
> 正好把 1 维输入升到 32 维。
## 二、为什么必须加激活函数？

只堆 `Wx+b`，无论多少层，**本质还是线性**（矩阵连乘还是一个矩阵），
画不出 sin 这样的弯曲曲线。

加 ReLU 引入非线性：

$$\text{ReLU}(x) = \max(0, x)$$

多层 + 非线性 → 能拟合任意复杂函数（**万能逼近定理**）。  

下面为神经网络基本框架
```python
class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(1, 32)
        self.fc2 = nn.Linear(32, 32)
        self.fc3 = nn.Linear(32, 1)
    def forward(self, x):
        x = torch.relu(self.fc1(x))   # 线性 + 非线性
        x = torch.relu(self.fc2(x))
        return self.fc3(x)            # 回归任务最后一层不加激活
```

## 三、训练五步骨架（雷打不动）

```python
for epoch in range(1000):
    optimizer.zero_grad()       # 1. 清空上轮梯度（梯度会累加，不清会错）
    pred = model(x)             # 2. 前向（自动调用 forward）
    loss = criterion(pred, y)   # 3. 算误差
    loss.backward()             # 4. 反向（autograd 自动算所有梯度）
    optimizer.step()            # 5. 按梯度更新参数
# 上述的代码是全批量训练的，因为数据量小
```


以上就是神经网络训练的基本流程了，后续会根据不同的任务更新不同的算法，敬请期待~