一、第一周：Pytorch基础概念

2. Pytorch的Tensor（张量）

Content

1. Tensor概念
2. Tensor创建一：直接创建
3. Tensor创建二：依据数值创建
4. Tensor创建三：依据概率创建

2.1 张量是什么（What is Tensor?）

张量是一个**多维数组**，它是标量、向量、矩阵的高维拓展。

2.2 Tensor与Variable

Variable是torch.autograd中的数据类型，主要用于封装Tensor，进行自动求导。

data：被封装的Tensor
grad：data的梯度
grad_fn：创建Tensor的Function，是自动求导的关键
requires_grad：指示是否需要梯度
is_leaf：指示是否是叶子结点（张量）

Pytorch0.4.0版开始，Variable并入Tensor

dtype：张量的数据类型，如torch.FloatTensor、torch.cuda.FloatTensor

shape：张量的形状，如(64,3,224,224)
device：张量所在设备，GPU/CPU，是加速的关键

2.3 张量的创建——（1）直接创建张量

1. torch.tensor()

torch.tensor()
功能：从data创建tensor

• data：数据，可以是list，numpy
• dtype：数据类型，默认与data的一致
• device：所在设备，cuda/cpu
• requires_grad：是否需要梯度
• pin_memory：是否存于锁页内存

  torch.tensor(
  data,
  dtype=None,
  device=None,
  requires_grad=False,
  pin_memory=False)

2. torch.from_numpy(ndarray)

torch.from_numpy(ndarray)
功能：从numpy创建tensor
注意事项：从torch.from_numpy创建的tensor与原ndarray共享内存，当修改其中一个的数据，另一个也将会被修改。

2.4 张量的创建——（2）依据数值创建张量

1. torch.zeros()

torch.zeros()
功能：依size创建全0张量

• size：张量的形状，如(3,3)、(3,244,244)
• out：输出的张量
• layout：内存中布局形式，有strided、sparse_coo等
• device：所在设备，gpu/cpu
• requires_grad：是否需要梯度

  torch.zeros(*size,
         out=None,
         dtype=None,
         layout=torch.strided,
         device=None,
         requires_grad=False)

2. torch.zeros_like()

torch.zeros_like()
功能：依input形状创建全0张量

• input：创建于input同形状的全0张量
• dtype：数据类型
• layout：内存中布局形式

  torch.zeros_like(input,
              dtype=None,
              layout=None,
              device=None,
              requires_grad=False)

3. torch.ones()

4. torch.ones_like()

torch.ones()
torch.ones_like()
功能：依input形状创建全1张量

• size：张量的形状，如(3,3)、(3,244,244)
• input：创建于input同形状的全1张量
• dtype：数据类型
• layout：内存中布局形式，有strided、sparse_coo等
• layout：内存中布局形式
• device：所在设备，gpu/cpu
• requires_grad：是否需要梯度

  torch.ones(*size,
         out=None,
         dtype=None,
         layout=torch.strided,
         device=None,
         requires_grad=False)

  torch.ones_like(input,
              dtype=None,
              layout=None,
              device=None,
              requires_grad=False)

5. torch.full()

6. torch.full_like()

torch.full()
torch.full_like()
功能：依据input形状创建全值张量

• size：张量的形状，如(3,3)
• full_value：张量的值

  torch.full(size,
        full_value,
         out=None,
         dtype=None,
         layout=torch.strided,
         device=None,
         requires_grad=False)

7. torch.arange()

torch.arange()
功能：创建等差的1维张量
注意事项：数值区间为[start,end)

• start：数列起始值
• end：数列”结束值”
• step：数列公差，默认为1

  torch.arange(start=0,
          end,
          step=1,
          out=None,
          dtype=None,
          layout=torch.strided,
          device=None,
          requires_grad=False)

8. torch.linspace()

torch.linspace()
功能：创建均分的1维张量
注意事项：数值区间为[start,end]

• start：数列起始值
• end：数列结束值
• steps：数列长度

步长为：(end-start)/(steps-1)

torch.linspace(start,
                 end,
                 steps=100,
                 out=None,
                 dtype=None,
                 layout=torch.strided,
                 device=None,
                 requires_grad=False)

9. torch.logspace()

torch.logspace()
功能：创建对数均分的1维张量
注意事项：数值区间为[start,end]；长度为steps，底数为base

• start：数列起始值
• end：数列结束值
• steps：数列长度
• base：对数函数的底，默认为10

  torch.logspace(start,
             end,
              steps=100,
                base=10.0,
              out=None,
              dtype=None,
              layout=torch.strided,
              device=None,
              requires_grad=False)

10. torch.eye()

torch.eye()
功能：创建单位对角矩阵（2维张量）
注意事项：默认为方阵

• n：矩阵函数
• m：矩阵列数

  torch.linspace(n,
            m=None,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

2.5 张量的创建——（3）依概率分布创建张量

1. torch.normal()

torch.normal()
功能：生成正态分布（高斯分布）

• mean：均值
• std：标准差

  torch.normal(mean,
          std,
          out=None)

  四种模式：
  mean为标量，std为标量
  mean为标量，std为张量
  mean为张量，std为标量
  mean为张量，std为张量

  torch.normal(mean,
          std,
          size,
          out=None)

2. torch.randn()

3. torch.randn_like()

torch.randn()
torch.randn_like()
功能：生成标准正态分布

• size：张量的形状

  torch.randn(*size,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

4. torch.rand()

5. torch.rand_like()

torch.rand()
torch.rand_like()
功能：在区间[0,1)上，生成均匀分布

torch.rand(*size,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

6. torch.randint()

7. torch.randint_like()

torch.randint()
torch.randint_like()
功能：在区间[low,high)生成整数均匀分布

• size：张量的形状

  torch.randint(low,
           high,
           size,
           out=None,
           dtype=None,
           layout=torch.strided,
           device=None,
           requires_grad=False)

8. torch.randperm()

torch.randperm()
功能：生成从0到n-1的随机排列

• n：张量的长度

  torch.randperm(n,
            out=None,
            dtype=None,
            layout=torch.strided,
            device=None,
            requires_grad=False)

9. torch.bernoulli()

torch.bernoulli()
功能：以input为概率，生成伯努利分布（0-1分布，两点分布）

• input：概率值

  torch.bernoulli(input,
             *,
             generator=None,
             out=None)

3. 张量操作与线性回归

Content

1. 张量的操作：拼接、切分、索引和变换
2. 张量的数学运算
3. 线性回归

3.1 张量的拼接与切分

1. torch.cat()

torch.cat()
功能：将张量按维度dim进行拼接

• tensors：张量序列
• dim：要拼接的维度

  torch.cat(tensors,
       dim=0,
       out=None)

  ```python import torch

t = torch.ones((2, 3)) t0 = torch.cat([t, t], dim=0) t1 = torch.cat([t, t], dim=1)

print(‘t:\n{}\nt.shape:\n{}’.format(t,t.shape)) print(‘t0:\n{}\nt0.shape:\n{}’.format(t0,t0.shape)) print(‘t1:\n{}\nt1.shape:\n{}’.format(t1,t1.shape))

output： t: tensor([[1., 1., 1.], [1., 1., 1.]]) t.shape: torch.Size([2, 3]) t0: tensor([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]) t0.shape: torch.Size([4, 3]) t1: tensor([[1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1.]]) t1.shape: torch.Size([2, 6])

<a name="WMTJT"></a>
#### 2. torch.stack()
torch.stack()<br />功能：在新创建的维度dim上进行拼接
   - tensors：张量序列
   - dim：要拼接的维度
```python
torch.stack(tensors,
            dim=0,
            out=None)

# example2
# torch.stack
import torch
t = torch.ones((2, 3))
t0 = torch.stack([t, t], dim=2)
t1 = torch.stack([t, t], dim=0)
# 若dim指定的维度已经存在，则会创建一个新的维度，已存在的依次向后挪一个维度。
print('t:\n{}\nt.shape:\n{}'.format(t, t.shape))
print('t0:\n{}\nt0.shape:\n{}'.format(t0, t0.shape))
print('t1:\n{}\nt1.shape:\n{}'.format(t1, t1.shape))
ouput：
t:
tensor([[1., 1., 1.],
        [1., 1., 1.]])
t.shape:
torch.Size([2, 3])
t0:
tensor([[[1., 1.],
         [1., 1.],
         [1., 1.]],
        [[1., 1.],
         [1., 1.],
         [1., 1.]]])
t0.shape:
torch.Size([2, 3, 2])
t1:
tensor([[[1., 1., 1.],
         [1., 1., 1.]],
        [[1., 1., 1.],
         [1., 1., 1.]]])
t1.shape:
torch.Size([2, 2, 3])

3. torch.chunk()

torch.chunk()
功能：将张量按维度dim进行平均切分
返回值：张量列表
注意事项：若不能整除，最后一个张量小于其他张量

• input：要切分的张量
• chunks：要切分的份数
• dim：要切分的维度

  torch.chunk(input,
         chunks,
         dim=0)

  ```python

  example3

  torch.chunk

import torch

a = torch.ones((2, 5))

list_tensors = torch.chunk(a, dim=1, chunks=2) for idx, t in enumerate(list_tensors): print(‘第{}个张量:\n{}\nshape is:\n{}’.format(idx + 1, t, t.shape))

output： 第1个张量: tensor([[1., 1., 1.], [1., 1., 1.]]) shape is: torch.Size([2, 3]) 第2个张量: tensor([[1., 1.], [1., 1.]]) shape is: torch.Size([2, 2])

<a name="MXTua"></a>
#### 4. torch.split()
torch.split()<br />功能：将张量按维度dim进行切分<br />返回值：张量列表
   - tensor：要切分的张量
   - split_size_or_sections：为int时，表示每一份长度；为list时，按list元素切分
   - dim：要切分的维度
注意事项：切分后，tensor指向切分完的最后一个张量
```python
torch.split(tensor,
            split_size_or_sections,
            dim=0)

# example4
# torch.split
import torch
t = torch.ones((2, 5))
list_tensors = torch.split(t, 2, dim=1)
for idx, t in enumerate(list_tensors):
    print('第{}个张量:\n{}\nshape is:\n{}'.format(idx + 1, t, t.shape))
print('t:\n',t)
t = torch.ones((2, 5))
list_tensors = torch.split(t, [2, 1, 2], dim=1)
for idx, t in enumerate(list_tensors):
    print('第{}个张量:\n{}\nshape is:\n{}'.format(idx + 1, t, t.shape))
output：
第1个张量:
tensor([[1., 1.],
        [1., 1.]])
shape is:
torch.Size([2, 2])
第2个张量:
tensor([[1., 1.],
        [1., 1.]])
shape is:
torch.Size([2, 2])
第3个张量:
tensor([[1.],
        [1.]])
shape is:
torch.Size([2, 1])
t:
 tensor([[1.],
        [1.]])
第1个张量:
tensor([[1., 1.],
        [1., 1.]])
shape is:
torch.Size([2, 2])
第2个张量:
tensor([[1.],
        [1.]])
shape is:
torch.Size([2, 1])
第3个张量:
tensor([[1., 1.],
        [1., 1.]])
shape is:
torch.Size([2, 2])

3.2 张量的索引

1. torch.index_select()

torch.index_select()
功能：在维度dim上，按index索引数据
返回值：依index索引数据拼接的张量

• input：要索引的张量
• dim：要索引的维度
• index：要索引数据的序号

  torch.index_select(input,
                dim,
                index,
                out=None)

  ```python

  example5

  torch.index_select

import torch

t = torch.randint(0, 9, size=(3, 3)) idx = torch.tensor([0, 2], dtype=torch.long) t_select = torch.index_select(t, dim=0, index=idx) print(‘t:\n{}\nidx:\n{}\nt_select:\n{}’.format(t, idx, t_select))

output： t: tensor([[4, 4, 1], [5, 1, 8], [2, 1, 2]]) idx: tensor([0, 2]) t_select: tensor([[4, 4, 1], [2, 1, 2]])

<a name="NN86p"></a>
#### 2. torch.masked_select()
torch.index_select()<br />功能：按mask中的True进行索引<br />返回值：一维张量
   - input：要索引的张量
   - mask：与input同形状的布尔类型张量
```python
torch.masked_select(input,
                    mask,
                    out=None)

ge：>= gt：> le：<= lt：<

# example6
# torch.masked_select
import torch
t = torch.randint(0, 9, size=(3, 3))
mask = t.ge(5)
t_select = torch.masked_select(t, mask)
print('t:\n{}\nmask:\n{}\nt_select:\n{}'.format(t, mask, t_select))
output：
t:
tensor([[5, 3, 1],
        [3, 8, 6],
        [1, 5, 4]])
mask:
tensor([[ True, False, False],
        [False,  True,  True],
        [False,  True, False]])
t_select:
tensor([5, 8, 6, 5])

3.3 张量的变换

1. torch.reshape()

torch.reshape()
功能：变换张量的形状
注意事项：当张量在内存中是连续存在时，新张量与input共享内存

• input：要变换的张量
• shape：新张量的形状

  torch.reshape(input,
           shape)

  ```python

  example7

  torch.reshape

import torch

t = torch.randperm(8) t_reshape = torch.reshape(t, (-1, 4)) print(‘t:\n{}\nt_reshape:\n{}’.format(t, t_reshape))

print(‘t.data 内存地址:{}’.format(id(t.data))) print(‘t_reshape.data 内存地址:{}’.format(id(t_reshape.data))) t[0] = 1024 print(‘t:\n{}\nt_reshape:\n{}’.format(t, t_reshape))

output： t: tensor([5, 7, 0, 2, 6, 1, 4, 3]) t_reshape: tensor([[5, 7, 0, 2], [6, 1, 4, 3]]) t.data 内存地址:1749654845224 t_reshape.data 内存地址:1749654845224 t: tensor([1024, 7, 0, 2, 6, 1, 4, 3]) t_reshape: tensor([[1024, 7, 0, 2], [ 6, 1, 4, 3]])

<a name="KRXRX"></a>
#### 2. torch.transpose()
torch.transpose()<br />功能：交换张量的两个维度
   - input：要交换维度的张量
   - dim0：要交换的维度
   - dim1：要交换的维度
```python
torch.transpose(input,
                dim0,
                dim1)

# example8
# torch.transpose
import torch
t = torch.rand(2, 3, 4)
t_transpose = torch.transpose(t, dim0=1, dim1=2)
print('t:\n{}\nt_transpose:\n{}'.format(t, t_transpose))
print('t.shape:\n{}\nt_transpose.shape:\n{}'.format(t.shape, t_transpose.shape))
output：
t:
tensor([[[0.9669, 0.3727, 0.8775, 0.5900],
         [0.1132, 0.6863, 0.9109, 0.8974],
         [0.5809, 0.0539, 0.7609, 0.3699]],
        [[0.9527, 0.2056, 0.6411, 0.6718],
         [0.6573, 0.9133, 0.6319, 0.2841],
         [0.5032, 0.6048, 0.4830, 0.4872]]])
t_transpose:
tensor([[[0.9669, 0.1132, 0.5809],
         [0.3727, 0.6863, 0.0539],
         [0.8775, 0.9109, 0.7609],
         [0.5900, 0.8974, 0.3699]],
        [[0.9527, 0.6573, 0.5032],
         [0.2056, 0.9133, 0.6048],
         [0.6411, 0.6319, 0.4830],
         [0.6718, 0.2841, 0.4872]]])
t.shape:
torch.Size([2, 3, 4])
t_transpose.shape:
torch.Size([2, 4, 3])

3. torch.t()

torch.t()
功能：2维张量转置，对矩阵而言，等价于 torch.transpose(input,0,1)

torch.t(input)

4. torch.squeeze()

torch.squeeze()
功能：压缩长度为1的维度（轴）

• dim：若为None，移除所有长度为1的轴；若指定维度，当且仅当该轴长度为1时，可以被移除。

  torch.squeeze(input,
           dim=None,
           out=None)

  ```python

  example9

  torch.squeeze

import torch

t = torch.rand((1, 2, 3, 1)) t_sq = torch.squeeze(t) t0 = torch.squeeze(t, dim=0) t1 = torch.squeeze(t, dim=1)

print(‘t.shape:\n{}\nt_sq.shape:\n{}’.format(t.shape, t_sq.shape)) print(‘t0.shape:\n{}\nt1.shape:\n{}’.format(t0.shape, t1.shape))

output： t.shape: torch.Size([1, 2, 3, 1]) t_sq.shape: torch.Size([2, 3]) t0.shape: torch.Size([2, 3, 1]) t1.shape: torch.Size([1, 2, 3, 1])

<a name="eZVKM"></a>
#### 5. torch.unsqueeze()
torch.unsqueeze()<br />功能：依据dim扩展维度
   - dim：扩展的维度
```python
torch.usqueeze(input,
               dim,
               out=None)

6. torch.flatten()

torch.flatten(input, start_dim=0, end_dim=-1)
功能：展平/推平一个连续范围的维度，输出类型为 Tensor

• input: 一个 tensor，即要被“推平”的 Tensor。
• start_dim: “推平”的起始维度。
• end_dim: “推平”的结束维度。

首先如果按照 start_dim 和 end_dim 的默认值，那么这个函数会把 input 推平成一个 shape 为 [n] 的tensor，其中 n 即 input 中元素个数
当 start_dim = 1 而 end_dim = −1 时，它把第 1 个维度到最后一个维度全部推平合并了。而当 start_dim = 0 而 end_dim = 1 时，它把第 0 个维度到第 1 个维度全部推平合并了。

import torch
t = torch.tensor([[[1, 2, 2, 1],
                   [3, 4, 4, 3],
                   [1, 2, 3, 4]],
                  [[5, 6, 6, 5],
                   [7, 8, 8, 7],
                   [5, 6, 7, 8]]])
print('t:\n{}\nt.shape:\n{}'.format(t, t.shape))
x = torch.flatten(t, start_dim=1)
print('x:\n{}\nx.shape:\n{}'.format(x, x.shape))
y = torch.flatten(t, start_dim=0, end_dim=1)
print('y:\n{}\ny.shape:\n{}'.format(y, y.shape))
output：
"""
t:
tensor([[[1, 2, 2, 1],
         [3, 4, 4, 3],
         [1, 2, 3, 4]],
        [[5, 6, 6, 5],
         [7, 8, 8, 7],
         [5, 6, 7, 8]]])
t.shape:
torch.Size([2, 3, 4])
x:
tensor([[1, 2, 2, 1, 3, 4, 4, 3, 1, 2, 3, 4],
        [5, 6, 6, 5, 7, 8, 8, 7, 5, 6, 7, 8]])
x.shape:
torch.Size([2, 12])
y:
tensor([[1, 2, 2, 1],
        [3, 4, 4, 3],
        [1, 2, 3, 4],
        [5, 6, 6, 5],
        [7, 8, 8, 7],
        [5, 6, 7, 8]])
y.shape:
torch.Size([6, 4])
"""

3.4 张量的数学运算——加减乘除

1. torch.add()

torch.add()
功能：逐元素计算 input+alpha×other

• input：第一个张量
• alpha：乘项因子
• other：第二个张量

  torch.add(input
       alpha=1,
       other,
       out=None)

  ```python

  example10

  torch.add

import torch

t0 = torch.randn((3, 3)) t1 = torch.ones_like(t0) t_add = torch.add(t0, 10, t1)

print(‘t0:\n{}\nt1:\n{}\nt_add:\n{}’.format(t0, t1, t_add))

output： t0: tensor([[-0.1253, -0.2573, -2.2917], [ 1.4232, 0.1650, -0.1312], [ 0.7477, 0.1264, -0.6293]]) t1: tensor([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]) t_add: tensor([[ 9.8747, 9.7427, 7.7083], [11.4232, 10.1650, 9.8688], [10.7477, 10.1264, 9.3707]])

<a name="bhNjB"></a>
#### 2. torch.addcdiv()
torch.addcdiv()<br />功能：逐元素计算    input + value * tensor1 / tensor2
torch.addcmul()<br />功能：input + value * tensor1 * tensor2
```python
torch.addcmul(input,
              value=1,
              tensor1,
              tensor2,
              out=None)

torch.sub()
torch.div()
torch.mul()

3.5 张量的数学运算——对指幂函数

torch.log(input,out=None)
torch.log10(input,out=None)
torch.log2(input,out=None)
torch.exp(input,out=None)
torch.pow()

3.6 张量的数学运算——三角函数

torch.abs(input,out=None)
torch.acos(input,out=None)
torch.cosh(input,out=None)
torch.cos(input,out=None)
torch.asin(input,out=None)
torch.atan(input,out=None)
torch.atan2(input,other,out=None)

3.7 线性回归

线性回归是分析一个变量与另外一（多）个变量之间关系的方法

因变量：y 自变量：x 关系：线性
y = wx + b

求解步骤：

1. 确定模型 Model：y = wx + b

2. 选择损失函数 MSE：

3. 求解梯度并更新w，b w = LR w.grad b = b - LR b.grad （LR：学习率，步长）

线性回归模型示例：

# -*- coding:utf-8 -*-
"""
@file_name  :lesson1.3-Linear_Regression
@author     :
@data       :2021-05-07
@brief      :一元线性回归
"""
import torch
from matplotlib import pyplot as plt
torch.manual_seed(10)
lr = 0.1  # 学习率
# 创建训练数据
x = torch.rand(20, 1) * 10  # x data (tensor),shape=(20,1)
y = 2 * x + (5 + torch.randn(20, 1))  # y data (tensor),shape=(20,1)
# 构建线性回归参数
w = torch.randn((1), requires_grad=True)
b = torch.zeros((1), requires_grad=True)
for iteration in range(1000):
    # 前向传播
    wx = torch.mul(w, x)
    y_pred = torch.add(wx, b)
    # 计算 MSE loss
    loss = (0.5 * (y - y_pred) ** 2).mean()
    # 反向传播
    loss.backward()
    # 更新参数
    b.data.sub_(lr * b.grad)
    w.data.sub_(lr * w.grad)
    # 绘图
    if iteration % 20 == 0:
        plt.scatter(x.data.numpy(), y.data.numpy())
        plt.plot(x.data.numpy(), y_pred.data.numpy(), 'r-', lw=5)
        plt.text(2, 20, 'Loss=%0.4f' % loss.data.numpy(), fontdict={'size': 20, 'color': 'red'})
        plt.xlim(1.5, 10)
        plt.ylim(8, 28)
        plt.title('Iteration:{}\nw:{} b:{}'.format(iteration, w.data.numpy(), b.data.numpy()))
        plt.pause(0.5)
        if loss.data.numpy() < 1:
            break

4. 计算图与动态图机制

Content

1. 计算图
2. Pytorch的动态图机制

4.1 计算图

• 计算图是用来描述运算的有向无环图
• 计算图两个主要元素：结点Node，边Edge
  • 结点表示数据，如向量/矩阵/张量
  • 边表示运算，如加/减/乘/除/卷积

用计算图表示：y = (x + w) * (w + 1)

计算图与梯度求导
y = (x + w) (w + 1)
a = x + w b = w + 1
y = a b

叶子结点
叶子节点：用户创建的结点，如上述的 x 和 w 。
is_leaf：指示张量是否为叶子结点
非叶子节点梯度会被释放

grad_fn：记录创建该张量时所用的方法/函数
叶子结点：grad_fn = None

# y.grad_fn = <MulBackward0>
# a.grad_fn = <AddBackward0>
# b.grad_fn = <AddBackward0>

# example1
# 计算图示例
import torch
w = torch.tensor([1., ], requires_grad=True)
x = torch.tensor([2., ], requires_grad=True)
a = torch.add(w, x)
a.retain_grad()  # 保存非叶子结点a的梯度
b = torch.add(w, 1)
y = torch.mul(a, b)
y.backward()
print(w.grad)  # w=5
# 查看叶子节点
# print("is_leaf:\n", w.is_leaf, x.is_leaf, a.is_leaf, b.is_leaf, y.is_leaf)    # TTFFF
print('w.is_leaf:', w.is_leaf)
print('x.is_leaf:', x.is_leaf)
print('a.is_leaf:', a.is_leaf)
print('b.is_leaf:', b.is_leaf)
print('y.is_leaf:', y.is_leaf)
# 查看梯度
# print("gradient:\n", w.grad, x.grad, a.grad, b.grad, y.grad)
print('w.grad:', w.grad)
print('x.grad:', x.grad)
print('a.grad:', a.grad)
print('b.grad:', b.grad)
print('y.grad:', y.grad)
# 查看 grad_fn
# print("grad_fn:\n", w.grad_fn, x.grad_fn, a.grad_fn, b.grad_fn, y.grad_fn)  # NNAAM
print('w.grad_fn:', w.grad_fn)
print('x.grad_fn:', x.grad_fn)
print('a.grad_fn:', a.grad_fn)
print('b.grad_fn:', b.grad_fn)
print('y.grad_fn:', y.grad_fn)
output：
tensor([5.])
w.is_leaf: True
x.is_leaf: True
a.is_leaf: False
b.is_leaf: False
y.is_leaf: False
w.grad: tensor([5.])
x.grad: tensor([2.])
a.grad: tensor([2.])
b.grad: None
y.grad: None
w.grad_fn: None
x.grad_fn: None
a.grad_fn: <AddBackward0 object at 0x000001974E7E15C8>
b.grad_fn: <AddBackward0 object at 0x000001974E7E1608>
y.grad_fn: <MulBackward0 object at 0x000001974E7E15C8>

4.2 动态图

动态图 VS. 静态图
根据计算图搭建方式，可将计算图分为动态图和静态图

5. 自动求导系统torch.autograd及逻辑回归实现

Content

1. torch.autograd
2. 逻辑回归

5.1 autograd——自动求导系统

1. torch.autograd.backward()

torch.autograd.backward()
功能：自动求取梯度

• tensors：用于求导的张量，如loss
• retain_graph：保存计算图
• create_graph：创建导数计算图，用于高阶求导
• grad_tensors：多梯度权值

torch.autograd.backward(tensors,
                        grad_tensors=None,
                        retain_graph=None,
                        create_graph=Flase)

# example1
# retain_graph
import torch
torch.manual_seed(10)
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([1.], requires_grad=True)
a = torch.add(w, x)
b = torch.add(w, 1)
y = torch.mul(a, b)
y.backward(retain_graph=True)
print(w.grad)
y.backward()
print(w.grad)
output：
tensor([4.])
tensor([8.])

# example2
# grad_tensors
import torch
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
a = torch.add(w, x)
b = torch.add(w, 1)
y0 = torch.mul(a, b)    # y0=(x + w)*(w + 1)    dy0/dw=5
y1 = torch.add(a, b)    # y1=(x + w)+(w + 1)    dy1/dw=2
loss = torch.cat([y0, y1], dim=0)
grad_tensors = torch.tensor([1., 2.])
loss.backward(gradient=grad_tensors)
# gradient 传入 torch.autograd.backward()中的grad_tensors
print(w.grad)
output：
tensor([9.])

2. torch.autograd.grad()

torch.autograd.grad()
功能：求取梯度

• outputs：用于求导的张量，如loss
• inputs：需要梯度的张量
• create_graph=Flase：创建导数计算图，用于高阶求导
• retain_graph=None：保存计算图
• grad_tensors=None：多梯度权值

torch.autograd.grad(outputs,
                    inputs,
                    grad_tensors=None,
                    retain_graph=None,
                    create_graph=Flase)

# example3
# torch.autograd.grad
import torch
x = torch.tensor([3.], requires_grad=True)
y = torch.pow(x, 2)
grad_1 = torch.autograd.grad(y, x, create_graph=True)
print(grad_1)
grad_2 = torch.autograd.grad(grad_1[0], x)
print(grad_2)
output：
(tensor([6.], grad_fn=<MulBackward0>),)
(tensor([2.]),)

autograd小贴士：

1. 梯度不自动清零，使用 w.grad.zero_() 操作清零

2. 依赖于叶子结点的结点，requires_grad默认为True

3. 叶子结点不可执行in-place

in-place：原位操作，在原有内存地址上进行操作

# example3
# tips-1
import torch
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
for i in range(3):
    a = torch.add(w, x)
    b = torch.add(w, 1)
    y = torch.mul(a, b)
    y.backward()
    print(w.grad)
    if i ==1:
        w.grad.zero_()
output：
tensor([5.])
tensor([10.])
tensor([5.])

# example4
# tips-2
import torch
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
a = torch.add(w, x)
b = torch.add(w, 1)
y = torch.mul(a, b)
print('a.requires_grad:',a.requires_grad)
print('b.requires_grad:',b.requires_grad)
print('y.requires_grad:',y.requires_grad)
output：
a.requires_grad: True
b.requires_grad: True
y.requires_grad: True

5.2 逻辑回归

逻辑回归是线性的二分类模型
模型表达式：

f(x)称为Sigmoid函数，也称为Logistics函数。

逻辑回归与线性回归
线性回归是分析自变量x与因变量y（标量）之间关系的方法
逻辑回归是分析自变量x与因变量y（概率）之间关系的方法

逻辑回归又称对数几率回归

机器学习模型训练步骤：

1. 数据：数据采集、数据清洗、数据划分、数据预处理
2. 模型：线性模型/神经网络模型
3. 损失函数：线性模型中采用的均方差损失函数、分类任务中的交叉熵
4. 优化器：更新权值
5. 迭代训练：反复迭代训练

逻辑回归模型示例：

# -*- coding:utf-8 -*-
"""
@file_name  :lesson1.5-Logistic_Regression
@author     :
@data       :2021-05-09
@brief      :逻辑回归
"""
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np
# ========== step 1/5 生成数据 ==========
sample_nums = 100
mean_value = 1.7
bias = 1
n_data = torch.torch.ones(sample_nums, 2)
x0 = torch.normal(mean_value * n_data, 1) + bias  # 类别0 数据 shape=(100,2)
y0 = torch.zeros(sample_nums)  # 类别0 标签 shape=(100,1)
x1 = torch.normal(-mean_value * n_data, 1) + bias  # 类别1 数据 shape=(100,2)
y1 = torch.ones(sample_nums)  # 类别1 标签 shape=(100,1)
train_x = torch.cat((x0, x1), 0)
train_y = torch.cat((y0, y1), 0)
# ========== step 2/5 选择数据 ==========
class LR(nn.Module):
    def __init__(self):
        super(LR, self).__init__()
        self.features = nn.Linear(2, 1)
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        x = self.features(x)
        x = self.sigmoid(x)
        return x
lr_net = LR()  # 实例化逻辑回归模型
# ========== step 3/5 选择损失函数 ==========
loss_fn = nn.BCELoss()
# ========== step 4/5 选择优化器 ==========
lr = 0.01  # 学习率
optimizer = torch.optim.SGD(lr_net.parameters(), lr=lr, momentum=0.9)
# ========== step 5/5 模型训练 ==========
for iteration in range(1000):
    # 前向传播
    y_pred = lr_net(train_x)
    # 计算loss
    loss = loss_fn(y_pred.squeeze(), train_y)
    # 方向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 绘图
    if iteration % 20 == 0:
        mask = y_pred.ge(0.5).float().squeeze()  # 以0.5为阀值进行分类
        correct = (mask == train_y).sum()  # 计算正确预测的样本个数
        acc = correct.item() / train_y.size(0)  # 计算分类准确率
        plt.scatter(x0.data.numpy()[:, 0], x0.data.numpy()[:, 1], c='r', label='class0')
        plt.scatter(x1.data.numpy()[:, 0], x1.data.numpy()[:, 1], c='b', label='class1')
        w0, w1 = lr_net.features.weight[0]
        w0, w1 = float(w0.item()), float(w1.item())
        plot_b = float(lr_net.features.bias[0].item())
        plot_x = np.arange(-6, 6, 0.1)
        plot_y = (-w0 * plot_x - plot_b) / w1
        plt.xlim(-5, 7)
        plt.ylim(-7, 7)
        plt.plot(plot_x, plot_y)
        plt.text(-5, 5, 'Loss=%0.4f' % loss.data.numpy(), fontdict={'size': 20, 'color': 'red'})
        plt.title('Iteration: {}\nw0:{:.2f} w1:{:.2f} b:{:.2f} accuracy:{:.2f}'.format(iteration, w0, w1, plot_b, acc))
        plt.legend()
        plt.show()
        plt.pause(0.5)
        if acc > 0.99:
            break

二、第二周：Pytorch数据处理

数据：

• 数据收集：数据又原始样本和标签
• 数据划分：数据会划分为训练集、验证集和测试集（train、valid、test）。

        - 训练集->训练模型；
        - 验证集->验证模型是否过拟合，也就是挑选模型，挑选那些还没有过拟合的模型；
        - 测试集->测试挑选出来的模型的性能

• 数据读取：DataLoader

        - Sampler->生成索引
        - Dataset->根据索引去读取图片和标签

• 数据预处理：transforms

6. 数据读取模块——DataSet与DataLoader

Content

1. 人民币二分类
2. DataLoader与Dataset

6.1 DataLoader与Dataset

1. torch.utils.data.DataLoader

torch.utils.data.DataLoader
功能：构建可迭代的数据装载器

• dataset：Dataset类，决定数据从哪里读取
• batch_size：批大小
• num_workers：是否多进程读取数据
• shuffle=False：每个epoch是否乱序
• drop_last=False：当样本数不能被batchsize整除时，是否舍弃最后一批数据

torch.utils.data.DataLoader()
DataLoader(dataset,
           batch_size=1,
           shuffle=False,
           sampler=None,
           batch_sampler=None,
           num_workers=0,
           collate_fn=None,
           pin_memory=False,
           drop_last=False,
           timeout=0,
           worker_in it_fn=None,
           multiprocessing_context=None)

epoch：所有训练样本都已输入到模型中，称为1个epoch
iteration：一批样本输入到模型中，称为1个iteration
batchsize：批大小，决定了一个epoch有多少个iteration

例如：

样本总数：87，batchsize：8
drop_last = True：1 epoch = 10 iteration    # 舍弃掉后七个样本
drop_last = Flase：1 epoch = 11 iteration

2. touch.utils.data.Dataset

touch.utils.data.Dataset
功能：Dataset抽象类，所有自定义的Dataset都需要继承它，并且复写 __getitem__()（接受一个索引，返回一个样本）

torch.utils.data.Dataset()
class Dataset(object):
    def __getitem__(self, index):
        # 接收一个索引，返回一个样本
        raise NotImplementedError
    def __add__(self, other):
        return ConcatDataset([self, other])

6.2 人民币二分类

数据读取：

• 读哪些数据？ Sampler输出Index
• 从哪读数据？ Dataset中的data_dir
• 怎么读数据？ Dataset中的getitem

7. 图像数据预处理模块——transforms

Content

1. transforms运行机制
2. 数据标准化——transforms.normalize

7.1 transforms运行机制

1. 计算机视觉工具包：torchvision

• torchvision.transforms：常用的图像预处理方法

• torchvision.datasets：常用数据集，如MNIST/CIFAR-10/ImageNet

• torchvision.model：常用的模型预训练，如AlexNet/VGG/ResNet/GoogLeNet

2. 常用图像预处理方法：transforms

• 数据中心化/标准化

• 缩放/裁剪/旋转/翻转/填充/噪声添加

• 灰度变换/线性变换/仿射变换/亮度、饱和度及对比度变换

7.2 数据标准化——transforms.Normalize

1. transform.Normalize

transform.Normalize
功能：逐channel（通道）的对图像进行标准化，加快模型的收敛速度
output = (input - mean) / std ==> 得到0均值1标准差的数据分布

• mean：各通道的均值
• std：各通道的标准差
• inplace：是否原地操作

  # 对图像的每个通道进行标准化
  # output = (input - mean) / std
  transforms.Normalize(mean,
                  std,
                  inplace=False)

8. transforms图像增强（一）

Content

1. 数据增强
2. transforms——裁剪
3. transforms——翻转和旋转

8.1 数据增强（Data Augmentation）

数据增强又称为数据增广、数据扩增，它是对训练集进行变换，使训练集更丰富，从而让模型更具泛化能力。

原则：使得训练集与测试集更接近

• 空间位置：平移
• 色彩：灰度图，色彩抖动
• 形状：仿射变换
• 上下文场景：遮挡，填充

8.2 transforms——裁剪（Crop）

1. transforms.CenterCrop

transforms.CenterCrop
功能：从图像中心裁剪图片

• size：所需裁剪图片尺寸（也就是裁剪后图片的尺寸）

  # 1. 从图像中心裁剪
  transforms.CenterCrop(size)    # 所需裁剪图片尺寸

2. transforms.RandomCrop

transforms.RandomCrop
功能：从图片中随机裁剪出尺寸为size的图片

• size：所需裁剪图片尺寸
• padding：设置填充大小
  • 当为 a 时，上下左右均填充 a 个像素
  • 当为 (a,b) 时，上下填充 b 个像素，左右填充 a 个像素
  • 当为 (a,b,c,d) 时，左、上、右、下分别填充 a,b,c,d 个像素
• pad_if_need：若图像小于设定的size，则填充
• padding_mode：填充模式，有 4 种模式
  • constant：像素值由 fill 设定
  • edge：像素值由图像边缘像素决定
  • reflect：镜像填充，最后一个像素不镜像，例：[1,2,3,4] — [3,2,1,2,3,4,3,2]
  • symmetric：镜像填充，最后一个像素镜像，例：[1,2,3,4] — [2,1,1,2,3,4,4,3]
• fill：constant时，设置填充的像素值

  transforms.RandomCrop(size,    # 所需裁剪图片的尺寸
                   padding=None,    # 设置填充大小
                   pad_if_needed=False,    # 若图像小于设定size，则填充
                   fill=0,    # 填充模式为constant时，设置填充的像素值，如(R,G,B)/(Gray)
                   padding_mode='constant')    # 填充模式，共有4种

3. transforms.RandomResizedCrop

transforms.RandomResizedCrop
功能：随机大小。长宽比裁剪图片

• size：所需裁剪图片的尺寸
• scale=(0.08, 1.0)：随机裁剪面积比例
• ratio=(3/4, 4/3)：随即长宽比
• interpolation：插值方法，最近邻/双线性/双三次插值
  • PIL.Image.NEAREST 最近邻
  • PIL.Image.BILINEAR 双线性
  • PIL.Image.BICUBIC 双三次插值

    # 3. 随机大小、长宽比裁剪图片
    transforms.RandomResizedCrop(size,    # 所需裁剪图片的尺寸
                         scale=(0.08, 1.0),    # 随机裁剪面积比例
                         ratio=(3/4, 4/3)    # 随机长宽比
                         interpolation)    # 插值方法，最近邻/双线性/双三次插值

4. transforms.FiveCrop

5. transforms.TenCrop

transforms.FiveCrop
transforms.TenCrop
功能：在图像的上下左右以及中心裁剪出尺寸为size的5张图片，transforms.TenCrop对这 5 张图片进行水平或者垂直镜像获得 10 张图片。

• size：所需裁剪图片尺寸
• vertical_flip：是否垂直翻转

  # 4. 从图像上下左右及中心裁剪出尺寸为size的5张图像
  transforms.FiveCrop(size)    # 返回一个tuple

  # 5. 对上述5张图像进行水平或者垂直镜像获得10张图像
  transforms.TenCrop(size,    # 所需裁剪图片尺寸
                vertical_flip=False)    # 是否垂直翻转

8.3 transforms——翻转与旋转（Flip and Rotation）

1. RandomHorizontalFlip

2. RandomVerticalFlip

RandomHorizontalFlip
RandomVerticalFlip
功能：依概率水平（左右）或垂直（上下）翻转图片

• p：翻转概率

  # 水平翻转
  transforms.RandomHorizontalFlip(p=0.5)

  # 垂直翻转
  transforms.RandomVerticalFlip(p=0.5)

3. transforms.RandomRotation

transforms.RandomRotation
功能：随机旋转图片

• degrees：旋转角度
  • 当degrees=a时，在(-a, a)之间选择旋转角度
  • 当degrees=(a, b)时，在（a, b)之间选择旋转角度
• resample=False：重采样方法
• expand=False：是否扩大图片，以保持原图信息
• center=None：旋转点设置，默认中心旋转

  # 2. 旋转
  transforms.RandomRotation(degrees,    # 旋转角度
                       resample=False,    # 重采样方法
                       expand=False,    # 是否扩大图片，以保持原图信息
                       center=None)    # 旋转点设置，默认中心旋转

9. transforms图像增强（二）

Content

1. transforms——图像变换
2. transforms——transforms方法操作
3. 自定义 transforms 方法

9.1 transforms——图像变换（Data Augmentation）

1. transforms.Pad

transforms.Pad
功能：对图片的边缘进行填充

• padding：设置填充大小
  • 当padding=a时，上下左右均填充a个像素
  • 当padding=(a, b)时，上下填充b个像素，左右填充a个像素
  • 当padding=(a, b, c, d)时，左/上/右/下分别填充a/b/c/d个像素
• padding_mode：填充模式，有 4 种模式，constant、edge、reflect、symmetric
• fill：填充模式为constant时，设置填充的像素值，如(R,G,B)/(Gray)

  # 1. 填充图像边缘
  transforms.Pad(padding,    # 设置填充大小
            # 当padding=a时，上下左右均填充a个像素
            # 当padding=(a, b)时，上下填充b个像素，左右填充a个像素
            # 当padding=(a, b, c, d)时，左/上/右/下分别填充a/b/c/d个像素
            fill=0,    # 填充模式为constant时，设置填充的像素值，如(R,G,B)/(Gray)
            padding_mode='constant')    # 填充模式，constant/edge/reflect/symmetric

2. transforms.ColorJitter

transforms.ColorJitter
功能：调整亮度、对比度、饱和度和色相

• brightness：亮度调整因子
  • 当brightness=a时，在[max(0, 1-a), 1+a]之间选择
  • 当brightness=(a, b)时，在[a, b]之间选择
• contrast：对比度参数，同brightness
• saturation：饱和度参数，同brightness
• hue=0：色相参数
  • 当hue=a时，在[-a, a]之间选择
  • 当hue=(a, b)时，在[a, b]之间选择

    # 2. 调整图像亮度/对比度/饱和度/色相
    transforms.ColorJitter(brightness=0,    # 亮度调整因子
                        # 当brightness=a时，在[max(0, 1-a), 1+a]之间选择
                        # 当brightness=(a, b)时，在[a, b]之间选择
                   contrast=0,    # 对比度参数，同brightness
                   saturation=0,    # 饱和度参数，同brightness
                   hue=0)    # 色相参数
                        # 当hue=a时，在[-a, a]之间选择
                        # 当hue=(a, b)时，在[a, b]之间选择

3. transforms.Grayscale

4. transforms.RandomGrayscale

transforms.Grayscale
transforms.RandomGrayscale
功能：依概率将图片转换为灰度图

• num_ouput_channels：输出通道数
• p：概率值，图像被转换为灰度图的概率

注意事项：transforms.Grayscale 是 transforms.RandomGrayscale p = 1 时的特例

# 3. 灰度图转换
transforms.Grayscale(num_output_channels)    # 输出通道数，1或3
transforms.RandomGrayscale(num_output_channels, 
                p=0.1)    # 概率值

5. transforms.RandomAffine

transforms.RandomAffine
功能：对图像进行仿射变换，仿射变换是二维的线性变换，由五种基本原子变换构成，分别是旋转、平移、缩放、错切和翻转。

• degrees：设置旋转角度
• translate：平移区间设置
  • 如 translate = (a, b) ，a 设置宽（width），b 设置高（height）；
  • 图像在宽维度平移的区间为 -img_width a < dx < img_width a
  • 图像在高维度平移的区间为 -img_height b < dy < img_height b
• scale：缩放比例（以面积为单位）
• fillcolor：填充颜色设置
• shear：错切角度设置，有水平错切和垂直错切
  • 当 shear = a 时，仅在 x 轴错切，错切角度在 (-a, a) 之间
  • 当 shear = (a, b) 时，则 x 轴在 (-a, a) 之间随机选择错切角度，y 轴在 (-b, b) 之间随机选择错切角度
  • 当shear=(a, b, c, d) 时，则 x 轴在 (a, b) 之间随机选择错切角度，y 轴在 (c, d) 之间随机选择错切角度
• resample：重采样方式，NEAREST、BILINEAR、BICUBIC

  # 5.    仿射变换
  # 仿射变换是二维的线性变换，由五种基本原子变换构成，旋转/平移/缩放/错切/翻转
  transforms.RandomAffine(degrees,    # 设置旋转角度
                     translate=None,    # 平移区间设置
                         # 例：translate=(a, b)，a为宽，b为高
                         # 图像在宽维度平移的区间为 -img_width * a < dx < img_width * a
                         # 图像在高维度平移的区间为 -img_height * b < dy < img_height * b
                     scale=None,    # 缩放比例
                     shear=None,    # 错切角度设置
                         # 当shear=a时，仅在x轴错切，错切角度在(-a, a)之间
                         # 当shear=(a, b)时，则a设置x轴角度，b设置y轴角度
                         # 当shear=(a, b, c, d)时，则a、b设置x轴角度，c、d设置y轴角
                     resample=False,    # 重采样方式，NEAREST/BILINEAR/BICUBIC
                     fillcolor=0)    # 填充颜色设置

6. transforms.RandomErasing

transforms.RandomErasing
功能：对图像进行随机遮挡

• p：概率值，执行该操作的概率
• scale：遮挡区域面积
• ratio=：遮挡区域长宽比
• value：遮挡区域像素值，如(R,G,B)/(Gray)/‘random’（只要是字符串就会随机）
• inplace

注意事项：transforms.RandomErasing 是对张量进行操作，所以执行 transforms.RandomErasing 之前，一般需要执行 transforms.ToTensor

# 6. 随机遮挡
transforms.ToTensor()
transforms.RandomErasing(p=0.5,    # 执行遮挡的概率
                         scale=(0.02, 0.33),    # 遮挡区域面积
                         ratio=(0.3, 3.3)    # 遮挡区域长宽比
                         value=0,    # 遮挡区域像素值，如(R,G,B)/(Gray)/'random'
                         inplace=False)

7. transforms.ToTensor

transforms.ToTensor
功能：将 PILImage 或者 numpy 的 ndarray 转化成 Tensor ；把一个取值范围是 [0,255] 的 PIL.Image 转换成 Tensor ，shape 为 (H,W,C) 的 numpy.ndarray ，转换成形状为 [C,H,W] ，取值范围是 [0,1.0] 的 Tensor 。
对于 PILImage 转化的 Tensor ，其数据类型是 torch.FloatTensor 对于 ndarray 的数据类型没有限制，但转化成的 Tensor 的数据类型是由 ndarray 的数据类型决定的。

8. transforms.Lambda

transforms.Lambda
功能：用户自定义 lambda 方法

• lambda：lambda 匿名函数
  • lambda[arg1 [,arg2,…,argn]] : expression

    # 8. 自定义lambda方法
    transforms.Lambda(lambd)    # 匿名函数 lambda[arg1 [,arg2,...,argn]] : expression

9.2 transforms——transforms方法操作（Transforms Operation）

1. transforms.RandomChoice

transforms.RandomChoice
功能：从一系列 transforms 方法中随机挑选一个

transforms.RandomChoice([transforms1, transforms2, transforms3])

2. transforms.RandomApply

transforms.RandomApply
功能：依概率执行一组 transforms 操作

transforms.RandomApply([transforms1, transforms2, transforms3], p=0.5)

3. transforms.RandomOrder

transforms.RandomOrder
功能：对一组 transforms 操作打乱顺序

transforms.RandomOrder([transforms1, transforms2, transforms3])

9.3 自定义 transforms 方法（User-Defined Transforms）

自定义 transforms 方法要素：

1. 仅接受一个参数，返回一个参数
2. 注意上下游的输出与输入

   class Compose(object):
    def __call__(self, img):
        for t in self.transform:
            img = t(img)
        return img

通过类实现多参数传入：

# 通过类实现多参数传入
class YoutTransforms(object):
    def __init__(self, ...):
        ...
    def __call__(self, img):
        ...
        return img

椒盐噪声
椒盐噪声又称为脉冲噪声，是一种随机出现的白点或者黑点，白点成为盐噪声，黑色成为椒噪声
信噪比（Signal-Noise Rate，SNR）是衡量噪声的比例，图像中为图像像素的占比

class AddPepperNoise(object):
    def __init__(self, snr, p):
        self.snr = snr
        self.p = p
    def __call__(self, img):
        """
        添加椒盐噪声具体实现过程
        """
        return img
class Compose(object):
    def __call__(self,img):
        for t in self.transforms:
            img = t(img)
        return img

transforms 方法总结

第三周 模型模块

10. 模型创建与 nn.Module

Content

1. 网络模型创建步骤
2. nn.Module属性

10.1 网络模型创建步骤（Steps of Creating Module）

模型创建两要素：

• 构建子模块(构建网络层) ==> init()
• 拼接子模块(拼接网络层) ==> forward()

10.2 nn.Module属性

1. torch.nn

torch.nn：

• nn.Parameter：张量子类，表示可学习参数，如weight/权重、bias/偏置
• nn.Module：所有网络层基类，管理网络属性
• nn.functional：函数具体实现，如卷积、池化、激活函数等
• nn.init：参数初始化方法

2. nn.Module

nn.Module
功能：所有网络层基类，管理网络属性
nn.Module有 8 个属性，这个 8 个属性都是有序字典（OrderDict）：

• paramters：存储管理 nn.Parameter 类
• modules：存储管理 nn.Module 类
• buffers：存储管理缓冲属性，如 BN 层中 running_mean
• *_hooks：存储管理钩子函数

  self._parameter = OrderDict()
  self._buffers = OrderDict()
  self._backward_hooks = OrderDict()
  self._forward_hooks = OrderDict()
  self._forward_pre_hooks = OrderDict()
  self._state_dict_hooks = OrderDict()
  self._load_state_pre_dict_hooks = OrderDict()
  self._modules = OrderDict()

3. nn.Module总结

nn.Module总结：

• 一个module可以包含多个子module
• 一个module相当于一个运算，必须实现 forward() 函数
• 每个module都有 8 个有序字典（OrderDict）管理它的属性

11. 模型容器Containers与AlexNet构建

Content

1. 模型容器(Containers)
2. AlexNet构建