deep_surface_svl_simple.c

Go to the documentation of this file.

 
#include "../common/common.h"
 
typedef struct 
{
    long long last_time_ms;
}sb_svl_user_data;
 
static sb_t_err svl_callback_dl(void* const user_data, const sb_t_svl_res* const res, int force)
{
    sb_t_info* info = NULL;
    char device_info_msg[512] = "";
    sb_get_info(&info, 1);
    //Search for the information of the device
    for (int i = 0; i < info->devices.size; i++)
    {
        if (res->devices.type == info->devices.device[i].type)
        {
            sb_t_device_info* device_info = &info->devices.device[i];
            sprintf(device_info_msg, ", device=\"%s-%s\",  memory=%lld/%lldMByte",
                sb_device_type_format(device_info->type), device_info->name, device_info->memory.system_used / (1024 * 1024), device_info->memory.system_total / (1024 * 1024));
            break;
        }
    }
    //Print every 500ms or if "force" flag is set
    sb_svl_user_data *ud = (sb_svl_user_data*)user_data;    
    if (ud->last_time_ms < res->time_ms)
    {
        ud->last_time_ms = res->time_ms + 500;
        if (strcmp(res->running_step, "training recipe") == 0 && res->global.epochs.size > 0)
        {
            // These fields start to be populated in the training recipe step
            printf("\r\"%s\", epoch=%d/%d, loss=%f, accuracy=%f, time left= %llds, time=%llds, time last improvement=%llds (%llds), memory=%lld/%lldMByte%s      ",
                res->running_step,
                res->global.epochs.size, res->par.svl.dl.num_epochs, res->global.epochs.epoch[res->global.epochs.size-1].loss, res->global.epochs.epoch[res->global.epochs.size-1].metrics.accuracy,
                res->time_left_ms / 1000,
                res->time_ms / 1000, res->time_ms_last_improvement / 1000, (res->time_ms - res->time_ms_last_improvement) / 1000,
                info->malloc_size/(1024*1024), info->malloc_size_max/(1024*1024), device_info_msg);
        }
        else
        {
            printf("\r\"%s\", time=%llds, memory=%lld/%lldMByte       ",
                res->running_step,
                res->time_ms / 1000,
                info->malloc_size/(1024*1024), info->malloc_size_max/(1024*1024));
        }
 
        fflush(stdout);
    }
    sb_destroy_info(&info);
    sb_svl_destroy_res(&res);
    return(SB_ERR_NONE);
}
 
#if defined(_WIN32) && !defined(QT_CREATOR)
int svl_run;
static DWORD WINAPI deep_surface_svl(LPVOID svl)
{
    sb_t_err err;
    printf(">>> START SVL <<<\n");
    err = sb_svl_run(svl);
    printf("\n>>> STOP SVL <<<\n");
    if (err != SB_ERR_NONE)
    {
        printf("sb_svl_run returns %d - %s", err, sb_err_format(err));
    }
    svl_run = 0;
    return 0;
}
#endif
 
sb_t_err create_deep_surface_project_file(SB_HANDLE* deep_surface);
 
sb_t_err set_labeling(SB_HANDLE deep_surface);
 
sb_t_err execute_training(void);
 
sb_t_err check_labeling_file_exists(char* img_file, sb_t_folder* folder_defects, int* file_index);
 
#define MODEL_NAME "stripe"
 
int main(void)
{
    sb_t_err err = SB_ERR_NONE;
    sb_t_info* sb_info = NULL;
    SB_HANDLE project = NULL;
 
    printf("Initialize the SqueezeBrains library\n");
    CHECK_FN_GOTO(sb_init("../sb.lic"));
 
#if defined(_WIN32)
    // "../../../win_x64/dl_framework" is the pre-defined relative path between working directory and SB Deep Learning Framework into the installation folder.
    CHECK_FN_GOTO(sb_init_dl("../../../win_x64/dl_framework", SB_DL_LIBRARY_PYTORCH));
    CHECK_FN_GOTO(sb_init_dl("../../../win_x64/dl_framework", SB_DL_LIBRARY_OPENVINO));
#else 
    CHECK_FN_GOTO(sb_init_dl(NULL, SB_DL_LIBRARY_PYTORCH));
    CHECK_FN_GOTO(sb_init_dl(NULL, SB_DL_LIBRARY_OPENVINO));
#endif
 
    // Print library version.
    CHECK_FN_GOTO(sb_get_info(&sb_info, 0));
    printf("sb ver. %s, compiled on %s %s\n", sb_info->version_str, sb_info->compile_date, sb_info->compile_time);
 
    printf("wait for license...\n");
    CHECK_FN_GOTO(wait_license());
 
    CHECK_FN_GOTO(create_deep_surface_project_file(&project));
 
    CHECK_FN_GOTO(set_labeling(project));
 
    CHECK_FN_GOTO(execute_training());
 
FnExit:
    sb_destroy_info(&sb_info);
    sb_project_destroy(&project);
 
    printf("Release SqueezeBrains library\n");
    sb_release();
 
    printf("Press ENTER to terminate\n");
    getchar();
    return (int)err;
}
 
sb_t_err create_deep_surface_project_file(SB_HANDLE* deep_surface)
{
    sb_t_err err = SB_ERR_NONE;
    sb_t_par* par = NULL;
 
    // Erase the project file to begin from zero
    remove("dataset/deep_surface." SB_SOLUTION_EXT);
 
    CHECK_FN_GOTO(sb_project_create(deep_surface, "semilavorato", SB_PROJECT_TYPE_DEEP_SURFACE));
    CHECK_FN_GOTO(sb_project_get_par(*deep_surface, &par));
    CHECK_FN_GOTO(sb_par_add_model(par, MODEL_NAME));
    CHECK_FN_GOTO(sb_project_set_par(*deep_surface, par));
    CHECK_FN_GOTO(sb_project_save(*deep_surface, "dataset/deep_surface." SB_SOLUTION_EXT, SB_PROJECT_MODE_DETECTION_AND_SVL))
FnExit:
    sb_par_destroy(&par);
    return err;
}
 
sb_t_err check_labeling_file_exists(char* img_file, sb_t_folder* folder_defects, int *file_index)
{
    sb_t_err err = SB_ERR_NONE;
    char img_name_no_ext[256];
    char img_defects_name_no_ext[256];
 
    CHECK_FN_GOTO(sb_file_extract_name(img_file, 0, &img_name_no_ext, sizeof(img_name_no_ext)));
 
    for (int i = 0; i < folder_defects->n; i++)
    {
        CHECK_FN_GOTO(sb_file_extract_name(folder_defects->file[i].name, 0, &img_defects_name_no_ext, sizeof(folder_defects->file[i].name)));
        if (strcmp(img_name_no_ext, img_defects_name_no_ext) == 0)
        {
            *file_index = i;
            break;
        }
    }
 
FnExit:
    return err;
}
 
sb_t_err set_labeling(SB_HANDLE deep_surface)
{
    sb_t_err err = SB_ERR_NONE;
    SB_HANDLE image_info = NULL;
    sb_t_roi *defects = NULL;
    sb_t_roi *roi = NULL;
    sb_t_image *img = NULL;
    sb_t_image *img_defects = NULL;
    sb_t_folder* folder = NULL;
    sb_t_folder* folder_defects = NULL;
    int i;
 
    CHECK_FN_GOTO(sb_folder_load(&folder, "dataset", SB_IMAGE_INFO_EXT, 1, 0))
    for(i = 0; i < folder->n; i++)
        remove(folder->file[i].name);
    CHECK_FN_GOTO(sb_folder_destroy(&folder));
 
    CHECK_FN_GOTO(sb_folder_load(&folder_defects, "dataset/roi_defects", "bmp", 1, 0))
 
    
    CHECK_FN_GOTO(sb_folder_load(&folder, "dataset", "png", 1, 0))
    for (i = 0; i < folder->n; i++)
    {
        int file_index = -1;
 
        // Check if image mask with defects labeling exists
        CHECK_FN_GOTO(check_labeling_file_exists(folder->file[i].name, folder_defects, &file_index))
        if (file_index >= 0)
        {
            // Load image and create image info
            CHECK_FN_GOTO(sb_image_load(&img, folder->file[i].name))
            CHECK_FN_GOTO(sb_image_info_load(&image_info, folder->file[i].name, deep_surface))
            // Reset the image info
            CHECK_FN_GOTO(sb_image_info_reset(image_info))
            CHECK_FN_GOTO(sb_image_info_set_type(image_info, SB_IMAGE_INFO_TYPE_SVL))
            // Get the roi
            CHECK_FN_GOTO(sb_image_info_get_roi(image_info, &roi, img->width, img->height, 0))
            // Set a full image ROI
            CHECK_FN_GOTO(sb_roi_set_rect(roi, 255, sb_rect(0, 0, roi->img->width, roi->img->height), 1))
            CHECK_FN_GOTO(sb_image_info_set_roi(image_info, roi));
            // Get the defects roi
            CHECK_FN_GOTO(sb_image_info_get_roi_defects(image_info, &defects, img->width, img->height, 0))
            // Load image with the defects mask
            CHECK_FN_GOTO(sb_image_load(&img_defects, folder_defects->file[file_index].name));
            // Copy defects mask data into ROI defects 
            CHECK_FN_GOTO(sb_image_copy(img_defects, defects->img));
            CHECK_FN_GOTO(sb_image_info_set_roi_defects(image_info, defects))
            CHECK_FN_GOTO(sb_image_info_save(image_info))
 
            sb_image_info_destroy(&image_info);
            sb_image_destroy(&img);
            sb_image_destroy(&img_defects);
            sb_roi_destroy(&roi);
            sb_roi_destroy(&defects);
        }
    }
 
FnExit:
    sb_image_info_destroy(&image_info);
    sb_image_destroy(&img);
    sb_image_destroy(&img_defects);
    sb_roi_destroy(&roi);
    sb_roi_destroy(&defects);
    sb_folder_destroy(&folder);
    sb_folder_destroy(&folder_defects);
    return err;
}
 
sb_t_err execute_training(void)
{
    sb_t_err err = SB_ERR_NONE;
    SB_HANDLE svl = NULL;
    sb_t_svl_res* svl_res = NULL;
    sb_t_par* par = NULL;
    sb_t_solution_info* solution = NULL;
    sb_svl_user_data user_data = {0};
 
    CHECK_FN_GOTO(sb_solution_get_info("dataset/deep_surface." SB_SOLUTION_EXT, &solution));
    CHECK_FN_GOTO(sb_project_load(&svl, "dataset/deep_surface." SB_SOLUTION_EXT, solution->projects.info[solution->current_project].uuid, SB_PROJECT_MODE_DETECTION_AND_SVL));
    CHECK_FN_GOTO(sb_svl_reset(svl));
    CHECK_FN_GOTO(sb_project_get_par(svl, &par));
    strcpy(par->svl.image_ext, SB_IMAGE_FILE_EXTENSIONS);
    strcpy(par->svl.project_path, "dataset/");
    par->svl.fp_progress = svl_callback_dl;
    //par.svl.free_memory_percentage = free_memory_percentage; // TODO da attivare
    par->svl.user_data = &user_data;
    // GPU device for SVL
    par->svl.devices.type = SB_DEVICE_GPU_NVIDIA;
    par->svl.devices.id[0] = 0;
    // dl network parameters
    par->svl.dl.network.type = SB_NETWORK_TYPE_SDINET0;
    par->svl.dl.num_epochs = 200;
    par->svl.dl.batch_size = 4;
    // dl perturbation parameters
    par->svl.dl.perturbations.flip_horizontal = 1;      
    par->svl.dl.perturbations.flip_vertical = 1;            
    par->svl.dl.perturbations.angle_range.min = -180;   
    par->svl.dl.perturbations.angle_range.max = 180;
    par->svl.dl.perturbations.shift_horizontal = 0.1f;
    par->svl.dl.perturbations.shift_vertical = 0.1f;
    CHECK_FN_GOTO(sb_project_set_par(svl, par));
 
#if defined(_WIN32) && !defined(QT_CREATOR)
    printf("-------------------------------------------------------------------------------------\n");
    printf("CTRL-right + F12 = stop svl\n");                   
    printf("-------------------------------------------------------------------------------------\n");
    svl_run = 1;
    int stop_request = 0;
    CreateThread(NULL, 0, deep_surface_svl, svl, 0, NULL);
    //With WINDOWS Visual Studio it is possibile to check the keyborad without waiting enter to be pressed
    while(1)
    {
        Sleep(100);
        //Check the keyborad without waiting enter to be pressed
        if (!stop_request && (GetAsyncKeyState(VK_RCONTROL) & 0x8000) && (GetAsyncKeyState(VK_F12) & 0x8000))            
        {
            printf("\nSend stop request to svl...\n");
            sb_svl_stop_request(svl);
            stop_request = 1;
        }
        if (!svl_run) { break;}
    }
#else
        CHECK_FN_GOTO(sb_svl_run(svl));
#endif
 
    CHECK_FN_GOTO(sb_svl_get_res(svl, &svl_res));
    if (strcmp(svl_res->running_step, SB_SVL_STEP_FINISHED) == 0)
    {
        printf("\nsaving SVL results....\n");
        CHECK_FN_GOTO(sb_project_save(svl, NULL, SB_PROJECT_MODE_DETECTION_AND_SVL))
    }
 
FnExit:
    sb_svl_destroy_res(&svl_res);
    sb_par_destroy(&par);
    sb_project_destroy(&svl);
    sb_solution_destroy_info(&solution);
    
    return err;
}