人脸表情识别是计算机视觉中一个重要的领域，近年来得到了广泛的研究和应用。PyTorch是一种基于Python的机器学习库，它支持动态计算图，具有易用性和高效性。

在PyTorch中，可以使用深度学习模型来进行人脸表情识别。常用的模型包括卷积神经网络（CNN）和循环神经网络（RNN）等。其中，CNN已经成为了人脸表情识别的主流模型，因为它可以自动从图像中提取特征，从而更好地理解图像。

下面是一个简单的PyTorch代码示例，用于训练和测试CNN模型进行人脸表情识别：

import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder

# 定义CNN模型
class CNNModel(nn.Module):
    def __init__(self):
        super(CNNModel, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.layer2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.layer3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.layer4 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.layer5 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.fc1 = nn.Linear(512 * 7 * 7, 1024)
        self.dropout = nn.Dropout(0.5)
        self.fc2 = nn.Linear(1024, 7)

    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = self.layer5(out)
        out = out.view(out.size(0), -1)
        out = self.fc1(out)
        out = self.dropout(out)
        out = self.fc2(out)
        return out

# 定义数据预处理
transforms = transforms.Compose([
    transforms.Resize(48),
    transforms.CenterCrop(48),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

# 加载数据
train_dataset = ImageFolder('train', transform=transforms)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = ImageFolder('test', transform=transforms)
test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=True)

# 初始化模型
model = CNNModel()

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

# 训练模型
num_epochs = 30
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_dataloader):
        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], Step [%d/%d], Loss: %.4f'
                 % (epoch+1, num_epochs, i+1, len(train_dataset)//64, loss.data[0]))

# 测试模型
correct = 0
total = 0
for images, labels in test_dataloader:
    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))

在上面的代码中，首先定义了一个CNN模型，该模型由五个卷积层和两个全连接层组成。然后定义了数据预处理操作，并将训练和测试数据集加载到DataLoader中。接下来，初始化模型、定义损失函数和优化器，并使用训练数据对模型进行训练。最后，使用测试数据对模型进行测试，并计算准确率。

需要注意的是，这里使用的训练和测试数据集是预处理好的图像数据集，其中每个图像都被标记为一种表情类别。因此，在实际应用中，需要准备好符合要求的数据集，并进行必要的数据预处理和标记。