使用RetinaFace实现人脸马赛克处理工具-开发者社区

使用RetinaFace实现人脸马赛克处理工具

在社交媒体分享、新闻报道或者公共监控视频中，我们经常需要保护个人隐私，将画面中的人脸进行模糊或打码处理。传统的手动框选方式不仅效率低下，面对大量图片或视频流时更是力不从心。有没有一种方法，能自动、精准、快速地完成这项任务呢？

今天，我们就来聊聊如何基于RetinaFace这个人脸检测模型，打造一个实用的人脸马赛克处理工具。这个工具不仅能批量处理图片，还能精准识别视频流中的每一帧，自动给人脸打上马赛克，在保护隐私的同时，大大提升工作效率。

1. 为什么选择RetinaFace？

在开始动手之前，我们先简单了解一下RetinaFace。它不是一个简单的“人脸探测器”，而是一个集成了人脸框检测、关键点定位（比如眼睛、鼻子、嘴角的位置）甚至3D位置预测的多任务模型。简单来说，它不仅能找到人脸在哪，还能知道脸的朝向和五官位置。

这对于我们的马赛克工具来说，有几个关键优势：

精度高：在复杂场景、多人脸、侧脸甚至部分遮挡的情况下，RetinaFace依然能保持很高的检测率，确保不会漏掉该处理的人脸。
关键点准：它输出的5个关键点（双眼、鼻尖、两个嘴角）能帮助我们更精准地确定人脸区域，避免把马赛克打到头发或背景上。
速度快：特别是它的轻量级版本（基于MobileNet），在普通电脑上也能达到实时处理的速度，满足视频流处理的需求。

市面上虽然也有其他人脸检测方案，但RetinaFace在精度和速度的平衡上做得相当不错，非常适合我们这种需要实际落地的应用场景。

2. 环境搭建与核心工具安装

工欲善其事，必先利其器。我们先来把开发环境准备好。整个过程很简单，跟着步骤走就行。

2.1 创建并激活虚拟环境

首先，我们创建一个独立的Python环境，避免包版本冲突。打开你的终端（命令行），执行以下命令：

# 创建名为 face_blur 的虚拟环境 python -m venv face_blur_env # 激活虚拟环境 # 在 Windows 上： face_blur_env\Scripts\activate # 在 macOS 或 Linux 上： source face_blur_env/bin/activate

激活后，你的命令行前面应该会出现(face_blur_env)的提示，表示已经在虚拟环境里了。

2.2 安装必要的Python库

接下来，安装我们需要的几个核心库。这里我们使用pip进行安装。

pip install torch torchvision pip install opencv-python pip install numpy pip install Pillow

简单解释一下：

torch：PyTorch深度学习框架，RetinaFace模型基于它。
opencv-python：强大的计算机视觉库，用来读取图片、视频，以及绘制马赛克。
numpy：Python的科学计算基础包，处理数组数据。
Pillow：Python的图像处理库，另一个常用的图片操作选择。

2.3 获取RetinaFace模型代码与权重

RetinaFace本身不是一个可以通过pip直接安装的包，我们需要从开源项目获取它的实现。一个比较流行的实现是biubug6/Pytorch_Retinaface。

你可以通过Git克隆这个仓库，或者直接下载ZIP文件。这里以克隆为例：

# 克隆仓库到当前目录 git clone https://github.com/biubug6/Pytorch_Retinaface.git # 进入项目目录 cd Pytorch_Retinaface

克隆完成后，你会在Pytorch_Retinaface文件夹里看到模型代码。我们还需要下载预训练好的模型权重文件，这样就不用自己从头训练了。通常项目README会提供下载链接，这里我们假设你已经下载好了Resnet50_Final.pth（用于高精度）或mobilenet0.25_Final.pth（用于轻量快速）这两个权重文件，并把它们放在Pytorch_Retinaface/weights/目录下。

好了，环境准备就绪，接下来我们进入核心部分。

3. 核心功能一：单张图片人脸马赛克

让我们先从最简单的功能开始：给一张图片里的人脸打马赛克。理解了这个过程，批量处理和视频处理就是它的延伸。

3.1 加载模型与检测人脸

首先，我们写一个函数来加载RetinaFace模型并进行人脸检测。

import torch import cv2 import numpy as np from models.retinaface import RetinaFace from data import cfg_mnet, cfg_re50 from utils.box_utils import decode, decode_landm from utils.nms.py_cpu_nms import py_cpu_nms import os def load_retinaface_model(weight_path, network='resnet50'): """ 加载RetinaFace模型 Args: weight_path: 权重文件路径 network: 网络类型，'resnet50' 或 'mobilenet' Returns: model: 加载好的模型 cfg: 模型配置 """ # 根据网络类型选择配置 if network == 'mobilenet': cfg = cfg_mnet else: cfg = cfg_re50 # 初始化模型 model = RetinaFace(cfg=cfg, phase='test') model.load_state_dict(torch.load(weight_path, map_location=torch.device('cpu'))) model.eval() # 设置为评估模式 print(f"模型加载成功: {network}") return model, cfg def detect_faces(model, cfg, img_raw, confidence_threshold=0.5): """ 检测图片中的人脸 Args: model: 加载的RetinaFace模型 cfg: 模型配置 img_raw: 原始图像 (BGR格式) confidence_threshold: 置信度阈值，高于此值才认为是人脸 Returns: faces: 检测到的人脸框列表，每个框为 [x1, y1, x2, y2] landmarks: 对应的人脸关键点列表 """ img = np.float32(img_raw) # 图像预处理：缩放、归一化、转换维度 im_height, im_width, _ = img.shape scale = torch.Tensor([img.shape[1], img.shape[0], img.shape[1], img.shape[0]]) img -= (104, 117, 123) # 减去均值 img = img.transpose(2, 0, 1) # HWC -> CHW img = torch.from_numpy(img).unsqueeze(0) # 增加批次维度 # 模型推理 with torch.no_grad(): loc, conf, landms = model(img) # 解码预测结果 priorbox = PriorBox(cfg, image_size=(im_height, im_width)) priors = priorbox.forward() boxes = decode(loc.data.squeeze(0), priors, cfg['variance']) boxes = boxes * scale scores = conf.squeeze(0)[:, 1] landms = decode_landm(landms.data.squeeze(0), priors, cfg['variance']) scale_landms = torch.Tensor([img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2]]) landms = landms * scale_landms # 过滤低置信度的检测结果 inds = np.where(scores > confidence_threshold)[0] boxes = boxes[inds] landms = landms[inds] scores = scores[inds] # 非极大值抑制，去除重叠框 dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=False) keep = py_cpu_nms(dets, 0.4) # NMS阈值 dets = dets[keep, :] landms = landms[keep] # 整理返回结果 faces = [] landmarks_list = [] for det, landm in zip(dets, landms): x1, y1, x2, y2 = int(det[0]), int(det[1]), int(det[2]), int(det[3]) faces.append([x1, y1, x2, y2]) # 整理5个关键点坐标 landm = landm.numpy() landmarks = [] for i in range(5): landmarks.append([int(landm[2*i]), int(landm[2*i+1])]) landmarks_list.append(landmarks) return faces, landmarks_list # 注意：这里需要从原项目导入PriorBox，或者根据项目代码自行定义 # from utils.prior_box import PriorBox

这段代码的核心是detect_faces函数。它接收一张图片，通过RetinaFace模型找出所有人脸的位置（faces）和关键点（landmarks）。confidence_threshold参数可以调节，值越高，检测要求越严格，可能漏检但误检少；值越低，检测更敏感，但可能把一些不是人脸的东西也框进来。

3.2 实现马赛克模糊效果

检测到人脸框之后，我们需要对这个区域进行模糊处理。这里我们采用经典的“像素块化”方法来模拟马赛克效果。

def apply_mosaic_to_face(image, face_box, mosaic_size=15): """ 对人脸区域应用马赛克效果 Args: image: 原始图像 face_box: 人脸框 [x1, y1, x2, y2] mosaic_size: 马赛克块的大小，值越大马赛克越粗 Returns: image: 处理后的图像 """ x1, y1, x2, y2 = face_box # 确保坐标在图像范围内 h, w = image.shape[:2] x1, y1 = max(0, x1), max(0, y1) x2, y2 = min(w, x2), min(h, y2) # 提取人脸区域 face_region = image[y1:y2, x1:x2] # 应用马赛克：缩小再放大 small = cv2.resize(face_region, (mosaic_size, mosaic_size), interpolation=cv2.INTER_LINEAR) mosaic_face = cv2.resize(small, (x2 - x1, y2 - y1), interpolation=cv2.INTER_NEAREST) # 将马赛克区域贴回原图 image[y1:y2, x1:x2] = mosaic_face return image def process_single_image(image_path, model, cfg, output_path=None, confidence_threshold=0.5): """ 处理单张图片：检测人脸并打马赛克 Args: image_path: 输入图片路径 model: RetinaFace模型 cfg: 模型配置 output_path: 输出图片路径，如果为None则显示而不保存 confidence_threshold: 检测置信度阈值 """ # 读取图片 img = cv2.imread(image_path) if img is None: print(f"无法读取图片: {image_path}") return img_display = img.copy() # 检测人脸 faces, landmarks = detect_faces(model, cfg, img, confidence_threshold) print(f"检测到 {len(faces)} 张人脸") # 对每张人脸应用马赛克 for i, face in enumerate(faces): img_display = apply_mosaic_to_face(img_display, face) # 可选：在图上画出人脸框和关键点（调试用） # x1, y1, x2, y2 = face # cv2.rectangle(img_display, (x1, y1), (x2, y2), (0, 255, 0), 2) # for point in landmarks[i]: # cv2.circle(img_display, tuple(point), 2, (0, 0, 255), -1) # 显示或保存结果 if output_path: cv2.imwrite(output_path, img_display) print(f"结果已保存至: {output_path}") else: # 并排显示原图和处理后的图 img_resized = cv2.resize(img, (img_display.shape[1], img_display.shape[0])) combined = np.hstack((img_resized, img_display)) cv2.imshow('Original vs. Processed', combined) cv2.waitKey(0) cv2.destroyAllWindows()

apply_mosaic_to_face函数是马赛克效果的核心。它的原理很简单：先把人脸区域缩放到一个很小的尺寸（比如15x15像素），这样细节就丢失了，只剩下色块；然后再把这个小色块放大回原来的尺寸，就形成了马赛克效果。mosaic_size参数控制马赛克的粗糙程度，值越小越精细（但可能模糊效果不够），值越大马赛克块越明显。

3.3 试试效果

现在，让我们写一个简单的脚本来测试一下。

if __name__ == "__main__": # 1. 加载模型 (请根据你下载的权重文件路径修改) weight_file = "./weights/mobilenet0.25_Final.pth" # 轻量版，速度快 # weight_file = "./weights/Resnet50_Final.pth" # 精度版，更准 model, cfg = load_retinaface_model(weight_file, network='mobilenet') # 2. 处理单张图片 input_image = "test_photo.jpg" # 替换成你的测试图片路径 output_image = "test_photo_mosaic.jpg" process_single_image(input_image, model, cfg, output_path=output_image)

运行这个脚本，如果一切顺利，你会在当前目录下看到生成的新图片test_photo_mosaic.jpg，里面所有人脸都应该被自动打上了马赛克。你可以找一张有多个人物的合影试试，看看效果如何。

4. 核心功能二：批量图片处理与优化

单张处理没问题了，但在实际工作中，我们往往需要处理成百上千张图片。一张张点开处理显然不现实，我们需要批量处理功能。

4.1 实现批量处理脚本

批量处理的逻辑很简单：遍历一个文件夹里的所有图片，对每张图片调用我们刚才写的process_single_image函数，然后保存到另一个文件夹。

import os from pathlib import Path def batch_process_images(input_dir, output_dir, model, cfg, confidence_threshold=0.5, supported_extensions=('.jpg', '.jpeg', '.png', '.bmp')): """ 批量处理一个文件夹内的所有图片 Args: input_dir: 输入图片文件夹路径 output_dir: 输出图片文件夹路径 model: RetinaFace模型 cfg: 模型配置 confidence_threshold: 检测置信度 supported_extensions: 支持的图片格式 """ # 创建输出目录 Path(output_dir).mkdir(parents=True, exist_ok=True) # 获取所有图片文件 image_files = [] for ext in supported_extensions: image_files.extend(Path(input_dir).glob(f'*{ext}')) image_files.extend(Path(input_dir).glob(f'*{ext.upper()}')) print(f"在 '{input_dir}' 中找到 {len(image_files)} 张图片") processed_count = 0 for img_path in image_files: try: output_path = Path(output_dir) / f"{img_path.stem}_mosaic{img_path.suffix}" process_single_image(str(img_path), model, cfg, output_path=str(output_path), confidence_threshold=confidence_threshold) processed_count += 1 print(f"已处理: {img_path.name} -> {output_path.name}") except Exception as e: print(f"处理图片 {img_path.name} 时出错: {e}") print(f"批量处理完成！成功处理 {processed_count}/{len(image_files)} 张图片。") # 使用示例 if __name__ == "__main__": model, cfg = load_retinaface_model("./weights/mobilenet0.25_Final.pth", 'mobilenet') batch_process_images("./input_photos", "./output_photos", model, cfg)

把需要处理的图片全部扔进input_photos文件夹，运行脚本，然后去output_photos文件夹查看结果就行了。

4.2 性能优化小技巧

处理大量图片时，速度可能是个问题。这里分享几个提速的小技巧：

使用轻量模型：在load_retinaface_model函数中，选择network='mobilenet'并加载对应的权重。MobileNet版本速度更快，虽然精度略低于ResNet50，但对于马赛克这种应用通常够用。

调整图片尺寸：如果原始图片分辨率非常高（比如4K），直接检测会很慢。可以在检测前先将图片缩放到一个合理的大小（例如，短边800像素），检测出人脸框后，再按缩放比例换算回原图坐标进行处理。

def detect_faces_fast(model, cfg, img_raw, target_size=800): """快速检测版本：先缩放图片""" h, w = img_raw.shape[:2] scale = target_size / min(h, w) new_w, new_h = int(w * scale), int(h * scale) img_resized = cv2.resize(img_raw, (new_w, new_h)) # 在缩放后的图上检测 faces_small, landmarks_small = detect_faces(model, cfg, img_resized) # 将坐标映射回原图 faces = [] landmarks = [] for face, landm in zip(faces_small, landmarks_small): x1, y1, x2, y2 = face faces.append([int(x1/scale), int(y1/scale), int(x2/scale), int(y2/scale)]) landmarks.append([[int(p[0]/scale), int(p[1]/scale)] for p in landm]) return faces, landmarks

并行处理：如果图片数量巨大，可以考虑使用Python的multiprocessing库进行多进程处理，充分利用多核CPU。

5. 核心功能三：视频流实时处理

图片处理搞定了，视频怎么办？视频本质上就是一连串的图片（帧）。所以，我们的思路就是：读取视频的每一帧 -> 检测人脸并打码 -> 把处理后的帧写回成一个新视频。

5.1 处理视频文件

def process_video_file(input_video_path, output_video_path, model, cfg, confidence_threshold=0.5, frame_skip=0): """ 处理视频文件：给人脸打马赛克 Args: input_video_path: 输入视频路径 output_video_path: 输出视频路径 model: RetinaFace模型 cfg: 模型配置 confidence_threshold: 检测置信度 frame_skip: 跳帧处理，0表示处理每一帧，1表示每2帧处理1帧，以此类推 """ # 打开视频 cap = cv2.VideoCapture(input_video_path) if not cap.isOpened(): print(f"无法打开视频文件: {input_video_path}") return # 获取视频信息 fps = int(cap.get(cv2.CAP_PROP_FPS)) width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # 创建视频写入器 fourcc = cv2.VideoWriter_fourcc(*'mp4v') # 或 'XVID' out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height)) frame_count = 0 processed_frame_count = 0 print(f"开始处理视频: {input_video_path}") print(f"分辨率: {width}x{height}, FPS: {fps}, 总帧数: {total_frames}") while True: ret, frame = cap.read() if not ret: break # 跳帧处理，提升速度 if frame_count % (frame_skip + 1) != 0: out.write(frame) # 跳过的帧直接写入原帧 frame_count += 1 continue # 检测并处理当前帧 faces, landmarks = detect_faces(model, cfg, frame, confidence_threshold) for face in faces: frame = apply_mosaic_to_face(frame, face) # 写入处理后的帧 out.write(frame) processed_frame_count += 1 # 打印进度 if processed_frame_count % 30 == 0: # 每处理30帧打印一次 print(f"进度: {processed_frame_count}/{total_frames} 帧") frame_count += 1 # 释放资源 cap.release() out.release() cv2.destroyAllWindows() print(f"视频处理完成！输出至: {output_video_path}") print(f"实际处理了 {processed_frame_count} 帧 (跳帧设置: {frame_skip})")

这个函数的关键参数是frame_skip。视频的帧率通常是25或30，意味着每秒有25-30张图片。如果对每一帧都进行人脸检测，计算量会很大，可能导致处理速度跟不上视频播放速度。frame_skip=1表示我们只处理第1, 3, 5, 7...帧，跳过的帧直接使用上一帧的处理结果（或者原帧）。这在人物运动不剧烈的场景下，能大幅提升处理速度，且视觉上差异不大。

5.2 实时摄像头处理

有了处理视频文件的基础，实现摄像头实时处理就很容易了，只需要把视频源从文件换成摄像头设备。

def process_camera_realtime(camera_id=0, model=None, cfg=None, confidence_threshold=0.5): """ 实时处理摄像头视频流 Args: camera_id: 摄像头ID，通常0是默认摄像头 model: RetinaFace模型 (如果为None，函数内部会尝试加载) cfg: 模型配置 confidence_threshold: 检测置信度 """ if model is None: # 默认加载轻量模型以求速度 model, cfg = load_retinaface_model("./weights/mobilenet0.25_Final.pth", 'mobilenet') cap = cv2.VideoCapture(camera_id) if not cap.isOpened(): print(f"无法打开摄像头 {camera_id}") return print("开始实时人脸马赛克处理。按 'q' 键退出。") while True: ret, frame = cap.read() if not ret: print("无法从摄像头读取帧。") break # 为了实时性，可以适当缩小帧的尺寸 frame_small = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5) # 检测人脸 faces, landmarks = detect_faces(model, cfg, frame_small, confidence_threshold) # 将检测到的人脸框坐标映射回原图尺寸 for face in faces: x1, y1, x2, y2 = [coord * 2 for coord in face] # 因为我们缩小了一半 frame = apply_mosaic_to_face(frame, [x1, y1, x2, y2]) # 显示结果 cv2.imshow('Real-time Face Mosaic', frame) # 按'q'退出 if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows() print("实时处理结束。")

运行process_camera_realtime()，你的电脑摄像头就会打开，画面中的人脸会被实时打上马赛克。这对于一些需要实时隐私保护的场景（比如在线会议、直播）的演示或原型开发很有用。

6. 更进一步：精准区域与动态模糊

我们目前是对整个矩形人脸框打码。但有时候，我们可能只想模糊眼睛，或者根据人脸姿态进行更精准的模糊。RetinaFace提供的5个关键点就派上用场了。

6.1 基于关键点的区域模糊

例如，如果我们只想模糊眼睛区域，可以利用左右眼的关键点坐标。

def apply_eye_mosaic(image, landmarks, mosaic_size=10, expand_ratio=0.3): """ 仅对眼睛区域打马赛克 Args: image: 图像 landmarks: 5个关键点列表 [[x1,y1], [x2,y2], ...]，顺序通常是：左眼、右眼、鼻子、左嘴角、右嘴角 mosaic_size: 马赛克块大小 expand_ratio: 在眼睛关键点基础上向外扩展的比例，确保覆盖整个眼窝 """ # 左眼和右眼是关键点的前两个 left_eye = landmarks[0] right_eye = landmarks[1] # 计算眼睛区域的边界框，并适当扩大 eye_centers_x = [left_eye[0], right_eye[0]] eye_centers_y = [left_eye[1], right_eye[1]] eye_width = abs(right_eye[0] - left_eye[0]) / 2 # 粗略估计单只眼睛的宽度 eye_height = eye_width * 0.6 # 眼睛大致高宽比 for eye_center in [left_eye, right_eye]: x_center, y_center = eye_center x1 = int(x_center - eye_width * (1 + expand_ratio)) y1 = int(y_center - eye_height * (1 + expand_ratio)) x2 = int(x_center + eye_width * (1 + expand_ratio)) y2 = int(y_center + eye_height * (1 + expand_ratio)) # 应用马赛克 image = apply_mosaic_to_face(image, [x1, y1, x2, y2], mosaic_size) return image

这样，你就可以在process_single_image函数的循环中，选择调用apply_mosaic_to_face（全脸模糊）还是apply_eye_mosaic（仅模糊眼睛），实现更精细的隐私保护控制。

6.2 尝试动态模糊效果

标准的马赛克是静态的方块。我们也可以尝试一种动态的模糊效果，比如高斯模糊，它看起来更柔和自然。

def apply_gaussian_blur_to_face(image, face_box, kernel_size=(35, 35)): """ 对人脸区域应用高斯模糊 Args: image: 图像 face_box: 人脸框 [x1, y1, x2, y2] kernel_size: 高斯核大小，必须是正奇数。值越大越模糊。 """ x1, y1, x2, y2 = face_box h, w = image.shape[:2] x1, y1 = max(0, x1), max(0, y1) x2, y2 = min(w, x2), min(h, y2) face_region = image[y1:y2, x1:x2] # 应用高斯模糊 blurred_face = cv2.GaussianBlur(face_region, kernel_size, 0) image[y1:y2, x1:x2] = blurred_face return image

你可以把apply_mosaic_to_face替换成apply_gaussian_blur_to_face，看看效果。高斯模糊的边缘过渡更自然，但隐私隐藏效果可能不如马赛克彻底。kernel_size参数控制模糊程度。