基于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，同时生成训练损失曲线图表。

相关推荐
Kaydeon1 小时前
【Anaconda】Conda 虚拟环境打包迁移教程
人工智能·pytorch·python·conda
love530love1 小时前
《Anaconda 精简路径治理》系列 · 番外篇Conda 虚拟环境路径结构方案全解——六种路径布局对比、优劣与治理建议
运维·人工智能·windows·python·conda
F_D_Z4 小时前
【PyTorch】图像二分类项目
人工智能·pytorch·深度学习·分类·数据挖掘
Yweir5 小时前
Elastic Search 8.x 分片和常见性能优化
java·python·elasticsearch
文浩（楠搏万）5 小时前
TensorFlow+CNN垃圾分类深度学习全流程实战教程
深度学习·ai·cnn·tensorflow·卷积神经网络·模型训练·全流程指导
小蜗牛狂飙记6 小时前
在github上传python项目，然后在另外一台电脑下载下来后如何保障成功运行
开发语言·python·github
倔强青铜三6 小时前
苦练Python第27天：嵌套数据结构
人工智能·python·面试
倔强青铜三6 小时前
苦练Python第26天：精通字典8大必杀技
人工智能·python·面试
creator_Li7 小时前
python学习笔记
笔记·python·学习
热门推荐
01【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致02全球最强模型Grok4，国内已可免费使用！（附教程）03Cursor Claude 模型无法使用的解决方法04KGG转MP3工具|非KGM文件|解密音频05Cursor限制国内用户使用Claude模型？附简单解决方案！06Vue (Official) v3.0.2 新特性 为非类npm环境引入 globalTypesPath 选项07赛博保姆出列！Gemini CLI & Claude Code + Kimi 手把手教程08这次领先Cursor！体验了Trae 2.0 SOLO 模式，超酷！09Claude Code 最新版已经支持 Windows 安装使用！10WPS文档中心及文档中台远程命令执行漏洞