第六周--P6周：好莱坞演员识别

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings

warnings.filterwarnings("ignore")             #忽略警告信息

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

device(type='cuda')

2.导入数据并划分数据集

''' 读取本地数据集并划分训练集与测试集 '''
def localDataset(data_dir):
    data_dir = pathlib.Path(data_dir)
    
    # 读取本地数据集
    data_paths = list(data_dir.glob('*'))
    classeNames = [str(path).split("\\")[-1] for path in data_paths]
    
    # 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
    train_transforms = torchvision.transforms.Compose([
        torchvision.transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
        # torchvision.transforms.RandomHorizontalFlip(), # 随机水平翻转
        torchvision.transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
        torchvision.transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
            mean=[0.485, 0.456, 0.406], 
            std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    ])
    
    total_dataset = torchvision.datasets.ImageFolder(data_dir,transform=train_transforms)
    print(total_dataset, '\n')
    print(total_dataset.class_to_idx, '\n')
    
    # 按比例划分训练集和测试集
    train_size = int(0.8 * len(total_dataset))
    test_size  = len(total_dataset) - train_size
    print('train_size', train_size, ', test_size', test_size, '\n')
    train_dataset, test_dataset = torch.utils.data.random_split(total_dataset, [train_size, test_size])
    
    return classeNames, train_dataset, test_dataset


if __name__=='__main__':
    ''' 加载数据 '''
    root = r'F:\P6_data'
    output = r'F:\model_param\p_6_model'
    data_dir = os.path.join(root, '48-data')
    batch_size = 32
    classeNames, train_ds, test_ds = localDataset(data_dir)
    ''' 图片的类别数 '''
    num_classes = len(classeNames)
    print('num_classes', num_classes)

Dataset ImageFolder
    Number of datapoints: 1800
    Root location: F:\P6_data\48-data
    StandardTransform
Transform: Compose(
               Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=warn)
               ToTensor()
               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
           ) 

{'Angelina Jolie': 0, 'Brad Pitt': 1, 'Denzel Washington': 2, 'Hugh Jackman': 3, 'Jennifer Lawrence': 4, 'Johnny Depp': 5, 'Kate Winslet': 6, 'Leonardo DiCaprio': 7, 'Megan Fox': 8, 'Natalie Portman': 9, 'Nicole Kidman': 10, 'Robert Downey Jr': 11, 'Sandra Bullock': 12, 'Scarlett Johansson': 13, 'Tom Cruise': 14, 'Tom Hanks': 15, 'Will Smith': 16} 

train_size 1440 , test_size 360 

num_classes 17

3.加载数据

''' 加载数据，并设置batch_size '''
def LoadData(train_ds, test_ds, batch_size=32, root='', show_flag=False):
    # 从 train_ds 加载训练集
    train_dl = torch.utils.data.DataLoader(train_ds,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=1)
    # 从 test_ds 加载测试集
    test_dl  = torch.utils.data.DataLoader(test_ds,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=1)
    
    # 取一个批次查看数据格式
    # 数据的shape为：[batch_size, channel, height, weight]
    # 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
    for X, y in test_dl:
        print('Shape of X [N, C, H, W]: ', X.shape)
        print('Shape of y: ', y.shape, y.dtype, '\n')
        break
    
    imgs, labels = next(iter(train_dl))
    print('Image shape: ', imgs.shape, '\n')
    # torch.Size([32, 3, 224, 224])  # 所有数据集中的图像都是224*224的RGB图
    return train_dl, test_dl

batch_size = 32
train_dl, test_dl = LoadData(train_ds, test_ds, batch_size, root, True)

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64 

Image shape:  torch.Size([32, 3, 224, 224])

4.数据可视化

'''数据可视化'''
import matplotlib.pyplot as plt
from PIL import Image

image_folder = r"F:\P6_data\48-data\Angelina Jolie"
image_files = [f for f in os.listdir(image_folder) if f.endswith((".jpg",".png",".jpeg"))]
img_path = os.path.join(image_folder,image_files[0])
img = Image.open(img_path)
plt.imshow(img)

三、调用官方的VGG-16模型

这个模型具体结构在稍后在手写复现vgg网络中会提到，此处先按下不表

from torchvision.models import vgg16

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))
    
# 加载预训练模型，并且对模型进行微调
model = vgg16(pretrained = True).to(device) # 加载预训练的vgg16模型

for param in model.parameters():
    param.requires_grad = False # 冻结模型的参数，这样子在训练的时候只训练最后一层的参数

# 修改classifier模块的第6层（即：(6): Linear(in_features=4096, out_features=2, bias=True)）
# 注意查看我们下方打印出来的模型
model.classifier._modules['6'] = nn.Linear(4096,len(classeNames)) # 修改vgg16模型中最后一层全连接层，输出目标类别个数
model.to(device)  
model

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=17, bias=True)
  )
)

四、模型训练

1.编写训练函数

还是那三个函数optimizer.zero_grad()，loss.backward()，optimizer.step()

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    
    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新
        
        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()
            
    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

2.编写测试函数

测试函数的结构与训练函数的结构大致相同，但是不需要用梯度下降对参数进行更新

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)
            
            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

3.设置动态学习率

设置动态学习率有两种方式供参考

1.自定义设置动态学习率

''' 自定义设置动态学习率 '''
def adjust_learning_rate(optimizer, epoch, start_lr):
    # 每 2 个epoch衰减到原来的 0.92
    lr = start_lr * (0.92 ** (epoch // 2))
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr


learn_rate = 1e-4 # 初始学习率
optimizer  = torch.optim.SGD(model.parameters(), lr=learn_rate)

2.调用官方动态学习率

learn_rate = 1e-4 # 初始学习率
optimizer  = torch.optim.SGD(model.parameters(), lr=learn_rate)

# 调用官方动态学习率接口时使用
lambda1 = lambda epoch: 0.92 ** (epoch // 4)
scheduler   = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)  # 选定调整方法

4.正式训练+保存模型最佳参数

这里我用的调用官方动态学习率，因为第一次训练的时候设置的epoch是50，模型的accuracy为20%不到，所以在最后一次训练的时候直接把epochs设置成了500，但是通过训练结果发现，当模型训练到91轮以后，accuracy就停止更新了，所以后面的训练只会使得train_loss减小，发生过拟合。

import time
import copy

''' 设置超参数 '''
start_epoch = 0
epochs      = 500
learn_rate  = 0.001 # 初始学习率
loss_fn     = nn.CrossEntropyLoss()  # 创建损失函数
optimizer   = torch.optim.SGD(model.parameters(), lr=learn_rate)
#optimizer   = torch.optim.Adam(model.parameters(),lr=learn_rate)
# 调用官方动态学习率接口时使用
lambda1 = lambda epoch: 0.92 ** (epoch // 4)
scheduler   = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)  # 选定调整方法

train_loss  = []
train_acc   = []
test_loss   = []
test_acc    = []
epoch_best_acc = 0

''' 加载之前保存的模型 '''
if not os.path.exists(output) or not os.path.isdir(output):
    os.makedirs(output)
if start_epoch > 0:
    resumeFile = os.path.join(output, 'epoch'+str(start_epoch)+'.pkl')
    if not os.path.exists(resumeFile) or not os.path.isfile(resumeFile):
        start_epoch = 0
    else:
        model.load_state_dict(torch.load(resumeFile))  # 加载模型参数

''' 开始训练模型 '''
print('\nStart training...')
best_model = None
for epoch in range(start_epoch, epochs):
    # 更新学习率（使用自定义学习率时使用）
    # adjust_learning_rate(optimizer, epoch, learn_rate)
    
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    scheduler.step() # 更新学习率（调用官方动态学习率接口时使用）
    
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    # 获取当前的学习率
    lr = optimizer.state_dict()['param_groups'][0]['lr']
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(time.strftime('[%Y-%m-%d %H:%M:%S]'), template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss, lr))
    
    # 保存最佳模型
    if epoch_test_acc>epoch_best_acc:
        epoch_best_acc = epoch_test_acc
        best_model = copy.deepcopy(model)
        print(('acc = {:.1f}%, saving model to best.pkl').format(epoch_best_acc*100))
        saveFile = os.path.join(output, 'best.pkl')
        torch.save(model.state_dict(), saveFile)
print('Done\n')

Start training...
[2023-11-21 23:05:01] Epoch: 1, Train_acc:23.5%, Train_loss:2.323, Test_acc:22.2%, Test_loss:2.335, Lr:1.00E-03
acc = 22.2%, saving model to best.pkl
[2023-11-21 23:05:36] Epoch: 2, Train_acc:24.1%, Train_loss:2.250, Test_acc:23.1%, Test_loss:2.312, Lr:1.00E-03
acc = 23.1%, saving model to best.pkl
[2023-11-21 23:06:12] Epoch: 3, Train_acc:25.8%, Train_loss:2.224, Test_acc:24.7%, Test_loss:2.261, Lr:1.00E-03
acc = 24.7%, saving model to best.pkl
[2023-11-21 23:06:48] Epoch: 4, Train_acc:28.8%, Train_loss:2.166, Test_acc:26.1%, Test_loss:2.226, Lr:9.20E-04
acc = 26.1%, saving model to best.pkl
[2023-11-21 23:07:23] Epoch: 5, Train_acc:30.9%, Train_loss:2.130, Test_acc:26.9%, Test_loss:2.186, Lr:9.20E-04
acc = 26.9%, saving model to best.pkl
[2023-11-21 23:07:58] Epoch: 6, Train_acc:31.1%, Train_loss:2.101, Test_acc:29.2%, Test_loss:2.162, Lr:9.20E-04
acc = 29.2%, saving model to best.pkl
[2023-11-21 23:08:34] Epoch: 7, Train_acc:32.5%, Train_loss:2.077, Test_acc:30.8%, Test_loss:2.145, Lr:9.20E-04
acc = 30.8%, saving model to best.pkl
[2023-11-21 23:09:10] Epoch: 8, Train_acc:34.4%, Train_loss:2.029, Test_acc:30.3%, Test_loss:2.127, Lr:8.46E-04
[2023-11-21 23:09:43] Epoch: 9, Train_acc:35.1%, Train_loss:2.012, Test_acc:31.7%, Test_loss:2.145, Lr:8.46E-04
acc = 31.7%, saving model to best.pkl
[2023-11-21 23:10:18] Epoch:10, Train_acc:35.2%, Train_loss:1.989, Test_acc:32.2%, Test_loss:2.090, Lr:8.46E-04
acc = 32.2%, saving model to best.pkl
[2023-11-21 23:10:53] Epoch:11, Train_acc:35.8%, Train_loss:1.977, Test_acc:33.3%, Test_loss:2.092, Lr:8.46E-04
acc = 33.3%, saving model to best.pkl
[2023-11-21 23:11:28] Epoch:12, Train_acc:36.4%, Train_loss:1.948, Test_acc:33.1%, Test_loss:2.074, Lr:7.79E-04
[2023-11-21 23:12:01] Epoch:13, Train_acc:38.6%, Train_loss:1.932, Test_acc:33.1%, Test_loss:2.061, Lr:7.79E-04
[2023-11-21 23:12:35] Epoch:14, Train_acc:37.7%, Train_loss:1.912, Test_acc:34.2%, Test_loss:2.066, Lr:7.79E-04
acc = 34.2%, saving model to best.pkl
[2023-11-21 23:13:10] Epoch:15, Train_acc:36.3%, Train_loss:1.908, Test_acc:32.8%, Test_loss:2.045, Lr:7.79E-04
[2023-11-21 23:13:43] Epoch:16, Train_acc:37.8%, Train_loss:1.885, Test_acc:33.6%, Test_loss:2.040, Lr:7.16E-04
[2023-11-21 23:14:16] Epoch:17, Train_acc:39.0%, Train_loss:1.874, Test_acc:33.9%, Test_loss:2.029, Lr:7.16E-04
[2023-11-21 23:14:49] Epoch:18, Train_acc:39.9%, Train_loss:1.856, Test_acc:34.4%, Test_loss:2.031, Lr:7.16E-04
acc = 34.4%, saving model to best.pkl
[2023-11-21 23:15:25] Epoch:19, Train_acc:39.6%, Train_loss:1.841, Test_acc:34.4%, Test_loss:2.019, Lr:7.16E-04
[2023-11-21 23:15:58] Epoch:20, Train_acc:39.6%, Train_loss:1.829, Test_acc:34.2%, Test_loss:1.989, Lr:6.59E-04
[2023-11-21 23:16:31] Epoch:21, Train_acc:40.9%, Train_loss:1.826, Test_acc:34.4%, Test_loss:1.995, Lr:6.59E-04
[2023-11-21 23:17:04] Epoch:22, Train_acc:42.5%, Train_loss:1.801, Test_acc:35.6%, Test_loss:2.006, Lr:6.59E-04
acc = 35.6%, saving model to best.pkl
[2023-11-21 23:17:39] Epoch:23, Train_acc:41.1%, Train_loss:1.800, Test_acc:35.8%, Test_loss:1.994, Lr:6.59E-04
acc = 35.8%, saving model to best.pkl
[2023-11-21 23:18:15] Epoch:24, Train_acc:42.1%, Train_loss:1.791, Test_acc:35.3%, Test_loss:1.972, Lr:6.06E-04
[2023-11-21 23:18:48] Epoch:25, Train_acc:42.4%, Train_loss:1.769, Test_acc:34.4%, Test_loss:1.955, Lr:6.06E-04
[2023-11-21 23:19:21] Epoch:26, Train_acc:43.3%, Train_loss:1.766, Test_acc:34.7%, Test_loss:1.967, Lr:6.06E-04
[2023-11-21 23:19:54] Epoch:27, Train_acc:41.9%, Train_loss:1.779, Test_acc:35.0%, Test_loss:1.948, Lr:6.06E-04
[2023-11-21 23:20:27] Epoch:28, Train_acc:43.2%, Train_loss:1.751, Test_acc:33.6%, Test_loss:1.954, Lr:5.58E-04
[2023-11-21 23:21:00] Epoch:29, Train_acc:44.0%, Train_loss:1.760, Test_acc:34.7%, Test_loss:1.967, Lr:5.58E-04
[2023-11-21 23:21:33] Epoch:30, Train_acc:45.3%, Train_loss:1.724, Test_acc:35.6%, Test_loss:1.961, Lr:5.58E-04
[2023-11-21 23:22:07] Epoch:31, Train_acc:45.6%, Train_loss:1.734, Test_acc:34.4%, Test_loss:1.953, Lr:5.58E-04
[2023-11-21 23:22:40] Epoch:32, Train_acc:44.7%, Train_loss:1.732, Test_acc:35.0%, Test_loss:1.954, Lr:5.13E-04
[2023-11-21 23:23:13] Epoch:33, Train_acc:43.6%, Train_loss:1.732, Test_acc:35.0%, Test_loss:1.900, Lr:5.13E-04
[2023-11-21 23:23:46] Epoch:34, Train_acc:45.1%, Train_loss:1.707, Test_acc:35.0%, Test_loss:1.937, Lr:5.13E-04
[2023-11-21 23:24:19] Epoch:35, Train_acc:45.4%, Train_loss:1.709, Test_acc:36.4%, Test_loss:1.926, Lr:5.13E-04
acc = 36.4%, saving model to best.pkl
[2023-11-21 23:24:54] Epoch:36, Train_acc:44.3%, Train_loss:1.712, Test_acc:35.3%, Test_loss:1.911, Lr:4.72E-04
[2023-11-21 23:25:27] Epoch:37, Train_acc:47.8%, Train_loss:1.663, Test_acc:35.3%, Test_loss:1.912, Lr:4.72E-04
[2023-11-21 23:26:01] Epoch:38, Train_acc:45.2%, Train_loss:1.694, Test_acc:34.7%, Test_loss:1.920, Lr:4.72E-04
[2023-11-21 23:26:34] Epoch:39, Train_acc:47.3%, Train_loss:1.674, Test_acc:35.6%, Test_loss:1.928, Lr:4.72E-04
[2023-11-21 23:27:07] Epoch:40, Train_acc:46.4%, Train_loss:1.678, Test_acc:35.0%, Test_loss:1.907, Lr:4.34E-04
[2023-11-21 23:27:40] Epoch:41, Train_acc:48.2%, Train_loss:1.658, Test_acc:35.0%, Test_loss:1.927, Lr:4.34E-04
[2023-11-21 23:28:13] Epoch:42, Train_acc:45.3%, Train_loss:1.679, Test_acc:35.0%, Test_loss:1.902, Lr:4.34E-04
[2023-11-21 23:28:46] Epoch:43, Train_acc:45.4%, Train_loss:1.677, Test_acc:35.8%, Test_loss:1.921, Lr:4.34E-04
[2023-11-21 23:29:19] Epoch:44, Train_acc:46.8%, Train_loss:1.665, Test_acc:35.3%, Test_loss:1.900, Lr:4.00E-04
[2023-11-21 23:29:53] Epoch:45, Train_acc:47.4%, Train_loss:1.649, Test_acc:35.3%, Test_loss:1.947, Lr:4.00E-04
[2023-11-21 23:30:26] Epoch:46, Train_acc:46.2%, Train_loss:1.656, Test_acc:35.6%, Test_loss:1.890, Lr:4.00E-04
[2023-11-21 23:30:59] Epoch:47, Train_acc:46.5%, Train_loss:1.646, Test_acc:35.8%, Test_loss:1.899, Lr:4.00E-04
[2023-11-21 23:31:32] Epoch:48, Train_acc:47.8%, Train_loss:1.639, Test_acc:36.1%, Test_loss:1.911, Lr:3.68E-04
[2023-11-21 23:32:04] Epoch:49, Train_acc:48.1%, Train_loss:1.631, Test_acc:35.8%, Test_loss:1.885, Lr:3.68E-04
[2023-11-21 23:32:28] Epoch:50, Train_acc:48.4%, Train_loss:1.639, Test_acc:36.4%, Test_loss:1.881, Lr:3.68E-04
[2023-11-21 23:32:52] Epoch:51, Train_acc:48.8%, Train_loss:1.621, Test_acc:35.8%, Test_loss:1.894, Lr:3.68E-04
[2023-11-21 23:33:16] Epoch:52, Train_acc:48.1%, Train_loss:1.634, Test_acc:36.1%, Test_loss:1.899, Lr:3.38E-04
[2023-11-21 23:33:40] Epoch:53, Train_acc:48.4%, Train_loss:1.615, Test_acc:36.9%, Test_loss:1.903, Lr:3.38E-04
acc = 36.9%, saving model to best.pkl
[2023-11-21 23:34:06] Epoch:54, Train_acc:48.3%, Train_loss:1.631, Test_acc:36.9%, Test_loss:1.884, Lr:3.38E-04
[2023-11-21 23:34:31] Epoch:55, Train_acc:47.4%, Train_loss:1.626, Test_acc:36.4%, Test_loss:1.854, Lr:3.38E-04
[2023-11-21 23:34:55] Epoch:56, Train_acc:49.5%, Train_loss:1.613, Test_acc:36.9%, Test_loss:1.881, Lr:3.11E-04
[2023-11-21 23:35:19] Epoch:57, Train_acc:48.7%, Train_loss:1.611, Test_acc:36.4%, Test_loss:1.863, Lr:3.11E-04
[2023-11-21 23:35:42] Epoch:58, Train_acc:49.0%, Train_loss:1.624, Test_acc:36.1%, Test_loss:1.865, Lr:3.11E-04
[2023-11-21 23:36:07] Epoch:59, Train_acc:47.8%, Train_loss:1.613, Test_acc:36.1%, Test_loss:1.881, Lr:3.11E-04
[2023-11-21 23:36:31] Epoch:60, Train_acc:49.0%, Train_loss:1.589, Test_acc:36.1%, Test_loss:1.867, Lr:2.86E-04
[2023-11-21 23:36:55] Epoch:61, Train_acc:46.9%, Train_loss:1.619, Test_acc:35.8%, Test_loss:1.845, Lr:2.86E-04
[2023-11-21 23:37:19] Epoch:62, Train_acc:48.1%, Train_loss:1.616, Test_acc:36.4%, Test_loss:1.883, Lr:2.86E-04
[2023-11-21 23:37:43] Epoch:63, Train_acc:48.0%, Train_loss:1.595, Test_acc:36.1%, Test_loss:1.852, Lr:2.86E-04
[2023-11-21 23:38:07] Epoch:64, Train_acc:49.1%, Train_loss:1.599, Test_acc:36.4%, Test_loss:1.892, Lr:2.63E-04
[2023-11-21 23:38:32] Epoch:65, Train_acc:49.5%, Train_loss:1.573, Test_acc:36.4%, Test_loss:1.853, Lr:2.63E-04
[2023-11-21 23:38:56] Epoch:66, Train_acc:49.0%, Train_loss:1.599, Test_acc:36.7%, Test_loss:1.859, Lr:2.63E-04
[2023-11-21 23:39:20] Epoch:67, Train_acc:49.4%, Train_loss:1.594, Test_acc:36.7%, Test_loss:1.849, Lr:2.63E-04
[2023-11-21 23:39:44] Epoch:68, Train_acc:49.1%, Train_loss:1.594, Test_acc:36.4%, Test_loss:1.843, Lr:2.42E-04

[2023-11-21 23:40:08] Epoch:69, Train_acc:49.3%, Train_loss:1.578, Test_acc:36.1%, Test_loss:1.881, Lr:2.42E-04
[2023-11-21 23:40:32] Epoch:70, Train_acc:50.4%, Train_loss:1.572, Test_acc:36.1%, Test_loss:1.823, Lr:2.42E-04
[2023-11-21 23:40:56] Epoch:71, Train_acc:48.0%, Train_loss:1.571, Test_acc:36.4%, Test_loss:1.872, Lr:2.42E-04
[2023-11-21 23:41:20] Epoch:72, Train_acc:48.2%, Train_loss:1.570, Test_acc:36.4%, Test_loss:1.851, Lr:2.23E-04
[2023-11-21 23:41:44] Epoch:73, Train_acc:51.3%, Train_loss:1.572, Test_acc:36.4%, Test_loss:1.884, Lr:2.23E-04
[2023-11-21 23:42:08] Epoch:74, Train_acc:48.7%, Train_loss:1.585, Test_acc:36.4%, Test_loss:1.864, Lr:2.23E-04
[2023-11-21 23:42:32] Epoch:75, Train_acc:50.7%, Train_loss:1.570, Test_acc:36.4%, Test_loss:1.863, Lr:2.23E-04
[2023-11-21 23:42:56] Epoch:76, Train_acc:50.1%, Train_loss:1.579, Test_acc:36.4%, Test_loss:1.869, Lr:2.05E-04
[2023-11-21 23:43:21] Epoch:77, Train_acc:49.6%, Train_loss:1.578, Test_acc:36.7%, Test_loss:1.844, Lr:2.05E-04
[2023-11-21 23:43:45] Epoch:78, Train_acc:49.4%, Train_loss:1.560, Test_acc:36.4%, Test_loss:1.856, Lr:2.05E-04
[2023-11-21 23:44:09] Epoch:79, Train_acc:51.2%, Train_loss:1.564, Test_acc:36.7%, Test_loss:1.841, Lr:2.05E-04
[2023-11-21 23:44:33] Epoch:80, Train_acc:50.3%, Train_loss:1.574, Test_acc:36.7%, Test_loss:1.860, Lr:1.89E-04
[2023-11-21 23:44:57] Epoch:81, Train_acc:50.8%, Train_loss:1.566, Test_acc:36.7%, Test_loss:1.875, Lr:1.89E-04
[2023-11-21 23:45:21] Epoch:82, Train_acc:50.3%, Train_loss:1.573, Test_acc:36.7%, Test_loss:1.840, Lr:1.89E-04
[2023-11-21 23:45:45] Epoch:83, Train_acc:49.7%, Train_loss:1.570, Test_acc:36.7%, Test_loss:1.860, Lr:1.89E-04
[2023-11-21 23:46:09] Epoch:84, Train_acc:49.4%, Train_loss:1.570, Test_acc:36.7%, Test_loss:1.838, Lr:1.74E-04
[2023-11-21 23:46:33] Epoch:85, Train_acc:50.2%, Train_loss:1.559, Test_acc:36.9%, Test_loss:1.813, Lr:1.74E-04
[2023-11-21 23:46:57] Epoch:86, Train_acc:51.2%, Train_loss:1.555, Test_acc:36.9%, Test_loss:1.817, Lr:1.74E-04
[2023-11-21 23:47:22] Epoch:87, Train_acc:51.9%, Train_loss:1.564, Test_acc:36.7%, Test_loss:1.840, Lr:1.74E-04
[2023-11-21 23:47:46] Epoch:88, Train_acc:49.7%, Train_loss:1.555, Test_acc:36.7%, Test_loss:1.834, Lr:1.60E-04
[2023-11-21 23:48:09] Epoch:89, Train_acc:50.1%, Train_loss:1.547, Test_acc:36.9%, Test_loss:1.867, Lr:1.60E-04
[2023-11-21 23:48:34] Epoch:90, Train_acc:50.3%, Train_loss:1.561, Test_acc:36.7%, Test_loss:1.856, Lr:1.60E-04
[2023-11-21 23:48:58] Epoch:91, Train_acc:50.3%, Train_loss:1.583, Test_acc:37.2%, Test_loss:1.832, Lr:1.60E-04
acc = 37.2%, saving model to best.pkl
[2023-11-21 23:49:24] Epoch:92, Train_acc:50.8%, Train_loss:1.549, Test_acc:37.2%, Test_loss:1.857, Lr:1.47E-04
[2023-11-21 23:49:48] Epoch:93, Train_acc:50.3%, Train_loss:1.550, Test_acc:37.2%, Test_loss:1.854, Lr:1.47E-04
[2023-11-21 23:50:13] Epoch:94, Train_acc:51.0%, Train_loss:1.545, Test_acc:37.2%, Test_loss:1.848, Lr:1.47E-04
[2023-11-21 23:50:37] Epoch:95, Train_acc:48.3%, Train_loss:1.561, Test_acc:37.2%, Test_loss:1.842, Lr:1.47E-04
[2023-11-21 23:51:01] Epoch:96, Train_acc:51.5%, Train_loss:1.542, Test_acc:37.2%, Test_loss:1.847, Lr:1.35E-04
[2023-11-21 23:51:25] Epoch:97, Train_acc:51.8%, Train_loss:1.534, Test_acc:37.2%, Test_loss:1.858, Lr:1.35E-04
[2023-11-21 23:51:49] Epoch:98, Train_acc:50.8%, Train_loss:1.555, Test_acc:37.2%, Test_loss:1.818, Lr:1.35E-04
[2023-11-21 23:52:13] Epoch:99, Train_acc:50.4%, Train_loss:1.553, Test_acc:37.2%, Test_loss:1.828, Lr:1.35E-04
[2023-11-21 23:52:37] Epoch:100, Train_acc:48.9%, Train_loss:1.546, Test_acc:37.2%, Test_loss:1.848, Lr:1.24E-04
[2023-11-21 23:53:01] Epoch:101, Train_acc:48.3%, Train_loss:1.539, Test_acc:37.2%, Test_loss:1.859, Lr:1.24E-04
[2023-11-21 23:53:25] Epoch:102, Train_acc:52.1%, Train_loss:1.514, Test_acc:37.2%, Test_loss:1.861, Lr:1.24E-04
[2023-11-21 23:53:49] Epoch:103, Train_acc:50.6%, Train_loss:1.559, Test_acc:37.2%, Test_loss:1.827, Lr:1.24E-04
[2023-11-21 23:54:13] Epoch:104, Train_acc:50.7%, Train_loss:1.541, Test_acc:37.2%, Test_loss:1.846, Lr:1.14E-04
[2023-11-21 23:54:38] Epoch:105, Train_acc:48.8%, Train_loss:1.553, Test_acc:37.2%, Test_loss:1.821, Lr:1.14E-04
[2023-11-21 23:55:01] Epoch:106, Train_acc:50.8%, Train_loss:1.535, Test_acc:37.2%, Test_loss:1.866, Lr:1.14E-04
[2023-11-21 23:55:25] Epoch:107, Train_acc:51.0%, Train_loss:1.541, Test_acc:37.2%, Test_loss:1.838, Lr:1.14E-04
[2023-11-21 23:55:50] Epoch:108, Train_acc:51.0%, Train_loss:1.526, Test_acc:37.2%, Test_loss:1.853, Lr:1.05E-04
[2023-11-21 23:56:14] Epoch:109, Train_acc:50.3%, Train_loss:1.520, Test_acc:37.2%, Test_loss:1.828, Lr:1.05E-04
[2023-11-21 23:56:38] Epoch:110, Train_acc:50.5%, Train_loss:1.548, Test_acc:37.2%, Test_loss:1.811, Lr:1.05E-04
[2023-11-21 23:57:02] Epoch:111, Train_acc:52.9%, Train_loss:1.519, Test_acc:36.9%, Test_loss:1.816, Lr:1.05E-04
[2023-11-21 23:57:26] Epoch:112, Train_acc:51.2%, Train_loss:1.542, Test_acc:36.9%, Test_loss:1.837, Lr:9.68E-05
[2023-11-21 23:57:50] Epoch:113, Train_acc:51.4%, Train_loss:1.530, Test_acc:36.9%, Test_loss:1.885, Lr:9.68E-05
[2023-11-21 23:58:15] Epoch:114, Train_acc:52.2%, Train_loss:1.525, Test_acc:36.9%, Test_loss:1.826, Lr:9.68E-05
[2023-11-21 23:58:39] Epoch:115, Train_acc:53.0%, Train_loss:1.529, Test_acc:36.9%, Test_loss:1.834, Lr:9.68E-05
[2023-11-21 23:59:03] Epoch:116, Train_acc:53.3%, Train_loss:1.524, Test_acc:36.9%, Test_loss:1.817, Lr:8.91E-05
[2023-11-21 23:59:27] Epoch:117, Train_acc:51.1%, Train_loss:1.530, Test_acc:36.9%, Test_loss:1.821, Lr:8.91E-05
[2023-11-21 23:59:51] Epoch:118, Train_acc:51.7%, Train_loss:1.521, Test_acc:36.9%, Test_loss:1.873, Lr:8.91E-05
[2023-11-22 00:00:15] Epoch:119, Train_acc:50.8%, Train_loss:1.533, Test_acc:36.9%, Test_loss:1.858, Lr:8.91E-05
[2023-11-22 00:00:39] Epoch:120, Train_acc:52.4%, Train_loss:1.528, Test_acc:36.9%, Test_loss:1.826, Lr:8.20E-05
[2023-11-22 00:01:03] Epoch:121, Train_acc:52.3%, Train_loss:1.523, Test_acc:36.9%, Test_loss:1.817, Lr:8.20E-05
[2023-11-22 00:01:27] Epoch:122, Train_acc:51.2%, Train_loss:1.537, Test_acc:36.9%, Test_loss:1.818, Lr:8.20E-05
[2023-11-22 00:01:51] Epoch:123, Train_acc:49.2%, Train_loss:1.555, Test_acc:36.9%, Test_loss:1.821, Lr:8.20E-05
[2023-11-22 00:02:16] Epoch:124, Train_acc:52.1%, Train_loss:1.495, Test_acc:36.9%, Test_loss:1.852, Lr:7.54E-05
[2023-11-22 00:02:40] Epoch:125, Train_acc:50.4%, Train_loss:1.542, Test_acc:36.9%, Test_loss:1.810, Lr:7.54E-05
[2023-11-22 00:03:04] Epoch:126, Train_acc:51.2%, Train_loss:1.522, Test_acc:36.9%, Test_loss:1.821, Lr:7.54E-05
[2023-11-22 00:03:28] Epoch:127, Train_acc:52.5%, Train_loss:1.528, Test_acc:36.7%, Test_loss:1.835, Lr:7.54E-05
[2023-11-22 00:03:52] Epoch:128, Train_acc:52.4%, Train_loss:1.521, Test_acc:36.7%, Test_loss:1.825, Lr:6.94E-05
[2023-11-22 00:04:16] Epoch:129, Train_acc:52.1%, Train_loss:1.539, Test_acc:36.9%, Test_loss:1.850, Lr:6.94E-05
[2023-11-22 00:04:41] Epoch:130, Train_acc:52.7%, Train_loss:1.519, Test_acc:36.7%, Test_loss:1.823, Lr:6.94E-05
[2023-11-22 00:05:05] Epoch:131, Train_acc:50.1%, Train_loss:1.521, Test_acc:36.9%, Test_loss:1.839, Lr:6.94E-05
[2023-11-22 00:05:29] Epoch:132, Train_acc:51.7%, Train_loss:1.525, Test_acc:36.9%, Test_loss:1.816, Lr:6.38E-05
[2023-11-22 00:05:54] Epoch:133, Train_acc:50.8%, Train_loss:1.534, Test_acc:36.7%, Test_loss:1.849, Lr:6.38E-05
[2023-11-22 00:06:18] Epoch:134, Train_acc:51.2%, Train_loss:1.522, Test_acc:36.9%, Test_loss:1.865, Lr:6.38E-05

...（后面的训练结果就不予展示了）

五、结果可视化

只取前100轮的训练结果做画图展示

''' 结果可视化 '''
    # 隐藏警告
warnings.filterwarnings("ignore")                # 忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False       # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100         # 分辨率
    
epochs_range = range(100)
train_acc  = [train_acc[f] for f in range(100) ]
test_acc   = [test_acc[f] for f in range(100) ]
train_loss = [train_loss[f] for f in range(100)]
test_loss  = [test_loss[f] for f in range(100)]

plt.figure('Result Visualization', figsize=(12, 3))
plt.subplot(1, 2, 1)
    
plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
    
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.savefig(os.path.join(output, 'AccuracyLoss.png'))
plt.show()

六、加载最佳模型+指定图片预测

''' 预测函数 '''
def predict(model, img_path):
    img = Image.open(img_path)
    test_transforms = torchvision.transforms.Compose([
        torchvision.transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
        torchvision.transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
        torchvision.transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
            mean=[0.485, 0.456, 0.406], 
            std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
    ])
    img = test_transforms(img)
    img = img.to(device).unsqueeze(0)
    output = model(img)
    #print(output.argmax(1))
    
    _, indices = torch.max(output, 1)
    percentage = torch.nn.functional.softmax(output, dim=1)[0] * 100
    perc = percentage[int(indices)].item()
    result = classeNames[indices]
    print('predicted:', result, perc)


if __name__=='__main__':
    classeNames = list({'Angelina Jolie': 0, 'Brad Pitt': 1, 'Denzel Washington': 2, 'Hugh Jackman': 3, 'Jennifer Lawrence': 4, 'Johnny Depp': 5, 'Kate Winslet': 6, 'Leonardo DiCaprio': 7, 'Megan Fox': 8, 'Natalie Portman': 9, 'Nicole Kidman': 10, 'Robert Downey Jr': 11, 'Sandra Bullock': 12, 'Scarlett Johansson': 13, 'Tom Cruise': 14, 'Tom Hanks': 15, 'Will Smith': 16})
    num_classes = len(classeNames)
    
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print("Using {} device\n".format(device))
    
    #model = Model().to(device)
    model = vgg16().to(device)  # 加载官方的vgg16模型
    for param in model.parameters():
        param.requires_grad = False # 冻结模型的参数，这样子在训练的时候只训练最后一层的参数
    # 修改classifier模块的第6层（即：(6): Linear(in_features=4096, out_features=2, bias=True)）
    # 注意查看我们下方打印出来的模型
    model.classifier._modules['6'] = nn.Linear(4096,len(classeNames)) # 修改vgg16模型中最后一层全连接层，输出目标类别个数
    model.to(device)
    model.load_state_dict(torch.load(os.path.join(r'F:\model_param\p_6_model', 'best.pkl')))
    model.eval()
    
    img_path = r'F:\P6_data\48-data\Hugh Jackman\027_ded82a08.jpg'
    predict(model, img_path)

Using cuda device

predicted: Hugh Jackman 52.52090835571289

虽然精度很低，但这张照片居然预测对了

七、手动搭建VGG16网络模型

#手写复现vgg-16网络结构
class vgg_16(nn.Module):
    def __init__(self):
        super(vgg_16, self).__init__()
        self.sequ1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),     # 64*224*224
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),    # 64*224*224
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), # 64*112*112
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),   # 128*112*112
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),  # 128*112*112
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), # 128*56*56
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),  # 256*56*56
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),  # 256*56*56
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),  # 256*56*56
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), # 256*28*28
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),  # 512*28*28
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),  # 512*28*28
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),  # 512*28*28
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False), # 512*14*14
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),  # 512*14*14
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),  # 512*14*14
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),  # 512*14*14
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)  # 512*7*7
        )
        self.pool2=nn.AdaptiveAvgPool2d(output_size=(7, 7))    # 512*7*7
        self.sequ3=nn.Sequential(
            nn.Linear(in_features=25088, out_features=4096, bias=True),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5, inplace=False),
            nn.Linear(in_features=4096, out_features=4096, bias=True),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5, inplace=False),
            nn.Linear(in_features=4096, out_features=17, bias=True)
        )
    
    def forward(self, x):
        x = self.sequ1(x)
        x = self.pool2(x)
        x = self.sequ3(x)
       
        return x

八、个人总结

1.本次课题离目标（准确率达到60%）相差甚远，尽管我在训练的轮次中做了很大的改变，都依然没有办法提升模型的精度。

2.初步分析我认为有以下几点导致模型精度没办法提升：

a.此次分类个数较多，有17个，而每个分类的原始数据又不够多

b.图片未像p4课题中的图片一样提前做了图像增强

c.我们训练的是时候将官方的VGG-16预训练模型的大部分参数（主要是特征提取部分的网络参数）进行了冻结，这部分参数无法随着我们的训练过程进行更新

3.这周五结束之前若还有时间，我将试试之前构建的简单的CNN模型去对图片进行预测，试试精度。

weixin_46559155

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第六周--P6周：好莱坞演员识别

1.本次课题离目标（准确率达到60%）相差甚远，尽管我在训练的轮次中做了很大的改变，都依然没有办法提升模型的精度。2.初步分析我认为有以下几点导致模型精度没办法提升：a.此次分类个数较多，有17个，而每个分类的原始数据又不够多b.图片未像p4课题中的图片一样提前做了图像增强c.我们训练的是时候将官方的VGG-16预训练模型的大部分参数（主要是特征提取部分的网络参数）进行了冻结，这部分参数无法随着我们的训练过程进行更新。
复制链接

扫一扫