サンプルコード ( ユーティリティ関数 )

ユーティリティ関数のサンプルコードです

• CPU 推論でデバイスを切り替える関数のサンプルコード: L.5- smp_save_optimized_model()
• モデル読み込み時間短縮のために動作環境に最適化されたモデルを保存する関数のサンプルコード: L.155- smp_change_cpu_device

#pragma once
#include "samples.h"
#include "oal_aloc.h"
 
int smp_change_cpu_device(const char* model_name, const char* img_name)
{
    INT ret = F_ERR_NONE;
    FHANDLE hsrc = NULL;
    H_MODEL hmodel = NULL;
    MODEL_CATEGORY model_category;
 
    // 対象デバイスの配列
    INT n_target_device = 2;
    OV_DEVICE* target_devices = (OV_DEVICE*)fnOAL_calloc(sizeof(OV_DEVICE), n_target_device);
    target_devices[0] = OV_DEVICE_CPU;
    target_devices[1] = OV_DEVICE_GPU;
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
    // 画像読込
    ret = fnFIE_load_img_file(img_name, &hsrc, F_COLOR_IMG_TYPE_UC8);
    printf_s("img: %d\r\n", ret);
    if (F_ERR_NONE != ret) { goto finally; }
 
    // ライセンスチェック
    ret = fnPDL_check_license();
    printf_s("lic : %d\r\n", ret);
 
    // ハンドルの生成
    hmodel = fnPDL_create_handle();
    if (NULL == hmodel) { printf_s("failed to create handle\r\n"); }
    else { printf_s("handle created\r\n"); }
 
    // CPU 推論
    for(auto i_device=0; i_device<n_target_device; i_device++)
    {
        OV_DEVICE device = target_devices[i_device];
        std::chrono::system_clock::time_point start, end;
        double elapsed;
 
        // デバイスの選択
        printf_s("set device=%d", device);
        ret = fnPDL_set_cpu_device(hmodel, device);
        if (F_ERR_NONE != ret) { printf_s("device set error=%d\r\n", ret); goto finally; }
 
        // モデル読込
        ret = fnPDL_load_model(model_name, hmodel);
        if (F_ERR_NONE != ret) { printf_s("load error=%d\r\n", ret); goto finally; }
 
        // モデルの種別の確認
        ret = fnPDL_get_model_category(hmodel, &model_category);
        printf_s("par : %d  category=%d\r\n", ret, model_category);
 
        // モデルの種別に応じて推論関数、出力データを分岐
        switch (model_category)
        {
        case UNKNOWN:
            break;
        case CLASSIFICATION:
        case ANOMALY_DETECTION:
        {
            FLOAT* scores = NULL;
            size_t n_scores;
 
            // 開始時刻
            start = std::chrono::system_clock::now();
 
            // 推論実行
            ret = fnPDL_predict(hmodel, hsrc, &scores, &n_scores);
 
            // 完了時刻
            end = std::chrono::system_clock::now();
 
            if (NULL != scores) { fnOAL_free(scores); }
            break;
        }
        case MULTI_VIEW_CNN:
        case MULTI_VIEW_AD:
        {
            INT n_views = 0;
            FHANDLE *hsrcs = NULL;
            FLOAT* scores = NULL;
            size_t n_scores;
 
            // 視点数を取得して入力画像配列を作成
            ret = fnPDL_get_how_many_views(hmodel, &n_views);
            if (F_ERR_NONE != ret) { printf_s("get how many view error=%d\r\n", ret); goto finally; }
            hsrcs = (FHANDLE*)fnOAL_calloc(sizeof(FHANDLE), n_views);
            for (auto i_view = 0; i_view < n_views; i_view++) { hsrcs[i_view] = hsrc; }
 
            // 開始時刻
            start = std::chrono::system_clock::now();
 
            // 推論実行
            ret = fnPDL_predict_multi_images(hmodel, n_views, hsrcs, &scores, &n_scores);
 
            // 完了時刻
            end = std::chrono::system_clock::now();
 
            if (NULL != hsrcs) { fnOAL_free(hsrcs); }
            if (NULL != scores) { fnOAL_free(scores); }
            break;
        }
        case SEMANTIC_SEGMENTATION:
        {
            FHANDLE hdst = fnFIE_img_root_alloc(F_IMG_US16, 1, fnFIE_img_get_width(hsrc), fnFIE_img_get_height(hsrc));
 
            // 開始時刻
            start = std::chrono::system_clock::now();
 
            // 推論実行
            ret = fnPDL_predict_segmentation(hmodel, hsrc, hdst);
 
            // 完了時刻
            end = std::chrono::system_clock::now();
 
            if (NULL != hdst) { fnFIE_free_object(hdst); }
            break;
        }
        case OBJECT_DETECTION:
        {
            F_OD_RESULT* detections = NULL;
            size_t n_detections;
 
            // 開始時刻
            start = std::chrono::system_clock::now();
 
            // 推論実行
            ret = fnPDL_predict_object_detection(hmodel, hsrc, &detections, &n_detections);
 
            // 完了時刻
            end = std::chrono::system_clock::now();
 
            if (NULL != detections) { fnOAL_free(detections); }
            break;
        }
        default:
            break;
        }
 
        // 推論時間をコンソールに出力
        elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / (double)1000;
        printf_s("%.3e [msec]\r\n", elapsed);
    }
 
finally: // 終了処理
    fnPDL_dispose(hmodel);
    if (NULL != hsrc) { fnFIE_free_object(hsrc); }
    fnFIE_teardown();
 
    return ret;
}
 
int smp_save_optimized_model(const char* original_model_name, const char* save_model_name)
{
    INT ret = F_ERR_NONE;
    H_MODEL hmodel = NULL;
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
    // WIL-PDL のライセンスチェック
    ret = fnPDL_check_license();
    printf_s("lic : %d\r\n", ret);
 
    //------- ここから -------//
 
    // ハンドルの生成
    hmodel = fnPDL_create_handle();
    if (NULL == hmodel) { printf_s("failed to create handle\r\n"); goto finally; }
    else { printf_s("handle created\r\n"); }
 
    // FV-AID で変換した元となるモデルの読み込み: この処理には時間が掛かります
    {
        std::chrono::system_clock::time_point start, end;
        double elapsed;
 
        // 開始時刻
        start = std::chrono::system_clock::now();
 
        // モデル読み込み
        ret = fnPDL_load_model(original_model_name, hmodel);
 
        // 完了時刻
        end = std::chrono::system_clock::now();
 
        // 読み込みに掛かった時間 [msec]
        elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / (double)1000;
 
        // コンソールに出力
        printf_s("load time ( original ) = %.3e msec ( return code = %d )\r\n", elapsed, ret);
        if (F_ERR_NONE != ret) { goto finally; }
    }
 
    // モデルを読み込んだ環境に最適化されたモデルの保存: CPU 推論のときには何も行いません
    ret = fnPDL_save_optimized_model(save_model_name, hmodel);
    if (F_ERR_NONE != ret) { printf_s("error = %d\r\n", ret);  goto finally; }
 
    // 最適化されたモデルの読み込み: 元となるモデルと比較して読み込み時間が短縮されます
    {
        std::chrono::system_clock::time_point start, end;
        double elapsed;
 
        // 開始時刻
        start = std::chrono::system_clock::now();
 
        // モデル読み込み
        ret = fnPDL_load_model(save_model_name, hmodel);
 
        // 完了時刻
        end = std::chrono::system_clock::now();
 
        // 読み込みに掛かった時間 [msec]
        elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / (double)1000;
 
        // コンソールに出力
        printf_s("load time ( original ) = %.3e msec ( return code = %d )\r\n", elapsed, ret);
        if (F_ERR_NONE != ret) { goto finally; }
    }
 
    finally:
    if (NULL != hmodel) { fnPDL_dispose(hmodel); }
 
    return ret;
}