サンプルコード ( 多視点アノマリー検出 )

多視点アノマリー検出のサンプルコードです

• 最も単純なサンプルコード: L.6- smp_mvad_simple()
• ベンチマークを計測するサンプルコード: L.126: smp_mvad_benchmark()
• FIE の関数を前処理として行うサンプルコード: L.246: smp_mvad_with_fie()

#pragma once
#include "samples.h"
#include "oal_aloc.h"
#include <string>
 
int smp_mvad_simple(const char* model_name, const char* img_folder, const FLOAT threshold)
{
    INT ret = F_ERR_NONE;
    H_MODEL hmodel = NULL;
    MODEL_CATEGORY model_category;
    MODEL_BACKEND model_backend;
    INT n_views = 0;
    FHANDLE* hsrcs = NULL;
    INT ch, w, h;
    FLOAT* anomaly_data = NULL;
    size_t anomaly_data_len;
 
    BOOL is_anomaly = false;
    FHANDLE hmap = NULL;
    FLOAT max_anomaly = .0;
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
 
    //------- ここから -------//
 
    // ライセンスチェック
    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"); }
 
    // モデル読込
    ret = fnPDL_load_model(model_name, hmodel);
    printf_s("load: %d\r\n", ret);
 
    // モデルの種別の確認
    ret = fnPDL_get_model_category(hmodel, &model_category);
    printf_s("par : %d  category=%d\r\n", ret, model_category);
    if (MULTI_VIEW_AD != model_category) { printf_s("unmatch model"); }
 
    // モデルの推論バックエンドの確認
    ret = fnPDL_get_model_backend(hmodel, &model_backend);
    printf_s("ret : %d  backend=%d\r\n", ret, model_backend);
 
    // モデルの期待する画像パラメータの確認
    ret = fnPDL_get_input_image_size(hmodel, &ch, &w, &h);
    printf_s("par : %d  ch=%d  w=%d  h=%d\r\n", ret, ch, w, h);
 
    // モデルの視点数の取得
    ret = fnPDL_get_how_many_views(hmodel, &n_views);
    printf_s("# of views=%d", n_views);
 
    // 入力画像配列のメモリ確保と画像読込
    hsrcs = (FHANDLE*)fnOAL_calloc(n_views, sizeof(FHANDLE));
    if (NULL == hsrcs) {
        ret = F_ERR_NOMEMORY;
        printf_s("malloc error");
    }
    else {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            std::string image_path = std::string(img_folder) + std::to_string(i_img) + ".bmp";
            ret = fnFIE_load_bmp(image_path.c_str(), &(hsrcs[i_img]), F_COLOR_IMG_TYPE_UC8);
            printf_s("img ( #=%d ): %d\r\n", i_img, ret);
        }
    }
 
    // 推論実行
    ret = fnPDL_predict_multi_images(hmodel, n_views, hsrcs, &anomaly_data, &anomaly_data_len);
    printf_s("pred: %d\r\n", ret);
 
    // 後処理1: is_anomaly の判定のみ
    ret = fnPDL_postproc_ad(hmodel, anomaly_data, anomaly_data_len, threshold, &is_anomaly, NULL, NULL);
    printf_s("    is_anomaly: %d, %s\r\n", ret, (is_anomaly ? "true" : "false"));
 
    // 後処理2: 最大異常度
    ret = fnPDL_postproc_ad(hmodel, anomaly_data, anomaly_data_len, NULL, NULL, NULL, &max_anomaly);
    printf_s("    max_anomaly: %d, %6e\r\n", ret, max_anomaly);
 
    // 後処理3-1: 最大異常度マップ出力 ( float 版 )
    hmap = fnFIE_img_root_alloc(F_IMG_FLOAT, 1, w, h);
    if (NULL != hmap) {
        ret = fnPDL_postproc_ad(hmodel, anomaly_data, anomaly_data_len, NULL, NULL, &hmap, NULL);
        printf_s("    calc_map: %d\r\n", ret);
 
        ret = fnFIE_save_bmp("map_float.bmp", hmap);
        printf_s("    save map: %d\r\n", ret);
    }
 
    // 後処理3-2: 最大異常度マップ出力 ( uc8 版 )
    hmap = fnFIE_img_root_alloc(F_IMG_UC8, 1, w, h);
    if (NULL != hmap) {
        ret = fnPDL_postproc_ad(hmodel, anomaly_data, anomaly_data_len, NULL, NULL, &hmap, NULL);
        printf_s("    calc_map: %d\r\n", ret);
 
        ret = fnFIE_save_bmp("map_uc8.bmp", hmap);
        printf_s("    save map: %d\r\n", ret);
    }
 
    // ハンドルの破棄
    fnPDL_dispose(hmodel);
 
    //------- ここまで -------//
 
 
    // 終了処理
    if (NULL != hsrcs) {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            fnFIE_free_object(hsrcs[i_img]);
        }
        fnOAL_free(hsrcs);
    }
    if (NULL != anomaly_data) { fnOAL_free(anomaly_data); }
    if (NULL != hmap) { fnFIE_free_object(hmap); }
 
    fnFIE_teardown();
 
    return ret;
}
int smp_mvad_benchmark(const char* model_name, const char* img_folder, const FLOAT threshold, const int bench_iter)
{
    // benchmark 用
    std::chrono::system_clock::time_point start, end;
 
    INT ret = F_ERR_NONE;
    H_MODEL hmodel = NULL;
    MODEL_CATEGORY model_category;
    INT n_views = 0;
    FHANDLE* hsrcs = NULL;
    INT ch, w, h;
    FLOAT* anomaly_data = NULL;
    size_t anomaly_data_len;
 
    BOOL is_anomaly = false;
    FHANDLE hmap = NULL;
    FLOAT max_anomaly = .0;
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
    // ライセンスチェック
    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"); }
 
    // モデル読込
    ret = fnPDL_load_model(model_name, hmodel);
    printf_s("load: %d\r\n", ret);
 
    // モデルの種別の確認
    ret = fnPDL_get_model_category(hmodel, &model_category);
    printf_s("par : %d  category=%d\r\n", ret, model_category);
    if (MULTI_VIEW_AD != model_category) { printf_s("unmatch model"); }
 
    // モデルの期待する画像パラメータの確認
    ret = fnPDL_get_input_image_size(hmodel, &ch, &w, &h);
    printf_s("par : %d  ch=%d  w=%d  h=%d\r\n", ret, ch, w, h);
 
    // モデルの視点数の取得
    ret = fnPDL_get_how_many_views(hmodel, &n_views);
    printf_s("# of views=%d", n_views);
 
    // 入力画像配列のメモリ確保と画像読込
    hsrcs = (FHANDLE*)fnOAL_calloc(n_views, sizeof(FHANDLE));
    if (NULL == hsrcs) {
        ret = F_ERR_NOMEMORY;
        printf_s("malloc error");
    }
    else {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            std::string image_path = std::string(img_folder) + std::to_string(i_img) + ".bmp";
            ret = fnFIE_load_bmp(image_path.c_str(), &(hsrcs[i_img]), F_COLOR_IMG_TYPE_UC8);
            printf_s("img ( #=%d ): %d\r\n", i_img, ret);
        }
    }
 
    // float で確保 ( 最も重いと思われる処理 )
    hmap = fnFIE_img_root_alloc(F_IMG_FLOAT, 1, w, h);
    if (NULL == hmap) { printf_s("map image: allocation error"); }
 
 
    //------- 計測ループ ここから -------//
 
    printf_s("--- start ---\r\n");
    printf_s("ret, elapsed[msec], scores\r\n");
    // 本体ループ
    for (int i = 0; i < bench_iter; i++) {
        double elapsed;
 
        // 開始時刻
        start = std::chrono::system_clock::now();
 
        // 推論実行
        ret = fnPDL_predict_multi_images(hmodel, n_views, hsrcs, &anomaly_data, &anomaly_data_len);
        // 後処理: アノマリー判定、最大異常度取得、マップ画像算出の全て
        ret = fnPDL_postproc_ad(hmodel, anomaly_data, anomaly_data_len, threshold, &is_anomaly, &hmap, &max_anomaly);
 
        // 完了時刻
        end = std::chrono::system_clock::now();
 
        if (F_ERR_NONE != ret) {
            printf_s("pred. err: %d\r\n", ret);
            goto finally;
        }
 
        // 推論時間 [msec]
        elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / (double)1000;
 
        // コンソールに出力
        printf_s("%04d, %.3e, %s, %.6e\r\n", i, elapsed, (is_anomaly ? "anomaly" : "normal"), max_anomaly);
    }
    printf_s("--- finish ---\r\n");
 
    //------- 計測ループ ここまで -------//
 
 
    // ハンドルの破棄
    fnPDL_dispose(hmodel);
 
    finally:
    // 終了処理
    if (NULL != hsrcs) {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            fnFIE_free_object(hsrcs[i_img]);
        }
        fnOAL_free(hsrcs);
    }
    if (NULL != anomaly_data) { fnOAL_free(anomaly_data); }
    if (NULL != hmap) { fnFIE_free_object(hmap); }
    fnFIE_teardown();
 
    return ret;
}
int smp_mvad_with_fie(const char* model_name, const char* img_folder, const FLOAT threshold)
{
    INT ret = F_ERR_NONE;
    
    // モデルとその情報
    H_MODEL hmodel = NULL;
    MODEL_CATEGORY model_category;
    INT n_views = 0;
 
    // 推論画像とその情報、フィルタをかけた画像
    FHANDLE* hsrcs = NULL;
    FHANDLE* hfiltereds = NULL;
    INT ch, w, h, type;
    INT_PTR step;
 
    // 推論結果
    FLOAT* anomaly_data = NULL;
    size_t anomaly_data_len;
    BOOL is_anomaly = false;
    FLOAT max_anomaly = .0;
 
 
    // FIEライブラリの使用前に必ずコールする必要があります。
    fnFIE_setup();
 
    // ライセンスチェック
    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"); }
 
    // モデル読込
    ret = fnPDL_load_model(model_name, hmodel);
    printf_s("load: %d\r\n", ret);
 
    // モデルの種別の確認
    ret = fnPDL_get_model_category(hmodel, &model_category);
    printf_s("par : %d  category=%d\r\n", ret, model_category);
    if (MULTI_VIEW_AD != model_category) { printf_s("unmatch model"); }
 
    // モデルの期待する画像パラメータの確認
    ret = fnPDL_get_input_image_size(hmodel, &ch, &w, &h);
    printf_s("par : %d  ch=%d  w=%d  h=%d\r\n", ret, ch, w, h);
 
    // モデルの視点数の取得
    ret = fnPDL_get_how_many_views(hmodel, &n_views);
    printf_s("# of views=%d", n_views);
 
    // 入力画像配列のメモリ確保と画像読込
    hsrcs = (FHANDLE*)fnOAL_calloc(n_views, sizeof(FHANDLE));
    if (NULL == hsrcs) {
        ret = F_ERR_NOMEMORY;
        printf_s("malloc error");
    }
    else {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            std::string image_path = std::string(img_folder) + std::to_string(i_img) + ".bmp";
            ret = fnFIE_load_bmp(image_path.c_str(), &(hsrcs[i_img]), F_COLOR_IMG_TYPE_UC8);
            printf_s("img ( #=%d ): %d\r\n", i_img, ret);
        }
    }
 
    // 読み込んだ画像をそのまま推論する
 
    // 推論実行
    ret = fnPDL_predict_multi_images(hmodel, n_views, hsrcs, &anomaly_data, &anomaly_data_len);
    printf_s("pred(original): %d\r\n", ret);
    // 後処理
    ret = fnPDL_postproc_ad(hmodel, anomaly_data, anomaly_data_len, threshold, &is_anomaly, NULL, &max_anomaly);
    printf_s("postproc(original): %d %s, %.6e\r\n", ret, (is_anomaly ? "anomaly" : "normal"), max_anomaly);
 
    // フィルタをかけた画像を推論する
 
    // ここでは単純な平均化フィルタ
    hfiltereds = (FHANDLE*)fnOAL_calloc(n_views, sizeof(FHANDLE));
    if (NULL == hsrcs) {
        ret = F_ERR_NOMEMORY;
        printf_s("malloc error ( filtered images )");
    }
    else {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            FHANDLE hsrc = hsrcs[i_img];
            FHANDLE hdst = hfiltereds[i_img];
            ret = fnFIE_average(hsrc, hdst, 0, 0);
            if (F_ERR_NONE != ret) { goto finally; }
        }
    }
 
    // 推論実行
    ret = fnPDL_predict_multi_images(hmodel, n_views, hfiltereds, &anomaly_data, &anomaly_data_len);
    printf_s("pred(original): %d\r\n", ret);
    // 後処理
    ret = fnPDL_postproc_ad(hmodel, anomaly_data, anomaly_data_len, threshold, &is_anomaly, NULL, &max_anomaly);
    printf_s("postproc(original): %d %s, %.6e\r\n", ret, (is_anomaly ? "anomaly" : "normal"), max_anomaly);
 
 
    finally:
    // ハンドルの破棄
    fnPDL_dispose(hmodel);
 
    // メモリの破棄
    if (NULL != hsrcs) {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            fnFIE_free_object(hsrcs[i_img]);
        }
        fnOAL_free(hsrcs);
    }
    if (NULL != hfiltereds) {
        INT i_img = 0;
        for (i_img = 0; i_img < n_views; i_img++) {
            fnFIE_free_object(hfiltereds[i_img]);
        }
        fnOAL_free(hfiltereds);
    }
    if (NULL != anomaly_data) { fnOAL_free(anomaly_data); }
 
    // 終了処理
    fnFIE_teardown();
 
    return ret;
}