void predict_move(network net, float *board, float *move, int multi)
{
float *output = network_predict(net, board);
copy_cpu(19*19, output, 1, move, 1);
int i;
if(multi){
image bim = float_to_image(19, 19, 1, board);
for(i = 1; i < 8; ++i){
rotate_image_cw(bim, i);
if(i >= 4) flip_image(bim);
float *output = network_predict(net, board);
image oim = float_to_image(19, 19, 1, output);
if(i >= 4) flip_image(oim);
rotate_image_cw(oim, -i);
axpy_cpu(19*19, 1, output, 1, move, 1);
if(i >= 4) flip_image(bim);
rotate_image_cw(bim, -i);
}
scal_cpu(19*19, 1./8., move, 1);
}
for(i = 0; i < 19*19; ++i){
if(board[i]) move[i] = 0;
}
}
void enc_astc_file(char* filename, char* dst_filename)
{
rgba_surface src_img;
load_bmp(&src_img, filename);
flip_image(&src_img);
int block_width = 6;
int block_height = 6;
rgba_surface output_tex;
output_tex.width = idiv_ceil(src_img.width, block_width);
output_tex.height = idiv_ceil(src_img.height, block_height);
output_tex.stride = output_tex.width * 16;
output_tex.ptr = (uint8_t*)malloc(output_tex.height * output_tex.stride);
rgba_surface edged_img;
fill_borders(&edged_img, &src_img, block_width, block_height);
printf("encoding <%s>...", filename);
compress_astc_tex(&output_tex, &edged_img, block_width, block_height);
printf("done.\n");
output_tex.width = src_img.width;
output_tex.height = src_img.height;
store_astc(&output_tex, block_width, block_height, dst_filename);
}
void test_cifar_csvtrain(char *filename, char *weightfile)
{
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
data test = load_all_cifar10();
matrix pred = network_predict_data(net, test);
int i;
for(i = 0; i < test.X.rows; ++i){
image im = float_to_image(32, 32, 3, test.X.vals[i]);
flip_image(im);
}
matrix pred2 = network_predict_data(net, test);
scale_matrix(pred, .5);
scale_matrix(pred2, .5);
matrix_add_matrix(pred2, pred);
matrix_to_csv(pred);
fprintf(stderr, "Accuracy: %f\n", matrix_topk_accuracy(test.y, pred, 1));
free_data(test);
}
void test_mnist_csv(char *filename, char *weightfile)
{
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
data test;
test = load_mnist_data("data/mnist/t10k-images.idx3-ubyte", "data/mnist/t10k-labels.idx1-ubyte", 10000);
matrix pred = network_predict_data(net, test);
int i;
for(i = 0; i < test.X.rows; ++i){
image im = float_to_image(32, 32, 3, test.X.vals[i]);
flip_image(im);
}
matrix pred2 = network_predict_data(net, test);
scale_matrix(pred, .5);
scale_matrix(pred2, .5);
matrix_add_matrix(pred2, pred);
matrix_to_csv(pred);
fprintf(stderr, "Accuracy: %f\n", matrix_topk_accuracy(test.y, pred, 1));
free_data(test);
}
void test_cifar_multi(char *filename, char *weightfile)
{
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(time(0));
float avg_acc = 0;
data test = load_cifar10_data("data/cifar/cifar-10-batches-bin/test_batch.bin");
int i;
for(i = 0; i < test.X.rows; ++i){
image im = float_to_image(32, 32, 3, test.X.vals[i]);
float pred[10] = {0};
float *p = network_predict(net, im.data);
axpy_cpu(10, 1, p, 1, pred, 1);
flip_image(im);
p = network_predict(net, im.data);
axpy_cpu(10, 1, p, 1, pred, 1);
int index = max_index(pred, 10);
int class = max_index(test.y.vals[i], 10);
if(index == class) avg_acc += 1;
free_image(im);
printf("%4d: %.2f%%\n", i, 100.*avg_acc/(i+1));
}
}
void random_go_moves(moves m, float *boards, float *labels, int n)
{
int i;
memset(labels, 0, 19*19*n*sizeof(float));
for(i = 0; i < n; ++i){
char *b = m.data[rand()%m.n];
int row = b[0];
int col = b[1];
labels[col + 19*(row + i*19)] = 1;
string_to_board(b+2, boards+i*19*19);
boards[col + 19*(row + i*19)] = 0;
int flip = rand()%2;
int rotate = rand()%4;
image in = float_to_image(19, 19, 1, boards+i*19*19);
image out = float_to_image(19, 19, 1, labels+i*19*19);
if(flip){
flip_image(in);
flip_image(out);
}
rotate_image_cw(in, rotate);
rotate_image_cw(out, rotate);
}
}
void optimize_picture(network *net, image orig, int max_layer, float scale, float rate, float thresh, int norm)
{
//scale_image(orig, 2);
//translate_image(orig, -1);
net->n = max_layer + 1;
int dx = rand()%16 - 8;
int dy = rand()%16 - 8;
int flip = rand()%2;
image crop = crop_image(orig, dx, dy, orig.w, orig.h);
image im = resize_image(crop, (int)(orig.w * scale), (int)(orig.h * scale));
if(flip) flip_image(im);
resize_network(net, im.w, im.h);
layer_t last = net->layers[net->n-1];
//net->layers[net->n - 1].activation = LINEAR;
image delta = make_image(im.w, im.h, im.c);
NETWORK_STATE(state);
#ifdef GPU
state.input = cuda_make_array(im.data, im.w*im.h*im.c);
state.delta = cuda_make_array(im.data, im.w*im.h*im.c);
forward_network_gpu(*net, state);
copy_ongpu(last.outputs, last.output_gpu, 1, last.delta_gpu, 1);
cuda_pull_array(last.delta_gpu, last.delta, last.outputs);
calculate_loss(last.delta, last.delta, last.outputs, thresh);
cuda_push_array(last.delta_gpu, last.delta, last.outputs);
backward_network_gpu(*net, state);
cuda_pull_array(state.delta, delta.data, im.w*im.h*im.c);
cuda_free(state.input);
cuda_free(state.delta);
#else
state.input = im.data;
state.delta = delta.data;
forward_network(*net, state);
fltcpy(last.delta, last.output, last.outputs);
calculate_loss(last.output, last.delta, last.outputs, thresh);
backward_network(*net, state);
#endif
if(flip) flip_image(delta);
//normalize_array(delta.data, delta.w*delta.h*delta.c);
image resized = resize_image(delta, orig.w, orig.h);
image out = crop_image(resized, -dx, -dy, orig.w, orig.h);
/*
image g = grayscale_image(out);
free_image(out);
out = g;
*/
//rate = rate / abs_mean(out.data, out.w*out.h*out.c);
if(norm) normalize_array(out.data, out.w*out.h*out.c);
fltaddmul(orig.data, out.data, orig.w * orig.h * orig.c, rate);
/*
normalize_array(orig.data, orig.w*orig.h*orig.c);
scale_image(orig, sqrt(var));
translate_image(orig, mean);
*/
//translate_image(orig, 1);
//scale_image(orig, .5);
//normalize_image(orig);
constrain_image(orig);
free_image(crop);
free_image(im);
free_image(delta);
free_image(resized);
free_image(out);
}
int main( int argc, char** argv ) {
int ikey=0;
char key;
IplImage *imCapt,*imDisp,*imDisp2;
static int tb1_val,tb2_val; /* Trackbar parameters */
timewin *tw;
buffer *bf_img;
bbuffer *bf_blobs;
int width,height;
if(kb_lowresfl) {
width=320;
height=240;
} else {
width=640;
height=480;
}
/* Set window title to a list of control keys */
const char *window1 = "Controls: (n)eighbours, (d)istance, (b)lur type, (h)igh-res, (c)olourspace, (r)eset, (ESC) exit";
const char *trackbar1 = "margin";
const char *trackbar2 = "timesteps";
int fno;
cvInitSystem( argc,argv );
/* Get an OpenCV camera handle */
cam = cvCreateCameraCapture(0);
/* Set size of image (appears to be ignored in Linux) */
cvSetCaptureProperty(cam, CV_CAP_PROP_FRAME_WIDTH, width);
cvSetCaptureProperty(cam, CV_CAP_PROP_FRAME_HEIGHT, height);
/* Create a window with slider */
cvNamedWindow(window1, CV_WINDOW_AUTOSIZE);
cvSetMouseCallback(window1,callback_mouse, NULL );
tb_margin = DEF_MARGIN; /* Default */
tb1_val=tb_margin/TB1_SCALE*TB1_MAX;
cvCreateTrackbar(trackbar1,window1,&tb1_val,TB1_MAX,callback_trackbar1);
tb2_val = tb_timesteps = DEF_TIMESTEPS; /* Default */
cvCreateTrackbar(trackbar2,window1,&tb2_val,TB2_MAX,callback_trackbar2);
cvMoveWindow(window1, 100, 45);
/* Allocate image buffers */
if(kb_lowresfl)
imDisp2 = cvCreateImage( cvSize(width*4,height*2), IPL_DEPTH_8U, 3);
else
imDisp2 = cvCreateImage( cvSize(width*2,height), IPL_DEPTH_8U, 3);
imDisp = cvCreateImage( cvSize(width*2,height), IPL_DEPTH_8U, 3);
bf_img = buffer_new(height,width,3);
bf_blobs = bbuffer_new(height,width,3);
tw=timewin_new(DEF_TIMESIZE);
fno=0;
key=(char)cvWaitKey(500);
while ( key !=27 ) {
imCapt = cvQueryFrame(cam);
buffer_iplcopy(bf_img,imCapt,1);
/* Detect blobs */
detect_and_render_blobs(bf_img,bf_blobs);
/* Display result */
flip_image(imCapt,imDisp);
paste_image(imDisp,bf_blobs,width);
if(kb_lowresfl) {
upsample_image(imDisp,imDisp2);
cvShowImage(window1, imDisp2);
} else {
cvShowImage(window1, imDisp);
}
ikey=cvWaitKey(5); /* Needed for highgui event processing */
if(ikey>0) {
key=(char)ikey;
if(key == 'n') {
kb_n8flag=1-kb_n8flag;
printf("n8flag=%d\n",kb_n8flag);
}
if(key == 'd') {
kb_normfl=1-kb_normfl;
printf("normfl=%d\n",kb_normfl);
}
if(key == 'b') {
kb_blurfl=1-kb_blurfl;
printf("blurfl=%d\n",kb_blurfl);
}
if(key =='c') {
kb_cspace=1-kb_cspace; /* Toggle colourspace */
printf("cspace=%d\n",kb_cspace);
}
if(key == 'r') {
tb_margin=DEF_MARGIN; /* Reset to default */
tb1_val=tb_margin/TB1_SCALE*TB1_MAX;
cvSetTrackbarPos(trackbar1,window1,tb1_val);
tb2_val=tb_timesteps=DEF_TIMESTEPS; /* Reset to default */
cvSetTrackbarPos(trackbar2,window1,tb2_val);
kb_n8flag=DEF_N8FLAG;
kb_normfl=DEF_NORMFL;
kb_blurfl=DEF_BLURFL;
printf("timesteps =%d\n",tb_timesteps);
printf("min_margin=%g\n",tb_margin);
printf("n8flag=%d\n",kb_n8flag);
printf("normfl=%d\n",kb_normfl);
printf("blurfl=%d\n",kb_blurfl);
cvWaitKey(1);
/* printf("tb1:%d\n",cvGetTrackbarPos(trackbar1,window1)); */
/* printf("tb2:%d\n",cvGetTrackbarPos(trackbar2,window1)); */
}
if(key == 'h') {
kb_lowresfl=1-kb_lowresfl; /* Toggle resolution */
if(kb_lowresfl) {
width=320;
height=240;
} else {
width=640;
height=480;
}
cvReleaseCapture(&cam);
cam = cvCreateCameraCapture(0);
/* Set size of image */
cvSetCaptureProperty(cam, CV_CAP_PROP_FRAME_WIDTH, width);
cvSetCaptureProperty(cam, CV_CAP_PROP_FRAME_HEIGHT, height);
/* Free image buffers */
cvReleaseImage( &imDisp );
buffer_free(bf_img);
bbuffer_free(bf_blobs);
/* Allocate image buffers */
imDisp = cvCreateImage( cvSize(width*2,height), IPL_DEPTH_8U, 3);
bf_img = buffer_new(height,width,3);
bf_blobs = bbuffer_new(height,width,3);
}
}
timewin_addtime(tw);
fno++;
if((fno%DEF_TIMESIZE)==0) printf("Frame rate %g Hz\n",timewin_rate(tw));
}
/* Clean up */
timewin_free(tw);
buffer_free(bf_img);
bbuffer_free(bf_blobs);
cvDestroyAllWindows();
cvReleaseCapture(&cam);
return 0;
}
void test_go(char *filename, char *weightfile, int multi)
{
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
set_batch_network(&net, 1);
float *board = calloc(19*19, sizeof(float));
float *move = calloc(19*19, sizeof(float));
int color = 1;
while(1){
float *output = network_predict(net, board);
fltcpy(move, output, 19 * 19);
int i;
if(multi){
image bim = float_to_image(19, 19, 1, board);
for(i = 1; i < 8; ++i){
rotate_image_cw(bim, i);
if(i >= 4) flip_image(bim);
float *output = network_predict(net, board);
image oim = float_to_image(19, 19, 1, output);
if(i >= 4) flip_image(oim);
rotate_image_cw(oim, -i);
fltadd(move, output, 19 * 19);
if(i >= 4) flip_image(bim);
rotate_image_cw(bim, -i);
}
scal_cpu(19*19, 1./8., move, 1);
}
for(i = 0; i < 19*19; ++i){
if(board[i]) move[i] = 0;
}
int indexes[nind];
int row, col;
top_k(move, 19*19, nind, indexes);
print_board(board, color, indexes);
for(i = 0; i < nind; ++i){
int index = indexes[i];
row = index / 19;
col = index % 19;
printf("%d: %c %d, %.2f%%\n", i+1, col + 'A' + 1*(col > 7 && noi), (inverted)?19 - row : row+1, move[index]*100);
}
if(color == 1) printf("\u25EF Enter move: ");
else printf("\u25C9 Enter move: ");
char c;
char *line = fgetl(stdin);
int picked = 1;
int dnum = sscanf(line, "%d", &picked);
int cnum = sscanf(line, "%c", &c);
if (strlen(line) == 0 || dnum) {
--picked;
if (picked < nind){
int index = indexes[picked];
row = index / 19;
col = index % 19;
board[row*19 + col] = 1;
}
} else if (cnum){
if (c <= 'T' && c >= 'A'){
int num = sscanf(line, "%c %d", &c, &row);
row = (inverted)?19 - row : row-1;
col = c - 'A';
if (col > 7 && noi) col -= 1;
if (num == 2) board[row*19 + col] = 1;
} else if (c == 'p') {
// Pass
} else if(c=='b' || c == 'w'){
char g;
int num = sscanf(line, "%c %c %d", &g, &c, &row);
row = (inverted)?19 - row : row-1;
col = c - 'A';
if (col > 7 && noi) col -= 1;
if (num == 3) board[row*19 + col] = (g == 'b') ? color : -color;
} else if(c == 'c'){
char g;
int num = sscanf(line, "%c %c %d", &g, &c, &row);
row = (inverted)?19 - row : row-1;
col = c - 'A';
if (col > 7 && noi) col -= 1;
if (num == 3) board[row*19 + col] = 0;
}
}
free(line);
update_board(board);
flip_board(board);
color = -color;
}
}
void train_go(char *cfgfile, char *weightfile)
{
data_seed = time(0);
srand(time(0));
float avg_loss = -1;
char *base = basecfg(cfgfile);
printf("%s\n", base);
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
printf("Learning Rate: %g, Momentum: %g, Decay: %g\n", net.learning_rate, net.momentum, net.decay);
char *backup_directory = "/home/pjreddie/backup/";
char buff[256];
sprintf(buff, "/home/pjreddie/go.train.%02d", rand()%10);
data train = load_go(buff);
int N = train.X.rows;
int epoch = (*net.seen)/N;
while(get_current_batch(net) < net.max_batches || net.max_batches == 0){
clock_t time=clock();
data batch = get_random_data(train, net.batch);
int i;
for(i = 0; i < batch.X.rows; ++i){
int flip = rand()%2;
int rotate = rand()%4;
image in = float_to_image(19, 19, 1, batch.X.vals[i]);
image out = float_to_image(19, 19, 1, batch.y.vals[i]);
//show_image_normalized(in, "in");
//show_image_normalized(out, "out");
if(flip){
flip_image(in);
flip_image(out);
}
rotate_image_cw(in, rotate);
rotate_image_cw(out, rotate);
//show_image_normalized(in, "in2");
//show_image_normalized(out, "out2");
//cvWaitKey(0);
}
float loss = train_network(net, batch);
free_data(batch);
if(avg_loss == -1) avg_loss = loss;
avg_loss = avg_loss*.95 + loss*.05;
printf("%d, %.3f: %f, %f avg, %f rate, %lf seconds, %d images\n", get_current_batch(net), (float)(*net.seen)/N, loss, avg_loss, get_current_rate(net), sec(clock()-time), *net.seen);
if(*net.seen/N > epoch){
epoch = *net.seen/N;
char buff[256];
sprintf(buff, "%s/%s_%d.weights",backup_directory,base, epoch);
save_weights(net, buff);
free_data(train);
sprintf(buff, "/home/pjreddie/go.train.%02d", epoch%10);
train = load_go(buff);
}
if(get_current_batch(net)%100 == 0){
char buff[256];
sprintf(buff, "%s/%s.backup",backup_directory,base);
save_weights(net, buff);
}
}
sprintf(buff, "%s/%s.weights", backup_directory, base);
save_weights(net, buff);
free_network(net);
free(base);
free_data(train);
}
void process_1_image (args cli_flags, char *files) {
char *out_file_name = get_out_filename (files, cli_flags);
if (file_exists (out_file_name)) {
printf ("| Output file %s already exists. skipping... ", out_file_name);
return;
}
// Origional Image Properties struct
img_prop o = (img_prop) malloc (sizeof (image_properties));
// set all the vales in the imapg properties struct to -1
null_ip (o);
// Create a data provider
CGDataProviderRef source_image_provider = CGDataProviderCreateWithFilename (files);
// Check for a null returned value
if (source_image_provider == NULL) {
// something went wrong
printf ("error: Couldn't create CGDataProvider from URL.\n");
exit (0);
}
// get the information from the image exif here
o->image_rot = get_exif_rot (source_image_provider);
// Create the image in memory from the JPEG data
CGImageRef source_image = CGImageCreateWithJPEGDataProvider (source_image_provider, NULL, no, kCGRenderingIntentDefault);
/********************************************/
/* Getting the colour space **/
o->colorSpace = CGImageGetColorSpace(source_image);
/********************************************/
// populate the image info struct
pop_img_props (source_image, o);
// create a data provider from the decoded JPEG data
CGDataProviderRef image_data_provider = CGImageGetDataProvider (source_image);
// Create a pointer to the data section of the image in memory
CFDataRef source_data_ptr = CGDataProviderCopyData (image_data_provider);
// The vImage_Buffers we will use
vImage_Buffer *vImage_source = (vImage_Buffer*) malloc (sizeof (vImage_Buffer));
// Check for NULL
if (NULL == vImage_source) {
printf ("Cannot malloc vImage_source buffer\n");
exit (0);
}
if (o->bits_ppixel == 24) {
// convert from 24bit to 32bit by adding the alpha channel.
source_data_ptr = convert24_32bit (source_data_ptr, o);
}
// Setup the vImage Buffer for the image
setupBuffer (vImage_source, o->image_h, o->image_w, o->bytes_row);
// Assign the data to the vImage Buffer for the source
vImage_source->data = (void *) CFDataGetBytePtr (source_data_ptr);
// Check for NULL
if (vImage_source->data == NULL)
printf ("Unable to get the vimage.data pointer\n");
if (o->image_rot != 1 && o->image_rot != 4 && o->image_rot != 2) // rotate the image
rotate_image (vImage_source, o, NULL);
// flip the image
if (o->image_rot == 2 || o->image_rot == 4 || o->image_rot == 7 || o->image_rot == 5)
flip_image (vImage_source, o, NULL);
// Resize the images
resize_image (vImage_source, o, cli_flags);
// Create a colour space to be compared against
CGColorSpaceRef rgb = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
if (NULL == rgb) {
fprintf(stderr, "Unable to create the reference colourspace.\n");
exit(0);
}
// Convert the colourspace to RGB
if (!CFEqual(rgb, o->colorSpace) && !cli_flags->disableCC) {
vImage_source->data = convert_space(vImage_source->data, o->image_w, o->image_h);
if (NULL == vImage_source->data) exit(0);
}
// release the reference colour space
CGColorSpaceRelease(rgb);
// save the image
save_image (vImage_source, o, cli_flags->quality, out_file_name);
// Release the source provider
CGDataProviderRelease (source_image_provider);
source_image_provider = NULL;
// Release the source image
CGImageRelease (source_image);
source_image = NULL;
free(source_data_ptr);
// Free the filename created by get_out_filename ()
free (out_file_name);
out_file_name = NULL;
// free the image properties
free (o);
o = NULL;
// if there is info in the buffer
if (vImage_source->data != NULL) {
free (vImage_source->data);
vImage_source->data = NULL;
}
// free the buffer
free (vImage_source);
vImage_source = NULL;
} // Process 1 image
void validate_classifier_multi(char *datacfg, char *cfg, char *weights)
{
int i, j;
network *net = load_network(cfg, weights, 0);
set_batch_network(net, 1);
srand(time(0));
list *options = read_data_cfg(datacfg);
char *label_list = option_find_str(options, "labels", "data/labels.list");
char *valid_list = option_find_str(options, "valid", "data/train.list");
int classes = option_find_int(options, "classes", 2);
int topk = option_find_int(options, "top", 1);
char **labels = get_labels(label_list);
list *plist = get_paths(valid_list);
//int scales[] = {224, 288, 320, 352, 384};
int scales[] = {224, 256, 288, 320};
int nscales = sizeof(scales)/sizeof(scales[0]);
char **paths = (char **)list_to_array(plist);
int m = plist->size;
free_list(plist);
float avg_acc = 0;
float avg_topk = 0;
int *indexes = calloc(topk, sizeof(int));
for(i = 0; i < m; ++i){
int class = -1;
char *path = paths[i];
for(j = 0; j < classes; ++j){
if(strstr(path, labels[j])){
class = j;
break;
}
}
float *pred = calloc(classes, sizeof(float));
image im = load_image_color(paths[i], 0, 0);
for(j = 0; j < nscales; ++j){
image r = resize_max(im, scales[j]);
resize_network(net, r.w, r.h);
float *p = network_predict(net, r.data);
if(net->hierarchy) hierarchy_predictions(p, net->outputs, net->hierarchy, 1 , 1);
axpy_cpu(classes, 1, p, 1, pred, 1);
flip_image(r);
p = network_predict(net, r.data);
axpy_cpu(classes, 1, p, 1, pred, 1);
if(r.data != im.data) free_image(r);
}
free_image(im);
top_k(pred, classes, topk, indexes);
free(pred);
if(indexes[0] == class) avg_acc += 1;
for(j = 0; j < topk; ++j){
if(indexes[j] == class) avg_topk += 1;
}
printf("%d: top 1: %f, top %d: %f\n", i, avg_acc/(i+1), topk, avg_topk/(i+1));
}
}
void validate_classifier_10(char *datacfg, char *filename, char *weightfile)
{
int i, j;
network *net = load_network(filename, weightfile, 0);
set_batch_network(net, 1);
srand(time(0));
list *options = read_data_cfg(datacfg);
char *label_list = option_find_str(options, "labels", "data/labels.list");
char *valid_list = option_find_str(options, "valid", "data/train.list");
int classes = option_find_int(options, "classes", 2);
int topk = option_find_int(options, "top", 1);
char **labels = get_labels(label_list);
list *plist = get_paths(valid_list);
char **paths = (char **)list_to_array(plist);
int m = plist->size;
free_list(plist);
float avg_acc = 0;
float avg_topk = 0;
int *indexes = calloc(topk, sizeof(int));
for(i = 0; i < m; ++i){
int class = -1;
char *path = paths[i];
for(j = 0; j < classes; ++j){
if(strstr(path, labels[j])){
class = j;
break;
}
}
int w = net->w;
int h = net->h;
int shift = 32;
image im = load_image_color(paths[i], w+shift, h+shift);
image images[10];
images[0] = crop_image(im, -shift, -shift, w, h);
images[1] = crop_image(im, shift, -shift, w, h);
images[2] = crop_image(im, 0, 0, w, h);
images[3] = crop_image(im, -shift, shift, w, h);
images[4] = crop_image(im, shift, shift, w, h);
flip_image(im);
images[5] = crop_image(im, -shift, -shift, w, h);
images[6] = crop_image(im, shift, -shift, w, h);
images[7] = crop_image(im, 0, 0, w, h);
images[8] = crop_image(im, -shift, shift, w, h);
images[9] = crop_image(im, shift, shift, w, h);
float *pred = calloc(classes, sizeof(float));
for(j = 0; j < 10; ++j){
float *p = network_predict(net, images[j].data);
if(net->hierarchy) hierarchy_predictions(p, net->outputs, net->hierarchy, 1, 1);
axpy_cpu(classes, 1, p, 1, pred, 1);
free_image(images[j]);
}
free_image(im);
top_k(pred, classes, topk, indexes);
free(pred);
if(indexes[0] == class) avg_acc += 1;
for(j = 0; j < topk; ++j){
if(indexes[j] == class) avg_topk += 1;
}
printf("%d: top 1: %f, top %d: %f\n", i, avg_acc/(i+1), topk, avg_topk/(i+1));
}
}
void validate_classifier_multi(char *datacfg, char *filename, char *weightfile)
{
int i, j;
network net = parse_network_cfg(filename);
set_batch_network(&net, 1);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
list *options = read_data_cfg(datacfg);
char *label_list = option_find_str(options, "labels", "data/labels.list");
char *valid_list = option_find_str(options, "valid", "data/train.list");
int classes = option_find_int(options, "classes", 2);
int topk = option_find_int(options, "top", 1);
char **labels = get_labels(label_list);
list *plist = get_paths(valid_list);
int scales[] = {192, 224, 288, 320, 352};
int nscales = sizeof(scales)/sizeof(scales[0]);
char **paths = (char **)list_to_array(plist);
int m = plist->size;
free_list(plist);
float avg_acc = 0;
float avg_topk = 0;
int *indexes = calloc(topk, sizeof(int));
for(i = 0; i < m; ++i){
int class = -1;
char *path = paths[i];
for(j = 0; j < classes; ++j){
if(strstr(path, labels[j])){
class = j;
break;
}
}
float *pred = calloc(classes, sizeof(float));
image im = load_image_color(paths[i], 0, 0);
for(j = 0; j < nscales; ++j){
image r = resize_min(im, scales[j]);
resize_network(&net, r.w, r.h);
float *p = network_predict(net, r.data);
fltadd(pred, p, classes);
flip_image(r);
p = network_predict(net, r.data);
fltadd(pred, p, classes);
free_image(r);
}
free_image(im);
top_k(pred, classes, topk, indexes);
free(pred);
if(indexes[0] == class) avg_acc += 1;
for(j = 0; j < topk; ++j){
if(indexes[j] == class) avg_topk += 1;
}
printf("%d: top 1: %f, top %d: %f\n", i, avg_acc/(i+1), topk, avg_topk/(i+1));
}
}
Image* ImageSerializer_xpm::read_xpm_2_bytes_per_pixel(
int width, int height, int num_colors, std::istream& stream
) {
// Converts a two-digit XPM color code into
// a color index.
static int conv_table[256][256] ;
// For checking, put a negative value to
// detect invalid color codes.
for(int k1=0; k1 < 256; k1++) {
for(int k2=0; k2 < 256; k2++) {
conv_table[k1][k2] = -1 ;
}
}
// _______________________ colormap
typedef Numeric::uint8 byte ;
Colormap* colormap = new Colormap(num_colors) ;
for(int entry_num=0; entry_num<num_colors; entry_num++) {
char* entry = next_xpm_data(stream) ;
if(entry == nil) {
Logger::err("Image")
<< "XPM Image reader: Unexpected end of file"
<< std::endl ;
delete colormap ;
return nil ;
}
int key1 = entry[0] ;
int key2 = entry[1] ;
char* colorcode = (char*)strstr(entry, "c #") ;
if(colorcode == NULL) {
if(strstr(entry, "None") != NULL) {
colorcode = (char*)"c #000000" ;
} else {
Logger::err("Image")
<< "XPM Image reader: Colormap entry without any color"
<< std::endl ;
Logger::err("Image")
<< " entry = \'" << entry << "\'" << std::endl ;
return nil ;
}
}
colorcode += 3 ;
byte r = byte(16 * htoi(colorcode[0]) + htoi(colorcode[1])) ;
byte g = byte(16 * htoi(colorcode[2]) + htoi(colorcode[3])) ;
byte b = byte(16 * htoi(colorcode[4]) + htoi(colorcode[5])) ;
colormap-> color_cell(entry_num) = Colormap::ColorCell(r,g,b,255) ;
conv_table[key1][key2] = (unsigned char)entry_num ;
}
// _______________________ image
Image* result = new Image(Image::INDEXED, width, height) ;
result-> set_colormap(colormap) ;
for(int y=0; y<height; y++) {
char* scan_line = next_xpm_data(stream) ;
if(scan_line == nil) {
Logger::err("Image")
<< "XPM Image reader: Unexpected end of file"
<< std::endl ;
delete result ;
return nil ;
}
for(int x=0; x<width; x++) {
int key1 = scan_line[2*x] ;
int key2 = scan_line[2*x+1] ;
int color_index = conv_table[key1][key2] ;
if(color_index < 0 || color_index > num_colors) {
Logger::err("Image")
<< "XPM Image reader: Invalid color index in image"
<< std::endl ;
delete result ;
return nil ;
}
result-> base_mem()[y * width + x] = byte(color_index) ;
}
}
flip_image(*result) ;
return result ;
}
