deep_cortex_svl_simple.c

Go to the documentation of this file.

 
#include "../common/common.h"
 
sb_t_err create_deep_cortex_project_file(SB_HANDLE* deep_cortex);
 
sb_t_err set_model_to_images(SB_HANDLE deep_cortex);
 
sb_t_err execute_training(void);
 
#define SAVE_BEST_EPOCH 0
 
int main(void)
{
    sb_t_err err = SB_ERR_NONE;
    sb_t_info* sb_info = NULL;
    SB_HANDLE deep_cortex = 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"));
#else 
    CHECK_FN_GOTO(sb_init_dl(NULL));
#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_cortex_project_file(&deep_cortex));
 
    CHECK_FN_GOTO(set_model_to_images(deep_cortex));
 
    CHECK_FN_GOTO(execute_training());
 
FnExit:
    sb_destroy_info(&sb_info);
    sb_project_destroy(&deep_cortex);
 
    printf("Release SqueezeBrains library\n");
    sb_release();
 
    printf("Press ENTER to terminate\n");
    getchar();
    return (int)err;
}
 
sb_t_err create_deep_cortex_project_file(SB_HANDLE* deep_cortex)
{
    sb_t_err err = SB_ERR_NONE;
    sb_t_par par;
 
    // Erase the project file to begin from zero
    remove("dataset/deep_cortex." SB_SOLUTION_EXT);
 
    // Create the project file
    CHECK_FN_GOTO(sb_project_create(deep_cortex, "nuts", SB_PROJECT_TYPE_DEEP_CORTEX));
    CHECK_FN_GOTO(sb_project_get_par(*deep_cortex, &par));
    CHECK_FN_GOTO(sb_par_add_model(&par, "peanut"));
    CHECK_FN_GOTO(sb_par_add_model(&par, "walnut"));
    CHECK_FN_GOTO(sb_par_add_model(&par, "hazelnut"));
    CHECK_FN_GOTO(sb_par_add_model(&par, "almond"));
    CHECK_FN_GOTO(sb_project_set_par(*deep_cortex, &par));
    CHECK_FN_GOTO(sb_project_save(*deep_cortex, "dataset/deep_cortex." SB_SOLUTION_EXT, SB_PROJECT_MODE_DETECTION_AND_SVL));
FnExit:
    return err;
}
 
sb_t_err set_model_to_images(SB_HANDLE deep_cortex)
{
    sb_t_err err = SB_ERR_NONE;
    SB_HANDLE image_info = NULL;
    sb_t_sample sample;
 
    memset(&sample, 0, sizeof(sample));
    sample.type = SB_OBJ_TEST;  
    sample.classify_mode = SB_SAMPLE_REQUIRED;  
    sample.scale = 1.0f;    
    // 1st image
    CHECK_FN_GOTO(sb_image_info_load(&image_info, "dataset/deep_cortex_peanut.png", deep_cortex));
    // 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));
    strcpy(sample.model_name, "peanut");
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)));
    CHECK_FN_GOTO(sb_image_info_add_sample(image_info, &sample));
    CHECK_FN_GOTO(sb_image_info_save(image_info));
    CHECK_FN_GOTO(sb_image_info_destroy(&image_info));
    // 2nd image
    CHECK_FN_GOTO(sb_image_info_load(&image_info, "dataset/deep_cortex_walnut.png", deep_cortex));
    // 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));
    strcpy(sample.model_name, "walnut");
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)));
    CHECK_FN_GOTO(sb_image_info_add_sample(image_info, &sample));
    CHECK_FN_GOTO(sb_image_info_save(image_info));
    CHECK_FN_GOTO(sb_image_info_destroy(&image_info));
    // 3dh image
    CHECK_FN_GOTO(sb_image_info_load(&image_info, "dataset/deep_cortex_hazelnut.png", deep_cortex));
    // 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));
    strcpy(sample.model_name, "hazelnut");
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)));
    CHECK_FN_GOTO(sb_image_info_add_sample(image_info, &sample));
    CHECK_FN_GOTO(sb_image_info_save(image_info));
    CHECK_FN_GOTO(sb_image_info_destroy(&image_info));
    // 4th image
    CHECK_FN_GOTO(sb_image_info_load(&image_info, "dataset/deep_cortex_almond.png", deep_cortex));
    // 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));
    strcpy(sample.model_name, "almond");
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)));
    CHECK_FN_GOTO(sb_image_info_add_sample(image_info, &sample));
    CHECK_FN_GOTO(sb_image_info_save(image_info));
    CHECK_FN_GOTO(sb_image_info_destroy(&image_info));
 
FnExit:
    sb_image_info_destroy(&image_info);
    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;
    sb_t_solution_info* solution = NULL;
 
    CHECK_FN_GOTO(sb_solution_get_info("dataset/deep_cortex." SB_SOLUTION_EXT, &solution));
    CHECK_FN_GOTO(sb_project_load(&svl, "dataset/deep_cortex." 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.dl.num_epochs = 100;
    par.svl.dl.batch_size = 4;
    // GPU device for SVL
    par.svl.devices.type = SB_DEVICE_GPU;
    par.svl.devices.id[0] = 0;
    // dl network parameters
    par.svl.dl.network.type = SB_NETWORK_TYPE_ICNET0_64;
    // 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));
    printf("Training is running, please wait . . .\n");
    CHECK_FN_GOTO(sb_svl_run(svl));
    CHECK_FN_GOTO(sb_svl_get_res(svl, &svl_res));
    printf("SVL results:\n");
    printf("\tepoch=%d\n", svl_res->global.epochs.size);
    printf("\tloss=%f\n", svl_res->global.epochs.epoch[svl_res->global.epochs.size-1].loss);
    printf("\taccuracy=%f\n", svl_res->global.epochs.epoch[svl_res->global.epochs.size-1].accuracy);
    printf("\ttime=%1.3fs\n", svl_res->time_ms / 1000.0f);
    CHECK_FN_GOTO(sb_project_save(svl, NULL, SB_PROJECT_MODE_DETECTION_AND_SVL));
FnExit:
    sb_svl_destroy_res(&svl_res);
    sb_project_destroy(&svl);
    sb_solution_destroy_info(&solution);
    return err;
}