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 ?
