一只菜鸟学机器学习的日记：入门深度学习计算

本文以作者阅读《Dive into Deep Learning》为线索，融合串联了自身理解感悟、原始论文、优秀文章等。如有无意侵权，请联系本人删除。

深度学习计算

看看基础概念：层与块

显然，一个线性模型只会有一个输出：

\[Input \xrightarrow{一组参数}标量输出\]
我们通过更新参数，优化某些目标函数，如loss
那么复杂模型、多个输出应该如何处理呢？
我们引入块，可以理解成 class，以便将多个层结合成块。
每个块：

• 有前向传播函数
  
• 有反向传播函数
  
• 储存必须的参数
  

参数管理

以此为例，

1. net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))

复制代码

这是单隐藏层的MLP
我们可以嵌套多个block :

1. def block1():
2.     return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
3.                          nn.Linear(8, 4), nn.ReLU())
4. def block2():
5.     net = nn.Sequential()
6.     for i in range(4):
7.         net.add_module(f'block {i}', block1())
8.     return net
9. rgnet = nn.Sequential(block2(), nn.Linear(4, 1))

复制代码

那么这里 rgnet 的参数就是

1. Sequential(
2.   (0): Sequential(
3.     (block 0): Sequential(
4.       (0): Linear(in_features=4, out_features=8, bias=True)
5.       (1): ReLU()
6.       (2): Linear(in_features=8, out_features=4, bias=True)
7.       (3): ReLU()
8.     )
9.     (block 1): Sequential(
10.       (0): Linear(in_features=4, out_features=8, bias=True)
11.       (1): ReLU()
12.       (2): Linear(in_features=8, out_features=4, bias=True)
13.       (3): ReLU()
14.     )
15.     (block 2): Sequential(
16.       (0): Linear(in_features=4, out_features=8, bias=True)
17.       (1): ReLU()
18.       (2): Linear(in_features=8, out_features=4, bias=True)
19.       (3): ReLU()
20.     )
21.     (block 3): Sequential(
22.       (0): Linear(in_features=4, out_features=8, bias=True)
23.       (1): ReLU()
24.       (2): Linear(in_features=8, out_features=4, bias=True)
25.       (3): ReLU()
26.     )
27.   )
28.   (1): Linear(in_features=4, out_features=1, bias=True)
29. )

复制代码

那么很显然，这是一个嵌套的大 Sequential
所以可以当成一个3维张量：
rgnet[0][3][3]
这就是最大索引
下面是简单的初始化：

1. def init_normal(m):
2.     if type(m) == nn.Linear:
3.         nn.init.normal_(m.weight, mean=0, std=0.01)
4.         nn.init.zeros_(m.bias)
5. net.apply(init_normal)

复制代码

只用了自带的normal初始化，\(\text{weight}\sim\mathcal{N}(0,0.01)\)，并设置\(\text{bias}=0\)
为了多层间共享参数，我们可以设置一个稠密层，有点像MySQL（雾）中的多表共用主键。

1. shared = nn.Linear(8, 8)
2. net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
3.                     shared, nn.ReLU(),
4.                     shared, nn.ReLU(),
5.                     nn.Linear(8, 1))

复制代码

这样共享了一个稠密层shared，这就意味着net[2].weight和net[4].weight是完全等价的。这里的等价意味着不仅初始值一样，过程中修改任何一个参数，两个都会变动，即对象等价。至于它的梯度，是net[2]和net[4]，即第3层和第5层梯度之和：

\[\frac{\partial \mathcal{L}}{\partial W_{shared}} = \sum_{i=1}^{n} \frac{\partial \mathcal{L}}{\partial W_i}\]
其中 \(n\) 是共享该权重的层数。
以上文代码为例：
前向传播：

\[\begin{align*}h^{(1)} &= W_1 x + b_1 \\a^{(1)} &= \text{ReLU}(h^{(1)}) \\h^{(2)} &= W_{\text{shared}} a^{(1)} + b_{\text{shared}} \\a^{(2)} &= \text{ReLU}(h^{(2)}) \\h^{(3)} &= W_{\text{shared}} a^{(2)} + b_{\text{shared}} \\a^{(3)} &= \text{ReLU}(h^{(3)}) \\y &= W_{\text{out}} a^{(3)} + b_{\text{out}}\end{align*}\]
反向传播：

\[\begin{split}&对于共享参数 W_{\text{shared}}，梯度来自两条路径：\\&\frac{\partial \mathcal{L}}{\partial W_{\text{shared}}} = \underbrace{\frac{\partial \mathcal{L}}{\partial h^{(3)}} \cdot \frac{\partial h^{(3)}}{\partial W_{\text{shared}}}}_{\text{(3)}} + \underbrace{\frac{\partial \mathcal{L}}{\partial h^{(2)}} \cdot \frac{\partial h^{(2)}}{\partial W_{\text{shared}}}}_{\text{(2)}}\end{split}\]
因此

1. id(net[2].weight) == id(net[4].weight)

复制代码

返回为True
延迟初始化

我们很难在编写MLP的时候就能确认输入维度，那不妨在第一次模型传递时再初始化参数。
此外，如果模型的参数太多，为了防止构建时太占内存，我们可以现场分配。
对于Pytorch，我们使用LazyLinear以实现惰性初始化参数。

1. class LazyLinear(nn.Module):
2.     def __init__(self):
3.         super().__init__()
4.         self.linear = None
5.         self.net = nn.Sequential(nn.ReLU(),nn.Linear(32, 10))
6.     def forward(self, data):
7.         if self.linear is None:
8.             self.linear = nn.Linear(in_features=data.shape[-1],
9.                                                             out_features=32)
10.         return self.net(self.linear(data))

复制代码

\[输入(5, 20)\xrightarrow{\text{self.linear}}(5, 30)\xrightarrow{\text{nn.ReLU}}(5, 30)\xrightarrow{\text{nn.Linear}}(5, 10)\]
避坑点：如果你试图

1. self.net = nn.Sequential(self.linear, nn.ReLU(),nn.Linear(32, 10))

复制代码

，而后直接调用self.net(data)，有很大问题：

• 初始化时是None，不是nn.Module的子类模块，无法会报错
  
• 如果通过一些方法初始化成功，forward中更新self.linear时Sequential里面的不会更新
  

你可以直接调用pytorch的LazyLinear：

1. self.linear = nn.LazyLinear(out_features = 10)

复制代码

注：延后初始化的变量或层，在第一次运行后，一般来说，不能再改变其形状
此外，这也是一种延后初始化，是合法的：

1. net = nn.Sequential(
2.     nn.Linear(20, 256), nn.ReLU(),
3.     nn.LazyLinear(128), nn.ReLU(),
4.     nn.LazyLinear(10)
5. )

复制代码

我们用一个例题结束这一小节：
\(设计一个接受输入并计算张量降维的层，它返回\space y_k = \sum_{i, j} W_{ijk} x_i x_j\)
我最开始理解为简单的张量求和降维（显然不对）

1. class ReduceDim(nn.Module):
2.     def __init__(self):
3.         super().__init__()
4.     def forward(self, X):
5.         return X.sum(dim=[1, 2])

复制代码

然而，题目的意思是

• 输入：一维向量x
  
• 权重：三维张量 W，形状为 (n, n, m)
  
• 输出：一维向量 y
  有运算：
  

\[y_k=x_1x_1\cdot W_{11k}+x_1x_2\cdot W_{12k}+x_1x_3\cdot W_{13k}+\dots+x_nx_n\cdot W_{nnk}\]
为了简化运算，我们使用爱因斯坦求和 einsum 标记。
这里这个文章很好：看图学 AI：einsum 爱因斯坦求和约定到底是怎么回事？ - 知乎
故在此不再赘述。
用了这个标记法，我们可以直接简化计算式：

1. y = torch.einsum('bi,ijK,bj->bK', x, self.W, x)
2. return y

复制代码

简单理解一些这个求和表达式：

• 爱因斯坦求和规则：在输出标记中不出现的维度会被求和掉
  
• 输入标记：bi, ijK, bj
  
• 输出标记：bK
  
• 被求和的梯度：i 和 j （输入中出现但是输出中不出现）
  这就是那个题目要求的公式。
  等价代码：
  

1. result = torch.zeros(x.shape, W.shape[2])
2. for b in range(x.shape):
3.         for k in range(W.shape[2]):
4.                 total = 0
5.                 for i in range(x.shape):
6.                         for j in range(x.shape):
7.                                 total += x[b,i] * W[i,j,k] * x[b,j]
8.                 result[b,k] = total

复制代码

综上我们有了：

1. class BilinearLayer(nn.Module):
2.     def __init__(self, input_dim, output_dim):
3.         super().__init__()
4.         self.W = nn.Parameter(torch.randn(input_dim, input_dim,
5.                                                                                   output_dim))
6.         self.input_dim = input_dim
7.         self.output_dim = output_dim
8.     def forward(self, x):
9.         y = torch.einsum('bi,ijK,bj->bK', x, self.W, x)
10.         return y
11. model = BilinearLayer(input_dim=3, output_dim=2)
12. x = torch.tensor([[1.0, 2.0, 3.0]])
13. print("Input:", x)
14. print("Output:", model(x))

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

过来提前占个楼

这个有用。