基于Pytorch的人脸识别程序

DeniuHe2025-07-21 21:08

人脸识别原理详解

人脸识别是模式识别和计算机视觉领域的重要研究方向，其目标是从图像或视频中识别出特定个体的身份。现代人脸识别技术主要基于深度学习方法，特别是卷积神经网络 (CNN)，下面从多个维度详细解析其原理：

1. 人脸识别的基本流程

人脸识别系统通常包含以下核心模块：

  • 人脸检测：从图像中定位并提取人脸区域
  • 人脸对齐：基于面部特征点 (如眼睛、鼻子、嘴巴) 对人脸进行归一化
  • 特征提取：将对齐后的人脸图像映射为固定维度的特征向量
  • 特征匹配：通过计算特征向量间的相似度进行身份验证或识别
2. 人脸识别的核心技术
2.1 基于深度学习的特征提取

现代人脸识别技术的突破主要归功于深度卷积神经网络的应用。典型的人脸识别网络结构包括：

  • 骨干网络 (Backbone)：通常采用 ResNet、MobileNet 等架构提取图像特征
  • 特征增强层：如 SE 模块 (Squeeze-and-Excitation)、注意力机制等
  • 损失函数设计 ：
    • Softmax 损失：直接分类
    • Triplet 损失：学习类内紧凑、类间分离的特征空间
    • ArcFace/Additive Angular Margin Loss：通过角度间隔优化特征分布
2.2 特征匹配与识别

提取的特征向量通常被归一化为单位长度，然后通过计算余弦相似度进行匹配：

当相似度超过设定阈值时，判定为同一人。

3. 人脸识别中的挑战
  • 姿态变化：正面、侧面、仰头、低头等不同姿态
  • 光照变化：强光、弱光、逆光等环境差异
  • 表情变化：微笑、愤怒、惊讶等面部表情
  • 年龄变化：随着年龄增长面部特征的变化
  • 遮挡问题：眼镜、口罩、胡须等遮挡物
4. 人脸识别的评价指标
  • 准确率 (Accuracy)：正确分类样本数占总样本数的比例
  • ROC 曲线：真阳性率 (TPR) 与假阳性率 (FPR) 的关系曲线
  • EER(Equal Error Rate)：错误接受率 (FAR) 等于错误拒绝率 (FRR) 时的值
  • ROC 曲线下面积 (AUC)：衡量分类器性能的综合指标

基于 PyTorch 的人脸识别程序实现

下面是完整的 PyTorch 实现代码：

python 复制代码 
import os
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import matplotlib.pyplot as plt

# 设置随机种子确保结果可复现
torch.manual_seed(42)
np.random.seed(42)

class FaceDataset(Dataset):
    """自定义人脸数据集类"""
    def __init__(self, root_dir, transform=None):
        """
        初始化人脸数据集
        
        参数:
            root_dir: 数据集根目录
            transform: 图像预处理转换
        """
        self.root_dir = root_dir
        self.transform = transform
        self.images = []  # 存储图像路径
        self.labels = []  # 存储标签
        
        # 遍历每个子文件夹(每个人)
        for person_id, person_name in enumerate(sorted(os.listdir(root_dir))):
            person_dir = os.path.join(root_dir, person_name)
            if os.path.isdir(person_dir):
                # 遍历该人所有图像
                for img_name in os.listdir(person_dir):
                    if img_name.endswith('.pgm'):
                        img_path = os.path.join(person_dir, img_name)
                        self.images.append(img_path)
                        self.labels.append(person_id)
    
    def __len__(self):
        """返回数据集大小"""
        return len(self.images)
    
    def __getitem__(self, idx):
        """获取指定索引的图像和标签"""
        img_path = self.images[idx]
        label = self.labels[idx]
        
        # 读取图像
        image = Image.open(img_path).convert('L')  # 转为灰度图
        
        # 应用预处理转换
        if self.transform:
            image = self.transform(image)
        
        return image, label

class FaceNet(nn.Module):
    """人脸识别网络模型"""
    def __init__(self, num_classes=40):
        """
        初始化人脸识别网络
        
        参数:
            num_classes: 类别数量(人数)
        """
        super(FaceNet, self).__init__()
        
        # 定义卷积神经网络结构
        self.features = nn.Sequential(
            # 第一层卷积
            nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            # 第二层卷积
            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            # 第三层卷积
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            
            # 第四层卷积
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        
        # 创建一个虚拟输入来计算特征维度
        self.feature_size = self._get_feature_size()
        
        # 全连接层用于特征提取
        self.fc = nn.Sequential(
            nn.Linear(self.feature_size, 512),
            nn.BatchNorm1d(512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512, 128),  # 提取128维特征向量
            nn.BatchNorm1d(128),
        )
        
        # 分类层
        self.classifier = nn.Linear(128, num_classes)
    
    def _get_feature_size(self):
        """计算特征向量维度"""
        # 创建一个虚拟输入(1通道，112x92尺寸)
        x = torch.zeros(1, 1, 112, 92)
        x = self.features(x)
        # 展平后的尺寸
        return x.view(1, -1).size(1)
    
    def forward(self, x):
        """前向传播过程"""
        x = self.features(x)
        x = x.view(x.size(0), -1)  # 展平
        features = self.fc(x)      # 提取特征向量
        logits = self.classifier(features)  # 分类
        
        return features, logits

def train_model(model, train_loader, criterion, optimizer, device, epochs=20):
    """
    训练人脸识别模型
    
    参数:
        model: 模型
        train_loader: 训练数据加载器
        criterion: 损失函数
        optimizer: 优化器
        device: 计算设备
        epochs: 训练轮数
    """
    model.train()
    train_losses = []
    
    for epoch in range(epochs):
        running_loss = 0.0
        correct = 0
        total = 0
        
        for inputs, labels in train_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            
            # 梯度清零
            optimizer.zero_grad()
            
            # 前向传播
            _, outputs = model(inputs)
            loss = criterion(outputs, labels)
            
            # 反向传播和优化
            loss.backward()
            optimizer.step()
            
            # 统计
            running_loss += loss.item()
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()
        
        # 计算平均损失和准确率
        epoch_loss = running_loss / len(train_loader)
        epoch_acc = 100.0 * correct / total
        train_losses.append(epoch_loss)
        
        print(f'Epoch {epoch+1}/{epochs}, Loss: {epoch_loss:.4f}, Acc: {epoch_acc:.2f}%')
    
    return train_losses

def evaluate_model(model, test_loader, device):
    """
    评估人脸识别模型
    
    参数:
        model: 模型
        test_loader: 测试数据加载器
        device: 计算设备
    """
    model.eval()
    correct = 0
    total = 0
    all_features = []
    all_labels = []
    
    with torch.no_grad():
        for inputs, labels in test_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            
            # 提取特征和预测
            features, outputs = model(inputs)
            _, predicted = outputs.max(1)
            
            # 统计
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()
            
            # 保存特征和标签用于后续分析
            all_features.append(features.cpu().numpy())
            all_labels.append(labels.cpu().numpy())
    
    # 计算准确率
    accuracy = 100.0 * correct / total
    print(f'测试集准确率: {accuracy:.2f}%')
    
    # 转换为numpy数组
    all_features = np.vstack(all_features)
    all_labels = np.hstack(all_labels)
    
    return accuracy, all_features, all_labels

def main():
    """主函数"""
    # 设置计算设备
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    print(f'使用设备: {device}')
    
    # 定义数据预处理
    train_transform = transforms.Compose([
        transforms.Resize((112, 92)),  # 调整图像大小
        transforms.RandomHorizontalFlip(),  # 随机水平翻转
        transforms.ToTensor(),  # 转为Tensor并归一化到[0,1]
        transforms.Normalize(mean=[0.5], std=[0.5])  # 标准化
    ])
    
    test_transform = transforms.Compose([
        transforms.Resize((112, 92)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.5], std=[0.5])
    ])
    
    # 创建数据集
    train_dataset = FaceDataset(
        root_dir=r'D:\数据集\faces\training',
        transform=train_transform
    )
    
    test_dataset = FaceDataset(
        root_dir=r'D:\数据集\faces\testing',
        transform=test_transform
    )
    
    # 创建数据加载器
    train_loader = DataLoader(
        train_dataset,
        batch_size=32,
        shuffle=True,
        num_workers=4
    )
    
    test_loader = DataLoader(
        test_dataset,
        batch_size=32,
        shuffle=False,
        num_workers=4
    )
    
    # 初始化模型
    model = FaceNet(num_classes=40).to(device)
    
    # 打印模型信息
    print("模型结构:")
    print(model)
    print(f"特征向量维度: {model.feature_size}")
    
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    # 训练模型
    print("开始训练模型...")
    train_losses = train_model(model, train_loader, criterion, optimizer, device)
    
    # 评估模型
    print("开始评估模型...")
    accuracy, features, labels = evaluate_model(model, test_loader, device)
    
    # 保存模型
    torch.save(model.state_dict(), 'face_recognition_model.pth')
    print("模型已保存为: face_recognition_model.pth")
    
    # 绘制训练损失曲线
    plt.figure(figsize=(10, 6))
    plt.plot(train_losses)
    plt.title('Training Loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.grid(True)
    plt.savefig('training_loss.png')
    plt.show()

if __name__ == "__main__":
    main()

代码解析

上述代码实现了一个完整的人脸识别系统，主要包含以下几个部分：

  1. 数据集处理：

    • 创建了FaceDataset类来加载 PGM 格式的人脸图像
    • 自动从文件夹结构中提取类别标签
    • 支持图像预处理和增强

  2. 模型架构：

    • 使用四层卷积网络提取人脸特征
    • 最后两层全连接层分别用于特征提取和分类
    • 提取 128 维的特征向量用于人脸识别

  3. 训练过程：

    • 使用交叉熵损失函数进行分类训练
    • 采用 Adam 优化器，学习率设为 0.001
    • 训练 20 个轮次并记录训练损失

  4. 评估过程：

    • 在测试集上评估模型准确率
    • 保存提取的特征向量用于后续分析

这个实现采用了经典的分类方法进行人脸识别，通过训练一个多类分类器，使得同一个人的特征向量在特征空间中接近，不同人的特征向量远离。在实际应用中，还可以进一步改进，例如使用 Triplet Loss 或 ArcFace 等更先进的损失函数来优化特征空间。

如果需要使用这个程序，只需确保数据集路径正确，然后运行代码即可。训练完成后，模型会保存为face_recognition_model.pth，同时生成训练损失曲线图表。

相关推荐
大神君Bob5 分钟前
【AI办公自动化】教你使用Pytho让Word文档处理自动化
python
轻竹办公PPT11 分钟前
2025实测！AI生成PPT工具全总结
人工智能·python·powerpoint
彼岸花开了吗13 分钟前
构建AI智能体：八十一、SVD模型压缩的艺术：如何科学选择K值实现最佳性能
人工智能·python·llm
AI小怪兽20 分钟前
轻量、实时、高精度！MIE-YOLO：面向精准农业的多尺度杂草检测新框架 | MDPI AgriEngineering 2026
开发语言·人工智能·深度学习·yolo·无人机
一招定胜负39 分钟前
图像形态学+边缘检测及CNN关联
人工智能·深度学习·cnn
dagouaofei40 分钟前
2026 年工作计划 PPT 制作方式对比：AI 与传统方法差异
人工智能·python·powerpoint
虚拟搬运工44 分钟前
xformers造成comfyu启动失败
python·comfyui
Hello.Reader1 小时前
PyFlink DataStream Operators 算子分类、函数写法、类型系统、链路优化（Chaining）与工程化踩坑
前端·python·算法
Learner1 小时前
Python函数
开发语言·python
万行1 小时前
机器学习&第五章生成式生成器
人工智能·python·算法·机器学习
热门推荐
01GitHub 镜像站点02Labelme从安装到标注：零基础完整指南03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04Linux下V2Ray安装配置指南05Claude Code 2.1.2 升级报错？别折腾了，一行命令搞定06jdk21下载、安装（Windows、Linux、macOS）07【踩坑笔记】50系显卡适配的 PyTorch 安装082025-04-03 Latex学习1——本地配置Latex + VScode环境09KGG转MP3工具|非KGM文件|解密音频10Overleaf编译超时，超出免费计划编译时限（已解决）