• 第P6周—好莱坞明星识别（2）

    五、模型训练

    1. # 训练循环
    2.     def train(dataloader, model, loss_fn, optimizer):
    3.         size = len(dataloader.dataset)  # 训练集的大小
    4.         num_batches = len(dataloader)   # 批次数目
    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
    28.  
    29.     # 测试函数
    30.     def test(dataloader, model, loss_fn):
    31.         size        = len(dataloader.dataset)  # 测试集的大小
    32.         num_batches = len(dataloader)          # 批次数目，(size/batch_size，向上取整)
    33.         test_loss, test_acc = 0, 0
    34.  
    35.         # 当不进行训练时，停止梯度更新，节省计算内存消耗
    36.         with torch.no_grad():
    37.             for imgs, target in dataloader:
    38.                 imgs, target = imgs.to(device), target.to(device)
    39.  
    40.                 # 计算loss
    41.                 target_pred = model(imgs)
    42.                 loss        = loss_fn(target_pred, target)
    43.  
    44.                 test_loss += loss.item()
    45.                 test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()
    46.  
    47.         test_acc  /= size
    48.         test_loss /= num_batches
    49.  
    50.         return test_acc, test_loss
    51.  
    52.     ''' 自定义设置动态学习率 '''
    53.     def adjust_learning_rate(optimizer, epoch, start_lr):
    54.         # 每 2 个epoch衰减到原来的 0.92
    55.         lr = start_lr * (0.92 ** (epoch // 2))
    56.         for param_group in optimizer.param_groups:
    57.             param_group['lr'] = lr
    58.  
    59.     # 设置初始学习率
    60.     learn_rate = 1e-4
    61.     optimizer  = torch.optim.SGD(model.parameters(), lr=learn_rate)
    62.  
    63.     # 定义学习率调整函数
    64.     lambda1 = lambda epoch: 0.92 ** (epoch // 4)
    65.     scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)  # 选定调整方法
    66.  
    67.     # 定义损失函数
    68.     loss_fn = nn.CrossEntropyLoss()
    69.  
    70.     # 定义训练参数
    71.     epochs = 40
    72.     train_loss = []
    73.     train_acc = []
    74.     test_loss = []
    75.     test_acc = []
    76.  
    77.     best_acc = 0  # 用于保存最佳模型的准确率
    78.  
    79.     for epoch in range(epochs):
    80.         model.train()
    81.         epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    82.         scheduler.step()  # 更新学习率（调用官方动态学习率接口时使用）
    83.  
    84.         model.eval()
    85.         epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    86.     
    87.         # 保存最佳模型到best model
    88.         if epoch_test_acc > best_acc:
    89.             best_acc = epoch_test_acc
    90.             best_model = copy.deepcopy(model)
    91.  
    92.         train_acc.append(epoch_train_acc)
    93.         train_loss.append(epoch_train_loss)
    94.         test_acc.append(epoch_test_acc)
    95.         test_loss.append(epoch_test_loss)
    96.  
    97.         # 获取当前的学习率
    98.         lr = optimizer.state_dict()['param_groups'][0]['lr']
    99.  
    100.         template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, lr:{:.2E}')
    101.         print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss, lr))
    102.  
    103.     # 保存最佳模型到文件中
    104.     PATH = './best_model.pth'  # 保存的参数文件名
    105.     torch.save(best_model.state_dict(), PATH)
    106.  
    107.     print('Done')

    在非实时编译器中运行出现Python 脚本中使用多进程相关问题报错，问题通常发生在没有正确使用 if __name__ == '__main__': 块的情况下。为了解决这个问题，我将完整代码修改如下：

    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, random, pathlib, warnings
    7. import copy
    8.  
    9. warnings.filterwarnings("ignore")
    10.  
    11. def main():
    12.     # 您的现有代码放在这里
    13.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    14.  
    15.     print(device)
    16.  
    17.     import os, PIL, random, pathlib
    18.  
    19.     data_dir = 'D:/P6/48-data/'
    20.     data_dir = pathlib.Path(data_dir)
    21.  
    22.     data_path = list(data_dir.glob('*'))
    23.     print(data_path)
    24.     classname = [str(path).split("\\")[3] for path in data_path]
    25.     print(classname)
    26.  
    27.     train_transforms = transforms.Compose([
    28.         transforms.Resize([224, 224]),
    29.         transforms.ToTensor(),
    30.         transforms.Normalize(
    31.             mean=[0.39354826, 0.41713402, 0.48036146],
    32.             std=[0.25076334, 0.25809455, 0.28359835]
    33.         )
    34.     ])
    35.  
    36.     total_data = datasets.ImageFolder("D:/P6/48-data/", transform=train_transforms)
    37.     print(total_data)
    38.  
    39.     print(total_data.class_to_idx)
    40.  
    41.     train_size = int(0.8 * len(total_data))
    42.     test_size = len(total_data) - train_size
    43.     train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
    44.     print(train_dataset, test_dataset)
    45.  
    46.     batch_size = 32
    47.     train_dl = torch.utils.data.DataLoader(train_dataset,
    48.                                        batch_size=batch_size,
    49.                                        shuffle=True,
    50.                                        num_workers=1)
    51.  
    52.     test_dl = torch.utils.data.DataLoader(test_dataset,
    53.                                       batch_size=batch_size,
    54.                                       shuffle=True,
    55.                                       num_workers=1)
    56.  
    57.     from torchvision.models import vgg16
    58.  
    59.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    60.     print("Using {} device\n".format(device))
    61.  
    62.     ''' 调用官方的VGG-16模型 '''
    63.     # 加载预训练模型，并且对模型进行微调
    64.     model = vgg16(pretrained=True).to(device)  # 加载预训练的vgg16模型
    65.     for param in model.parameters():
    66.         param.requires_grad = False  # 冻结模型的参数，这样子在训练的时候只训练最后一层的参数
    67.     # 修改classifier模块的第6层（即：(6): Linear(in_features=4096, out_features=2, bias=True)）
    68.     # 注意查看我们下方打印出来的模型
    69.     model.classifier._modules['6'] = nn.Linear(4096, 17)  # 修改vgg16模型中最后一层全连接层，输出目标类别个数
    70.     model.to(device)
    71.  
    72.     print(model)
    73.  
    74.     # 训练循环
    75.     def train(dataloader, model, loss_fn, optimizer):
    76.         size = len(dataloader.dataset)  # 训练集的大小
    77.         num_batches = len(dataloader)   # 批次数目
    78.  
    79.         train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    80.  
    81.         for X, y in dataloader:  # 获取图片及其标签
    82.             X, y = X.to(device), y.to(device)
    83.  
    84.             # 计算预测误差
    85.             pred = model(X)          # 网络输出
    86.             loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
    87.  
    88.             # 反向传播
    89.             optimizer.zero_grad()  # grad属性归零
    90.             loss.backward()        # 反向传播
    91.             optimizer.step()       # 每一步自动更新
    92.  
    93.             # 记录acc与loss
    94.             train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
    95.             train_loss += loss.item()
    96.  
    97.         train_acc  /= size
    98.         train_loss /= num_batches
    99.  
    100.         return train_acc, train_loss
    101.  
    102.     # 测试函数
    103.     def test(dataloader, model, loss_fn):
    104.         size        = len(dataloader.dataset)  # 测试集的大小
    105.         num_batches = len(dataloader)          # 批次数目，(size/batch_size，向上取整)
    106.         test_loss, test_acc = 0, 0
    107.  
    108.         # 当不进行训练时，停止梯度更新，节省计算内存消耗
    109.         with torch.no_grad():
    110.             for imgs, target in dataloader:
    111.                 imgs, target = imgs.to(device), target.to(device)
    112.  
    113.                 # 计算loss
    114.                 target_pred = model(imgs)
    115.                 loss        = loss_fn(target_pred, target)
    116.  
    117.                 test_loss += loss.item()
    118.                 test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()
    119.  
    120.         test_acc  /= size
    121.         test_loss /= num_batches
    122.  
    123.         return test_acc, test_loss
    124.  
    125.     ''' 自定义设置动态学习率 '''
    126.     def adjust_learning_rate(optimizer, epoch, start_lr):
    127.         # 每 2 个epoch衰减到原来的 0.92
    128.         lr = start_lr * (0.92 ** (epoch // 2))
    129.         for param_group in optimizer.param_groups:
    130.             param_group['lr'] = lr
    131.  
    132.     # 设置初始学习率
    133.     learn_rate = 1e-4
    134.     optimizer  = torch.optim.SGD(model.parameters(), lr=learn_rate)
    135.  
    136.     # 定义学习率调整函数
    137.     lambda1 = lambda epoch: 0.92 ** (epoch // 4)
    138.     scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)  # 选定调整方法
    139.  
    140.     # 定义损失函数
    141.     loss_fn = nn.CrossEntropyLoss()
    142.  
    143.     # 定义训练参数
    144.     epochs = 40
    145.     train_loss = []
    146.     train_acc = []
    147.     test_loss = []
    148.     test_acc = []
    149.  
    150.     best_acc = 0  # 用于保存最佳模型的准确率
    151.  
    152.     for epoch in range(epochs):
    153.         model.train()
    154.         epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    155.         scheduler.step()  # 更新学习率（调用官方动态学习率接口时使用）
    156.  
    157.         model.eval()
    158.         epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    159.     
    160.         # 保存最佳模型到best model
    161.         if epoch_test_acc > best_acc:
    162.             best_acc = epoch_test_acc
    163.             best_model = copy.deepcopy(model)
    164.  
    165.         train_acc.append(epoch_train_acc)
    166.         train_loss.append(epoch_train_loss)
    167.         test_acc.append(epoch_test_acc)
    168.         test_loss.append(epoch_test_loss)
    169.  
    170.         # 获取当前的学习率
    171.         lr = optimizer.state_dict()['param_groups'][0]['lr']
    172.  
    173.         template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, lr:{:.2E}')
    174.         print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss, lr))
    175.  
    176.     # 保存最佳模型到文件中
    177.     PATH = './best_model.pth'  # 保存的参数文件名
    178.     torch.save(best_model.state_dict(), PATH)
    179.  
    180.     print('Done')
    181. if __name__ == '__main__':
    182.     main()

  • 相关阅读:
    为什么生命科学企业都在陆续上云？
    零基础入门低代码后端开发，只需几行代码就可以操作数据库
    专访科杰科技CEO于洋：湖仓一体数据底座，企业构建数据能力的“最优解” | 爱分析访谈
    【教3妹学编程-java基础6】详解父子类变量、代码块、构造函数执行顺序
    开学季征文 | 一位开发实习生的真情流露
    动态尺寸模型优化实践之Shape Constraint IR Part I
    Spring基础篇：注入
    SpingBoot之替换容器为Undertow
    猿创征文｜Spring Boot 整合分布式调度框架：xxl-job
    BloomFilter：布隆过滤器和Redis缓存穿透
  • 原文地址：https://blog.csdn.net/qq_60245590/article/details/133220885