OpenVINO™ によるスタイル転送#

%pip install -q "openvino>=2023.1.0" 
%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 time 

import cv2 
import numpy as np 
from pathlib import Path 
import ipywidgets as widgets 
from IPython.display import display, clear_output, Image 
import openvino as ov 

import notebook_utils as utils

# ドロップダウンを使用してさまざまなスタイルを選択するオプション 
style_dropdown = widgets.Dropdown( 
    options=["MOSAIC", "RAIN-PRINCESS", "CANDY", "UDNIE", "POINTILISM"], 
    value="MOSAIC", # デフォルト値を設定 
    description="Select Style:", 
    disabled=False, 
    style={"description_width": "initial"}, # 必要に応じて幅を調整 )

 # ドロップダウンの変更を処理し、選択したスタイルをプリントする関数 
def print_style(change): 
    if change["type"] == "change" and change["name"] == "value": 
        print(f"Selected style {change['new']}") 

# ドロップダウンの値の変化を観察 
style_dropdown.observe(print_style, names="value") 

# ドロップダウンをプリント 
display(style_dropdown)

# ONNX モデル動物園からモデルをダウンロードするディレクトリー 
base_model_dir = "model" 
base_url = 
"https://github.com/onnx/models/raw/69d69010b7ed6ba9438c392943d2715026792d40/archive/vision/style_transfer/fast_neural_style/model" 

# 選択した ONNX モデルはパスにダウンロードされます 
model_path = Path(f"{style_dropdown.value.lower()}-9.onnx") 

style_url = f"{base_url}/{model_path}" 
utils.download_file(style_url, directory=base_model_dir)

# モデル・トランスフォーメーション API のコマンドを構築します 

ov_model = ov.convert_model(f"model/{style_dropdown.value.lower()}-9.onnx") 
ov.save_model(ov_model, f"model/{style_dropdown.value.lower()}-9.xml")

# 変換された IR モデルパス 
ir_path = Path(f"model/{style_dropdown.value.lower()}-9.xml") 
onnx_path = Path(f"model/{model_path}")

# OpenVINO ランタイムを初期化 
core = ov.Core() 

# ONNX モデルからネットワークと対応する重みを読み取り
# model = ie_core.read_model(model=onnx_path) 

# IR モデルからネットワークと対応する重みを読み取り 
model = core.read_model(model=ir_path)

import ipywidgets as widgets 

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

# CPU 用にモデルをコンパイルするか (または他のデバイスの場合は GPU などに変更)、 
# OpenVINO に AUTO で利用可能な最適なデバイスを選択させる 
device

compiled_model = core.compile_model(model=model, device_name=device.value) 

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

print(input_layer.any_name, output_layer.any_name) 
print(input_layer.shape) 
print(output_layer.shape) 

# 入力サイズを取得 
N, C, H, W = list(input_layer.shape)

# 入力画像を前処理 
def preprocess_images(frame, H, W): 
    """ 
    Preprocess input image to align with network size 

    Parameters:
        :param frame: input frame 
        :param H: height of the frame to style transfer model 
        :param W: width of the frame to style transfer model 
        :returns: resized and transposed frame 
    """ 
    image = np.array(frame).astype("float32") 
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) 
    image = cv2.resize(src=image, dsize=(H, W), interpolation=cv2.INTER_AREA) 
    image = np.transpose(image, [2, 0, 1]) 
    image = np.expand_dims(image, axis=0) 
    return image

# 結果を後処理 
def convert_result_to_image(frame, stylized_image) -> np.ndarray: 
    """ 
    Postprocess stylized image for visualization 

    Parameters:
        :param frame: input frame 
        :param stylized_image: stylized image with specific style applied 
        :returns: resized stylized image for visualization 
    """ 
    h, w = frame.shape[:2] 
    stylized_image = stylized_image.squeeze().transpose(1, 2, 0) 
    stylized_image = cv2.resize(src=stylized_image, dsize=(w, h), interpolation=cv2.INTER_CUBIC) 
    stylized_image = np.clip(stylized_image, 0, 255).astype(np.uint8) 
    stylized_image = cv2.cvtColor(stylized_image, cv2.COLOR_BGR2RGB) 
    return stylized_image

def run_style_transfer(source=0, flip=False, use_popup=False, skip_first_frames=0): 
    """ 
    Main function to run the style inference: 
    1. Create a video player to play with target fps (utils.VideoPlayer). 
    2. Prepare a set of frames for style transfer. 
    3. Run AI inference for style transfer. 
    4. 結果を視覚化します。
    Parameters: 
        source: The webcam number to feed the video stream with primary webcam set to "0", or the video path. 
        flip: To be used by VideoPlayer function for flipping capture image. 
        use_popup: False for showing encoded frames over this notebook, True for creating a popup window. 
        skip_first_frames: Number of frames to skip at the beginning of the video.
    """ 
    # ターゲット fps で再生するビデオプレーヤーを作成 
    player = None 
    try: 
        player = utils.VideoPlayer(source=source, flip=flip, fps=30, skip_first_frames=skip_first_frames) 
        # ビデオ・キャプチャーを開始 
        Player.start().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 = 720 / max(frame.shape) 
            if scale < 1: 
                frame = cv2.resize( 
                        src=frame, 
                        dsize=None, 
                        fx=scale, 
                        fy=scale, 
                        interpolation=cv2.INTER_AREA, 
                ) 
            # 入力画像を前処理 

            image = preprocess_images(frame, H, W) 

            # 入力画像の処理時間を測定 
            start_time = time.time() 
            # 推論ステップを実行 
            stylized_image = compiled_model([image])[output_layer] 
            stop_time = time.time() 

            # 様式化された画像の後処理 
            result_image = convert_result_to_image(frame, stylized_image) 

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

            # 結果を視覚化 
            f_height, f_width = frame.shape[:2] 
            fps = 1000 / processing_time_det 
            cv2.putText( 
                result_image, 
                text=f"Inference time: {processing_time_det:.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(title, result_image) 
                key = cv2.waitKey(1) 
                # escape = 27 
                if key == 27: 
                        break 
            else: 
                # numpy 配列を jpg にエンコード
                _, encoded_img = cv2.imencode(".jpg", result_image, params=[cv2.IMWRITE_JPEG_QUALITY, 90]) 
                # IPython イメージを作成 
                i = Image(data=encoded_img) 
                # このノートブックに画像を表示 
                clear_output(wait=True) 
                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 

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

source = cam_id if USE_WEBCAM else video_file 

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