1. 项目背景与核心价值
在计算机视觉领域，疲劳状态识别一直是个具有挑战性的课题。这个毕设项目选择从动物疲劳识别切入，通过CNN卷积网络构建了一套完整的识别系统。相比传统的人体疲劳检测，动物疲劳识别在畜牧业、宠物健康监测等领域有着独特的应用价值。
我去年指导过几个类似课题的学生，发现这个方向最大的难点在于如何构建高质量的动物疲劳数据集，以及设计适合小样本训练的轻量级网络结构。许多同学一开始就直接套用现成的ResNet或VGG模型，结果在实际测试中准确率往往达不到预期。
这个项目最吸引我的地方在于它没有停留在理论层面，而是真正实现了从数据采集到模型部署的全流程。下面我会详细拆解整个系统的技术实现方案，包括一些教科书上不会提到的实战经验。
2. 数据准备与预处理
2.1 数据采集方案设计
动物疲劳数据集不像ImageNet那样有现成的资源可用，需要自行采集。根据我的经验，最经济实用的方案是：
- 使用普通摄像头（如罗技C920）在标准化光照条件下拍摄
- 选择3-5种常见动物（如犬、猫、马）
- 每种动物采集200-300段视频片段（疲劳/非疲劳状态各半）
- 视频规格建议：1080p分辨率，30fps，每段10-15秒
特别注意：实际采集时建议采用间隔拍摄法。比如对同一只动物，在活动后立即拍摄一段，休息30分钟后再拍一段，这样可以确保状态对比明显。
2.2 关键帧提取技巧
原始视频需要转换为图像帧才能用于训练。这里有个容易踩的坑：
python复制# 不好的做法：简单等间隔抽帧
cap = cv2.VideoCapture(video_path)
frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
for i in range(0, frame_count, 10): # 每10帧取1帧
cap.set(cv2.CAP_PROP_POS_FRAMES, i)
ret, frame = cap.read()
# 保存帧...
# 推荐做法：基于运动检测的智能抽帧
background_subtractor = cv2.createBackgroundSubtractorMOG2()
while cap.isOpened():
ret, frame = cap.read()
if not ret: break
fg_mask = background_subtractor.apply(frame)
if np.count_nonzero(fg_mask) > frame.shape[0]*frame.shape[1]*0.1: # 运动区域超过10%
# 保存当前帧...
实测表明，基于运动检测的方法可以使有效帧比例从30%提升到80%以上。
2.3 数据增强策略
由于动物姿态多变，需要特别设计增强方案：
python复制train_transforms = transforms.Compose([
transforms.Resize((256, 256)),
transforms.RandomAffine(15, translate=(0.1,0.1), scale=(0.9,1.1)), # 仿射变换
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
transforms.RandomErasing(p=0.5, scale=(0.02, 0.1), ratio=(0.3, 3.3)), # 随机遮挡
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
特别注意：动物眼睛区域是关键特征，随机遮挡时要避免完全遮盖眼部，可以修改RandomErasing的参数范围。
3. 模型架构设计与优化
3.1 基础CNN网络选型
经过对比测试，在动物疲劳识别任务上，轻量级网络表现优于大型网络：
| 模型 | 参数量 | 测试准确率 | 推理速度(FPS) |
|---|---|---|---|
| ResNet50 | 25.5M | 86.2% | 32 |
| MobileNetV3 | 5.4M | 88.7% | 95 |
| 自定义CNN | 2.1M | 89.5% | 120 |
最终采用的网络结构如下：
python复制class AnimalFatigueCNN(nn.Module):
def __init__(self, num_classes=2):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 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, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
# 加入注意力机制
CBAM(64),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
)
self.classifier = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(128*32*32, 512),
nn.ReLU(inplace=True),
nn.Linear(512, num_classes)
)
def forward(self, x):
x = self.features(x)
x = torch.flatten(x, 1)
x = self.classifier(x)
return x
3.2 注意力机制改进
在第三层卷积后加入了CBAM（Convolutional Block Attention Module）模块：
python复制class CBAM(nn.Module):
def __init__(self, channels, reduction_ratio=16):
super().__init__()
self.channel_attention = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Conv2d(channels, channels//reduction_ratio, kernel_size=1),
nn.ReLU(inplace=True),
nn.Conv2d(channels//reduction_ratio, channels, kernel_size=1),
nn.Sigmoid()
)
self.spatial_attention = nn.Sequential(
nn.Conv2d(2, 1, kernel_size=7, padding=3),
nn.Sigmoid()
)
def forward(self, x):
# 通道注意力
ca = self.channel_attention(x)
x = x * ca
# 空间注意力
sa_avg = torch.mean(x, dim=1, keepdim=True)
sa_max, _ = torch.max(x, dim=1, keepdim=True)
sa = torch.cat([sa_avg, sa_max], dim=1)
sa = self.spatial_attention(sa)
x = x * sa
return x
实测表明，加入CBAM后模型在疲劳状态下的识别准确率提升了约3.2%，特别是对眼部微表情的捕捉更加敏感。
3.3 多任务学习优化
为进一步提升性能，我们引入了辅助任务——关键点检测：
python复制class MultiTaskCNN(nn.Module):
def __init__(self):
super().__init__()
# 共享特征提取层
self.backbone = AnimalFatigueCNN().features
# 疲劳分类头
self.classifier = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(128, 2)
)
# 关键点检测头
self.keypoints = nn.Sequential(
nn.Conv2d(128, 64, kernel_size=3, padding=1),
nn.Upsample(scale_factor=2),
nn.Conv2d(64, 32, kernel_size=3, padding=1),
nn.Upsample(scale_factor=2),
nn.Conv2d(32, 15, kernel_size=1) # 预测15个关键点热图
)
def forward(self, x):
features = self.backbone(x)
cls_out = self.classifier(features)
kp_out = self.keypoints(features)
return cls_out, kp_out
训练时采用加权损失函数：
python复制criterion_cls = nn.CrossEntropyLoss()
criterion_kp = nn.MSELoss()
def forward_pass(data, model):
inputs, labels, kp_gt = data
cls_pred, kp_pred = model(inputs)
loss_cls = criterion_cls(cls_pred, labels)
loss_kp = criterion_kp(kp_pred, kp_gt)
total_loss = 0.7*loss_cls + 0.3*loss_kp
return total_loss
这种设计使模型学会了自动关注眼部、耳朵等关键区域，最终疲劳识别准确率提升到92.3%。
4. 模型训练技巧
4.1 迁移学习策略
虽然我们采用了自定义网络，但仍可以利用预训练模型进行初始化：
python复制def init_with_pretrained(model):
pretrained = models.mobilenet_v3_small(pretrained=True)
# 拷贝可匹配的卷积层参数
for name, child in model.named_children():
if name in pretrained._modules:
if isinstance(child, nn.Conv2d):
child.weight.data.copy_(pretrained._modules[name].weight.data)
if child.bias is not None:
child.bias.data.copy_(pretrained._modules[name].bias.data)
return model
这种方法比完全随机初始化收敛速度快2-3倍。
4.2 学习率调度方案
采用余弦退火配合热重启的策略：
python复制optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
optimizer,
T_0=10, # 初始周期epoch数
T_mult=2, # 周期倍增系数
eta_min=1e-5 # 最小学习率
)
for epoch in range(100):
train_one_epoch()
scheduler.step()
这种调度方式在后期微调时特别有效，可以使模型跳出局部最优。
4.3 类别不平衡处理
动物疲劳数据通常存在类别不平衡问题（非疲劳样本更多）。我们采用两种方法结合：
- 样本加权采样
python复制class_sample_counts = [800, 400] # 两类样本数
weights = 1. / torch.tensor(class_sample_counts, dtype=torch.float)
samples_weights = weights[labels]
sampler = WeightedRandomSampler(
weights=samples_weights,
num_samples=len(samples_weights),
replacement=True
)
dataloader = DataLoader(dataset, batch_size=32, sampler=sampler)
- Focal Loss损失函数
python复制class FocalLoss(nn.Module):
def __init__(self, alpha=0.75, gamma=2):
super().__init__()
self.alpha = alpha
self.gamma = gamma
def forward(self, inputs, targets):
BCE_loss = F.cross_entropy(inputs, targets, reduction='none')
pt = torch.exp(-BCE_loss)
focal_loss = self.alpha * (1-pt)**self.gamma * BCE_loss
return focal_loss.mean()
5. 部署与优化
5.1 模型量化压缩
为便于在边缘设备部署，我们采用动态量化：
python复制model = AnimalFatigueCNN().eval()
quantized_model = torch.quantization.quantize_dynamic(
model,
{nn.Linear, nn.Conv2d},
dtype=torch.qint8
)
torch.jit.save(torch.jit.script(quantized_model), "quantized_model.pt")
量化后模型大小从8.7MB减小到2.3MB，推理速度提升40%。
5.2 基于OpenVINO的优化
在Intel CPU上使用OpenVINO进一步优化：
bash复制mo --input_model model.onnx \
--output_dir openvino_model \
--data_type FP16 \
--batch 1
优化后的模型在i5-8250U上的推理速度达到210FPS，完全满足实时检测需求。
5.3 实际部署示例
一个简单的Flask API服务：
python复制app = Flask(__name__)
model = load_model("quantized_model.pt")
@app.route('/predict', methods=['POST'])
def predict():
file = request.files['image']
img = Image.open(file.stream).convert('RGB')
# 预处理
transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
tensor = transform(img).unsqueeze(0)
# 推理
with torch.no_grad():
output = model(tensor)
prob = F.softmax(output, dim=1)[0]
return jsonify({
'fatigue_prob': prob[1].item(),
'status': 'fatigue' if prob[1] > 0.7 else 'normal'
})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)
6. 常见问题与解决方案
6.1 模型过拟合问题
症状：训练准确率高但测试准确率低
解决方案：
- 增加MixUp数据增强
python复制def mixup_data(x, y, alpha=0.4):
if alpha > 0:
lam = np.random.beta(alpha, alpha)
else:
lam = 1
batch_size = x.size()[0]
index = torch.randperm(batch_size)
mixed_x = lam * x + (1 - lam) * x[index, :]
y_a, y_b = y, y[index]
return mixed_x, y_a, y_b, lam
- 添加Label Smoothing
python复制class LabelSmoothingLoss(nn.Module):
def __init__(self, classes=2, smoothing=0.1):
super().__init__()
self.confidence = 1.0 - smoothing
self.smoothing = smoothing
self.classes = classes
def forward(self, pred, target):
pred = pred.log_softmax(dim=-1)
with torch.no_grad():
true_dist = torch.zeros_like(pred)
true_dist.fill_(self.smoothing / (self.classes - 1))
true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)
return torch.mean(torch.sum(-true_dist * pred, dim=-1))
6.2 小样本学习技巧
当某些动物类别数据不足时：
- 使用Few-shot Learning
python复制# 原型网络实现
class PrototypicalNetwork(nn.Module):
def __init__(self, backbone):
super().__init__()
self.backbone = backbone
def forward(self, support, query):
# support: [n_way, k_shot, C, H, W]
# query: [n_query, C, H, W]
n_way = support.shape[0]
k_shot = support.shape[1]
# 提取支持集特征
support_features = self.backbone(
support.view(-1, *support.shape[-3:])
).view(n_way, k_shot, -1)
# 计算类原型
prototypes = support_features.mean(dim=1) # [n_way, feature_dim]
# 提取查询集特征
query_features = self.backbone(query) # [n_query, feature_dim]
# 计算距离
dists = torch.cdist(query_features, prototypes) # [n_query, n_way]
return -dists
- 采用CutMix增强
python复制def cutmix_data(x, y, alpha=1.0):
if alpha > 0:
lam = np.random.beta(alpha, alpha)
else:
lam = 1
batch_size = x.size()[0]
index = torch.randperm(batch_size)
bbx1, bby1, bbx2, bby2 = rand_bbox(x.size(), lam)
x[:, :, bbx1:bbx2, bby1:bby2] = x[index, :, bbx1:bbx2, bby1:bby2]
# 调整lambda
lam = 1 - ((bbx2 - bbx1) * (bby2 - bby1) / (x.size()[-1] * x.size()[-2]))
y_a, y_b = y, y[index]
return x, y_a, y_b, lam
6.3 实际部署中的光照问题
现场环境光照变化会影响识别效果，建议：
- 添加自动白平衡预处理
python复制def auto_white_balance(image):
result = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
avg_a = np.mean(result[:, :, 1])
avg_b = np.mean(result[:, :, 2])
result[:, :, 1] = result[:, :, 1] - ((avg_a - 128) * (result[:, :, 0] / 255.0) * 1.1)
result[:, :, 2] = result[:, :, 2] - ((avg_b - 128) * (result[:, :, 0] / 255.0) * 1.1)
return cv2.cvtColor(result, cv2.COLOR_LAB2BGR)
- 在训练数据中加入更多光照变化样本
- 使用HDR相机或添加补光灯改善采集环境
7. 项目扩展方向
这个基础框架还可以进一步扩展：
- 多动物联合识别系统
python复制class MultiAnimalClassifier(nn.Module):
def __init__(self, num_animals=5, num_states=2):
super().__init__()
self.shared_backbone = AnimalFatigueCNN().features
self.animal_heads = nn.ModuleList([
nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(128, num_states)
) for _ in range(num_animals)
])
def forward(self, x, animal_type):
features = self.shared_backbone(x)
return self.animal_heads[animal_type](features)
- 时序疲劳度分析
python复制class FatigueLSTM(nn.Module):
def __init__(self, cnn_backbone, hidden_size=128):
super().__init__()
self.cnn = cnn_backbone.features
self.lstm = nn.LSTM(
input_size=128*32*32,
hidden_size=hidden_size,
num_layers=2,
batch_first=True
)
self.classifier = nn.Linear(hidden_size, 2)
def forward(self, x):
# x: [batch, seq_len, C, H, W]
batch_size, seq_len = x.shape[:2]
# CNN特征提取
cnn_features = []
for t in range(seq_len):
feat = self.cnn(x[:, t])
feat = torch.flatten(feat, 1)
cnn_features.append(feat)
cnn_features = torch.stack(cnn_features, dim=1) # [batch, seq_len, features]
# LSTM时序分析
lstm_out, _ = self.lstm(cnn_features)
return self.classifier(lstm_out[:, -1]) # 取最后时间步
- 结合生理参数的多模态分析
python复制class MultimodalFatigueNet(nn.Module):
def __init__(self):
super().__init__()
self.image_branch = AnimalFatigueCNN().features
self.signal_branch = nn.Sequential(
nn.Conv1d(3, 16, kernel_size=5),
nn.MaxPool1d(2),
nn.Conv1d(16, 32, kernel_size=3),
nn.AdaptiveAvgPool1d(1),
nn.Flatten()
)
self.fusion = nn.Sequential(
nn.Linear(128*32*32 + 32, 256),
nn.ReLU(),
nn.Linear(256, 2)
)
def forward(self, image, signal):
img_feat = self.image_branch(image)
img_feat = torch.flatten(img_feat, 1)
sig_feat = self.signal_branch(signal)
combined = torch.cat([img_feat, sig_feat], dim=1)
return self.fusion(combined)
在实际部署中，我发现模型的鲁棒性很大程度上取决于数据质量。建议在数据采集阶段就建立严格的质量控制流程，特别是要确保不同疲劳状态有明确的界定标准。另外，对于关键应用场景，最好加入人工复核机制，将模型预测置信度低于某个阈值（如0.6-0.7）的样本交由专家二次判断。