基于 SSR-Net 的年龄估计模型训练实战（PyTorch 实现）

前言

年龄估计是计算机视觉中的一个经典任务，在人脸属性分析、智能安防、推荐系统等领域有广泛应用。本文记录我使用 SSR-Net（Soft Stagewise Regression Network） 训练年龄估计模型的完整流程，包括模型结构、数据处理、训练策略等关键环节。

源码地址：模型地址

一、SSR-Net 模型简介

SSR-Net 是一种轻量级的年龄估计网络，发表于 IJCAI 2018，核心思想是将年龄回归问题分解为多阶段分类问题，通过软区间回归（Soft Stagewise Regression）实现从粗到细的年龄预测。

特点：

• 双流结构（Two-Stream）：Stream1 使用 ReLU + AvgPool，Stream2 使用 Tanh + MaxPool，互补提取特征
• 多阶段预测：3个阶段（stage1/2/3）分别负责粗粒度、中粒度、细粒度的年龄估计
• 参数量小：仅约 0.32M 参数，适合移动端部署
• 动态软区间：每个阶段的年龄区间宽度可学习，比固定区间更灵活

模型初始化参数：

model = SSRNet(
    stage_num=[3, 3, 3],   # 三阶段，每阶段3个区间
    image_size=64,          # 输入图像尺寸 64x64
    class_range=73          # 年龄范围 0-72（对应 1-73 岁）
)

---

二、SSR-Net 在年龄识别中的优势

相比传统年龄估计方法，SSR-Net 的设计在多个维度上具备明显优势：

2.1 与分类方法对比

早期年龄估计通常被建模为纯分类问题（将每个年龄当作一个独立类别），存在两个痛点：

• 忽略年龄有序性：分类任务中 20 岁预测成 50 岁和 30 岁的 loss 是完全一样的，显然不符合直觉
• 类别数过多导致参数爆炸：如 0-100 岁需要 101 个分类头，参数量大且长尾年龄样本不足

SSR-Net 通过有序回归 + 软区间解决了这些问题：年龄本质是有序变量，相邻年龄之间应具有连续性而非相互独立。

2.2 与纯回归方法对比

直接用 CNN → FC → 单个年龄值的回归方案，在面对年龄估计这种高模糊性任务时容易预测出"平均年龄"，缺乏区分度。SSR-Net 的多阶段分桶机制可以将年龄范围逐级细化，同时输出预测值的置信度分布，比单点回归更加可靠。

2.3 动态软区间的优势

固定区间的方法（如每 10 岁一档）需要人工设定分桶边界，而不同数据集、不同种族的年龄分布差异很大。SSR-Net 的 delta_k 参数是可学习的，网络会根据数据分布自动调整每个阶段的区间宽度，对不同数据分布的适应能力更强。

2.4 轻量级设计

模型	参数量	输入尺寸	适用场景
DEX (VGG-16)	~138M	224×224	服务端
SSR-Net	~0.32M	64×64	移动端/边缘设备
MobileNetV2 + Age	~3.5M	224×224	移动端

SSR-Net 参数量仅 0.32M，输入只需 64×64 分辨率，在 ARM 设备上推理延迟可控制在个位数毫秒，特别适合实时视频流中人脸年龄的逐帧分析。

2.5 双流互补特征

• Stream1（ReLU + AvgPool）：平滑下采样，保留纹理细节，对皮肤质感的细微变化敏感
• Stream2（Tanh + MaxPool）：强调显著特征，对轮廓结构（如下颌线、眼窝）变化敏感

两条流从不同角度提取年龄相关特征，融合后能比单流网络捕捉更丰富的老化信息。

---

三、年龄模型的落地应用场景

年龄估计模型在实际业务中很少独立存在，更多是作为人脸属性分析的一环，与性别、表情、颜值等模型协同工作。以下是一些典型的应用方向：

3.1 智能营销与推荐

• 线下零售：门店摄像头采集顾客年龄分布，辅助选品和货架陈列策略（如年轻客群多则加大潮流单品占比）
• 数字广告屏：根据观看者年龄实时切换广告素材，提升转化率
• 电商个性化推荐：结合用户年龄做商品推荐（护肤品、服饰等品类与年龄强相关）

3.2 安全与合规

• 未成年人防沉迷：游戏、短视频平台通过人脸年龄估计判断用户是否为未成年人，触发防沉迷策略
• 未成年人禁售：自动售货机（烟酒）、无人零售柜识别购买者年龄，拦截未成年购买行为
• 网吧/网约车实名辅助：作为实名认证的补充校验手段

3.3 社交与内容

• 社交平台年龄画像：构建用户画像，用于内容推荐、好友推荐
• 美颜相机/滤镜：不同年龄段应用不同的美颜策略和滤镜风格
• 社交匹配：交友类应用根据年龄范围做匹配推荐

3.4 安防与公共管理

• 走失儿童/老人寻找：结合年龄估计缩小搜索范围，提高寻人效率
• 跨年龄段人脸识别辅助：帮助判断两张时间跨度较大的照片是否为同一人
• 区域人流年龄统计：商圈、景区、交通枢纽的人流年龄结构分析

3.5 医疗与健康

• 皮肤状态评估：结合年龄估计与实际年龄，评估皮肤老化程度
• 儿童生长发育监测：通过骨龄、面相等判断发育是否与年龄匹配

---

四、数据预处理

4.1 数据集来源

训练数据存储在 MongoDB 中，通过 pymongo 读取，数据集合为 face_age，每条记录包含：

• _id：图片唯一标识
• age：真实年龄
• location_yolo：YOLO 人脸检测框 [center_x, center_y, width, height]（归一化坐标）

4.2 数据划分

使用 CRC32 哈希取尾号的方式划分训练集和测试集，保证划分的确定性和可复现性：

hash_code = int(str(zlib.crc32(bytes(_id,'utf-8')))[-1:])
if hash_code <= 8:   # 尾号 0-8 → 训练集（约90%）
    train_dataset.append(...)
else:                # 尾号 9   → 测试集（约10%）
    test_dataset.append(...)

4.3 人脸区域裁剪

根据 YOLO 检测结果，对人脸区域进行扩展裁剪（Extra Margin Cropping）：

# 在检测框基础上扩展边界，确保覆盖完整人脸
x1 = x1 - w * 0.3   # 左侧扩展 30%
y1 = y1 - h * 0.6   # 上方扩展 60%（额头区域）
x2 = x2 + w * 0.3   # 右侧扩展 30%
y2 = y2 + h * 0.2   # 下方扩展 20%

裁剪后的图像统一 resize 到 64×64，使用 ImageNet 均值和标准差做归一化：

transform = transforms.Compose([
    transforms.Resize((64, 64)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

这里使用 ImageNet 统计量做归一化是合理的迁移学习做法，因为 SSR-Net 的 backbone 卷积层可以用 ImageNet 预训练权重初始化。

---

五、训练配置

配置项	设置
优化器	Adam
学习率	0.0005
损失函数	MSELoss（均方误差）
Batch Size	512
Epochs	300
设备	CUDA:1（或多GPU环境）
数据加载	48个工作线程，pin_memory=True

optimizer = optim.Adam(model.parameters(), lr=0.0005)
criterion = nn.MSELoss()
train_loader = DataLoader(dataset, batch_size=512, shuffle=True, 
                          pin_memory=True, num_workers=48)

为什么用 MSE Loss？

SSR-Net 最终输出的是一个连续的年龄值（通过对各阶段预测的概率分布求期望得到），因此使用 MSE 损失函数直接回归年龄值是自然的选择。论文中也提到可以结合 MAE 做评估，但训练时 MSE 更稳定。

---

六、训练循环

6.1 训练阶段

model.train()
for images, labels in train_loader:
    images = images.to(device)
    labels = labels[:, 0].to(device)   # age 从 [batch, 1] 展平为 [batch]
    
    optimizer.zero_grad()
    pre_age = model(images)            # 前向传播，输出 [batch] 预测年龄
    loss = criterion(pre_age, labels)  # MSE 损失
    loss.backward()
    optimizer.step()

6.2 验证阶段

使用 MAE（平均绝对误差） 作为评估指标：

model.eval()
with torch.no_grad():
    for images, labels in test_loader:
        pre_age = model(images).tolist()
        labels = labels[:, 0].tolist()
        for i in range(len(pre_age)):
            dts.append(abs(pre_age[i] - labels[i]))
    mae = sum(dts) / len(dts)
    print(f'age模型平均误差：{mae}')

6.3 模型保存

每个 epoch 保存一次模型权重（CPU 格式，方便跨设备加载）：

torch.save(model.cpu().state_dict(), f'model/age_ssrnet_epoch{epoch}.pth.cpu')
model.cuda(device)  # 保存后移回 GPU 继续训练

---

七、完整代码

#!/usr/bin/env python
#  -*- coding:utf-8 -*-

import torch, pymongo, zlib
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, Dataset
from PIL import Image
from SSR_models.SSR_Net_model import SSRNet
import logging
from logging.handlers import RotatingFileHandler

# ======================== 日志配置 ========================
logger = logging.getLogger()
logger.setLevel(logging.INFO)
file_handler = RotatingFileHandler('log.txt', maxBytes=1024**3, backupCount=5)
file_handler.setLevel(logging.INFO)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
formatter = logging.Formatter(
    '%(pathname)s - [line:%(lineno)d] - %(asctime)s - %(levelname)s: %(message)s'
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(console_handler)

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

def path_to_image(path, location_yolo):
    """根据 YOLO 检测框裁剪人脸区域并预处理"""
    image = Image.open(path)
    width, height = image.size

    # YOLO 归一化坐标 → 像素坐标
    midx = location_yolo[0] * width
    midy = location_yolo[1] * height
    w = location_yolo[2] * width
    h = location_yolo[3] * height

    # 计算裁剪边界
    x1 = midx - w/2
    y1 = midy - h/2
    x2 = midx + w/2
    y2 = midy + h/2

    # 扩展边界（确保完整覆盖人脸）
    x1 = x1 - w * 0.3
    y1 = y1 - h * 0.6
    x2 = x2 + w * 0.3
    y2 = y2 + h * 0.2

    # 边界裁剪
    x1 = 0 if x1 < 0 else x1
    y1 = 0 if y1 < 0 else y1
    x2 = width if x2 >= width else x2
    y2 = height if y2 >= height else y2

    image = image.crop((x1, y1, x2, y2))
    image = transform(image)
    return image

class MyDataset(Dataset):
    def __init__(self, image_paths, features, location_yolos):
        self.image_paths = image_paths
        self.features = features      # 年龄标签
        self.location_yolos = location_yolos

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

    def __getitem__(self, idx):
        return (
            path_to_image(self.image_paths[idx], self.location_yolos[idx]),
            torch.Tensor(self.features[idx])
        )

# ======================== 模型初始化 ========================
device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu")
model = SSRNet(class_range=73)
loaded_model = torch.load('model/age_ssrnet_best.pth.cpu')
model.load_state_dict(loaded_model)
model = model.to(device)
optimizer = optim.Adam(model.parameters(), lr=0.0005)
criterion = nn.MSELoss()

# ======================== 数据加载 ========================
client = pymongo.MongoClient("mongodb://192.168.31.222:27017/admin")
db = client['face_detect']

train_image_paths, train_features, train_location_yolos = [], [], []
test_image_paths, test_features, test_location_yolos = [], [], []

for item in db['face_age'].find({'location_yolo': {'$ne': None}}).sort([('_id', 1)]):
    _id = item['_id']
    file_path = '/home/pycode/face_detect/data/age/' + _id + '.jpg'
    hash_code = int(str(zlib.crc32(bytes(_id, 'utf-8')))[-1:])
    if hash_code <= 8:
        train_image_paths.append(file_path)
        train_features.append([int(item['age']) - 1])   # 年龄从1开始，模型预测0-72
        train_location_yolos.append(item['location_yolo'])
    else:
        test_image_paths.append(file_path)
        test_features.append([int(item['age']) - 1])
        test_location_yolos.append(item['location_yolo'])

logger.info(f'训练数据大小: {len(train_image_paths)}')

train_loader = DataLoader(
    MyDataset(train_image_paths, train_features, train_location_yolos),
    batch_size=512, shuffle=True, pin_memory=True, num_workers=48
)
test_loader = DataLoader(
    MyDataset(test_image_paths, test_features, test_location_yolos),
    batch_size=512, shuffle=True, pin_memory=True, num_workers=48
)

# ======================== 训练循环 ========================
num_epochs = 300
for epoch in range(num_epochs):
    logger.info(f'开始训练 age模型，epoch: {epoch + 1}')

    # ---- 训练 ----
    model.train()
    for images, labels in train_loader:
        images = images.to(device)
        labels = labels[:, 0].to(device)
        optimizer.zero_grad()
        pre_age = model(images)
        loss = criterion(pre_age, labels)
        loss.backward()
        optimizer.step()
    logger.info(f'age模型损失值: {loss}')

    # ---- 验证 ----
    model.eval()
    dts = []
    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            pre_age = model(images).tolist()
            labels = labels[:, 0].tolist()
            for i in range(len(pre_age)):
                dts.append(abs(pre_age[i] - labels[i]))
        logger.info(f'age模型平均误差: {sum(dts) / len(dts)}')

    # ---- 保存模型 ----
    torch.save(model.cpu().state_dict(), f'model/age_ssrnet_epoch{epoch}.pth.cpu')
    model.cuda(device)
    logger.info('--------------------------------------')

---

八、关键细节与经验总结

8.1 年龄标签偏移

train_features.append([int(item['age']) - 1])

年龄从 1 开始（1-73 岁），但模型 class_range=73 预测的是 0-72 的索引，因此标签需要减 1。

8.2 日志轮转

使用 RotatingFileHandler 设置 1GB 上限、保留 5 个历史文件，避免训练日志撑爆磁盘。

8.3 多 GPU 环境

脚本指定 cuda:1 而非默认 cuda:0，避免与其他任务抢占 GPU 资源。

8.4 模型保存策略

每个 epoch 都保存一份模型，方便后续选择 MAE 最优的 checkpoint。生产中可改为仅保存最佳模型：

if mae < best_mae:
    best_mae = mae
    torch.save(model.cpu().state_dict(), 'model/age_ssrnet_best.pth.cpu')

---

九、总结

本文介绍了基于 SSR-Net 的年龄估计模型训练全流程，核心要点：

1. SSR-Net 双流多阶段架构，实现从粗到细的年龄回归
2. YOLO 检测 + 扩展裁剪，确保人脸区域完整
3. CRC32 哈希划分数据集，保证可复现性
4. MSE 训练 + MAE 评估，符合年龄估计任务特点
5. 逐 epoch 保存 + 日志轮转，方便实验管理和复盘

SSR-Net 的轻量级特性使其非常适合边缘设备和实时场景，MegaAge 数据集上官方报告 MAE 约 3-4 岁，实际效果取决于训练数据质量。

---

参考资料

• SSR-Net 论文: SSR-Net: A Compact Soft Stagewise Regression Network for Age Estimation (IJCAI 2018)
• 官方 PyTorch 实现