deep__cortex__svl__simple_8c_source.html

#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", 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_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 = NULL;


    // 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:

    sb_par_destroy(&par);

    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 = NULL;

    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;

    par->svl.dl.save_best = 1;

    // 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_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.saved_epoch);

    printf("\tloss=%f\n", svl_res->global.epochs.epoch[svl_res->global.epochs.saved_epoch].loss);

    printf("\taccuracy=%f\n", svl_res->global.epochs.epoch[svl_res->global.epochs.saved_epoch].metrics.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_par_destroy(&par);

    sb_project_destroy(&svl);

    sb_solution_destroy_info(&solution);

    return err;

}

wait_license
EXTERN_C sb_t_err wait_license(void)
The functions wait until the license status is active.
Definition: common.c:11

CHECK_FN_GOTO
#define CHECK_FN_GOTO(function)
Definition: common.h:34

create_deep_cortex_project_file
sb_t_err create_deep_cortex_project_file(SB_HANDLE *deep_cortex)
Create a deep_cortex project file.
Definition: deep_cortex_svl_simple.c:112

main
int main(void)
Definition: deep_cortex_svl_simple.c:61

execute_training
sb_t_err execute_training(void)
Execute training.
Definition: deep_cortex_svl_simple.c:200

set_model_to_images
sb_t_err set_model_to_images(SB_HANDLE deep_cortex)
Set samples.
Definition: deep_cortex_svl_simple.c:136

sb_t_err
sb_t_err
Errors code enum.
Definition: sb.h:6230

SB_ERR_NONE
@ SB_ERR_NONE
No errors.
Definition: sb.h:6231

sb_destroy_info
sb_t_err sb_destroy_info(sb_t_info **const info)
Destroys the structure.

sb_release
sb_t_err sb_release(void)
Releases all the resources allocates in the library.

sb_get_info
sb_t_err sb_get_info(sb_t_info **const info, int dl_devices_info)
The function gets information about the sb library and the available computational devices.

sb_init
sb_t_err sb_init(const char *const license_file)
Initializes the SB library.

sb_init_dl
sb_t_err sb_init_dl(const char *const search_path, sb_t_dl_library_type lib_type)
Initialize the Deep Learning library.

SB_HANDLE
void * SB_HANDLE
HANDLE definition.
Definition: sb.h:6766

sb_get_uuid
sb_t_err sb_get_uuid(char *const str, size_t size)
Creates a new uuid.

SB_DL_LIBRARY_PYTORCH
@ SB_DL_LIBRARY_PYTORCH
Pytorch library.
Definition: sb.h:6693

SB_DL_LIBRARY_OPENVINO
@ SB_DL_LIBRARY_OPENVINO
Openvino library. Can be used only for inference with sb_project_detection function.
Definition: sb.h:6694

SB_DEVICE_GPU_NVIDIA
@ SB_DEVICE_GPU_NVIDIA
GPU NVidia device.
Definition: sb.h:6834

sb_image_info_set_type
sb_t_err sb_image_info_set_type(SB_HANDLE image_info, sb_t_image_info_type type)
Sets the type of the SqueezeBrains image info.

sb_image_info_add_sample
sb_t_err sb_image_info_add_sample(SB_HANDLE image_info, const sb_t_sample *const sample)
Adds a sample into the SqueezeBrains image info handle.

sb_image_info_load
sb_t_err sb_image_info_load(SB_HANDLE *image_info, const char *const image_file, SB_HANDLE module_handle)
Creates a SqueezeBrains image info handle.

sb_image_info_reset
sb_t_err sb_image_info_reset(SB_HANDLE image_info)
Erases all the data from the SqueezeBrains image info handle.

sb_image_info_destroy
sb_t_err sb_image_info_destroy(SB_HANDLE *image_info)
Destroys the SqueezeBrains image info handle.

sb_image_info_save
sb_t_err sb_image_info_save(SB_HANDLE image_info)
Saves the SqueezeBrains image info handle into the image file.

SB_IMAGE_INFO_TYPE_SVL
@ SB_IMAGE_INFO_TYPE_SVL
Image is used for SVL and not used for training.
Definition: sb.h:13377

SB_IMAGE_FILE_EXTENSIONS
#define SB_IMAGE_FILE_EXTENSIONS
List of the possible extensions of the image.
Definition: sb.h:8033

sb_par_add_model
sb_t_err sb_par_add_model(sb_t_par *const par, const char *const model_name)
Adds the model to the parameter structure.

sb_par_destroy
sb_t_err sb_par_destroy(sb_t_par **const par)
Destroys the project parameters structure.

sb_project_set_par
sb_t_err sb_project_set_par(SB_HANDLE handle, const sb_t_par *const par)
Sets the parameters structure into the project handle.

sb_project_create
sb_t_err sb_project_create(SB_HANDLE *phandle, const char *const project_name, sb_t_project_type project_type)
Creates a new project of the specifed type.

sb_project_save
sb_t_err sb_project_save(SB_HANDLE handle, const char *const solution_file, sb_t_project_mode mode)
Saves the project to file.

sb_project_load
sb_t_err sb_project_load(SB_HANDLE *phandle, const char *const solution_file, const char *const project_uuid, sb_t_project_mode mode)
Loads an existing project from a solution file.

sb_project_destroy
sb_t_err sb_project_destroy(SB_HANDLE *phandle)
Frees all the resources of the project handle.

sb_project_get_par
sb_t_err sb_project_get_par(SB_HANDLE handle, sb_t_par **const par)
Retrieves the project parameters structure.

SB_PROJECT_MODE_DETECTION_AND_SVL
@ SB_PROJECT_MODE_DETECTION_AND_SVL
Load/save all the module information.
Definition: sb.h:9823

SB_PROJECT_TYPE_DEEP_CORTEX
@ SB_PROJECT_TYPE_DEEP_CORTEX
Project Deep Cortex.
Definition: sb.h:9673

SB_OBJ_TEST
@ SB_OBJ_TEST
Object is not used for learning.
Definition: sb.h:8762

SB_SAMPLE_REQUIRED
@ SB_SAMPLE_REQUIRED
Definition: sb.h:8845

sb_solution_get_info
sb_t_err sb_solution_get_info(const char *const solution_file, sb_t_solution_info **const solution)
Returns the information contained in the solution_file.

SB_SOLUTION_EXT
#define SB_SOLUTION_EXT
Extension of the SqueezeBrains solution file.
Definition: sb.h:9721

sb_solution_destroy_info
sb_t_err sb_solution_destroy_info(sb_t_solution_info **const solution)
Destroys the structure of the solution information.

sb_svl_destroy_res
sb_t_err sb_svl_destroy_res(sb_t_svl_res **const res)
Destroys the structure of the results of SVL.

sb_svl_reset
sb_t_err sb_svl_reset(SB_HANDLE handle)
Resets the history of previous executions of the SVL.

sb_svl_run
sb_t_err sb_svl_run(SB_HANDLE handle)
Runs the SVL.

sb_svl_get_res
sb_t_err sb_svl_get_res(SB_HANDLE handle, sb_t_svl_res **const res)
Retrieves the results of SVL.

SB_NETWORK_TYPE_ICNET0_64
@ SB_NETWORK_TYPE_ICNET0_64
Deep Learning Image Classification Network 0 with input size 64x64.
Definition: sb.h:10443

sb_t_devices_par::id
int id[SB_DEVICES_MAX_NUMBER]
Identifier of the devices to be used.
Definition: sb.h:11252

sb_t_devices_par::type
sb_t_device_type type
Device type.
Definition: sb.h:11237

sb_t_info
General information about sb library and computing devices like CPU and GPUs.
Definition: sb.h:6946

sb_t_info::compile_time
char compile_time[32]
String with the compilation time of the sb library.
Definition: sb.h:6950

sb_t_info::compile_date
char compile_date[32]
String with the compilation date of the sb library.
Definition: sb.h:6949

sb_t_info::version_str
char version_str[16]
String with the version of the sb library.
Definition: sb.h:6948

sb_t_metrics::accuracy
float accuracy
accuracy
Definition: sb.h:12312

sb_t_par
Project parameters.
Definition: sb.h:11797

sb_t_par::svl
sb_t_svl_par svl
SVL parameters.
Definition: sb.h:11913

sb_t_project_info::uuid
char uuid[SB_PROJECT_UUID_LEN]
Project UUID.
Definition: sb.h:9697

sb_t_projects_info::info
sb_t_project_info * info
Array of solution project information.
Definition: sb.h:9707

sb_t_range::max
int max
maximum value
Definition: sb.h:6517

sb_t_range::min
int min
minimum value
Definition: sb.h:6516

sb_t_sample
Sample of an image.
Definition: sb.h:8908

sb_t_sample::model_name
char model_name[SB_PAR_STRING_LEN]
Name of the model.
Definition: sb.h:8981

sb_t_sample::uuid
char uuid[36]
uuid of the sample.
Definition: sb.h:8909

sb_t_sample::scale
float scale
Scale factor.
Definition: sb.h:8994

sb_t_sample::classify_mode
sb_t_sample_classify_mode classify_mode
Classification mode.
Definition: sb.h:9063

sb_t_sample::type
sb_t_obj_type type
Sample type.
Definition: sb.h:8999

sb_t_solution_info
Solution info structure.
Definition: sb.h:9727

sb_t_solution_info::projects
sb_t_projects_info projects
Array of the projects info.
Definition: sb.h:9728

sb_t_solution_info::current_project
int current_project
Index of the current project in the projects array.
Definition: sb.h:9729

sb_t_svl_dl_par_network::type
sb_t_network_type type
Network type.
Definition: sb.h:10540

sb_t_svl_dl_par_perturbation::angle_range
sb_t_range angle_range
Angular range, in degrees, for random rotation.
Definition: sb.h:10925

sb_t_svl_dl_par_perturbation::shift_horizontal
float shift_horizontal
Maximum shift along x-axis.
Definition: sb.h:10909

sb_t_svl_dl_par_perturbation::flip_horizontal
int flip_horizontal
Flip around horizontal axis.
Definition: sb.h:10892

sb_t_svl_dl_par_perturbation::shift_vertical
float shift_vertical
Maximum shift along y-axis.
Definition: sb.h:10917

sb_t_svl_dl_par_perturbation::flip_vertical
int flip_vertical
Flip around vertical axis.
Definition: sb.h:10901

sb_t_svl_dl_par::batch_size
int batch_size
Size of the batch used during SVL.
Definition: sb.h:11106

sb_t_svl_dl_par::save_best
int save_best
At the end of the training, the best internal parameters configuration is recovered.
Definition: sb.h:11131

sb_t_svl_dl_par::network
sb_t_svl_dl_par_network network
Network parameters.
Definition: sb.h:11033

sb_t_svl_dl_par::num_epochs
int num_epochs
Number of epochs.
Definition: sb.h:11096

sb_t_svl_dl_par::perturbations
sb_t_svl_dl_par_perturbation perturbations
Perturbations for deep learning training.
Definition: sb.h:11079

sb_t_svl_par::devices
sb_t_devices_par devices
Devices used for SVL/training.
Definition: sb.h:11336

sb_t_svl_par::project_path
char project_path[512]
Path of the project, where the SVL will find the images.
Definition: sb.h:11289

sb_t_svl_par::dl
sb_t_svl_dl_par dl
Deep Learning SVL parameters.
Definition: sb.h:11348

sb_t_svl_par::image_ext
char image_ext[64]
Extensions of the images.
Definition: sb.h:11297

sb_t_svl_res_epoch::loss
float loss
SVL loss.
Definition: sb.h:14338

sb_t_svl_res_epoch::metrics
sb_t_metrics metrics
SVL metrics.
Definition: sb.h:14354

sb_t_svl_res_epochs::epoch
sb_t_svl_res_epoch * epoch
Array of the results of the training epochs.
Definition: sb.h:14369

sb_t_svl_res_epochs::saved_epoch
int saved_epoch
Definition: sb.h:14370

sb_t_svl_res_level::epochs
sb_t_svl_res_epochs epochs
Results of training of module based on Deep Learning.
Definition: sb.h:14567

sb_t_svl_res
Defines the results of SVL.
Definition: sb.h:14638

sb_t_svl_res::global
sb_t_svl_res_level global
Cumulative results of all levels of all models.
Definition: sb.h:14681

sb_t_svl_res::time_ms
long long time_ms
Execution time, in ms, of SVL.
Definition: sb.h:14740