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

Rename variables

Browse Source
This commit is contained in:
Julien Chemillier 2022-04-05 09:08:39 +02:00
parent 8c46c16fd7
commit c7e0b50759
5 changed files with 74 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
src/mnist/neural_network.c
View File

@ -9,23 +9,39 @@
#define TAUX_APPRENTISSAGE 0.15 // Définit le taux d'apprentissage du réseau neuronal, donc la rapidité d'adaptation du modèle (compris entre 0 et 1) #define TAUX_APPRENTISSAGE 0.15 // Définit le taux d'apprentissage du réseau neuronal, donc la rapidité d'adaptation du modèle (compris entre 0 et 1)
float max(float a, float b){
return a<b?b:a;
}
float sigmoid(float x){
return 1/(1 + exp(x));
}
float sigmoid_derivee(float x){
float tmp = exp(-x);
return tmp/((1 + tmp)*(1+tmp));
}
float ReLU(float x){
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_neuronal, int* neurones_par_couche, int nb_couches) {
/* Créé les différentes variables dans la variable du réseau neuronal à /* Créé et alloue de la mémoire aux différentes variables dans le réseau neuronal*/
partir du nombre de couches et de la liste du nombre de neurones par couche */
reseau_neuronal->nb_couches = nb_couches; reseau_neuronal->nb_couches = nb_couches;
reseau_neuronal->couches = (Couche**)malloc(sizeof(Couche*)*nb_couches); // Création des différentes couches reseau_neuronal->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_neuronal->couches[i] = (Couche*)malloc(sizeof(Couche)); // Utilité ?
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*)*reseau_neuronal->couches[i]->nb_neurones); // 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
for (int j=0; j < reseau_neuronal->couches[i]->nb_neurones; j++) { for (int j=0; j < reseau_neuronal->couches[i]->nb_neurones; j++) {
reseau_neuronal->couches[i]->neurones[j] = (Neurone*)malloc(sizeof(Neurone)); reseau_neuronal->couches[i]->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_neuronal->nb_couches-1) { // On exclut la dernière couche dont les neurones ne contiennent pas de poids sortants
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)*neurones_par_couche[i+1]);// Création des poids sortants du neurone
reseau_neuronal->couches[i]->neurones[j]->dw= (float*)malloc(sizeof(float)*neurones_par_couche[i+1]); reseau_neuronal->couches[i]->neurones[j]->d_poids_sortants = (float*)malloc(sizeof(float)*neurones_par_couche[i+1]);
} }
} }
} }
@ -36,13 +52,13 @@ 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) {
/* 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' */
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<reseau_neuronal->couches[i]->nb_neurones; 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);
free(reseau_neuronal->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_neuronal->couches[i]->neurones); // On libère enfin la liste des neurones de la couche
@ -54,25 +70,24 @@ void suppression_du_reseau_neuronal(Reseau* reseau_neuronal) {
void forward_propagation(Reseau* reseau_neuronal) { void forward_propagation(Reseau* reseau_neuronal) {
/* Effectue une propagation en avant du réseau neuronal à partir du nombre /* Effectue une propagation en avant du réseau neuronal lorsque les données
de couches et de la liste du nombre de neurones par couche */ on été insérées dans la première couche. Le résultat de la propagation se
trouve dans la dernière 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<reseau_neuronal->couches[i]->nb_neurones;j++) { // Pour chaque neurone de la couche for (int j=0; j<reseau_neuronal->couches[i]->nb_neurones; j++) {
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;
for (int k=0; k<reseau_neuronal->couches[i-1]->nb_neurones; 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]; // ???
} }
if (i<reseau_neuronal->nb_couches-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 (0 si z<0, z sinon)
if (reseau_neuronal->couches[i]->neurones[j]->z < 0) reseau_neuronal->couches[i]->neurones[j]->z=ReLU(reseau_neuronal->couches[i]->neurones[j]->z);
reseau_neuronal->couches[i]->neurones[j]->activation = 0;
else
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 à savoir une probabilité
reseau_neuronal->couches[i]->neurones[j]->activation = 1/(1 + exp(reseau_neuronal->couches[i]->neurones[j]->activation)); reseau_neuronal->couches[i]->neurones[j]->z = sigmoid(reseau_neuronal->couches[i]->neurones[j]->z);
} }
} }
} }
@ -97,36 +112,34 @@ 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_neuronal, 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 */
nombre de couches, de la liste du nombre de neurone par couche et de
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<reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; 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 calcule l'erreur de la sortie
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]->d_z = (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->z - sortie_voulue[i])*(reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->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_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]->d_poids_sortants[i] = (reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->d_z * 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]->d_activation = reseau_neuronal->couches[reseau_neuronal->nb_couches-2]->neurones[k]->poids_sortants[i] * reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->d_z;
} }
// ??? // ???
reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dbiais = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->dz; reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->d_biais = reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[i]->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_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<reseau_neuronal->couches[i]->nb_neurones; 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]->d_z = reseau_neuronal->couches[i]->neurones[j]->d_activation;
else // ??? ... else // ??? ...
reseau_neuronal->couches[i]->neurones[j]->dz = 0; reseau_neuronal->couches[i]->neurones[j]->d_z = 0;
for(int k=0; k<reseau_neuronal->couches[i-1]->nb_neurones; 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]->d_poids_sortants[j] = reseau_neuronal->couches[i]->neurones[j]->d_z * 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]->d_activation = reseau_neuronal->couches[i-1]->neurones[k]->poids_sortants[j] * reseau_neuronal->couches[i]->neurones[j]->d_z;
} }
reseau_neuronal->couches[i]->neurones[j]->dbiais = reseau_neuronal->couches[i]->neurones[j]->dz; // ??? ... reseau_neuronal->couches[i]->neurones[j]->d_biais = reseau_neuronal->couches[i]->neurones[j]->d_z; // ??? ...
} }
} }
@ -141,9 +154,9 @@ void modification_du_reseau_neuronal(Reseau* reseau_neuronal) {
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<reseau_neuronal->couches[i]->nb_neurones; 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]->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_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]->d_poids_sortants[k]); // On modifie le poids du neurone à partir des données de la propagation en arrière
} }
} }
} }
@ -156,14 +169,15 @@ void initialisation_du_reseau_neuronal(Reseau* 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<reseau_neuronal->couches[i]->nb_neurones-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(reseau_neuronal->couches[i]->nb_neurones); double borne_superieure = 1/sqrt(reseau_neuronal->couches[i]->nb_neurones);
double borne_inferieure = - borne_superieure; double borne_inferieure = - borne_superieure;
reseau_neuronal->couches[i]->neurones[j]->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_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]->d_poids_sortants[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->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
@ -172,7 +186,8 @@ void initialisation_du_reseau_neuronal(Reseau* reseau_neuronal) {
} }
double borne_superieure = 1/sqrt(reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones); 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 < reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->nb_neurones; 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++) {// Intialisation de la dernière couche exclut ci-dessus
reseau_neuronal->couches[reseau_neuronal->nb_couches-1]->neurones[j]->activation = borne_inferieure + ((double)rand())/((double)RAND_MAX)*(borne_superieure - borne_inferieure);
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
} }
} }

4
src/mnist/neural_network.h
View File

@ -9,6 +9,10 @@
#ifndef DEF_NEURAL_NETWORK_H #ifndef DEF_NEURAL_NETWORK_H
#define DEF_NEURAL_NETWORK_H #define DEF_NEURAL_NETWORK_H
float max(float a, float b);
float sigmoid(float x);
float sigmoid_derivee(float x);
float ReLU(float x);
void creation_du_reseau_neuronal(Reseau* reseau_neuronal, int* neurones_par_couche, int nb_couches); void creation_du_reseau_neuronal(Reseau* reseau_neuronal, int* neurones_par_couche, int nb_couches);
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);

10
src/mnist/neuron_io.c
View File

@ -21,19 +21,19 @@ Neurone* lire_neurone(uint32_t nb_poids_sortants, FILE *ptr) {
neurone->biais = biais; neurone->biais = biais;
neurone->z = 0.0; neurone->z = 0.0;
neurone->dactivation = 0.0; neurone->d_activation = 0.0;
neurone->dbiais = 0.0; neurone->d_biais = 0.0;
neurone->dz = 0.0; neurone->d_z = 0.0;
float* poids_sortants = malloc(sizeof(float)*nb_poids_sortants); float* poids_sortants = malloc(sizeof(float)*nb_poids_sortants);
neurone->dw = malloc(sizeof(float)*nb_poids_sortants); neurone->d_poids_sortants = malloc(sizeof(float)*nb_poids_sortants);
neurone->poids_sortants = poids_sortants; neurone->poids_sortants = poids_sortants;
for (int i=0; i < nb_poids_sortants; i++) { for (int i=0; i < nb_poids_sortants; i++) {
fread(&tmp, sizeof(float), 1, ptr); fread(&tmp, sizeof(float), 1, ptr);
neurone->poids_sortants[i] = tmp; neurone->poids_sortants[i] = tmp;
neurone->dw[i] = 0.0; neurone->d_poids_sortants[i] = 0.0;
} }
return neurone; return neurone;

16
src/mnist/struct/neuron.h
View File

@ -7,21 +7,21 @@ typedef struct Neurone{
float biais; // Caractérise le biais du neurone float biais; // Caractérise le biais du neurone
float z; // Sauvegarde des calculs faits sur le neurone (programmation dynamique) float z; // Sauvegarde des calculs faits sur le neurone (programmation dynamique)
float dactivation; float d_activation; // Changement d'activation lors de la backpropagation
float *dw; float *d_poids_sortants; // Changement des poids sortants lors de la backpropagation
float dbiais; float d_biais; // Changement du biais lors de la backpropagation
float dz; float d_z; // Quantité de changements générals à effectuer lors de la backpropagation
} Neurone; } Neurone;
typedef struct Couche{ typedef struct Couche{
int nb_neurones; // Nombre de neurones dans la couche (longueur de la liste ci-dessous) int nb_neurones; // Nombre de neurones dans la couche (longueur du tableau ci-dessous)
Neurone** neurones; // Liste des neurones dans la couche Neurone** neurones; // Tableau des neurones dans la couche
} Couche; } Couche;
typedef struct Reseau{ typedef struct Reseau{
int nb_couches; int nb_couches; // Nombre de couches dans le réseau neuronal (longueur du tableau ci-dessous)
Couche** couches; Couche** couches; // Tableau des couches dans le réseau neuronal
} Reseau; } Reseau;
#endif #endif

10
test/neuron_io.c
View File

@ -9,18 +9,18 @@
Neurone* creer_neurone(int nb_sortants) { Neurone* creer_neurone(int nb_sortants) {
Neurone* neurone = malloc(2*sizeof(float*)+6*sizeof(float)); Neurone* neurone = malloc(2*sizeof(float*)+6*sizeof(float));
neurone->poids_sortants = malloc(sizeof(float)*nb_sortants); neurone->poids_sortants = malloc(sizeof(float)*nb_sortants);
neurone->dw = malloc(sizeof(float)*nb_sortants); neurone->d_poids_sortants = malloc(sizeof(float)*nb_sortants);
for (int i=0; i < nb_sortants; i++) { for (int i=0; i < nb_sortants; i++) {
neurone->poids_sortants[i] = 0.5; neurone->poids_sortants[i] = 0.5;
neurone->dw[i] = 0.0; neurone->d_poids_sortants[i] = 0.0;
} }
neurone->activation = 0.0; neurone->activation = 0.0;
neurone->biais = 0.0; neurone->biais = 0.0;
neurone->z = 0.0; neurone->z = 0.0;
neurone->dactivation = 0.0; neurone->d_activation = 0.0;
neurone->dbiais = 0.0; neurone->d_biais = 0.0;
neurone->dz = 0.0; neurone->d_z = 0.0;
return neurone; return neurone;
} }