• 【深度学习实验】卷积神经网络（六）：自定义卷积神经网络模型（VGG）实现图片多分类任务

    目录

    一、实验介绍

    二、实验环境

    1. 配置虚拟环境

    2. 库版本介绍

    三、实验内容

    0. 导入必要的工具包

    1. 构建数据集（CIFAR10Dataset）

    a. read_csv_labels（）

    b. CIFAR10Dataset

    2. 构建模型（FeedForward）

    3.整合训练、评估、预测过程（Runner）

    4. __main__

    预测结果

    5. 代码整合

    一、实验介绍

            本实验实现了一个简化版VGG网络，并基于此完成图像分类任务。
           

            VGG网络是深度卷积神经网络中的经典模型之一，由牛津大学计算机视觉组（Visual Geometry Group）提出。它在2014年的ImageNet图像分类挑战中取得了优异的成绩（分类任务第二，定位任务第一），被广泛应用于图像分类、目标检测和图像生成等任务。

            VGG网络的主要特点是使用了非常小的卷积核尺寸（通常为3x3）和更深的网络结构。该网络通过多个卷积层和池化层堆叠在一起，逐渐增加网络的深度，从而提取图像的多层次特征表示。VGG网络的基本构建块是由连续的卷积层组成，每个卷积层后面跟着一个ReLU激活函数。在每个卷积块的末尾，都会添加一个最大池化层来减小特征图的尺寸。VGG网络的这种简单而有效的结构使得它易于理解和实现，并且在不同的任务上具有很好的泛化性能。

            VGG网络有几个不同的变体，如VGG11、VGG13、VGG16和VGG19，它们的数字代表网络的层数。这些变体在网络深度和参数数量上有所区别，较深的网络通常具有更强大的表示能力，但也更加复杂。

    二、实验环境

        本系列实验使用了PyTorch深度学习框架，相关操作如下：

    1. 配置虚拟环境

    conda create -n DL python=3.7 
    conda activate DL
    pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html

    conda install matplotlib
     conda install scikit-learn

    2. 库版本介绍

    软件包本实验版本目前最新版
    matplotlib3.5.33.8.0
    numpy1.21.61.26.0
    python3.7.16
    scikit-learn0.22.11.3.0
    torch1.8.1+cu1022.0.1
    torchaudio0.8.12.0.2
    torchvision0.9.1+cu1020.15.2

    三、实验内容

    ChatGPT：

            卷积神经网络（Convolutional Neural Network，简称CNN）是一种深度学习模型，广泛应用于图像识别、计算机视觉和模式识别等领域。它的设计灵感来自于生物学中视觉皮层的工作原理。

            卷积神经网络通过多个卷积层、池化层和全连接层组成。

    • 卷积层主要用于提取图像的局部特征，通过卷积操作和激活函数的处理，可以学习到图像的特征表示。
    • 池化层则用于降低特征图的维度，减少参数数量，同时保留主要的特征信息。
    • 全连接层则用于将提取到的特征映射到不同类别的概率上，进行分类或回归任务。

            卷积神经网络在图像处理方面具有很强的优势，它能够自动学习到具有层次结构的特征表示，并且对平移、缩放和旋转等图像变换具有一定的不变性。这些特点使得卷积神经网络成为图像分类、目标检测、语义分割等任务的首选模型。除了图像处理，卷积神经网络也可以应用于其他领域，如自然语言处理和时间序列分析。通过将文本或时间序列数据转换成二维形式，可以利用卷积神经网络进行相关任务的处理。

    0. 导入必要的工具包

    1. import torch 
    2. from torch import nn
    3. import torch.nn.functional as F
    4. from torch.utils.data import Dataset, DataLoader
    5. from torchvision.io import read_image
    6. import matplotlib.pyplot as plt
    7. import os

    1. 构建数据集（CIFAR10Dataset）

    a. read_csv_labels（）

            从CSV文件中读取标签信息并返回一个标签字典。

    1. def read_csv_labels(fname):
    2.     """读取fname来给标签字典返回一个文件名"""
    3.     with open(fname, 'r') as f:
    4.         # 跳过文件头行(列名)
    5.         lines = f.readlines()[1:]
    6.     tokens = [l.rstrip().split(',') for l in lines]
    7.     return dict(((name, label) for name, label in tokens))

    •  使用open函数打开指定文件名的CSV文件，并将文件对象赋值给变量f。这里使用'r'参数以只读模式打开文件。

    • 使用文件对象的readlines()方法读取文件的所有行，并将结果存储在名为lines的列表中。通过切片操作[1:]，跳过了文件的第一行（列名），将剩余的行存储在lines列表中。

    • 列表推导式（list comprehension）：对lines列表中的每一行进行处理。对于每一行，使用rstrip()方法去除行末尾的换行符，并使用split(',')方法将行按逗号分割为多个标记。最终，将所有行的标记组成的子列表存储在tokens列表中。

    • 使用字典推导式（dictionary comprehension）将tokens列表中的子列表转换为字典。对于tokens中的每个子列表，将子列表的第一个元素作为键（name），第二个元素作为值（label），最终返回一个包含这些键值对的字典。

    b. CIFAR10Dataset

    1. class CIFAR10Dataset(Dataset):
    2.     def __init__(self, folder_path, fname):
    3.         self.labels = read_csv_labels(os.path.join(folder_path, fname))
    4.         self.folder_path = os.path.join(folder_path, 'train')
    5.  
    6.     def __len__(self):
    7.         return len(self.labels)
    8.  
    9.     def __getitem__(self, idx):
    10.         img = read_image(self.folder_path + '/' + str(idx + 1) + '.png')
    11.         label = self.labels[str(idx + 1)]
    12.  
    13.         return img, torch.tensor(int(label))

    • 构造函数：

      • 接受两个参数

        • folder_path表示数据集所在的文件夹路径

        • fname表示包含标签信息的文件名。

      • 调用read_csv_labels函数，传递folder_path和fname作为参数，以读取CSV文件中的标签信息，并将返回的标签字典存储在self.labels变量中。

      • 通过拼接folder_path和字符串'train'来构建数据集的文件夹路径，将结果存储在self.folder_path变量中。

    • def __len__(self)

      • 这是CIFAR10Dataset类的方法，用于返回数据集的长度，即样本的数量。

    • def __getitem__(self, idx): 这是CIFAR10Dataset类的方法，用于根据给定的索引idx获取数据集中的一个样本。它首先根据索引idx构建图像文件的路径，并调用read_image函数来读取图像数据，将结果存储在img变量中。然后，它通过将索引转换为字符串，并使用该字符串作为键来从self.labels字典中获取相应的标签，将结果存储在label变量中。最后，它返回一个元组，包含图像数据和经过torch.tensor转换的标签。

    2. 构建模型（FeedForward）

            参考前文：

    【深度学习实验】卷积神经网络（五）：深度卷积神经网络经典模型——VGG网络（卷积层、池化层、全连接层）_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133350927?spm=1001.2014.3001.5501

    1. #  每个卷积块由Conv2d卷积 + BatchNorm2d(批量标准化处理) + ReLU激活层组成
    2. def conv_layer(chann_in, chann_out, k_size, p_size):
    3.     layer = nn.Sequential(
    4.         nn.Conv2d(chann_in, chann_out, kernel_size=k_size, padding=p_size),
    5.         nn.BatchNorm2d(chann_out),
    6.         nn.ReLU()
    7.     )
    8.     return layer
    9.     
    10. # vgg卷积模块是由几个相同的卷积块以及最大池化组成
    11. def vgg_conv_block(in_list, out_list, k_list, p_list, pooling_k, pooling_s):
    12.  
    13.     layers = [conv_layer(in_list[i], out_list[i], k_list[i], p_list[i]) for i in range(len(in_list)) ]
    14.     layers += [nn.MaxPool2d(kernel_size = pooling_k, stride = pooling_s)]
    15.     return nn.Sequential(*layers)
    16.  
    17. # vgg全连接层由Linear + BatchNorm1d + ReLU组成
    18. def vgg_fc_layer(size_in, size_out):
    19.     layer = nn.Sequential(
    20.         nn.Linear(size_in, size_out),
    21.         nn.BatchNorm1d(size_out),
    22.         nn.ReLU()
    23.     )
    24.     return layer
    25.  
    26.  
    27. # 为了简化，我们少使用了几层卷积层，方便大家使用
    28. class VGG_S(nn.Module):
    29.     def __init__ (self, num_classes):
    30.         super().__init__()
    31.         
    32.         self.layer1 = vgg_conv_block([3,64], [64,64], [3,3], [1,1], 2, 2)   
    33.         self.layer2 = vgg_conv_block([64,128], [128,128], [3,3], [1,1], 2, 2)
    34.         self.layer3 = vgg_conv_block([128,256,256], [256,256,256], [3,3,3], [1,1,1], 2, 2)
    35.  
    36.         # 全连接层
    37.         self.layer4 = vgg_fc_layer(4096, 1024)
    38.         # Final layer
    39.         self.layer5 = nn.Linear(1024, num_classes)
    40.         
    41.     def forward(self, x):
    42.         out = self.layer1(x)
    43.         out = self.layer2(out)
    44.         vgg16_features = self.layer3(out)
    45.         out = vgg16_features.view(out.size(0), -1)
    46.         out = self.layer4(out)
    47.         out = self.layer5(out)
    48.  
    49.         return out

    3.整合训练、评估、预测过程（Runner）

            参考前文：

    【深度学习实验】前馈神经网络（九）：整合训练、评估、预测过程（Runner）_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133219448?spm=1001.2014.3001.5501

            （略有改动：）

    1. class Runner(object):
    2.     def __init__(self, model, optimizer, loss_fn, metric=None):
    3.         self.model = model
    4.         self.optimizer = optimizer
    5.         self.loss_fn = loss_fn
    6.         # 用于计算评价指标
    7.         self.metric = metric
    8.         
    9.         # 记录训练过程中的评价指标变化
    10.         self.dev_scores = []
    11.         # 记录训练过程中的损失变化
    12.         self.train_epoch_losses = []
    13.         self.dev_losses = []
    14.         # 记录全局最优评价指标
    15.         self.best_score = 0
    16.    
    17.  
    18. # 模型训练阶段
    19.     def train(self, train_loader, dev_loader=None, **kwargs):
    20.         # 将模型设置为训练模式，此时模型的参数会被更新
    21.         self.model.train()
    22.         
    23.         num_epochs = kwargs.get('num_epochs', 0)
    24.         log_steps = kwargs.get('log_steps', 100)
    25.         save_path = kwargs.get('save_path','best_model.pth')
    26.         eval_steps = kwargs.get('eval_steps', 0)
    27.         # 运行的step数，不等于epoch数
    28.         global_step = 0
    29.         
    30.         if eval_steps:
    31.             if dev_loader is None:
    32.                 raise RuntimeError('Error: dev_loader can not be None!')
    33.             if self.metric is None:
    34.                 raise RuntimeError('Error: Metric can not be None')
    35.                 
    36.         # 遍历训练的轮数
    37.         for epoch in range(num_epochs):
    38.             total_loss = 0
    39.             # 遍历数据集
    40.             for step, data in enumerate(train_loader):
    41.                 x, y = data
    42.                 logits = self.model(x.float())
    43.                 loss = self.loss_fn(logits, y.long())
    44.                 total_loss += loss
    45.                 if step%log_steps == 0:
    46.                     print(f'loss:{loss.item():.5f}')
    47.                     
    48.                 loss.backward()
    49.                 self.optimizer.step()
    50.                 self.optimizer.zero_grad()
    51.             # 每隔一定轮次进行一次验证，由eval_steps参数控制，可以采用不同的验证判断条件
    52.             if eval_steps != 0 :
    53.                 if (epoch+1) % eval_steps ==  0:
    54.  
    55.                     dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
    56.                     print(f'[Evalute] dev score:{dev_score:.5f}, dev loss:{dev_loss:.5f}')
    57.                 
    58.                     if dev_score > self.best_score:
    59.                         self.save_model(f'model_{epoch+1}.pth')
    60.                     
    61.                         print(f'[Evaluate]best accuracy performance has been updated: {self.best_score:.5f}-->{dev_score:.5f}')
    62.                         self.best_score = dev_score
    63.                     
    64.                 # 验证过程结束后，请记住将模型调回训练模式   
    65.                     self.model.train()
    66.             
    67.             global_step += 1
    68.             # 保存当前轮次训练损失的累计值
    69.             train_loss = (total_loss/len(train_loader)).item()
    70.             self.train_epoch_losses.append((global_step,train_loss))
    71.         self.save_model(f'{save_path}.pth')   
    72.         print('[Train] Train done')
    73.         
    74.     # 模型评价阶段
    75.     def evaluate(self, dev_loader, **kwargs):
    76.         assert self.metric is not None
    77.         # 将模型设置为验证模式，此模式下，模型的参数不会更新
    78.         self.model.eval()
    79.         global_step = kwargs.get('global_step',-1)
    80.         total_loss = 0
    81.         self.metric.reset()
    82.         
    83.         for batch_id, data in enumerate(dev_loader):
    84.             x, y = data
    85.             logits = self.model(x.float())
    86.             loss = self.loss_fn(logits, y.long()).item()
    87.             total_loss += loss 
    88.             self.metric.update(logits, y)
    89.             
    90.         dev_loss = (total_loss/len(dev_loader))
    91.         self.dev_losses.append((global_step, dev_loss))
    92.         dev_score = self.metric.accumulate()
    93.         self.dev_scores.append(dev_score)
    94.         return dev_score, dev_loss
    95.     
    96.     # 模型预测阶段，
    97.     def predict(self, x, **kwargs):
    98.         self.model.eval()
    99.         logits = self.model(x)
    100.         return logits
    101.     
    102.     # 保存模型的参数
    103.     def save_model(self, save_path):
    104.         torch.save(self.model.state_dict(), save_path)
    105.         
    106.     # 读取模型的参数
    107.     def load_model(self, model_path):
    108.         self.model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))

    4. __main__

    1. if __name__ == '__main__':
    2.     batch_size = 20
    3.     # 构建训练集
    4.     train_data = CIFAR10Dataset('cifar10_tiny', 'trainLabels.csv')
    5.     train_iter = DataLoader(train_data, batch_size=batch_size)
    6.     # 构建测试集
    7.     test_data = CIFAR10Dataset('cifar10_tiny', 'trainLabels.csv')
    8.     test_iter = DataLoader(test_data, batch_size=batch_size)
    9.  
    10.     # 模型训练
    11.     num_classes = 10
    12.     # 定义模型
    13.     model = VGG_S(num_classes)
    14.     # 定义损失函数
    15.     loss_fn = F.cross_entropy
    16.     # 定义优化器
    17.     optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
    18.  
    19.     runner = Runner(model, optimizer, loss_fn, metric=None)
    20.     runner.train(train_iter, num_epochs=10, save_path='chapter_5')
    21.  
    22.     # 模型预测
    23.     runner.load_model('chapter_5.pth')
    24.     x, label = next(iter(test_iter))
    25.     predict = torch.argmax(runner.predict(x.float()), dim=1)
    26.     print('predict:', predict)
    27.     print('  label:', label)
    28.  
    29.

    预测结果

    1. predict: tensor([6, 1, 9, 6, 1, 1, 6, 7, 0, 3, 4, 7, 7, 1, 9, 0, 9, 5, 3, 6])
    2.   label: tensor([6, 9, 9, 4, 1, 1, 2, 7, 8, 3, 4, 7, 7, 2, 9, 9, 9, 3, 2, 6])

    5. 代码整合

    1. # 导入必要的工具包
    2. import torch
    3. from torch import nn
    4. import torch.nn.functional as F
    5. from torch.utils.data import Dataset, DataLoader
    6. from torchvision.io import read_image
    7. import matplotlib.pyplot as plt
    8. import os
    9.  
    10.  
    11. def read_csv_labels(fname):
    12.     """读取fname来给标签字典返回一个文件名"""
    13.     with open(fname, 'r') as f:
    14.         # 跳过文件头行(列名)
    15.         lines = f.readlines()[1:]
    16.     tokens = [l.rstrip().split(',') for l in lines]
    17.     return dict(((name, label) for name, label in tokens))
    18.  
    19.  
    20. class CIFAR10Dataset(Dataset):
    21.     def __init__(self, folder_path, fname):
    22.         self.labels = read_csv_labels(os.path.join(folder_path, fname))
    23.         self.folder_path = os.path.join(folder_path, 'train')
    24.  
    25.     def __len__(self):
    26.         return len(self.labels)
    27.  
    28.     def __getitem__(self, idx):
    29.         img = read_image(self.folder_path + '/' + str(idx + 1) + '.png')
    30.         label = self.labels[str(idx + 1)]
    31.  
    32.         return img, torch.tensor(int(label))
    33.  
    34.  
    35. #  每个卷积块由Conv2d卷积 + BatchNorm2d(批量标准化处理) + ReLU激活层组成
    36. def conv_layer(chann_in, chann_out, k_size, p_size):
    37.     layer = nn.Sequential(
    38.         nn.Conv2d(chann_in, chann_out, kernel_size=k_size, padding=p_size),
    39.         nn.BatchNorm2d(chann_out),
    40.         nn.ReLU()
    41.     )
    42.     return layer
    43.  
    44.  
    45. # vgg卷积模块是由几个相同的卷积块以及最大池化组成
    46. def vgg_conv_block(in_list, out_list, k_list, p_list, pooling_k, pooling_s):
    47.     layers = [conv_layer(in_list[i], out_list[i], k_list[i], p_list[i]) for i in range(len(in_list))]
    48.     layers += [nn.MaxPool2d(kernel_size=pooling_k, stride=pooling_s)]
    49.     return nn.Sequential(*layers)
    50.  
    51.  
    52. # vgg全连接层由Linear + BatchNorm1d + ReLU组成
    53. def vgg_fc_layer(size_in, size_out):
    54.     layer = nn.Sequential(
    55.         nn.Linear(size_in, size_out),
    56.         nn.BatchNorm1d(size_out),
    57.         nn.ReLU()
    58.     )
    59.     return layer
    60.  
    61.  
    62. # 为了简化，我们少使用了几层卷积层，方便大家使用
    63. class VGG_S(nn.Module):
    64.     def __init__(self, num_classes):
    65.         super().__init__()
    66.  
    67.         self.layer1 = vgg_conv_block([3, 64], [64, 64], [3, 3], [1, 1], 2, 2)
    68.         self.layer2 = vgg_conv_block([64, 128], [128, 128], [3, 3], [1, 1], 2, 2)
    69.         self.layer3 = vgg_conv_block([128, 256, 256], [256, 256, 256], [3, 3, 3], [1, 1, 1], 2, 2)
    70.  
    71.         # 全连接层
    72.         self.layer4 = vgg_fc_layer(4096, 1024)
    73.         # Final layer
    74.         self.layer5 = nn.Linear(1024, num_classes)
    75.  
    76.     def forward(self, x):
    77.         out = self.layer1(x)
    78.         out = self.layer2(out)
    79.         vgg16_features = self.layer3(out)
    80.         out = vgg16_features.view(out.size(0), -1)
    81.         out = self.layer4(out)
    82.         out = self.layer5(out)
    83.  
    84.         return out
    85.  
    86.  
    87.  
    88. class Runner(object):
    89.     def __init__(self, model, optimizer, loss_fn, metric=None):
    90.         self.model = model
    91.         self.optimizer = optimizer
    92.         self.loss_fn = loss_fn
    93.         # 用于计算评价指标
    94.         self.metric = metric
    95.  
    96.         # 记录训练过程中的评价指标变化
    97.         self.dev_scores = []
    98.         # 记录训练过程中的损失变化
    99.         self.train_epoch_losses = []
    100.         self.dev_losses = []
    101.         # 记录全局最优评价指标
    102.         self.best_score = 0
    103.  
    104.     # 模型训练阶段
    105.     def train(self, train_loader, dev_loader=None, **kwargs):
    106.         # 将模型设置为训练模式，此时模型的参数会被更新
    107.         self.model.train()
    108.  
    109.         num_epochs = kwargs.get('num_epochs', 0)
    110.         log_steps = kwargs.get('log_steps', 100)
    111.         save_path = kwargs.get('save_path', 'best_model.pth')
    112.         eval_steps = kwargs.get('eval_steps', 0)
    113.         # 运行的step数，不等于epoch数
    114.         global_step = 0
    115.  
    116.         if eval_steps:
    117.             if dev_loader is None:
    118.                 raise RuntimeError('Error: dev_loader can not be None!')
    119.             if self.metric is None:
    120.                 raise RuntimeError('Error: Metric can not be None')
    121.  
    122.         # 遍历训练的轮数
    123.         for epoch in range(num_epochs):
    124.             total_loss = 0
    125.             # 遍历数据集
    126.             for step, data in enumerate(train_loader):
    127.                 x, y = data
    128.                 logits = self.model(x.float())
    129.                 loss = self.loss_fn(logits, y.long())
    130.                 total_loss += loss
    131.                 if step % log_steps == 0:
    132.                     print(f'loss:{loss.item():.5f}')
    133.  
    134.                 loss.backward()
    135.                 self.optimizer.step()
    136.                 self.optimizer.zero_grad()
    137.             # 每隔一定轮次进行一次验证，由eval_steps参数控制，可以采用不同的验证判断条件
    138.             if eval_steps != 0:
    139.                 if (epoch + 1) % eval_steps == 0:
    140.  
    141.                     dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
    142.                     print(f'[Evalute] dev score:{dev_score:.5f}, dev loss:{dev_loss:.5f}')
    143.  
    144.                     if dev_score > self.best_score:
    145.                         self.save_model(f'model_{epoch + 1}.pth')
    146.  
    147.                         print(
    148.                             f'[Evaluate]best accuracy performance has been updated: {self.best_score:.5f}-->{dev_score:.5f}')
    149.                         self.best_score = dev_score
    150.  
    151.                     # 验证过程结束后，请记住将模型调回训练模式
    152.                     self.model.train()
    153.  
    154.             global_step += 1
    155.             # 保存当前轮次训练损失的累计值
    156.             train_loss = (total_loss / len(train_loader)).item()
    157.             self.train_epoch_losses.append((global_step, train_loss))
    158.         self.save_model(f'{save_path}.pth')
    159.         print('[Train] Train done')
    160.  
    161.     # 模型评价阶段
    162.     def evaluate(self, dev_loader, **kwargs):
    163.         assert self.metric is not None
    164.         # 将模型设置为验证模式，此模式下，模型的参数不会更新
    165.         self.model.eval()
    166.         global_step = kwargs.get('global_step', -1)
    167.         total_loss = 0
    168.         self.metric.reset()
    169.  
    170.         for batch_id, data in enumerate(dev_loader):
    171.             x, y = data
    172.             logits = self.model(x.float())
    173.             loss = self.loss_fn(logits, y.long()).item()
    174.             total_loss += loss
    175.             self.metric.update(logits, y)
    176.  
    177.         dev_loss = (total_loss / len(dev_loader))
    178.         self.dev_losses.append((global_step, dev_loss))
    179.         dev_score = self.metric.accumulate()
    180.         self.dev_scores.append(dev_score)
    181.         return dev_score, dev_loss
    182.  
    183.     # 模型预测阶段，
    184.     def predict(self, x, **kwargs):
    185.         self.model.eval()
    186.         logits = self.model(x)
    187.         return logits
    188.  
    189.     # 保存模型的参数
    190.     def save_model(self, save_path):
    191.         torch.save(self.model.state_dict(), save_path)
    192.  
    193.     # 读取模型的参数
    194.     def load_model(self, model_path):
    195.         self.model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
    196.  
    197.  
    198. if __name__ == '__main__':
    199.     batch_size = 20
    200.     # 构建训练集
    201.     train_data = CIFAR10Dataset('cifar10_tiny', 'trainLabels.csv')
    202.     train_iter = DataLoader(train_data, batch_size=batch_size)
    203.     # 构建测试集
    204.     test_data = CIFAR10Dataset('cifar10_tiny', 'trainLabels.csv')
    205.     test_iter = DataLoader(test_data, batch_size=batch_size)
    206.  
    207.     # 模型训练
    208.     num_classes = 10
    209.     # 定义模型
    210.     model = VGG_S(num_classes)
    211.     # 定义损失函数
    212.     loss_fn = F.cross_entropy
    213.     # 定义优化器
    214.     optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
    215.  
    216.     runner = Runner(model, optimizer, loss_fn, metric=None)
    217.     runner.train(train_iter, num_epochs=10, save_path='chapter_5')
    218.  
    219.     # 模型预测
    220.     runner.load_model('chapter_5.pth')
    221.     x, label = next(iter(test_iter))
    222.     predict = torch.argmax(runner.predict(x.float()), dim=1)
    223.     print('predict:', predict)
    224.     print('  label:', label)
    225.  
    226.

  • 相关阅读:
    有什么好用的站内搜索SaaS能帮网站实现站内搜索功能？
    优雅而高效的JavaScript——扩展运算符
    【C++】笔试训练（四）
    [Python急救站]基于Transformer Models模型完成GPT2的学生AIGC学习训练模型
    Python计算均值、方差、标准差、协方差等常用指标的方法——Numpy模块+Pandas模块
    【探索C++】C++对C语言的扩展
    信息学奥赛一本通：1102：与指定数字相同的数的个数
    大部分人都缺乏一种特质
    linux快捷操作方式
    阿里云&腾讯云服务器安装oracle11g
  • 原文地址：https://blog.csdn.net/m0_63834988/article/details/133393522