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

Change variable's name

Browse Source
This commit is contained in:
Julien Chemillier 2022-04-12 18:19:09 +02:00
parent 9eadb75887
commit 63c2544b45
2 changed files with 49 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/mnist/main.c
View File

@ -42,7 +42,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]->activation = (float)image[i][j] / 255.0; reseau->couches[0]->neurones[i*height+j]->z = (float)image[i][j] / 255.0;
} }
} }
} }

96
src/mnist/neural_network.c
View File

@ -26,23 +26,23 @@ float ReLU(float x){
return max(x, 0); return max(x, 0);
} }
void creation_du_reseau_neuronal(Reseau* reseau_neuronal, int* neurones_par_couche, int nb_couches) { void creation_du_reseau_neuronal(Reseau* reseau, int* neurones_par_couche, int nb_couches) {
/* Créé et alloue de la mémoire aux différentes variables dans le réseau neuronal*/ /* Créé et alloue de la mémoire aux différentes variables dans le réseau neuronal*/
Couche* couche; Couche* couche;
reseau_neuronal->nb_couches = nb_couches; reseau->nb_couches = nb_couches;
reseau_neuronal->couches = (Couche**)malloc(sizeof(Couche*)*nb_couches); reseau->couches = (Couche**)malloc(sizeof(Couche*)*nb_couches);
for (int i=0; i < nb_couches; i++) { for (int i=0; i < nb_couches; i++) {
reseau_neuronal->couches[i] = (Couche*)malloc(sizeof(Couche)); reseau->couches[i] = (Couche*)malloc(sizeof(Couche));
couche = reseau_neuronal->couches[i]; couche = reseau->couches[i];
couche->nb_neurones = neurones_par_couche[i]; // nombre de neurones pour la couche couche->nb_neurones = neurones_par_couche[i]; // nombre de neurones pour la couche
couche->neurones = (Neurone**)malloc(sizeof(Neurone*)*reseau_neuronal->couches[i]->nb_neurones); // Création des différents neurones dans la couche couche->neurones = (Neurone**)malloc(sizeof(Neurone*)*reseau->couches[i]->nb_neurones); // Création des différents neurones dans la couche
for (int j=0; j < couche->nb_neurones; j++) { for (int j=0; j < couche->nb_neurones; j++) {
couche->neurones[j] = (Neurone*)malloc(sizeof(Neurone)); couche->neurones[j] = (Neurone*)malloc(sizeof(Neurone));
if (i != reseau_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants if (i != reseau->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
couche->neurones[j]->poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]);// Création des poids sortants du neurone couche->neurones[j]->poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]);// Création des poids sortants du neurone
couche->neurones[j]->d_poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]); couche->neurones[j]->d_poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]);
} }
@ -53,35 +53,35 @@ 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) {
/* Libère l'espace mémoire alloué aux différentes variables dans la fonction /* Libère l'espace mémoire alloué aux différentes variables dans la fonction
'creation_du_reseau_neuronal' */ 'creation_du_reseau' */
for (int i=0; i<reseau_neuronal->nb_couches; i++) { for (int i=0; i<reseau->nb_couches; i++) {
if (i!=reseau_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants if (i!=reseau->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
for (int j=0; j<reseau_neuronal->couches[i]->nb_neurones; j++) { for (int j=0; j<reseau->couches[i]->nb_neurones; j++) {
free(reseau_neuronal->couches[i]->neurones[j]->poids_sortants); free(reseau->couches[i]->neurones[j]->poids_sortants);
free(reseau_neuronal->couches[i]->neurones[j]->d_poids_sortants); free(reseau->couches[i]->neurones[j]->d_poids_sortants);
} }
} }
free(reseau_neuronal->couches[i]->neurones); // On libère enfin la liste des neurones de la couche free(reseau->couches[i]->neurones); // On libère enfin la liste des neurones de la couche
} }
free(reseau_neuronal); // Pour finir, on libère le réseau neronal contenant la liste des couches free(reseau); // Pour finir, on libère le réseau neronal contenant la liste des couches
} }
void forward_propagation(Reseau* reseau_neuronal) { void forward_propagation(Reseau* reseau) {
/* Effectue une propagation en avant du réseau neuronal lorsque les données /* Effectue une propagation en avant du réseau neuronal lorsque les données
on été insérées dans la première couche. Le résultat de la propagation se on été insérées dans la première couche. Le résultat de la propagation se
trouve dans la dernière couche */ trouve dans la dernière couche */
Couche* couche; // Couche actuelle Couche* couche; // Couche actuelle
Couche* pre_couche; // Couche précédante Couche* pre_couche; // Couche précédante
for (int i=1; i < reseau_neuronal->nb_couches; i++) { // La première couche contient déjà des valeurs for (int i=1; i < reseau->nb_couches; i++) { // La première couche contient déjà des valeurs
couche = reseau_neuronal->couches[i]; couche = reseau->couches[i];
pre_couche = reseau_neuronal->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 = couche->neurones[j]->biais; couche->neurones[j]->z = couche->neurones[j]->biais;
@ -90,7 +90,7 @@ void forward_propagation(Reseau* reseau_neuronal) {
couche->neurones[j]->z += pre_couche->neurones[k]->z * pre_couche->neurones[k]->poids_sortants[i]; // CHECK: ->poids_sortants[k] plutôt que i couche->neurones[j]->z += pre_couche->neurones[k]->z * pre_couche->neurones[k]->poids_sortants[i]; // CHECK: ->poids_sortants[k] plutôt que i
} }
if (i < reseau_neuronal->nb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction ReLU (0 si z<0, z sinon) if (i < reseau->nb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction ReLU (0 si z<0, z sinon)
couche->neurones[j]->z = ReLU(couche->neurones[j]->z); couche->neurones[j]->z = 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é
@ -103,11 +103,11 @@ 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, int pos_nombre_voulu) {
/* Renvoie la liste des sorties voulues à partir du nombre /* Renvoie la liste des sorties voulues à partir du nombre
de couches, de la liste du nombre de neurones par couche et de la de couches, de la liste du nombre de neurones par couche et de la
position du résultat voulue, */ position du résultat voulue, */
int nb_neurones = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; int nb_neurones = reseau->couches[reseau->nb_couches-1]->nb_neurones;
int* sortie_voulue = (int*)malloc(sizeof(int)*nb_neurones); int* sortie_voulue = (int*)malloc(sizeof(int)*nb_neurones);
@ -121,20 +121,20 @@ int* creation_de_la_sortie_voulue(Reseau* reseau_neuronal, int pos_nombre_voulu)
void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue) { void backward_propagation(Reseau* reseau, int* sortie_voulue) {
/* Effectue une propagation en arrière du réseau neuronal */ /* Effectue une propagation en arrière du réseau neuronal */
Neurone* neurone; Neurone* neurone;
Neurone* neurone2; Neurone* neurone2;
// 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=0; i < reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; i++) { for (int i=0; i < reseau->couches[reseau->nb_couches-1]->nb_neurones; i++) {
// On calcule l'erreur de la sortie // On calcule l'erreur de la sortie
neurone = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]; neurone = reseau->couches[reseau->nb_couches-1]->neurones[i];
neurone->d_z = (neurone->z - sortie_voulue[i])*(neurone->z - sortie_voulue[i]); neurone->d_z = (neurone->z - sortie_voulue[i])*(neurone->z - sortie_voulue[i]);
for(int k=0; k<reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->nb_neurones; k++) { // Pour chaque neurone de l'avant dernière couche for(int k=0; k<reseau->couches[reseau->nb_couches-2]->nb_neurones; k++) { // Pour chaque neurone de l'avant dernière couche
neurone2 = reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]; neurone2 = reseau->couches[reseau->nb_couches-2]->neurones[k];
neurone2->d_poids_sortants[i] = neurone->d_z; neurone2->d_poids_sortants[i] = neurone->d_z;
neurone2->d_activation = neurone2->poids_sortants[i] * neurone->d_z; neurone2->d_activation = neurone2->poids_sortants[i] * neurone->d_z;
@ -143,17 +143,17 @@ void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue) {
neurone->d_biais = neurone->d_z; neurone->d_biais = neurone->d_z;
} }
for(int i=reseau_neuronal->nb_couches-2; i > 0; i--) { // On remonte les couche de l'avant dernière jusqu'à la première for(int i=reseau->nb_couches-2; i > 0; i--) { // On remonte les couche de l'avant dernière jusqu'à la première
for(int j=0; j<reseau_neuronal->couches[i]->nb_neurones; j++) { for(int j=0; j<reseau->couches[i]->nb_neurones; j++) {
neurone = reseau_neuronal->couches[i]->neurones[j]; neurone = reseau->couches[i]->neurones[j];
if(neurone->z >= 0) // ??? ... if(neurone->z >= 0) // ??? ...
neurone->d_z = neurone->d_activation; neurone->d_z = neurone->d_activation;
else // ??? ... else // ??? ...
neurone->d_z = 0; neurone->d_z = 0;
for(int k=0; k<reseau_neuronal->couches[i-1]->nb_neurones; k++) { for(int k=0; k<reseau->couches[i-1]->nb_neurones; k++) {
neurone2 = reseau_neuronal->couches[i-1]->neurones[k]; neurone2 = reseau->couches[i-1]->neurones[k];
neurone2->d_poids_sortants[j] = neurone->d_z; neurone2->d_poids_sortants[j] = neurone->d_z;
if(i>1) // ??? ... if(i>1) // ??? ...
@ -168,17 +168,17 @@ void backward_propagation(Reseau* reseau_neuronal, int* sortie_voulue) {
void modification_du_reseau_neuronal(Reseau* reseau_neuronal) { void modification_du_reseau_neuronal(Reseau* reseau) {
/* 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;
for (int i=0; i < reseau_neuronal->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_neuronal->couches[i]->nb_neurones; j++) { for (int j=0; j < reseau->couches[i]->nb_neurones; j++) {
neurone = reseau_neuronal->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 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
for (int k=0; k < reseau_neuronal->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 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
} }
} }
@ -188,7 +188,7 @@ void modification_du_reseau_neuronal(Reseau* reseau_neuronal) {
void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal) { void initialisation_du_reseau_neuronal(Reseau* reseau) {
/* Initialise les variables du réseau neuronal (activation, biais, poids, ...) /* Initialise les variables du réseau neuronal (activation, biais, poids, ...)
en suivant de la méthode de Xavier ...... à partir du nombre de couches et de la liste du nombre de neurone par couche */ en suivant de la méthode de Xavier ...... à partir du nombre de couches et de la liste du nombre de neurone par couche */
Neurone* neurone; Neurone* neurone;
@ -196,17 +196,17 @@ void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal) {
double borne_inferieure; double borne_inferieure;
srand(time(0)); srand(time(0));
for (int i=0; i < reseau_neuronal->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_neuronal->couches[i]->nb_neurones-1; j++) { for (int j=0; j < reseau->couches[i]->nb_neurones-1; j++) {
neurone = reseau_neuronal->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
borne_superieure = 1/sqrt(reseau_neuronal->couches[i]->nb_neurones); borne_superieure = 1/sqrt(reseau->couches[i]->nb_neurones);
borne_inferieure = - borne_superieure; borne_inferieure = - borne_superieure;
neurone->activation = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); neurone->activation = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure);
for (int k=0; k < reseau_neuronal->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-1; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié
neurone->poids_sortants[k] = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // Initialisation des poids sortants aléatoirement neurone->poids_sortants[k] = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // Initialisation des poids sortants aléatoirement
neurone->d_poids_sortants[k] = 0.0; // ... ??? neurone->d_poids_sortants[k] = 0.0; // ... ???
} }
@ -215,12 +215,12 @@ void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal) {
} }
} }
} }
borne_superieure = 1/sqrt(reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones); borne_superieure = 1/sqrt(reseau->couches[reseau->nb_couches-1]->nb_neurones);
borne_inferieure = - borne_superieure; borne_inferieure = - borne_superieure;
for (int j=0; j < reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; j++) {// Intialisation de la dernière couche exclue ci-dessus for (int j=0; j < reseau->couches[reseau->nb_couches-1]->nb_neurones; j++) {// Intialisation de la dernière couche exclue ci-dessus
neurone = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[j]; neurone = reseau->couches[reseau->nb_couches-1]->neurones[j];
neurone->activation = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); neurone->activation = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure);
neurone->biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement neurone->biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement
} }
} }