动手学深度学习（Pytorch版）代码实践 -卷积神经网络-28批量规范化

28批量规范化

"""可持续加速深层网络的收敛速度"""
import torch
from torch import nn
import liliPytorch as lp
import matplotlib.pyplot as plt

def batch_norm(X, gamma, beta, moving_mean, moving_var, eps, momentum):
    """实现一个具有张量的批量规范化层。"""
    # 如果启用了梯度计算，torch.is_grad_enabled() 返回 True；否则返回 False。
    if not torch.is_grad_enabled():
        # torch.no_grad() 是一个上下文管理器，用于临时禁用梯度计算
        # torch.enable_grad() 是一个上下文管理器，用于在禁用梯度计算的上下文中重新启用梯度计算。
        X_hat = (X - moving_mean) / torch.sqrt(moving_var + eps)
    else:
        assert len(X.shape) in (2, 4)
        if len(X.shape) == 2:
            # 使用全连接层的情况，计算特征维上的均值和方差
            mean = X.mean(dim=0) # 计算张量 X 沿着第 0 维的平均值
            # 维度 0 代表样本数量，即沿着每个特征计算所有样本的平均值。
            var = ((X - mean) ** 2).mean(dim=0)
        else:
            # 使用二维卷积层的情况，计算通道维上（axis=1）的均值和方差。
            # 这里我们需要保持X的形状以便后面可以做广播运算
            mean = X.mean(dim=(0, 2, 3), keepdim=True)
            var = ((X - mean) ** 2).mean(dim=(0, 2, 3), keepdim=True)
        # 训练模式下，用当前的均值和方差做标准化
        X_hat = (X - mean) / torch.sqrt(var + eps)

        # 更新移动平均的均值和方差
        moving_mean = momentum * moving_mean + (1.0 - momentum) * mean
        moving_var = momentum * moving_var + (1.0 - momentum) * var
    # gamma 和 beta 的更新是通过反向传播和优化器自动完成的
    Y = gamma * X_hat + beta # 缩放和移位
    return Y, moving_mean.data, moving_var.data

class BatchNorm(nn.Module):
    # num_features：完全连接层的输出数量或卷积层的输出通道数。
    # num_dims：2表示完全连接层，4表示卷积层
    def __init__(self, num_features, num_dims):
        super().__init__()
        if num_dims == 2:
            shape = (1, num_features)
        else:
            shape = (1, num_features, 1, 1)
        # 参与求梯度和迭代的拉伸和偏移参数，分别初始化成1和0
        self.gamma = nn.Parameter(torch.ones(shape))
        self.beta = nn.Parameter(torch.zeros(shape))
        
        # 非模型参数的变量初始化为0和1
        # 经过归一化处理后的数据均值接近于零。因此，将滑动均值初始化为0，是对数据初始均值的一种合理假设。
        self.moving_mean = torch.zeros(shape)
        # 方差表示数据的离散程度。将滑动方差初始化为1，意味着假设数据的初始方差为1，
        # 即数据分布接近标准正态分布。这样初始化可以避免初始阶段的数值不稳定。
        self.moving_var = torch.ones(shape)

    def forward(self, X):
        # 如果X不在内存上，将moving_mean和moving_var
        # 复制到X所在GPU上                              
        if self.moving_mean.device != X.device:
            self.moving_mean = self.moving_mean.to(X.device)
            self.moving_var = self.moving_var.to(X.device)
        
         # 保存更新过的moving_mean和moving_var
        Y, self.moving_mean, self.moving_var = batch_norm(
            X, self.gamma, self.beta, self.moving_mean,
            self.moving_var, eps=1e-5, momentum=0.9)
        return Y

#使用批量规范化层的 LeNet
net = nn.Sequential(
    nn.Conv2d(1, 6,  kernel_size=5, padding=2), # 卷积层1：输入通道数1，输出通道数6，卷积核大小5x5，填充2
    BatchNorm(num_features=6, num_dims=4),
    nn.ReLU(), # 激活函数
    nn.AvgPool2d(kernel_size=2, stride=2), # 平均池化层1：池化窗口大小2x2，步幅2

    nn.Conv2d(6, 16, kernel_size=5), # 卷积层2：输入通道数6，输出通道数16，卷积核大小5x5
    BatchNorm(num_features=16, num_dims=4),
    nn.ReLU(), 
    nn.AvgPool2d(kernel_size=2, stride=2), # 平均池化层2：池化窗口大小2x2，步幅2

    nn.Flatten(), # 展平层：将多维输入展平为1维
    nn.Linear(16 * 5 * 5, 120), # 全连接层1：输入节点数16*5*5，输出节点数120
    BatchNorm(num_features=120, num_dims=2),
    nn.ReLU(),
    nn.Linear(120, 84), # 全连接层2：输入节点数120，输出节点数84
    BatchNorm(num_features=84, num_dims=2),
    nn.ReLU(), 
    nn.Linear(84, 10) # 全连接层3：输入节点数84，输出节点数10（对应10个分类）
)

lr, num_epochs, batch_size = 1.0, 10, 256
train_iter, test_iter = lp.loda_data_fashion_mnist(batch_size)
# lp.train_ch6(net, train_iter, test_iter, num_epochs, lr, lp.try_gpu())
# plt.show()

# loss 0.200, train acc 0.925, test acc 0.812
# 34957.3 examples/sec on cuda:0

# loss 0.189, train acc 0.928, test acc 0.894
# 33471.2 examples/sec on cuda:0


#简明实现
net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5), nn.BatchNorm2d(6), nn.ReLU(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.BatchNorm2d(16), nn.ReLU(),
    nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(),
    nn.Linear(256, 120), nn.BatchNorm1d(120), nn.ReLU(),
    nn.Linear(120, 84), nn.BatchNorm1d(84), nn.ReLU(),
    nn.Linear(84, 10)
)
lp.train_ch6(net, train_iter, test_iter, num_epochs, lr, lp.try_gpu())
plt.show()

# nn.Sigmoid()
# loss 0.263, train acc 0.902, test acc 0.833
# 46935.0 examples/sec on cuda:0

# nn.ReLU()
# loss 0.224, train acc 0.914, test acc 0.874
# 44479.2 examples/sec on cuda:0
"""
通常高级API变体运行速度快得多，因为它的代码已编译为C++或CUDA，而我们的自定义代码由Python实现。
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125