1 引言

接触机器学习半年多了，也看了三四十篇论文，复现了不少模型，自认为Python基础还可以。但看着写好的代码，仿佛空中楼阁，想一想自己真正代码上的入门到头来其实只有小土堆的那一门速成的课程，还是不够深入、代码、相关经验其实都远远落后。趁着开学事情少巩固一下技术，积累一些知识。

强推李沐，我素未谋面的恩师 - 跟李沐学AI的个人空间-跟李沐学AI个人主页-哔哩哔哩视频 (bilibili.com)

本文是博主在学习《动手学深度学习v2》这门课程时的笔记，水平有限，如有错误与不足欢迎指正。

_{GNN相关内容年底补充}

2 预备知识

2.3 线性代数

1.一些容易忘记的特殊矩阵。

• 正定矩阵，矩阵A满足如下条件：

• 正交矩阵，所有行都相互正交且所有行都有单位长度，可以写成 $U{U}^{\mathrm{\top }}=1$$UU^\top=1$
• 置换矩阵，每行和每列都有一个 1 条目，其他地方有 0。

2.特征向量与特征值。

矩阵就是一次空间的扭曲，而特征向量就是不会被矩阵改变方向的向量。

对称矩阵总是可以找到特征矩阵。

矩阵特征值和特征向量详细计算过程_特征向量怎么求-CSDN博客

3.矩阵按照特定轴作sum。

​x
x = torch.arange(24).reshape([2,3,4])
x
out>tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],

        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]])

注意在求x.sum()时，下面的这几个的区别：

xxxxxxxxxx
x.sum()
x.sum(axis=0)
x.sum(axis=1)
x.sum(axis=2)
x.sum(axis=[0,1])

4.torch在矩阵与向量相乘时，是不区分行向量与列向量的。

xxxxxxxxxx
A.shape, x.shape, torch.mv(A, x)
out>(torch.Size([5, 4]), torch.Size([4]), tensor([ 14.,  38.,  62.,  86., 110.]))

2.4 微积分

1.亚导数？

将导数扩展到不可微的函数：

另一个例子：

2.梯度？

将导数扩展到向量，下面的图表使用分子布局来表示。

1. $\partial y/\partial \mathbf{x}$$\partial y/\partial\mathbf{x}$

   $$\begin{array}{c}\mathbf{x}=\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]\frac{\partial y}{\partial \mathbf{x}}=\left[\begin{array}{c}\frac{\partial y}{\partial x_1},\frac{\partial y}{\partial x_2},...,\frac{\partial y}{\partial x_n}\end{array}\right]\end{array}$$

   关于列向量的导数是一个行向量，举个例子：

   

2. $\partial \mathbf{y}/\partial x$$\partial\mathbf{y}/\partial x$

   $\partial y/\partial \mathbf{x}$$\partial y/\partial\mathbf{x}$是行向量，$\partial \mathbf{y}/\partial x$$\partial\mathbf{y}/\partial x$是列向量。这个被称之为分子布局符号，反过来的版本叫分母布局符号。

3. $\partial \mathbf{y}/\partial \mathbf{x}$$\partial\mathbf{y}/\partial\mathbf{x}$

   $$\begin{array}{c}\mathbf{x}=\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]\mathbf{y}=\left[\begin{array}{c}{y}_1\\ y_2\\ ⋮\\ y_m\end{array}\right]\end{array}$$
   $$\begin{array}{c}\frac{\partial \mathbf{y}}{\partial \mathbf{x}}=\left[\begin{array}{c}\frac{\partial y_1}{\partial \mathbf{x}}\\ \frac{\partial y_2}{\partial \mathbf{x}}\\ ⋮\\ \frac{\partial y_m}{\partial \mathbf{x}}\end{array}\right]=\left[\begin{array}{c}\frac{\partial y_1}{\partial x_1},\frac{\partial y_1}{\partial x_2},\dots ,\frac{\partial y_1}{\partial x_n}\\ \frac{\partial y_2}{\partial x_1},\frac{\partial y_2}{\partial x_2},\dots ,\frac{\partial y_2}{\partial x_n}\\ ⋮\\ \frac{\partial y_m}{\partial x_1},\frac{\partial y_m}{\partial x_2},\dots ,\frac{\partial y_m}{\partial x_n}\end{array}\right]\end{array}$$

2.5 自动微分

1.两个手动求导的例子，快速回忆。

但是神经网络动不动就几百层链式，很难手动求导，所以我们需要自动求导。

2.计算图

自动求导是计算一个函数在指定值上的导数。

它有别于：

• 符号求导

$$\begin{array}{rc}in[1]:=& \mathbf{D}[\mathbf{4}{\mathbf{x}}^3+{\mathbf{x}}^2+3,\mathbf{x}]\\ \\ \mathrm{Out}[1]=& 2\mathbf{x}+12{\mathbf{x}}^2\end{array}$$

• 数值求导

$$\frac{\partial f(x)}{\partial x}=\underset{h\to 0}{lim}\frac{f(x+h)-f(x)}{h}$$

数值求导不需要知道函数到底长什么样子，他就是带入一个特别小的h现场算一个近似值即可。

在了解自动求导之前，我们先引入计算图的概念：

• 将代码分解为操作子
• 将计算表示成一个无环的图

• 显示构造

  类似于数学中公式的定义，先定义好再计算。

  xxxxxxxxxx
  import tensorflow as tf
  
  # 定义计算图
  x = tf.placeholder(tf.float32)
  y = tf.placeholder(tf.float32)
  z = x + y
  
  # 执行计算图
  with tf.Session() as sess:
      result = sess.run(z, feed_dict={x: 1, y: 2})
      print(result)  # 输出: 3.0
  

  • TensorFlow（早期版本）/Theano/MXNet（支持静态图和动态图）

• 隐式构造

  xxxxxxxxxx
  import torch
  
  # 即时执行
  x = torch.tensor(1.0)
  y = torch.tensor(2.0)
  z = x + y
  print(z)  # 输出: tensor(3.0)
  

  • PyTorch/MXNet（支持静态图和动态图）

3.自动求导

链式法则：$\frac{\partial y}{\partial x}=\frac{\partial y}{\partial u_n}\frac{\partial u_n}{\partial u_{n-1}}...\frac{\partial u_2}{\partial u_1}\frac{\partial u_1}{\partial x}$$\frac{\partial y}{\partial x}=\frac{\partial y}{\partial u_n}\frac{\partial u_n}{\partial u_{n-1}}...\frac{\partial u_2}{\partial u_1}\frac{\partial u_1}{\partial x}$

自动求导的两种方式：

• 正向积累：$\frac{\partial y}{\partial x}=\frac{\partial y}{\partial u_n}\left(\frac{\partial u_n}{\partial u_{n-1}}(...\left(\frac{\partial u_2}{\partial u_1}\frac{\partial u_1}{\partial x}\right))\right)$$\frac{\partial y}{\partial x}=\frac{\partial y}{\partial u_n}\left(\frac{\partial u_n}{\partial u_{n-1}}\left(...\left(\frac{\partial u_2}{\partial u_1}\frac{\partial u_1}{\partial x}\right)\right)\right)$
• 反向积累、又称反向传递：$\frac{\partial y}{\partial x}=\left((\left(\frac{\partial y}{\partial u_n}\frac{\partial u_n}{\partial u_{n-1}}\right)\cdots )\frac{\partial u_2}{\partial u_1}\right)\frac{\partial u_1}{\partial x}$$\frac{\partial y}{\partial x}=\left(\left(\left(\frac{\partial y}{\partial u_n}\frac{\partial u_n}{\partial u_{n-1}}\right)\cdots\right)\frac{\partial u_2}{\partial u_1}\right)\frac{\partial u_1}{\partial x}$

因此，前向是执行图，存储中间结果；反向从是相反方向执行图，去除不需要的枝。

复杂度：

• 计算复杂度：O(n),n 是操作子个数。（常正向和方向的代价类似）
• 内存复杂度：O(n),因为需要存储正向的所有中间结果。（正向的是O(1)）

4.pyTorch隐式求导示例：

xxxxxxxxxx
def f(a):
    b = a * 2
    while b.norm() < 1000:
        b = b * 2
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c


a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()

a.grad == d / a
> tensor(True)

3 线性神经网络

3.2 Softmax回归

1.交叉熵：交叉熵常用来衡量两个概率的区别

将他们作为损失函数

可以证明只有当真实值与预测值相等时，才有最小值。

2.梯度：梯度就是真实概率与预测概率的区别

证明如下：

4 多层感知机

4.1 单层感知机

1.局限性：例如不能拟合XOR函数，它只能产生线性分割面。（下面这张图是无法通过一条线来分割的）

4.2 多层感知机

1.为什么要激活函数？以单隐藏层-单分类问题为例。

• 输入$\mathbf{x}\in {\mathbb{R}}^n$$\mathbf{x}\in\mathbb{R}^{n}$
• 隐藏层${\mathbf{W}}_1\in {\mathbb{R}}^{m\times n},{\mathbf{b}}_1\in {\mathbb{R}}^m$$\mathbf{W}_1\in\mathbb{R}^{m\times n},\mathbf{b}_1\in\mathbb{R}^m$
• 输出层${\mathbf{w}}_2\in {\mathbb{R}}^m,b_2\in \mathbb{R}$$\mathbf{w}_{2}\in\mathbb{R}^{m},b_{2}\in\mathbb{R}$

$\sigma$$\sigma$是按元素的激活函数

4.4 权重衰退

1.使用均方范数作为硬性限制

通过限制参数值的选择范围来控制模型容量

$min\ell (\mathbf{w},b)subjectto\parallel \mathbf{w}{\parallel }^2\le \theta$$min\ell(\mathbf{w},b)~~~~subjectto\|\mathbf{w}\|^2\leq\theta$

• 通常不限制便宜b（限不限制都差不多）
• 小的$\text{θ}$$\text{θ}$意味着更强的正则项

2.使用均方范数作为柔性限制

L2正则化：

对每个θ，都可以找到使得之前的目标函数等价于下面

可以通过拉格朗日乘子来证明！超参数$\lambda$$\lambda$控制了正则项的重要程度。

• $\lambda =0:\text{无作用}$$\lambda=0\colon\text{无作用}$
• $\lambda \to \mathrm{\infty },{\mathbf{w}}^{\ast }\to \mathbf{0}$$\lambda\to\infty,\mathbf{w}^*\to\mathbf{0}$

这张图还是挺直观的

那么为什么叫权重衰退呢？

• 计算梯度

  $$\frac{\partial }{\partial \mathbf{w}}(\ell (\mathbf{w},b)+\frac{\lambda }{2}\parallel \mathbf{w}{\parallel }^2)=\frac{\partial \ell (\mathbf{w},b)}{\partial \mathbf{w}}+\lambda \mathbf{w}$$

• 时间t更新参数

  $${\mathbf{w}}_{t+1}=(1-\eta \lambda ){\mathbf{w}}_t-\eta \frac{\partial \ell ({\mathbf{w}}_t,b_t)}{\partial {\mathbf{w}}_t}$$
  • $\text{通常 }\eta \lambda <1\text{,在深度学习中通常叫做权重衰退}$$\text{通常 }\eta\lambda<1\text{,在深度学习中通常叫做权重衰退}$

权重衰退时最广泛使用的正则化技术之一。

4.5 丢弃法

xxxxxxxxxx
def dropout_layer(X, dropout):
    assert 0 <= dropout <= 1
    # 在本情况中，所有元素都被丢弃
    if dropout == 1:
        return torch.zeros_like(X)
    # 在本情况中，所有元素都被保留
    if dropout == 0:
        return X
    mask = (torch.rand(X.shape) > dropout).float()
    return mask * X / (1.0 - dropout)

一般都是通过一个mask来实现，因为矩阵乘法往往要比选择快。

根据此模型的设计，其期望值保持不变，即$E[h^{\prime }]=h$$E[h^{\prime}]=h$$E[h^{\prime }]=h$$E[h^{\prime}]=h$

4.6 数值稳定性

考虑如下有d层的神经网络：

计算损失$\ell$$\ell$关于参数$W_t$$W_t$的梯度：

中间包含（d-t）次矩阵乘法。

这就会带来两个问题，梯度爆炸与梯度消失。

例如：${1.5}^{100}\approx 4\times {10}^{17}{0.8}^{100}\approx 2\times {10}^{-10}$$1.5^{100}\approx4\times10^{17}\quad0.8^{100}\approx2\times10^{-10}$

梯度爆炸：以一个MLP为例

加入如下MLP，为了简单省略了偏移

$f_t({\mathbf{h}}^{t-1})=\sigma ({\mathbf{W}}^t{\mathbf{h}}^{t-1})\sigma \text{ 是激活函数}$$f_t(\mathbf{h}^{t-1})=\sigma(\mathbf{W}^t\mathbf{h}^{t-1})\quad\sigma\text{ 是激活函数}$

$\frac{\partial {\mathbf{h}}^t}{\partial {\mathbf{h}}^{t-1}}=\mathrm{diag}({\sigma }^{\prime }({\mathbf{W}}^t{\mathbf{h}}^{t-1}))(W^t{)}^T{\sigma }^{\prime }\text{ 是}\sigma \text{的导数函数}$$\frac{\partial\mathbf{h}^t}{\partial\mathbf{h}^{t-1}}=\mathrm{diag}\left(\sigma^{\prime}(\mathbf{W}^t\mathbf{h}^{t-1})\right)(W^t)^T\quad\sigma^{\prime}\text{ 是}\sigma\text{的导数函数}$

这里求导用了链式法则，可以自己再琢磨一下，其实很简单

$\prod _{i=t}^{d-1}\frac{\partial {\mathbf{h}}^{i+1}}{\partial {\mathbf{h}}^i}=\prod _{i=t}^{d-1}\mathrm{diag}({\sigma }^{\prime }({\mathbf{W}}^i{\mathbf{h}}^{i-1}))(W^i{)}^T$$\prod_{i=t}^{d-1}\frac{\partial\mathbf{h}^{i+1}}{\partial\mathbf{h}^i}=\prod_{i=t}^{d-1}\mathrm{diag}\left(\sigma^{\prime}(\mathbf{W}^i\mathbf{h}^{i-1})\right)(W^i)^T$

如果我们使用ReLU作为激活函数

那么对角矩阵不是1就是0，最后的值的一些元素就会

• 如果（d-t）很大，值就会很大

• 值超出值域（对于16位浮点数尤为严重，数值区间6e-5-6e4）

• 对学习率比价敏感

  • 如果学习率太大-》大参数值-》更大的梯度
  • 如果学习率太小-》训练无进展
  • 我们可能需要在训练过程不断调整学习率

梯度消失

使用sigmoid作为激活函数

$\prod _{i=t}^{d-1}\frac{\partial {\mathbf{h}}^{i+1}}{\partial {\mathbf{h}}^i}=\prod _{i=t}^{d-1}\mathrm{diag}({\sigma }^{\prime }({\mathbf{W}}^i{\mathbf{h}}^{i-1}))(W^i{)}^T$$\prod_{i=t}^{d-1}\frac{\partial\mathbf{h}^{i+1}}{\partial\mathbf{h}^i}=\prod_{i=t}^{d-1}\mathrm{diag}\left(\sigma^{\prime}(\mathbf{W}^i\mathbf{h}^{i-1})\right)(W^i)^T$的元素值是（d-t）个小数值的乘积。

• 梯度值变为0（对于16位浮点数尤为严重，数值区间6e-5-6e4）

• 不管如何选择学习率，训练都没有进展

• 对于底部层尤为严重

  • 仅仅顶部层训练的更好
  • 无法让神经网络更深

4.7 让训练更加稳定

目标：让梯度值在合理的范围内，例如[1e-6, 1e3]

• 将乘法变加法

  • ResNet，LSTM

• 归一化

  • 梯度归一化，梯度裁剪

• 合理的权重初始和激活函数

合理的权重初始化和激活函数

• 将每层的输出和梯度都看做随机变量
• 让它们的均值和方差都保持一致

1.权重初始化

• 在合理值区间里随机初始参数

• 训练开始的时候更容易有数值不稳定

  

  • 远离最优解的地方损失函数表面可能很复杂
  • 最优解附近表面会比较平

• 使用N(0,0.01)来初始可能对小网络没问题，但不能保证深度神经网络

2.Xavier初始（比较常用）

• 难以需要满足 $n_{t-1}{\gamma }_t=1$$n_{t-1}\gamma_t=1$和 $n_t{\gamma }_t=1$$n_t\gamma_t=1$
• Xavier 使得${\gamma }_t(n_{t-1}+n_t)/2=1$$\gamma _t( n_{t- 1}+ n_t) / 2= 1$ $\to {\gamma }_t=2/(n_{t-1}+n_t)$$\rightarrow \gamma _t= 2/ ( n_{t- 1}+ n_t)$
• 正态分布$\mathcal{N}(0,\sqrt{2/(n_{t-1}+n_t)})$$\mathcal{N}\left(0,\sqrt{2/(n_{t-1}+n_t)}\right)$
• 均匀分布$\mathcal{U}(-\sqrt{6}/(n_{t-1}+n_t),\sqrt{6/(n_{t-1}+n_t)})$$\mathscr{U}\left(-\sqrt6/(n_{t-1}+n_t),\sqrt{6/(n_{t-1}+n_t)}\right)$
• 分布$\mathcal{U}[-a,a]$$\mathscr{U}[-a,a]$和方差是$a^2/3$$a^2/3$
• 适配权重形状变换，特别是$n_t$$n_t$

3.假设线性的激活函数

4.检查常用激活函数

• 使用泰勒展开

  $$\begin{array}{c}sigmoid(x)=\frac{1}{2}+\frac{x}{4}-\frac{x^3}{48}+O(x^5)\\ \tanh \left(x\right)=0+x-\frac{x^3}{3}+O(x^5)\\ relu(x)=0+x\text{for}x\ge 0\end{array}$$

• 调整sigmoid：$4\times \mathrm{sigmoid}(x)-2$$4\times\mathrm{sigmoid}(x)-2$

5 深度学习计算

5.1 层和块

xxxxxxxxxx
import torch
from torch import nn
from torch.nn import functional as F

# 网络中没有自己设置w和b，会自动初始化
net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))

# 2是你的批量大小，20是输入的维度
X = torch.rand(2, 20)
net(X)

xxxxxxxxxx
tensor([[-0.0669, -0.0667, -0.1325,  0.0877,  0.0250, -0.1648,  0.1947,  0.1535,
          0.0227, -0.0684],
        [-0.0293,  0.0540, -0.1153,  0.0521,  0.1237, -0.0733,  0.0426,  0.0997,
          0.0257, -0.0520]], grad_fn=<AddmmBackward0>)

nn.Sequential定义了一种特殊的Module，Module在Pytorch中是一个很重要的概念。

Module可以认为是，任何一个层或者任何一个神经网络都可以认为是Module的一个子类。

自定义块

在实现我们自定义块之前，我们简要总结一下每个块必须提供的基本功能。

1. 将输入数据作为其前向传播函数的参数。
2. 通过前向传播函数来生成输出。请注意，输出的形状可能与输入的形状不同。例如，我们上面模型中的第一个全连接的层接收一个20维的输入，但是返回一个维度为256的输出。
3. 计算其输出关于输入的梯度，可通过其反向传播函数进行访问。通常这是自动发生的。
4. 存储和访问前向传播计算所需的参数。
5. 根据需要初始化模型参数。

在下面的代码片段中，我们从零开始编写一个块。 它包含一个多层感知机，其具有256个隐藏单元的隐藏层和一个10维输出层。 注意，下面的MLP类继承了表示块的类。 我们的实现只需要提供我们自己的构造函数（Python中的__init__函数）和前向传播函数。

xxxxxxxxxx
class MLP(nn.Module):
    # 用模型参数声明层。这里，我们声明两个全连接的层
    def __init__(self):
        # 调用MLP的父类Module的构造函数来执行必要的初始化。
        # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
        super().__init__()
        self.hidden = nn.Linear(20, 256)  # 隐藏层
        self.out = nn.Linear(256, 10)  # 输出层

    # 定义模型的前向传播，即如何根据输入X返回所需的模型输出
    def forward(self, X):
        # 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
        return self.out(F.relu(self.hidden(X)))
    
net = MLP()
net(X)

xxxxxxxxxx
tensor([[-0.0203, -0.0231,  0.1462,  0.1428, -0.1055, -0.0453, -0.1232, -0.1168,
          0.2106,  0.2049],
        [ 0.0708, -0.0984, -0.0216,  0.0652, -0.0192,  0.1467, -0.3095, -0.3248,
          0.1947,  0.1943]], grad_fn=<AddmmBackward0>)

顺序块

现在我们可以更仔细地看看Sequential类是如何工作的， 回想一下Sequential的设计是为了把其他模块串起来。 为了构建我们自己的简化的MySequential， 我们只需要定义两个关键函数：

1. 一种将块逐个追加到列表中的函数；
2. 一种前向传播函数，用于将输入按追加块的顺序传递给块组成的“链条”。

下面的MySequential类提供了与默认Sequential类相同的功能。

xxxxxxxxxx
class MySequential(nn.Module):
    def __init__(self, *args):
        super().__init__()
        for block in args:
            self._modules[block] = block
            
    def forward(self, X):
        for block in self._modules.values():
            x = block(x)
        return X
    
net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
net(X)
# 这不是起那面的自己实现版吗，这下理解了吧

在正向传播函数中执行代码

反向计算是不需要定义的，都是自动求导

Sequential类使模型构造变得简单， 允许我们组合新的架构，而不必定义自己的类。 然而，并不是所有的架构都是简单的顺序架构。 当需要更强的灵活性时，我们需要定义自己的块。 例如，我们可能希望在前向传播函数中执行Python的控制流。 此外，我们可能希望执行任意的数学运算， 而不是简单地依赖预定义的神经网络层。

xxxxxxxxxx
class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不计算梯度的随机权重参数。因此其在训练期间保持不变
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)

    def forward(self, X):
        X = self.linear(X)
        # 使用创建的常量参数以及relu和mm函数
        X = F.relu(torch.mm(X, self.rand_weight) + 1)
        # 复用全连接层。这相当于两个全连接层共享参数
        X = self.linear(X)
        # 控制流
        while X.abs().sum() > 1:
            X /= 2
        return X.sum()
    
net = FixedHiddenMLP()
net(X)

xxxxxxxxxx
tensor(0.2183, grad_fn=<SumBackward0>)

混合搭配各种组合块的方法

xxxxxxxxxx
# 定义 NestMLP 类
class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(20, 64),  # 第一层：20 -> 64
            nn.ReLU(),
            nn.Linear(64, 32),  # 第二层：64 -> 32
            nn.ReLU()
        )
        self.linear = nn.Linear(32, 16)  # 额外的线性层：32 -> 16

    def forward(self, X):
        return self.linear(self.net(X))
    
chimera = nn.Sequential(
    NestMLP(),               # 使用 NestMLP
    nn.Linear(16, 20),        # 增加一层：16 -> 20
    FixedHiddenMLP()          # 使用 FixedHiddenMLP
)
chimera(X)

xxxxxxxxxx
tensor(0.2624，grad_fn=<SumBackward0>)

5.2 参数管理

我们首先关注具有单隐藏层的多层感知机

xxxxxxxxxx
import torch
from torch import nn

net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)

xxxxxxxxxx
tensor([[-0.0970],
        [-0.0827]], grad_fn=<AddmmBackward0>)

参数访问

xxxxxxxxxx
print(net[2].state_dict())

xxxxxxxxxx
OrderedDict([('weight', tensor([[-0.0427, -0.2939, -0.1894,  0.0220, -0.1709, -0.1522, -0.0334, -0.2263]])), ('bias', tensor([0.0887]))])

1.目标参数

xxxxxxxxxx
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)

xxxxxxxxxx
<class 'torch.nn.parameter.Parameter'>
Parameter containing:
tensor([0.0887], requires_grad=True)
tensor([0.0887])

xxxxxxxxxx
net[2].weight.grad == None
# grad是梯度的意思们这里还没有做计算，所以为空

True

2.一次性访问所有参数

xxxxxxxxxx
print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])

xxxxxxxxxx
('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))
# relu是没有参数的，所以第1层没有拿出参数

xxxxxxxxxx
net.state_dict()['2.bias'].data

tensor([0.0887])

3.从嵌套块收集参数

xxxxxxxxxx
def block1():
    return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                         nn.Linear(8, 4), nn.ReLU())

def block2():
    net = nn.Sequential()
    for i in range(4):
        # 在这里嵌套
        net.add_module(f'block {i}', block1())
    return net

rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
rgnet(X)

xxxxxxxxxx
tensor([[0.2596],
        [0.2596]], grad_fn=<AddmmBackward0>)

设计了网络后，我们看看它是如何工作的。

xxxxxxxxxx
print(rgnet)

Sequential(
  (0): Sequential(
    (block 0): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 1): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 2): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 3): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
  )
  (1): Linear(in_features=4, out_features=1, bias=True)
)

因为层是分层嵌套的，所以我们也可以像通过嵌套列表索引一样访问它们。 下面，我们访问第一个主要的块中、第二个子块的第一层的偏置项。

xxxxxxxxxx
rgnet[0][1][0].bias.data

tensor([ 0.1999, -0.4073, -0.1200, -0.2033, -0.1573,  0.3546, -0.2141, -0.2483])

参数初始化

1.内置初始化

xxxxxxxxxx
def init_normal(m):
    if type(m) == nn.Linear:
        # _下划线的意思是“替换”函数，不会返回而是直接替换掉原来的
        nn.init.normal_(m.weight, mean=0, std=0.01)
        nn.init.zeros_(m.bias)
        
# apply的意思就是对于net里面所有的module，都调用一遍    
net.apply(init_normal)
net[0].weight.data[0], net[0].bias.data[0]

(tensor([1., 1., 1., 1.]), tensor(0.))

xxxxxxxxxx
def init_constant(m):
    if type(m) == nn.Linear:
        # 初始化为给定的常量
        nn.init.constant_(m.weight, 1)
        nn.init.zeros_(m.bias)
net.apply(init_constant)
net[0].weight.data[0], net[0].bias.data[0]

为什么实际中我们不能把权重全部初始化为常数？

1. 对称性问题（Symmetry Problem）

   如果你将所有的权重初始化为相同的值（例如全零或者某个常数），神经网络中的每个神经元在每一层中都会执行完全相同的计算，并且在反向传播时更新的梯度也是相同的。这会导致所有神经元保持相同的权重更新，因此它们的行为无法多样化。具体来说：

   • 每个神经元在每一层执行的操作都是相同的，无法学习到不同的特征。
   • 网络的学习能力会被限制住，训练的效果非常差甚至没有效果。

2. 梯度传播问题

   如果将所有权重初始化为常数（特别是全零），可能会导致梯度在反向传播时变得非常小，尤其是使用基于梯度的优化算法（如 SGD、Adam 等）时，无法有效更新权重。特别是：

   • 如果权重初始化为零，所有的神经元在反向传播时梯度都会变得一样，因此它们的权重更新也是相同的，这种更新无法让模型学到有意义的特征。
   • 如果权重初始化为一个非常大的常数，则可能导致梯度爆炸，导致网络训练不稳定。

我们还可以对某些块应用不同的初始化方法。 例如，下面我们使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42。

xxxxxxxxxx
def init_xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
def init_42(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 42)

net[0].apply(init_xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)

tensor([ 0.5236,  0.0516, -0.3236,  0.3794])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])

2.自定义初始化

有时，深度学习框架没有提供我们需要的初始化方法。 在下面的例子中，我们使用以下的分布为任意权重参数𝑤定义初始化方法：

xxxxxxxxxx
def my_init(m):
    if type(m) == nn.Linear:
        print("Init", *[(name, param.shape)
                        for name, param in m.named_parameters()][0])
        nn.init.uniform_(m.weight, -10, 10)
        m.weight.data *= m.weight.data.abs() >= 5

net.apply(my_init)
net[0].weight[:2]

Init weight torch.Size([8, 4])
Init weight torch.Size([1, 8])
tensor([[5.4079, 9.3334, 5.0616, 8.3095],
        [0.0000, 7.2788, -0.0000, -0.0000]], grad_fn=<SliceBackward0>)

更暴力的方法有...

xxxxxxxxxx
net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
net[0].weight.data[0]

参数绑定

有时我们希望在多个层间共享参数： 我们可以定义一个稠密层，然后使用它的参数来设置另一个层的参数。

xxxxxxxxxx
# 我们需要给共享层一个名称，以便可以引用它的参数
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                    shared, nn.ReLU(),
                    shared, nn.ReLU(),
                    nn.Linear(8, 1))
net(X)
# 检查参数是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
# 确保它们实际上是同一个对象，而不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])

tensor([True, True, True, True, True, True, True, True])
tensor([True, True, True, True, True, True, True, True])

5.3 自定义层

1.构造一个没有任何参数的自定义层

xxxxxxxxxx
import torch
import torch.nn.functional as F
from torch import nn


class CenteredLayer(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, X):
        return X - X.mean()
    
layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))

tensor([-2., -1.,  0.,  1.,  2.])

将层作为组件合并到更复杂的模型中

xxxxxxxxxx
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())

Y = net(torch.rand(4, 8))
Y.mean()

xxxxxxxxxx
tensor(7.4506e-09, grad_fn=<MeanBackward0>)

2.带参数的层

xxxxxxxxxx
class MyLinear(nn.Module):
    def __init__(self, in_units, units):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(in_units, units))
        self.bias = nn.Parameter(torch.randn(units,))
        
    def forward(self, X):
        # 通过.data访问参数
        linear = torch.matmul(X, self.weight.data) + self.bias.data
        return F.relu(linear)
    
linear = MyLinear(5, 3)
linear.weight

Parameter containing:
tensor([[ 0.1775, -1.4539,  0.3972],
        [-0.1339,  0.5273,  1.3041],
        [-0.3327, -0.2337, -0.6334],
        [ 1.2076, -0.3937,  0.6851],
        [-0.4716,  0.0894, -0.9195]], requires_grad=True)

• torch.randn()：生成 标准正态分布 的随机数，数值范围可能是正数或负数，均值为 0，标准差为 1。
• torch.rand()：生成 均匀分布 的随机数，数值范围为 [0, 1)。

pytorch一维张量不区分行跟列，会自动转换：

我们可以使用自定义层直接执行前向传播计算

xxxxxxxxxx
linear(torch.rand(2, 5))

tensor([[0., 0., 0.],
        [0., 0., 0.]])

使用自定义层构建模型

xxxxxxxxxx
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))

tensor([[0.],
        [0.]])

5.4 读写文件

1.加载和保存张量

xxxxxxxxxx
import torch
from torch import nn
from torch.nn import functional as F

x = torch.arange(4)
torch.save(x, 'x-file')

x2 = torch.load('x-file')
x2

tensor([0, 1, 2, 3])

存储一个张量列表，然后把它们读回内存

xxxxxxxxxx
y = torch.zeros(4)
torch.save([x, y],'x-files')
x2, y2 = torch.load('x-files')
(x2, y2)

(tensor([0, 1, 2, 3]), tensor([0., 0., 0., 0.]))

写入或读取从字符串映射到张量的字典

xxxxxxxxxx
mydict = {'x': x, 'y': y}
torch.save(mydict, 'mydict')
mydict2 = torch.load('mydict')
mydict2

{'x': tensor([0, 1, 2, 3]), 'y': tensor([0., 0., 0., 0.])}

2.加载和保存模型参数

xxxxxxxxxx
class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(20, 256)
        self.output = nn.Linear(256, 10)

    def forward(self, x):
        return self.output(F.relu(self.hidden(x)))

net = MLP()
X = torch.randn(size=(2, 20))
Y = net(X)

将模型的参数存储在一个叫做“mlp.params”的文件中

xxxxxxxxxx
torch.save(net.state_dict(), 'mlp.params')

为了恢复模型，我们实例化了原始多层感知机模型的一个备份。 这里我们不需要随机初始化模型参数，而是直接读取文件中存储的参数。

xxxxxxxxxx
clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval()

xxxxxxxxxx
MLP(
  (hidden): Linear(in_features=20, out_features=256, bias=True)
  (output): Linear(in_features=256, out_features=10, bias=True)
)

xxxxxxxxxx
Y_clone = clone(X)
Y_clone == Y

xxxxxxxxxx
tensor([[True, True, True, True, True, True, True, True, True, True],
        [True, True, True, True, True, True, True, True, True, True]])

6 卷积神经网络

6.1 卷积层

1.对全连接层使用平移不变性和局部性得到卷积层。

2.二维交叉相关

*一般表示的都是卷积操作。

3.二维卷积层

• 输入$X$$X$：$n_h\times n_w$$n_h\times n_w$

• 核$W$$W$：$k_h\times k_w$$k_h\times k_w$

• 偏差$b\in \mathbb{R}$$b\in\mathbb{R}$

• 输出$\mathbf{Y}:(n_h-k_h+1)\times (n_w-k_w+1)$$\mathbf{Y}:(n_{h}-k_{h}+1)\times(n_{w}-k_{w}+1)$

  $\mathbf{Y}=\mathbf{X}\star \mathbf{W}+b$$\mathbf{Y}=\mathbf{X}\star\mathbf{W}+b$

• $W$$W$和b是可学习的参数

超参数是卷积核的大小，代表着而他的局部性。

卷积层其实就是一个特殊的全连接层

4.其他一些维度

三维一般情况都是多一个时间维度。

5.我们以一个图像的卷积为例，关注他的代码实现

1. 先实现他的互相关运算：

   xxxxxxxxxx
   import torch
   from torch import nn
   from d2l import torch as d2l
   
   def corr2d(X, K):  #@save
       """计算二维互相关运算"""
       h, w = K.shape
       Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
       for i in range(Y.shape[0]):
           for j in range(Y.shape[1]):
               Y[i, j] = (X[i:i + h, j:j + w] * K).sum()
       return Y
   

   xxxxxxxxxx
   X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
   K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
   corr2d(X, K)
   
   tensor([[19., 25.],
           [37., 43.]])
   

2. 实现二维卷积：

   xxxxxxxxxx
   class Conv2D(nn.Module):
       def __init__(self, kernel_size):
           super().__init__()
           self.weight = nn.Parameter(torch.rand(kernel_size))
           self.bias = nn.Parameter(torch.zeros(1))
   
       def forward(self, x):
           return corr2d(x, self.weight) + self.bias
   

3. 学习一个由X生成Y的卷积核：

   xxxxxxxxxx
   # 构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
   conv2d = nn.Conv2d(1,1, kernel_size=(1, 2), bias=False)
   
   # 这个二维卷积层使用四维输入和输出格式（批量大小、通道、高度、宽度），
   # 其中批量大小和通道数都为1,（批量大小、通道、高度、宽度）
   X = X.reshape((1, 1, 6, 8))
   Y = Y.reshape((1, 1, 6, 7))
   lr = 3e-2  # 学习率
   
   for i in range(10):
       Y_hat = conv2d(X)
       l = (Y_hat - Y) ** 2
       conv2d.zero_grad()
       l.sum().backward()
       # 迭代卷积核
       conv2d.weight.data[:] -= lr * conv2d.weight.grad
       if (i + 1) % 2 == 0:
           print(f'epoch {i+1}, loss {l.sum():.3f}')
           
   epoch 2, loss 6.422
   epoch 4, loss 1.225
   epoch 6, loss 0.266
   epoch 8, loss 0.070
   epoch 10, loss 0.022
   

   xxxxxxxxxx
   conv2d.weight.data.reshape((1, 2))
   
   tensor([[ 1.0010, -0.9739]])
   

6.2 填充和步幅

都是超参数

填充

在应用多层卷积时，我们常常丢失边缘像素。 由于我们通常使用小卷积核，因此对于任何单个卷积，我们可能只会丢失几个像素。 但随着我们应用许多连续卷积层，累积丢失的像素数就多了。 解决这个问题的简单方法即为填充（padding）：在输入图像的边界填充元素（通常填充元素是0）。

• 填充$p_h$$p_h$行和$p_w$$p_w$列，输出形状为

• $\text{通}\text{常}\text{取}{p}_h=k_h-1$$通常取p_h= k_h- 1$, $p_w=k_w-1$$p_w= k_w- 1$
• 当$k_h$$k_h$为奇数：在上下两侧填充$p_h/2$$p_h/2$
• 当$k_h$$k_h$为偶数：在上侧填充「$p_h/2|$$p_h/2|$,在下侧填充$\lfloor p_h/2\rfloor$$\lfloor p_h/2\rfloor$
• 这样不管核的大小为多少，都不会更改样本的形状。

xxxxxxxxxx
import torch
from torch import nn

# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
def comp_conv2d(conv2d, X):
    # 这里的（1，1）表示批量大小和通道数都是1
    X = X.reshape((1, 1) + X.shape)
    Y = conv2d(X)
    # 省略前两个维度：批量大小和通道
    return Y.reshape(Y.shape[2:])

# 请注意，这里每边都填充了1行或1列，因此总共添加了2行或2列
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
X = torch.rand(size=(8, 8))
comp_conv2d(conv2d, X).shape

xxxxxxxxxx
torch.Size([8, 8])

当卷积核的高度和宽度不同时，我们可以填充不同的高度和宽度，使输出和输入具有相同的高度和宽度。在如下示例中，我们使用高度为5，宽度为3的卷积核，高度和宽度两边的填充分别为2和1。

xxxxxxxxxx
conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
comp_conv2d(conv2d, X).shape

torch.Size([8, 8])

步幅

填充减小的输出大小与层数线性相关

• 给定输入大小224×224，在使用 5×5 卷积核的情况下，需要 44 层将输出降低到 4× 4
• 需要大量计算才能得到较小输出

xxxxxxxxxx
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
comp_conv2d(conv2d, X).shape

torch.Size([4, 4])

一个稍微复杂的例子

xxxxxxxxxx
conv2d = nn.Conv2d(1, 1, kernel_size=(3, 5), padding=(0, 1), stride=(3, 4))
comp_conv2d(conv2d, X).shape

torch.Size([2, 2])