基于AlexNet改进的多尺寸卷积网络人脸表情识别_Fer2013_JAFFE

1. 样本数量：

   • FER-2013 包含 35,887 张灰度图像。

   • 图像分为 训练集（28,709 张）、验证集（3,589 张）和 测试集（3,589 张）。

2. 表情类别：

   • 7 种基本表情类别：

     1. Anger（生气）

     2. Disgust（厌恶）

     3. Fear（恐惧）

     4. Happy（高兴）

     5. Sad（悲伤）

     6. Surprise（惊讶）

     7. Neutral（中性）

3. 图像格式：

   • 图像为灰度图，分辨率为 48x48 像素。

   • 每张图像以像素值的形式存储在一个 CSV 文件中。

4. 数据来源：

   • 图像是通过 Google 图像搜索 API 收集的，涵盖了不同年龄、性别和种族的人群。

   • 数据集具有较高的多样性，但也包含一些噪声（如标注错误、模糊图像等）。

由于其是CSV文件，图像没有直观的展示，可使用如下代码查看：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


# 加载 FER2013 数据集
def load_fer2013(file_path):
    data = pd.read_csv(file_path)
    pixels = data['pixels'].tolist()
    emotions = data['emotion'].tolist()
    return pixels, emotions


# 将像素字符串转换为图像数组
def string_to_image(pixel_string):
    pixel_list = list(map(int, pixel_string.split()))
    image_array = np.array(pixel_list).reshape(48, 48)
    return image_array


# 显示图像
def show_image(image_array, emotion):
    plt.imshow(image_array, cmap='gray')
    plt.title(f'Emotion: {emotion}')
    plt.axis('off')
    plt.show()


file_path = 'fer2013.csv'  # 替换为你的文件路径
pixels, emotions = load_fer2013(file_path)

# 显示前 100 张图片
for i in range(100):
    image_array = string_to_image(pixels[i])
    show_image(image_array, emotions[i])

最后就是基于上述内容，进行图像预处理，损失函数的改进，模型训练代码的编写：

import numpy as np
import pandas as pd
from PIL import Image
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms


# 自定义数据集类
class Fer2013Dataset(Dataset):
    def __init__(self, csv_file, usage='Training', transform=None):
        """
        Args:
            csv_file (str): Fer2013 数据集的 CSV 文件路径。
            usage (str): 数据集用途，可选 'Training', 'PublicTest', 'PrivateTest'。
            transform (callable, optional): 数据预处理方法。
        """
        self.data = pd.read_csv(csv_file)
        self.data = self.data[self.data['Usage'] == usage]  # 根据 Usage 筛选数据
        self.transform = transform

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        # 获取图像数据（字符串形式）
        image_data = self.data.iloc[idx, 1]  # 第二列是像素数据
        # 将字符串转换为 numpy 数组
        image = np.array([int(pixel) for pixel in image_data.split()], dtype=np.uint8)
        image = image.reshape(48, 48)  # Fer2013 图像尺寸为 48x48
        # 转换为 PIL 图像
        image = Image.fromarray(image)
        # 获取标签
        label = self.data.iloc[idx, 0]  # 第一列是标签
        # 数据增强和预处理
        if self.transform:
            image = self.transform(image)
        return image, label


import torch.nn as nn
import torch.nn.functional as F


# 焦点损失函数实现
class FocalLoss(nn.Module):
    def __init__(self, alpha=0.25, gamma=2.0, reduction='mean'):
        """
        Args:
            alpha (float/tensor): 类别权重，可设为标量（平衡因子）或各类别权重的张量
            gamma (float): 难易样本调节因子
            reduction (str): 损失聚合方式 ('mean', 'sum', 'none')
        """
        super(FocalLoss, self).__init__()
        self.alpha = alpha
        self.gamma = gamma
        self.reduction = reduction

    def forward(self, inputs, targets):
        # 计算交叉熵损失
        ce_loss = F.cross_entropy(inputs, targets, reduction='none')  # [N]

        # 计算概率 p_t
        p = torch.exp(-ce_loss)  # p_t = exp(-CE)

        # 计算焦点损失
        focal_loss = (self.alpha * (1 - p) ** self.gamma * ce_loss)  # [N]

        # 聚合方式
        if self.reduction == 'mean':
            return focal_loss.mean()
        elif self.reduction == 'sum':
            return focal_loss.sum()
        else:
            return focal_loss


# 数据预处理管道
transform_train = transforms.Compose([
    transforms.Grayscale(num_output_channels=3),  # 转为 3 通道
    transforms.Resize((227, 227)),  # 调整尺寸为 227x227
    transforms.RandomHorizontalFlip(),  # 随机水平翻转
    transforms.RandomRotation(10),  # 随机旋转
    transforms.ToTensor(),  # 转为 Tensor
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])  # 标准化
])

transform_test = transforms.Compose([
    transforms.Grayscale(num_output_channels=3),  # 转为 3 通道
    transforms.Resize((227, 227)),  # 调整尺寸为 227x227
    transforms.ToTensor(),  # 转为 Tensor
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])  # 标准化
])

# 加载数据集
train_dataset = Fer2013Dataset(csv_file='../fer2013.csv', usage='Training', transform=transform_train)
val_dataset = Fer2013Dataset(csv_file='../fer2013.csv', usage='PublicTest', transform=transform_test)
test_dataset = Fer2013Dataset(csv_file='../fer2013.csv', usage='PrivateTest', transform=transform_test)

# 创建数据加载器
batch_size = 64
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

import torch
import torch.optim as optim
from tqdm import tqdm
from AlexNET import AlexNet_pro

# 设备配置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 初始化模型
model = AlexNet_pro(num_classes=7).to(device)

# 定义损失函数和优化器
criterion = FocalLoss(alpha=0.25, gamma=2.0).to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

# 训练参数
num_epochs = 30
best_acc = 0.0

# 训练循环
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    # 训练阶段
    for images, labels in tqdm(train_loader, desc=f"Epoch {epoch + 1}/{num_epochs}"):
        images = images.to(device)
        labels = labels.to(device)

        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # 统计损失和准确率
        running_loss += loss.item()
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()

    # 计算训练损失和准确率
    train_loss = running_loss / len(train_loader)
    train_acc = 100.0 * correct / total

    # 验证阶段
    model.eval()
    val_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in val_loader:
            images = images.to(device)
            labels = labels.to(device)

            outputs = model(images)
            loss = criterion(outputs, labels)

            val_loss += loss.item()
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()

    # 计算验证损失和准确率
    val_loss /= len(val_loader)
    val_acc = 100.0 * correct / total

    # 打印结果
    print(f"Epoch [{epoch + 1}/{num_epochs}] "
          f"Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}% | "
          f"Val Loss: {val_loss:.4f}, Val Acc: {val_acc:.2f}%")

    # 保存最佳模型
    if val_acc > best_acc:
        best_acc = val_acc
        torch.save(model.state_dict(), "model_Fer2013.pth")

    # 更新学习率
    scheduler.step()

# 测试阶段
model.load_state_dict(torch.load("model_Fer2013.pth"))
model.eval()
test_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)

        outputs = model(images)
        loss = criterion(outputs, labels)

        test_loss += loss.item()
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()

# 计算测试损失和准确率
test_loss /= len(test_loader)
test_acc = 100.0 * correct / total

print(f"Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.2f}%")
print(f"Training complete. Best validation accuracy: {best_acc:.2f}%")

训练时间略久，1h左右，因GPU而异

在Fer2013上的表现其实感觉一般，可以考虑用JAFFE横向对比，看看是否有改进。

以下代码是在 JAFFE上训练测试：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets, models
from torch.utils.data import DataLoader, random_split
import os
from AlexNET import AlexNet_pro

# 设备配置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

import cv2
import numpy as np
from PIL import Image


# 定义图像预处理方法
def preprocess_image(image):
    # 1. 将图像转为灰度
    image_gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)

    # 2. 进行直方图均衡化
    image_eq = cv2.equalizeHist(image_gray)

    # 3. 转换回三通道，复制灰度值到R, G, B通道
    image_eq_rgb = cv2.cvtColor(image_eq, cv2.COLOR_GRAY2RGB)

    # 将图像转换为PIL格式
    return Image.fromarray(image_eq_rgb)

import torch.nn as nn
import torch.nn.functional as F


# 焦点损失函数实现
class FocalLoss(nn.Module):
    def __init__(self, alpha=0.25, gamma=2.0, reduction='mean'):
        """
        Args:
            alpha (float/tensor): 类别权重，可设为标量（平衡因子）或各类别权重的张量
            gamma (float): 难易样本调节因子
            reduction (str): 损失聚合方式 ('mean', 'sum', 'none')
        """
        super(FocalLoss, self).__init__()
        self.alpha = alpha
        self.gamma = gamma
        self.reduction = reduction

    def forward(self, inputs, targets):
        # 计算交叉熵损失
        ce_loss = F.cross_entropy(inputs, targets, reduction='none')  # [N]

        # 计算概率 p_t
        p = torch.exp(-ce_loss)  # p_t = exp(-CE)

        # 计算焦点损失
        focal_loss = (self.alpha * (1 - p) ** self.gamma * ce_loss)  # [N]

        # 聚合方式
        if self.reduction == 'mean':
            return focal_loss.mean()
        elif self.reduction == 'sum':
            return focal_loss.sum()
        else:
            return focal_loss

# 图像预处理管道
transform = transforms.Compose([
    transforms.Resize(256),  # 图像调整为 256*256
    transforms.CenterCrop(227),  # 中心裁剪 227*227
    transforms.Lambda(lambda x: preprocess_image(x)),  # 自定义预处理方法
    transforms.ToTensor(),  # 转为Tensor
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])  # 标准化
])

# 加载数据集
dataset_path = "../jaffe"
full_dataset = datasets.ImageFolder(root=dataset_path, transform=transform)

# 划分训练集和验证集 (85-15)
train_size = int(0.85 * len(full_dataset))
val_size = len(full_dataset) - train_size
train_dataset, val_dataset = random_split(full_dataset, [train_size, val_size])

# 创建数据加载器
batch_size = 64
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)

# 初始化模型
model = AlexNet_pro(num_classes=7).to(device)

# 定义损失函数和优化器
criterion = FocalLoss(alpha=0.25, gamma=2.0).to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练参数
num_epochs = 100
best_acc = 0.0

# 训练循环
for epoch in range(num_epochs):
    # 训练阶段
    model.train()
    running_loss = 0.0
    for images, labels in train_loader:
        images = images.to(device)
        labels = labels.to(device)

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

        running_loss += loss.item() * images.size(0)

    epoch_loss = running_loss / len(train_dataset)

    # 验证阶段
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in val_loader:
            images = images.to(device)
            labels = labels.to(device)

            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    acc = 100 * correct / total

    print(f"Epoch [{epoch + 1}/{num_epochs}] "
          f"Train Loss: {epoch_loss:.4f} "
          f"Val Acc: {acc:.2f}%")

    # 保存最佳模型
    if acc > best_acc:
        best_acc = acc
        torch.save(model.state_dict(), "model_JAFFE.pth")

print(f"Training complete. Best validation accuracy: {best_acc:.2f}%")

对比原始的AlexNet，有显著提升！！