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

Suppression de variables inutiles

Browse Source
This commit is contained in:
Julien Chemillier 2022-03-28 13:53:16 +02:00
parent 991ecebcf4
commit 9399908ea3
1 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/mnist/neural_network.c
View File

@ -10,29 +10,29 @@
Reseau* reseau_neuronal; Reseau* reseau_neuronal;
void creation_du_reseau_neuronal(int* neurones_par_couche); void creation_du_reseau_neuronal(int* neurones_par_couche, int nb_couches);
void suppression_du_reseau_neuronal(int* neurones_par_couche); void suppression_du_reseau_neuronal();
void forward_propagation(int* neurones_par_couche); void forward_propagation();
int* creation_de_la_sortie_voulue(int* neurones_par_couche, int pos_nombre_voulu); int* creation_de_la_sortie_voulue(int pos_nombre_voulu);
void backward_propagation(int* neurones_par_couche, int* sortie_voulue); void backward_propagation(int* sortie_voulue);
void modification_du_reseau_neuronal(int* neurones_par_couche); void modification_du_reseau_neuronal();
void initialisation_du_reseau_neuronal(int* neurones_par_couche); void initialisation_du_reseau_neuronal();
void creation_du_reseau_neuronal(int* neurones_par_couche) { void creation_du_reseau_neuronal(int* neurones_par_couche, int nb_couches) {
/* 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->nb_couches = nb_couches;
reseau_neuronal->couches = (Couche**)malloc(sizeof(Couche*)*reseau_neuronal->nb_couches); // 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_couches; i++) { for (int i=0; i<reseau_neuronal->nb_couches; i++) {
reseau_neuronal->couches[i]->nb_neurones = 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->couches[i]->neurones = (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*)*reseau_neuronal->couches[i]->nb_neurones); // Création des différents neurones dans la couche
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_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<reseau_neuronal->couches[i]->nb_neurones; j++) {
reseau_neuronal->couches[i]->neurones[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)*reseau_neuronal->couches[i+1]->nb_neurones) ;// Création des poids sortants du neurone
} }
} }
} }
@ -41,14 +41,14 @@ void creation_du_reseau_neuronal(int* neurones_par_couche) {
void suppression_du_reseau_neuronal(int* neurones_par_couche) { void suppression_du_reseau_neuronal() {
/* 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' à 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_couches; i++) { for (int i=0; i<reseau_neuronal->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_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<reseau_neuronal->couches[i]->nb_neurones; j++) {
free(reseau_neuronal->couches[i]->neurones[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
} }
} }
@ -60,15 +60,15 @@ void suppression_du_reseau_neuronal(int* neurones_par_couche) {
void forward_propagation(int* neurones_par_couche) { void forward_propagation() {
/* 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_couches; 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<reseau_neuronal->couches[i]->nb_neurones;j++) { // Pour chaque neurone de la couche
reseau_neuronal->couches[i]->neurones[j]->z = reseau_neuronal->couches[i]->neurones[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<reseau_neuronal->couches[i-1]->nb_neurones; k++) {
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]; // ??? 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]; // ???
} }
@ -88,13 +88,13 @@ void forward_propagation(int* neurones_par_couche) {
int* creation_de_la_sortie_voulue(int* neurones_par_couche, int pos_nombre_voulu) { int* creation_de_la_sortie_voulue(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* sortie_voulue = (int*)malloc(sizeof(int)); int* sortie_voulue = (int*)malloc(sizeof(int));
for (int i=0; i<neurones_par_couche[reseau_neuronal->nb_couches-1]; i++) // On initialise toutes les sorties à 0 par défault for (int i=0; i<reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; 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;
@ -103,17 +103,17 @@ int* creation_de_la_sortie_voulue(int* neurones_par_couche, int pos_nombre_voulu
void backward_propagation(int* neurones_par_couche, int* sortie_voulue) { void backward_propagation(int* sortie_voulue) {
/* Effectue une propagation en arrière du réseau neuronal à partir du /* Effectue une propagation en arrière du réseau neuronal à partir du
nombre de couches, de la liste du nombre de neurone par couche et de nombre de couches, de la liste du nombre de neurone par couche et de
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_couches-1]; i++) { for (int i=0; i<reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; i++) {
// On applique la formule de propagation en arrière // On applique la formule de propagation en arrière
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); 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_couches-2]; k++) { // Pour chaque neurone de l'avant dernière couche 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
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->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->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->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;
} }
@ -122,13 +122,13 @@ void backward_propagation(int* neurones_par_couche, int* sortie_voulue) {
} }
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_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<reseau_neuronal->couches[i]->nb_neurones; j++) {
if(reseau_neuronal->couches[i]->neurones[j]->z >= 0) // ??? ... if(reseau_neuronal->couches[i]->neurones[j]->z >= 0) // ??? ...
reseau_neuronal->couches[i]->neurones[j]->dz = reseau_neuronal->couches[i]->neurones[j]->dactivation; reseau_neuronal->couches[i]->neurones[j]->dz = reseau_neuronal->couches[i]->neurones[j]->dactivation;
else // ??? ... else // ??? ...
reseau_neuronal->couches[i]->neurones[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<reseau_neuronal->couches[i-1]->nb_neurones; k++) {
reseau_neuronal->couches[i-1]->neurones[k]->dw[j] = reseau_neuronal->couches[i]->neurones[j]->dz * reseau_neuronal->couches[i-1]->neurones[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->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->couches[i-1]->neurones[k]->dactivation = reseau_neuronal->couches[i-1]->neurones[k]->poids_sortants[j] * reseau_neuronal->couches[i]->neurones[j]->dz;
@ -142,14 +142,14 @@ void backward_propagation(int* neurones_par_couche, int* sortie_voulue) {
void modification_du_reseau_neuronal(int* neurones_par_couche) { void modification_du_reseau_neuronal() {
/* 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_couches-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<reseau_neuronal->couches[i]->nb_neurones; j++) {
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 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<reseau_neuronal->couches[i+1]->nb_neurones; k++) {
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 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
} }
} }
@ -159,16 +159,16 @@ void modification_du_reseau_neuronal(int* neurones_par_couche) {
void initialisation_du_reseau_neuronal(int* neurones_par_couche) { void initialisation_du_reseau_neuronal() {
/* 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_couches-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<reseau_neuronal->couches[i]->nb_neurones-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(reseau_neuronal->couches[i]->nb_neurones);
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<reseau_neuronal->couches[i+1]->nb_neurones-1; k++) { // Pour chaque neurone de la couche suivante auquel le neurone est relié
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->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->couches[i]->neurones[j]->dw[k] = 0.0; // ... ??? reseau_neuronal->couches[i]->neurones[j]->dw[k] = 0.0; // ... ???
} }
@ -176,8 +176,8 @@ void initialisation_du_reseau_neuronal(int* neurones_par_couche) {
reseau_neuronal->couches[i]->neurones[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_couches-1]); double borne_superieure = 1/sqrt(reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones);
double borne_inferieure = - borne_superieure; double borne_inferieure = - borne_superieure;
for (int j=0; j<neurones_par_couche[reseau_neuronal->nb_couches-1]; j++) // Pour chaque neurone de la dernière couche for (int j=0; j<reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; j++) // Pour chaque neurone de la dernière couche
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 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
} }