Python深度学习实战：人脸表情识别系统从训练到部署

简介：这套Python人脸表情识别系统是一份面向高校课程设计与深度学习入门者的完整工程，以卷积神经网络为核心，实现从人脸检测、表情分类到结果可视化的全流程，包含训练、测试、GUI交互和摄像头实时识别等主要功能模块。压缩包共19个文件，其中10个Python脚本是整个系统的主体，分别承担数据读取、模型构建、训练推理、界面展示等任务；此外还包含演示文稿与Markdown说明文档、卷积神经网络结构图、中文字体文件以及若干JPG效果图，便于对照阅读和二次开发。资源整体大小约10.81MB，代码均经过本地编译运行，评审评分为95分以上，难度适中，适合作为课程设计、毕业设计或深度学习入门的参考项目。目前已有204人浏览学习。下载后可以获得可运行的项目源码、配套数据集、依赖库清单和完整说明文档，其中演示文稿、网络结构图和中文字体文件都有助于快速理解系统和二次开发。

1. 人脸表情识别不是猜情绪，是一条可复现的深度学习流水线

人脸表情识别这几年在课程设计和简历里出现频率很高，但多数人把它当成一个“图像分类”任务来做：找模型、训数据、出准确率，完事。真正到了答辩现场，老师问一句“光照变了为什么准确率掉一半”“你这个模型在视频里为什么一卡一卡的”，很多人就答不上来了。这篇博文就围绕“Python + 深度学习”这条主线，把一套人脸表情识别系统的设计与实现拆开讲：从模型选型、数据集处理、训练调参，到模型导出和实时视频推理，最后落到一个很多人没做但效果很明显的关键帧平滑技巧。无论你是要交课程设计、准备毕业设计，还是想在自己的项目里快速接入表情识别能力，这篇文章都能让你少走弯路。

2. 系统设计与数据集准备：用 Python 搭起深度学习的“地基”

2.1 模型选型：不盲目追求大网络，要匹配场景

人脸表情识别本质上是一个图像分类任务，输入是一张人脸图，输出是情绪类别（如开心、悲伤、惊讶等）。常见做法有两种：一种是直接使用在 ImageNet 上预训练过的 ResNet、MobileNet 等模型做迁移学习，另一种是从零训练一个轻量级 CNN。很多人一上来就选 ResNet50，理由是“越深越准”，实际上在表情识别这种细粒度分类任务上，ResNet50 的参数量大，推理慢，且在小数据集上很容易过拟合。

我在做课程设计这类场景时，通常推荐 MobileNetV3 或 ResNet18 作为主干网络。MobileNetV3 的参数量约为 4.2M，配合深度可分离卷积，在 CPU 上跑一帧 48x48 的灰度人脸图只需要 10 毫秒左右，准确率并不会比 ResNet50 差太多。下表是我在 fer2013 数据集上对比过的实测数据（训练集 28000 张、验证集 7000 张、测试集 7000 张的划分方式）供参考：

注意一个关键点：fer2013 是一个灰度 48x48 的数据集，类别是 angry、disgust、fear、happy、sad、surprise、neutral 七类。如果你的系统面向的是视频流实时识别，选 MobileNetV3 会更实际；如果只要求离线图片分类准确率，ResNet18 是性价比最高的选择。

2.2 数据集的下载与目录组织

人脸表情识别公开数据集常见的有 fer2013、RAF-DB、CK+、AffectNet 等。课程设计阶段最常用的是 fer2013，因为它的规模适中、标签已标注。这个数据集在 Kaggle 上有原始 CSV 格式的版本，每行包含 emotion 标签和 48x48 像素灰度值。下载后先做预处理，把 CSV 里的灰度数组拆成图片文件，或者直接写成 PyTorch 的 Dataset 类。

我建议把项目按下列目录结构组织，这样后续训练、评估、部署都清晰：

face-expression-recognition/ ├── dataset/ │ ├── train/ │ │ ├── angry/ │ │ ├── happy/ │ │ └── ... │ ├── val/ │ └── test/ ├── models/ │ └── mobilenetv3.py # 模型定义 ├── train.py # 训练脚本 ├── infer.py # 单张图片推理 ├── webapp/ # Web 演示端 ├── weights/ # 模型权重文件 └── requirements.txt

如果你拿到的是 CSV 格式的 fer2013，写个简单的 Python 脚本就能转换成图片目录。核心是利用PIL.Image的frombytes方法把 48x48 像素值还原成图片：

import pandas as pd import numpy as np from PIL import Image import os df = pd.read_csv('fer2013.csv') for split_name in ['Training', 'PublicTest', 'PrivateTest']: split_df = df[df['Usage'] == split_name] target_dir = f'dataset/{split_name.replace("PublicTest", "val").replace("PrivateTest", "test")}' os.makedirs(target_dir, exist_ok=True) for idx, row in split_df.iterrows(): pixels = np.array(row['pixels'].split(), dtype=np.uint8).reshape(48, 48) emotion = str(row['emotion']) class_dir = os.path.join(target_dir, emotion) os.makedirs(class_dir, exist_ok=True) Image.fromarray(pixels).save(os.path.join(class_dir, f'{idx}.png'))

这段脚本把 CSV 中每张图片的 2304 个像素（48*48）还原成灰度图，并按 7 类情绪分别保存。iterrows()在数据量约 35000 张时会偏慢，但课程设计场景完全够用；如果想提速，可以改用df.itertuples()或者先转成 numpy 数组批量处理。

2.3 数据增强：把 28000 张图变出“看不完”的训练集

fer2013 最大的问题是类间样本不均衡。比如 disgust 这个类别的样本只有几百张，而 happy 有近万张。不处理这个问题，模型训练出的结果会是“要么永远预测 happy，要么 disgust 永远学不会”。解决办法有两种：一种是设置类别权重，在损失函数中放大低频类别的梯度；另一种是数据增强，让每个类别在训练中呈现更多变体。

我常用的增强策略是随机水平翻转（label 不变）、随机旋转 10 度、随机亮度对比度扰动，以及重点是 Cutout，也就是随机遮挡人脸某一块区域，逼迫模型不依赖单一局部特征。这部分如果用 PyTorch 实现非常简洁：

import torchvision.transforms as T train_transform = T.Compose([ T.RandomHorizontalFlip(p=0.5), T.RandomRotation(degrees=10), T.ColorJitter(brightness=0.2, contrast=0.2), T.RandomResizedCrop(size=(48, 48), scale=(0.8, 1.0)), T.ToTensor(), T.Normalize(mean=[0.5], std=[0.5]) ])

这里有一个容易被忽略的细节：fer2013 的像素值本身是 0 到 255 的整数，归一化时用mean=0.5, std=0.5可以把像素映射到 -1 到 1 之间，有助于训练时的梯度稳定性。RandomResizedCrop是在裁剪后再缩放到 48x48，等于同时做了随机裁剪和尺度扰动。模型推理时不需要这些随机变换，只做ToTensor()和归一化即可。

3. 深度学习模型训练：用 PyTorch 把准确率一步步“压”到 62% 以上

3.1 数据加载与训练循环的最小实现

数据准备完成后，下一步就是写Dataset类和数据加载器。PyTorch 的ImageFolder可以直接读取目录形式的图片数据，不需要自定义__getitem__方法。加载器代码如下：

from torchvision import datasets train_ds = datasets.ImageFolder('dataset/train', transform=train_transform) val_ds = datasets.ImageFolder('dataset/val', transform=val_transform) train_loader = DataLoader(train_ds, batch_size=64, shuffle=True, num_workers=4, pin_memory=True) val_loader = DataLoader(val_ds, batch_size=64, shuffle=False)

batch_size=64是一个保守的选择。如果你的显卡显存是 4GB 以上，可以调到 128；如果是 CPU 训练，建议把 batch_size 降到 32，否则一次迭代的耗时会让整个训练过程变得没有耐心。num_workers=4表示用 4 个子进程预取数据，能在数据加载阶段省下大量等待时间，但 Windows 下如果报BrokenPipeError，把它改为 0 就行。

训练循环的主体就是三件事：前向传播、计算损失、反向传播。这里用 MobileNetV3-Small 做主干，并在模型定义里把最后一层全连接换成 7 分类输出：

import torch.nn as nn from torchvision.models import mobilenet_v3_small class ExpressionModel(nn.Module): def __init__(self, num_classes=7): super().__init__() self.backbone = mobilenet_v3_small(weights='DEFAULT') # 替换最后一层分类头 in_features = self.backbone.classifier[-1].in_features self.backbone.classifier[-1] = nn.Linear(in_features, num_classes) def forward(self, x): return self.backbone(x)

这里使用weights='DEFAULT'加载了 ImageNet 预训练权重，再只替换最后一层全连接。原分类头输出 1000 类，替换成 7 类后，训练时新层会快速收敛，backbone 的底层特征也能保持预训练时的判别力。需要注意，训练初期要把 backbone 的梯度置为False，先只训练分类头几个 epoch，再解锁全部参数做微调。这种做法叫 layer-wise fine-tuning，能有效防止一开始就破坏底层特征。

3.2 三个关键训练参数：学习率、损失函数、早停

课程设计项目失败的原因，往往不是模型太差，而是训练策略不对。以下三个参数是我试验多轮后最值得注意的：

学习率方面，我建议使用AdamW优化器，权重衰减设为 1e-4。AdamW 相比传统的 Adam，把权重衰减和梯度更新解耦了，在视觉任务上普遍有更好的泛化效果。如果在验证集上损失一直在 1.3 附近横跳，多半是学习率偏大，把它降到 1e-4 后通常会很快看到下降。

损失函数这里建议用LabelSmoothing。原因在于人脸表情数据集本身存在标注噪声——一张脸既可以被认为是“中性”，也可以被认为是“悲伤”，硬标签会让模型为学出 100% 置信度而过度自信。用LabelSmoothing=0.1即可，即在计算交叉熵时，把真实标签的 one-hot 向量变成一个平滑的分布，真实类概率约 0.9，其余类共享 0.1。

早停是利用验证集损失控制的，不达标就提前终止：

best_loss = float('inf') patience = 10 bad_epochs = 0 for epoch in range(50): train_one_epoch(model, train_loader, criterion, optimizer) val_loss = evaluate(model, val_loader, criterion) if val_loss < best_loss: best_loss = val_loss bad_epochs = 0 torch.save(model.state_dict(), 'weights/best_model.pth') else: bad_epochs += 1 if bad_epochs >= patience: print(f"Early stopping at epoch {epoch}") break

这段逻辑的核心是：每个 epoch 结束后比较验证集损失，一旦连续 10 个 epoch 没有创新低就让训练停止，同时保留历史最优权重。很多人不写保存最优模型这一步，训练结束拿一个中间权重去测试，最后准确率低还找不到原因。torch.save只保存 state_dict 不保存整个模型，一是文件小，二是跨环境加载更稳定。

3.3 在验证集上怎么观察：混淆矩阵让你看到模型的“误解”

训练结束后看准确率是不够的。表情识别里常见的错误是 surprise 被预测为 fear、angry 被预测为 neutral。把验证集所有样本跑一遍，生成混淆矩阵，能立刻看出哪两类被模型混淆得严重。用 sklearn 和 matplotlib 各十几行代码就能画出来：

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay import matplotlib.pyplot as plt model.eval() all_preds, all_labels = [], [] with torch.no_grad(): for imgs, labels in val_loader: preds = model(imgs).argmax(dim=1).cpu().numpy() all_preds.extend(preds) all_labels.extend(labels.numpy()) cm = confusion_matrix(all_labels, all_preds) disp = ConfusionMatrixDisplay(cm, display_labels=val_ds.classes) disp.plot(cmap='Blues') plt.savefig('result/confusion_matrix.png', dpi=150)

如果看到 fear 和 surprise 之间混得很厉害，这其实符合认知规律，因为这两类表情在面部肌肉运动模式上有重叠（眉毛提升、眼睛睁大）。处理思路有两层：一是检查数据样本，看是不是标签错了；二是在预测后处理阶段，对这两类降低置信度阈值。后一种做法后面第 5 章会详细讲。

4. 系统实现与部署：让模型跑在摄像头画面里

4.1 用 OpenCV 的 Haar 级联检测人脸，再送入表情模型

模型本身只负责“识别人脸的表情”，没有人脸检测能力。在实时系统里，我通常用 OpenCV 自带的 Haar 级联分类器做人脸检测，然后用同一帧里检测出的人脸区域送入表情模型。虽然深度学习人脸检测器（如 MTCNN、RetinaFace）更准，但在 CPU 上做实时处理时，Haar 级联的延迟低一个数量级。课程设计的答辩现场，用摄像头演示，操作者的脸只要正对镜头，Haar 级联的效果足够。

import cv2 face_cascade = cv2.CascadeClassifier( cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') cap = cv2.VideoCapture(0) # 打开默认摄像头 while True: ret, frame = cap.read() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale( gray, scaleFactor=1.1, minNeighbors=5, minSize=(48, 48)) for (x, y, w, h) in faces: roi = gray[y:y+h, x:x+w] roi = cv2.resize(roi, (48, 48)) tensor = torch.from_numpy(roi).float().unsqueeze(0).unsqueeze(0) tensor = (tensor / 255.0 - 0.5) / 0.5 with torch.no_grad(): logits = model(tensor) label = logits.argmax(dim=1).item() cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2) cv2.putText(frame, val_ds.classes[label], (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2) cv2.imshow('Expression Recognition', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

这段代码里有个容易出现 bug 的地方：cv2.resize默认插值会把灰度图缩放到 48x48，但输入到模型前一定要做和设备训练时一致的归一化处理，也就是(原始像素/255 - 0.5)/0.5。很多人训练时用Normalize(0.5, 0.5)，推理时忘了归一化，结果准确率直接掉到 20% 以下，这是最典型的低级错误。

4.2 把 PyTorch 模型导出为 ONNX，让推理不依赖训练框架

课程设计如果只在本机跑 PyTorch 模型，答辩演示没问题，但如果你想在演示机器上避免装完整 PyTorch 环境，或者想展示系统的工程完整度，把模型导出为 ONNX 格式再用 ONNXRuntime 推理，是更稳妥的方案。导出代码很短：

dummy_input = torch.randn(1, 1, 48, 48) torch.onnx.export( model.cpu(), dummy_input, 'weights/expression_model.onnx', input_names=['input'], output_names=['output'], dynamic_axes={'input': {0: 'batch'}, 'output': {0: 'batch'}}, opset_version=11 )

dynamic_axes设置 batch 维度为动态，这样导出的模型后续可以接受任意 batch 大小的输入。opset_version=11是一个兼容性很好的版本，几乎任何版本的 ONNXRuntime 都能加载。导出后推理时，模型不再依赖 PyTorch 的model.eval()、torch.no_grad()等上下文管理，直接用onnxruntime的InferenceSession运行：

import onnxruntime as ort import numpy as np session = ort.InferenceSession('weights/expression_model.onnx') input_name = session.get_inputs()[0].name def infer_onnx(face_tensor): preds = session.run(None, {input_name: face_tensor.numpy()})[0] return np.argmax(preds, axis=1).item()

导出的好处是明显的：目标机器只需要安装onnxruntime（不到 100MB 的依赖），省去了安装 PyTorch、torchvision 以及一大堆 CUDA 相关包的麻烦。答辩演示时，万一现场显卡驱动出了问题，现场的机器也能直接运行。

4.3 UI 方案选择：桌面端演示用 Tkinter，远程演示用 Flask

课程设计的展示形式决定了 UI 层的选择。如果是本地答辩，直接用一个 Tkinter 窗口展示摄像头画面和识别结果，简单且不会出岔子。如果需要在多台设备上演示（比如把系统跑在服务器上，评委用手机或平板观看），就应该把推理封装成 Flask 接口。

下面是一个最小可用的 Flask 识别接口，接收上传的图片文件，返回表情类别和置信度：

from flask import Flask, request, jsonify from PIL import Image import torchvision.transforms as T app = Flask(__name__) transform = T.Compose([ T.Resize((48, 48)), T.ToTensor(), T.Normalize(mean=[0.5], std=[0.5]) ]) @app.route('/predict', methods=['POST']) def predict(): file = request.files['image'] img = Image.open(file.stream).convert('L') tensor = transform(img).unsqueeze(0) with torch.no_grad(): logits = model(tensor) prob = torch.softmax(logits, dim=1) label = prob.argmax(dim=1).item() confidence = prob.max().item() return jsonify({ 'emotion': val_ds.classes[label], 'confidence': round(confidence, 4) }) if __name__ == '__main__': app.run(host='0.0.0.0', port=5000)

可以看到，这个接口没有包含人脸检测逻辑，是假设调用方已经截取好的人脸小图。这么设计的好处是把“检测”和“分类”拆成两个独立服务，前端可以调 Haar 做检测，再把人脸区域发给 Flask。整体架构清晰，答辩时也更容易讲清楚系统模块边界。启动后可以用curl -F "image=@test.jpg" http://127.0.0.1:5000/predict验证接口是否正常。

5. 进阶技巧：用滑窗投票机制抑制视频流的表情跳变

无论模型在静态图片上准确率多高，放到视频流里都会出现一个让人沮丧的现象：表情分类结果逐帧抖个不停，同一张脸在 happy 和 neutral 之间反复横跳。这是因为单帧图片里的面部肌肉纹理本身就有细微变化，加上光照波动和摄像头噪声，模型输出并不稳定。与其在模型层面把准确率再提升 1%，不如在决策层面用一个简单的滑窗投票机制，把时间上下文利用起来。

做法是维护一个长度为 N 的队列，存储最近 N 帧的预测类别，每次输出队列中出现次数最多的类别。核心逻辑如下：

from collections import deque, Counter window_size = 7 pred_queue = deque(maxlen=window_size) def stable_predict(face_tensor): logits = model(face_tensor) pred = logits.argmax(dim=1).item() pred_queue.append(pred) if len(pred_queue) < 3: return pred # 早期帧不足，直接返回当前帧 counter = Counter(pred_queue) # 同时满足两个条件才切换：次数超过一半，且和当前帧一致 top_label, top_count = counter.most_common(1)[0] if top_count >= window_size // 2 + 1: return top_label return pred

这里的window_size=7是我测试下来在“响应速度”和“稳定性”之间比较平衡的参数。窗口越大，输出越平滑，但表情实际变化时肉眼会感觉到明显的滞后，例如从开心转向惊讶，UI 上需要约 0.5 秒才能翻转。窗口设为 7 帧，配合 30FPS 的摄像头，延迟约 0.2 秒，感知不明显。

条件top_count >= window_size // 2 + 1意味着队列中某个表情出现超过一半帧数才切换输出状态。如果心算不方便，用一个更简单直观的策略：输出队列里出现次数最多的标签，但只有当该标签的 softmax 平均置信度超过 0.7 时才更新界面上的表情文字。两种做法本质相同，都是引入时间维度的“惯性”，避免模型单帧噪声干扰。

还有一个值得顺带做的技巧：数据集中某些类别的置信度天然偏低（比如 disgust）。在滑窗投票的同时，为不同类别设定不同的判定阈值，即概率大于该类阈值的帧才允许进入投票队列。比如thresholds = {'angry': 0.4, 'happy': 0.5, 'disgust': 0.3}，这样可以过滤掉那些模型自身就不确定的预测帧。调阈值的最快方法是对验证集做一个统计，把每个类别的平均置信度算出来，再打 8 折作为阈值下限，直接在验证脚本里打印输出即可。

这套方案跑通之后，视频流里的识别结果会明显稳定很多，答辩时演示的效果比单帧推理有质的提升，而且代码量很小，也不会引入额外的推理时延。

本文还有配套的精品资源，点击获取