Thread: Quantizing genann ANN library

Hi,

I want to quantize genann library from double/float network type to int16_t . Still I have not got the right output , see this code :

In genann.h

Code:

typedef int16_t genann_t;
#define GENANN_MAX 10000

In genann.c using genann_act_linear function :

Code:

void genann_train(genann const *ann, genann_t const *inputs, genann_t const *desired_outputs, float learning_rate) {
    /* To begin with, we must run the network forward. */
    genann_run(ann, inputs);


    float quant_factor = GENANN_MAX;
    int h, j, k;


    /* First set the output layer deltas. */
    {
        genann_t const *o = ann->output + ann->inputs + ann->hidden * ann->hidden_layers; /* First output. */
        genann_t *d = ann->delta + ann->hidden * ann->hidden_layers; /* First delta. */
        genann_t const *t = desired_outputs; /* First desired output. */


        
        /* Set output layer deltas. */
        if (genann_act_output == genann_act_linear ||
                ann->activation_output == genann_act_linear) {
            for (j = 0; j < ann->outputs; ++j) {
                //*d++ = *t++ - *o++;
                float output = (float)(*o++ * quant_factor); 
                float target = (float)(*t++ * quant_factor); 
                float delta = target - output; 
                *d++ = delta; 
            }
        } else {
            for (j = 0; j < ann->outputs; ++j) {
                float output = (float)(*o++ * quant_factor); 
                float target = (float)(*t++ * quant_factor); 
                float delta = (target - output) * output * (quant_factor - output);
                *d++ = delta;
            }
        }
    }




    /* Set hidden layer deltas, start on last layer and work backwards. */
    /* Note that loop is skipped in the case of hidden_layers == 0. */
    for (h = ann->hidden_layers - 1; h >= 0; --h) {


        /* Find first output and delta in this layer. */
        genann_t const *o = ann->output + ann->inputs + (h * ann->hidden);
        genann_t *d = ann->delta + (h * ann->hidden);


        /* Find first delta in following layer (which may be hidden or output). */
        genann_t const * const dd = ann->delta + ((h+1) * ann->hidden);


        /* Find first weight in following layer (which may be hidden or output). */
        genann_t const * const ww = ann->weight + ((ann->inputs+1) * ann->hidden) + ((ann->hidden+1) * ann->hidden * (h));


        for (j = 0; j < ann->hidden; ++j) {
    
            float delta = 0;
    
            for (k = 0; k < (h == ann->hidden_layers-1 ? ann->outputs : ann->hidden); ++k) {
                const float forward_delta = dd[k];
                const int windex = k * (ann->hidden + 1) + (j + 1);
                const float forward_weight = ww[windex];
                delta += forward_delta * forward_weight;
            }


            float output = (float)(*o++ * quant_factor); 
            *d++ = (genann_t)((float)output * (1.0-output) * ((float)delta * (1.0 / quant_factor)));
        }
    }




    /* Train the output layer */
    
    for (int l = 0; l < ann->outputs; ++l) {
        float delta = ann->delta[ann->hidden * ann->hidden_layers + l]; 
        
        genann_t *w;
        w = ann->weight + (ann->hidden_layers 
                            ? ((ann->inputs + 1) * ann->hidden + (ann->hidden + 1) * ann->hidden * (ann->hidden_layers - 1)) 
                            : 0) 
                            + l * (ann->hidden + 1); 
        
        *w += delta * learning_rate * -1.0; 
        for (int m = 0; m < ann->hidden; ++m) {
            int windex = m + (ann->hidden_layers ? (ann->hidden * (ann->hidden_layers - 1)) : 0);
            w[m+1] += delta * learning_rate 
                * ann->output[windex]; 
        }
    }
    


    /* Train the hidden layers. */
    for (int n = ann->hidden_layers - 1; n >= 0; --n) {


        /* Find first delta in this layer. */
        genann_t const *d = ann->delta + (n * ann->hidden);


        /* Find first input to this layer. */
        genann_t const *i = ann->output + (n ? (ann->inputs + ann->hidden * (n-1)) : 0);


        /* Find first weight to this layer. */
        genann_t *w = ann->weight + (n ? ((ann->inputs+1) * ann->hidden + (ann->hidden+1) * (ann->hidden) * (n-1)) : 0);


        for (int q = 0; q < ann->hidden; ++q) {
            *w += *d * learning_rate * -1.0; 
            ++w;
            for (int r = 1; r < (n == 0 ? ann->inputs : ann->hidden) + 1; ++r) {
                *w += *d * learning_rate * i[r-1]; 
                ++w;
            }
            ++d; 
        }
    }


}

Can you help me fix it ?

is line 92 correct??? i know nothing about what your trying to do but it looks to me like you declare a variable (windex) with out initialization then test to see if it equals m + (ann->hidden_layers with no closing bracket

That part could be written as :

Code:

for (int m = 0; m < ann->hidden; ++m) {
            int windex = m + (ann->hidden_layers ? (ann->hidden * (ann->hidden_layers - 1)) : 0);
            w[m+1] += delta * learning_rate * ann->output[windex]; 
        }

Because I deleted some comments. It was not properly written.