前処理の最適化#

# openvino_notebooks ストレージからイメージをダウンロード 
image_path = download_file( 
    "https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/image/coco.jpg", 
    directory="data", 
) 
image_path = str(image_path)

import ipywidgets as widgets 

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

device

model_name = "InceptionResNetV2" 

model_dir = Path("model") 
model_dir.mkdir(exist_ok=True) 

model_path = model_dir / model_name 

model = tf.keras.applications.InceptionV3() 
model.save(model_path)

core = ov.Core()

image = cv2.imread(image_path) 
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) 
print(f"The original shape of the image is {image.shape}") 
print(f"The original data type of the image is {image.dtype}")

ir_path = model_dir / "ir_model" / f"{model_name}.xml" 

ppp_model = None 

if ir_path.exists(): 
    ppp_model = core.read_model(model=ir_path) 
    print(f"Model in OpenVINO format already exists: {ir_path}") 
else: 
    ppp_model = ov.convert_model(model_path, input=[1, 299, 299, 3]) 
    ov.save_model(ppp_model, str(ir_path))

from openvino.preprocess import PrePostProcessor 

ppp = PrePostProcessor(ppp_model)

# データの形式を設定 
ppp.input().tensor().set_element_type(ov.Type.u8).set_spatial_dynamic_shape().set_layout(ov.Layout("NHWC"))

input_layer_ir = next(iter(ppp_model.inputs)) 
print(f"The input shape of the model is {input_layer_ir.shape}") 

ppp.input().model().set_layout(ov.Layout("NHWC"))

from openvino.preprocess import ResizeAlgorithm 

ppp.input().preprocess().convert_element_type(ov.Type.f32).resize(ResizeAlgorithm.RESIZE_LINEAR).mean([127.5, 127.5, 127.5]).scale([127.5, 127.5, 127.5])

print(f"Dump preprocessor: {ppp}") 
model_with_preprocess = ppp.build()

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

def manual_image_preprocessing(path_to_image, compiled_model): 
    input_layer_ir = next(iter(compiled_model.inputs)) 

    # N, H, W, C = バッチサイズ、高さ、幅、チャネル数 
    N, H, W, C = input_layer_ir.shape 

    # 画像を読み込むと、画像はモデル入力サイズに合わせてサイズ変更され RGB に変換 
    img = tf.keras.preprocessing.image.load_img(image_path, target_size=(H, W), color_mode="rgb") 

    x = tf.keras.preprocessing.image.img_to_array(img) 
    x = np.expand_dims(x, axis=0) 

    # 入力ピクセルを -1 から 1 の間でスケール 
    input_tensor = tf.keras.applications.inception_resnet_v2.preprocess_input(x) 
    return input_tensor 

input_tensor = manual_image_preprocessing(image_path, compiled_model) 
print(f"The shape of the image is {input_tensor.shape}") 
print(f"The data type of the image is {input_tensor.dtype}")

output_layer = compiled_model.output(0) 

result = compiled_model(input_tensor)[output_layer]

def check_results(input_tensor, compiled_model, imagenet_classes): 
    output_layer = compiled_model.output(0) 

    results = compiled_model(input_tensor)[output_layer][0] 

    top_indices = np.argsort(results)[-5:][::-1] 
    top_softmax = results[top_indices] 

    for index, softmax_probability in zip(top_indices, top_softmax): 
        print(f"{imagenet_classes[index]}, {softmax_probability:.5f}") 

    return top_indices, top_softmax 

# 推論結果をクラス名に変換 
imagenet_filename = download_file( 

"https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/datasets/imagenet/imagenet_2012.txt", 
    directory="data", 
) 
imagenet_classes = imagenet_filename.read_text().splitlines() 
imagenet_classes = ["background"] + imagenet_classes 

# 前処理 API を使用して推論の結果を取得 
print("Result of inference with Preprocessing API:") 
res = check_results(ppp_input_tensor, compiled_model_with_preprocess_api, imagenet_classes) 

print("\n") 

# 手動で画像を準備して推論の結果を得る 
print("Result of inference with manual image setup:") 
res = check_results(input_tensor, compiled_model, imagenet_classes)

def check_performance(compiled_model, preprocessing_function=None): 
    num_images = 1000 

    start = time.perf_counter() 

    for _ in range(num_images): 
        input_tensor = preprocessing_function(image_path, compiled_model) 
        compiled_model(input_tensor) 

    end = time.perf_counter() 
    time_ir = end - start 

    return time_ir, num_images 

time_ir, num_images = check_performance(compiled_model, manual_image_preprocessing) 
print(f"IR model in OpenVINO Runtime/CPU with manual image preprocessing: {time_ir/num_images:.4f} " f"seconds per image, FPS: {num_images/time_ir:.2f}") 

time_ir, num_images = check_performance(compiled_model_with_preprocess_api, prepare_image_api_preprocess) 
print(f"IR model in OpenVINO Runtime/CPU with preprocessing API: {time_ir/num_images:.4f} " f"seconds per image, FPS: {num_images/time_ir:.2f}")