IA/classificatore_immagini
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ci sto lavorando, provare nuova discesa del gradiente

Browse Source
This commit is contained in:
mirimatcode
2025-02-21 00:32:54 +01:00
parent 760940ef97
commit 828fea5d6a
4 changed files with 51 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
classificatore_singolo
View File

Binary file not shown.

40
classificatore_singolo.c
View File

@@ -6,8 +6,8 @@
//Scelgo quale categoria voglio identificare. nel caso dello xor -1 //Scelgo quale categoria voglio identificare. nel caso dello xor -1
#define CATEGORIA -1 #define CATEGORIA -1
#define NUM_LAYERS 5 #define NUM_LAYERS 2
#define PERCETTRONI_LAYER_0 256 #define PERCETTRONI_LAYER_0 2
#define MAX_EPOCHE 10000 #define MAX_EPOCHE 10000
byte get_out_corretto(byte); byte get_out_corretto(byte);
@@ -41,38 +41,55 @@ void main() {
//ADDESTRAMENTO //ADDESTRAMENTO
for(int i = 0; i < MAX_EPOCHE; i++) { for(int i = 0; i < MAX_EPOCHE; i++) {
printf("Epoca %d\n", i); //printf("Epoca %d\n", i);
stampa_tempo(tempo_epoche, i); //stampa_tempo(tempo_epoche, i);
int corrette = 0; int corrette = 0;
double errore_totale = 0.0;
for(int indice_set = 0; indice_set < set.size; indice_set++) { for(int indice_set = 0; indice_set < set.size; indice_set++) {
//sigmoidi è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
// sigmoidi[indice_layer][indice_percettrone]
double **sigmoidi = (double **)malloc(sizeof(double*) * NUM_LAYERS); double **sigmoidi = (double **)malloc(sizeof(double*) * NUM_LAYERS);
//Il layer di ingresso ha bisogno di una funzione a parte perchè prende byte come input
sigmoidi[0] = (double*)malloc(sizeof(double) * PERCETTRONI_LAYER_0); sigmoidi[0] = (double*)malloc(sizeof(double) * PERCETTRONI_LAYER_0);
sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale.layers[0], set.istanze[indice_set].dati); sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale.layers[0], set.istanze[indice_set].dati);
//Calcolo le sigmoidi in tutti gli altri layer
for(int j = 1; j < NUM_LAYERS; j++) { for(int j = 1; j < NUM_LAYERS; j++) {
sigmoidi[j] = (double*)malloc(sizeof(double) * rete_neurale.layers[j].size); sigmoidi[j] = (double*)malloc(sizeof(double) * rete_neurale.layers[j].size);
sigmoidi[j] = funzioni_attivazione_layer_double(rete_neurale.layers[j], sigmoidi[j-1]); sigmoidi[j] = funzioni_attivazione_layer_double(rete_neurale.layers[j], sigmoidi[j-1]);
} }
byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione); byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
printf("Inputs: %d %d\t", set.istanze[indice_set].dati[0], set.istanze[indice_set].dati[1]);
printf("Previsione: %d, out corretto: %d\n", previsione(sigmoidi[NUM_LAYERS-1][0]), output_corretto);
//Se prevede male //Se prevede male
if(previsione(sigmoidi[NUM_LAYERS-1][0]) != output_corretto) { if(previsione(sigmoidi[NUM_LAYERS-1][0]) != output_corretto) {
//gradienti è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
//gradienti[indice_layer][indice_percettrone]
double **gradienti = (double**)malloc(sizeof(double*) * NUM_LAYERS); double **gradienti = (double**)malloc(sizeof(double*) * NUM_LAYERS);
//Alloco la dimensione per ogni layer
for(int indice_layer = 0; indice_layer < NUM_LAYERS; indice_layer++) { 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[indice_layer] = (double*)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
} }
//Errore /* Gestione dell'errore
Funzione di perdita -> errore quadratico medio: (risultato_esatto - previsione)^2
Gradiente dell'errore rispetto all'attivazione = derivata(funzione_perdita) * derivata(sigmoide_out)
= -(risultato_esatto - previsione) * (sigmoide_out * (1 - sigmoide_out))
//Per ogni percettrone sugli altri layer:
- calcolare derivata della propria sigmoide
- gradiente dell'errore retropropagato = peso del ne
*/
gradienti[NUM_LAYERS-1][0] = (output_corretto - sigmoidi[NUM_LAYERS-1][0]); gradienti[NUM_LAYERS-1][0] = (output_corretto - sigmoidi[NUM_LAYERS-1][0]);
errore_totale += gradienti[NUM_LAYERS-1][0];
correggi_layer_interni(&rete_neurale, gradienti, sigmoidi); correggi_layer_interni(&rete_neurale, gradienti, sigmoidi);
correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].dati, NUM_LAYERS); correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].dati, NUM_LAYERS);
@@ -81,9 +98,16 @@ void main() {
{ {
corrette++; corrette++;
} }
if(corrette == 4) {
printf("\tConvergo all'epoca %d\n", i);
break;
}
} }
printf("\tRisposte corrette: %d\n", corrette); printf("Errore: %f\n", errore_totale);
//printf("\tRisposte corrette: %d\n", corrette);
if(corrette == set.size) { if(corrette == set.size) {
break; break;

24
percettroni.h
View File

@@ -52,15 +52,17 @@ ReteNeurale *caricaReteNeurale(const char*);
//Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1] //Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
double randomico() { double randomico() {
// Genero numeri nell'intervallo [-1,1] // Genero numeri nell'intervallo [-1,1]
return (double)((rand() / RAND_MAX) * -1);//((double)(rand() % 101 * 0.01 * 2 ) -1); return ((double)(rand() % 101 * 0.01 * 2 ) -1);
} }
//Questa funzione inizializza il percettrone allocando la memoria in base al numero dei pesi che voglio ed inizializza il loro valore usando randomico() //Questa funzione inizializza il percettrone allocando la memoria in base al numero dei pesi che voglio ed inizializza il loro valore usando randomico()
Percettrone inizializza_percettrone(int n_pesi) { Percettrone inizializza_percettrone(int n_pesi) {
Percettrone p; Percettrone p;
p.pesi = (double*) malloc(sizeof(double) * n_pesi); p.pesi = (double*) malloc(sizeof(double) * n_pesi);
for(int i = 0; i < n_pesi; i++) for(int i = 0; i < n_pesi; i++) {
p.pesi[i] = randomico(); p.pesi[i] = randomico();
//printf("peso[%d]: %f\n",i, p.pesi[i]);
}
p.bias = randomico(); p.bias = randomico();
@@ -113,6 +115,7 @@ Layer inizializza_layer(int n_percettroni, int n_pesi) {
for(int i = 0; i < n_percettroni; i++) { for(int i = 0; i < n_percettroni; i++) {
layer.percettroni[i] = inizializza_percettrone(n_pesi); layer.percettroni[i] = inizializza_percettrone(n_pesi);
} }
layer.size = n_percettroni; layer.size = n_percettroni;
@@ -124,8 +127,11 @@ Layer inizializza_layer(int n_percettroni, int n_pesi) {
double sigmoide_byte(Percettrone p, byte *valori, int n_input) { double sigmoide_byte(Percettrone p, byte *valori, int n_input) {
double sommatoria = 0.0; double sommatoria = 0.0;
//printf("valori: [%d][%d]", valori[0], valori[1]);
//printf("pesi: [%f][%f]", p.pesi[0], p.pesi[1]);
for(int i = 0; i < n_input; i++) { for(int i = 0; i < n_input; i++) {
sommatoria += ((double)valori[i] * p.pesi[i]); sommatoria += (valori[i] * p.pesi[i]);
} }
//printf("sommatoria= %f\n", sommatoria); //printf("sommatoria= %f\n", sommatoria);
double funzione = sommatoria + p.bias; double funzione = sommatoria + p.bias;
@@ -196,9 +202,9 @@ void correggi_layer_interni(ReteNeurale *rete, double **gradienti, double **sigm
for(int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++) {//Numero percettroni for(int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++) {//Numero percettroni
for(int indice_peso = 0; indice_peso < rete->layers[indice_layer].percettroni[indice_percettrone].size; indice_peso++) {//Numero pesi for(int indice_peso = 0; indice_peso < rete->layers[indice_layer].percettroni[indice_percettrone].size; indice_peso++) {//Numero pesi
//gradienti[indice_layer][indice_percettrone] = gradienti[rete->size-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone])); gradienti[indice_layer][indice_percettrone] = gradienti[rete->size-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));
//rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * sigmoidi[indice_layer-1][indice_percettrone]); rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * sigmoidi[indice_layer-1][indice_percettrone]);
rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[rete->size-1][0] * LRE * sigmoidi[indice_layer-1][indice_percettrone]); //rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[rete->size-1][0] * LRE * sigmoidi[indice_layer-1][indice_percettrone]);
} }
rete->layers[indice_layer].percettroni[indice_percettrone].bias += (gradienti[indice_layer][indice_percettrone] * LRE); rete->layers[indice_layer].percettroni[indice_percettrone].bias += (gradienti[indice_layer][indice_percettrone] * LRE);
//printf("bias: %f\n", rete->layers[indice_layer].percettroni[indice_percettrone].bias); //printf("bias: %f\n", rete->layers[indice_layer].percettroni[indice_percettrone].bias);
@@ -213,9 +219,9 @@ void correggi_layer_input(Layer *layer, double **gradienti, double **sigmoidi, b
for(int indice_percettrone = 0; indice_percettrone < layer->size; indice_percettrone++) {//Numero percettroni for(int indice_percettrone = 0; indice_percettrone < layer->size; indice_percettrone++) {//Numero percettroni
for(int indice_peso = 0; indice_peso < layer->percettroni->size; indice_peso++) { //Numero pesi for(int indice_peso = 0; indice_peso < layer->percettroni->size; indice_peso++) { //Numero pesi
//gradienti[indice_layer][indice_percettrone] = gradienti[n_layers-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone])); gradienti[indice_layer][indice_percettrone] = gradienti[n_layers-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));
//layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * inputs[indice_peso]); layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * inputs[indice_peso]);
layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[n_layers-1][0] * LRE * inputs[indice_peso]); //layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[n_layers-1][0] * LRE * inputs[indice_peso]);
} }
layer->percettroni[indice_percettrone].bias += (gradienti[n_layers-1][0] * LRE); layer->percettroni[indice_percettrone].bias += (gradienti[n_layers-1][0] * LRE);
} }

3
tempCodeRunnerFile.c Normal file
View File

@@ -0,0 +1,3 @@
for(int indice_percettrone = 0; indice_percettrone < PERCETTRONI_LAYER_0; indice_percettrone++) {
printf("percettrone %d -> sigmoide: %f\n", indice_percettrone, sigmoidi[0][indice_percettrone]);
}