03讲-神经网络-PyTorch深度学习快速入门教程

第 03 讲神经网络📝#

1.1 基本骨架#

1.1.1 Module#

torch.nn 是非常常用的包，其中 torch.container 中的 「Module」 是所有神经网络的基类

自己定义的模型需要实现「Module」的 __init__ 和 forward 函数

前向传播

此图的 F. 是下面代码块定义的 -> import torch.nn.functional as F

nn_module.py

1
import torch
2

3
from torch import nn
4

5

6

7
class Tudui(nn.Module):
8

9
    def __init__(self):
10

11
        super().__init__()  ## 习惯性添加,调用了父类 `nn.Module` 的初始化方法,及时下面过程没有使用 `nn.Module` 的高级功能
12

13

14
    def forward(self, input):  ## 当你自定义一个模型，只要继承自 `nn.Module`，就必须定义一个名为 `forward(self, …)` 的方法，用来描述模型的前向传播逻辑
15

16

17
        output = input + 1
18

19
        return output
20

21

22

23
tudui = Tudui()
24

25
x = torch.tensor([1.0])
26

27
output = tudui(x)
28

29
print(output)
30
# 输出tensor([2.])PyTorch 默认的张量打印格式，表示其值为 2.0

1.1.2 Layers#

1.1.2.1 Ⅰ 卷积层#

卷积层中最常使用 Conv2d — 因为图像为二维

卷积核的 「size」 一般是预定义好的

卷积核的 「weights」 一般是先初始化然后通过不断迭代学习而来的

以上完整输出为:

nn_conv.py

1
import torch
2

3
import torch.nn.functional as F
4

5

6

7
input =torch.tensor([[1,2,0,3,1],
8

9
                     [0,1,2,3,1],
10

11
                     [1,2,1,0,0],
12

13
                     [5,2,3,1,1],
14

15
                     [2,1,0,1,1]])
16

17

18

19
kernel = torch.tensor([[1,2,1],
20

21
                       [0,1,0],
22

23
                       [2,1,0]])
24

25

26
print(input.shape)
27

28
print(kernel.shape)
29
#以上输出torch.Size([5,5])和torch.Size([3,3]),不满足使用条件-> - reshape 是为了让数据 shape 满足 conv2d 的要求
30

31
# 01 看shape发现不满足,修改一下shape
32

33

34
input = torch.reshape(input,(1,1,5,5))
35

36
kernel = torch.reshape(kernel,(1,1,3,3))
37

38

39

40
## 02 卷积 conv2d
41

42
output = F.conv2d(input,kernel,stride=1) ## 这里的stride=1代表上下左右各移动一个像素(去扫描)
43

44
print(output)
45

46

47

48
output2 = F.conv2d(input,kernel,stride=2)
49

50
print(output2)
51

52

53

54
output3 = F.conv2d(input,kernel,stride=1,padding=1)  ## padding=1代表上下左右填充1个像素
55

56
print(output3)

观察以下过程

输出 channel=2,代表有两个卷积核去扫描.并且两个卷积核数值是随机的

nn_conv2d.py

以下正式讲解卷积层的使用

1
import torch
2

3
import torchvision
4

5
from torch import nn
6

7
from torch.nn import Conv2d
8

9
from torch.utils.data import DataLoader
10

11
from torch.utils.tensorboard import SummaryWriter
12

13
from urllib3.filepost import writer
14

15

16
# 准备数据集
17
datset = torchvision.datasets.CIFAR10("data",
18

19
                                      train=False, ## 训练数据集太大了,就用测试数据集
20

21
                                      transform=torchvision.transforms.ToTensor(),
22

23
                                      download=True)
24

25

26
# 加载数据集
27
dataloader = DataLoader(datset,batch_size=64)
28

29

30
# 自定义神经网络
31
class Tudui(nn.Module):
32

33
    def __init__(self):
34

35
        super().__init__()
36

37

38
## 创建conv1,表示你的第一个卷积层，并且后续可以在`forward`方法里直接用
39
        self.conv1 = nn.Conv2d(in_channels=3,
40

41
                out_channels=6,
42

43
                               kernel_size=3, ##卷积核大小
44

45
                                    stride=1,
46

47
                  padding=0)
48

49

50
    def forward(self,x):
51

52
        x = self.conv1(x)
53

54
        return x
55

56

57
# 初始化这个网络
58

59
tudui = Tudui()
60

61
## print(tudui)
62

63

64
writer = SummaryWriter("logs")
65

66
step = 0
67

68
for data in dataloader:  ## `data` 只是一个变量名 它代表每次迭代从 `dataloader` 取出的那 1 批数据
69

70
    imgs, targets = data
71

72
    output = tudui(imgs)
73

74
    # print(imgs.shape)
75

76
    # print(output.shape)
77

78
    writer.add_images("input",imgs,step) # 输入的torch.Size([64, 3, 32, 32]) 在卷积层中运行后 会输出 [64, 6, 30, 30] 有6通道;TensorBoard add_images 只支持 1 或 3 通道图片，不支持 6 通道
79

80

81
    output = torch.reshape(output,(-1,3,30,30))
82
  ## `-1` 代表自动根据其他维度推算 batch 数量, 意思就是这个-1会经过reshape后自动计算成对应的数值.比如将以上[64, 6, 30, 30]的6压缩成两组3的话,就变成[128, 3, 30, 30]
83

84

85

86
    writer.add_images("output",output,step) # 输出的torch.Size([128, 3, 30, 30])
87

88
    step = step + 1
89

90

91

92
writer.close()

1.1.2.2 Ⅱ 池化层#

池化层中最常使用 「MaxPool2d」

其一是对卷积层所提取的信息做更一步降维， 减少计算量 ，

其二是 加强图像特征的不变性 ，使之增加图像的偏移、旋转等方面的鲁棒性

nn_maxpool.py

1
import torch
2

3
import torchvision
4

5
from torch import nn
6

7
from torch.utils.data import DataLoader
8

9
from torch.utils.tensorboard import SummaryWriter
10

11

12

13
# 01 测试最大池化的实现
14

15
# input =torch.tensor([ [1,2,0,3,1],
16

17
#                       [0,1,2,3,1],
18

19
#                       [1,2,1,0,0],
20

21
#                       [5,2,3,1,1],
22

23
#                       [2,1,0,1,1]  ],
24

25
#                      dtype=torch.float32)
26
            ## 这是因为池化操作在底层实现时，用的都是浮点计算
27

28
# input = torch.reshape(input,(-1,1,5,5))
29

30
# print(input.shape)
31
  ##输出torch.Size([1,1,5,5])
32

33
#
34

35
# class Tudui(nn.Module):
36

37
#     def __init__(self):
38

39
#         super().__init__()
40

41
#         self.maxpool1 = nn.MaxPool2d(kernel_size=3,ceil_mode=True)
42

43
#
44

45
#     def forward(self, input):
46

47
#         output = self.maxpool1(input)
48

49
#         return output
50

51
#
52

53
# tudui = Tudui()
54

55
# output = tudui(input)
56

57
# print(output)
58

59

60

61
# 02 针对数据集测试
62

63
dataset = torchvision.datasets.CIFAR10(root='./data',
64

65
                                       train=False,
66

67
                                       transform=torchvision.transforms.ToTensor(),
68

69
                                       download=True)
70

71
dataloader = DataLoader(dataset,batch_size=64)
72

73

74

75
class Tudui(nn.Module):
76

77
    def __init__(self):
78

79
        super().__init__()
80

81
        self.maxpool1 = nn.MaxPool2d(kernel_size=3,ceil_mode=False)
82

83

84

85
    def forward(self, input):
86

87
        output = self.maxpool1(input)
88

89
        return output
90

91

92

93
tudui = Tudui()
94

95

96

97
writer = SummaryWriter("logs")
98

99
step = 0
100

101
for data in dataloader:
102

103
    imgs, targets = data
104

105
    writer.add_images("input",imgs,step)
106

107

108
    output = tudui(imgs)
109

110

111

112
    writer.add_images("output",output,step)
113

114
    step = step + 1
115

116

117

118
writer.close()

1.1.2.3 Ⅲ 激活层#

激活层一般采用 「非线性激活」 ，神经网络中引入非线性的特质，才能训练出符合各种特征的模型

非线性激活函数有很多，如比较常见 「ReLU」 和 「Sigmoid」

nn_relu.py

1
import torch
2

3
import torchvision
4

5
from torch import nn
6

7
from torch.nn import ReLU
8

9
from torch.utils.data import DataLoader
10

11
from torch.utils.tensorboard import SummaryWriter
12

13

14

15
from nn_conv2d import dataloader
16

17

18

19
# # 01 测试ReLU
20

21
# input = torch.tensor([[1,-0.5],
22

23
#                        [-1,3]])
24

25

26
# output = torch.reshape(input,(-1,1,2,2))
27
  ## 输出( [[[[1, -0.5],
28
  ##            [-1, 3]]]] )
29
  ## 如果仅仅在此测试Relu中,可以不需要reshape,但在Conv2d这样的情况下就需要
30

31
# print(output.shape)
32
  ## 输出(1,1,2,2)
33

34

35

36
# class Tudui(nn.Module):
37

38
#     def __init__(self):
39

40
#         super().__init__()
41

42
#         self.relu1 = nn.ReLU()
43

44

45

46
#     def forward(self, input):
47

48
#         output = self.relu1(input)
49

50
#         return output
51

52

53

54
# tudui = Tudui()
55

56
# output = tudui(input)
57

58
# print(output)
59
  ## 输出( [[[[1.,0.],
60
  ##            [0., 3.]]]] )
61

62

63

64

65
# 02 Sigmoid
66

67
dataset = torchvision.datasets.CIFAR10(root='./data',
68

69
                                       train=False,
70

71
                                       transform=torchvision.transforms.ToTensor(),
72

73
                                       download=True)
74

75

76

77
dataloader = DataLoader(dataset,batch_size=64)
78

79

80

81
class Tudui(nn.Module):
82

83
    def __init__(self):
84

85
        super().__init__()
86

87
        self.sigmoid1 = nn.Sigmoid()
88

89

90

91
    def forward(self, input):
92

93
        output = self.sigmoid1(input)
94

95
        return output
96

97

98

99
tudui = Tudui()
100

101

102

103
writer = SummaryWriter("logs")
104

105

106

107
step = 0
108

109
for data in dataloader:
110

111
    imgs, targets = data
112

113
    writer.add_images("input",imgs,step)
114

115
    output = tudui(imgs)
116

117
    writer.add_images("output",output,step)
118

119
    step += 1
120

121

122

123
writer.close()

对于 Relu(input,inplace=True/False)

True 代表替换原来的变量

1.1.2.4 Ⅳ 其他层#

「Transformer Layers」特定的网络结构

「Sparse Layers」特定的网络结构，其中的 Embedding 用于自然语言处理

「Linear Layers」用的较多，即全连接层

nn_linear.py

1
import torch
2

3
import torchvision
4

5
from torch import nn
6

7
from torch.nn import Linear
8

9
from torch.utils.data import DataLoader
10

11

12

13
dataset = torchvision.datasets.CIFAR10("./data",
14

15
                                       train=False,
16

17
                                       transform=torchvision.transforms.ToTensor(),
18

19
                                       download=True)
20

21

22

23
dataloader = DataLoader(dataset, batch_size=64)
24

25

26

27
class Tudui(nn.Module):
28

29
    def __init__(self):
30

31
        super().__init__()
32

33
        self.linear1 = Linear(196608, 10)
34

35

36

37
    def forward(self, input):
38

39
        output = self.linear1(input)
40

41
        return output
42

43

44

45
tudui = Tudui()
46

47

48

49
for data in dataloader:
50

51
    imgs, targets = data
52

53
    print(imgs.shape) # torch.Size([64, 3, 32, 32])
54

55

56

57
    # flatten 展平成一行  类似于reshape(1,1,1,-1),但是维度不一样哦
58
  # 注意, torch.flatten和下面代码中的nn.Flatten()不一样
59
    output = torch.flatten(imgs)
60

61
    print(output.shape) # torch.Size([196608])  注意:变成一维的了
62

63

64
    output = tudui(output)
65

66
    print(output.shape)
67
    ## 输出torch.Size([10])

NOTE
注意点:
torch.flatten(imgs)，它直接把所有图片合成了一个一维向量，丢掉了 batch 信息。模型只能输出 `torch.Size([10])
nn.Flatten()，只展平单张图片，不会丢失 batch，所以每一张图片都能独立得到 10 维预测，输出就是 torch.Size([64,10])

1.1.3 Sequential#

Sequential 主要是方便代码的编写，使代码更加简洁

根据下图搭建神经网络：判断一个图的类别（最后输出为十个类别，最后进行判断）

nn_seq.py

未使用 sequential

使用 sequential 统一管理中间层

1
import torch
2

3
from torch import nn
4

5
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
6

7
from torch.utils.tensorboard import SummaryWriter
8

9

10

11
class Tudui(nn.Module):
12

13
    def __init__(self):
14

15
        super(Tudui, self).__init__()
16

17
        self.model1 = Sequential(
18

19
            Conv2d(3, 32, 5, padding=2),##对照以上那个图
20

21
            MaxPool2d(2),  ##池化
22

23
            Conv2d(32, 32, 5, padding=2),
24

25
            MaxPool2d(2),
26

27
            Conv2d(32, 64, 5, padding=2),
28

29
            MaxPool2d(2),
30

31
            Flatten(),  ## 展平成一维
32

33
            Linear(1024, 64),
34

35
            Linear(64, 10)
36

37
        )
38

39

40

41
    def forward(self, x):
42

43
        x = self.model1(x)
44

45
        return x
46

47

48

49
tudui = Tudui()
50

51
print(tudui)
52

53

54

55
# 检查网络
56

57
input = torch.ones((64, 3, 32, 32))
58

59
output = tudui(input)
60

61
print(output.shape)  ## 输出 torch.Size([64,10])
62

63

64
# tensorboard中的add_graph 查看神经网络的流程图
65

66
writer = SummaryWriter("logs")
67

68
writer.add_graph(tudui, input)
69

70
writer.close()

1.2 损失&优化#

1.2.1 损失函数#

损失函数（Loss Function）用于衡量模型的「预测输出」与「实际标签」之间的差异或者误差

损失越小越好，根据 loss 调整参数，以减小损失

1
# 计算output和target之差的「绝对值」
2

3
nn.L1Loss()
4

5
# 计算output和target之差的「均方差」
6

7
nn.MSELoss()

1
# 交叉熵损失函数（Cross-Entropy Loss Function）是在分类问题中经常使用的一种损失函数
2

3
# 当分类预测正确时，损失要比较小，即\`-x[class]\`相比右边的项应较大
4

5
nn.CrossEntropyLoss()

nn_loss.py

1
import torch
2

3
from torch.nn import L1Loss
4

5
from torch import nn
6

7

8

9
inputs = torch.tensor([1, 2, 3], dtype=torch.float32)
10

11
targets = torch.tensor([1, 2, 5], dtype=torch.float32)
12

13

14

15
inputs = torch.reshape(inputs, (1, 1, 1, 3))
16

17
targets = torch.reshape(targets, (1, 1, 1, 3))
18

19

20

21
# 01 L1Loss
22

23
loss = L1Loss(reduction='sum') # mean or sum  选择计算方式
24

25
result = loss(inputs, targets)
26

27
print(result)
28

29

30

31
# 02 MSELoss
32

33
loss_mse = nn.MSELoss()
34

35
result_mse = loss_mse(inputs, targets)
36

37
print(result_mse)
38

39

40

41
# 03 CrossEntropyLoss
42

43
x = torch.tensor([0.1, 0.2, 0.3])
44

45
y = torch.tensor([1])
46

47
x = torch.reshape(x, (1, 3))
48
##`CrossEntropyLoss` 期望 x 的形状是 (1, 3)（一个样本，三个类别），y 的形状是 (1,)
49
## 必须将 x 的形状由 (3,) 变为 (1, 3)
50

51
loss_cross = nn.CrossEntropyLoss()
52

53
result_cross = loss_cross(x, y)
54

55
print(result_cross)

1.2.2 反向传播#

前向传播：将训练集数据输入到 NN 的「输入层」，经过「隐藏层」，最后到达「输出层」并输出结果

反向传播：计算估计值与实际值之间的误差，并将误差从「输出层」向「隐藏层」反向传播，直至「输入层」

nn_loss_network.py

1
import torchvision
2

3
from torch import nn
4

5
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
6

7
from torch.utils.data import DataLoader
8

9

10

11
dataset = torchvision.datasets.CIFAR10("./data",
12

13
                                       train=False,
14

15
                                       transform=torchvision.transforms.ToTensor(),
16

17
                                       download=True)
18

19

20

21
dataloader = DataLoader(dataset, batch_size=1)
22

23

24

25
class Tudui(nn.Module):
26

27
    def __init__(self):
28

29
        super(Tudui, self).__init__()
30

31
        self.model1 = Sequential(
32

33
            Conv2d(3, 32, 5, padding=2),
34

35
            MaxPool2d(2),
36

37
            Conv2d(32, 32, 5, padding=2),
38

39
            MaxPool2d(2),
40

41
            Conv2d(32, 64, 5, padding=2),
42

43
            MaxPool2d(2),
44

45
            Flatten(),
46

47
            Linear(1024, 64),
48

49
            Linear(64, 10)
50

51
        )
52

53

54

55
    def forward(self, x):
56

57
        x = self.model1(x)
58

59
        return x
60

61

62

63
loss = nn.CrossEntropyLoss()
64

65
tudui = Tudui()
66

67
for data in dataloader:
68

69
    imgs, targets = data
70

71
    outputs = tudui(imgs)
72

73
    result_loss = loss(outputs, targets)
74

75
    # 反向传播 计算梯度
76

77
    result_loss.backward()
78

79
    print("ok")

1.2.3 优化器#

更新参数减少损失

反向传播（backward）–> 计算出梯度（grad）–> 根据梯度和学习率更新参数 –> 减小 loss

优化器的种类比较多，常用的就是 SGD（随机梯度下降）

不同优化器的参数列表不同，一般设置「parameters」和 l「lr」这两个参数，其他默认

nn_optim.py

1
import torch
2

3
import torchvision
4

5
from torch import nn
6

7
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
8

9
from torch.optim.lr_scheduler import StepLR
10

11
from torch.utils.data import DataLoader
12

13

14

15
dataset = torchvision.datasets.CIFAR10("./data",
16

17
                                       train=False,
18

19
                                       transform=torchvision.transforms.ToTensor(),
20

21
                                       download=True)
22

23

24

25
dataloader = DataLoader(dataset, batch_size=1)
26

27

28

29
class Tudui(nn.Module):
30

31
    def __init__(self):
32

33
        super(Tudui, self).__init__()
34

35
        self.model1 = Sequential(
36

37
            Conv2d(3, 32, 5, padding=2),
38

39
            MaxPool2d(2),
40

41
            Conv2d(32, 32, 5, padding=2),
42

43
            MaxPool2d(2),
44

45
            Conv2d(32, 64, 5, padding=2),
46

47
            MaxPool2d(2),
48

49
            Flatten(),
50

51
            Linear(1024, 64),
52

53
            Linear(64, 10)
54

55
        )
56

57

58

59
    def forward(self, x):
60

61
        x = self.model1(x)
62

63
        return x
64

65

66

67
loss = nn.CrossEntropyLoss()
68

69
tudui = Tudui()
70

71

72

73
# 优化器 SGD（随机梯度下降）
74

75
optim = torch.optim.SGD(tudui.parameters(), lr=0.01) ## lr学习率，太大不稳定，太小收敛慢
76
##tudui.parameters() 的作用：这个方法会自动遍历 `Tudui` 网络中所有子模块（比如 `Conv2d` 和 `Linear` 层），收集这些层的所有可训练参数，返回到torch.optim.SGD
77

78

79
for epoch in range(20):  ## 进行多轮学习
80

81
    running_loss = 0.0
82

83
    for data in dataloader:
84

85
        imgs, targets = data
86

87
        outputs = tudui(imgs)
88

89
        result_loss = loss(outputs, targets)
90

91

92

93
        optim.zero_grad() # 把上一步的梯度清零，否则会累加
94

95
        result_loss.backward()
96

97
        optim.step() # 对weight参数进行更新
98

99

100

101
        running_loss = running_loss + result_loss
102

103
    print(running_loss)

第 03 讲 神经网络📝#

1.1 基本骨架#

1.1.1 Module#

1.1.2 Layers#

1.1.2.1 Ⅰ 卷积层#

1.1.2.2 Ⅱ 池化层#

1.1.2.3 Ⅲ 激活层#

1.1.2.4 Ⅳ 其他层#

1.1.3 Sequential#

1.2 损失&优化#

1.2.1 损失函数#

1.2.2 反向传播#

1.2.3 优化器#

第 03 讲神经网络📝#