深度学习-快速了解整个流程-基于Pytorch实现MNIST数据集分类任务

导包#

不得不提， PyTorch 是目前深度学习领域非常火的框架之一。今天我以 MNIST 数据集分类 为任务，为大家演示 PyTorch 的基本使用；并且，文末为大家提 供粘贴可运行 的代码。 如有错误，还请指正。 在开始之前，首先需要介绍 PyTorch 在计算机视觉领域中最重要的两个包： torch 与 torchvision：

torch 是 PyTorch 的核心库，提供了张量计算、自动微分等功能。

torchvision 是 PyTorch 的一个独立子库，主要用于计算机视觉任务，包括图像处理、数据加载、数据增强、预训练模型等。

1
import torch #  pytorch 1.13.0+ 版本
2

3
from torch import nn, optim # 包含神经网络模块和优化器模块
4
from torch.utils.data import DataLoader # DataLoader是PyTorch中用于加载数据的工具，可以自动处理批次、打乱数据等
5

6

7

8
import torchvision # torchvision是PyTorch的一个子库，包含了常用的数据集、模型和图像处理工具
9

10
from torchvision import datasets, transforms, models # datasets包含了常用的数据集，transforms包含了图像处理的变换函数，models包含了预训练模型和常用的网络结构

目前来看，采用深度学习解决任何一个任务往往都需要这几个步骤：定义模型、训练模型、测试模型。

一、模型定义#

针对 MNIST 数据集的分类任务，可采用经典的 AlexNet 模型，并使用 PyTorch 带有的预训练模型参数，初始化模型。

AlexNet 原始模型架构

1
AlexNet(
2
  (features): Sequential(
3
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
4
    (1): ReLU(inplace=True)
5
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
6
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
7
    (4): ReLU(inplace=True)
8
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
9
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
10
    (7): ReLU(inplace=True)
11
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
12
    (9): ReLU(inplace=True)
13
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
14
    (11): ReLU(inplace=True)
15
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
16
  )
17
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
18
  (classifier): Sequential(
19
    (0): Dropout(p=0.5, inplace=False)
20
    (1): Linear(in_features=9216, out_features=4096, bias=True)
21
    (2): ReLU(inplace=True)
22
    (3): Dropout(p=0.5, inplace=False)
23
    (4): Linear(in_features=4096, out_features=4096, bias=True)
24
    (5): ReLU(inplace=True)
25
    (6): Linear(in_features=4096, out_features=1000, bias=True)
26
  )
27
)

自定义神经网络模型

1
# 自定义神经网络模型类，继承自torch.nn.Module
2

3
class MyAlexNet(nn.Module):
4

5
    def __init__(self, class_num):
6

7
        super().__init__()
8

9
        # 使用torchvision 0.13+ 推荐方式加载预训练模型权重，不再用 pretrained=True
10

11
        weights = models.AlexNet_Weights.DEFAULT
12

13
        self.net = models.alexnet(weights=weights)
14

15
        # 修改AlexNet模型的分类器，调整输出类别数
16

17
        # 这里AlexNet最后Flatten后的特征维度是256*6*6
18

19
        self.net.classifier = nn.Sequential(
20

21
            nn.Dropout(p=0.5),
22

23
            nn.Linear(256 * 6 * 6, 4096),
24

25
            nn.ReLU(inplace=True),
26

27
            nn.Dropout(p=0.5),
28

29
            nn.Linear(4096, 4096),
30

31
            nn.ReLU(inplace=True),
32

33
            nn.Linear(4096, class_num),
34

35
        )
36

37

38
# 定义模型的前向传播函数
39
    def forward(self, inputs):
40

41
        return self.net(inputs)

改完后的 AlexNet 模型结构 (示例: 要得到 10 分类的 AlexNet 模型对象)

alexnet = MyAlexNet(class_num=10) # 10 类分类任务

print(alexnet)

1
MyAlexNet(
2
  (net): AlexNet(
3
    (features): Sequential(
4
      (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
5
      (1): ReLU(inplace=True)
6
      (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
7
      (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
8
      (4): ReLU(inplace=True)
9
      (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
10
      (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
11
      (7): ReLU(inplace=True)
12
      (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
13
      (9): ReLU(inplace=True)
14
      (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
15
      (11): ReLU(inplace=True)
16
      (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
17
    )
18
    (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
19

20
## 以下发生了修改
21

22
    (classifier): Sequential(
23
      (0): Dropout(p=0.5, inplace=False)
24
      (1): Linear(in_features=9216, out_features=4096, bias=True)
25
      (2): ReLU(inplace=True)
26
      (3): Dropout(p=0.5, inplace=False)
27
      (4): Linear(in_features=4096, out_features=4096, bias=True)
28
      (5): ReLU(inplace=True)
29
      (6): Linear(in_features=4096, out_features=10, bias=True)
30
    )
31
  )
32
)

二、定义训练函数#

数据增强&数据集&数据加载器#

数据增强，即 transform，一方面用于增加训练的数据量，提高模型的泛化能力，提升模型的鲁棒性；另一方面用于对样本进行处理，使其符合模型的输入。

1
transform = transforms.Compose([
2

3
        transforms.Resize((96, 96)),
4

5
        transforms.Grayscale(num_output_channels=3),
6

7
        transforms.ToTensor(),
8

9
        transforms.Normalize((0.2, 0.2, 0.2), (0.3, 0.3, 0.3))
10

11
    ])

数据集，即 dataset，主要分为训练集与测试集。PyTorch 自带有 MNIST 数据集；该数据集是一个手写体数字的图片数据集，该图片为 28×2828×2828×2828×28 单通道黑白图片，训练集一共包含了 60,000 张样本，测试集一共包含了 10,000 张样本。

1
train_set = datasets.MNIST(root='./dataset', train=True, download=True, transform=transform)
2

3
test_set = datasets.MNIST(root='./dataset', train=False, download=True, transform=transform)

数据加载器，即 data loader，是 PyTorch 为了方便模型训练与数据集加载提供的工具类；data loader 会将数据集中样本根据 batch_size 分割成一个一个的 mini-batch，方便后序的训练与测试过程（目前的训练与测试采用的大都是 mini-batch 的方式）。

1
train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True) # shuffle=True表示每个epoch开始时打乱数据顺序
2

3
test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False) # shuffle=False表示测试集不需要打乱顺序

loss 损失函数#

分类任务，毫无疑问，使用交叉熵损失函数 。根据模型的输出与正确结果，计算损失，同时可以根据自动微分功能，实现由 loss 函数而始的梯度反向传播。不得不说，通常说的模型，往往指的是参数模型，并不包含梯度；反向传播，传播的是模型的梯度.

1
criterion = nn.CrossEntropyLoss() # 使用交叉熵损失函数，适用于多分类问题

优化器及学习率#

优化器，即 optimizer，实现模型参数的更新。主要利用反向传播而来的梯度，以及采用梯度下降的方式，实现参数的更新： θn=θn−1−g∗lrθn = θn−1−g∗lr .其中 θn−1 代指模型当前参数； g 代指参数的梯度； lr 代指学习率，往往与学模型学习过程快慢有关； θn 代指优化器进行参数更新后的模型参数。

1
# 使用AdamW优化器，学习率设置为1e-4(lr=0.0001)
2
optimizer = optim.AdamW(model.parameters(), lr=1e-4)

定义训练函数#

训练 (有监督训练) 是指将训练集输入到算法模型中，根据模型输出与正确标签计算损失，并通过反向传播与梯度下降的方式，对模型参数不断优化，使模型能够识别、分析和预测各种情况。注：最终得到的是模型的参数。

1
# 训练模型函数
2
# Parameters(参数介绍):
3

4
# - data_loader: DataLoader对象，提供训练数据
5

6
# - model: nn.Module对象，待训练的模型
7

8
# - optimizer: 优化器对象，用于更新模型参数
9

10
# - criterion: 损失函数对象，用于计算损失
11

12
# - device: torch.device对象，指定计算设备（CPU或GPU）
13

14
# - epoch: 当前训练的轮次
15

16
# - print_freq: 打印频率，用于控制日志输出
17

18
# Returns:
19

20
# - total_loss: 平均损失值
21

22
# - total_acc: 平均准确率
23

24

25

26
def train_model(data_loader: DataLoader, model: nn.Module, optimizer: optim.Optimizer, criterion: nn.Module, device: torch.device, epoch: int, print_freq: int):
27

28
    model.train() # 设置模型为训练模式
29

30
    model.to(device) # 将模型移动到指定设备
31

32
    total_loss, total_acc = 0., 0. # 初始化总损失和总准确率
33

34
    batch_num = len(data_loader) # 获取批次数量
35

36

37

38
    for idx, (img, target) in enumerate(data_loader, 1): # 遍历数据加载器 / enumerate(data_loader, 1) 从1开始计数到DataLoader的长度
39

40
        img, target = img.to(device), target.to(device)# 为了使用GPU加速，必须将数据和模型都放到同一设备上
41

42
        optimizer.zero_grad() #PyTorch默认梯度是累积的，所以每次训练前需要手动清零
43

44
        outputs = model(img) # 使用前面定义的模型 前向传播，计算模型输出
45

46
        loss = criterion(outputs, target)
47

48
        loss.backward()
49

50
        optimizer.step() # 反向传播，计算梯度并更新模型参数
51

52
        pred = outputs.argmax(dim=1) # 找到预测输出中概率（或分数）最大的类别索引  / dim=1 指按行找最大值索引，即对每个样本找到最高得分类别。
53

54
        acc = pred.eq(target).float().mean() # 计算准确率，pred.eq(target)返回一个布尔张量，表示预测是否正确，然后转换为浮点数并求平均值
55

56
        total_loss += loss.item() # item()将张量转换为Python数值
57

58
        total_acc += acc.item()
59

60
        if idx % print_freq == 0 or idx == batch_num: # 累计当前批次的损失和准确率数值，方便后面计算整个epoch的平均
61

62
            print(f"Epoch:{epoch:03d} Batch:[{idx}/{batch_num}] Loss:{loss.item():f} Acc:{acc.item():f}") # 解释 f-string格式化输出当前批次的损失和准确率 # epoch:03d表示epoch是3位数，不足补0，Batch:[{idx}/{batch_num}]表示当前批次和总批次数，Loss:{loss.item():f}表示损失值保留4位小数，Acc:{acc.item():f}表示准确率保留4位小数
63

64
            # 示例 Epoch:001 Batch:[16/118] Loss:0.2009 Acc:0.9531
65

66
    return total_loss / batch_num, total_acc / batch_num

定义模型函数#

在模型训练过程中或者训练结束后，需要使用测试集对模型进行测试；并根据模型在测试集上的推理准确率，评判模型的优劣。

1
# 测试模型函数
2
# Parameters(参数介绍):
3

4
# - data_loader: DataLoader对象，提供测试数据
5

6
# - model: nn.Module对象，待测试的模型
7

8
# - criterion: 损失函数对象，用于计算损失
9

10
# - device: torch.device对象，指定计算设备（CPU或GPU）
11

12
# Returns:
13

14
# - total_loss: 平均损失值
15

16
# - total_acc: 平均准确率
17

18
def test_model(data_loader: DataLoader, model: nn.Module, criterion: nn.Module, device: torch.device):
19

20
    model.eval()
21

22
    model.to(device) #这里的model是训练过的模型，eval()方法将模型设置为评估模式，这会影响某些层（如Dropout和BatchNorm）的行为，使其在测试时表现得更稳定。
23

24
    total_loss, total_acc = 0., 0.
25

26
    batch_num = len(data_loader)
27

28

29

30
    with torch.no_grad(): # 在测试时不需要计算梯度，使用torch.no_grad()可以节省内存和计算资源
31

32
        for idx, (img, target) in enumerate(data_loader, 1):
33

34
            img, target = img.to(device), target.to(device)
35

36
            outputs = model(img)
37

38
            loss = criterion(outputs, target)
39

40
            pred = outputs.argmax(dim=1)
41

42
            acc = pred.eq(target).float().mean()
43

44
            total_loss += loss.item()
45

46
            total_acc += acc.item()
47

48
    return total_loss / batch_num, total_acc / batch_num

完整代码 (包含定义函数与主函数)#

针对以上定义,总结逻辑代码,在 pytorch 环境下粘贴运行

1
import torch #  pytorch 1.13.0+ 版本
2

3
from torch import nn, optim # 包含神经网络模块和优化器模块
4

5
from torch.utils.data import DataLoader # DataLoader是PyTorch中用于加载数据的工具，可以自动处理批次、打乱数据等
6

7

8

9
import torchvision # torchvision是PyTorch的一个子库，包含了常用的数据集、模型和图像处理工具
10

11
from torchvision import datasets, transforms, models # datasets包含了常用的数据集，transforms包含了图像处理的变换函数，models包含了预训练模型和常用的网络结构
12

13

14

15
# 自定义神经网络模型类，继承自torch.nn.Module
16

17
class MyAlexNet(nn.Module):
18

19
    def __init__(self, class_num):
20

21
        super().__init__()
22

23
        # 使用torchvision 0.13+ 推荐方式加载预训练模型权重，不再用 pretrained=True
24

25
        weights = models.AlexNet_Weights.DEFAULT
26

27
        self.net = models.alexnet(weights=weights)
28

29
        # 修改AlexNet模型的分类器，调整输出类别数
30

31
        # 这里AlexNet最后Flatten后的特征维度是256*6*6
32

33
        self.net.classifier = nn.Sequential(
34

35
            nn.Dropout(p=0.5),
36

37
            nn.Linear(256 * 6 * 6, 4096),
38

39
            nn.ReLU(inplace=True),
40

41
            nn.Dropout(p=0.5),
42

43
            nn.Linear(4096, 4096),
44

45
            nn.ReLU(inplace=True),
46

47
            nn.Linear(4096, class_num),
48

49
        )
50

51

52

53
    def forward(self, inputs):
54

55
        return self.net(inputs)
56

57

58

59
# 定义训练和测试函数
60

61

62

63

64
# 训练模型函数
65

66

67

68
# Parameters:
69

70
# - data_loader: DataLoader对象，提供训练数据
71

72
# - model: nn.Module对象，待训练的模型
73

74
# - optimizer: 优化器对象，用于更新模型参数
75

76
# - criterion: 损失函数对象，用于计算损失
77

78
# - device: torch.device对象，指定计算设备（CPU或GPU）
79

80
# - epoch: 当前训练的轮次
81

82
# - print_freq: 打印频率，用于控制日志输出
83

84
# Returns:
85

86
# - total_loss: 平均损失值
87

88
# - total_acc: 平均准确率
89

90

91

92
def train_model(data_loader: DataLoader, model: nn.Module, optimizer: optim.Optimizer, criterion: nn.Module, device: torch.device, epoch: int, print_freq: int):
93

94
    model.train() # 设置模型为训练模式
95

96
    model.to(device) # 将模型移动到指定设备
97

98
    total_loss, total_acc = 0., 0. # 初始化总损失和总准确率
99

100
    batch_num = len(data_loader) # 获取批次数量
101

102

103

104
    for idx, (img, target) in enumerate(data_loader, 1): # 遍历数据加载器 / enumerate(data_loader, 1) 从1开始计数到DataLoader的长度
105

106
        img, target = img.to(device), target.to(device)# 为了使用GPU加速，必须将数据和模型都放到同一设备上
107

108
        optimizer.zero_grad() #PyTorch默认梯度是累积的，所以每次训练前需要手动清零
109

110
        outputs = model(img) # 使用前面定义的模型 前向传播，计算模型输出
111

112
        loss = criterion(outputs, target)
113

114
        loss.backward()
115

116
        optimizer.step() # 反向传播，计算梯度并更新模型参数
117

118
        pred = outputs.argmax(dim=1) # 找到预测输出中概率（或分数）最大的类别索引  / dim=1 指按行找最大值索引，即对每个样本找到最高得分类别。
119

120
        acc = pred.eq(target).float().mean() # 计算准确率，pred.eq(target)返回一个布尔张量，表示预测是否正确，然后转换为浮点数并求平均值
121

122
        total_loss += loss.item() # item()将张量转换为Python数值
123

124
        total_acc += acc.item()
125

126
        if idx % print_freq == 0 or idx == batch_num: # 累计当前批次的损失和准确率数值，方便后面计算整个epoch的平均
127

128
            print(f"Epoch:{epoch:03d} Batch:[{idx}/{batch_num}] Loss:{loss.item():f} Acc:{acc.item():f}") # 解释 f-string格式化输出当前批次的损失和准确率 # epoch:03d表示epoch是3位数，不足补0，Batch:[{idx}/{batch_num}]表示当前批次和总批次数，Loss:{loss.item():f}表示损失值保留4位小数，Acc:{acc.item():f}表示准确率保留4位小数
129

130
            # 示例 Epoch:001 Batch:[16/118] Loss:0.2009 Acc:0.9531
131

132
    return total_loss / batch_num, total_acc / batch_num
133

134

135

136

137
# 测试模型函数
138

139

140

141
# Parameters:
142

143
# - data_loader: DataLoader对象，提供测试数据
144

145
# - model: nn.Module对象，待测试的模型
146

147
# - criterion: 损失函数对象，用于计算损失
148

149
# - device: torch.device对象，指定计算设备（CPU或GPU）
150

151
# Returns:
152

153
# - total_loss: 平均损失值
154

155
# - total_acc: 平均准确率
156

157
def test_model(data_loader: DataLoader, model: nn.Module, criterion: nn.Module, device: torch.device):
158

159
    model.eval()
160

161
    model.to(device) #这里的model是训练过的模型，eval()方法将模型设置为评估模式，这会影响某些层（如Dropout和BatchNorm）的行为，使其在测试时表现得更稳定。
162

163
    total_loss, total_acc = 0., 0.
164

165
    batch_num = len(data_loader)
166

167

168

169
    with torch.no_grad(): # 在测试时不需要计算梯度，使用torch.no_grad()可以节省内存和计算资源
170

171
        for idx, (img, target) in enumerate(data_loader, 1):
172

173
            img, target = img.to(device), target.to(device)
174

175
            outputs = model(img)
176

177
            loss = criterion(outputs, target)
178

179
            pred = outputs.argmax(dim=1)
180

181
            acc = pred.eq(target).float().mean()
182

183
            total_loss += loss.item()
184

185
            total_acc += acc.item()
186

187
    return total_loss / batch_num, total_acc / batch_num
188

189

190

191

192

193
# 为了组织代码逻辑，通常会将主要执行流程放在一个main函数中，这样可以更清晰地看到程序的结构和执行顺序。
194

195
def main():
196

197

198

199
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 设置设备，优先使用GPU
200

201
    print(f"Using device: {device}")
202

203

204

205
    # 定义数据变换 在这为了符合AlexNet的输入要求，将MNIST数据集的图像大小调整为96x96，并转换为3通道（RGB）图像。
206

207
    # MNIST数据集原始图像是28x28的灰度图像
208

209
    # AlexNet要求输入图像为3通道（RGB），所以需要将灰度图像转换为3通道。
210

211
    # 另外，AlexNet通常使用较大的输入图像尺寸（如224x224），但这里为了适应MNIST数据集的特性，使用96x96作为输入尺寸。
212

213
    # 归一化参数根据AlexNet的预训练权重进行设置，通常使用均值(0.2, 0.2, 0.2)和标准差(0.3, 0.3, 0.3)进行归一化处理。
214

215
    transform = transforms.Compose([
216

217
        transforms.Resize((96, 96)),
218

219
        transforms.Grayscale(num_output_channels=3),
220

221
        transforms.ToTensor(),
222

223
        transforms.Normalize((0.2, 0.2, 0.2), (0.3, 0.3, 0.3))
224

225
    ])
226

227

228

229
    # 下载与加载数据集
230

231
    train_set = datasets.MNIST(root='./dataset', train=True, download=True, transform=transform)
232

233
    test_set = datasets.MNIST(root='./dataset', train=False, download=True, transform=transform)
234

235

236

237
    batch_size = 512 # 设置批次大小 ，总批次就是数据集大小除以批次大小=此处为60000/512=117.1875，向上取整为118个批次
238

239
    train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True) # shuffle=True表示每个epoch开始时打乱数据顺序
240

241
    test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False) # shuffle=False表示测试集不需要打乱顺序
242

243

244

245
    # 实例化模型，定义损失函数和优化器
246

247
    class_num = 10
248

249
    model = MyAlexNet(class_num)
250

251
    criterion = nn.CrossEntropyLoss() # 使用交叉熵损失函数，适用于多分类问题
252

253
    optimizer = optim.AdamW(model.parameters(), lr=1e-4) # 使用AdamW优化器，学习率设置为1e-4
254

255

256

257
    # 学习率调度器，30个epoch学习率乘以0.1 是为了在训练过程中逐渐降低学习率，以便模型在训练后期能够更精细地调整参数。
258

259
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
260

261

262

263
    epoch_num = 5
264

265
    print_freq = 16 # 打印频率，控制日志输出的频率 / 每16个批次打印一次训练日志
266

267

268

269
    # 训练和测试 循环
270

271
    best_acc = 0.0
272

273
    for epoch in range(1, epoch_num + 1): # 训练5个epoch
274

275

276

277
        train_loss, train_acc = train_model(train_loader, model, optimizer, criterion, device, epoch, print_freq)
278

279
            #期间输出Epoch:001 Batch:[16/118] Loss:0.2009 Acc:0.9531 …
280

281

282

283
        test_loss, test_acc = test_model(test_loader, model, criterion, device)
284

285

286

287
        print(f"Epoch {epoch} Summary: Train Loss={train_loss:f}, Train Acc={train_acc:f} | Test Loss={test_loss:f}, Test Acc={test_acc:f}")
288

289
            #示例 Epoch 5 Summary: Train Loss=0.0118, Train Acc=0.9962 | Test Loss=0.0281, Test Acc=0.9930
290

291

292

293
        scheduler.step() # 更新学习率 / step()方法会根据预设的调度策略更新优化器的学习率。
294

295

296

297
        # 早停示意（可按需启用）/ 在训练过程中监控验证集的性能，如果连续若干个epoch验证集性能没有提升，则提前停止训练以避免过拟合。
298

299
        # if test_acc > best_acc:
300

301
        #     best_acc = test_acc
302

303
        #     torch.save(model.state_dict(), "best_model.pth")
304

305
        # else:
306

307
        #     print("Early stopping triggered.")
308

309
        #     break
310

311

312

313
    # 保存最终训练好的模型参数
314

315
    torch.save(model.state_dict(), "alexnet_weight.pth")
316

317
    print("模型参数已保存到 alexnet_weight.pth")
318

319

320

321

322
if __name__ == "__main__": # 在Python中，if __name__ == "__main__": 是一个常见的结构，用于判断当前脚本是否是直接运行的，而不是被导入到其他脚本中。
323

324

325

326
    main()
327

328
    # 如果当前脚本是直接运行的，则执行main函数
329

330
    # 这样可以避免在导入时执行不必要的代码，保持代码的模块化和可重用性。
331

332
    # 这种结构使得脚本既可以作为独立程序运行，也可以作为模块被其他脚本导入而不执行main函数中的代码。
333

334
    # 例如：python testmodel.py
335

336
    # 直接运行时会执行main函数，加载数据集，训练模型等；
337

338
    # 如果在其他脚本中导入这个模块，则不会执行main函数中的代码
339

340
    # 这样可以避免在导入时执行不必要的代码，保持代码的模块化和可重用性。
341

342
    # 例如：from testmodel import MyAlexNet
343

344
    # 导入时不会执行main函数中的代码，只会导入MyAlexNet类
345

346
    # 这样可以避免在导入时执行不必要的代码，保持代码的模块化和可重用性。

输出结果参考#

1
Using device: cuda
2
Epoch:001 Batch:[16/118] Loss:0.2009 Acc:0.9531
3
Epoch:001 Batch:[32/118] Loss:0.1344 Acc:0.9629
4
Epoch:001 Batch:[48/118] Loss:0.0443 Acc:0.9844
5
Epoch:001 Batch:[64/118] Loss:0.0312 Acc:0.9902
6
Epoch:001 Batch:[80/118] Loss:0.0400 Acc:0.9883
7
Epoch:001 Batch:[96/118] Loss:0.0484 Acc:0.9844
8
Epoch:001 Batch:[112/118] Loss:0.0440 Acc:0.9844
9
Epoch:001 Batch:[118/118] Loss:0.0805 Acc:0.9792
10
Epoch 1 Summary: Train Loss=0.1539, Train Acc=0.9518 | Test Loss=0.0317, Test Acc=0.9901
11
Epoch:002 Batch:[16/118] Loss:0.0433 Acc:0.9941
12
Epoch:002 Batch:[32/118] Loss:0.0418 Acc:0.9883
13
Epoch:002 Batch:[48/118] Loss:0.0536 Acc:0.9863
14
Epoch:002 Batch:[64/118] Loss:0.0260 Acc:0.9902
15
Epoch:002 Batch:[80/118] Loss:0.0493 Acc:0.9883
16
Epoch:002 Batch:[96/118] Loss:0.0181 Acc:0.9922
17
Epoch:002 Batch:[112/118] Loss:0.0154 Acc:0.9941
18
Epoch:002 Batch:[118/118] Loss:0.0007 Acc:1.0000
19
Epoch 2 Summary: Train Loss=0.0309, Train Acc=0.9904 | Test Loss=0.0303, Test Acc=0.9908
20
Epoch:003 Batch:[16/118] Loss:0.0236 Acc:0.9902
21
Epoch:003 Batch:[32/118] Loss:0.0037 Acc:1.0000
22
Epoch:003 Batch:[48/118] Loss:0.0156 Acc:0.9961
23
Epoch:003 Batch:[64/118] Loss:0.0355 Acc:0.9922
24
Epoch:003 Batch:[80/118] Loss:0.0103 Acc:0.9961
25
Epoch:003 Batch:[96/118] Loss:0.0101 Acc:0.9941
26
Epoch:003 Batch:[112/118] Loss:0.0115 Acc:0.9980
27
Epoch:003 Batch:[118/118] Loss:0.0718 Acc:0.9792
28
Epoch 3 Summary: Train Loss=0.0205, Train Acc=0.9935 | Test Loss=0.0318, Test Acc=0.9902
29
Epoch:004 Batch:[16/118] Loss:0.0140 Acc:0.9922
30
Epoch:004 Batch:[32/118] Loss:0.0177 Acc:0.9941
31
Epoch:004 Batch:[48/118] Loss:0.0142 Acc:0.9941
32
Epoch:004 Batch:[64/118] Loss:0.0179 Acc:0.9922
33
Epoch:004 Batch:[80/118] Loss:0.0100 Acc:0.9961
34
Epoch:004 Batch:[96/118] Loss:0.0267 Acc:0.9883
35
Epoch:004 Batch:[112/118] Loss:0.0163 Acc:0.9922
36
Epoch:004 Batch:[118/118] Loss:0.0180 Acc:0.9896
37
Epoch 4 Summary: Train Loss=0.0149, Train Acc=0.9953 | Test Loss=0.0360, Test Acc=0.9910
38
Epoch:005 Batch:[16/118] Loss:0.0023 Acc:1.0000
39
Epoch:005 Batch:[32/118] Loss:0.0043 Acc:1.0000
40
Epoch:005 Batch:[48/118] Loss:0.0191 Acc:0.9961
41
Epoch:005 Batch:[64/118] Loss:0.0038 Acc:1.0000
42
Epoch:005 Batch:[80/118] Loss:0.0413 Acc:0.9922
43
Epoch:005 Batch:[96/118] Loss:0.0060 Acc:0.9980
44
Epoch:005 Batch:[112/118] Loss:0.0103 Acc:0.9980
45
Epoch:005 Batch:[118/118] Loss:0.0555 Acc:0.9792
46
Epoch 5 Summary: Train Loss=0.0118, Train Acc=0.9962 | Test Loss=0.0281, Test Acc=0.9930
47
模型参数已保存到 alexnet_weight.pth