int main(int argc, char** argv)
{
if (argc != 5)
{
print_help();
return -1;
}
ccv_enable_default_cache();
int i, rt;
int posnum = atoi(argv[2]);
FILE* pf = fopen(argv[1], "r");
ccv_dense_matrix_t** posimg = (ccv_dense_matrix_t**)malloc(sizeof(posimg[0]) * posnum);
for (i = 0; i < posnum; i++)
{
char buf[1024];
rt = fscanf(pf, "%s", buf);
ccv_read(buf, &posimg[i], CCV_IO_GRAY | CCV_IO_ANY_FILE);
}
fclose(pf);
int negnum = atoi(argv[4]);
FILE* bgf = fopen(argv[3], "r");
int bgnum;
rt = fscanf(bgf, "%d", &bgnum);
char** bgfiles = (char**)malloc(sizeof(bgfiles[0]) * bgnum);
for (i = 0; i < bgnum; i++)
{
bgfiles[i] = (char*)malloc(1024);
rt = fscanf(bgf, "%s", bgfiles[i]);
}
fclose(bgf);
ccv_bbf_new_param_t params = {
.pos_crit = 0.9975,
.neg_crit = 0.50,
.balance_k = 1.0,
.layer = 24,
.feature_number = 100,
.optimizer = CCV_BBF_GENETIC_OPT | CCV_BBF_FLOAT_OPT,
};
ccv_bbf_classifier_cascade_new(posimg, posnum, bgfiles, bgnum, negnum, ccv_size(24, 24), "data", params);
for (i = 0; i < bgnum; i++)
free(bgfiles[i]);
for (i = 0; i < posnum; i++)
ccv_matrix_free(&posimg[i]);
free(posimg);
free(bgfiles);
ccv_disable_cache();
return 0;
}
int main(int argc, char** argv)
{
static struct option image_net_options[] = {
/* help */
{"help", 0, 0, 0},
/* required parameters */
{"train-list", 1, 0, 0},
{"test-list", 1, 0, 0},
{"working-dir", 1, 0, 0},
/* optional parameters */
{"base-dir", 1, 0, 0},
{"max-epoch", 1, 0, 0},
{"iterations", 1, 0, 0},
{0, 0, 0, 0}
};
char* train_list = 0;
char* test_list = 0;
char* working_dir = 0;
char* base_dir = 0;
ccv_convnet_train_param_t train_params = {
.max_epoch = 100,
.mini_batch = 64,
.sgd_frequency = 1, // do sgd every sgd_frequency batches (mini_batch * device_count * sgd_frequency)
.iterations = 50000,
.device_count = 4,
.peer_access = 1,
.symmetric = 1,
.image_manipulation = 0.2,
.color_gain = 0.001,
.input = {
.min_dim = 257,
.max_dim = 257,
},
};
int i, c;
while (getopt_long_only(argc, argv, "", image_net_options, &c) != -1)
{
switch (c)
{
case 0:
exit_with_help();
case 1:
train_list = optarg;
break;
case 2:
test_list = optarg;
break;
case 3:
working_dir = optarg;
break;
case 4:
base_dir = optarg;
break;
case 5:
train_params.max_epoch = atoi(optarg);
break;
case 6:
train_params.iterations = atoi(optarg);
break;
}
}
if (!train_list || !test_list || !working_dir)
exit_with_help();
ccv_enable_default_cache();
FILE *r0 = fopen(train_list, "r");
assert(r0 && "train-list doesn't exists");
FILE* r1 = fopen(test_list, "r");
assert(r1 && "test-list doesn't exists");
char* file = (char*)malloc(1024);
int dirlen = (base_dir != 0) ? strlen(base_dir) + 1 : 0;
ccv_array_t* categorizeds = ccv_array_new(sizeof(ccv_categorized_t), 64, 0);
while (fscanf(r0, "%d %s", &c, file) != EOF)
{
char* filename = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(filename, base_dir, 1024);
filename[dirlen - 1] = '/';
}
strncpy(filename + dirlen, file, 1024 - dirlen);
ccv_file_info_t file_info = {
.filename = filename,
};
// imageNet's category class starts from 1, thus, minus 1 to get 0-index
ccv_categorized_t categorized = ccv_categorized(c - 1, 0, &file_info);
ccv_array_push(categorizeds, &categorized);
}
fclose(r0);
ccv_array_t* tests = ccv_array_new(sizeof(ccv_categorized_t), 64, 0);
while (fscanf(r1, "%d %s", &c, file) != EOF)
{
char* filename = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(filename, base_dir, 1024);
filename[dirlen - 1] = '/';
}
strncpy(filename + dirlen, file, 1024 - dirlen);
ccv_file_info_t file_info = {
.filename = filename,
};
// imageNet's category class starts from 1, thus, minus 1 to get 0-index
ccv_categorized_t categorized = ccv_categorized(c - 1, 0, &file_info);
ccv_array_push(tests, &categorized);
}
fclose(r1);
free(file);
// #define model_params vgg_d_params
#define model_params matt_c_params
int depth = sizeof(model_params) / sizeof(ccv_convnet_layer_param_t);
ccv_convnet_t* convnet = ccv_convnet_new(1, ccv_size(257, 257), model_params, depth);
if (ccv_convnet_verify(convnet, 1000) == 0)
{
ccv_convnet_layer_train_param_t layer_params[depth];
memset(layer_params, 0, sizeof(layer_params));
for (i = 0; i < depth; i++)
{
layer_params[i].w.decay = 0.0005;
layer_params[i].w.learn_rate = 0.01;
layer_params[i].w.momentum = 0.9;
layer_params[i].bias.decay = 0;
layer_params[i].bias.learn_rate = 0.01;
layer_params[i].bias.momentum = 0.9;
}
// set the two full connect layers to last with dropout rate at 0.5
for (i = depth - 3; i < depth - 1; i++)
layer_params[i].dor = 0.5;
train_params.layer_params = layer_params;
ccv_set_cli_output_levels(ccv_cli_output_level_and_above(CCV_CLI_INFO));
ccv_convnet_supervised_train(convnet, categorizeds, tests, working_dir, train_params);
} else {
PRINT(CCV_CLI_ERROR, "Invalid convnet configuration\n");
}
ccv_convnet_free(convnet);
ccv_disable_cache();
return 0;
}
int main(int argc, char** argv)
{
static struct option scd_options[] = {
/* help */
{"help", 0, 0, 0},
/* required parameters */
{"positive-list", 1, 0, 0},
{"background-list", 1, 0, 0},
{"negative-count", 1, 0, 0},
{"working-dir", 1, 0, 0},
/* optional parameters */
{0, 0, 0, 0}
};
char* positive_list = 0;
char* background_list = 0;
char* working_dir = 0;
char* base_dir = 0;
int negative_count = 0;
int k;
while (getopt_long_only(argc, argv, "", scd_options, &k) != -1)
{
switch (k)
{
case 0:
exit_with_help();
case 1:
positive_list = optarg;
break;
case 2:
background_list = optarg;
break;
case 3:
negative_count = atoi(optarg);
break;
case 4:
working_dir = optarg;
break;
case 5:
base_dir = optarg;
}
}
assert(positive_list != 0);
assert(background_list != 0);
assert(working_dir != 0);
assert(negative_count > 0);
FILE* r0 = fopen(positive_list, "r");
assert(r0 && "positive-list doesn't exists");
FILE* r1 = fopen(background_list, "r");
assert(r1 && "background-list doesn't exists");
int dirlen = (base_dir != 0) ? strlen(base_dir) + 1 : 0;
ccv_array_t* posfiles = ccv_array_new(sizeof(ccv_file_info_t), 32, 0);
char* file = (char*)malloc(1024);
size_t len = 1024;
ssize_t read;
while ((read = getline(&file, &len, r0)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
ccv_file_info_t file_info;
file_info.filename = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(file_info.filename, base_dir, 1024);
file_info.filename[dirlen - 1] = '/';
}
strncpy(file_info.filename + dirlen, file, 1024 - dirlen);
ccv_array_push(posfiles, &file_info);
}
fclose(r0);
ccv_array_t* hard_mine = (ccv_array_t*)ccv_array_new(sizeof(ccv_file_info_t), 32, 0);
while ((read = getline(&file, &len, r1)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
ccv_file_info_t file_info;
file_info.filename = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(file_info.filename, base_dir, 1024);
file_info.filename[dirlen - 1] = '/';
}
strncpy(file_info.filename + dirlen, file, 1024 - dirlen);
ccv_array_push(hard_mine, &file_info);
}
fclose(r1);
free(file);
ccv_scd_train_param_t params = {
.boosting = 10,
.size = ccv_size(48, 48),
.feature = {
.base = ccv_size(8, 8),
.range_through = 4,
.step_through = 4,
},
.stop_criteria = {
.hit_rate = 0.995,
.false_positive_rate = 0.5,
.accu_false_positive_rate = 1e-7,
.auc_crit = 1e-5,
.maximum_feature = 2048,
.prune_stage = 3,
.prune_feature = 4,
},
.weight_trimming = 0.98,
int main(int argc, char** argv)
{
static struct option bbf_options[] = {
/* help */
{"help", 0, 0, 0},
/* required parameters */
{"positive-list", 1, 0, 0},
{"background-list", 1, 0, 0},
{"working-dir", 1, 0, 0},
{"negative-count", 1, 0, 0},
{"width", 1, 0, 0},
{"height", 1, 0, 0},
/* optional parameters */
{"base-dir", 1, 0, 0},
{"layer", 1, 0, 0},
{"positive-criteria", 1, 0, 0},
{"negative-criteria", 1, 0, 0},
{"balance", 1, 0, 0},
{"feature-number", 1, 0, 0},
{0, 0, 0, 0}
};
char* positive_list = 0;
char* background_list = 0;
char* working_dir = 0;
char* base_dir = 0;
int negnum = 0;
int width = 0, height = 0;
ccv_bbf_new_param_t params = {
.pos_crit = 0.9975,
.neg_crit = 0.50,
.balance_k = 1.0,
.layer = 24,
.feature_number = 100,
.optimizer = CCV_BBF_GENETIC_OPT | CCV_BBF_FLOAT_OPT,
};
int i, k;
while (getopt_long_only(argc, argv, "", bbf_options, &k) != -1)
{
switch (k)
{
case 0:
exit_with_help();
case 1:
positive_list = optarg;
break;
case 2:
background_list = optarg;
break;
case 3:
working_dir = optarg;
break;
case 4:
negnum = atoi(optarg);
break;
case 5:
width = atoi(optarg);
break;
case 6:
height = atoi(optarg);
break;
case 7:
base_dir = optarg;
break;
case 8:
params.layer = atoi(optarg);
break;
case 9:
params.pos_crit = atof(optarg);
break;
case 10:
params.neg_crit = atof(optarg);
break;
case 11:
params.balance_k = atof(optarg);
break;
case 12:
params.feature_number = atoi(optarg);
break;
}
}
assert(positive_list != 0);
assert(background_list != 0);
assert(working_dir != 0);
assert(negnum > 0);
assert(width > 0 && height > 0);
ccv_enable_default_cache();
FILE* r0 = fopen(positive_list, "r");
assert(r0 && "positive-list doesn't exists");
FILE* r1 = fopen(background_list, "r");
assert(r1 && "background-list doesn't exists");
char* file = (char*)malloc(1024);
int dirlen = (base_dir != 0) ? strlen(base_dir) + 1 : 0;
size_t len = 1024;
ssize_t read;
int capacity = 32, size = 0;
ccv_dense_matrix_t** posimg = (ccv_dense_matrix_t**)ccmalloc(sizeof(ccv_dense_matrix_t*) * capacity);
while ((read = getline(&file, &len, r0)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
char* posfile = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(posfile, base_dir, 1024);
posfile[dirlen - 1] = '/';
}
strncpy(posfile + dirlen, file, 1024 - dirlen);
posimg[size] = 0;
ccv_read(posfile, &posimg[size], CCV_IO_GRAY | CCV_IO_ANY_FILE);
if (posimg != 0)
{
++size;
if (size >= capacity)
{
capacity *= 2;
posimg = (ccv_dense_matrix_t**)ccrealloc(posimg, sizeof(ccv_dense_matrix_t*) * capacity);
}
}
}
fclose(r0);
int posnum = size;
capacity = 32;
size = 0;
char** bgfiles = (char**)ccmalloc(sizeof(char*) * capacity);
while ((read = getline(&file, &len, r1)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
bgfiles[size] = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(bgfiles[size], base_dir, 1024);
bgfiles[size][dirlen - 1] = '/';
}
strncpy(bgfiles[size] + dirlen, file, 1024 - dirlen);
++size;
if (size >= capacity)
{
capacity *= 2;
bgfiles = (char**)ccrealloc(bgfiles, sizeof(char*) * capacity);
}
}
fclose(r1);
int bgnum = size;
free(file);
ccv_bbf_classifier_cascade_new(posimg, posnum, bgfiles, bgnum, negnum, ccv_size(width, height), working_dir, params);
for (i = 0; i < bgnum; i++)
free(bgfiles[i]);
for (i = 0; i < posnum; i++)
ccv_matrix_free(&posimg[i]);
free(posimg);
free(bgfiles);
ccv_disable_cache();
return 0;
}
.partition = 1,
},
.node = {
.count = 4096,
},
},
.output = {
.full_connect = {
.relu = 0,
.count = 1000,
},
},
},
};
*/
ccv_convnet_t* convnet = ccv_convnet_new(1, ccv_size(225, 225), params, sizeof(params) / sizeof(ccv_convnet_layer_param_t));
ccv_convnet_verify(convnet, 1000);
ccv_convnet_layer_train_param_t layer_params[13];
memset(layer_params, 0, sizeof(layer_params));
int i;
for (i = 0; i < 13; i++)
{
layer_params[i].w.decay = 0.005;
layer_params[i].w.learn_rate = 0.0005;
layer_params[i].w.momentum = 0.9;
layer_params[i].bias.decay = 0;
layer_params[i].bias.learn_rate = 0.001;
layer_params[i].bias.momentum = 0.9;
}
ccv_convnet_train_param_t train_params = {
.max_epoch = 100,
int main(int argc, char** argv)
{
static struct option icf_options[] = {
/* help */
{"help", 0, 0, 0},
/* required parameters */
{"positive-list", 1, 0, 0},
{"background-list", 1, 0, 0},
{"validate-list", 1, 0, 0},
{"working-dir", 1, 0, 0},
{"negative-count", 1, 0, 0},
{"positive-count", 1, 0, 0},
{"acceptance", 1, 0, 0},
{"size", 1, 0, 0},
{"feature-size", 1, 0, 0},
{"weak-classifier-count", 1, 0, 0},
/* optional parameters */
{"base-dir", 1, 0, 0},
{"grayscale", 1, 0, 0},
{"margin", 1, 0, 0},
{"deform-shift", 1, 0, 0},
{"deform-angle", 1, 0, 0},
{"deform-scale", 1, 0, 0},
{"min-dimension", 1, 0, 0},
{"bootstrap", 1, 0, 0},
{0, 0, 0, 0}
};
char* positive_list = 0;
char* background_list = 0;
char* validate_list = 0;
char* working_dir = 0;
char* base_dir = 0;
int negative_count = 0;
int positive_count = 0;
ccv_icf_new_param_t params = {
.grayscale = 0,
.margin = ccv_margin(0, 0, 0, 0),
.size = ccv_size(0, 0),
.deform_shift = 1,
.deform_angle = 0,
.deform_scale = 0.075,
.feature_size = 0,
.weak_classifier = 0,
.min_dimension = 2,
.bootstrap = 3,
.detector = ccv_icf_default_params,
};
params.detector.step_through = 4; // for faster negatives bootstrap time
int i, k;
char* token;
char* saveptr;
while (getopt_long_only(argc, argv, "", icf_options, &k) != -1)
{
switch (k)
{
case 0:
exit_with_help();
case 1:
positive_list = optarg;
break;
case 2:
background_list = optarg;
break;
case 3:
validate_list = optarg;
break;
case 4:
working_dir = optarg;
break;
case 5:
negative_count = atoi(optarg);
break;
case 6:
positive_count = atoi(optarg);
break;
case 7:
params.acceptance = atof(optarg);
break;
case 8:
token = strtok_r(optarg, "x", &saveptr);
params.size.width = atoi(token);
token = strtok_r(0, "x", &saveptr);
params.size.height = atoi(token);
break;
case 9:
params.feature_size = atoi(optarg);
break;
case 10:
params.weak_classifier = atoi(optarg);
break;
case 11:
base_dir = optarg;
break;
case 12:
params.grayscale = !!atoi(optarg);
break;
case 13:
token = strtok_r(optarg, ",", &saveptr);
params.margin.left = atoi(token);
token = strtok_r(0, ",", &saveptr);
params.margin.top = atoi(token);
token = strtok_r(0, ",", &saveptr);
params.margin.right = atoi(token);
token = strtok_r(0, ",", &saveptr);
params.margin.bottom = atoi(token);
break;
case 14:
params.deform_shift = atof(optarg);
break;
case 15:
params.deform_angle = atof(optarg);
break;
case 16:
params.deform_scale = atof(optarg);
break;
case 17:
params.min_dimension = atoi(optarg);
break;
case 18:
params.bootstrap = atoi(optarg);
break;
}
}
assert(positive_list != 0);
assert(background_list != 0);
assert(validate_list != 0);
assert(working_dir != 0);
assert(positive_count > 0);
assert(negative_count > 0);
assert(params.size.width > 0);
assert(params.size.height > 0);
ccv_enable_cache(512 * 1024 * 1024);
FILE* r0 = fopen(positive_list, "r");
assert(r0 && "positive-list doesn't exists");
FILE* r1 = fopen(background_list, "r");
assert(r1 && "background-list doesn't exists");
FILE* r2 = fopen(validate_list, "r");
assert(r2 && "validate-list doesn't exists");
char* file = (char*)malloc(1024);
ccv_decimal_pose_t pose;
int dirlen = (base_dir != 0) ? strlen(base_dir) + 1 : 0;
ccv_array_t* posfiles = ccv_array_new(sizeof(ccv_file_info_t), 32, 0);
// roll pitch yaw
while (fscanf(r0, "%s %f %f %f %f %f %f %f", file, &pose.x, &pose.y, &pose.a, &pose.b, &pose.roll, &pose.pitch, &pose.yaw) != EOF)
{
ccv_file_info_t file_info;
file_info.filename = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(file_info.filename, base_dir, 1024);
file_info.filename[dirlen - 1] = '/';
}
strncpy(file_info.filename + dirlen, file, 1024 - dirlen);
file_info.pose = pose;
ccv_array_push(posfiles, &file_info);
}
fclose(r0);
size_t len = 1024;
ssize_t read;
ccv_array_t* bgfiles = (ccv_array_t*)ccv_array_new(sizeof(ccv_file_info_t), 32, 0);
while ((read = getline(&file, &len, r1)) != -1)
{
while(read > 1 && isspace(file[read - 1]))
read--;
file[read] = 0;
ccv_file_info_t file_info;
file_info.filename = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(file_info.filename, base_dir, 1024);
file_info.filename[dirlen - 1] = '/';
}
strncpy(file_info.filename + dirlen, file, 1024 - dirlen);
ccv_array_push(bgfiles, &file_info);
}
fclose(r1);
ccv_array_t* validatefiles = ccv_array_new(sizeof(ccv_file_info_t), 32, 0);
// roll pitch yaw
while (fscanf(r2, "%s %f %f %f %f %f %f %f", file, &pose.x, &pose.y, &pose.a, &pose.b, &pose.roll, &pose.pitch, &pose.yaw) != EOF)
{
ccv_file_info_t file_info;
file_info.filename = (char*)ccmalloc(1024);
if (base_dir != 0)
{
strncpy(file_info.filename, base_dir, 1024);
file_info.filename[dirlen - 1] = '/';
}
strncpy(file_info.filename + dirlen, file, 1024 - dirlen);
file_info.pose = pose;
ccv_array_push(validatefiles, &file_info);
}
fclose(r2);
free(file);
ccv_icf_classifier_cascade_t* classifier = ccv_icf_classifier_cascade_new(posfiles, positive_count, bgfiles, negative_count, validatefiles, working_dir, params);
char filename[1024];
snprintf(filename, 1024, "%s/final-cascade", working_dir);
ccv_icf_write_classifier_cascade(classifier, filename);
for (i = 0; i < posfiles->rnum; i++)
{
ccv_file_info_t* file_info = (ccv_file_info_t*)ccv_array_get(posfiles, i);
free(file_info->filename);
}
ccv_array_free(posfiles);
for (i = 0; i < bgfiles->rnum; i++)
{
ccv_file_info_t* file_info = (ccv_file_info_t*)ccv_array_get(bgfiles, i);
free(file_info->filename);
}
ccv_array_free(bgfiles);
for (i = 0; i < validatefiles->rnum; i++)
{
ccv_file_info_t* file_info = (ccv_file_info_t*)ccv_array_get(validatefiles, i);
free(file_info->filename);
}
ccv_array_free(validatefiles);
ccv_disable_cache();
return 0;
}
