【vMaker Edge AI專欄 #22】使用Intel OpenVINO搭配YOLOv11輕鬆駕馭姿態偵測

 作者：Jack OmniXRI, 2024/10/15

留言

相信有在玩AI影像「物件偵測」的朋友對於YOLO(Yolo Only Look Once)一定不會陌生。從2015年第一版(v1)問世至今，在各路大神的努力之下，現在已發展到第十一版(v11)，而其中 v4, v7, v9 正是中研院資訊所廖弘源所長及高徒王建堯博士所貢獻的。

目前最新的 YOLOv11 [1] [2] 就是由 Ultralytic 這家公司所提出的，它是基於該公司先前提出的 v8 版本進行改良而得的，並發表於今(2024)年9月底 YOLO Vision 2024 [3] 活動中。此次這個版本延續之前 v8 版本，一樣提供了「影像分類」、「物件偵測」（含正矩形和斜矩形外框）、影像分割、物件追蹤及姿態估測（人體骨架偵測）等模型，並支援多種推論框架，包括 Google TensorFlow, PyTorch, ONNX, Apple CoreML 及 Intel OpenVINO。

Intel OpenVINO 為了讓大家更快上手，馬上就在開源範例庫 Notebooks [4] 上給出 YOLOv11 物件偵測、姿態估測及影像分割等三個案例，還可支援 Google Colab ，讓大家不用在桌機、筆電上安裝 OpenVINO 也可體驗一把。

接下來我們就跟著源碼說明[5]來了解一下如何運行 【姿態估測】 範例「Convert and Optimize YOLOv11 keypoint detection model with OpenVINO™」及動作原理。完整源碼請參考[6]，點擊連結即可進到 Google Colab 環境執行。

執行前建議可先點擊選單「檔案」─「在雲端硬碟中儲存複本」，複製一份到自己的雲端硬體，方便如果想修改測試時更為方便。接著點擊選單「編輯」─「清除所有輸出內容」，方便稍後觀察運行過程中產出的內容。最後點擊選單「執行階段」─「全部執行」即可看到所有運行結果。

原則上這個範例程式可分成五大段來看，如下所示。

1. 原始 YOLOv11 推論結果
2. 轉換到 OpenVINO IR推論結果
3. 經過 NNCF 壓縮優化推論結果
4. 使用基準測試工具進行比較
5. 連續影片推論展示

這裡為方便大家學習，這裡已把完整源碼[6]步驟簡化為上述五大步驟，並將註解簡化成易懂的中文說明，新版完整範例及說明請參考下方連結。

完整Colab範例程式（點擊後可直接執行）

1. 原始 YOLOv11 推論結果

1.1 安裝 Intel OpenVINO 、 Ultralytics(YOLOv11) 及必要套件包

下載及安裝 OpenVINO, NNCF, PyTorch, Ultralytic(YOLOv11), OpenCV 等相關套件包。但由於 OpenVINO 在 Colab 環境下只能在 Intel Xeon CPU 下運行，所以這裡安裝的 PyTorch 是 CPU 版本。

%pip install -q "openvino>=2024.0.0" "nncf>=2.9.0"
%pip install -q "protobuf==3.20.*" "torch>=2.1" "torchvision>=0.16" "ultralytics==8.3.0" tqdm opencv-python --extra-index-url https://download.pytorch.org/whl/cpu

1.2 下載必要函式庫並引入

下載 notebook_utils.py 到暫存區，並引入 download_file, VideoPlayer, device_widge 函式庫。

from pathlib import Path

# Fetch `notebook_utils` module
import requests

r = requests.get(
    url="https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/notebook_utils.py",
)

open("notebook_utils.py", "w").write(r.text)
from notebook_utils import download_file, VideoPlayer, device_widget

1.3 下載測試用影像

下載網路上影像檔 intel_rnb.jpg，可自行替換 url 後影像來源路徑。

# Download a test sample
IMAGE_PATH = Path("./data/intel_rnb.jpg")
download_file(
    url="https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/image/intel_rnb.jpg",
    filename=IMAGE_PATH.name,
    directory=IMAGE_PATH.parent,
)

1.4 指定推論用模型名稱並下載

建立模型名稱清單，可使用下拉盒式選取，預設名稱為為第[0]個，yolo11n-pose。
這裡可支援 yolov8 及 yolov11 模型名稱，n, s, m, l, x 分別代表模型的大小，從最小到最大，越小推論速度越快但精度略差，反之越大則越慢但精度會提高一些，可依實際需求調整。

import ipywidgets as widgets

model_id = [
    "yolo11n-pose",
    "yolo11s-pose",
    "yolo11m-pose",
    "yolo11l-pose",
    "yolo11x-pose",
    "yolov8n-pose",
    "yolov8s-pose",
    "yolov8m-pose",
    "yolov8l-pose",
    "yolov8x-pose",
]

model_name = widgets.Dropdown(options=model_id, value=model_id[0], description="Model")

model_name

1.5 實例化 YOLO 並測試推論

依上一步驟取得之模型名稱下載模型並實例化成 pose_model
接著直接使用該模型對先前指定好的影像進行推論，並取得姿態（關節點）結果 res （包含物件外框、類別及置信度）繪製在影像上。
另外會輸出總時間及各步驟工作所耗費時間，包含前處理（影像轉換等）、推論（姿態估測）及後處理（輸出數值及繪製結果）。

註：理論上如果只是想取得姿態估測結果，到這一步就可結束了。但這裡可先記下工作耗時及置信度，方便後面和經過 OpenVINO 處理過的內容作比較。

from PIL import Image
from ultralytics import YOLO

POSE_MODEL_NAME = model_name.value

pose_model = YOLO(f"{POSE_MODEL_NAME}.pt")
label_map = pose_model.model.names

res = pose_model(IMAGE_PATH)
Image.fromarray(res[0].plot()[:, :, ::-1])

輸出結果：
image 1/1 /content/data/intel_rnb.jpg: 480x640 1 person, 529.1ms
Speed: 23.2ms preprocess, 529.1ms inference, 33.4ms postprocess per image at shape (1, 3, 480, 640)

2. 轉換到 OpenVINO IR推論結果

2.1 將模型轉換成 OpenVINO IR 格式

Ultralytics 本來就有支援將模型輸出成 Intel OpenVINO IR(xml + bin) 格式，只要執行下列程式即可。
轉換好的模型會存放在 /yolo11n-pose_openvino_model/ 路徑下。這裡仍保持原有 FP32 資料格式。

註：這裡要保留動態形狀（Dynamic Shape）設定為 True，方便後續工作。

# object detection model
pose_model_path = Path(f"{POSE_MODEL_NAME}_openvino_model/{POSE_MODEL_NAME}.xml")
if not pose_model_path.exists():
    pose_model.export(format="openvino", dynamic=True, half=True)

2.2 選擇推論裝置

在 Google Colab 上只能選 CPU ，在本機端則還可選用Intel GPU（內顯）來提升推論速度。 不過一般為了方便，可直接設為 AUTO 讓系統自行選用即可。

device = device_widget()

device

2.3 測試單張影像

這裡的測試影像沿用步驟1.3，接著測試轉成 Intel OpenVINO IR 格式的模型是否能正確推論。
結果正確，且推論時間可減少一半以上，推論精度仍接近原來水準。

import openvino as ov # 引入 OpenVINO 函式庫

core = ov.Core() # 配置 OpenVINO 核心
pose_ov_model = core.read_model(pose_model_path) # 讀取推論用模型

ov_config = {}

if device.value != "CPU":
    pose_ov_model.reshape({0: [1, 3, 640, 640]})

if "GPU" in device.value or ("AUTO" in device.value and "GPU" in core.available_devices):
    ov_config = {"GPU_DISABLE_WINOGRAD_CONVOLUTION": "YES"}

pose_compiled_model = core.compile_model(pose_ov_model, device.value, ov_config) # 進行模型編譯

pose_model = YOLO(pose_model_path.parent, task="pose")

if pose_model.predictor is None:
    custom = {"conf": 0.25, "batch": 1, "save": False, "mode": "predict"}  # method defaults
    args = {**pose_model.overrides, **custom}
    pose_model.predictor = pose_model._smart_load("predictor")(overrides=args, _callbacks=pose_model.callbacks)
    pose_model.predictor.setup_model(model=pose_model.model)

pose_model.predictor.model.ov_compiled_model = pose_compiled_model # 指定 OpenVINO 編譯好的模型


res = pose_model(IMAGE_PATH) # 進行推論取得結果
Image.fromarray(res[0].plot()[:, :, ::-1]) # 繪製結果

輸出結果：
image 1/1 /content/data/intel_rnb.jpg: 640x640 1 person, 187.4ms
Speed: 3.4ms preprocess, 187.4ms inference, 1.4ms postprocess per image at shape (1, 3, 640, 640)

3. 經過 NNCF 壓縮優化推論結果

NNCF 是 OpenVINO 作為模型優化的重要工具， 它提供了多種模型壓縮及優化方式，這裡僅使用到參數量化(Quantization)，即將 FP32 轉換到 INT8。

3.1 指定是否量化

預設 to_quantize value 為 True，即要啟用量化。

import ipywidgets as widgets

int8_model_pose_path = Path(f"{POSE_MODEL_NAME}_openvino_int8_model/{POSE_MODEL_NAME}.xml")
quantized_pose_model = None

to_quantize = widgets.Checkbox(
    value=True,
    description="Quantization",
    disabled=False,
)

to_quantize

3.2 不啟用量化處理方式

若不啟用量化則需使用 skip_kernel_extension 模組來協助略過部份工作。

# Fetch skip_kernel_extension module
r = requests.get(
    url="https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/skip_kernel_extension.py",
)
open("skip_kernel_extension.py", "w").write(r.text)

%load_ext skip_kernel_extension

3.3 產生 NNCF 所需資料集

下載校正用資料，並設定轉換函式，產生 NNCF 所需資料集。
此步驟需較長時間，請耐心等候。

%%skip not $to_quantize.value

import nncf
from typing import Dict

from zipfile import ZipFile

from ultralytics.data.utils import DATASETS_DIR
from ultralytics.utils import DEFAULT_CFG
from ultralytics.cfg import get_cfg
from ultralytics.data.utils import check_det_dataset
from ultralytics.models.yolo.pose import PoseValidator
from ultralytics.utils.metrics import OKS_SIGMA

if not int8_model_pose_path.exists():

    DATA_URL = "https://ultralytics.com/assets/coco8-pose.zip"
    CFG_URL = "https://raw.githubusercontent.com/ultralytics/ultralytics/v8.1.0/ultralytics/cfg/datasets/coco8-pose.yaml"

    OUT_DIR = DATASETS_DIR

    DATA_PATH = OUT_DIR / "val2017.zip"
    CFG_PATH = OUT_DIR / "coco8-pose.yaml"

    download_file(DATA_URL, DATA_PATH.name, DATA_PATH.parent)
    download_file(CFG_URL, CFG_PATH.name, CFG_PATH.parent)

    if not (OUT_DIR / "coco8-pose/labels").exists():
        with ZipFile(DATA_PATH, "r") as zip_ref:
            zip_ref.extractall(OUT_DIR)

    args = get_cfg(cfg=DEFAULT_CFG)
    args.data = "coco8-pose.yaml"

    pose_validator = PoseValidator(args=args)
    pose_validator.data = check_det_dataset(args.data)
    pose_validator.stride = 32
    pose_data_loader = pose_validator.get_dataloader(OUT_DIR / "coco8-pose", 1)

    pose_validator.is_coco = True
    pose_validator.names = label_map
    pose_validator.metrics.names = pose_validator.names
    pose_validator.nc = 1
    pose_validator.sigma = OKS_SIGMA


    def transform_fn(data_item:Dict):
        """
        Quantization transform function. Extracts and preprocess input data from dataloader item for quantization.
        Parameters:
           data_item: Dict with data item produced by DataLoader during iteration
        Returns:
            input_tensor: Input data for quantization
        """
        input_tensor = pose_validator.preprocess(data_item)['img'].numpy()
        return input_tensor


    quantization_dataset = nncf.Dataset(pose_data_loader, transform_fn)

3.4 使用 NNCF 進行模型量化

開始進行量化，產生新 INT8 模型。
此步驟需較長時間，請耐心等候。

%%skip not $to_quantize.value

if not int8_model_pose_path.exists():

    ignored_scope = nncf.IgnoredScope(  # post-processing
        subgraphs=[
            nncf.Subgraph(inputs=[f"__module.model.{22 if 'v8' in POSE_MODEL_NAME else 23}/aten::cat/Concat",
                                  f"__module.model.{22 if 'v8' in POSE_MODEL_NAME else 23}/aten::cat/Concat_1",
                                  f"__module.model.{22 if 'v8' in POSE_MODEL_NAME else 23}/aten::cat/Concat_2",
                                 f"__module.model.{22 if 'v8' in POSE_MODEL_NAME else 23}/aten::cat/Concat_7"],
                          outputs=[f"__module.model.{22 if 'v8' in POSE_MODEL_NAME else 23}/aten::cat/Concat_9"])
        ]
    )

    # Detection model
    quantized_pose_model = nncf.quantize(
        pose_ov_model,
        quantization_dataset,
        preset=nncf.QuantizationPreset.MIXED,
        ignored_scope=ignored_scope
    )
    print(f"Quantized keypoint detection model will be saved to {int8_model_pose_path}")
    ov.save_model(quantized_pose_model, str(int8_model_pose_path))

3.5 測試單張影像

這裡的測試影像沿用步驟1.3，接著測試經 NNCF 量化後的模型是否能正確推論。
結果正確，推論精度仍接近原來水準。

%%skip not $to_quantize.value

device

%%skip not $to_quantize.value

if quantized_pose_model is None:
    quantized_pose_model = core.read_model()

ov_config = {}
if device.value != "CPU":
    quantized_pose_model.reshape({0: [1, 3, 640, 640]})

if "GPU" in device.value or ("AUTO" in device.value and "GPU" in core.available_devices):
    ov_config = {"GPU_DISABLE_WINOGRAD_CONVOLUTION": "YES"}
    
quantized_pose_compiled_model = core.compile_model(quantized_pose_model, device.value, ov_config)

pose_model = YOLO(pose_model_path.parent, task="pose")

if pose_model.predictor is None:
    custom = {"conf": 0.25, "batch": 1, "save": False, "mode": "predict"}  # method defaults
    args = {**pose_model.overrides, **custom}
    pose_model.predictor = pose_model._smart_load("predictor")(overrides=args, _callbacks=pose_model.callbacks)
    pose_model.predictor.setup_model(model=pose_model.model)

pose_model.predictor.model.ov_compiled_model = pose_compiled_model

res = pose_model(IMAGE_PATH)
display(Image.fromarray(res[0].plot()[:, :, ::-1]))

輸出結果：
image 1/1 /content/data/intel_rnb.jpg: 640x640 1 person, 285.1ms
Speed: 4.3ms preprocess, 285.1ms inference, 2.2ms postprocess per image at shape (1, 3, 640, 640)

4. 使用基準測試工具進行比較

4.1 使用基準測試工具測試

Benchmark Tool 是 OpenVINO 提供的一組工具程式，方便連續測試用，可指定不同推論裝置、連續工作時間（預設60秒，可加 -t 指定秒數），再去計算每秒可執行次數及每次推論所需最小、最大及平均時間，方便進行性能比較。這和單張略微不同，可省去許多共同時間，如模型載入、編譯等。
若在本機端執行時可將裝置設為 GPU 進行比較。

%%skip not $to_quantize.value

device

4.2 使用 FP32 模型推論

if int8_model_pose_path.exists():
    # Inference FP32 model (OpenVINO IR)
    !benchmark_app -m $pose_model_path -d $device.value -api async -shape "[1,3,640,640]" -t 15

部份輸出結果：
…
[ INFO ] First inference took 179.61 ms
[Step 11/11] Dumping statistics report
[ INFO ] Execution Devices:['CPU']
[ INFO ] Count: 106 iterations
[ INFO ] Duration: 15499.93 ms
[ INFO ] Latency:
[ INFO ] Median: 257.80 ms
[ INFO ] Average: 292.03 ms
[ INFO ] Min: 231.82 ms
[ INFO ] Max: 484.45 ms
[ INFO ] Throughput: 6.84 FPS

4.3 使用 INT8 模型推論

if int8_model_pose_path.exists():
    # Inference INT8 model (OpenVINO IR)
    !benchmark_app -m $int8_model_pose_path -d $device.value -api async -shape "[1,3,640,640]" -t 15

部份輸出結果：
…
[ INFO ] First inference took 125.02 ms
[Step 11/11] Dumping statistics report
[ INFO ] Execution Devices:['CPU']
[ INFO ] Count: 150 iterations
[ INFO ] Duration: 15198.45 ms
[ INFO ] Latency:
[ INFO ] Median: 170.15 ms
[ INFO ] Average: 202.29 ms
[ INFO ] Min: 145.57 ms
[ INFO ] Max: 588.30 ms
[ INFO ] Throughput: 9.87 FPS

從上述量化前後二個結果來比較，明顯可看出量化後模型明顯推論速度快上許多，但可能受網路影響所以推論最大時間和最小時間異頗大，若移到本地端相信應該不會漂得這麼多，可以更穩定推論。

5. 連續影片推論展示

5.1 建立推論函式

run_keypoint_detection 這個函式包括模型載入、影像載入、推論及繪製結果。

import collections
import time
from IPython import display
import cv2
import numpy as np


def run_keypoint_detection(
    source=0,
    flip=False,
    use_popup=False,
    skip_first_frames=0,
    model=pose_model,
    device=device.value,
):
    player = None

    ov_config = {}
    if device != "CPU":
        model.reshape({0: [1, 3, 640, 640]})

    if "GPU" in device or ("AUTO" in device and "GPU" in core.available_devices):
        ov_config = {"GPU_DISABLE_WINOGRAD_CONVOLUTION": "YES"}
        
    compiled_model = core.compile_model(model, device, ov_config)

    if pose_model.predictor is None:
        custom = {"conf": 0.25, "batch": 1, "save": False, "mode": "predict"}  # method defaults
        args = {**seg_model.overrides, **custom}
        pose_model.predictor = pose_model._smart_load("predictor")(overrides=args, _callbacks=pose_model.callbacks)
        pose_model.predictor.setup_model(model=pose_model.model)

    pose_model.predictor.model.ov_compiled_model = compiled_model

    try:
        # Create a video player to play with target fps.
        player = VideoPlayer(source=source, flip=flip, fps=30, skip_first_frames=skip_first_frames)
        # Start capturing.
        player.start()
        if use_popup:
            title = "Press ESC to Exit"
            cv2.namedWindow(winname=title, flags=cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_AUTOSIZE)

        processing_times = collections.deque()
        while True:
            # Grab the frame.
            frame = player.next()
            if frame is None:
                print("Source ended")
                break
            # If the frame is larger than full HD, reduce size to improve the performance.
            scale = 1280 / max(frame.shape)
            if scale < 1:
                frame = cv2.resize(
                    src=frame,
                    dsize=None,
                    fx=scale,
                    fy=scale,
                    interpolation=cv2.INTER_AREA,
                )
            # Get the results
            input_image = np.array(frame)

            start_time = time.time()

            detections = pose_model(input_image)
            stop_time = time.time()
            frame = detections[0].plot()

            processing_times.append(stop_time - start_time)
            # Use processing times from last 200 frames.
            if len(processing_times) > 200:
                processing_times.popleft()

            _, f_width = frame.shape[:2]
            # Mean processing time [ms].
            processing_time = np.mean(processing_times) * 1000
            fps = 1000 / processing_time
            cv2.putText(
                img=frame,
                text=f"Inference time: {processing_time:.1f}ms ({fps:.1f} FPS)",
                org=(20, 40),
                fontFace=cv2.FONT_HERSHEY_COMPLEX,
                fontScale=f_width / 1000,
                color=(0, 0, 255),
                thickness=1,
                lineType=cv2.LINE_AA,
            )
            # Use this workaround if there is flickering.
            if use_popup:
                cv2.imshow(winname=title, mat=frame)
                key = cv2.waitKey(1)
                # escape = 27
                if key == 27:
                    break
            else:
                # Encode numpy array to jpg.
                _, encoded_img = cv2.imencode(ext=".jpg", img=frame, params=[cv2.IMWRITE_JPEG_QUALITY, 100])
                # Create an IPython image.
                i = display.Image(data=encoded_img)
                # Display the image in this notebook.
                display.clear_output(wait=True)
                display.display(i)
    # ctrl-c
    except KeyboardInterrupt:
        print("Interrupted")
    # any different error
    except RuntimeError as e:
        print(e)
    finally:
        if player is not None:
            # Stop capturing.
            player.stop()
        if use_popup:
            cv2.destroyAllWindows()

5.2 取得影片進行姿態估測

呼叫 run_keypoint_detection 進行推論，可依需要改變影片來源、推論裝置及模型。

• 若在本地端運行時，將 Source 改成 0 ，就可直接支援本機（桌機或筆電)上的第1部網路攝影機。若有多部則修改為 1 到 N 。
• 若在 Colab 上遇到畫面閃爍問題時，可將 use_popup 設為 True 來改善。
• 若想多次測試不同影片、裝置（CPU / GPU / AUTO）或模型(pose_ov_model / quantized_pose_model)，可直接修改參數，單獨運行本格程式即可，不用全部程式重新運行。

VIDEO_SOURCE = "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/video/people.mp4"

device

run_keypoint_detection(
    source=VIDEO_SOURCE,
    flip=True,
    use_popup=False,
    model=pose_ov_model, # pose_ov_model, quantized_pose_model
    device=device.value,
)

輸出結果：

小結

相信大家看到這麼長的程式可能會想打退堂鼓，但仔細看完本文介紹後，會發覺其實只有選擇模型（原始或量化）、決定推論裝置、給定待測影像或影片就結束了，程式幾乎都不太需要改就能用，算是很容易上手。原始 YOLOv11 姿態估測模型經 OpenVINO 或 NNCF處理過後其推論速度都比原始模型快上許多，有助於邊緣裝置應用。從輸出結果（物件外框、骨架關節等）來看，並沒有因為模型變小就變得不可靠，即使人物很小也能正確判定，所以還是很值得拿來應用。另外使用 OpenVINO 還有一個好處，就是未來硬體升級也不用大改程式，只需要重新指定推論裝置即可，意思就是未來有更好的 CPU 、 GPU 或 NPU 時，程式效能自然提升，也不用擔心程式要重新開發，有興趣的朋友還不趕快動手來試試。

參考文獻

[1] Ultralytics, YOLOv11
https://docs.ultralytics.com/models/yolo11/

[2] Github Ultralytics / Ultralytics (YOLOv11)
https://github.com/ultralytics/ultralytics

[3] Ultralytics, YOLO Vision 2024
https://www.ultralytics.com/zh/events/yolovision

[4] Intel, OpenVINO™ Notebooks at GitHub Pages
https://openvinotoolkit.github.io/openvino_notebooks/

[5] Intel, OpenVINO Document - Learn OpenVINO - Interactive Tutorials(Python) - Convert and Optimize YOLOv11 keypoint detection model with OpenVINO
https://docs.openvino.ai/2024/notebooks/yolov11-keypoint-detection-with-output.html

[6] Intel, Github OpenVINO Notebooks - yolov11-keypoint-detection
https://colab.research.google.com/github/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/yolov11-optimization/yolov11-keypoint-detection.ipynb

延伸閱讀

[A] Intel OpenVINO Document - Convert and Optimize YOLOv11 real-time object detection with OpenVINO™
https://docs.openvino.ai/2024/notebooks/yolov11-object-detection-with-output.html

[B] Intel OpenVINO Document - Convert and Optimize YOLOv11 instance segmentation model with OpenVINO™
https://docs.openvino.ai/2024/notebooks/yolov11-instance-segmentation-with-output.html

本文同步發表在【台灣自造者 vMaker】