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

Change struct names

Browse Source
This commit is contained in:
Julien Chemillier 2022-03-28 13:29:29 +02:00
parent 058dcf7239
commit 991ecebcf4
4 changed files with 55 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/mnist/neural_network.c
View File

@ -24,15 +24,15 @@ void creation_du_reseau_neuronal(int* neurones_par_couche) {
/* Créé les différentes variables dans la variable du réseau neuronal à /* Créé les différentes variables dans la variable du réseau neuronal à
partir du nombre de couches et de la liste du nombre de neurones par couche */ partir du nombre de couches et de la liste du nombre de neurones par couche */
reseau_neuronal->couche = (Couche*)malloc(sizeof(Couche)*reseau_neuronal->nb_couche); // Création des différentes couches reseau_neuronal->couches = (Couche**)malloc(sizeof(Couche*)*reseau_neuronal->nb_couches); // Création des différentes couches
for (int i=0; i<reseau_neuronal->nb_couche; i++) { for (int i=0; i<reseau_neuronal->nb_couches; i++) {
reseau_neuronal->couche[i].nb_neurone = neurones_par_couche[i]; // nombre de neurones pour la couche reseau_neuronal->couches[i]->nb_neurones = neurones_par_couche[i]; // nombre de neurones pour la couche
reseau_neuronal->couche[i].neurone = (Neurone*)malloc(sizeof(Neurone)*neurones_par_couche[i]); // Création des différents neurones dans la couche reseau_neuronal->couches[i]->neurones = (Neurone**)malloc(sizeof(Neurone*)*neurones_par_couche[i]); // Création des différents neurones dans la couche
if (i!=reseau_neuronal->nb_couche-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants if (i!=reseau_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
for (int j=0; j<neurones_par_couche[i]; j++) { for (int j=0; j<neurones_par_couche[i]; j++) {
reseau_neuronal->couche[i].neurone[j].poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]) ;// Création des poids sortants du neurone reseau_neuronal->couches[i]->neurones[j]->poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]) ;// Création des poids sortants du neurone
} }
} }
} }
@ -46,13 +46,13 @@ void suppression_du_reseau_neuronal(int* neurones_par_couche) {
'creation_du_reseau_neuronal' à partir du nombre de couche et de la liste du 'creation_du_reseau_neuronal' à partir du nombre de couche et de la liste du
nombre de neurone par couche */ nombre de neurone par couche */
for (int i=0; i<reseau_neuronal->nb_couche; i++) { for (int i=0; i<reseau_neuronal->nb_couches; i++) {
if (i!=reseau_neuronal->nb_couche-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants if (i!=reseau_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
for (int j=0; j<neurones_par_couche[i]; j++) { for (int j=0; j<neurones_par_couche[i]; j++) {
free(reseau_neuronal->couche[i].neurone[j].poids_sortants); // On libère la variables des poids sortants free(reseau_neuronal->couches[i]->neurones[j]->poids_sortants); // On libère la variables des poids sortants
} }
} }
free(reseau_neuronal->couche[i].neurone); // On libère enfin la liste des neurones de la couche free(reseau_neuronal->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_neuronal); // Pour finir, on libère le réseau neronal contenant la liste des couches
} }
@ -64,22 +64,22 @@ void forward_propagation(int* neurones_par_couche) {
/* Effectue une propagation en avant du réseau neuronal à partir du nombre /* Effectue une propagation en avant du réseau neuronal à partir du nombre
de couches et de la liste du nombre de neurones par couche */ de couches et de la liste du nombre de neurones par couche */
for (int i=1; i<reseau_neuronal->nb_couche; i++) { // La première couche contient déjà des valeurs for (int i=1; i<reseau_neuronal->nb_couches; i++) { // La première couche contient déjà des valeurs
for (int j=0; j<neurones_par_couche[i];j++) { // Pour chaque neurone de la couche for (int j=0; j<neurones_par_couche[i];j++) { // Pour chaque neurone de la couche
reseau_neuronal->couche[i].neurone[j].z = reseau_neuronal->couche[i].neurone[j].biais; // On réinitialise l'utilisation actuelle du neurone à son biais reseau_neuronal->couches[i]->neurones[j]->z = reseau_neuronal->couches[i]->neurones[j]->biais; // On réinitialise l'utilisation actuelle du neurone à son biais
for (int k=0; k<neurones_par_couche[i-1]; k++) { for (int k=0; k<neurones_par_couche[i-1]; k++) {
reseau_neuronal->couche[i].neurone[j].z += reseau_neuronal->couche[i-1].neurone[k].activation * reseau_neuronal->couche[i-1].neurone[k].z * reseau_neuronal->couche[i-1].neurone[k].poids_sortants[i]; // ??? reseau_neuronal->couches[i]->neurones[j]->z += reseau_neuronal->couches[i-1]->neurones[k]->activation * reseau_neuronal->couches[i-1]->neurones[k]->z * reseau_neuronal->couches[i-1]->neurones[k]->poids_sortants[i]; // ???
} }
if (i<reseau_neuronal->nb_couche-1) { // Pour toutes les couches sauf la dernière on utilise la fonction relu if (i<reseau_neuronal->nb_couches-1) { // Pour toutes les couches sauf la dernière on utilise la fonction relu
if (reseau_neuronal->couche[i].neurone[j].z < 0) if (reseau_neuronal->couches[i]->neurones[j]->z < 0)
reseau_neuronal->couche[i].neurone[j].activation = 0; reseau_neuronal->couches[i]->neurones[j]->activation = 0;
else else
reseau_neuronal->couche[i].neurone[j].activation = reseau_neuronal->couche[i].neurone[j].z; reseau_neuronal->couches[i]->neurones[j]->activation = reseau_neuronal->couches[i]->neurones[j]->z;
} }
else{ // Pour la dernière couche on utilise la fonction sigmoid permettant d'obtenir un résultat entre 0 et 1 étant une probabilité else{ // Pour la dernière couche on utilise la fonction sigmoid permettant d'obtenir un résultat entre 0 et 1 étant une probabilité
reseau_neuronal->couche[i].neurone[j].activation = 1/(1 + exp(reseau_neuronal->couche[i].neurone[j].activation)); reseau_neuronal->couches[i]->neurones[j]->activation = 1/(1 + exp(reseau_neuronal->couches[i]->neurones[j]->activation));
} }
} }
} }
@ -94,7 +94,7 @@ int* creation_de_la_sortie_voulue(int* neurones_par_couche, int pos_nombre_voulu
position du résultat voulue, */ position du résultat voulue, */
int* sortie_voulue = (int*)malloc(sizeof(int)); int* sortie_voulue = (int*)malloc(sizeof(int));
for (int i=0; i<neurones_par_couche[reseau_neuronal->nb_couche-1]; i++) // On initialise toutes les sorties à 0 par défault for (int i=0; i<neurones_par_couche[reseau_neuronal->nb_couches-1]; i++) // On initialise toutes les sorties à 0 par défault
sortie_voulue[i]=0; sortie_voulue[i]=0;
sortie_voulue[pos_nombre_voulu]=1; // Seule la sortie voulue vaut 1 sortie_voulue[pos_nombre_voulu]=1; // Seule la sortie voulue vaut 1
return sortie_voulue; return sortie_voulue;
@ -109,31 +109,31 @@ void backward_propagation(int* neurones_par_couche, int* sortie_voulue) {
la liste des sorties voulues*/ la liste des sorties voulues*/
// 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<neurones_par_couche[reseau_neuronal->nb_couche-1]; i++) { for (int i=0; i<neurones_par_couche[reseau_neuronal->nb_couches-1]; i++) {
// On applique la formule de propagation en arrière // On applique la formule de propagation en arrière
reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz = (reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].activation - sortie_voulue[i]) * (reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].activation) * (1- reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].activation); reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz = (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->activation - sortie_voulue[i]) * (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->activation) * (1- reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->activation);
for(int k=0; k<neurones_par_couche[reseau_neuronal->nb_couche-2]; k++) { // Pour chaque neurone de l'avant dernière couche for(int k=0; k<neurones_par_couche[reseau_neuronal->nb_couches-2]; k++) { // Pour chaque neurone de l'avant dernière couche
reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].dw[i] = (reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz * reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].activation); reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->dw[i] = (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz * reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->activation);
reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].dactivation = reseau_neuronal->couche[reseau_neuronal->nb_couche-2].neurone[k].poids_sortants[i] * reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz; reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->dactivation = reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->poids_sortants[i] * reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz;
} }
// ??? // ???
reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dbiais = reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[i].dz; reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dbiais = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz;
} }
for(int i=reseau_neuronal->nb_couche-2; i>0; i--) { // On remonte les couche de l'avant dernière jusqu'à la première 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 j=0; j<neurones_par_couche[i]; j++) { for(int j=0; j<neurones_par_couche[i]; j++) {
if(reseau_neuronal->couche[i].neurone[j].z >= 0) // ??? ... if(reseau_neuronal->couches[i]->neurones[j]->z >= 0) // ??? ...
reseau_neuronal->couche[i].neurone[j].dz = reseau_neuronal->couche[i].neurone[j].dactivation; reseau_neuronal->couches[i]->neurones[j]->dz = reseau_neuronal->couches[i]->neurones[j]->dactivation;
else // ??? ... else // ??? ...
reseau_neuronal->couche[i].neurone[j].dz = 0; reseau_neuronal->couches[i]->neurones[j]->dz = 0;
for(int k=0; k<neurones_par_couche[i-1]; k++) { for(int k=0; k<neurones_par_couche[i-1]; k++) {
reseau_neuronal->couche[i-1].neurone[k].dw[j] = reseau_neuronal->couche[i].neurone[j].dz * reseau_neuronal->couche[i-1].neurone[k].activation; reseau_neuronal->couches[i-1]->neurones[k]->dw[j] = reseau_neuronal->couches[i]->neurones[j]->dz * reseau_neuronal->couches[i-1]->neurones[k]->activation;
if(i>1) // ??? ... if(i>1) // ??? ...
reseau_neuronal->couche[i-1].neurone[k].dactivation = reseau_neuronal->couche[i-1].neurone[k].poids_sortants[j] * reseau_neuronal->couche[i].neurone[j].dz; reseau_neuronal->couches[i-1]->neurones[k]->dactivation = reseau_neuronal->couches[i-1]->neurones[k]->poids_sortants[j] * reseau_neuronal->couches[i]->neurones[j]->dz;
} }
reseau_neuronal->couche[i].neurone[j].dbiais = reseau_neuronal->couche[i].neurone[j].dz; // ??? ... reseau_neuronal->couches[i]->neurones[j]->dbiais = reseau_neuronal->couches[i]->neurones[j]->dz; // ??? ...
} }
} }
@ -146,11 +146,11 @@ void modification_du_reseau_neuronal(int* neurones_par_couche) {
/* 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 */
for (int i=0; i<reseau_neuronal->nb_couche-1; i++) { // on exclut la dernière couche for (int i=0; i<reseau_neuronal->nb_couches-1; i++) { // on exclut la dernière couche
for (int j=0; i<neurones_par_couche[i]; j++) { for (int j=0; i<neurones_par_couche[i]; j++) {
reseau_neuronal->couche[i].neurone[j].biais = reseau_neuronal->couche[i].neurone[j].biais - (TAUX_APPRENTISSAGE * reseau_neuronal->couche[i].neurone[j].dbiais); // On modifie le biais du neurone à partir des données de la propagation en arrière reseau_neuronal->couches[i]->neurones[j]->biais = reseau_neuronal->couches[i]->neurones[j]->biais - (TAUX_APPRENTISSAGE * reseau_neuronal->couches[i]->neurones[j]->dbiais); // On modifie le biais du neurone à partir des données de la propagation en arrière
for (int k=0; k<neurones_par_couche[i+1]; k++) { for (int k=0; k<neurones_par_couche[i+1]; k++) {
reseau_neuronal->couche[i].neurone[j].poids_sortants[k] = reseau_neuronal->couche[i].neurone[j].poids_sortants[k] - (TAUX_APPRENTISSAGE * reseau_neuronal->couche[i].neurone[j].dw[k]); // On modifie le poids du neurone à partir des données de la propagation en arrière reseau_neuronal->couches[i]->neurones[j]->poids_sortants[k] = reseau_neuronal->couches[i]->neurones[j]->poids_sortants[k] - (TAUX_APPRENTISSAGE * reseau_neuronal->couches[i]->neurones[j]->dw[k]); // On modifie le poids du neurone à partir des données de la propagation en arrière
} }
} }
} }
@ -163,21 +163,21 @@ void initialisation_du_reseau_neuronal(int* neurones_par_couche) {
/* 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 */
srand(time(0)); srand(time(0));
for (int i=0; i<reseau_neuronal->nb_couche-1; i++) { // on exclut la dernière couche for (int i=0; i<reseau_neuronal->nb_couches-1; i++) { // on exclut la dernière couche
for (int j=0; j<neurones_par_couche[i]-1; j++) { for (int j=0; j<neurones_par_couche[i]-1; j++) {
// Initialisation des bornes supérieure et inférieure // Initialisation des bornes supérieure et inférieure
double borne_superieure = 1/sqrt(neurones_par_couche[i]); double borne_superieure = 1/sqrt(neurones_par_couche[i]);
double borne_inferieure = - borne_superieure; double borne_inferieure = - borne_superieure;
for (int k=0; k<neurones_par_couche[i+1]-1; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié for (int k=0; k<neurones_par_couche[i+1]-1; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié
reseau_neuronal->couche[i].neurone[j].poids_sortants[k] = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // Initialisation des poids sortants aléatoirement reseau_neuronal->couches[i]->neurones[j]->poids_sortants[k] = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // Initialisation des poids sortants aléatoirement
reseau_neuronal->couche[i].neurone[j].dw[k] = 0.0; // ... ??? reseau_neuronal->couches[i]->neurones[j]->dw[k] = 0.0; // ... ???
} }
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
reseau_neuronal->couche[i].neurone[j].biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement reseau_neuronal->couches[i]->neurones[j]->biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement
} }
} }
double borne_superieure = 1/sqrt(neurones_par_couche[reseau_neuronal->nb_couche-1]); double borne_superieure = 1/sqrt(neurones_par_couche[reseau_neuronal->nb_couches-1]);
double borne_inferieure = - borne_superieure; double borne_inferieure = - borne_superieure;
for (int j=0; j<neurones_par_couche[reseau_neuronal->nb_couche-1]; j++) // Pour chaque neurone de la dernière couche for (int j=0; j<neurones_par_couche[reseau_neuronal->nb_couches-1]; j++) // Pour chaque neurone de la dernière couche
reseau_neuronal->couche[reseau_neuronal->nb_couche-1].neurone[j].biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[j]->biais = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure); // On initialise le biais aléatoirement
} }

8
src/mnist/neuron_io.c
View File

@ -70,7 +70,7 @@ void ecrire_neurone(Neurone* neurone, int poids_sortants, FILE *ptr) {
// Stocke l'entièreté du réseau neuronal dans un fichier binaire // Stocke l'entièreté du réseau neuronal dans un fichier binaire
int ecrire_reseau(char* filename, Reseau* reseau) { int ecrire_reseau(char* filename, Reseau* reseau) {
FILE *ptr; FILE *ptr;
int nb_couches = reseau->nb_couche; int nb_couches = reseau->nb_couches;
int nb_neurones[nb_couches+1]; int nb_neurones[nb_couches+1];
ptr = fopen(filename, "wb"); ptr = fopen(filename, "wb");
@ -80,8 +80,8 @@ int ecrire_reseau(char* filename, Reseau* reseau) {
buffer[0] = MAGIC_NUMBER; buffer[0] = MAGIC_NUMBER;
buffer[1] = nb_couches; buffer[1] = nb_couches;
for (int i=0; i < nb_couches; i++) { for (int i=0; i < nb_couches; i++) {
buffer[i+2] = reseau->couche[i]->nb_neurone; buffer[i+2] = reseau->couches[i]->nb_neurones;
nb_neurones[i] = reseau->couche[i]->nb_neurone; nb_neurones[i] = reseau->couches[i]->nb_neurones;
} }
nb_neurones[nb_couches] = 0; nb_neurones[nb_couches] = 0;
@ -89,7 +89,7 @@ int ecrire_reseau(char* filename, Reseau* reseau) {
for (int i=0; i < nb_couches; i++) { for (int i=0; i < nb_couches; i++) {
for (int j=0; j < nb_neurones[i]; j++) { for (int j=0; j < nb_neurones[i]; j++) {
ecrire_neurone(reseau->couche[i]->neurone[j], nb_neurones[i+1], ptr); ecrire_neurone(reseau->couches[i]->neurones[j], nb_neurones[i+1], ptr);
} }
} }

8
src/mnist/struct/neuron.c
View File

@ -12,11 +12,11 @@ typedef struct Neurone{
typedef struct Couche{ typedef struct Couche{
int nb_neurone; // Nombre de neurones dans la couche (longueur de la liste ci-dessous) int nb_neurones; // Nombre de neurones dans la couche (longueur de la liste ci-dessous)
Neurone** neurone; // Liste des neurones dans la couche Neurone** neurones; // Liste des neurones dans la couche
} Couche; } Couche;
typedef struct Reseau{ typedef struct Reseau{
int nb_couche; int nb_couches;
Couche** couche; Couche** couches;
} Reseau; } Reseau;

10
test/neuron_io.c
View File

@ -30,8 +30,8 @@ Couche* creer_couche(int nb_neurones, int nb_sortants) {
Couche* couche = malloc(sizeof(int)+sizeof(Neurone**)); Couche* couche = malloc(sizeof(int)+sizeof(Neurone**));
Neurone** tab = malloc(sizeof(Neurone*)*nb_neurones); Neurone** tab = malloc(sizeof(Neurone*)*nb_neurones);
couche->nb_neurone = nb_neurones; couche->nb_neurones = nb_neurones;
couche->neurone = tab; couche->neurones = tab;
for (int i=0; i<nb_neurones; i++) { for (int i=0; i<nb_neurones; i++) {
tab[i] = creer_neurone(nb_sortants); tab[i] = creer_neurone(nb_sortants);
@ -42,10 +42,10 @@ Couche* creer_couche(int nb_neurones, int nb_sortants) {
Reseau* creer_reseau(int nb_couches, int nb_max_neurones, int nb_min_neurones) { Reseau* creer_reseau(int nb_couches, int nb_max_neurones, int nb_min_neurones) {
Reseau* reseau = malloc(sizeof(int)+sizeof(Couche**)); Reseau* reseau = malloc(sizeof(int)+sizeof(Couche**));
reseau->couche = malloc(sizeof(Couche*)*nb_couches); reseau->couches = malloc(sizeof(Couche*)*nb_couches);
int nb_neurones[nb_couches+1]; int nb_neurones[nb_couches+1];
reseau->nb_couche = nb_couches; reseau->nb_couches = nb_couches;
for (int i=0; i < nb_couches; i++) { for (int i=0; i < nb_couches; i++) {
nb_neurones[i] = i*(nb_min_neurones-nb_max_neurones)/(nb_couches-1) + nb_max_neurones; nb_neurones[i] = i*(nb_min_neurones-nb_max_neurones)/(nb_couches-1) + nb_max_neurones;
@ -53,7 +53,7 @@ Reseau* creer_reseau(int nb_couches, int nb_max_neurones, int nb_min_neurones) {
nb_neurones[nb_couches] = 0; nb_neurones[nb_couches] = 0;
for (int i=0; i < nb_couches; i++) { for (int i=0; i < nb_couches; i++) {
reseau->couche[i] = creer_couche(nb_neurones[i], nb_neurones[i+1]); reseau->couches[i] = creer_couche(nb_neurones[i], nb_neurones[i+1]);
} }
return reseau; return reseau;
} }