机器学习-面部表情识别

一、选题背景

　　面部表情识别的深度学习技术具有广泛的应用前景和社会价值。从社会层面来看，它可以应用于公共安全、金融支付、智能交通等领域，提高社会治理效率和安全性；从经济层面来看，它可以为企业提供更加智能化的服务，提高企业竞争力和盈利能力；从技术层面来看，深度学习技术在图像处理、模式识别等方面具有优势，可以不断提高面部识别的准确性和可靠性；从数据来源方面来看，随着智能手机、摄像头等设备的普及，人们在日常生活中产生的大量数据为面部识别提供了丰富的训练样本。

二、机器学习设计方案

　　本项目是基于卷积神经网络模型开展表情识别的研究，为了尽可能的提高最终表情识别的准确性，需要大量的样本图片训练，优化，所以采用了 一个大量的图片数据集用来训练、测试，划分一下训练集和验证集。

　　本次训练的数据来源于：https://www.kaggle.com/c/challenges-in-representation-learning-facial-expression-recognition-challenge/data

　　数据集包含人类面部表情的图片的label和feature。在这里，面部表情识别相当于一个分类问题，共有7个类别。

其中label包括7种类型表情：

　　面部表情识别面临着一些技术难点，如：光照变化的影响，不同的光照条件可能会影响面部表情的识别准确率，特别是在光线较暗或者过度曝光的情况下；面部姿态的多样性，面部表情不仅受到肌肉运动的影响，还与头部姿态、面部朝向等因素有关，这增加了表情识别的复杂性。对这两个我们可以对光照进行调整和补偿：可以通过图像预处理技术对光照变化进行补偿，如使用直方图均衡化或自适应直方图均衡化技术来改善图像对比度。姿态估计，引入姿态估计模型来辅助表情识别，使用卷积神经网络（CNN）来预测头部姿态，从而校正姿态造成的误差。

框架描述：
1. 数据收集：收集大量的面部表情图像数据，这些数据通常来自于不同的场景、光照条件和角度。为了保证模型的泛化能力，数据集应包含多样化的表情和个体差异。
2. 数据预处理：对收集到的数据进行预处理，以提高模型训练的效率和准确性。预处理步骤可能包括图像大小标准化、归一化、数据增强（如旋转、缩放、裁剪）等。
3. 特征提取：从预处理后的图像中提取有助于表情识别的特征。这可能包括面部关键点（如眼睛、鼻子、嘴巴的位置）、面部姿态、以及用于描述面部表情的局部二值模式（LBP）或深度学习特征（如卷积神经网络的特征）。
4. 模型选择与训练：选择合适的机器学习模型来训练表情识别任务。常用的模型包括支持向量机（SVM）、随机森林、卷积神经网络（CNN）等。使用训练数据集对模型进行训练，调整模型参数以最小化分类错误。
5. 模型评估：使用验证集或测试集对训练好的模型进行评估，以确定其性能。评估指标可能包括准确率、召回率、F1分数等。
6. 模型优化：根据评估结果对模型进行调整和优化，以提高其泛化能力。这可能涉及超参数调优、模型融合、特征选择等。
7. 模型部署：将训练好的模型部署到实际应用中，如应用程序、网站或嵌入式设备。部署过程中需要考虑模型的实时性能、资源消耗和兼容性问题。
8. 持续学习与更新：随着更多数据的积累和变化，定期更新和优化模型，以适应新的表情趋势和个体差异。

三、机器学习的实现步骤

　　面部表情识别框架

　　面部表情识别通常可以划分为四个进程。包括图像获取，面部检测，图像预处理和表情分类。其中，面部检测，脸部特征提取和面部表情分类是面部表情识别的三个关键环节面部表情识别的基本框架如下图所示。

 

　　首先是获取图像并执行面部检测，然后提取仅具有面部的图像部分。所提取的面部表情在比例和灰度上不均匀，因此有必要对面部特征区域进行分割和归一化，其中执行归一化主要是对面部光照和位置进行统一处理，将图像统一重塑为标准大小，如 48×48 像素的图片，即图像预处理。然后对脸部图像提取面部表情特征值，并进行分类。采用卷积神经网络(CNN)来完成特征提取和分类的任务，因为 CNN 是模仿人脑工作并建立卷积神经网络结构模型的著名模型，所以选择卷积神经网络作为构建模型体系结构的基础，最后不断训练，优化，最后达到较准确识别出面部表情的结果。

　　具体步骤如下:

 　　先对图像进行预处理：

（1）在原文件中，emotion和pixels人脸像素数据是集中在一起的。为了方便操作，决定利用pandas库进行数据分离，即将所有emotion读出后，写入新创建的文件emotion.csv；将所有的像素数据读出后，写入新创建的文件pixels.csv。

 

# 将emotion和pixels像素数据分离
import pandas as pd

# 注意修改train.csv为你电脑上文件所在的相对或绝对路劲地址。
path = 'dataset/train.csv'
# 读取数据
df = pd.read_csv(path)
# 提取emotion数据
df_y = df[['emotion']]
# 提取pixels数据
df_x = df[['pixels']]
# 将emotion写入emotion.csv
df_y.to_csv('dataset/emotion.csv', index=False, header=False)
# 将pixels数据写入pixels.csv
df_x.to_csv('dataset/pixels.csv', index=False, header=False)

　（2）给定的数据集是csv格式的，所以我先将其全部可视化，还原为图片文件再送进模型进行处理。

# face_view.py

import cv2
import numpy as np

# 放图片的路径
path = '../images'
# 读取像素数据
data = np.loadtxt('../datasets/cnn_data.csv')

# 按行取数据并写图
for i in range(data.shape[0]):
    face_array = data[i, :].reshape((48, 48))  # reshape
    cv2.imwrite(path + '//' + '{}.jpg'.format(i), face_array)  # 写图

　　（3）Step1：划分一下训练集和验证集。一共有28709张图片，取了前24000张图片作为训练集，其他图片作为验证集。新建文件夹cnn_train和cnn_val，将0.jpg到23999.jpg放进文件夹cnn_train，将其他图片放进文件夹cnn_val.

# cnn_picture_label.py
# ###三、表情图片和类别标注,
# 1.取前24000张图片作为训练集放入cnn_train，其他图片作为验证集放入cnn_val
# 2.对每张图片标记属于哪一个类别，存放在dataset.csv中，分别在刚刚训练集和测试集执行标记任务。

# #因为cpu训练太慢，我只取前2000张做训练，400张做测试！！，手动删除两个文件夹重dataset.csv的多余行数据
import os
import pandas as pd


def data_label(path):
    # 读取label文件
    df_label = pd.read_csv('../datasets/cnn_label.csv', header=None)
    # 查看该文件夹下所有文件
    files_dir = os.listdir(path)
    # 存放文件名和标签的列表
    path_list = []
    label_list = []
    # 遍历所有文件，取出文件名和对应的标签分别放入path_list和label_list列表
    for file_dir in files_dir:
        if os.path.splitext(file_dir)[1] == '.jpg':
            path_list.append(file_dir)
            index = int(os.path.splitext(file_dir)[0])
            label_list.append(df_label.iat[index, 0])
    # 将两个列表写进dataset.csv文件
    path_s = pd.Series(path_list)
    label_s = pd.Series(label_list)
    df = pd.DataFrame()
    df['path'] = path_s
    df['label'] = label_s
    df.to_csv(path + '\\dataset.csv', index=False, header=False)


def main():
    # 指定文件夹路径
    train_path = '../datasets/cnn_train'
    val_path = '../datasets/cnn_val'
    data_label(train_path)
    data_label(val_path)


if __name__ == '__main__':
    main()

　　（3）然后重写Dataset类，这是Pytorch中图像数据集加载的一个基类，需要重写类来实现加载上面的图像数据集

 

# rewrite_dataset.py
# ###四、重写类来实现加载上面的图像数据集。
import bisect
import warnings

import cv2
import numpy as np
import pandas as pd
import torch
import torch.utils.data as data


class FaceDataset(data.Dataset):
    # 初始化
    def __init__(self, root):
        super(FaceDataset, self).__init__()
        self.root = root
        df_path = pd.read_csv(root + '\\dataset.csv', header=None, usecols=[0])
        df_label = pd.read_csv(root + '\\dataset.csv', header=None, usecols=[1])
        self.path = np.array(df_path)[:, 0]
        self.label = np.array(df_label)[:, 0]

    # 读取某幅图片，item为索引号
    def __getitem__(self, item):
        # 图像数据用于训练，需为tensor类型，label用numpy或list均可
        face = cv2.imread(self.root + '\\' + self.path[item])
        # 读取单通道灰度图
        face_gray = cv2.cvtColor(face, cv2.COLOR_BGR2GRAY)
        # 直方图均衡化
        face_hist = cv2.equalizeHist(face_gray)

        """
        像素值标准化
        读出的数据是48X48的，而后续卷积神经网络中nn.Conv2d() 
        API所接受的数据格式是(batch_size, channel, width, height)，
        本次图片通道为1，因此我们要将48X48 reshape为1X48X48。
        """
        face_normalized = face_hist.reshape(1, 48, 48) / 255.0
        face_tensor = torch.from_numpy(face_normalized)
        face_tensor = face_tensor.type('torch.FloatTensor')
        # face_tensor = face_tensor.type('torch.cuda.FloatTensor')
        label = self.label[item]
        return face_tensor, label

    # 获取数据集样本个数
    def __len__(self):
        return self.path.shape[0]

 

然后开始搭建模型：

　　卷积神经网络(CNN)是一种前馈神经网络，它包括卷积计算并具有较深的结构，因此是深度学习的代表性算法之一。随着科技的不断进步，人们在研究人脑组织时受启发创立了神经网络。神经网络由很多相互联系的神经元组成，并且可以在不同的神经元之间通过调整传递彼此之间联系的权重系数 x 来增强或抑制信号。标准卷积神经网络通常由输入层、卷积层、池化层、全连接层和输出层组成，如下图所示

 

　　上图中第一层为输入层，大小为 28×28，然后通过 20×24×24 的卷积层，得到的结果再输入池化层中，最后再通过图中第四层既全连接层，直到最后输出。

　　下图为CNN常见的网络模型。其中包括 4 个卷积层，3 个池化层，池化层的大小为 3×3，最终再通过两个全连接层到达输出层。网络模型中的输入层一般是一个矩阵，卷积层，池化层和全连接层可以当作隐藏层，这些层通常具有不同的计算方法，需要学习权重以找到最佳值。

# CNN_face.py
# 定义一个CNN模型
"""
inputs(48*48*1) ->
conv(24*24*64) -> conv(12*12*128) -> conv(6*6*256) ->
Dropout -> fc(4096) -> Dropout -> fc(1024) ->
outputs(7)
"""

import torch.nn as nn


# 参数初始化
def gaussian_weights_init(m):
    classname = m.__class__.__name__
    # 字符串查找find，找不到返回-1，不等-1即字符串中含有该字符
    if classname.find('Conv') != -1:
        m.weight.data.normal_(0.0, 0.04)


class FaceCNN(nn.Module):
    # 初始化网络结构
    def __init__(self):
        super(FaceCNN, self).__init__()

        # layer1(conv + relu + pool)
        # input:(bitch_size, 1, 48, 48), output(bitch_size, 64, 24, 24)
        self.conv1 = nn.Sequential(
            nn.Conv2d(1, 64, 3, 1, 1),
            nn.BatchNorm2d(num_features=64),
            nn.RReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # layer2(conv + relu + pool)
        # input:(bitch_size, 64, 24, 24), output(bitch_size, 128, 12, 12)
        self.conv2 = nn.Sequential(
            nn.Conv2d(64, 128, 3, 1, 1),
            nn.BatchNorm2d(num_features=128),
            nn.RReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # layer3(conv + relu + pool)
        # input: (bitch_size, 128, 12, 12), output: (bitch_size, 256, 6, 6)
        self.conv3 = nn.Sequential(
            nn.Conv2d(128, 256, 3, 1, 1),
            nn.BatchNorm2d(num_features=256),
            nn.RReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        # 参数初始化
        self.conv1.apply(gaussian_weights_init)
        self.conv2.apply(gaussian_weights_init)
        self.conv3.apply(gaussian_weights_init)

        # 全连接层
        self.fc = nn.Sequential(
            nn.Dropout(p=0.2),
            nn.Linear(256*6*6, 4096),
            nn.RReLU(inplace=True),

            nn.Dropout(p=0.5),
            nn.Linear(4096, 1024),
            nn.RReLU(inplace=True),

            nn.Linear(1024, 256),
            nn.RReLU(inplace=True),
            nn.Linear(256, 7)
        )

    # 向前传播
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.shape[0], -1)  # 数据扁平化
        y = self.fc(x)

        return y

 

 

之后就是训练模型：

　　损失函数使用交叉熵，优化器是随机梯度下降SGD，其中weight_decay为正则项系数，每轮训练打印损失值，每10轮训练打印准确率。

 

 

 

# train.py
# 定义训练轮
import torch
import torch.utils.data as data
import torch.nn as nn
import numpy as np
from torch import optim

from models import CNN_face
from dataloader import rewrite_dataset


def train(train_dataset, val_dataset, batch_size, epochs, learning_rate, wt_decay, print_cost=True, isPlot=True):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    # 加载数据集并分割batch
    train_loader = data.DataLoader(train_dataset, batch_size)
    # 构建模型
    model = CNN_face.FaceCNN()
    model.to(device)
    # 损失函数和优化器
    compute_loss = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=wt_decay)
    # 学习率衰减
    # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.8)

    for epoch in range(epochs):
        loss = 0
        model.train()
        for images, labels in train_loader:
            optimizer.zero_grad()
            outputs = model.forward(images)
            loss = compute_loss(outputs, labels)
            loss.backward()
            optimizer.step()

        # 打印损失值
        if print_cost:
            print('epoch{}: train_loss:'.format(epoch + 1), loss.item())

        # 评估模型准确率
        if epoch % 10 == 9:
            model.eval()
            acc_train = validate(model, train_dataset, batch_size)
            acc_val = validate(model, val_dataset, batch_size)
            print('acc_train: %.1f %%' % (acc_train * 100))
            print('acc_val: %.1f %%' % (acc_val * 100))

    return model


# 验证模型在验证集上的正确率
def validate(model, dataset, batch_size):
    val_loader = data.DataLoader(dataset, batch_size)
    result, total = 0.0, 0
    for images, labels in val_loader:
        pred = model.forward(images)
        pred_tmp = pred.cuda().data.cpu().numpy()
        pred = np.argmax(pred_tmp.data.numpy(), axis=1)
        labels = labels.data.numpy()
        result += np.sum((pred == labels))
        total += len(images)
    acc = result / total
    return acc


def main():
    train_dataset = rewrite_dataset.FaceDataset(root=r'D:\01 Desktop\JUST_YAN\05 DeepLearning\Facial-expression_Reg\datasets\cnn_train')
    val_dataset = rewrite_dataset.FaceDataset(root=r'D:\01 Desktop\JUST_YAN\05 DeepLearning\Facial-expression_Reg\datasets\cnn_val')
    model = train(train_dataset, val_dataset, batch_size=128, epochs=100, learning_rate=0.01,
                  wt_decay=0, print_cost=True, isPlot=True)
    torch.save(model, 'model_net.pkl')  # 保存模型


if __name__ == '__main__':
    main()

最后是 项目结果：

在超参数为：batch_size=128, epochs=100, learning_rate=0.01, wt_decay=0，的情况下跑得最终结果如下：

 总结

　　在本次机器学习过程实现中我明白了数据预处理是关键。在面部表情识别中，数据预处理包括图像去噪、裁剪、对齐等操作，这些操作能够提高模型的准确性和鲁棒性。特征提取是重要的一步。在面部表情识别中，常用的特征提取方法有基于几何特征的方法、基于纹理特征的方法和基于深度学习的方法等。其中，基于深度学习的方法具有更好的性能表现。在本次的机器学习过程实现中我加深了对面部表情识别算法的理解，和培养自己解决问题的能力，提高了机器学习技能和知识水平，以及获得了系统化的思维。

总代码如下：

# cnn_feature_label.py
# ###一、将原始数据的label和feature(像素)数据分离
import pandas as pd

# 源数据路径
path = '../datasets/originalData/cnn_train.csv'
# 读取数据
df = pd.read_csv(path)
# 提取feature(像素)数据 和 label数据
df_x = df[['feature']]
df_y = df[['label']]
# 将feature和label数据分别写入两个数据集
df_x.to_csv('../datasets/cnn_data.csv', index=False, header=False)
df_y.to_csv('../datasets/cnn_label.csv', index=False, header=False)



# face_view.py
# ###二、数据可视化,将每个数据行的2304个像素值合成每张48*48的表情图。
import cv2
import numpy as np

# 放图片的路径
path = '../images'
# 读取像素数据
data = np.loadtxt('../datasets/cnn_data.csv')

# 按行取数据并写图
for i in range(data.shape[0]):
    face_array = data[i, :].reshape((48, 48))  # reshape
    cv2.imwrite(path + '//' + '{}.jpg'.format(i), face_array)  # 写图片



# cnn_picture_label.py
# ###三、表情图片和类别标注,
# 1.取前24000张图片作为训练集放入cnn_train，其他图片作为验证集放入cnn_val
# 2.对每张图片标记属于哪一个类别，存放在dataset.csv中，分别在刚刚训练集和测试集执行标记任务。

# #因为cpu训练太慢，我只取前2000张做训练，400张做测试！！，手动删除两个文件夹重dataset.csv的多余行数据
import os
import pandas as pd


def data_label(path):
    # 读取label文件
    df_label = pd.read_csv('../datasets/cnn_label.csv', header=None)
    # 查看该文件夹下所有文件
    files_dir = os.listdir(path)
    # 存放文件名和标签的列表
    path_list = []
    label_list = []
    # 遍历所有文件，取出文件名和对应的标签分别放入path_list和label_list列表
    for file_dir in files_dir:
        if os.path.splitext(file_dir)[1] == '.jpg':
            path_list.append(file_dir)
            index = int(os.path.splitext(file_dir)[0])
            label_list.append(df_label.iat[index, 0])

    # 将两个列表写进dataset.csv文件
    path_s = pd.Series(path_list)
    label_s = pd.Series(label_list)
    df = pd.DataFrame()
    df['path'] = path_s
    df['label'] = label_s
    df.to_csv(path + '\\dataset.csv', index=False, header=False)


def main():
    # 指定文件夹路径
    train_path = '../datasets/cnn_train'
    val_path = '../datasets/cnn_val'
    data_label(train_path)
    data_label(val_path)


if __name__ == '__main__':
    main()



# rewrite_dataset.py
# ###四、重写类来实现加载上面的图像数据集。
import bisect
import warnings

import cv2
import numpy as np
import pandas as pd
import torch
import torch.utils.data as data


class FaceDataset(data.Dataset):
    # 初始化
    def __init__(self, root):
        super(FaceDataset, self).__init__()
        self.root = root
        df_path = pd.read_csv(root + '\\dataset.csv', header=None, usecols=[0])
        df_label = pd.read_csv(root + '\\dataset.csv', header=None, usecols=[1])
        self.path = np.array(df_path)[:, 0]
        self.label = np.array(df_label)[:, 0]

    # 读取某幅图片，item为索引号
    def __getitem__(self, item):
        # 图像数据用于训练，需为tensor类型，label用numpy或list均可
        face = cv2.imread(self.root + '\\' + self.path[item])

        # 读取单通道灰度图
        face_gray = cv2.cvtColor(face, cv2.COLOR_BGR2GRAY)

        # 直方图均衡化
        face_hist = cv2.equalizeHist(face_gray)

        """
        像素值标准化
        读出的数据是48X48的，而后续卷积神经网络中nn.Conv2d() 
        API所接受的数据格式是(batch_size, channel, width, height)，
        本次图片通道为1，因此我们要将48X48 reshape为1X48X48。
        """
        face_normalized = face_hist.reshape(1, 48, 48) / 255.0
        face_tensor = torch.from_numpy(face_normalized)
        face_tensor = face_tensor.type('torch.FloatTensor')
        # face_tensor = face_tensor.type('torch.cuda.FloatTensor')
        label = self.label[item]
        return face_tensor, label

    # 获取数据集样本个数
    def __len__(self):
        return self.path.shape[0]



# CNN_face.py
# 定义一个CNN模型
"""
inputs(48*48*1) ->
conv(24*24*64) -> conv(12*12*128) -> conv(6*6*256) ->
Dropout -> fc(4096) -> Dropout -> fc(1024) ->
outputs(7)
"""

import torch.nn as nn


# 参数初始化
def gaussian_weights_init(m):
    classname = m.__class__.__name__
    # 字符串查找find，找不到返回-1，不等-1即字符串中含有该字符
    if classname.find('Conv') != -1:
        m.weight.data.normal_(0.0, 0.04)


class FaceCNN(nn.Module):
    # 初始化网络结构
    def __init__(self):
        super(FaceCNN, self).__init__()

        # layer1(conv + relu + pool)
        # input:(bitch_size, 1, 48, 48), output(bitch_size, 64, 24, 24)
        self.conv1 = nn.Sequential(
            nn.Conv2d(1, 64, 3, 1, 1),
            nn.BatchNorm2d(num_features=64),
            nn.RReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # layer2(conv + relu + pool)
        # input:(bitch_size, 64, 24, 24), output(bitch_size, 128, 12, 12)
        self.conv2 = nn.Sequential(
            nn.Conv2d(64, 128, 3, 1, 1),
            nn.BatchNorm2d(num_features=128),
            nn.RReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        # layer3(conv + relu + pool)
        # input: (bitch_size, 128, 12, 12), output: (bitch_size, 256, 6, 6)
        self.conv3 = nn.Sequential(
            nn.Conv2d(128, 256, 3, 1, 1),
            nn.BatchNorm2d(num_features=256),
            nn.RReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

        # 参数初始化
        self.conv1.apply(gaussian_weights_init)
        self.conv2.apply(gaussian_weights_init)
        self.conv3.apply(gaussian_weights_init)

        # 全连接层
        self.fc = nn.Sequential(
            nn.Dropout(p=0.2),
            nn.Linear(256*6*6, 4096),
            nn.RReLU(inplace=True),

            nn.Dropout(p=0.5),
            nn.Linear(4096, 1024),
            nn.RReLU(inplace=True),

            nn.Linear(1024, 256),
            nn.RReLU(inplace=True),
            nn.Linear(256, 7)
        )

    # 向前传播
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.shape[0], -1)  # 数据扁平化
        y = self.fc(x)

        return y



# train.py
# 定义训练轮
import torch
import torch.utils.data as data
import torch.nn as nn
import numpy as np
from torch import optim

from models import CNN_face
from dataloader import rewrite_dataset


def train(train_dataset, val_dataset, batch_size, epochs, learning_rate, wt_decay, print_cost=True, isPlot=True):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    # 加载数据集并分割batch
    train_loader = data.DataLoader(train_dataset, batch_size)

    # 构建模型
    model = CNN_face.FaceCNN()
    model.to(device)

    # 损失函数和优化器
    compute_loss = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=wt_decay)

    # 学习率衰减
    # scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.8)

    for epoch in range(epochs):
        loss = 0
        model.train()
        for images, labels in train_loader:
            optimizer.zero_grad()
            outputs = model.forward(images)
            loss = compute_loss(outputs, labels)
            loss.backward()
            optimizer.step()

        # 打印损失值
        if print_cost:
            print('epoch{}: train_loss:'.format(epoch + 1), loss.item())

        # 评估模型准确率
        if epoch % 10 == 9:
            model.eval()
            acc_train = validate(model, train_dataset, batch_size)
            acc_val = validate(model, val_dataset, batch_size)
            print('acc_train: %.1f %%' % (acc_train * 100))
            print('acc_val: %.1f %%' % (acc_val * 100))

    return model


# 验证模型在验证集上的正确率
def validate(model, dataset, batch_size):
    val_loader = data.DataLoader(dataset, batch_size)
    result, total = 0.0, 0
    for images, labels in val_loader:
        pred = model.forward(images)
        pred_tmp = pred.cuda().data.cpu().numpy()
        pred = np.argmax(pred_tmp.data.numpy(), axis=1)
        labels = labels.data.numpy()
        result += np.sum((pred == labels))
        total += len(images)
    acc = result / total
    return acc


def main():
    train_dataset = rewrite_dataset.FaceDataset(root=r'D:\01 Desktop\JUST_YAN\05 DeepLearning\Facial-expression_Reg\datasets\cnn_train')
    val_dataset = rewrite_dataset.FaceDataset(root=r'D:\01 Desktop\JUST_YAN\05 DeepLearning\Facial-expression_Reg\datasets\cnn_val')
    model = train(train_dataset, val_dataset, batch_size=128, epochs=100, learning_rate=0.01,
                  wt_decay=0, print_cost=True, isPlot=True)
    torch.save(model, 'model_net.pkl')  # 保存模型


if __name__ == '__main__':
    main()