pusho per testare nel threadripper

classificatore_singolo.c

@@ -0,0 +1,124 @@
+#include "visualizzatore.h"
+
+#define NUM_LAYERS 5
+
+#define PERCETTRONI_LAYER_0 256
+#define INPUT_LAYER_0 3072
+#define PERCETTRONI_LAYER_1 128
+#define INPUT_LAYER_1 256
+#define PERCETTRONI_LAYER_2 64
+#define INPUT_LAYER_2 128
+#define PERCETTRONI_LAYER_3 10
+#define INPUT_LAYER_3 64
+#define PERCETTRONI_LAYER_4 1
+#define INPUT_LAYER_4 10
+
+#define MAX_EPOCHE 100
+
+//Scelgo quale categoria voglio identificare. La 7 sono i cavalli. La rete mi dirà per ogni immagine se è un cavallo o no
+#define CATEGORIA 7
+byte get_out_corretto(byte);
+void stampa_layer_indirizzo(Layer*);
+
+void main() {
+    srand(time(NULL));
+
+    /* init_allegro();
+
+    // Carica la prima immagine
+    load_current_image(set);
+
+    while (!key[KEY_ESC]) {
+        draw_interface();
+        handle_input(set);
+        rest(10);
+    }
+
+    destroy_bitmap(buffer);
+    destroy_bitmap(image);
+    allegro_exit(); */
+
+    Dataset *set_appoggio = get_dataset("cifar-10-batches/data_batch_1.bin");
+    if(set_appoggio == NULL)
+        return;
+    Dataset set = *set_appoggio;
+    free(set_appoggio);
+
+    ReteNeurale rete_neurale = inizializza_rete_neurale(NUM_LAYERS);
+    //inizializzo layer 0
+    rete_neurale.layers[0] = inizializza_layer(PERCETTRONI_LAYER_0, INPUT_LAYER_0);
+    //inizializzo layer 1
+    rete_neurale.layers[1] = inizializza_layer(PERCETTRONI_LAYER_1, INPUT_LAYER_1);
+    //inizializzo layer 2
+    rete_neurale.layers[2] = inizializza_layer(PERCETTRONI_LAYER_2, INPUT_LAYER_2);
+    //inizializzo layer 3
+    rete_neurale.layers[3] = inizializza_layer(PERCETTRONI_LAYER_3, INPUT_LAYER_3);
+    //inizializzo layer ULTIMO
+    rete_neurale.layers[4] = inizializza_layer(PERCETTRONI_LAYER_4, INPUT_LAYER_4);
+
+    printf("Numero immagini: %d\n",set.size);
+
+    //ADDESTRAMENTO
+    for(int i = 0; i < MAX_EPOCHE; i++) {
+        printf("Epoca %d\n", i);
+
+        int corrette = 0;
+
+        for(int indice_set = 0; indice_set < 100; indice_set++) {
+
+            //printf("\timmagine: %d\n", indice_set);
+
+            double **sigmoidi = (double **)malloc(sizeof(double*) * NUM_LAYERS);
+
+            sigmoidi[0] = (double*)malloc(sizeof(double) * PERCETTRONI_LAYER_0);
+            sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale.layers[0], set.istanze[indice_set].immagine);
+
+            for(int j = 1; j < NUM_LAYERS; j++) {
+                sigmoidi[j] = (double*)malloc(sizeof(double) * rete_neurale.layers[j].size);
+                sigmoidi[j] = funzioni_attivazione_layer_double(rete_neurale.layers[j], sigmoidi[j-1]);
+            }
+
+            byte output_corretto = get_out_corretto(set.istanze[indice_set].categoria);
+
+            //Se prevede male
+            if(previsione(sigmoidi[NUM_LAYERS-1][0]) != output_corretto) {
+
+                double **gradienti = (double**)malloc(sizeof(double*) * NUM_LAYERS);
+
+                for(int indice_layer = 0; indice_layer < NUM_LAYERS; indice_layer++) {
+                    gradienti[indice_layer] = (double*)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
+                }
+
+                gradienti[NUM_LAYERS-1][0] = output_corretto - sigmoidi[NUM_LAYERS-1][0];
+
+                correggi_layer_interni(&rete_neurale, gradienti, sigmoidi);
+                correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].immagine, NUM_LAYERS);
+            }
+            else
+            {
+                //printf("immagine: %d categoria: %d, risposta_esatta: %d, previsione: %d\n", indice_set, set.istanze[indice_set].categoria, output_corretto, previsione(*sigmoide_out));
+                corrette++;
+            }
+        }
+        printf("\tRisposte corrette: %d\n", corrette);
+    }
+}
+
+//Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
+byte get_out_corretto(byte categoria) {
+    if(categoria == CATEGORIA)
+        return 1;
+    else
+        return 0;
+}
+
+void stampa_layer_indirizzo(Layer *layer) {
+    for(int i = 0; i < layer->size; i++) {
+        printf("Percettrone %d ->", i);
+        for(int j = 0; j < layer->percettroni->size; j++) {
+            printf("\t peso %d, valore: %f",j, layer->percettroni[i].pesi[j]);
+            layer->percettroni[i].pesi[j] += 1;
+        }
+        printf("\n");
+    }
+}