OpenVINO™ による生物の検出#

%pip install -q "openvino-dev>=2024.0.0" 
%pip install -q tensorflow 
%pip install -q opencv-python requests tqdm 

# `notebook_utils` モジュールを取得 
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)

import collections 
import tarfile 
import time 
from pathlib import Path

import cv2 
import numpy as np 
from IPython import display 
import openvino as ov 
from openvino.tools.mo.front import tf as ov_tf_front 
from openvino.tools import mo 

import notebook_utils as utils

# モデルがダウンロードされるディレクトリー 
base_model_dir = Path("model") 

# Open Model Zoo のモデルの名前 
model_name = "ssdlite_mobilenet_v2" 

archive_name = Path(f"{model_name}_coco_2018_05_09.tar.gz") 
model_url = 
f"https://storage.openvinotoolkit.org/repositories/open_model_zoo/public/2022.1/{model_name}/{archive_name}" 

# アーカイブをダウンロード 
downloaded_model_path = base_model_dir / archive_name 
    if not downloaded_model_path.exists(): 
        utils.download_file(model_url, downloaded_model_path.name, downloaded_model_path.parent) 

# モデルをアンパック 
tf_model_path = base_model_dir / archive_name.with_suffix("").stem / "frozen_inference_graph.pb" 
if not tf_model_path.exists(): 
    with tarfile.open(downloaded_model_path) as file: 
        file.extractall(base_model_dir)

precision = "FP16" 
# 変換の出力パス 
converted_model_path = Path("model") / f"{model_name}_{precision.lower()}.xml" 

# 以前に変換されていない場合は IR に変換 
trans_config_path = Path(ov_tf_front.__file__).parent / "ssd_v2_support.json" 
if not converted_model_path.exists(): 
    ov_model = mo.convert_model( 
        tf_model_path, 
        compress_to_fp16=(precision == "FP16"), 
        transformations_config=trans_config_path, 
        tensorflow_object_detection_api_pipeline_config=tf_model_path.parent / "pipeline.config", 
        reverse_input_channels=True, 
    ) 
    ov.save_model(ov_model, converted_model_path) 
    del ov_model

import ipywidgets as widgets 

core = ov.Core() 
device = widgets.Dropdown( 
    options=core.available_devices + ["AUTO"], 
    value="AUTO", 
    description="Device:", 
    disabled=False, 
) 

device

# ファイルからネットワークと対応する重みを読み取ります。 
model = core.read_model(model=converted_model_path) 
# CPU 用にモデルをコンパイルします (CPU、GPU などを手動で選択できます) 
# または、エンジンに利用可能な最適なデバイスを選択させます (AUTO)。 
compiled_model = core.compile_model(model=model, device_name=device.value) 

# 入力ノードと出力ノードを取得 
input_layer = compiled_model.input(0) 
output_layer = compiled_model.output(0) 

# 入力サイズを取得 
height, width = list(input_layer.shape)[1:3]

input_layer.any_name, output_layer.any_name

# https://tech.amikelive.com/node-718/what-object-categories-labels-are-in-coco-dataset/ 
classes = [ 
    "background", 
    "person", 
    "bicycle", 
    "car", 
    "motorcycle", 
    "airplane",
    "bus", 
    "train", 
    "truck", 
    "boat", 
    "traffic light", 
    "fire hydrant", 
    "street sign", 
    "stop sign", 
    "parking meter", 
    "bench", 
    "bird", 
    "cat", 
    "dog", 
    "horse", 
    "sheep", 
    "cow", 
    "elephant", 
    "bear", 
    "zebra", 
    "giraffe", 
    "hat", 
    "backpack", 
    "umbrella", 
    "shoe", 
    "eye glasses", 
    "handbag", 
    "tie", 
    "suitcase", 
    "frisbee", 
    "skis", 
    "snowboard",
    "sports ball", 
    "kite", 
    "baseball bat", 
    "baseball glove", 
    "skateboard", 
    "surfboard", 
    "tennis racket", 
    "bottle",
    "plate", 
    "wine glass", 
    "cup", 
    "fork", 
    "knife", 
    "spoon", 
    "bowl", 
    "banana", 
    "apple", 
    "sandwich", 
    "orange", 
    "broccoli", 
    "carrot", 
    "hot dog", 
    "pizza", 
    "donut", 
    "cake", 
    "chair", 
    "couch", 
    "potted plant", 
    "bed", 
    "mirror", 
    "dining table", 
    "window", 
    "desk", 
    "toilet", 
    "door", 
    "tv", 
    "laptop", 
    "mouse", 
    "remote", 
    "keyboard", 
    "cell phone", 
    "microwave", 
    "oven", 
    "toaster", 
    "sink", 
    "refrigerator", 
    "blender", 
    "book", 
    "clock", 
    "vase", 
    "scissors", 
    "teddy bear", 
    "hair drier", 
    "toothbrush", 
    "hair brush", 
] 

# 上記のクラスの色 (レインボー・カラー・マップ)。 
colors = cv2.applyColorMap( 
    src=np.arange(0, 255, 255 / len(classes), dtype=np.float32).astype(np.uint8), 
    colormap=cv2.COLORMAP_RAINBOW, 
).squeeze() 

def process_results(frame, results, thresh=0.6):
    # 元のフレームのサイズ 
    h, w = frame.shape[:2] 
    # 'results' 変数は[1, 1, 100, 7] テンソルです。 
    results = results.squeeze() 
    boxes = [] 
    labels = [] 
    scores = [] 
    for _, label, score, xmin, ymin, xmax, ymax in results:
        # 正規化された座標 [0,1] のボックスからピクセル座標のボックスを作成 
        boxes.append(tuple(map(int, (xmin * w, ymin * h, (xmax - xmin) * w, (ymax - ymin) * h)))) 
        labels.append(int(label)) 
        scores.append(float(score)) 

    # 重複する多数のエンティティーを除去するため非最大抑制を適用
    # https://paperswithcode.com/method/non-maximum-suppression を参照 
    # このアルゴリズムは、保持するオブジェクトのインデックスを返します 
    indices = cv2.dnn.NMSBoxes(bboxes=boxes, scores=scores, score_threshold=thresh, nms_threshold=0.6) 

    # ボックスがない場合 
    if len(indices) == 0: 
        return [] 

    # 検出されたオブジェクトをフィルタリング 
    return [(labels[idx], scores[idx], boxes[idx]) for idx in indices.flatten()] 

def draw_boxes(frame, boxes): 
    for label, score, box in boxes:
        # ラベルの色を選択 
        color = tuple(map(int, colors[label])) 
        # ボックスを描画 
        x2 = box[0] + box[2] 
        y2 = box[1] + box[3] 
        cv2.rectangle(img=frame, pt1=box[:2], pt2=(x2, y2), color=color, thickness=3) 

        # ボックス内にラベル名を描画  
        cv2.putText( 
            img=frame, 
            text=f"{classes[label]} {score:.2f}", 
            org=(box[0] + 10, box[1] + 30), 
            fontFace=cv2.FONT_HERSHEY_COMPLEX, 
            fontScale=frame.shape[1] / 1000, 
            color=color, 
            thickness=1, 
            lineType=cv2.LINE_AA,             
    ) 

return frame

# 物体検出を実行するメイン処理関数 
def run_object_detection(source=0, flip=False, use_popup=False, skip_first_frames=0): 
    player = None 
    try:
        # ターゲット fps で再生するビデオプレーヤーを作成 
        player = utils.VideoPlayer(source=source, flip=flip, fps=30, skip_first_frames=skip_first_frames) 
        # キャプチャー開始 
        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:
            # フレームをグラブ 
            frame = player.next() 
            if frame is None: 
                print("Source ended") 
                break 
            # フレームがフル HD より大きい場合は、サイズを縮小してパフォーマンスを向上させます 
            scale = 1280 / max(frame.shape) 
            if scale < 1: 
                frame = cv2.resize( 
                    src=frame, 
                    dsize=None, 
                    fx=scale, 
                    fy=scale, 
                    interpolation=cv2.INTER_AREA, 
                ) 

            # ニューラル・ネットワークの入力に合わせて画像のサイズを変更し暗さを変更 
            input_img = cv2.resize(src=frame, dsize=(width, height), interpolation=cv2.INTER_AREA) 
            # 画像のバッチを作成 (size = 1) 
            input_img = input_img[np.newaxis, ...]
            # 処理時間を測定 

            start_time = time.time() 
            # 結果を取得. 
            results = compiled_model([input_img])[output_layer] 
            stop_time = time.time() 
            # ネットワークの結果からポーズを取得 
            boxes = process_results(frame=frame, results=results) 

            # フレーム上にボックスを描画 
            frame = draw_boxes(frame=frame, boxes=boxes) 

            processing_times.append(stop_time - start_time) 
            # 最後の 200 フレームの処理時間を使用 
            if len(processing_times) > 200: 
                processing_times.popleft() 

            _, f_width = frame.shape[:2] 
            # 平均処理時間 [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, 
            )
 
            # ちらつきがある場合はこの回避策を使用 
            if use_popup: 
                cv2.imshow(winname=title, mat=frame) 
                key = cv2.waitKey(1) 
                # escape = 27 
                if key == 27: 
                    break 
                else: 
                    # numpy 配列を jpg にエンコード
                    _, encoded_img = cv2.imencode(ext=".jpg", img=frame, params=[cv2.IMWRITE_JPEG_QUALITY, 100]) 
                    # IPython イメージを作成 
                    i = display.Image(data=encoded_img) 
                    # このノートブックに画像を表示 
                    display.clear_output(wait=True) 
                    display.display(i) 

# ctrl-c 
except KeyboardInterrupt: 
    print("Interrupted") 
# 異なるエラー 
except RuntimeError as e: 
    print(e) 
finally: 
    if player is not None:
        # キャプチャーを停止 
        Player.stop().stop() 
    if use_popup: 
        cv2.destroyAllWindows()

USE_WEBCAM = False 

video_file = 
"https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/video/Coco%20Walking%20in%20Berkeley.mp4" 
cam_id = 0 

source = cam_id if USE_WEBCAM else video_file 

run_object_detection(source=source, flip=isinstance(source, int), use_popup=False)