void backward_crnn_layer(layer_t l, network_state state)
{
NETWORK_STATE(s);
s.train = state.train;
int i;
layer_t input_layer = *(l.input_layer);
layer_t self_layer = *(l.self_layer);
layer_t output_layer = *(l.output_layer);
increment_layer(&input_layer, l.steps-1);
increment_layer(&self_layer, l.steps-1);
increment_layer(&output_layer, l.steps-1);
l.state += l.hidden*l.batch*l.steps;
for (i = l.steps-1; i >= 0; --i) {
fltcpy(l.state, input_layer.output, l.hidden * l.batch);
fltadd(l.state, self_layer.output, l.hidden * l.batch);
s.input = l.state;
s.delta = self_layer.delta;
backward_convolutional_layer(output_layer, s);
l.state -= l.hidden*l.batch;
/*
if(i > 0){
fltcpy(l.state, input_layer.output - l.hidden * l.batch, l.hidden * l.batch);
fltadd(l.state, self_layer.output - l.hidden * l.batch, l.hidden * l.batch);
}else{
memset(l.state, 0, sizeof(float) * l.hidden * l.batch);
}
*/
s.input = l.state;
s.delta = self_layer.delta - l.hidden*l.batch;
if (i == 0) s.delta = NULL;
backward_convolutional_layer(self_layer, s);
fltcpy(input_layer.delta, self_layer.delta, l.hidden * l.batch);
if (i > 0 && l.shortcut) fltadd(self_layer.delta - l.hidden * l.batch, self_layer.delta, l.hidden * l.batch);
s.input = state.input + i*l.inputs*l.batch;
if(state.delta) s.delta = state.delta + i*l.inputs*l.batch;
else s.delta = NULL;
backward_convolutional_layer(input_layer, s);
increment_layer(&input_layer, -1);
increment_layer(&self_layer, -1);
increment_layer(&output_layer, -1);
}
}
void SimpleVis::sendSoundData( const QByteArray &data )
{
if ( !w.tim.isActive() || !data.size() )
return;
QMutexLocker mL( &mutex );
if ( !tmpData.size() )
return;
int newDataPos = 0;
while ( newDataPos < data.size() )
{
const int size = qMin( data.size() - newDataPos, tmpData.size() - tmpDataPos );
fltcpy( ( float * )( tmpData.data() + tmpDataPos ), ( const float * )( data.data() + newDataPos ), size );
newDataPos += size;
tmpDataPos += size;
if ( tmpDataPos == tmpData.size() )
{
memcpy( w.soundData.data(), tmpData.constData(), tmpDataPos );
tmpDataPos = 0;
}
}
}
void forward_crnn_layer(layer_t l, network_state state)
{
NETWORK_STATE(s);
s.train = state.train;
int i;
layer_t input_layer = *(l.input_layer);
layer_t self_layer = *(l.self_layer);
layer_t output_layer = *(l.output_layer);
memset(output_layer.delta, 0, sizeof(float) * l.outputs * l.batch * l.steps);
memset(self_layer.delta, 0, sizeof(float) * l.hidden * l.batch * l.steps);
memset(input_layer.delta, 0, sizeof(float) * l.hidden * l.batch * l.steps);
if(state.train) memset(l.state, 0, sizeof(float) * l.hidden * l.batch);
for (i = 0; i < l.steps; ++i) {
s.input = state.input;
forward_convolutional_layer(input_layer, s);
s.input = l.state;
forward_convolutional_layer(self_layer, s);
float *old_state = l.state;
if(state.train) l.state += l.hidden*l.batch;
if(l.shortcut){
fltcpy(l.state, old_state, l.hidden * l.batch);
}else{
memset(l.state, 0, sizeof(float) * l.hidden * l.batch);
}
fltadd(l.state, input_layer.output, l.hidden * l.batch);
fltadd(l.state, self_layer.output, l.hidden * l.batch);
s.input = l.state;
forward_convolutional_layer(output_layer, s);
state.input += l.inputs*l.batch;
increment_layer(&input_layer, 1);
increment_layer(&self_layer, 1);
increment_layer(&output_layer, 1);
}
}
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);
}
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;
}
}
