神经网络-人脸表情识别

情绪检测

情绪检测或表情分类在深度学习领域中有着广泛的研究。使用电脑摄像头和一些简单的代码我们就可以对情绪进行实时分类。 需要预先掌握的知识：

• Python基础

• OpenCV基础

• 卷积神经网络（CNN）

• pytorch基础

训练集： 本文共使用28000张人脸情绪图片作为训练样本，类别分为愤怒、害怕、高兴、正常、悲伤、惊讶6个类。

测试集： 本文共使用3500张人脸情绪图片作为测试样本，用来测试神经网络模型的效果。

该数据集属于公开数据集，约3w张分好类的人脸灰度图。其数据类别分布不均衡，所以对于某些类别的预测不准确。数据集公众号回复：emotion_data 即可下载

定义网络模型

本文使用卷积神经网络，代码如下：

# 定义卷积神经网络，这里使用5层的神经网络
import torch
import torch.nn as nn
class CNN5(nn.Module):
    def __init__(self):
        super(CNN5, self).__init__()
        self.conv1 = nn.Conv2d(1, 64, kernel_size=(3, 3),padding=1)
        self.relu = nn.ReLU()
        self.maxpool1 = nn.MaxPool2d(kernel_size=(2, 2) )
        self.conv2 = nn.Conv2d(64, 256, kernel_size=(3, 3))
        self.maxpool2 = nn.MaxPool2d(kernel_size=(2, 2) )
        self.fc1 = nn.Linear(256*7*7, 4096)
        self.fc2 = nn.Linear(4096, 1024)
        self.fc3 = nn.Linear(1024, 6)

    def forward(self, img):
        output = self.conv1(img)
        output = self.relu(output)
        output = self.maxpool1(output)

        output = self.conv2(output)
        output = self.relu(output)
        output = self.maxpool2(output)

        feature = output.view(-1, 256*7*7)

        output = self.fc1(feature)
        output = self.relu(output)
        output = self.fc2(output)
        output = self.relu(output)
        output = self.fc3(output)
        return output

读取数据集

定义好了卷积网络接着需要读取文件夹中的训练数据集，并进行数据增强、归一化等操作。代码如下：

def get_emotion_data(args):
    #args参数封装，理解为参数字典
    train_loader = torch.utils.data.DataLoader(
        datasets.ImageFolder(args.data_root+'train',
                       transform=transforms.Compose([
                           transforms.Resize((32, 32)),
                           transforms.ToTensor(),
                           transforms.Grayscale(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=args.batch_size, shuffle=True, num_workers=2)
        
    test_loader = torch.utils.data.DataLoader(
        datasets..ImageFolder(args.data_root+'validation',
                       transform=transforms.Compose([
                           transforms.Resize((32, 32)),
                           transforms.ToTensor(),
                           transforms.Grayscale(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=args.batch_size, shuffle=True, num_workers=2)

   return train_loader , test_loader

训练方法

def my_train(args, model, device, train_loader, optimizer, epoch):
  model.train()
  for idx, (data, target) in enumerate(train_loader):
      data, target = data.to(device), target.to(device)
      optimizer.zero_grad()
      output = model(data)
      loss = F.cross_entropy(output, target)
      loss.backward()
      optimizer.step()

      if (idx+1) % 20 == 0:
          print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
              epoch, idx * len(data), len(train_loader.dataset),
              100. * idx / len(train_loader), loss.item()))

测试方法

def my_test(args, model, device, test_loader, cur_epoch):
  model.eval()
  test_loss = 0
  correct = 0
  with torch.no_grad():
      for data, target in test_loader:
          data, target = data.to(device), target.to(device)
          output = model(data)
          test_loss += F.cross_entropy(output, target, reduction='sum').item() # sum up batch loss
          pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability
          correct += pred.eq(target.view_as(pred)).sum().item()

  test_loss /= len(test_loader.dataset)

  print('\nEpoch {} Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.4f}%)'.format(
      cur_epoch, test_loss, correct, len(test_loader.dataset),
      100. * correct / len(test_loader.dataset)))
  return correct/len(test_loader.dataset)

main方法

if __name__ == '__main__':
  #封装参数
  parser = argparse.ArgumentParser()
  parser.add_argument('--data_root', type=str, default='Q:\cache\emotion\\')
  parser.add_argument('--batch_size', type=int, default=128, metavar='N',
                      help='input batch size for training (default: 64)')
  parser.add_argument('--lr', type=float, default=0.1, metavar='LR',
                      help='learning rate (default: 0.1)')
  parser.add_argument('--weight_decay', type=float, default=5e-4)
  parser.add_argument('--epochs',type=int,default=30)
  parser.add_argument('--momentum', type=float, default=0.9, metavar='M',
                      help='SGD momentum (default: 0.9)')
  args = parser.parse_args()

  device = "cuda" if torch.cuda.is_available() else "cpu"
  print('运行在{}上...'.format(device))

  #实例化模型
  model = LeNet5().to(device)

  #定义优化器
  optimizer = optim.SGD(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, momentum=args.momentum)

  #加载数据
  train_loader,test_loader = get_emotion_data(args)


  best_acc=0
  for epoch in range(1, args.epochs + 1):
      my_train(args, model, device, train_loader, optimizer, epoch)
      acc = my_test(args, model, device, test_loader, epoch)
      if acc>best_acc:
          best_acc = acc
          torch.save(model.state_dict(),"models/emotion.ckpt")
  print("Best Acc=%.6f"%best_acc)

本文默认运行30个epoch，最后保存准确率最高为52.8%的模型。完整代码关注本公众号回复:"情绪检测代码"即可获得完整源码。这个准确率其实一言难尽，目前使用ResNet网络来训练准确率也只有60%左右，因为这个数据集的自身分类误差就很大，加之数据类别不均衡等原因导致识别难度大。这依旧是具有挑战性的研究，在CVPR、Kaggle等比赛中，人脸情绪识别依旧很火热。本文作为入门实验在这里不做深入探究。

使用表情检测模型

当我们训练完识别模型后我们可以用来检测视频中的人物表情或者摄像头拍摄到的人物表情，这里基于OpenCV来实现。其实我们用来训练的是人脸，所以首先我们需要检测出人脸，我们当然可以训练一个神经网络用来检测人脸，但是本期介绍主要介绍图片分类，所以检测人脸我们直接调用OpenCV的模型。OpenCV自带的人脸检测表现的非常糟糕，有兴趣的小伙伴有手就行可以轻松训练人脸检测的网络轻轻松松超越OpenCV自带的模型。该部分代码获取公众号回复"情绪检测"即可获取！

公众号：矩阵科学