介绍#

最近在网上看见了一个用神经网络实现“一个字符串的所有字母用它的后继字母代替（比如，a用b代替，b用c代替）”功能的代码。看见里面加了一个残差网络，就去看了一下残差网络的相关概念。如下这篇文章：

残差网络解决了什么，为什么有效？

里面有提到网络退化（即深层网络的效率比不上浅层网络）的现象，于是我就想做个实验试试。

本次实验用到了三个网络：

$26 \rightarrow 64 \rightarrow 26$ 的全连接神经网络
$26 \rightarrow 64 \rightarrow 26 \rightarrow 64 \rightarrow 64 \rightarrow 26$ 的全连接神经网络
在第二个网络的 $\rightarrow 26$ 处加了残差的神经网络

以上三个模型训练时使用的训练集完全一致。

环境#

pytorch==1.10
tensorboard==2.7.0

代码#

1
import string
2

3
import torch
4
from torch import nn
5
from torch.utils.data import Dataset, DataLoader
6
from tqdm import trange
7
from torch.utils.tensorboard import SummaryWriter
8

9
# 驱动选择
10
device = "cuda" if torch.cuda.is_available() else "cpu"
11

12
# tensorboard
13
writer_rn = SummaryWriter(log_dir = "runs/loss_rn")
14
writer_nn = SummaryWriter(log_dir = "runs/loss_nn")
15
writer_n = SummaryWriter(log_dir = "runs/loss_n")
16

17

18
print(f"Using {device} devive")
19

20
# 残差网络
21
class RN(nn.Module):
22
    def __init__(self):
23
        super(RN, self).__init__()
24
        self.linear_stack = nn.Sequential(
25
            nn.Linear(26, 64),
26
            nn.Hardsigmoid(),
27
            nn.Linear(64, 26),
28
            nn.Hardsigmoid(),
29
        )
30

31
        self.linear_stack_2 = nn.Sequential(
32
            nn.Linear(26, 64),
33
            nn.Hardsigmoid(),
34
            nn.Linear(64, 64),
35
            nn.Hardsigmoid(),
36
        )
37

38
        self.output_layer = nn.Linear(64, 26)
39

40
    def forward(self, x):
41
        y = self.linear_stack(x)
42
        # 残差
43
        y = y+x
44
        y = self.linear_stack_2(y)
45
        y = self.output_layer(y)
46

47
        return y
48

49
# 没加残差、其他结构完全一致的神经网络
50
class NN(nn.Module):
51
    def __init__(self):
52
        super(NN, self).__init__()
53
        self.linear_stack = nn.Sequential(
54
            nn.Linear(26, 64),
55
            nn.Hardsigmoid(),
56
            nn.Linear(64, 26),
57
            nn.Hardsigmoid(),
58
        )
59

60
        self.linear_stack_2 = nn.Sequential(
61
            nn.Linear(26, 64),
62
            nn.Hardsigmoid(),
63
            nn.Linear(64, 64),
64
            nn.Hardsigmoid(),
65
        )
66

67
        self.output_layer = nn.Linear(64, 26)
68

69
    def forward(self, x):
70
        y = self.linear_stack(x)
71
        # 此处没有参擦
72
        # x = y+x
73
        y = self.linear_stack_2(y)
74
        y = self.output_layer(y)
75

76
        return y
77

78
# 只有一层的神经网络
79
class N(nn.Module):
80
    def __init__(self):
81
        super(N, self).__init__()
82
        self.linear_stack = nn.Sequential(
83
            nn.Linear(26, 64),
84
            nn.Hardsigmoid(),
85
        )
86

87

88
        self.output_layer = nn.Linear(64, 26)
89

90
    def forward(self, x):
91
        y = self.linear_stack(x)
92
        y = self.output_layer(y)
93

94
        return y
95

96
# Dataset类
97
class Data(Dataset):
98
    def __init__(self, x):
99
        """
100
        x:[1...26, 0]
101
        """
102
        self.data = list(
103

104
                zip(x, list(range(1, 26)) + [0])
105
        )
106

107
    def __len__(self):
108
        return 26
109

110
    def __getitem__(self, idx):
111
        return self.data[idx]
112

113
# 输出替换结果
114
def trans_word(model, word):
115
    return "".join(
116
        alphabet_digit_map_reverse[model(alphabet_digit_map[w]).argmax().item()]
117
        for w in word
118
    )
119

120
# 生成两个模型实例
121
rNetwork = RN().to(device=device)
122
nNetwork = NN().to(device=device)
123
n = N().to(device=device)
124

125
"""
126
生成数据集
127
a:[1, 0, ..., 0]
128
b:[0, 1, ..., 0]
129
...
130
z:[0, 0, ..., 1]
131
"""
132
x = torch.zeros((26, 26), dtype=torch.float32).to(device=device)
133
for i in range(26):
134
    x[i][i] = 1
135

136
# 生成数据集对象
137
data = Data(x)
138
dataloader = DataLoader(data, batch_size=1, shuffle=True)
139

140
# 定义损失函数和优化器
141
loss_rn = nn.CrossEntropyLoss()
142
loss_nn = nn.CrossEntropyLoss()
143
loss_n = nn.CrossEntropyLoss()
144
optimizer_rn = torch.optim.Adam(rNetwork.parameters(), lr=1e-3)
145
optimizer_nn = torch.optim.Adam(nNetwork.parameters(), lr=1e-3)
146
optimizer_n = torch.optim.Adam(n.parameters(), lr=1e-3)
147

148
# 训练， 三个个模型使用完全相同的数据
149
for epoch in trange(500):
150
    for batch, (X, y) in enumerate(dataloader):
151
        X, y = X.to(device), y.to(device)
152

153
        # 训练 rn
154
        pred = rNetwork(X)
155
        loss = loss_rn(pred, y)
156
        writer_rn.add_scalar("loss", loss.item(), global_step=epoch)
157
        optimizer_rn.zero_grad()
158
        loss.backward()
159
        optimizer_rn.step()
160

161
        # 训练 nn
162
        pred = nNetwork(X)
163
        loss = loss_nn(pred, y)
164
        writer_nn.add_scalar("loss", loss.item(), global_step=epoch)
165
        optimizer_nn.zero_grad()
166
        loss.backward()
167
        optimizer_nn.step()
168

169
        # 训练 n
170
        pred = n(X)
171
        loss = loss_n(pred, y)
172
        writer_n.add_scalar("loss", loss.item(), global_step=epoch)
173
        optimizer_n.zero_grad()
174
        loss.backward()
175
        optimizer_n.step()
176

177
# 关闭tensorboard流，保证信息所有输出完毕
178
writer_rn.close()
179
writer_nn.close()
180
writer_n.close()
181

182
# 定义字母表到数字的映射
183
alphabet_digit_map = dict(zip(string.ascii_lowercase, x))
184
# 数字到字母的映射
185
alphabet_digit_map_reverse = dict(zip(range(26), string.ascii_lowercase))
186

187
# a-z
188
my_word = string.ascii_lowercase
189
# 输出结果
190
print(trans_word(rNetwork, my_word))
191
print(trans_word(nNetwork, my_word))
192
print(trans_word(n, my_word))

输出结果#

1
bcdefghijklmnopqrstuvwxyza
2
bidtfgtiiiidttptittitwiyia
3
bcdefghijklmnopqrstuvwxyza

tensorboard结果输出#

在这里插入图片描述

其中橙色是加了残差深层神经网络，蓝色是没加残差深层神经网络，红色是浅层神经网络。

总结#

从整体来看，红色不管在收敛速度和最终结果来看，都是三个模型中最优的，且也是结构最简单的模型。蓝色（深层神经网络）是最拉跨的模型。

对比蓝色和红色，可以看到确实出现了网络退化的现象，红色的收敛速度远高于蓝色，且蓝色损失波动极大（背景浅蓝色是真实损失，深蓝色线是经过压缩的）。

对比蓝色和橙色，可以看出加了残差只有，网络的效率大幅度提升，可见残差在解决网络退化问题上效果很好。

对比红色和橙色，可以看到虽然残差解决了网络退化的一些问题，但收敛速度和最终效果仍没有浅层网络好，但这只是在这个简单模型、简单问题上的结果，残差在复杂模型（如Transformer）上有很多应用，并且取得了相当好的结果。

可见，一味地增加神经网络的深度并不一定可以获得更好的效果，正如奥卡姆剃刀原理如无必要，勿增实体，要更多地去关注问题本质。

原文链接：CSDN