• 第P7周—咖啡豆识别（1）

     数据集及wen件目录介绍：

    数据集：工作台 - Heywhale.com

    一、前期工作

    1.1 数据详情

    1. import torch
    2. import torch.nn as nn
    3. import torchvision.transforms as transforms
    4. import torchvision
    5. from torchvision import transforms, datasets
    6. import os,PIL,pathlib,warnings
    7.  
    8. warnings.filterwarnings("ignore")             #忽略警告信息
    9.  
    10. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    11. print(device)
    12.  
    13. import os,PIL,random,pathlib
    14.  
    15. data_dir = 'D:/P7/49-data/'
    16. data_dir = pathlib.Path(data_dir)
    17.  
    18. data_paths  = list(data_dir.glob('*'))
    19. classeNames = [str(path).split("\\")[3] for path in data_paths]
    20. print(classeNames)
    21.  
    22. image_count = len(list(data_dir.glob('*/*.png')))
    23.  
    24. print("图片总数为：",image_count)

    1.2 图片预处理： 

    详见：写文章-CSDN创作中心icon-default.png?t=N7T8https://mp.csdn.net/mp_blog/creation/editor/133411331

    1. train_transforms = transforms.Compose([
    2.     transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    3.     # transforms.RandomHorizontalFlip(), # 随机水平翻转
    4.     transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    5.     transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
    6.         mean=[0.485, 0.456, 0.406], 
    7.         std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    8. ])
    9.  
    10. test_transform = transforms.Compose([
    11.     transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    12.     transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    13.     transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
    14.         mean=[0.485, 0.456, 0.406], 
    15.         std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    16. ])
    17.  
    18. total_data = datasets.ImageFolder("D:/P7/49-data",transform=train_transforms)
    19. print(total_data)

     标签量化处理：

    print(total_data.class_to_idx)

    1.4 划分数据集

    1. train_size = int(0.8 * len(total_data))
    2. test_size  = len(total_data) - train_size
    3. train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
    4. print(train_dataset, test_dataset)

    二、搭建VGG—16模型 

    2.1 搭建VGG模型

    1. import torch.nn.functional as F
    2.  
    3. class vgg16(nn.Module):
    4.     def __init__(self):
    5.         super(vgg16, self).__init__()
    6.         # 卷积块1
    7.         self.block1 = nn.Sequential(
    8.             nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    9.             nn.ReLU(),
    10.             nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    11.             nn.ReLU(),
    12.             nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    13.         )
    14.         # 卷积块2
    15.         self.block2 = nn.Sequential(
    16.             nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    17.             nn.ReLU(),
    18.             nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    19.             nn.ReLU(),
    20.             nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    21.         )
    22.         # 卷积块3
    23.         self.block3 = nn.Sequential(
    24.             nn.Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    25.             nn.ReLU(),
    26.             nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    27.             nn.ReLU(),
    28.             nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    29.             nn.ReLU(),
    30.             nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    31.         )
    32.         # 卷积块4
    33.         self.block4 = nn.Sequential(
    34.             nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    35.             nn.ReLU(),
    36.             nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    37.             nn.ReLU(),
    38.             nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    39.             nn.ReLU(),
    40.             nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    41.         )
    42.         # 卷积块5
    43.         self.block5 = nn.Sequential(
    44.             nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    45.             nn.ReLU(),
    46.             nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    47.             nn.ReLU(),
    48.             nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    49.             nn.ReLU(),
    50.             nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    51.         )
    52.         
    53.         # 全连接网络层，用于分类
    54.         self.classifier = nn.Sequential(
    55.             nn.Linear(in_features=512*7*7, out_features=4096),
    56.             nn.ReLU(),
    57.             nn.Linear(in_features=4096, out_features=4096),
    58.             nn.ReLU(),
    59.             nn.Linear(in_features=4096, out_features=4)
    60.         )
    61.  
    62.     def forward(self, x):
    63.  
    64.         x = self.block1(x)
    65.         x = self.block2(x)
    66.         x = self.block3(x)
    67.         x = self.block4(x)
    68.         x = self.block5(x)
    69.         x = torch.flatten(x, start_dim=1)
    70.         x = self.classifier(x)
    71.  
    72.         return x
    73.  
    74. device = "cuda" if torch.cuda.is_available() else "cpu"
    75. print("Using {} device".format(device))
    76.     
    77. model = vgg16().to(device)
    78. print(model)

                    

    2.2 模型信息 

     

    三、模型训练

    3.1 编写训练函数

    1. # 训练循环
    2. def train(dataloader, model, loss_fn, optimizer):
    3.     size = len(dataloader.dataset)  # 训练集的大小
    4.     num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)
    5.  
    6.     train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    7.     
    8.     for X, y in dataloader:  # 获取图片及其标签
    9.         X, y = X.to(device), y.to(device)
    10.         
    11.         # 计算预测误差
    12.         pred = model(X)          # 网络输出
    13.         loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
    14.         
    15.         # 反向传播
    16.         optimizer.zero_grad()  # grad属性归零
    17.         loss.backward()        # 反向传播
    18.         optimizer.step()       # 每一步自动更新
    19.         
    20.         # 记录acc与loss
    21.         train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
    22.         train_loss += loss.item()
    23.             
    24.     train_acc  /= size
    25.     train_loss /= num_batches
    26.  
    27.     return train_acc, train_loss

    3.2  编写测试函数

    1. def test (dataloader, model, loss_fn):
    2.     size        = len(dataloader.dataset)  # 测试集的大小
    3.     num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    4.     test_loss, test_acc = 0, 0
    5.     
    6.     # 当不进行训练时，停止梯度更新，节省计算内存消耗
    7.     with torch.no_grad():
    8.         for imgs, target in dataloader:
    9.             imgs, target = imgs.to(device), target.to(device)
    10.             
    11.             # 计算loss
    12.             target_pred = model(imgs)
    13.             loss        = loss_fn(target_pred, target)
    14.             
    15.             test_loss += loss.item()
    16.             test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()
    17.  
    18.     test_acc  /= size
    19.     test_loss /= num_batches
    20.  
    21.     return test_acc, test_loss

    3.3 模型训练 （完整代码）

    1. import torch
    2. import torch.nn as nn
    3. import torchvision.transforms as transforms
    4. from torchvision import datasets
    5. import pathlib
    6. import warnings
    7.  
    8. warnings.filterwarnings("ignore")
    9.  
    10. def main():
    11.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    12.     print(device)
    13.  
    14.     data_dir = 'D:/P7/49-data/'
    15.     data_dir = pathlib.Path(data_dir)
    16.  
    17.     data_paths = list(data_dir.glob('*'))
    18.     classeNames = [str(path).split("\\")[3] for path in data_paths]
    19.     print(classeNames)
    20.  
    21.     image_count = len(list(data_dir.glob('*/*.png')))
    22.  
    23.     print("图片总数为：", image_count)
    24.  
    25.     train_transforms = transforms.Compose([
    26.         transforms.Resize([224, 224]),
    27.         transforms.ToTensor(),
    28.         transforms.Normalize(
    29.             mean=[0.485, 0.456, 0.406],
    30.             std=[0.229, 0.224, 0.225])
    31.     ])
    32.  
    33.     test_transform = transforms.Compose([
    34.         transforms.Resize([224, 224]),
    35.         transforms.ToTensor(),
    36.         transforms.Normalize(
    37.             mean=[0.485, 0.456, 0.406],
    38.             std=[0.229, 0.224, 0.225])
    39.     ])
    40.  
    41.     total_data = datasets.ImageFolder("D:/P7/49-data", transform=train_transforms)
    42.     print(total_data)
    43.  
    44.     train_size = int(0.8 * len(total_data))
    45.     test_size = len(total_data) - train_size
    46.     train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
    47.     print(train_dataset, test_dataset)
    48.  
    49.     batch_size = 32
    50.  
    51.     train_dl = torch.utils.data.DataLoader(train_dataset,
    52.                                            batch_size=batch_size,
    53.                                            shuffle=True,
    54.                                            num_workers=1)
    55.     test_dl = torch.utils.data.DataLoader(test_dataset,
    56.                                           batch_size=batch_size,
    57.                                           shuffle=True,
    58.                                           num_workers=1)
    59.  
    60.     class VGG16Lite(nn.Module):
    61.         def __init__(self, num_classes=4):
    62.             super(VGG16Lite, self).__init__()
    63.             self.features = nn.Sequential(
    64.                 nn.Conv2d(3, 64, kernel_size=3, padding=1),
    65.                 nn.ReLU(inplace=True),
    66.                 nn.MaxPool2d(kernel_size=2, stride=2),
    67.                 nn.Conv2d(64, 128, kernel_size=3, padding=1),
    68.                 nn.ReLU(inplace=True),
    69.                 nn.MaxPool2d(kernel_size=2, stride=2),
    70.                 nn.Conv2d(128, 256, kernel_size=3, padding=1),
    71.                 nn.ReLU(inplace=True),
    72.                 nn.Conv2d(256, 256, kernel_size=3, padding=1),
    73.                 nn.ReLU(inplace=True),
    74.                 nn.MaxPool2d(kernel_size=2, stride=2),
    75.             )
    76.             self.classifier = nn.Sequential(
    77.                 nn.Linear(256 * 28 * 28, 4096),
    78.                 nn.ReLU(inplace=True),
    79.                 nn.Dropout(),
    80.                 nn.Linear(4096, 4096),
    81.                 nn.ReLU(inplace=True),
    82.                 nn.Dropout(),
    83.                 nn.Linear(4096, num_classes),
    84.             )
    85.  
    86.         def forward(self, x):
    87.             x = self.features(x)
    88.             x = x.view(x.size(0), -1)
    89.             x = self.classifier(x)
    90.             return x
    91.  
    92.     device = "cuda" if torch.cuda.is_available() else "cpu"
    93.     print("Using {} device".format(device))
    94.  
    95.     model = VGG16Lite().to(device)
    96.     print(model)
    97.  
    98.     import torch.optim as optim
    99.  
    100.     optimizer = optim.Adam(model.parameters(), lr=1e-4)
    101.     loss_fn = nn.CrossEntropyLoss()
    102.  
    103.     epochs = 40
    104.  
    105.     train_loss = []
    106.     train_acc = []
    107.     test_loss = []
    108.     test_acc = []
    109.  
    110.     best_acc = 0
    111.     best_model = None
    112.  
    113.     for epoch in range(epochs):
    114.         model.train()
    115.         epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    116.  
    117.         model.eval()
    118.         epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    119.  
    120.         if epoch_test_acc > best_acc:
    121.             best_acc = epoch_test_acc
    122.             best_model = model.state_dict()
    123.  
    124.         train_acc.append(epoch_train_acc)
    125.         train_loss.append(epoch_train_loss)
    126.         test_acc.append(epoch_test_acc)
    127.         test_loss.append(epoch_test_loss)
    128.  
    129.         lr = optimizer.param_groups[0]['lr']
    130.  
    131.         template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    132.         print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss,
    133.                               epoch_test_acc * 100, epoch_test_loss, lr))
    134.  
    135.     PATH = './best_model_lite.pth'
    136.     torch.save(best_model, PATH)
    137.  
    138.     print('Done')
    139.  
    140. if __name__ == '__main__':
    141.     main()

     3.4 轻量化上述VGG16模型

    1. import torch
    2. import torch.nn as nn
    3. import torchvision.transforms as transforms
    4. import torchvision
    5. from torchvision import transforms, datasets
    6. import os,PIL,pathlib,warnings
    7.  
    8. warnings.filterwarnings("ignore")             #忽略警告信息
    9.  
    10. def main():
    11.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    12.     print(device)
    13.  
    14.     import os,PIL,random,pathlib
    15.  
    16.     data_dir = 'D:/P7/49-data/'
    17.     data_dir = pathlib.Path(data_dir)
    18.  
    19.     data_paths  = list(data_dir.glob('*'))
    20.     classeNames = [str(path).split("\\")[3] for path in data_paths]
    21.     print(classeNames)
    22.  
    23.     image_count = len(list(data_dir.glob('*/*.png')))
    24.  
    25.     print("图片总数为：",image_count)
    26.  
    27.  
    28.     train_transforms = transforms.Compose([
    29.         transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    30.         # transforms.RandomHorizontalFlip(), # 随机水平翻转
    31.         transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    32.         transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
    33.             mean=[0.485, 0.456, 0.406], 
    34.             std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    35.     ])
    36.  
    37.     test_transform = transforms.Compose([
    38.         transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    39.         transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    40.         transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
    41.             mean=[0.485, 0.456, 0.406], 
    42.             std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    43.     ])
    44.  
    45.     total_data = datasets.ImageFolder("D:/P7/49-data",transform=train_transforms)
    46.     print(total_data)
    47.  
    48.     print(total_data.class_to_idx)
    49.  
    50.     train_size = int(0.8 * len(total_data))
    51.     test_size  = len(total_data) - train_size
    52.     train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
    53.     print(train_dataset, test_dataset)
    54.  
    55.     batch_size = 32
    56.  
    57.     train_dl = torch.utils.data.DataLoader(train_dataset,
    58.                                             batch_size=batch_size,
    59.                                             shuffle=True,
    60.                                             num_workers=1)
    61.     test_dl = torch.utils.data.DataLoader(test_dataset,
    62.                                             batch_size=batch_size,
    63.                                             shuffle=True,
    64.                                             num_workers=1)
    65.  
    66.     import torch.nn.functional as F
    67.  
    68.     class vgg16(nn.Module):
    69.         def __init__(self):
    70.             super(vgg16, self).__init__()
    71.             # 卷积块1
    72.             self.block1 = nn.Sequential(
    73.                 nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    74.                 nn.ReLU(),
    75.                 nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    76.                 nn.ReLU(),
    77.                 nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    78.             )
    79.             # 卷积块2
    80.             self.block2 = nn.Sequential(
    81.                 nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    82.                 nn.ReLU(),
    83.                 nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    84.                 nn.ReLU(),
    85.                 nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    86.             )
    87.             # 卷积块3
    88.             self.block3 = nn.Sequential(
    89.                 nn.Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    90.                 nn.ReLU(),
    91.                 nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    92.                 nn.ReLU(),
    93.                 nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    94.                 nn.ReLU(),
    95.                 nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    96.             )
    97.             # 卷积块4
    98.             self.block4 = nn.Sequential(
    99.                 nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    100.                 nn.ReLU(),
    101.                 nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    102.                 nn.ReLU(),
    103.                 nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    104.                 nn.ReLU(),
    105.                 nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    106.             )
    107.             # 卷积块5
    108.             self.block5 = nn.Sequential(
    109.                 nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    110.                 nn.ReLU(),
    111.                 nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    112.                 nn.ReLU(),
    113.                 nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
    114.                 nn.ReLU(),
    115.                 nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
    116.             )
    117.             
    118.             # 全连接网络层，用于分类
    119.             self.classifier = nn.Sequential(
    120.                 nn.Linear(in_features=512*7*7, out_features=4096),
    121.                 nn.ReLU(),
    122.                 nn.Linear(in_features=4096, out_features=4096),
    123.                 nn.ReLU(),
    124.                 nn.Linear(in_features=4096, out_features=4)
    125.             )
    126.  
    127.         def forward(self, x):
    128.  
    129.             x = self.block1(x)
    130.             x = self.block2(x)
    131.             x = self.block3(x)
    132.             x = self.block4(x)
    133.             x = self.block5(x)
    134.             x = torch.flatten(x, start_dim=1)
    135.             x = self.classifier(x)
    136.  
    137.             return x
    138.  
    139.     device = "cuda" if torch.cuda.is_available() else "cpu"
    140.     print("Using {} device".format(device))
    141.         
    142.     model = vgg16().to(device)
    143.     print(model)
    144.  
    145.     # 统计模型参数量以及其他指标
    146.     import torchsummary as summary
    147.     summary.summary(model, (3, 224, 224))
    148.  
    149.     # 训练循环
    150.     def train(dataloader, model, loss_fn, optimizer):
    151.         size = len(dataloader.dataset)  # 训练集的大小
    152.         num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)
    153.  
    154.         train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    155.         
    156.         for X, y in dataloader:  # 获取图片及其标签
    157.             X, y = X.to(device), y.to(device)
    158.             
    159.             # 计算预测误差
    160.             pred = model(X)          # 网络输出
    161.             loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
    162.             
    163.             # 反向传播
    164.             optimizer.zero_grad()  # grad属性归零
    165.             loss.backward()        # 反向传播
    166.             optimizer.step()       # 每一步自动更新
    167.             
    168.             # 记录acc与loss
    169.             train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
    170.             train_loss += loss.item()
    171.                 
    172.         train_acc  /= size
    173.         train_loss /= num_batches
    174.  
    175.         return train_acc, train_loss
    176.  
    177.     def test (dataloader, model, loss_fn):
    178.         size        = len(dataloader.dataset)  # 测试集的大小
    179.         num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    180.         test_loss, test_acc = 0, 0
    181.         
    182.         # 当不进行训练时，停止梯度更新，节省计算内存消耗
    183.         with torch.no_grad():
    184.             for imgs, target in dataloader:
    185.                 imgs, target = imgs.to(device), target.to(device)
    186.                 
    187.                 # 计算loss
    188.                 target_pred = model(imgs)
    189.                 loss        = loss_fn(target_pred, target)
    190.                 
    191.                 test_loss += loss.item()
    192.                 test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()
    193.  
    194.         test_acc  /= size
    195.         test_loss /= num_batches
    196.  
    197.         return test_acc, test_loss
    198.  
    199.     import copy
    200.  
    201.     optimizer  = torch.optim.Adam(model.parameters(), lr= 1e-4)
    202.     loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
    203.  
    204.     epochs     = 40
    205.  
    206.     train_loss = []
    207.     train_acc  = []
    208.     test_loss  = []
    209.     test_acc   = []
    210.  
    211.     best_acc = 0    # 设置一个最佳准确率，作为最佳模型的判别指标
    212.  
    213.     for epoch in range(epochs):
    214.         
    215.         model.train()
    216.         epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    217.         
    218.         model.eval()
    219.         epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    220.         
    221.         # 保存最佳模型到 best_model
    222.         if epoch_test_acc > best_acc:
    223.             best_acc   = epoch_test_acc
    224.             best_model = copy.deepcopy(model)
    225.         
    226.         train_acc.append(epoch_train_acc)
    227.         train_loss.append(epoch_train_loss)
    228.         test_acc.append(epoch_test_acc)
    229.         test_loss.append(epoch_test_loss)
    230.         
    231.         # 获取当前的学习率
    232.         lr = optimizer.state_dict()['param_groups'][0]['lr']
    233.         
    234.         template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    235.         print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, 
    236.                             epoch_test_acc*100, epoch_test_loss, lr))
    237.         
    238.     # 保存最佳模型到文件中
    239.     PATH = './best_model.pth'  # 保存的参数文件名
    240.     torch.save(model.state_dict(), PATH)
    241.  
    242.     print('Done')   
    243.  
    244. if __name__ == '__main__':
    245.     main()

     

  • 相关阅读:
    R包的尽头是 C/C++
    数据赋能（121）——体系：数据清洗——实施过程、应用特点
    合肥工业大学计算机网络课设-在线留言板
    多端统一开发框架Taro、UniApp和WeApp这三个应用各自在前端开发领域有着独特的定位和功能
    Node.js 应用开发详解14 工具应用：使用 clinicj 工具实现通用性安全检查
    轻量封装WebGPU渲染系统示例＜1＞-彩色三角形(源码)
    第6章 Elasticsearch，分布式搜索引擎
    【迁移ORACLE数据到MogDB/openGauss时的字符集问题】
    树莓派 RaspBerryPi 网络配置相关与改造usb网络摄像头
    基于ssm+vue的美食分享网站
  • 原文地址：https://blog.csdn.net/qq_60245590/article/details/133411047