• 教程 >
  • 树莓派 4 上的实时推理 (30 fps!)
快捷方式

树莓派 4 上的实时推理 (30 fps!)

作者: Tristan Rice

PyTorch 对树莓派 4 提供了开箱即用的支持。本教程将指导你如何在树莓派 4 上设置 PyTorch 并实时 (30 fps+) 在 CPU 上运行 MobileNet v2 分类模型。

所有这些都在树莓派 4 Model B 4GB 上进行了测试,但应该也适用于 2GB 版本,以及在 3B 上运行,但性能会降低。

https://user-images.githubusercontent.com/909104/153093710-bc736b6f-69d9-4a50-a3e8-9f2b2c9e04fd.gif

先决条件

要学习本教程,你需要一台树莓派 4、一个摄像头以及所有其他标准配件。

树莓派 4 设置

PyTorch 仅为 Arm 64 位 (aarch64) 提供 pip 包,因此你需要在树莓派上安装 64 位版本的系统

你可以从 https://downloads.raspberrypi.org/raspios_arm64/images/ 下载最新的 arm64 Raspberry Pi OS 并通过 rpi-imager 安装。

32 位 Raspberry Pi OS 将无法工作。

https://user-images.githubusercontent.com/909104/152866212-36ce29b1-aba6-4924-8ae6-0a283f1fca14.gif

安装至少需要几分钟,具体取决于你的互联网速度和 SD 卡速度。完成后,它应该如下所示

https://user-images.githubusercontent.com/909104/152867425-c005cff0-5f3f-47f1-922d-e0bbb541cd25.png

现在是时候将你的 SD 卡插入 Raspberry Pi,连接摄像头并启动它了。

https://user-images.githubusercontent.com/909104/152869862-c239c980-b089-4bd5-84eb-0a1e5cf22df2.png

启动并完成初始设置后,你需要编辑 /boot/config.txt 文件以启用摄像头。

# This enables the extended features such as the camera.
start_x=1

# This needs to be at least 128M for the camera processing, if it's bigger you can just leave it as is.
gpu_mem=128

# You need to commment/remove the existing camera_auto_detect line since this causes issues with OpenCV/V4L2 capture.
#camera_auto_detect=1

然后重启。重启后,video4linux2 设备 /dev/video0 应该存在。

安装 PyTorch 和 OpenCV

PyTorch 和我们需要的其他所有库都有 ARM 64 位/aarch64 版本,因此你可以通过 pip 安装它们,就像在任何其他 Linux 系统上一样。

$ pip install torch torchvision torchaudio
$ pip install opencv-python
$ pip install numpy --upgrade
https://user-images.githubusercontent.com/909104/152874260-95a7a8bd-0f9b-438a-9c0b-5b67729e233f.png

现在我们可以检查所有内容是否已正确安装。

$ python -c "import torch; print(torch.__version__)"
https://user-images.githubusercontent.com/909104/152874271-d7057c2d-80fd-4761-aed4-df6c8b7aa99f.png

视频捕捉

对于视频捕捉,我们将使用 OpenCV 来流式传输视频帧,而不是更常见的 picamerapicamera 在 64 位 Raspberry Pi OS 上不可用,并且比 OpenCV 慢得多。OpenCV 直接访问 /dev/video0 设备来抓取帧。

我们使用的模型(MobileNetV2)接收 224x224 尺寸的图像,因此我们可以直接从 OpenCV 以 36fps 的速度请求。我们的目标是模型的 30fps,但我们请求稍微更高的帧率,这样总会有足够的帧。

import cv2
from PIL import Image

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 224)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 224)
cap.set(cv2.CAP_PROP_FPS, 36)

OpenCV 返回一个 BGR 格式的 numpy 数组,因此我们需要读取并进行一些调整以将其转换为预期的 RGB 格式。

ret, image = cap.read()
# convert opencv output from BGR to RGB
image = image[:, :, [2, 1, 0]]

此数据读取和处理大约需要 3.5 ms

图像预处理

我们需要获取帧并将它们转换为模型期望的格式。这与你在任何机器上使用标准 torchvision 变换所做的处理相同。

from torchvision import transforms

preprocess = transforms.Compose([
    # convert the frame to a CHW torch tensor for training
    transforms.ToTensor(),
    # normalize the colors to the range that mobilenet_v2/3 expect
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
input_tensor = preprocess(image)
# The model can handle multiple images simultaneously so we need to add an
# empty dimension for the batch.
# [3, 224, 224] -> [1, 3, 224, 224]
input_batch = input_tensor.unsqueeze(0)

模型选择

你可以选择许多模型,它们具有不同的性能特征。并非所有模型都提供 qnnpack 预训练版本,因此出于测试目的,你应该选择一个提供预训练版本的模型,但如果你训练并量化自己的模型,则可以使用任何模型。

在本教程中,我们使用 mobilenet_v2,因为它具有良好的性能和准确性。

Raspberry Pi 4 基准测试结果

模型

FPS

总时间(毫秒/帧)

模型时间(毫秒/帧)

qnnpack 预训练

mobilenet_v2

33.7

29.7

26.4

mobilenet_v3_large

29.3

34.1

30.7

resnet18

9.2

109.0

100.3

resnet50

4.3

233.9

225.2

resnext101_32x8d

1.1

892.5

885.3

inception_v3

4.9

204.1

195.5

googlenet

7.4

135.3

132.0

shufflenet_v2_x0_5

46.7

21.4

18.2

shufflenet_v2_x1_0

24.4

41.0

37.7

shufflenet_v2_x1_5

16.8

59.6

56.3

shufflenet_v2_x2_0

11.6

86.3

82.7

MobileNetV2:量化和 JIT

为了获得最佳性能,我们希望模型被量化和融合。量化意味着它使用 int8 进行计算,这比标准的 float32 数学运算效率高得多。融合意味着在可能的情况下,连续的操作已被融合成更高效的版本。通常,诸如激活(ReLU)之类的操作可以在推理期间与之前的层(Conv2d)合并。

aarch64 版本的 pytorch 需要使用 qnnpack 引擎。

import torch
torch.backends.quantized.engine = 'qnnpack'

在本例中,我们将使用 torchvision 提供的 MobileNetV2 的预量化和融合版本。

from torchvision import models
net = models.quantization.mobilenet_v2(pretrained=True, quantize=True)

然后,我们希望对模型进行 JIT,以减少 Python 开销并融合任何操作。JIT 使我们能够达到大约 30fps,而不是没有 JIT 的大约 20fps。

net = torch.jit.script(net)

整合在一起

现在我们可以将所有部分整合在一起并运行它。

import time

import torch
import numpy as np
from torchvision import models, transforms

import cv2
from PIL import Image

torch.backends.quantized.engine = 'qnnpack'

cap = cv2.VideoCapture(0, cv2.CAP_V4L2)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 224)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 224)
cap.set(cv2.CAP_PROP_FPS, 36)

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

net = models.quantization.mobilenet_v2(pretrained=True, quantize=True)
# jit model to take it from ~20fps to ~30fps
net = torch.jit.script(net)

started = time.time()
last_logged = time.time()
frame_count = 0

with torch.no_grad():
    while True:
        # read frame
        ret, image = cap.read()
        if not ret:
            raise RuntimeError("failed to read frame")

        # convert opencv output from BGR to RGB
        image = image[:, :, [2, 1, 0]]
        permuted = image

        # preprocess
        input_tensor = preprocess(image)

        # create a mini-batch as expected by the model
        input_batch = input_tensor.unsqueeze(0)

        # run model
        output = net(input_batch)
        # do something with output ...

        # log model performance
        frame_count += 1
        now = time.time()
        if now - last_logged > 1:
            print(f"{frame_count / (now-last_logged)} fps")
            last_logged = now
            frame_count = 0

运行它表明我们徘徊在约 30fps。

https://user-images.githubusercontent.com/909104/152892609-7d115705-3ec9-4f8d-beed-a51711503a32.png

这是在 Raspberry Pi OS 中使用所有默认设置的情况下。如果你禁用了默认启用的 UI 和所有其他后台服务,则性能会更高,更稳定。

如果我们检查 htop,我们会看到我们几乎有 100% 的利用率。

https://user-images.githubusercontent.com/909104/152892630-f094b84b-19ba-48f6-8632-1b954abc59c7.png

为了验证它端到端地工作,我们可以计算类的概率,并 使用 ImageNet 类标签 打印检测结果。

top = list(enumerate(output[0].softmax(dim=0)))
top.sort(key=lambda x: x[1], reverse=True)
for idx, val in top[:10]:
    print(f"{val.item()*100:.2f}% {classes[idx]}")

mobilenet_v3_large 实时运行

https://user-images.githubusercontent.com/909104/153093710-bc736b6f-69d9-4a50-a3e8-9f2b2c9e04fd.gif

检测橙子

https://user-images.githubusercontent.com/909104/153092153-d9c08dfe-105b-408a-8e1e-295da8a78c19.jpg

检测马克杯

https://user-images.githubusercontent.com/909104/153092155-4b90002f-a0f3-4267-8d70-e713e7b4d5a0.jpg

故障排除:性能

PyTorch 默认情况下将使用所有可用的核心。如果你在 Raspberry Pi 上的后台运行任何东西,它可能会导致与模型推理的竞争,从而导致延迟峰值。为了缓解这个问题,你可以减少线程数,这将以少量性能损失为代价降低峰值延迟。

torch.set_num_threads(2)

对于 shufflenet_v2_x1_5,使用 2 个线程 而不是 4 个线程 将最佳情况延迟从 60 ms 提高到 72 ms,但消除了 128 ms 的延迟峰值。

后续步骤

你可以创建自己的模型或微调现有的模型。如果你微调 torchvision.models.quantized 中的某个模型,则大部分融合和量化的工作已经为你完成,因此你可以直接部署并在 Raspberry Pi 上获得良好的性能。

更多信息

  • 量化,了解有关如何量化和融合模型的更多信息。

  • 迁移学习教程,了解如何使用迁移学习将预先存在的模型微调到你的数据集。

文档

访问 PyTorch 的全面开发者文档

查看文档

教程

获取适合初学者和高级开发人员的深入教程

查看教程

资源

查找开发资源并获得问题的解答

查看资源