深度学习实验十三 卷积神经网络（4）——使用预练习resnet18实现CIFAR-10分 ...

目次
一、数据加载
二、数据集类构建
三、模型构建
四、模型练习
五、模型评价及猜测
附完整可运行代码：
实验大要步调：

注：
在自己电脑的CPU跑代码×
毗连长途服务器跑代码√
本次实验由于数据量巨大，我的笔记本上还没有GPU，跑代码不停跑不出来，不停停在如下这个位置不动：

于是我想到了毗连长途服务器来跑代码。
 如果你的电脑上有GPU，那么可以参考学长的博客跑：学长本次实验的博客
我这里使用的是AutoDL算力云，租个3080的服务器，跑个七八分钟就能出来，而且租一小时才1块多！安利！
我在这里也附上怎样使用长途服务器的方法
进入AutoDL官网后，点击算力市场：

任意租个就可以

基础镜像这边选个Pytorch的某个版本就行
接下来就跟着这个视频做吧：Pycharm毗连长途GPU服务器跑深度学习_哔哩哔哩_bilibili
有几点需要留意的地方：
1.pycharm必须是专业版，社区版没有毗连长途服务器的功能。pycharm专业版参考这个链接：​​​​​​​Pycharm专业版​​​​​​​
2.毗连成功之后，可能会遇到一些安装包安装不上的标题，比如我在import torch的这里不停报错，体现安装错误，多安装几次就好了，安装的时间尽量不要连hbu的校园网，不是很稳定，容易下载出错。
3.在自己笔记本就能运行，也没有报错，为什么毗连个长途服务器会出现size不匹配的错误？还有numpy也会出错？

第一个标题，这个错误是因为模型中的输入和权重在不同的装备上进行计算，导致了范例不匹配。我的模型使用了GPU（torch.cuda.FloatTensor），而输入数据却是CPU上的张量（torch.FloatTensor）。PyTorch要求输入和模型的权重在雷同的装备上，才能进行有用的计算。以是，需要时时候刻确保输入数据和模型在同一个装备上。
于是要多处添加如下的代码：

第二个标题，出现在 nndl_3.py 文件中的 self.metric.update(logits, y) 这一行，具体是因为实验将一个在 GPU 上的 tensor 转换为 NumPy 数组。由于 NumPy 不支持在 GPU 上的 tensor，以是必须先将其移动到 CPU 上。代码改成如下：

一、数据加载

本实验的数据集使用计算机视觉领域的经典数据集：CIFAR-10数据集，数据集下载位置：数据集下载

代码如下：

1. def load_cifar10_batch(folder_path, batch_id=1, mode='train'):
2.     if mode == 'test':
3.         file_path = os.path.join(folder_path, 'test_batch')
4.     else:
5.         file_path = os.path.join(folder_path, 'data_batch_' + str(batch_id))
7.     # 加载数据集文件
8.     with open(file_path, 'rb') as batch_file:
9.         batch = pickle.load(batch_file, encoding='latin1')
11.     imgs = batch['data'].reshape((len(batch['data']), 3, 32, 32)) / 255.
12.     labels = batch['labels']
14.     return np.array(imgs, dtype='float32'), np.array(labels)
17. imgs_batch, labels_batch = load_cifar10_batch(folder_path=r'cifar-10-batches-py',
18.                                               batch_id=1, mode='train')
19. # 打印一下每个batch中X和y的维度
20. print("batch of imgs shape: ", imgs_batch.shape, "batch of labels shape: ", labels_batch.shape)
21. print(torch.__version__)
22. print(torch.cuda.is_available())
23. # ==========可视化观察其中的一张样本图像和对应的标签=================================
24. import matplotlib.pyplot as plt
26. image, label = imgs_batch[1], labels_batch[1]
27. print("The label in the picture is {}".format(label))
28. plt.figure(figsize=(2, 2))
29. plt.imshow(image.transpose(1, 2, 0))
30. plt.show()

复制代码

运行结果：

 

二、数据集类构建

代码如下：

1. # =====构建Dataset类======================================================
2. import torch
3. from torch.utils.data import Dataset, DataLoader
4. import torchvision.transforms as transforms
7. class CIFAR10Dataset(Dataset):
8.     def __init__(self, folder_path=r'cifar-10-batches-py', mode='train', device=None):
9.         if mode == 'train':
10.             self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, batch_id=1, mode='train')
11.             for i in range(2, 5):
12.                 imgs_batch, labels_batch = load_cifar10_batch(folder_path=folder_path, batch_id=i, mode='train')
13.                 self.imgs, self.labels = np.concatenate([self.imgs, imgs_batch]), np.concatenate(
14.                     [self.labels, labels_batch])
15.         elif mode == 'dev':
16.             self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, batch_id=5, mode='dev')
17.         elif mode == 'test':
18.             self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, mode='test')
20.         self.transforms = transforms.Compose([transforms.Resize(32), transforms.ToTensor(),
21.                                               transforms.Normalize(mean=[0.4914, 0.4822, 0.4465],
22.                                                                    std=[0.2023, 0.1994, 0.2010])])
23.         self.device = device  # 保存设备信息
25.     def __getitem__(self, idx):
26.         img, label = self.imgs[idx], self.labels[idx]
27.         img, label = torch.tensor(img).float(), torch.tensor(label).long()  # 转为Tensor
28.         if self.device:
29.             img, label = img.to(self.device), label.to(self.device)  # 将数据传输到目标设备
30.         return img, label
32.     def __len__(self):
33.         return len(self.imgs)
36. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
37. print(device)
38. # 创建数据集时传递设备信息
39. train_dataset = CIFAR10Dataset(folder_path=r'cifar-10-batches-py', mode='train', device=device)
40. dev_dataset = CIFAR10Dataset(folder_path=r'cifar-10-batches-py', mode='dev', device=device)
41. test_dataset = CIFAR10Dataset(folder_path=r'cifar-10-batches-py', mode='test', device=device)

复制代码

三、模型构建

使用PyTorch API中的Resnet18进行图像分类实验。
代码如下：

1. # =======模型构建========================================
2. from torchvision.models import resnet18
3. time1 = time.time()
4. resnet18_model = resnet18(pretrained=True)

复制代码

四、模型练习

代码如下：

1. # =======模型训练================================================
2. import torch.nn.functional as F
3. import torch.optim as opt
4. from nndl_3 import RunnerV3, Accuracy
6. # 学习率大小
7. lr = 0.001
8. # 批次大小
9. batch_size = 64
10. # 加载数据
11. train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
12. dev_loader = DataLoader(dev_dataset, batch_size=batch_size)
13. test_loader = DataLoader(test_dataset, batch_size=batch_size)
14. # 定义网络
15. model = resnet18_model.to(device)
16. # 定义优化器，这里使用Adam优化器以及l2正则化策略，相关内容在7.3.3.2和7.6.2中会进行详细介绍
17. optimizer = opt.Adam(lr=lr, params=model.parameters(), weight_decay=0.005)
18. # 定义损失函数
19. loss_fn = F.cross_entropy
20. loss_fn = loss_fn
21. # 定义评价指标
22. metric = Accuracy(is_logist=True)
23. # 在训练和评估时，将数据传输到设备上
24. for data, labels in train_loader:
25.     data, labels = data.to(device), labels.to(device)  # 将数据和标签都发送到相同的设备
26.     logits = model(data)  # 进行前向传播
27.     loss = loss_fn(logits, labels)
28.     optimizer.zero_grad()
29.     loss.backward()
30.     optimizer.step()
31. # 实例化RunnerV3
32. runner = RunnerV3(model, optimizer, loss_fn, metric)
33. # 启动训练
34. log_steps = 3000
35. eval_steps = 3000
36. runner.train(train_loader, dev_loader, num_epochs=30, log_steps=log_steps,
37.              eval_steps=eval_steps, save_path="best_model.pdparams")
39. from nndl_3 import plot
41. plot(runner, fig_name='cnn-loss4.pdf')

复制代码

运行结果：

五、模型评价及猜测

代码如下：

1. # ========模型评价============================================
2. # 加载最优模型
3. runner.load_model('best_model.pdparams')
4. # 模型评价
5. score, loss = runner.evaluate(test_loader)
6. print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))
8. # ==========模型预测================================================
9. import matplotlib.pyplot as plt
11. # 获取测试集中的一个batch的数据
12. X, label = next(iter(test_loader))
13. X = X.to(device)
14. logits = runner.predict(X, dim=1)
15. # 多分类，使用softmax计算预测概率
16. pred = F.softmax(logits)
17. # print(pred)
18. # 获取概率最大的类别
19. pred_class = torch.argmax(pred[2][0]).cpu().numpy()
20. label = label[2].item()
21. # 输出真实类别与预测类别
22. print("The true category is {} and the predicted category is {}".format(label, pred_class))
23. # 可视化图片
24. plt.figure(figsize=(2, 2))
25. imgs, labels = load_cifar10_batch(folder_path=r'cifar-10-batches-py', mode='test')
26. plt.imshow(imgs[2].transpose(1, 2, 0))
27. plt.savefig('cnn-test-vis.pdf')
28. time2 = time.time()
29. print('使用预训练模型的训练时间：{}'.format(time2-time1))

复制代码

 运行结果：

运行时间：

以上是使用预练习的结果，对比不适用预练习，只需要修改这一行代码：

1. resnet18_model = resnet18(pretrained=True)

复制代码

把True改为False即可。
不使用预练习的结果如下：

对比可以看出：使用预练习运行时间变短了，正确率变高了，那么这是为什么呢？
首先来说，什么是预练习？什么是迁移学习呢？
   预练习：      
    “预练习”的做法一般是将大量低成本网络的练习数据放在一起，颠末某种预训方法去学习其中的共性，然后将其中的共性“移植”到特定任务的模型中，再使用相关特定领域的少量标注数据进行“微调”，这样的话，模型只需要从“共性”出发，去学习该特定任务的“特别”部分即可。
        因为预练习模型已经在大规模数据集上学到了一般性的特征表现（如边缘、纹理、颜色等），以是参数已经初始化为较优值，只需对少部分参数进行调解，模型无需从零开始学习，因而练习过程更快。
    迁移学习：
  迁移学习主要头脑：
  

  迁移学习的焦点头脑是：在一个任务上练习得到的模型包含的知识可以部分或全部地转移到另一个任务上。这通常涉及以下两个主要步调：
  ·源任务学习： 在源任务上练习模型，这个任务通常有大量的数据可用。
  ·知识迁移： 将从源任务学到的知识（如网络参数、特征表现等）应用到目的任务上。
迁移学习通过重复利用已有的知识，不但进步了学习效率和模型性能，还低落了对标注数据的需求和整体练习成本。它在小数据集、跨领域应用和办理复杂标题方面展现了显著的上风。
平凡练习、预练习、迁移学习的对比：
  

   实验过程中，使用的优化器不是SGD了，而是换成了Adam，那么Adam优化器和SGD优化器有什么区别呢？
   Adam是一种常用的自适应优化算法，它结合了动量和自适应学习率机制。Adam是基于梯度降落法的，它通过调解每个参数的学习率来加速练习并避免一些常见标题（如梯度消失或爆炸）。
Adam优化器和SGD的对比：
  

Adam优化器主动调解每个参数的学习率，尤其得当大规模的深度学习任务。以是本次实验选择了Adam优化器。
  本次实验中还用到了权重衰减，用来防止过拟合，那么它的原理是什么呢？
   权重衰减是一种正则化方法，旨在防止模型的过拟合。它通过在损失函数中添加一个项，使得模型的参数保持较小的值，从而避免模型过分依赖某些特征，导致过拟合。
  权重衰减的公式：
  对于一个损失函数J(θ)，在应用权重衰减后，损失函数变为：
  

λ 是权重衰减的超参数（通常称为正则化强度），决定了对权重的惩罚水平。
  

是模型权重的L2范数，即权重的平方和。
L2正则化和权重衰减本质上是雷同的，区别在于在实现时是否将其明白作为正则化项添加到损失函数中。通常，现代优化器（如Adam、SGD）会通过直接修改损失函数来实现这一点，从而形成权重衰减。
  
附完整可运行代码：

主程序：

1. import osimport pickleimport timeimport numpy as npimport torchdef load_cifar10_batch(folder_path, batch_id=1, mode='train'):
2.     if mode == 'test':
3.         file_path = os.path.join(folder_path, 'test_batch')
4.     else:
5.         file_path = os.path.join(folder_path, 'data_batch_' + str(batch_id))
7.     # 加载数据集文件
8.     with open(file_path, 'rb') as batch_file:
9.         batch = pickle.load(batch_file, encoding='latin1')
11.     imgs = batch['data'].reshape((len(batch['data']), 3, 32, 32)) / 255.
12.     labels = batch['labels']
14.     return np.array(imgs, dtype='float32'), np.array(labels)
17. imgs_batch, labels_batch = load_cifar10_batch(folder_path=r'cifar-10-batches-py',
18.                                               batch_id=1, mode='train')
19. # 打印一下每个batch中X和y的维度
20. print("batch of imgs shape: ", imgs_batch.shape, "batch of labels shape: ", labels_batch.shape)
21. print(torch.__version__)
22. print(torch.cuda.is_available())
23. # ==========可视化观察其中的一张样本图像和对应的标签=================================
24. import matplotlib.pyplot as plt
26. image, label = imgs_batch[1], labels_batch[1]
27. print("The label in the picture is {}".format(label))
28. plt.figure(figsize=(2, 2))
29. plt.imshow(image.transpose(1, 2, 0))
30. plt.show()
31. # =====构建Dataset类======================================================
32. import torch
33. from torch.utils.data import Dataset, DataLoader
34. import torchvision.transforms as transforms
37. class CIFAR10Dataset(Dataset):
38.     def __init__(self, folder_path=r'cifar-10-batches-py', mode='train', device=None):
39.         if mode == 'train':
40.             self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, batch_id=1, mode='train')
41.             for i in range(2, 5):
42.                 imgs_batch, labels_batch = load_cifar10_batch(folder_path=folder_path, batch_id=i, mode='train')
43.                 self.imgs, self.labels = np.concatenate([self.imgs, imgs_batch]), np.concatenate(
44.                     [self.labels, labels_batch])
45.         elif mode == 'dev':
46.             self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, batch_id=5, mode='dev')
47.         elif mode == 'test':
48.             self.imgs, self.labels = load_cifar10_batch(folder_path=folder_path, mode='test')
50.         self.transforms = transforms.Compose([transforms.Resize(32), transforms.ToTensor(),
51.                                               transforms.Normalize(mean=[0.4914, 0.4822, 0.4465],
52.                                                                    std=[0.2023, 0.1994, 0.2010])])
53.         self.device = device  # 保存设备信息
55.     def __getitem__(self, idx):
56.         img, label = self.imgs[idx], self.labels[idx]
57.         img, label = torch.tensor(img).float(), torch.tensor(label).long()  # 转为Tensor
58.         if self.device:
59.             img, label = img.to(self.device), label.to(self.device)  # 将数据传输到目标设备
60.         return img, label
62.     def __len__(self):
63.         return len(self.imgs)
66. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
67. print(device)
68. # 创建数据集时传递设备信息
69. train_dataset = CIFAR10Dataset(folder_path=r'cifar-10-batches-py', mode='train', device=device)
70. dev_dataset = CIFAR10Dataset(folder_path=r'cifar-10-batches-py', mode='dev', device=device)
71. test_dataset = CIFAR10Dataset(folder_path=r'cifar-10-batches-py', mode='test', device=device)
72. # =======模型构建========================================
73. from torchvision.models import resnet18
74. time1 = time.time()
75. resnet18_model = resnet18(pretrained=True)
76. # =======模型训练================================================
77. import torch.nn.functional as F
78. import torch.optim as opt
79. from nndl_3 import RunnerV3, Accuracy
81. # 学习率大小
82. lr = 0.001
83. # 批次大小
84. batch_size = 64
85. # 加载数据
86. train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
87. dev_loader = DataLoader(dev_dataset, batch_size=batch_size)
88. test_loader = DataLoader(test_dataset, batch_size=batch_size)
89. # 定义网络
90. model = resnet18_model.to(device)
91. # 定义优化器，这里使用Adam优化器以及l2正则化策略，相关内容在7.3.3.2和7.6.2中会进行详细介绍
92. optimizer = opt.Adam(lr=lr, params=model.parameters(), weight_decay=0.005)
93. # 定义损失函数
94. loss_fn = F.cross_entropy
95. loss_fn = loss_fn
96. # 定义评价指标
97. metric = Accuracy(is_logist=True)
98. # 在训练和评估时，将数据传输到设备上
99. for data, labels in train_loader:
100.     data, labels = data.to(device), labels.to(device)  # 将数据和标签都发送到相同的设备
101.     logits = model(data)  # 进行前向传播
102.     loss = loss_fn(logits, labels)
103.     optimizer.zero_grad()
104.     loss.backward()
105.     optimizer.step()
106. # 实例化RunnerV3
107. runner = RunnerV3(model, optimizer, loss_fn, metric)
108. # 启动训练
109. log_steps = 3000
110. eval_steps = 3000
111. runner.train(train_loader, dev_loader, num_epochs=30, log_steps=log_steps,
112.              eval_steps=eval_steps, save_path="best_model.pdparams")
114. from nndl_3 import plot
116. plot(runner, fig_name='cnn-loss4.pdf')
117. # ========模型评价============================================
118. # 加载最优模型
119. runner.load_model('best_model.pdparams')
120. # 模型评价
121. score, loss = runner.evaluate(test_loader)
122. print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))
124. # ==========模型预测================================================
125. import matplotlib.pyplot as plt
127. # 获取测试集中的一个batch的数据
128. X, label = next(iter(test_loader))
129. X = X.to(device)
130. logits = runner.predict(X, dim=1)
131. # 多分类，使用softmax计算预测概率
132. pred = F.softmax(logits)
133. # print(pred)
134. # 获取概率最大的类别
135. pred_class = torch.argmax(pred[2][0]).cpu().numpy()
136. label = label[2].item()
137. # 输出真实类别与预测类别
138. print("The true category is {} and the predicted category is {}".format(label, pred_class))
139. # 可视化图片
140. plt.figure(figsize=(2, 2))
141. imgs, labels = load_cifar10_batch(folder_path=r'cifar-10-batches-py', mode='test')
142. plt.imshow(imgs[2].transpose(1, 2, 0))
143. plt.savefig('cnn-test-vis.pdf')
144. time2 = time.time()
145. print('使用预训练模型的训练时间：{}'.format(time2-time1))

复制代码

nndl_3的代码：

1. import torch
2. from matplotlib import pyplot as plt
3. from torch import nn
6. class Op(object):
7.     def __init__(self):
8.         pass
10.     def __call__(self, inputs):
11.         return self.forward(inputs)
13.     def forward(self, inputs):
14.         raise NotImplementedError
16.     def backward(self, inputs):
17.         raise NotImplementedError
20. # 实现一个两层前馈神经网络
21. class Model_MLP_L2_V3(torch.nn.Module):
22.     def __init__(self, input_size, hidden_size, output_size):
23.         super(Model_MLP_L2_V3, self).__init__()
24.         self.fc1 = torch.nn.Linear(input_size, hidden_size)
25.         w_ = torch.normal(0, 0.01, size=(hidden_size, input_size), requires_grad=True)
26.         self.fc1.weight = torch.nn.Parameter(w_)
27.         self.fc1.bias = torch.nn.init.constant_(self.fc1.bias, val=1.0)
28.         self.fc2 = torch.nn.Linear(hidden_size, output_size)
29.         w2 = torch.normal(0, 0.01, size=(output_size, hidden_size), requires_grad=True)
30.         self.fc2.weight = nn.Parameter(w2)
31.         self.fc2.bias = torch.nn.init.constant_(self.fc2.bias, val=1.0)
32.         self.act = torch.sigmoid
34.     def forward(self, inputs):
35.         outputs = self.fc1(inputs)
36.         outputs = self.act(outputs)
37.         outputs = self.fc2(outputs)
38.         return outputs
41. class RunnerV3(object):
42.     def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
43.         self.model = model
44.         self.optimizer = optimizer
45.         self.loss_fn = loss_fn
46.         self.metric = metric  # 只用于计算评价指标
48.         # 记录训练过程中的评价指标变化情况
49.         self.dev_scores = []
51.         # 记录训练过程中的损失函数变化情况
52.         self.train_epoch_losses = []  # 一个epoch记录一次loss
53.         self.train_step_losses = []  # 一个step记录一次loss
54.         self.dev_losses = []
56.         # 记录全局最优指标
57.         self.best_score = 0
59.     def train(self, train_loader, dev_loader=None, **kwargs):
60.         # 将模型切换为训练模式
61.         self.model.train()
63.         # 传入训练轮数，如果没有传入值则默认为0
64.         num_epochs = kwargs.get("num_epochs", 0)
65.         # 传入log打印频率，如果没有传入值则默认为100
66.         log_steps = kwargs.get("log_steps", 100)
67.         # 评价频率
68.         eval_steps = kwargs.get("eval_steps", 0)
70.         # 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
71.         save_path = kwargs.get("save_path", "best_model.pdparams")
73.         custom_print_log = kwargs.get("custom_print_log", None)
75.         # 训练总的步数
76.         num_training_steps = num_epochs * len(train_loader)
78.         if eval_steps:
79.             if self.metric is None:
80.                 raise RuntimeError('Error: Metric can not be None!')
81.             if dev_loader is None:
82.                 raise RuntimeError('Error: dev_loader can not be None!')
84.         # 运行的step数目
85.         global_step = 0
87.         # 进行num_epochs轮训练
88.         for epoch in range(num_epochs):
89.             # 用于统计训练集的损失
90.             total_loss = 0
91.             for step, data in enumerate(train_loader):
92.                 X, y = data
93.                 # 获取模型预测
94.                 logits = self.model(X)
95.                 loss = self.loss_fn(logits, y.long())  # 默认求mean
96.                 total_loss += loss
98.                 # 训练过程中，每个step的loss进行保存
99.                 self.train_step_losses.append((global_step, loss.item()))
101.                 if log_steps and global_step % log_steps == 0:
102.                     print(
103.                         f"[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f}")
105.                 # 梯度反向传播，计算每个参数的梯度值
106.                 loss.backward()
108.                 if custom_print_log:
109.                     custom_print_log(self)
111.                 # 小批量梯度下降进行参数更新
112.                 self.optimizer.step()
113.                 # 梯度归零
114.                 self.optimizer.zero_grad()
116.                 # 判断是否需要评价
117.                 if eval_steps > 0 and global_step > 0 and \
118.                         (global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):
120.                     dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
121.                     print(f"[Evaluate]  dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f}")
123.                     # 将模型切换为训练模式
124.                     self.model.train()
126.                     # 如果当前指标为最优指标，保存该模型
127.                     if dev_score > self.best_score:
128.                         self.save_model(save_path)
129.                         print(
130.                             f"[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} --> {dev_score:.5f}")
131.                         self.best_score = dev_score
133.                 global_step += 1
135.             # 当前epoch 训练loss累计值
136.             trn_loss = (total_loss / len(train_loader)).item()
137.             # epoch粒度的训练loss保存
138.             self.train_epoch_losses.append(trn_loss)
140.         print("[Train] Training done!")
142.     # 模型评估阶段，使用'torch.no_grad()'控制不计算和存储梯度
143.     @torch.no_grad()
144.     def evaluate(self, dev_loader, **kwargs):
145.         assert self.metric is not None
147.         # 将模型设置为评估模式
148.         self.model.eval()
150.         global_step = kwargs.get("global_step", -1)
152.         # 用于统计训练集的损失
153.         total_loss = 0
155.         # 重置评价
156.         self.metric.reset()
158.         # 遍历验证集每个批次
159.         for batch_id, data in enumerate(dev_loader):
160.             X, y = data
162.             # 计算模型输出
163.             logits = self.model(X)
165.             # 计算损失函数
166.             loss = self.loss_fn(logits, y).item()
167.             # 累积损失
168.             total_loss += loss
170.             # 累积评价
171.             self.metric.update(logits, y)
173.         dev_loss = (total_loss / len(dev_loader))
174.         dev_score = self.metric.accumulate()
176.         # 记录验证集loss
177.         if global_step != -1:
178.             self.dev_losses.append((global_step, dev_loss))
179.             self.dev_scores.append(dev_score)
181.         return dev_score, dev_loss
183.     # 模型评估阶段，使用'torch.no_grad()'控制不计算和存储梯度
184.     @torch.no_grad()
185.     def predict(self, x, **kwargs):
186.         # 将模型设置为评估模式
187.         self.model.eval()
188.         # 运行模型前向计算，得到预测值
189.         logits = self.model(x)
190.         return logits
192.     def save_model(self, save_path):
193.         torch.save(self.model.state_dict(), save_path)
195.     def load_model(self, model_path):
196.         model_state_dict = torch.load(model_path)
197.         self.model.load_state_dict(model_state_dict)
200. class Accuracy():
201.     def __init__(self, is_logist=True):
202.         # 用于统计正确的样本个数
203.         self.num_correct = 0
204.         # 用于统计样本的总数
205.         self.num_count = 0
207.         self.is_logist = is_logist
209.     def update(self, outputs, labels):
210.         if outputs.shape[1] == 1:  # 二分类
211.             outputs = torch.squeeze(outputs, dim=-1)
212.             if self.is_logist:
213.                 # logist判断是否大于0
214.                 preds = torch.tensor((outputs >= 0), dtype=torch.float32)
215.             else:
216.                 # 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
217.                 preds = torch.tensor((outputs >= 0.5), dtype=torch.float32)
218.         else:
219.             # 多分类时，使用'torch.argmax'计算最大元素索引作为类别
220.             preds = torch.argmax(outputs, dim=1)
222.         # 获取本批数据中预测正确的样本个数
223.         labels = torch.squeeze(labels, dim=-1)
224.         batch_correct = torch.sum(torch.tensor(preds == labels, dtype=torch.float32)).cpu().numpy()
225.         batch_count = len(labels)
227.         # 更新num_correct 和 num_count
228.         self.num_correct += batch_correct
229.         self.num_count += batch_count
231.     def accumulate(self):
232.         # 使用累计的数据，计算总的指标
233.         if self.num_count == 0:
234.             return 0
235.         return self.num_correct / self.num_count
237.     def reset(self):
238.         # 重置正确的数目和总数
239.         self.num_correct = 0
240.         self.num_count = 0
242.     def name(self):
243.         return "Accuracy"
246. # 可视化
247. def plot(runner, fig_name):
248.     plt.figure(figsize=(10, 5))
250.     plt.subplot(1, 2, 1)
251.     train_items = runner.train_step_losses[::30]
252.     train_steps = [x[0] for x in train_items]
253.     train_losses = [x[1] for x in train_items]
255.     plt.plot(train_steps, train_losses, color='#8E004D', label="Train loss")
256.     if runner.dev_losses[0][0] != -1:
257.         dev_steps = [x[0] for x in runner.dev_losses]
258.         dev_losses = [x[1] for x in runner.dev_losses]
259.         plt.plot(dev_steps, dev_losses, color='#E20079', linestyle='--', label="Dev loss")
260.     # 绘制坐标轴和图例
261.     plt.ylabel("loss", fontsize='x-large')
262.     plt.xlabel("step", fontsize='x-large')
263.     plt.legend(loc='upper right', fontsize='x-large')
265.     plt.subplot(1, 2, 2)
266.     # 绘制评价准确率变化曲线
267.     if runner.dev_losses[0][0] != -1:
268.         plt.plot(dev_steps, runner.dev_scores,
269.                  color='#E20079', linestyle="--", label="Dev accuracy")
270.     else:
271.         plt.plot(list(range(len(runner.dev_scores))), runner.dev_scores,
272.                  color='#E20079', linestyle="--", label="Dev accuracy")
273.     # 绘制坐标轴和图例
274.     plt.ylabel("score", fontsize='x-large')
275.     plt.xlabel("step", fontsize='x-large')
276.     plt.legend(loc='lower right', fontsize='x-large')
278.     plt.savefig(fig_name)
279.     plt.show()

复制代码

今天的分享就到这里，下次再见~
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。