正文

深度学习100例|第2例：人脸表情识别-pytorch实现(代码片段)

K同学啊  K同学啊  2022-11-29  467

关键词：

大家好，我是K同学啊，今天讲《深度学习100例》PyTorch版的第二个例子，前面一些例子主要还是以带大家了解PyTorch为主，建议手动敲一下代码，只有自己动手了，才能真正体会到里面的内容，光看不练是没有用的。今天的重点是在PyTorch调用VGG-16算法模型。先来了解一下PyTorch与TensorFlow的区别

PyTorch VS TensorFlow：

TensorFlow：简单，模块封装比较好，容易上手，对新手比较友好。在工业界最重要的是模型落地，目前国内的大部分企业支持TensorFlow模型在线部署，不支持Pytorch。
PyTorch：前沿算法多为PyTorch版本，如果是你高校学生or研究人员，建议学这个。相对于TensorFlow，Pytorch在易用性上更有优势，更加方便调试。

当然如果你时间充足，我建议两个模型都是需要了解一下的，这两者都还是很重要的。

文章目录

🍖 我的环境：

语言环境：Python3.8
编译器：Jupyter Lab
深度学习环境：
- torch==1.10.0+cu113
- torchvision==0.11.1+cu113
创作平台：🔗 极链AI云
创作教程：🔎 操作手册

一、导入数据

from torchvision.datasets   import CIFAR10
from torchvision.transforms import transforms
from torch.utils.data       import DataLoader
from torchvision            import datasets
from torch.optim            import Adam
import torchvision.models   as models
import torch.nn.functional  as F
import torch.nn             as nn
import torch,torchvision

train_datadir = './2-Emotion_Images/train/'
test_datadir  = './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] 从数据集中随机抽样计算得到的。
])

train_data = datasets.ImageFolder(train_datadir,transform=train_transforms)

test_data  = datasets.ImageFolder(test_datadir,transform=test_transforms)

train_loader = torch.utils.data.DataLoader(train_data,
                                          batch_size=16,
                                          shuffle=True,
                                          num_workers=1)
test_loader  = torch.utils.data.DataLoader(test_data,
                                          batch_size=16,
                                          shuffle=True,
                                          num_workers=1)

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))

classes = ('Angry', 'Fear', 'Happy', 'Surprise')

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

二、VGG-16算法模型

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

# 直接调用官方封装好的VGG16模型
model = models.vgg16(pretrained=True)
model

Using cuda device

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. 优化器与损失函数

optimizer  = Adam(model.parameters(), lr=0.0001, weight_decay=0.0001)
loss_model = nn.CrossEntropyLoss()

from torch.autograd import Variable

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 += 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

def train(model,train_loader,loss_model,optimizer):
    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()

        if i % 1000 == 0:    
            print('[%5d] loss: %.3f' % (i, loss))

2. 模型的训练

test_acc_list  = []
epochs = 10

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)
print("Done!")

Epoch 1
-------------------------------
[    0] loss: 37.630
[ 1000] loss: 1.025
Test Error: 
 Accuracy: 69.7%, Avg loss: 0.716039 

Epoch 2
-------------------------------
[    0] loss: 0.836
[ 1000] loss: 0.438
Test Error: 
 Accuracy: 71.0%, Avg loss: 0.699544 

Epoch 3
-------------------------------
[    0] loss: 0.527
[ 1000] loss: 0.616
Test Error: 
 Accuracy: 75.3%, Avg loss: 0.634513 

Epoch 4
-------------------------------
[    0] loss: 0.276
[ 1000] loss: 0.294
Test Error: 
 Accuracy: 75.7%, Avg loss: 0.817064 

Epoch 5
-------------------------------
[    0] loss: 1.014
[ 1000] loss: 0.496
Test Error: 
 Accuracy: 77.0%, Avg loss: 0.619491 

Epoch 6
-------------------------------
[    0] loss: 0.298
[ 1000] loss: 0.111
Test Error: 
 Accuracy: 76.4%, Avg loss: 0.780474 

Epoch 7
-------------------------------
[    0] loss: 0.037
[ 1000] loss: 0.151
Test Error: 
 Accuracy: 75.4%, Avg loss: 0.890973 

Epoch 8
-------------------------------
[    0] loss: 0.263
[ 1000] loss: 0.285
Test Error: 
 Accuracy: 79.1%, Avg loss: 0.863850 

Epoch 9
-------------------------------
[    0] loss: 0.010
[ 1000] loss: 0.014
Test Error: 
 Accuracy: 78.0%, Avg loss: 1.078627 

Epoch 10
-------------------------------
[    0] loss: 0.004
[ 1000] loss: 0.545
Test Error: 
 Accuracy: 78.5%, Avg loss: 1.079087 

Done!

三、可视化

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

深度学习100例——使用pytorch实现验证码识别|第4例

前言大家好，我是阿光。本专栏整理了《深度学习100例》，内包含了各种不同的深度学习项目，包含项目原理以及源码，每一个项目实例都附带有完整的代码+数据集。正在更新中~✨ 查看详情

深度学习100例|第4例：水果识别-pytorch实现(代码片段)

...练四、结果分析大家好，我是K同学啊，今天讲《深度学习100例》PyTorch版的第4个例子，前面一些例子主要还是以带大家了解PyTorch为主，建议手动敲一下代码，只有自己动手了，才能真正体会到里查看详情

深度学习100例-卷积神经网络（inception-resnet-v2）识别交通标志|第14天

查看详情

深度学习100例|第1例：猫狗识别-pytorch实现(代码片段)

...om/kzbkzb/Python-AI已收录作者：K同学啊来自专栏：《深度学习100例》-PyTorch版本数据链接：https://pan.baidu.com/s/1YREL1omT9YJrp9B1PBPTfQ（提取码查看详情

深度学习100例-卷积神经网络（cnn）花朵识别|第4天(代码片段)

...识别我的环境：语言环境：Python3.6.5编译器：jupyternotebook深度学习环境：TensorFlow2来自专栏：【深度学习100例】1.设置GPU如果使用的是CPU可以查看详情

深度学习100例-卷积神经网络（cnn）实现mnist手写数字识别|第1天

...说明我的环境：语言环境：Python3.6.5编译器：jupyternotebook深度学习环境：TensorFlow2来自专栏：【深度学习100例查看详情

深度学习100例|第41天：语音识别-pytorch实现(代码片段)

...的环境：语言环境：Python3.8编译器：JupyterLab深度学习环境：torch==1.10.0+cu113torchv 查看详情

深度学习100例-卷积神经网络（inceptionv3）识别手语|第13天

查看详情

深度学习100例|第24天-卷积神经网络（xception）：动物识别(代码片段)

...图」图解10大CNN架构的文章后，发现有些模型在我们的《深度学习100例》中并未介绍，后来不是说填坑嘛，之前已经写一篇深度学习100例-卷积神经网络（LeNet-5）深度学习里的“HelloWord”|第22天来填补LeNet-5的坑。今天继续写一篇... 查看详情

深度学习100例|第3天：交通标志识别-pytorch实现(代码片段)

...练四、结果分析大家好，我是K同学啊，今天讲《深度学习100例》PyTorch版的第3个例子，前面一些例子主要还是以带大家了解PyTorch为主，建议手动敲一下代码，只有自己动手了，才能查看详情

深度学习100例-卷积神经网络（cnn）实现车牌识别|第15天

文章目录一、前期工作1.设置GPU2.导入数据3.数据可视化4.标签数字化二、构建一个tf.data.Dataset1.预处理函数2.加载数据3.配置数据三、搭建网络模型四、设置动态学习率五、编译六、训练七、模型评估八、保存和加载模型九、预测... 查看详情

深度学习100例|第36天：fmd材料识别(代码片段)

...1a;python3🚩作者：K同学啊🥇选自专栏：《深度学习100例》🔥精选专栏：《新手入门深度学习》📚推荐专栏：《Matplotlib教程》🧿优秀专栏：《Python入门100题》大家好，我是K同学啊查看详情

深度学习100例-卷积神经网络（resnet-50）鸟类识别|第8天(代码片段)

文章目录一、前期工作1.设置GPU2.导入数据3.查看数据二、数据预处理1.加载数据2.可视化数据3.再次检查数据4.配置数据集三、残差网络（ResNet）介绍1.残差网络解决了什么2.ResNet-50介绍四、构建ResNet-50网络模型五、编译六、训练模... 查看详情

深度学习100例-卷积神经网络（cnn）识别神奇宝贝小智一伙|第16天

文章目录一、前期工作1.设置GPU2.导入数据3.查看数据二、数据预处理1.加载数据2.可视化数据3.再次检查数据4.配置数据集三、调用官方网络模型四、设置动态学习率五、编译六、训练模型七、模型评估八、保存and加载模型九、预... 查看详情

深度学习100例-卷积神经网络（cnn）识别眼睛状态|第17天(代码片段)

文章目录一、前期工作1.设置GPU2.导入数据3.查看数据二、数据预处理1.加载数据2.可视化数据3.再次检查数据4.配置数据集三、调用官方网络模型四、设置动态学习率五、编译六、训练模型七、模型评估1.Accuracy与Loss图2.混淆矩阵八... 查看详情

正文