吴恩达深度学习课程四：计算机视觉 第四周：卷积网络应用 课后习题和代码实践

此分类用于记录吴恩达深度学习课程的学习笔记。
课程相关信息链接如下：

• 原课程视频链接：[双语字幕]吴恩达深度学习deeplearning.ai
  
• github课程资料，含课件与笔记:吴恩达深度学习教学资料
  
• 课程配套练习（中英）与答案：吴恩达深度学习课后习题与答案
  

本篇为第四课第四周的课后习题和代码实践部分。
1. 理论习题

【中英】【吴恩达课后测验】Course 4 -卷积神经网络 - 第四周测验
还是比较简单，我们就不展开了。
2.代码实践

【中英】【吴恩达课后编程作业】Course 4 -卷积神经网络 - 第四周作业
再次提醒 Keras 的导库问题。
老样子，我们还是使用现有的成熟框架来分别实现本周介绍的人脸识别和图像风格转换模型。
2.1 人脸识别

实际上，在如今的实验和实际部署中，人脸识别的整套逻辑已经远比我们在理论部分所介绍的要复杂和完善的多，我们依旧分点来进行介绍。
（1）python 库：InsightFace

作为一个应用中生活中方方面面的技术，就像我们之前介绍的目标检测有ultralytics，人脸识别也有将成熟算法体系工程化、模块化的工具库：InsightFace
InsightFace 是基于 ArcFace 等先进算法构建的人脸分析库，功能涵盖：

• 人脸检测：支持单人或多人图像检测，返回人脸框和关键点；
  
• 人脸对齐：通过关键点实现旋转、缩放等对齐操作，提高识别精度；
  
• 人脸识别/验证：提取 embedding，进行相似度计算或一对多搜索；
  
• 性别、年龄、姿态估计：内置轻量化预测模型；
  
• 模块化、可扩展：你可以直接使用预训练模型，也可以替换为自己训练的模型。
  

使用 InsightFace，我们几乎不需要从零实现算法逻辑，只需调用接口即可完成人脸识别的实验和演示。
同样，我们可以通过 pip 安装 InsightFace 相关依赖：

1. pip install insightface onnxruntime

复制代码

其中：

• CPU 版本：默认安装即可，无需额外配置。
  
• GPU 版本：如果希望使用 GPU 加速，则需要安装 GPU 版本 ONNX Runtime：
  

1. pip install onnxruntime-gpu

复制代码

有一些注意事项，如果不进行相关配置会导致报错：

• ONNX Runtime GPU 需要 CUDA 和 cuDNN 与当前版本兼容
  
• 在 Windows 上，部分组件需要 Microsoft C++ Build Tools，用于编译部分 C++/Cython 扩展：
  
  
  
  • 安装 Visual Studio Installer
    
  • 勾选 “使用 C++ 的桌面开发”
    
  • 即可保证 insightface 或其他依赖（如 face3d）可以正确编译。
    
  
  

在成功安装 InsightFace 后，我们来看看如何使用这个框架。
（2）InsightFace 预训练模型

我们对预训练模型的使用也早就不陌生了，InsightFace 同样内置了一系列从轻量级到重量级的预训练模型，我们可以通过接口实现下载并调用。
来简单看一段代码：

1. from insightface.app import FaceAnalysis
2. app = FaceAnalysis(name='buffalo_l')  # 会自动下载预训练模型，这是一种轻量级模型

复制代码

当你运行时，模型会缓存到用户目录下，自动下载并解压，无需手动配置：

1. C:\Users\<用户名>\.insightface\models\

复制代码

需要特别说明的是，buffalo_l 模型不仅仅是单一的识别模型，它实际上集成了人脸识别任务中的多个环节，包括：

• 人脸检测 ：在输入图像中快速找到人脸区域。
  
• 关键点定位：在检测到的人脸上标出关键点（如眼睛、嘴角、鼻尖等）。
  
• 3D 人脸建模（可选，部分模型）：预测人脸的三维结构信息。
  
• 人脸特征提取：将每张人脸映射到一个高维向量空间，就是我们之前说的编码。
  
• 性别与年龄预测（部分模型）：预测人脸的性别和年龄区间。
  

了解了它的功能后，现在我们就来演示一下：
（3）示例使用：人脸检测

我们用这样一段代码来进行初始化和人脸检测：

1. from insightface.app import FaceAnalysis  
2. import cv2 # 用来读取图像  
3.   
4. app = FaceAnalysis(name='buffalo_l')  # 轻量级预训练模型  
5. app.prepare(ctx_id=0, det_size=(640, 640))  # ctx_id=-1 使用 CPU  
6. img = cv2.imread("images4.jpg") # 读取图片  
7. faces = app.get(img) # 传入模型进行处理  
8.   
9. if faces:  
10.     print("检测到人脸数量:", len(faces))  
11.     print("第一张人脸 embedding:", faces[0].embedding[:20]) # 只显示前 20 维  
12.     print("第二张人脸 embedding:", faces[1].embedding[:20])

复制代码

来看看运行后的效果：

这样，就完成了对图像的编码。
（4）示例使用：关键点定位

同样，只要所选用的预训练模型支持，app.get(img)的同样可以实现关键点定位：

1. from insightface.app import FaceAnalysis  
2. import cv2  
3.   
4. app = FaceAnalysis(name='buffalo_l')  
5. app.prepare(ctx_id=0, det_size=(640, 640))  
6. img = cv2.imread("images4.jpg")  
7. faces = app.get(img)  
8.   
9. if faces:  
10.     # 画定位图  
11.     vis = img.copy()  
12.     for face in faces:  
13.         bbox = face.bbox.astype(int)  
14.         cv2.rectangle(vis, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)  
15.         if 'landmark_2d_106' in face:  
16.             landmarks_2d = face['landmark_2d_106'].astype(int)  
17.             for (x, y) in landmarks_2d:  
18.                 cv2.circle(vis, (x, y), 2, (0, 0, 255), -1)  
19.     # 保存结果  
20.     cv2.imwrite("output.jpg", vis)  
21.     print("结果已保存到 output.jpg")

复制代码

来看结果：

同样可以较为成功的定位到人脸的各个部位。
（5）通过相似度学习实现人脸识别

演示了一些基本功能后，我们回到正题，再回顾一下原理：人脸识别并非要训练“你是谁”的网络，而是“你更像谁”的网络。即学习相似度而非分类，以此来实现具有较高部署价值的系统。
因此，我们可以把两幅图像输入预训练模型，通过二者的编码来计算它们的相似度，代码如下：

1. import cv2  
2. import numpy as np  
3. from insightface.app import FaceAnalysis  
4.   
5. # 1. 初始化
6. InsightFaceapp = FaceAnalysis(name='buffalo_l')  
7. app.prepare(ctx_id=-1, det_size=(640, 640))  # ctx_id=-1 用 CPU  
8. # 2. 读取图片  
9. img1 = cv2.imread("images1.jpg")  
10. img2 = cv2.imread("images2.jpg")  
11.   
12. # 3. 检测并提取人脸 embedding
13. faces1 = app.get(img1)  
14. faces2 = app.get(img2)  
15. emb1 = faces1[0].embedding  
16. emb2 = faces2[0].embedding  
17.   
18. # 4. 另一种更常用的相似度计算：余弦相似度  
19. def cosine_similarity(a, b):  
20.     return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))  
21. sim = cosine_similarity(emb1, emb2)  
22. print(f"Cosine similarity: {sim:.4f}")  
23.   
24. # 5.阈值决策  
25. if sim > 0.60:  
26.     print("很可能是同一个人")  
27. else:  
28.     print("很可能不是同一个人")

复制代码

来看结果：

这样，我们就通过学习相似度，避免了因人数增加而导致的结构和训练问题，实现了人脸识别。
而在实际应用中，我们便可以将所有识别目标预先输入模型得到编码并存储，与刷脸时截取的图像输入模型得到的编码依次计算相似度，根据结果进行下一步操作。
同时，如果希望得到指标更高的结果，我们可以下载更重量级的模型。
现在还有一个问题：如果我们想自己训练模型呢？
由于 InsightFace 本身主要是 提供预训练模型和推理/应用接口，所以它并没有像 Pytorch 或 TF 一样完全封装一套“开箱即用、端到端训练你自己数据集”的完整训练流水线。
因此，我们虽然可以调用 InsightFace 定义的网络结构，但仍需要借助 Pytorch 或 TF 来编码数据输入、训练和梯度下降等逻辑。
但为了实现二者的兼容使用，我们就又要进行很多设置，一个更常见的思路是完全使用Pytorch 或 TF 来搭建自己的人脸识别网络，但这又涉及一些我们还没介绍过的网络结构。
因此在这里就不再展开了，在相关理论补充完成后，我们再来进行这部分内容。
下面来看另一部分：图像风格转换。
2.2 图像风格转换

同样先回顾一下图像风格转换的核心思想：在固定预训练卷积神经网络参数的前提下，利用网络中间层特征，将图像的内容结构与风格统计进行显式分离，并通过在特征空间中最小化相应的代价函数，直接对输入图像进行优化，从而重构出一幅同时匹配内容与风格约束的图像。
因此，要实现一个图像风格转换网络，我们首先要选择一个经过预训练，可以合理提取图像特征的网络作为工具。
在这里，我选择使用 VGG16 作为预训练模型：

1. vgg = models.vgg16(pretrained=True).features.to(device).eval() # 选择评估模式
2. for param in vgg.parameters():  # 冻结所有网络参数
3.     param.requires_grad = False

复制代码

开始编码，首先，我们需要对风格图和内容图两幅图像进行处理：

1. # 读取并预处理输入图像：统一尺寸、转换为张量并送入指定设备，网络输入要求
2. def load_image(path, size=(512, 256)):  
3.     image = Image.open(path).convert("RGB")  
4.     transform = transforms.Compose([  
5.         transforms.Resize(size),  
6.         transforms.ToTensor()  
7.     ])  
8.     return transform(image).unsqueeze(0).to(device)  
9.   
10. content = load_image("content.jpg")  
11. style = load_image("style.jpg")  

复制代码

此外，我们还需要一些工具方法：

1. # 将模型输出的张量形式图像后处理为 PIL 图像，用于结果可视化与保存  
2. def tensor_to_pil(tensor):  
3.     image = tensor.cpu().clone().squeeze(0)  
4.     image = transforms.ToPILImage()(image.clamp(0,1))  
5.     return image  
6.    
7. # 提取输出特征图用于计算代价
8. def get_features(x, model, layers):  
9.     features = {}  
10.     for name, layer in model._modules.items():  
11.         x = layer(x)  
12.         if name in layers:  
13.             features[name] = x  
14.     return features      
15.      
16. # 计算 Gram 矩阵用于计算风格代价  
17. def gram_matrix(features):  
18.     b, ch, h, w = features.size()  
19.     features = features.view(b, ch, h*w)  
20.     gram = torch.bmm(features, features.transpose(1,2))  
21.     return gram / (ch*h*w)

复制代码

最后，再进行传播前的超参数设置：

1. # 指定用于内容表示的 VGG 网络层（通常选用较深层，保留语义信息）
2. content_layers = ['15']
3. # 指定用于风格表示的 VGG 网络层（从浅到深，捕捉不同尺度的纹理与统计特征）
4. style_layers   = ['0', '5', '10', '15']
5. # 以内容图像为初始值创建可优化的输出图像张量，并开启梯度计算
6. output = content.clone().requires_grad_(True).to(device)
7. # 使用 L-BFGS 优化器对输出图像进行优化（风格迁移中常用）
8. optimizer = optim.LBFGS([output])
9. # 风格损失的权重，控制生成结果中风格特征的强度
10. style_weight = 1e6
11. # 内容损失的权重，控制生成结果与原内容图像的相似程度
12. content_weight = 1
13. # 提前计算内容图像在指定内容层上的特征表示
14. content_features = get_features(content, vgg, content_layers)
15. # 提前计算风格图像在指定风格层上的特征表示
16. style_features = get_features(style, vgg, style_layers)
17. # 提前对风格图像的各层特征计算 Gram 矩阵，用于表示风格的统计特性
18. style_grams = {layer: gram_matrix(style_features[layer]) for layer in style_layers}
19. # 设置优化的总迭代次数
20. num_steps = 400
21. # 设置每隔多少步保存或显示一次中间结果
22. display_step = 50
23. # 用于存储每隔 display_step 生成的输出图像，便于可视化训练过程
24. output_images = []

复制代码

由此，我们终于可以进行训练了：

1. run = [0]  
2. while run[0] <= num_steps:  
3.     def closure():  
4.         optimizer.zero_grad()  
5.         output_features = get_features(output, vgg, content_layers + style_layers)
6.   
7.         # 内容损失  
8.         content_loss = 0  
9.         for layer in content_layers:  
10.             content_loss += torch.mean((output_features[layer] - content_features[layer])**2)  
11.   
12.         # 风格损失  
13.         style_loss = 0  
14.         for layer in style_layers:  
15.             G = gram_matrix(output_features[layer])  
16.             style_loss += torch.mean((G - style_grams[layer])**2)  
17.   
18.         total_loss = content_weight * content_loss + style_weight * style_loss  
19.         total_loss.backward()  
20.   
21.         # 保存中间输出  
22.         if run[0] % display_step == 0:  
23.             print(f"Step {run[0]}: Total Loss: {total_loss.item():.2f}")  
24.             output_images.append(tensor_to_pil(output.clone()))  
25.         run[0] += 1  
26.         return total_loss  
27.   
28.     optimizer.step(closure)

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！