基于pytorch的人脸表情识别

人脸表情识别是计算机视觉领域的一个研究热点，通过分析人脸图像中的表情信息，可以识别出人的情感状态。基于 PyTorch 的人脸表情识别可以使用卷积神经网络来提取图像特征，然后使用全连接层进行分类。以下是一个基于 PyTorch 的人脸表情识别的简单代码示例：

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable

# 定义超参数
batch_size = 100
num_epochs = 10
learning_rate = 0.001

# 加载数据集
train_dataset = dsets.ImageFolder(root='train',
                                   transform=transforms.Compose([
                                       transforms.Grayscale(),  # 转换为灰度图像
                                       transforms.Resize(48),  # 调整图像大小
                                       transforms.RandomHorizontalFlip(),  # 随机水平翻转
                                       transforms.ToTensor()]))  # 转换为张量

test_dataset = dsets.ImageFolder(root='test',
                                  transform=transforms.Compose([
                                      transforms.Grayscale(),
                                      transforms.Resize(48),
                                      transforms.ToTensor()]))

# 加载数据集到 DataLoader
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 64, kernel_size=5)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=5)
        self.fc1 = nn.Linear(128 * 9 * 9, 1024)
        self.fc2 = nn.Linear(1024, 7)

    def forward(self, x):
        x = nn.functional.relu(self.conv1(x))
        x = nn.functional.max_pool2d(x, kernel_size=2, stride=2)
        x = nn.functional.relu(self.conv2(x))
        x = nn.functional.max_pool2d(x, kernel_size=2, stride=2)
        x = x.view(-1, 128 * 9 * 9)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = Net()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = Variable(images)
        labels = Variable(labels)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        if (i + 1) % 10 == 0:
            print('Epoch [%d/%d], Iter [%d/%d] Loss: %.4f'
                  % (epoch + 1, num_epochs, i + 1, len(train_dataset) // batch_size, loss.item()))

# 测试模型
correct = 0
total = 0
for images, labels in test_loader:
    images = Variable(images)
    outputs = model(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy of the model on the test images: %d %%' % (100 * correct / total))

在这个代码示例中，我们先定义了超参数，包括 batch_size、num_epochs、learning_rate 等。然后我们使用 PyTorch 提供的 `ImageFolder` 类加载了数据集，将图像转换为灰度图像，调整图像大小并转换为张量。我们使用 `DataLoader` 将数据集加载到内存中，以便进行批量处理。接下来，我们定义了一个基于卷积神经网络的模型，包括两个卷积层和两个全连接层。我们使用交叉熵损失函数和 Adam 优化器进行训练。最后，我们使用测试集评估模型的性能。