-
pytorch 入门 （四）案例二：人脸表情识别-VGG16实现
实战教案二：人脸表情识别-VGG16实现
本文为🔗小白入门Pytorch内部限免文章
参考本文所写记录性文章，请在文章开头注明以下内容，复制粘贴即可- 🍨 本文为🔗小白入门Pytorch中的学习记录博客
- 🍦 参考文章：【小白入门Pytorch】人脸表情识别-VGG16实现
- 🍖 原作者：K同学啊
数据集下载：
链接：https://pan.baidu.com/s/1RvlpOx8v6MudY65Oi78-kQ?pwd=zhfo
提取码：zhfo
–来自百度网盘超级会员V4的分享一、导入数据
from torchvision.datasets import CIFAR10 # CIFAR10是一个用于计算机视觉的经典数据集，其中包含60000张32x32的彩色图像，分为10个类别，每个类别有6000张图像。 from torchvision.transforms import transforms # 这是一个常用的模块，用于图像的预处理和增强。 from torch.utils.data import DataLoader # 可以将数据集转化为迭代器的工具，方便在训练循环中加载数据。 from torchvision import datasets # 导入了torchvision下的所有数据集，但实际上这与前面导入CIFAR10是重复的，可能是不必要的。 from torch.optim import Adam # 导入了Adam优化器。Adam是一个常用的、表现良好的深度学习优化器。 import torchvision.models as models # 这个模块提供了各种预训练模型，例如ResNet、VGG、DenseNet等。 import torch.nn.functional as F # 提供了各种激活函数、损失函数和其他的功能函数。 import torch.nn as nn # 这个模块提供了构建神经网络所需的各种工具，如层、损失函数等。 import torch,torchvision # torch是PyTorch的核心库，提供了基础的张量操作；torchvision则是与计算机视觉相关的库，提供了数据集、预处理方法和预训练模型。- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
train_datadir = '/home/mw/input/kzb324321357/2-Emotion_Images/2-Emotion_Images/train' test_datadir = '/home/mw/input/kzb324321357/2-Emotion_Images/2-Emotion_Images/test' train_transforms = transforms.Compose([ transforms.Resize([48, 48]), # 将输入图片resize成统一尺寸 transforms.ToTensor(), # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间 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] 从数据集中随机抽样计算得到的。 ]) test_transforms = transforms.Compose([ transforms.Resize([48, 48]), # 将输入图片resize成统一尺寸 transforms.ToTensor(), # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间 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] 从数据集中随机抽样计算得到的。 ]) # 使用 datasets.ImageFolder 加载训练数据集和测试数据集 # ImageFolder假定所有的文件按文件夹保存，每个文件夹下存储同一个类别的图片，文件夹名为类别的名字。 # 同时，为加载的数据应用了之前定义的预处理流程。 train_data = datasets.ImageFolder(train_datadir, transform=train_transforms) test_data = datasets.ImageFolder(test_datadir, transform=test_transforms)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
⭐ torch.utils.data.DataLoader详解
torch.utils.data.DataLoader是Pytorch自带的一个数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集。函数原型：
torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device=‘’)
参数说明：
- dataset(string) ：加载的数据集
- batch_size (int,optional) ：每批加载的样本大小（默认值：1）
- shuffle(bool,optional) : 如果为
True，每个epoch重新排列数据。 - sampler (Sampler or iterable, optional) ： 定义从数据集中抽取样本的策略。 可以是任何实现了 len 的 Iterable。 如果指定，则不得指定 shuffle 。
- batch_sampler (Sampler or iterable, optional) ： 类似于sampler，但一次返回一批索引。与 batch_size、shuffle、sampler 和 drop_last 互斥。
- num_workers(int,optional) ： 用于数据加载的子进程数。 0 表示数据将在主进程中加载（默认值：0）。
- pin_memory (bool,optional) : 如果为 True，数据加载器将在返回之前将张量复制到设备/CUDA 固定内存中。 如果数据元素是自定义类型，或者collate_fn返回一个自定义类型的批次。
- drop_last(bool,optional) : 如果数据集大小不能被批次大小整除，则设置为 True 以删除最后一个不完整的批次。 如果 False 并且数据集的大小不能被批大小整除，则最后一批将保留。 （默认值：False）
- timeout(numeric,optional) : 设置数据读取的超时时间 ， 超过这个时间还没读取到数据的话就会报错。（默认值：0）
- worker_init_fn(callable,optional) ： 如果不是 None，这将在步长之后和数据加载之前在每个工作子进程上调用，并使用工作 id（[0，num_workers - 1] 中的一个 int）的顺序逐个导入。 （默认：None）
# 创建训练数据加载器（data loader），用于将数据分成小批次进行训练 train_loader = torch.utils.data.DataLoader(train_data, batch_size=16, # 每个批次包含的图像数量 shuffle=True, # 随机打乱数据 num_workers=4) # 使用多少个子进程来加载数据 # 创建测试数据加载器（data loader），用于将测试数据分成小批次进行测试 test_loader = torch.utils.data.DataLoader(test_data, batch_size=16, # 每个批次包含的图像数量 shuffle=True, # 随机打乱数据 num_workers=4) # 使用多少个子进程来加载数据 # 打印数据集的信息 # 请注意，这里使用len(train_loader) * 16来计算图像总数是基于批次大小为16的假设。 # 实际上，最后一个批次的图像数量可能少于16。 print("The number of images in a training set is: ", len(train_loader) * 16) # 计算训练集中的图像总数 print("The number of images in a test set is: ", len(test_loader) * 16) # 计算测试集中的图像总数 print("The number of batches per epoch is: ", len(train_loader)) # 计算每个 epoch 中的批次数 # 定义数据集的类别标签 classes = ('Angry', 'Fear', 'Happy', 'Surprise')- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
The number of images in a training set is: 18480 The number of images in a test set is: 2320 The number of batches per epoch is: 1155- 1
- 2
- 3
二、VGG-16算法模型
device = "cuda" if torch.cuda.is_available() else "cpu" print("Using {} device".format(device)) # 直接调用官方封装好的VGG16模型 model = models.vgg16(pretrained = True) model- 1
- 2
- 3
- 4
- 5
- 6
- 7
Using cuda device- 1
Downloading: "https://download.pytorch.org/models/vgg16-397923af.pth" to /home/mw/.cache/torch/hub/checkpoints/vgg16-397923af.pth- 1
HBox(children=(FloatProgress(value=0.0, max=553433881.0), HTML(value='')))- 1
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=1000, bias=True) ) )- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
1. 优化器与损失函数
optimizer = Adam(model.parameters(),lr = 0.0001,weight_decay = 0.0001) loss_model = nn.CrossEntropyLoss()- 1
- 2
import torch from torch.autograd import Variable # 定义训练函数 def train(model,train_loader,loss_model,optimizer): # 将模型移动到指定设备（如：GPU） model = model.to(device) # 将模型设置为训练模式（启用梯度计算） model.train() for i,(images,labels) in enumerate(train_loader,0): # 将输入数据和标签移动到指定设备 images = Variable(images.to(device)) labels = Variable(labels.to(device)) # 梯度清零 optimizer.zero_grad() # 前向传播得到模型输出 outputs = model(images) # 计算损失 loss = loss_model(outputs,labels) # 反向传播 loss.backward() # 更新模型参数 optimizer.step() # 每隔1000个批次输出一次损失 if i%1000 == 0: print('[%5d] loss: %.3f' % (i,loss)) # 定义测试函数 def test(model,test_loader,loss_model): # 获取测试数据集大小 size = len(test_loader.dataset) # 获取测试数据批次数 num_batches = len(test_loader) # 将模型设置为评估模式（不进行梯度计算） model.eval() test_loss,correct = 0,0 # 在不计算梯度的上下文中执行测试 with torch.no_grad(): for X,y in test_loader: X,y = X.to(device),y.to(device) # 使用模型进行前向传播得到预测 pred = model(X) # 计算损失值，并将其累积到test_loss中 test_loss += loss_model(pred,y).item() # 计算正确预测的数量 correct += (pred.argmax(1)==y).type(torch.float).sum().item() # 计算平均测试损失和准确率 test_loss /= num_batches correct /= size print(f"Test Error:\n Accuracy:{(100*correct):>0.1f}%,Avg loss:{test_loss:>8f} \n") return correct,test_loss- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
提问：梯度清零有三种放置方法吗，放到循环最前面或者最后面，或者反向传播之前
是的，您理解得很准确。在PyTorch中，
optimizer.zero_grad()的位置有一定的灵活性。以下是这三种常见的放置方法：- 循环开始时：在每次迭代的最开始，即前向传播之前，清零梯度。
- 反向传播之前：在前向传播之后、反向传播之前，清零梯度。这也是您提供的代码中使用的方法。
- 循环结束时：在每次迭代的最后，即更新参数之后，清零梯度。
这三种方法在大多数情况下都是等效的，因为关键是确保在进行下一次反向传播之前梯度是清零的。
但是，如果您在一个迭代中进行多次反向传播（例如，当您想要累加梯度时），那么您必须在每次反向传播之前清零梯度。在这种特定情境中，第二种方法（反向传播之前）是最合适的。
对于大多数常规的训练循环，选择哪种方法主要是根据个人偏好或代码的可读性来决定的。
2. 模型的训练
# 创建一个空列表用于存储每个epoch的测试集准确率 test_acc_list = [] # 定义训练的总论数 epochs = 10 # 开始训练循环，每个epoch 都会执行一下操作 for t in range(epochs): print(f"Epoch {t+1}\n-------------------------------") # 在训练数据上训练模型 train(model,train_loader,loss_model,optimizer) # 在测试数据集上测试模型的性能，并获取测试准确率和测试损失 test_acc,test_loss = test(model,test_loader,loss_model) # 将测试准确率添加到列表中，以便后续分析 test_acc_list.append(test_acc) # 所有epoch完成后打印完成消息 print("Done!")- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
Epoch 1 ------------------------------- [ 0] loss: 0.129 [ 1000] loss: 0.005 Test Error: Accuracy:77.4%,Avg loss:1.069592 Epoch 2 ------------------------------- [ 0] loss: 0.028 [ 1000] loss: 0.055 Test Error: Accuracy:78.7%,Avg loss:0.976879 Epoch 3 ------------------------------- [ 0] loss: 0.033 [ 1000] loss: 0.050 Test Error: Accuracy:77.9%,Avg loss:1.202651 Epoch 4 ------------------------------- [ 0] loss: 0.051 [ 1000] loss: 0.356 Test Error: Accuracy:79.0%,Avg loss:1.080943 Epoch 5 ------------------------------- [ 0] loss: 0.001 [ 1000] loss: 0.183 Test Error: Accuracy:78.7%,Avg loss:1.248081 Epoch 6 ------------------------------- [ 0] loss: 0.003 [ 1000] loss: 0.127 Test Error: Accuracy:78.4%,Avg loss:1.129110 Epoch 7 ------------------------------- [ 0] loss: 0.003 [ 1000] loss: 0.076 Test Error: Accuracy:77.6%,Avg loss:1.200314 Epoch 8 ------------------------------- [ 0] loss: 0.042 [ 1000] loss: 0.071 Test Error: Accuracy:78.0%,Avg loss:1.149877 Epoch 9 ------------------------------- [ 0] loss: 0.002 [ 1000] loss: 0.212 Test Error: Accuracy:78.0%,Avg loss:1.353625 Epoch 10 ------------------------------- [ 0] loss: 0.001 [ 1000] loss: 0.001 Test Error: Accuracy:78.5%,Avg loss:1.249242 Done!- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
test_acc_list- 1
[0.773552290406223, 0.7869490060501296, 0.7791702679343129, 0.7904062229904927, 0.7869490060501296, 0.783923941227312, 0.7757130509939498, 0.780466724286949, 0.780466724286949, 0.7852203975799481]- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
三、可视化
import numpy as np import matplotlib.pyplot as plt x = [i for i in range(1,11)] plt.plot(x,test_acc_list,label="line ACC",alpha = 0.8) plt.xlabel("epoch") plt.ylabel("acc") plt.legend() plt.show()- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 1
-
相关阅读:
60行自己动手写LockSupport是什么体验？
6 从物理层到MAC层
Hikyuu 1.2.5 发布，高性能量化交易研究框架
Java.lang.Class asSubclass()方法有什么功能呢？
layuiAPI
【JAVA高级】——吃透JDBC中的SQL注入问题和解决方案
(转)冒泡排序及优化详解
鸿蒙HarmonyOS开发规范-完善中
P38 Border边框
GO实现Redis：GO实现Redis集群（5）
- 原文地址：https://blog.csdn.net/qq_33489955/article/details/133993996
