歐尼克斯實境互動工作室(OmniXRI): 【vMaker Edge AI專欄 #22】使用Intel OpenVINO搭配YOLOv11輕鬆駕馭姿態偵測

作者：Jack OmniXRI, 2024/10/15

vMaker_EdgeAI_22_00

相信有在玩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 環境執行。

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

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

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

這裡為方便大家學習，這裡已把完整源碼[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)
yolov11_1

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)
yolov11_2

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)
yolov11_3

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_4

小結

相信大家看到這麼長的程式可能會想打退堂鼓，但仔細看完本文介紹後，會發覺其實只有選擇模型（原始或量化）、決定推論裝置、給定待測影像或影片就結束了，程式幾乎都不太需要改就能用，算是很容易上手。原始 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】

歐尼克斯實境互動工作室(OmniXRI)

網頁

2024年10月28日星期一

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

1. 原始 YOLOv11 推論結果

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

1.2 下載必要函式庫並引入

1.3 下載測試用影像

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

1.5 實例化 YOLO 並測試推論

2. 轉換到 OpenVINO IR推論結果

2.1 將模型轉換成 OpenVINO IR 格式

2.2 選擇推論裝置

2.3 測試單張影像

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

3.1 指定是否量化

3.2 不啟用量化處理方式

3.3 產生 NNCF 所需資料集

3.4 使用 NNCF 進行模型量化

3.5 測試單張影像

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

4.1 使用基準測試工具測試

4.2 使用 FP32 模型推論

4.3 使用 INT8 模型推論

5. 連續影片推論展示

5.1 建立推論函式

5.2 取得影片進行姿態估測

小結

參考文獻

延伸閱讀

沒有留言:

張貼留言

網頁

2024年10月28日 星期一

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

1. 原始 YOLOv11 推論結果

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

1.2 下載必要函式庫並引入

1.3 下載測試用影像

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

1.5 實例化 YOLO 並測試推論

2. 轉換到 OpenVINO IR推論結果

2.1 將模型轉換成 OpenVINO IR 格式

2.2 選擇推論裝置

2.3 測試單張影像

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

3.1 指定是否量化

3.2 不啟用量化處理方式

3.3 產生 NNCF 所需資料集

3.4 使用 NNCF 進行模型量化

3.5 測試單張影像

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

4.1 使用基準測試工具測試

4.2 使用 FP32 模型推論

4.3 使用 INT8 模型推論

5. 連續影片推論展示

5.1 建立推論函式

5.2 取得影片進行姿態估測

小結

參考文獻

延伸閱讀

沒有留言:

張貼留言

2024年10月28日星期一