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

  • 相关阅读:
    熵增定律与软件的熵
    一个由于全局变量造成express路由重复堆叠的问题案例
    视频融合平台EasyCVR语音播报功能无法关闭，且告警信息与其需要警告的内容不匹配该如何解决？
    BGP服务器
    强化学习与视觉语言模型之间的碰撞，UC伯克利提出语言奖励调节LAMP框架
    Linux入门学习20
    初探CSS 上
    MYSQL安装
    【API接口功能】以图搜款，最快1秒助您找到想要的商品！
    小程序页面跳转
  • 原文地址：https://blog.csdn.net/qq_60245590/article/details/133220885