up new v4

Scheaven

2021-06-03 168af40fe9a3cc81c6ee16b3e81f154780c36bdb

 lib/detecter_tools/darknet/conv_lstm_layer.c

@@ -32,7 +32,7 @@
}





layer make_conv_lstm_layer(int batch, int h, int w, int c, int output_filters, int groups, int steps, int size, int stride, int dilation, int pad, ACTIVATION activation, int batch_normalize, int peephole, int xnor, int train)

layer make_conv_lstm_layer(int batch, int h, int w, int c, int output_filters, int groups, int steps, int size, int stride, int dilation, int pad, ACTIVATION activation, int batch_normalize, int peephole, int xnor, int bottleneck, int train)
{

    fprintf(stderr, "CONV_LSTM Layer: %d x %d x %d image, %d filters\n", h, w, c, output_filters);

    /*

@@ -51,6 +51,7 @@
    l.train = train;

    l.batch = batch;

    l.type = CONV_LSTM;

    l.bottleneck = bottleneck;
    l.steps = steps;

    l.size = size;

    l.stride = stride;

@@ -86,7 +87,17 @@
    l.uo->batch = batch;

    if (l.workspace_size < l.uo->workspace_size) l.workspace_size = l.uo->workspace_size;





    if (l.bottleneck) {
        // bottleneck-conv with 2x channels
        l.wf = (layer*)xcalloc(1, sizeof(layer));
        l.wi = (layer*)xcalloc(1, sizeof(layer));
        l.wg = (layer*)xcalloc(1, sizeof(layer));
        l.wo = (layer*)xcalloc(1, sizeof(layer));
        *(l.wf) = make_convolutional_layer(batch, steps, h, w, output_filters*2, output_filters, groups, size, stride, stride, dilation, pad, activation, batch_normalize, 0, xnor, 0, 0, 0, 0, NULL, 0, 0, train);
        l.wf->batch = batch;
        if (l.workspace_size < l.wf->workspace_size) l.workspace_size = l.wf->workspace_size;
    }
    else {
    // W

    l.wf = (layer*)xcalloc(1, sizeof(layer));

    *(l.wf) = make_convolutional_layer(batch, steps, h, w, output_filters, output_filters, groups, size, stride, stride, dilation, pad, activation, batch_normalize, 0, xnor, 0, 0, 0, 0, NULL, 0, 0, train);

@@ -107,7 +118,7 @@
    *(l.wo) = make_convolutional_layer(batch, steps, h, w, output_filters, output_filters, groups, size, stride, stride, dilation, pad, activation, batch_normalize, 0, xnor, 0, 0, 0, 0, NULL, 0, 0, train);

    l.wo->batch = batch;

    if (l.workspace_size < l.wo->workspace_size) l.workspace_size = l.wo->workspace_size;



    }


    // V

    l.vf = (layer*)xcalloc(1, sizeof(layer));

@@ -134,13 +145,14 @@


    l.batch_normalize = batch_normalize;



    l.out_h = l.wo->out_h;

    l.out_w = l.wo->out_w;

    l.outputs = l.wo->outputs;

    l.out_h = l.uo->out_h;
    l.out_w = l.uo->out_w;
    l.outputs = l.uo->outputs;
    int outputs = l.outputs;

    l.inputs = w*h*c;



    assert(l.wo->outputs == l.uo->outputs);

    if (!l.bottleneck) assert(l.wo->outputs == l.uo->outputs);
    assert(l.wf->outputs == l.uf->outputs);


    l.output = (float*)xcalloc(outputs * batch * steps, sizeof(float));

    //l.state = (float*)xcalloc(outputs * batch, sizeof(float));

@@ -167,6 +179,22 @@
    l.dc_cpu =          (float*)xcalloc(batch*outputs, sizeof(float));

    l.dh_cpu =          (float*)xcalloc(batch*outputs, sizeof(float));



    /*
    {
        int k;
        for (k = 0; k < l.uf->n; ++k) {
            l.uf->biases[k] = 2;    // ~0.9
            l.ui->biases[k] = -22;  // ~0.1
            l.uo->biases[k] = 5;    // ~1.0
        }
#ifdef GPU
        cuda_push_array(l.uf->biases_gpu, l.uf->biases, l.n);
        cuda_push_array(l.ui->biases_gpu, l.ui->biases, l.n);
        cuda_push_array(l.uo->biases_gpu, l.uo->biases, l.n);
#endif// GPU
    }
    */

#ifdef GPU

    l.forward_gpu = forward_conv_lstm_layer_gpu;

    l.backward_gpu = backward_conv_lstm_layer_gpu;

@@ -186,6 +214,10 @@
    l.g_gpu = cuda_make_array(0, batch*outputs);

    l.o_gpu = cuda_make_array(0, batch*outputs);

    l.c_gpu = cuda_make_array(0, batch*outputs);

    if (l.bottleneck) {
        l.bottelneck_hi_gpu = cuda_make_array(0, batch*outputs * 2);
        l.bottelneck_delta_gpu = cuda_make_array(0, batch*outputs * 2);
    }
    l.h_gpu = cuda_make_array(0, batch*outputs);

    l.stored_c_gpu = cuda_make_array(0, batch*outputs);

    l.stored_h_gpu = cuda_make_array(0, batch*outputs);

@@ -196,7 +228,6 @@
    l.dh_gpu = cuda_make_array(0, batch*outputs);

    l.last_prev_state_gpu = cuda_make_array(0, l.batch*l.outputs);

    l.last_prev_cell_gpu = cuda_make_array(0, l.batch*l.outputs);



#endif



    l.bflops = l.uf->bflops + l.ui->bflops + l.ug->bflops + l.uo->bflops +

@@ -208,6 +239,198 @@


    return l;

}


layer make_history_layer(int batch, int h, int w, int c, int history_size, int steps, int train)
{
    layer l = { (LAYER_TYPE)0 };
    l.train = train;
    l.batch = batch;
    l.type = HISTORY;
    l.steps = steps;
    l.history_size = history_size;
    l.h = h;
    l.w = w;
    l.c = c;
    l.out_h = h;
    l.out_w = w;
    l.out_c = c * history_size;
    l.inputs = h * w * c;
    l.outputs = h * w * c * history_size;

    l.forward = forward_history_layer;
    l.backward = backward_history_layer;

    fprintf(stderr, "HISTORY b = %d, s = %2d, steps = %2d   %4d x%4d x%4d -> %4d x%4d x%4d \n", l.batch / l.steps, l.history_size, l.steps, w, h, c, l.out_w, l.out_h, l.out_c);

    l.output = (float*)xcalloc(l.batch * l.outputs, sizeof(float));
    l.delta = (float*)xcalloc(l.batch * l.outputs, sizeof(float));

    l.prev_state_cpu = (float*)xcalloc(l.batch*l.outputs, sizeof(float));

#ifdef GPU

    l.forward_gpu = forward_history_layer_gpu;
    l.backward_gpu = backward_history_layer_gpu;

    l.output_gpu = cuda_make_array(0, l.batch * l.outputs);
    l.delta_gpu = cuda_make_array(0, l.batch * l.outputs);

    l.prev_state_gpu = cuda_make_array(0, l.batch*l.outputs);

#endif  // GPU

    //l.batch = 4;
    //l.steps = 1;

    return l;
}

void forward_history_layer(layer l, network_state state)
{
    if (l.steps == 1) {
        copy_cpu(l.inputs*l.batch, state.input, 1, l.output, 1);
        return;
    }

    const int batch = l.batch / l.steps;

    float *prev_output = l.prev_state_cpu;

    int i;
    for (i = 0; i < l.steps; ++i) {
        // shift cell
        int shift_size = l.inputs * (l.history_size - 1);
        int output_sift = l.inputs;

        int b;
        for (b = 0; b < batch; ++b) {
            int input_start = b*l.inputs + i*l.inputs*batch;
            int output_start = b*l.outputs + i*l.outputs*batch;
            float *input = state.input + input_start;
            float *output = l.output + output_start;

            copy_cpu(shift_size, prev_output + b*l.outputs, 1, output + output_sift, 1);

            copy_cpu(l.inputs, input, 1, output, 1);
        }
        prev_output = l.output + i*l.outputs*batch;
    }

    int output_start = (l.steps-1)*l.outputs*batch;
    copy_cpu(batch*l.outputs, l.output + output_start, 1, l.prev_state_cpu, 1);
}

void backward_history_layer(layer l, network_state state)
{
    if (l.steps == 1) {
        axpy_cpu(l.inputs*l.batch, 1, l.delta, 1, state.delta, 1);
        return;
    }

    const int batch = l.batch / l.steps;

    // l.delta -> state.delta
    int i;
    for (i = 0; i < l.steps; ++i) {
        int b;
        for (b = 0; b < batch; ++b) {
            int input_start = b*l.inputs + i*l.inputs*batch;
            int output_start = b*l.outputs + i*l.outputs*batch;
            float *state_delta = state.delta + input_start;
            float *l_delta = l.delta + output_start;

            //copy_cpu(l.inputs, l_delta, 1, state_delta, 1);
            axpy_cpu(l.inputs, 1, l_delta, 1, state_delta, 1);
        }
    }
}

#ifdef GPU
void forward_history_layer_gpu(const layer l, network_state state)
{
    if (l.steps == 1) {
        simple_copy_ongpu(l.inputs*l.batch, state.input, l.output_gpu);
        return;
    }

    const int batch = l.batch / l.steps;

    //int copy_size = l.inputs*batch*l.steps;
    //printf(" copy_size = %d, inputs = %d, batch = %d, steps = %d, l.history_size = %d \n", copy_size, l.inputs, batch, l.steps, l.history_size);
    //simple_copy_ongpu(copy_size, state.input, l.output_gpu);
    //return;

    //fill_ongpu(batch*l.outputs, 0, l.prev_state_gpu, 1);
    float *prev_output = l.prev_state_gpu;

    int i;
    for (i = 0; i < l.steps; ++i) {
        // shift cell
        int shift_size = l.inputs * (l.history_size - 1);
        int output_sift = l.inputs;

        int b;
        for (b = 0; b < batch; ++b) {
            //printf(" hist-fw: i = %d, b = %d \n", i, b);

            int input_start = b*l.inputs + i*l.inputs*batch;
            int output_start = b*l.outputs + i*l.outputs*batch;
            float *input = state.input + input_start;
            float *output = l.output_gpu + output_start;

            //copy_cpu(shift_size, prev_output + b*l.outputs, 1, output + output_sift, 1);
            simple_copy_ongpu(shift_size, prev_output + b*l.outputs, output + output_sift);

            //copy_cpu(l.inputs, input, 1, output, 1);
            simple_copy_ongpu(l.inputs, input, output);

            int h;
            for (h = 1; h < l.history_size; ++h) {
                //scal_ongpu(l.inputs, (l.history_size - h)/ (float)l.history_size, output + h*l.inputs, 1);
                //scal_ongpu(l.inputs, 0, output + h*l.inputs, 1);
            }
        }
        prev_output = l.output_gpu + i*l.outputs*batch;
    }

    int output_start = (l.steps - 1)*l.outputs*batch;
    //copy_cpu(batch*l.outputs, l.output + output_start, 1, l.prev_state_cpu, 1);
    simple_copy_ongpu(batch*l.outputs, l.output_gpu + output_start, l.prev_state_gpu);
}

void backward_history_layer_gpu(const layer l, network_state state)
{
    if (l.steps == 1) {
        axpy_ongpu(l.inputs*l.batch, 1, l.delta_gpu, 1, state.delta, 1);
        return;
    }

    const int batch = l.batch / l.steps;

    //int copy_size = l.inputs*batch*l.steps;
    //printf(" copy_size = %d, inputs = %d, batch = %d, steps = %d, l.history_size = %d \n", copy_size, l.inputs, batch, l.steps, l.history_size);
    //axpy_ongpu(copy_size, 1, l.delta_gpu, 1, state.delta, 1);
    //return;

    // l.delta -> state.delta
    int i;
    for (i = 0; i < l.steps; ++i) {
        int b;
        for (b = 0; b < batch; ++b) {
            //printf(" hist-bw: i = %d, b = %d \n", i, b);

            int input_start = b*l.inputs + i*l.inputs*batch;
            int output_start = b*l.outputs + i*l.outputs*batch;
            float *state_delta = state.delta + input_start;
            float *l_delta = l.delta_gpu + output_start;

            //copy_cpu(l.inputs, l_delta, 1, state_delta, 1);
            axpy_ongpu(l.inputs, 1, l_delta, 1, state_delta, 1);
        }
    }
}
#endif



void update_conv_lstm_layer(layer l, int batch, float learning_rate, float momentum, float decay)

{

@@ -765,9 +988,11 @@
        pull_convolutional_layer(*(l.vo));

    }

    pull_convolutional_layer(*(l.wf));

    if (!l.bottleneck) {
    pull_convolutional_layer(*(l.wi));

    pull_convolutional_layer(*(l.wg));

    pull_convolutional_layer(*(l.wo));

    }
    pull_convolutional_layer(*(l.uf));

    pull_convolutional_layer(*(l.ui));

    pull_convolutional_layer(*(l.ug));

@@ -782,9 +1007,11 @@
        push_convolutional_layer(*(l.vo));

    }

    push_convolutional_layer(*(l.wf));

    if (!l.bottleneck) {
    push_convolutional_layer(*(l.wi));

    push_convolutional_layer(*(l.wg));

    push_convolutional_layer(*(l.wo));

    }
    push_convolutional_layer(*(l.uf));

    push_convolutional_layer(*(l.ui));

    push_convolutional_layer(*(l.ug));

@@ -799,9 +1026,11 @@
        update_convolutional_layer_gpu(*(l.vo), batch, learning_rate, momentum, decay, loss_scale);

    }

    update_convolutional_layer_gpu(*(l.wf), batch, learning_rate, momentum, decay, loss_scale);

    if (!l.bottleneck) {
    update_convolutional_layer_gpu(*(l.wi), batch, learning_rate, momentum, decay, loss_scale);

    update_convolutional_layer_gpu(*(l.wg), batch, learning_rate, momentum, decay, loss_scale);

    update_convolutional_layer_gpu(*(l.wo), batch, learning_rate, momentum, decay, loss_scale);

    }
    update_convolutional_layer_gpu(*(l.uf), batch, learning_rate, momentum, decay, loss_scale);

    update_convolutional_layer_gpu(*(l.ui), batch, learning_rate, momentum, decay, loss_scale);

    update_convolutional_layer_gpu(*(l.ug), batch, learning_rate, momentum, decay, loss_scale);

@@ -838,9 +1067,11 @@
        }



        fill_ongpu(l.outputs * l.batch * l.steps, 0, wf.delta_gpu, 1);

        if (!l.bottleneck) {
        fill_ongpu(l.outputs * l.batch * l.steps, 0, wi.delta_gpu, 1);

        fill_ongpu(l.outputs * l.batch * l.steps, 0, wg.delta_gpu, 1);

        fill_ongpu(l.outputs * l.batch * l.steps, 0, wo.delta_gpu, 1);

        }


        fill_ongpu(l.outputs * l.batch * l.steps, 0, uf.delta_gpu, 1);

        fill_ongpu(l.outputs * l.batch * l.steps, 0, ui.delta_gpu, 1);

@@ -860,6 +1091,16 @@
            // vo below

        }



        if (l.bottleneck) {
            // l.bottelneck_hi_gpu size is 2x
            simple_copy_ongpu(l.outputs*l.batch, l.h_gpu, l.bottelneck_hi_gpu);
            simple_copy_ongpu(l.outputs*l.batch, state.input, l.bottelneck_hi_gpu + l.outputs*l.batch);
            s.input = l.bottelneck_hi_gpu;
            forward_convolutional_layer_gpu(wf, s); // 2x input channels
            activate_array_ongpu(wf.output_gpu, l.outputs*l.batch, l.lstm_activation);
            s.input = wf.output_gpu;
        }
        else {
        assert(l.outputs == wf.out_w * wf.out_h * wf.out_c);

        assert(wf.c == l.out_c && wi.c == l.out_c && wg.c == l.out_c && wo.c == l.out_c);



@@ -869,31 +1110,33 @@
        forward_convolutional_layer_gpu(wg, s);

        forward_convolutional_layer_gpu(wo, s);



            s.input = state.input;
        }

        assert(l.inputs == uf.w * uf.h * uf.c);

        assert(uf.c == l.c && ui.c == l.c && ug.c == l.c && uo.c == l.c);



        s.input = state.input;

        forward_convolutional_layer_gpu(uf, s);

        forward_convolutional_layer_gpu(ui, s);

        forward_convolutional_layer_gpu(ug, s);

        forward_convolutional_layer_gpu(uo, s);



        // f = wf + uf + vf

        add_3_arrays_activate(wf.output_gpu, uf.output_gpu, (l.peephole)?vf.output_gpu:NULL, l.outputs*l.batch, LOGISTIC, l.f_gpu);

        add_3_arrays_activate((l.bottleneck)?NULL:wf.output_gpu, uf.output_gpu, (l.peephole)?vf.output_gpu:NULL, l.outputs*l.batch, LOGISTIC, l.f_gpu);
        //copy_ongpu(l.outputs*l.batch, wf.output_gpu, 1, l.f_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, uf.output_gpu, 1, l.f_gpu, 1);

        //if (l.peephole) axpy_ongpu(l.outputs*l.batch, 1, vf.output_gpu, 1, l.f_gpu, 1);

        //activate_array_ongpu(l.f_gpu, l.outputs*l.batch, LOGISTIC);



        // i = wi + ui + vi

        add_3_arrays_activate(wi.output_gpu, ui.output_gpu, (l.peephole) ? vi.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.i_gpu);

        add_3_arrays_activate((l.bottleneck)?NULL:wi.output_gpu, ui.output_gpu, (l.peephole) ? vi.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.i_gpu);
        //copy_ongpu(l.outputs*l.batch, wi.output_gpu, 1, l.i_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, ui.output_gpu, 1, l.i_gpu, 1);

        //if (l.peephole) axpy_ongpu(l.outputs*l.batch, 1, vi.output_gpu, 1, l.i_gpu, 1);

        //activate_array_ongpu(l.i_gpu, l.outputs*l.batch, LOGISTIC);



        // g = wg + ug

        add_3_arrays_activate(wg.output_gpu, ug.output_gpu, NULL, l.outputs*l.batch, TANH, l.g_gpu);

        add_3_arrays_activate((l.bottleneck)?NULL:wg.output_gpu, ug.output_gpu, NULL, l.outputs*l.batch, l.lstm_activation, l.g_gpu);
        //copy_ongpu(l.outputs*l.batch, wg.output_gpu, 1, l.g_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, ug.output_gpu, 1, l.g_gpu, 1);

        //activate_array_ongpu(l.g_gpu, l.outputs*l.batch, TANH);

@@ -910,24 +1153,30 @@
            s.input = l.c_gpu;

            forward_convolutional_layer_gpu(vo, s);

        }

        add_3_arrays_activate(wo.output_gpu, uo.output_gpu, (l.peephole) ? vo.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.o_gpu);

        add_3_arrays_activate((l.bottleneck)?NULL:wo.output_gpu, uo.output_gpu, (l.peephole) ? vo.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.o_gpu);
        //copy_ongpu(l.outputs*l.batch, wo.output_gpu, 1, l.o_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, uo.output_gpu, 1, l.o_gpu, 1);

        //if (l.peephole) axpy_ongpu(l.outputs*l.batch, 1, vo.output_gpu, 1, l.o_gpu, 1);

        //activate_array_ongpu(l.o_gpu, l.outputs*l.batch, LOGISTIC);



        // h = o * tanh(c)

        activate_and_mult(l.c_gpu, l.o_gpu, l.outputs*l.batch, TANH, l.h_gpu);

        activate_and_mult(l.c_gpu, l.o_gpu, l.outputs*l.batch, l.lstm_activation, l.h_gpu);
        //simple_copy_ongpu(l.outputs*l.batch, l.c_gpu, l.h_gpu);

        //activate_array_ongpu(l.h_gpu, l.outputs*l.batch, TANH);

        //mul_ongpu(l.outputs*l.batch, l.o_gpu, 1, l.h_gpu, 1);



        fix_nan_and_inf(l.c_gpu, l.outputs*l.batch);

        fix_nan_and_inf(l.h_gpu, l.outputs*l.batch);

        fix_nan_and_inf(l.c_gpu, l.outputs*l.batch);    // should be fix_nan_and_inf()
        fix_nan_and_inf(l.h_gpu, l.outputs*l.batch);    // should be fix_nan_and_inf()
        if (l.state_constrain) constrain_ongpu(l.outputs*l.batch, l.state_constrain, l.c_gpu, 1);



        if(state.train) simple_copy_ongpu(l.outputs*l.batch, l.c_gpu, l.cell_gpu);

        simple_copy_ongpu(l.outputs*l.batch, l.h_gpu, l.output_gpu); // is required for both Detection and Training


        if (l.shortcut) {
            // partial residual connection
            if (l.bottleneck) axpy_ongpu(l.outputs*l.batch/2, 1, wf.output_gpu, 1, l.output_gpu, 1);
            //else axpy_ongpu(l.outputs*l.batch, 1, l.f_gpu, 1, l.output_gpu, 1);
        }


        state.input += l.inputs*l.batch;

        l.output_gpu    += l.outputs*l.batch;

@@ -1017,27 +1266,27 @@
        l.dh_gpu = (i == 0) ? 0 : l.delta_gpu - l.outputs*l.batch;



        // f = wf + uf + vf

        add_3_arrays_activate(wf.output_gpu, uf.output_gpu, (l.peephole) ? vf.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.f_gpu);

        add_3_arrays_activate((l.bottleneck) ? NULL : wf.output_gpu, uf.output_gpu, (l.peephole) ? vf.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.f_gpu);
        //copy_ongpu(l.outputs*l.batch, wf.output_gpu, 1, l.f_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, uf.output_gpu, 1, l.f_gpu, 1);

        //if (l.peephole) axpy_ongpu(l.outputs*l.batch, 1, vf.output_gpu, 1, l.f_gpu, 1);

        //activate_array_ongpu(l.f_gpu, l.outputs*l.batch, LOGISTIC);



        // i = wi + ui + vi

        add_3_arrays_activate(wi.output_gpu, ui.output_gpu, (l.peephole) ? vi.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.i_gpu);

        add_3_arrays_activate((l.bottleneck) ? NULL : wi.output_gpu, ui.output_gpu, (l.peephole) ? vi.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.i_gpu);
        //copy_ongpu(l.outputs*l.batch, wi.output_gpu, 1, l.i_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, ui.output_gpu, 1, l.i_gpu, 1);

        //if (l.peephole) axpy_ongpu(l.outputs*l.batch, 1, vi.output_gpu, 1, l.i_gpu, 1);

        //activate_array_ongpu(l.i_gpu, l.outputs*l.batch, LOGISTIC);



        // g = wg + ug

        add_3_arrays_activate(wg.output_gpu, ug.output_gpu, NULL, l.outputs*l.batch, TANH, l.g_gpu);

        add_3_arrays_activate((l.bottleneck) ? NULL : wg.output_gpu, ug.output_gpu, NULL, l.outputs*l.batch, l.lstm_activation, l.g_gpu);   // TANH
        //copy_ongpu(l.outputs*l.batch, wg.output_gpu, 1, l.g_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, ug.output_gpu, 1, l.g_gpu, 1);

        //activate_array_ongpu(l.g_gpu, l.outputs*l.batch, TANH);

        //activate_array_ongpu(l.g_gpu, l.outputs*l.batch, l.lstm_activation);


        // o = wo + uo + vo

        add_3_arrays_activate(wo.output_gpu, uo.output_gpu, (l.peephole) ? vo.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.o_gpu);

        add_3_arrays_activate((l.bottleneck) ? NULL : wo.output_gpu, uo.output_gpu, (l.peephole) ? vo.output_gpu : NULL, l.outputs*l.batch, LOGISTIC, l.o_gpu);
        //copy_ongpu(l.outputs*l.batch, wo.output_gpu, 1, l.o_gpu, 1);

        //axpy_ongpu(l.outputs*l.batch, 1, uo.output_gpu, 1, l.o_gpu, 1);

        //if (l.peephole) axpy_ongpu(l.outputs*l.batch, 1, vo.output_gpu, 1, l.o_gpu, 1);

@@ -1047,12 +1296,12 @@
        simple_copy_ongpu(l.outputs*l.batch, l.delta_gpu, l.temp3_gpu);  // temp3 = delta



        simple_copy_ongpu(l.outputs*l.batch, l.c_gpu, l.temp_gpu);

        activate_array_ongpu(l.temp_gpu, l.outputs*l.batch, TANH);  // temp  = tanh(c)

        activate_array_ongpu(l.temp_gpu, l.outputs*l.batch, l.lstm_activation);  // temp  = tanh(c)


        simple_copy_ongpu(l.outputs*l.batch, l.temp3_gpu, l.temp2_gpu);

        mul_ongpu(l.outputs*l.batch, l.o_gpu, 1, l.temp2_gpu, 1);   // temp2 = delta * o



        gradient_array_ongpu(l.temp_gpu, l.outputs*l.batch, TANH, l.temp2_gpu); // temp2 = delta * o * grad_tanh(tanh(c))

        gradient_array_ongpu(l.temp_gpu, l.outputs*l.batch, l.lstm_activation, l.temp2_gpu); // temp2 = delta * o * grad_tanh(tanh(c))
        //???

        axpy_ongpu(l.outputs*l.batch, 1, l.dc_gpu, 1, l.temp2_gpu, 1);          // temp2 = delta * o * grad_tanh(tanh(c)) + delta_c(???)

        // temp  = tanh(c)

@@ -1060,7 +1309,7 @@
        // temp3 = delta



        simple_copy_ongpu(l.outputs*l.batch, l.c_gpu, l.temp_gpu);

        activate_array_ongpu(l.temp_gpu, l.outputs*l.batch, TANH);    // temp  = tanh(c)

        activate_array_ongpu(l.temp_gpu, l.outputs*l.batch, l.lstm_activation);    // temp  = tanh(c)


        mul_ongpu(l.outputs*l.batch, l.temp3_gpu, 1, l.temp_gpu, 1);  // temp  = delta * tanh(c)

        gradient_array_ongpu(l.o_gpu, l.outputs*l.batch, LOGISTIC, l.temp_gpu);  // temp  = delta * tanh(c) * grad_logistic(o)

@@ -1077,30 +1326,47 @@
            backward_convolutional_layer_gpu(vo, s);

        }



        if (!l.bottleneck) {
        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, wo.delta_gpu);

        s.input = l.prev_state_gpu;

        //s.delta = l.dh_gpu;

            s.delta = l.temp3_gpu;// s.delta = l.dh_gpu;
            fill_ongpu(l.outputs * l.batch, 0, l.temp3_gpu, 1);
        backward_convolutional_layer_gpu(wo, s);

        }


        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, uo.delta_gpu);

        if (l.bottleneck) {
            s.input = wf.output_gpu;
            s.delta = wf.delta_gpu;
        }
        else {
        s.input = state.input;

        s.delta = state.delta;

        }
        backward_convolutional_layer_gpu(uo, s);



        // g

        simple_copy_ongpu(l.outputs*l.batch, l.temp2_gpu, l.temp_gpu);

        mul_ongpu(l.outputs*l.batch, l.i_gpu, 1, l.temp_gpu, 1);

        gradient_array_ongpu(l.g_gpu, l.outputs*l.batch, TANH, l.temp_gpu);

        gradient_array_ongpu(l.g_gpu, l.outputs*l.batch, l.lstm_activation, l.temp_gpu);
        // delta for c,f,i,g(w,u,v): temp = (delta * o * grad_tanh(tanh(c)) + delta_c(???)) * i * grad_tanh(g)



        if (!l.bottleneck) {
        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, wg.delta_gpu);

        s.input = l.prev_state_gpu;

        //s.delta = l.dh_gpu;

        backward_convolutional_layer_gpu(wg, s);

            s.delta = l.temp3_gpu;// s.delta = l.dh_gpu;   // comment this
            backward_convolutional_layer_gpu(wg, s);  // lead to nan
        }


        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, ug.delta_gpu);

        if (l.bottleneck) {
            s.input = wf.output_gpu;
            s.delta = wf.delta_gpu;
        }
        else {
        s.input = state.input;

        s.delta = state.delta;

        }
        backward_convolutional_layer_gpu(ug, s);



        // i

@@ -1116,14 +1382,22 @@
            backward_convolutional_layer_gpu(vi, s);

        }



        if (!l.bottleneck) {
        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, wi.delta_gpu);

        s.input = l.prev_state_gpu;

        //s.delta = l.dh_gpu;

        backward_convolutional_layer_gpu(wi, s);

            s.delta = l.temp3_gpu;// s.delta = l.dh_gpu;   // comment this
            backward_convolutional_layer_gpu(wi, s);  // lead to nan (after 1000 it)
        }


        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, ui.delta_gpu);

        if (l.bottleneck) {
            s.input = wf.output_gpu;
            s.delta = wf.delta_gpu;
        }
        else {
        s.input = state.input;

        s.delta = state.delta;

        }
        backward_convolutional_layer_gpu(ui, s);



        // f

@@ -1139,21 +1413,56 @@
            backward_convolutional_layer_gpu(vf, s);

        }



        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, wf.delta_gpu);

        s.input = l.prev_state_gpu;

        //s.delta = l.dh_gpu;

        backward_convolutional_layer_gpu(wf, s);



        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, uf.delta_gpu);

        if (l.bottleneck) {
            s.input = wf.output_gpu;
            s.delta = wf.delta_gpu;
        }
        else {
        s.input = state.input;

        s.delta = state.delta;

        }
        backward_convolutional_layer_gpu(uf, s);



        if (l.bottleneck) {
            // l.bottelneck_hi_gpu size is 2x
            simple_copy_ongpu(l.outputs*l.batch, l.prev_state_gpu, l.bottelneck_hi_gpu);
            simple_copy_ongpu(l.outputs*l.batch, state.input, l.bottelneck_hi_gpu + l.outputs*l.batch);
            fill_ongpu(l.outputs * l.batch * 2, 0, l.bottelneck_delta_gpu, 1);
            s.input = l.bottelneck_hi_gpu;
            s.delta = l.bottelneck_delta_gpu;
            if (l.shortcut) axpy_ongpu(l.outputs*l.batch/2, 1, l.delta_gpu, 1, wf.delta_gpu, 1);    // partial residual connection
            gradient_array_ongpu(wf.output_gpu, l.outputs*l.batch, l.lstm_activation, wf.delta_gpu);

            reset_nan_and_inf(wf.delta_gpu, l.outputs*l.batch);
            constrain_ongpu(l.outputs*l.batch, 1, wf.delta_gpu, 1);
        }
        else {
            s.input = l.prev_state_gpu;
            simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, wf.delta_gpu);
            s.delta = l.temp3_gpu;// s.delta = l.dh_gpu;
        }

        // WF
        backward_convolutional_layer_gpu(wf, s);

        if (l.bottleneck) {
            reset_nan_and_inf(l.bottelneck_delta_gpu, l.outputs*l.batch*2);
            //constrain_ongpu(l.outputs*l.batch*2, 1, l.bottelneck_delta_gpu, 1);
            if (l.dh_gpu) axpy_ongpu(l.outputs*l.batch, l.time_normalizer, l.bottelneck_delta_gpu, 1, l.dh_gpu, 1);
            axpy_ongpu(l.outputs*l.batch, 1, l.bottelneck_delta_gpu + l.outputs*l.batch, 1, state.delta, 1);    // lead to nan
        }
        else {
            axpy_ongpu(l.outputs*l.batch, l.time_normalizer, l.temp3_gpu, 1, l.dh_gpu, 1);
        }


        // c

        simple_copy_ongpu(l.outputs*l.batch, l.temp2_gpu, l.temp_gpu);

        mul_ongpu(l.outputs*l.batch, l.f_gpu, 1, l.temp_gpu, 1);

        simple_copy_ongpu(l.outputs*l.batch, l.temp_gpu, l.dc_gpu);

        fix_nan_and_inf(l.dc_gpu, l.outputs*l.batch);

        reset_nan_and_inf(l.dc_gpu, l.outputs*l.batch);
        if (i != 0) reset_nan_and_inf(l.dh_gpu, l.outputs*l.batch);
        // delta for c,f,i,g(w,u,v): delta_c = temp = (delta * o * grad_tanh(tanh(c)) + delta_c(???)) * f    // (grad_linear(c)==1)



        state.input -= l.inputs*l.batch;