augustin64/tipe
1
1
Fork 0
mirror of https://github.com/augustin64/projet-tipe synced 2025-01-23 23:26:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add debug options & cleaned code

Browse Source
This commit is contained in:
augustin64 2022-04-22 14:22:45 +02:00
parent 48a95b10db
commit b30bedd375
3 changed files with 51 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/mnist/main.c
View File

@ -46,7 +46,7 @@ void help(char* call) {
void ecrire_image_dans_reseau(int** image, Reseau* reseau, int height, int width) { void ecrire_image_dans_reseau(int** image, Reseau* reseau, int height, int width) {
for (int i=0; i < height; i++) { for (int i=0; i < height; i++) {
for (int j=0; j < width; j++) { for (int j=0; j < width; j++) {
reseau->couches[0]->neurones[i*height+j]->z = (float)image[i][j] / 255.0; reseau->couches[0]->neurones[i*height+j]->z = (float)image[i][j] / 255.0f;
} }
} }
} }
@ -58,7 +58,7 @@ void train(int batches, int couches, int neurons, char* recovery, char* image_fi
//int* repartition = malloc(sizeof(int)*couches); //int* repartition = malloc(sizeof(int)*couches);
int nb_neurones_der = 10; int nb_neurones_der = 10;
int repartition[5] = {784, 100, 75, 40, nb_neurones_der}; int repartition[4] = {784, 16, 16, nb_neurones_der};
float* sortie = malloc(sizeof(float)*nb_neurones_der); float* sortie = malloc(sizeof(float)*nb_neurones_der);
int* sortie_voulue; int* sortie_voulue;
@ -112,7 +112,7 @@ void train(int batches, int couches, int neurons, char* recovery, char* image_fi
} }
printf("\rBatch [%d/%d]\tImage [%d/%d]\tAccuracy: %0.1f%%\n",i, batches, nb_images, nb_images, accuracy*100); printf("\rBatch [%d/%d]\tImage [%d/%d]\tAccuracy: %0.1f%%\n",i, batches, nb_images, nb_images, accuracy*100);
modification_du_reseau_neuronal(reseau); modification_du_reseau_neuronal(reseau, nb_images);
ecrire_reseau(out, reseau); ecrire_reseau(out, reseau);
} }
suppression_du_reseau_neuronal(reseau); suppression_du_reseau_neuronal(reseau);
@ -218,7 +218,7 @@ int main(int argc, char* argv[]) {
} }
if (! strcmp(argv[1], "train")) { if (! strcmp(argv[1], "train")) {
int batches = 5; int batches = 5;
int couches = 5; int couches = 4;
int neurons = 784; int neurons = 784;
char* images = NULL; char* images = NULL;
char* labels = NULL; char* labels = NULL;

71
src/mnist/neural_network.c
View File

@ -1,5 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#include <time.h> #include <time.h>
@ -8,12 +10,15 @@
// Définit le taux d'apprentissage du réseau neuronal, donc la rapidité d'adaptation du modèle (compris entre 0 et 1) // Définit le taux d'apprentissage du réseau neuronal, donc la rapidité d'adaptation du modèle (compris entre 0 et 1)
//Cette valeur peut évoluer au fur et à mesure des époques (linéaire c'est mieux) //Cette valeur peut évoluer au fur et à mesure des époques (linéaire c'est mieux)
#define TAUX_APPRENTISSAGE 0.15 #define TAUX_APPRENTISSAGE 0.015
//Retourne un nombre aléatoire entre 0 et 1 //Retourne un nombre aléatoire entre 0 et 1
#define RAND_DOUBLE() ((double)rand())/((double)RAND_MAX) #define RAND_DOUBLE() ((double)rand())/((double)RAND_MAX)
//Coefficient leaking ReLU //Coefficient leaking ReLU
#define COEFF_LEAKY_RELU 0.2 #define COEFF_LEAKY_RELU 0.2
#define MAX_RESEAU 10 #define MAX_RESEAU 100000
#define PRINT_POIDS false
#define PRINT_BIAIS false
float max(float a, float b){ float max(float a, float b){
@ -21,7 +26,7 @@ float max(float a, float b){
} }
float sigmoid(float x){ float sigmoid(float x){
return 1/(1 - exp(-x)); return 1/(1 + exp(-x));
} }
float sigmoid_derivee(float x){ float sigmoid_derivee(float x){
@ -32,7 +37,7 @@ float sigmoid_derivee(float x){
float leaky_ReLU(float x){ float leaky_ReLU(float x){
if (x > 0) if (x > 0)
return x; return x;
return x*COEFF_LEAKY_RELU; return COEFF_LEAKY_RELU;
} }
float leaky_ReLU_derivee(float x){ float leaky_ReLU_derivee(float x){
@ -99,7 +104,7 @@ void forward_propagation(Reseau* reseau) {
pre_couche = reseau->couches[i-1]; pre_couche = reseau->couches[i-1];
for (int j=0; j < couche->nb_neurones; j++) { for (int j=0; j < couche->nb_neurones; j++) {
couche->neurones[j]->z = sigmoid(couche->neurones[j]->biais)-0.5; couche->neurones[j]->z = couche->neurones[j]->biais;
for (int k=0; k < pre_couche->nb_neurones; k++) { for (int k=0; k < pre_couche->nb_neurones; k++) {
couche->neurones[j]->z += pre_couche->neurones[k]->z * pre_couche->neurones[k]->poids_sortants[j]; couche->neurones[j]->z += pre_couche->neurones[k]->z * pre_couche->neurones[k]->poids_sortants[j];
@ -107,8 +112,7 @@ void forward_propagation(Reseau* reseau) {
if (i < reseau->nb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction leaky_ReLU (a*z si z<0, z sinon) if (i < reseau->nb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction leaky_ReLU (a*z si z<0, z sinon)
couche->neurones[j]->z = leaky_ReLU(couche->neurones[j]->z); couche->neurones[j]->z = leaky_ReLU(couche->neurones[j]->z);
} } else { // Pour la dernière couche on utilise la fonction sigmoid permettant d'obtenir un résultat entre 0 et 1 à savoir une probabilité
else { // Pour la dernière couche on utilise la fonction sigmoid permettant d'obtenir un résultat entre 0 et 1 à savoir une probabilité
couche->neurones[j]->z = sigmoid(couche->neurones[j]->z); couche->neurones[j]->z = sigmoid(couche->neurones[j]->z);
} }
} }
@ -141,39 +145,37 @@ void backward_propagation(Reseau* reseau, int* sortie_voulue) {
Neurone* neurone2; Neurone* neurone2;
float changes; float changes;
int i = reseau->nb_couches-2;
// On commence par parcourir tous les neurones de la couche finale // On commence par parcourir tous les neurones de la couche finale
for (int i=reseau->nb_couches-2; i>=0; i--) {
if (i==reseau->nb_couches-2){
for (int j=0; j<reseau->couches[i]->nb_neurones; j++) {
neurone = reseau->couches[reseau->nb_couches-1]->neurones[i];
changes = sigmoid_derivee(neurone->z)*2*(neurone->z - sortie_voulue[i]);
//neurone->biais = neurone->biais - TAUX_APPRENTISSAGE*changes;
for (int k=0; k<reseau->couches[i+1]->nb_neurones; k++) {
reseau->couches[i]->neurones[j]->d_poids_sortants[k] += reseau->couches[i-1]->neurones[k]->poids_sortants[j]*changes;
}
}
}
else {
for (int j=0; j < reseau->couches[i+1]->nb_neurones; j++) { for (int j=0; j < reseau->couches[i+1]->nb_neurones; j++) {
float changes = 0; neurone = reseau->couches[i+1]->neurones[j];
for (int k=0; k<reseau->couches[i+2]->nb_neurones; k++) { changes = sigmoid_derivee(neurone->z)*2*(neurone->z - sortie_voulue[j]);
changes += reseau->couches[i+1]->neurones[j]->poids_sortants[k]*reseau->couches[i+1]->neurones[j]->d_poids_sortants[k];
}
changes = changes*leaky_ReLU_derivee(reseau->couches[i+1]->neurones[j]->z);
reseau->couches[i+1]->neurones[j]->d_biais += changes;
for (int k=0; k < reseau->couches[i]->nb_neurones; k++) { for (int k=0; k < reseau->couches[i]->nb_neurones; k++) {
reseau->couches[i]->neurones[k]->d_poids_sortants[j] += reseau->couches[i]->neurones[k]->poids_sortants[j]*changes; reseau->couches[i]->neurones[k]->d_poids_sortants[j] += reseau->couches[i]->neurones[k]->poids_sortants[j]*changes;
} }
} }
i--;
for (; i >= 0; i--) {
for (int j=0; j < reseau->couches[i+1]->nb_neurones; j++) {
changes = 0;
for (int k=0; k < reseau->couches[i+2]->nb_neurones; k++) {
//printf("Couche %d Neurone %d Poids %f\n", i+1, j, reseau->couches[i+1]->neurones[j]->poids_sortants[k]);
changes += (reseau->couches[i+1]->neurones[j]->poids_sortants[k]*reseau->couches[i+1]->neurones[j]->d_poids_sortants[k])/reseau->couches[i+1]->nb_neurones;
}
changes = changes*leaky_ReLU_derivee(reseau->couches[i+1]->neurones[j]->z);
reseau->couches[i+1]->neurones[j]->d_biais += changes;
for (int l=0; l < reseau->couches[i]->nb_neurones; l++){
//printf("%f\n", changes);
reseau->couches[i]->neurones[l]->d_poids_sortants[j] += reseau->couches[i]->neurones[l]->poids_sortants[j]*changes;
}
} }
} }
//mise_a_jour_parametres(reseau);
} }
void modification_du_reseau_neuronal(Reseau* reseau) { void modification_du_reseau_neuronal(Reseau* reseau, uint32_t nb_modifs) {
/* Modifie les poids et le biais des neurones du réseau neuronal à partir /* Modifie les poids et le biais des neurones du réseau neuronal à partir
du nombre de couches et de la liste du nombre de neurone par couche */ du nombre de couches et de la liste du nombre de neurone par couche */
Neurone* neurone; Neurone* neurone;
@ -181,16 +183,23 @@ void modification_du_reseau_neuronal(Reseau* reseau) {
for (int i=0; i < reseau->nb_couches-1; i++) { // on exclut la dernière couche for (int i=0; i < reseau->nb_couches-1; i++) { // on exclut la dernière couche
for (int j=0; j < reseau->couches[i]->nb_neurones; j++) { for (int j=0; j < reseau->couches[i]->nb_neurones; j++) {
neurone = reseau->couches[i]->neurones[j]; neurone = reseau->couches[i]->neurones[j];
neurone->biais = neurone->biais + TAUX_APPRENTISSAGE * neurone->d_biais; // On modifie le biais du neurone à partir des données de la propagation en arrière if (neurone->biais != 0 && PRINT_BIAIS)
printf("C %d\tN %d\tb: %f \tDb: %f\n", i, j, neurone->biais, (TAUX_APPRENTISSAGE/nb_modifs) * neurone->d_biais);
neurone->biais -= (TAUX_APPRENTISSAGE/nb_modifs) * neurone->d_biais; // On modifie le biais du neurone à partir des données de la propagation en arrière
neurone->d_biais = 0; neurone->d_biais = 0;
if (neurone->biais > MAX_RESEAU) if (neurone->biais > MAX_RESEAU)
neurone->biais = MAX_RESEAU; neurone->biais = MAX_RESEAU;
else if (neurone->biais < -MAX_RESEAU) else if (neurone->biais < -MAX_RESEAU)
neurone->biais = -MAX_RESEAU; neurone->biais = -MAX_RESEAU;
for (int k=0; k < reseau->couches[i+1]->nb_neurones; k++) { for (int k=0; k < reseau->couches[i+1]->nb_neurones; k++) {
neurone->poids_sortants[k] = neurone->poids_sortants[k] - (TAUX_APPRENTISSAGE * neurone->d_poids_sortants[k]); // On modifie le poids du neurone à partir des données de la propagation en arrière if (neurone->poids_sortants[k] != 0 && PRINT_POIDS)
printf("C %d\tN %d -> %d\tp: %f \tDp: %f\n", i, j, k, neurone->poids_sortants[k], (TAUX_APPRENTISSAGE/nb_modifs) * neurone->d_poids_sortants[k]);
neurone->poids_sortants[k] -= (TAUX_APPRENTISSAGE/nb_modifs) * neurone->d_poids_sortants[k]; // On modifie le poids du neurone à partir des données de la propagation en arrière
neurone->d_poids_sortants[k] = 0; neurone->d_poids_sortants[k] = 0;
if (neurone->poids_sortants[k] > MAX_RESEAU) if (neurone->poids_sortants[k] > MAX_RESEAU)
neurone->poids_sortants[k] = MAX_RESEAU; neurone->poids_sortants[k] = MAX_RESEAU;
else if (neurone->poids_sortants[k] < -MAX_RESEAU) else if (neurone->poids_sortants[k] < -MAX_RESEAU)
@ -213,7 +222,7 @@ void initialisation_du_reseau_neuronal(Reseau* reseau) {
srand(time(0)); srand(time(0));
for (int i=0; i < reseau->nb_couches-1; i++) { // On exclut la dernière couche for (int i=0; i < reseau->nb_couches-1; i++) { // On exclut la dernière couche
for (int j=0; j < reseau->couches[i]->nb_neurones-1; j++) { for (int j=0; j < reseau->couches[i]->nb_neurones; j++) {
neurone = reseau->couches[i]->neurones[j]; neurone = reseau->couches[i]->neurones[j];
// Initialisation des bornes supérieure et inférieure // Initialisation des bornes supérieure et inférieure
@ -223,7 +232,7 @@ void initialisation_du_reseau_neuronal(Reseau* reseau) {
neurone->activation = borne_inferieure + RAND_DOUBLE()*ecart_bornes; neurone->activation = borne_inferieure + RAND_DOUBLE()*ecart_bornes;
for (int k=0; k < reseau->couches[i+1]->nb_neurones-1; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié for (int k=0; k < reseau->couches[i+1]->nb_neurones; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié
neurone->poids_sortants[k] = borne_inferieure + RAND_DOUBLE()*ecart_bornes; // Initialisation des poids sortants aléatoirement neurone->poids_sortants[k] = borne_inferieure + RAND_DOUBLE()*ecart_bornes; // Initialisation des poids sortants aléatoirement
} }
if (i > 0) {// Pour tous les neurones n'étant pas dans la première couche if (i > 0) {// Pour tous les neurones n'étant pas dans la première couche

3
src/mnist/neural_network.h
View File

@ -18,9 +18,8 @@ void creation_du_reseau_neuronal(Reseau* reseau_neuronal, int* neurones_par_couc
void suppression_du_reseau_neuronal(Reseau* reseau_neuronal); void suppression_du_reseau_neuronal(Reseau* reseau_neuronal);
void forward_propagation(Reseau* reseau_neuronal); void forward_propagation(Reseau* reseau_neuronal);
int* creation_de_la_sortie_voulue(Reseau* reseau_neuronal, int pos_nombre_voulu); int* creation_de_la_sortie_voulue(Reseau* reseau_neuronal, int pos_nombre_voulu);
void mise_a_jour_parametres(Reseau* reseau);
void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue); void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue);
void modification_du_reseau_neuronal(Reseau* reseau_neuronal); void modification_du_reseau_neuronal(Reseau* reseau_neuronal, uint32_t nb_modifs);
void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal); void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal);
float erreur_sortie(Reseau* reseau, int numero_voulu); float erreur_sortie(Reseau* reseau, int numero_voulu);