CI_ASS2_Neural Network Classification_C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

float learning_rate  = .001;
int layers_config[3] = {2, 4, 1};

// from http://stackoverflow.com/a/686373
float generateWeight (float min, float max) {
    return .0005;
    return min + ((float) rand()) / ((float) (RAND_MAX / (max - min)));
}

float activate (float net) {
    return tanh(net);
}

float deriveActivation (float net) {
    return 1.0 - pow(tanh(net), 2.0);
}


int main() {

    srand(time(NULL));

    float training_sets[1000][3];

    int layer, prev_layer, next_layer, node, prev_node, next_node;
    int layer_last = sizeof(layers_config) / sizeof(int) - 1;
    float weights[3][4][4];
    float biases[3][4];
    for (layer = 1; layer <= layer_last; ++layer) {
        int prev_layer = layer - 1;
        for (node = 0; node < layers_config[layer]; node++) {
            for (prev_node = 0; prev_node < layers_config[prev_layer]; prev_node++) {
                weights[prev_layer][prev_node][node] = generateWeight(-.001, .001);
            }
            biases[layer][node] = generateWeight(-.001, .001);
        }
    }

    float p0, p1;
    int count = 0;
    while (1) {
        char desired_out_str[2];
        scanf("%f,%f,%s\n", &p0, &p1, desired_out_str);
        if (p0 == 0 && p1 == 0 && desired_out_str[0] == '0') break;

        training_sets[count][0] = p0;
        training_sets[count][1] = p1;
        training_sets[count][2] = desired_out_str[0] == '+' ? 1 : -1;
        count++;

    }

    // The training process starts
    int i, j, desired_output;
    for (i = 0; i < 1000; i++) {
        for (j = 0; j < count; j++) {
            desired_output = training_sets[j][2];

            // Forward activations
            float outputs[3][4];
            outputs[0][0] = training_sets[j][0];
            outputs[0][1] = training_sets[j][1];
            for (layer = 1; layer <= layer_last; layer++) {
                prev_layer = layer - 1;
                for (node = 0; node < layers_config[layer]; node++) {
                    float sum = 0;
                    for (prev_node = 0; prev_node < layers_config[prev_layer]; prev_node++) {
                        sum += outputs[prev_layer][prev_node] * weights[prev_layer][prev_node][node];
                    }
                    outputs[layer][node] = activate(sum - biases[layer][node]);
                }
            }

            // Back propagations
            float error_gradients[3][4];
            for (layer = layer_last; layer > 0; layer--) {
                next_layer = layer + 1;
                prev_layer = layer - 1;
                for (node = 0; node < layers_config[layer]; node++) {
                    float derivation = deriveActivation(outputs[layer][node]);
                    //printf("Current layer: %d/%d\n", layer, layer_last);
                    if (layer == layer_last) {
                        error_gradients[layer][node] = derivation * (desired_output - outputs[layer][node]);
                        //printf("Error gradient in node %d, layer %d: %f\n", layer, node, derivation);
                    } else {
                        error_gradients[layer][node] = 0;
                        for (next_node = 0; next_node < layers_config[next_layer]; next_node++) {
                            error_gradients[layer][node] += error_gradients[next_layer][next_node] * weights[layer][node][next_node];
                        }
                        error_gradients[layer][node] *= derivation;
                    }
                    for (prev_node = 0; prev_node < layers_config[prev_layer]; prev_node++) {
                        weights[prev_layer][prev_node][node] += learning_rate * outputs[prev_layer][prev_node] * error_gradients[layer][node];
                    }
                    biases[layer][node] += learning_rate * -error_gradients[layer][node];
                }
            }
        }
    }


    while (scanf("%f,%f\n", &p0, &p1) != EOF) {
        float outputs[3][4];
        outputs[0][0] = p0;
        outputs[0][1] = p1;
        for (layer = 1; layer <= layer_last; layer++) {
            prev_layer = layer - 1;
            for (node = 0; node < layers_config[layer]; node++) {
                float sum = 0;
                for (prev_node = 0; prev_node < layers_config[prev_layer]; prev_node++) {
                    sum += outputs[prev_layer][prev_node] * weights[prev_layer][prev_node][node];
                    //printf("Weights for layer %i, edge %i->%i: %f, output: %f, weight: %f\n", prev_layer, prev_node, node, weights[prev_layer][prev_node][node], outputs[prev_layer][prev_node], weights[prev_layer][prev_node][node]);
                }
                outputs[layer][node] = activate(sum - biases[layer][node]);
            }
        }
        char* out_str = outputs[2][0] >= 0 ? "+1" : "-1";
        printf("%s %f\n", out_str, outputs[2][0]);
    }

    return 0;
}