• 第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()

     

  • 相关阅读:
    实现双向链表的增删查改
    智慧工地管理系统源码（电脑端+手机端+APP+SAAS云平台）
    计算机毕业设计ssm基于协同过滤推荐算法的新闻推荐系统43149系统+程序+源码+lw+远程部署
    Orange Pi i96 入手填坑问题总结
    我是怎么设计一个消息推送接口的？
    Spring Boot-2.3.7.RELEASE整合activiti-6.0示例步骤
    【计算机网络】OSI七层网络参考模型
    C/C++数据结构——树的同构（二叉树）
    Python第二次作业（4）【矩形面积与周长】
    kafka伪集群部署，使用zookeeper模式
  • 原文地址：https://blog.csdn.net/qq_60245590/article/details/133411047