1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
#include"./Neurone.h"
/**
* Constructeur par defauts
* @method Neurone::Neurone
*/
Neurone::Neurone(){
n = 0;
}
/**
* Constructeur par nombre d'entrées
* @method Neurone::Neurone
* @param n Nombre d'entrées
* @param n Fonction d'Activation
*/
Neurone::Neurone(int n,FonctionActivation::EnumFonctionActivation fct){
this->n = n;
fonctionActivation.setFonctionActivation(fct);
aleaWeights();
}
/**
* Constructeur par arguments
* @method Neurone::Neurone
* @param taille Nombre d'entrées
* @param x Vecteur de poids
*/
Neurone::Neurone(int n, std::vector<double> * x,FonctionActivation::EnumFonctionActivation fct){
w = x;
fonctionActivation.setFonctionActivation(fct);
this->n = n;
}
/**
* Méthode de propagation en avant
* @method Neurone::fire
* @param in Vecteur d'entrées
* @param k Coefficient de sigmoid k
* @return Valeur d'activation
*/
double Neurone::fire(std::vector<double> in, double k)const{
return fw_activate(fw_sum(in),k);
}
/**
* Méthode de somme des valeurs du vecteur
* @method Neurone::fw_sum
* @param x Vecteur
* @return Somme
*/
double Neurone::fw_sum(std::vector<double> x)const{
double res=0;
for(int i=0; i<n; i++){
res += (x[i]) * (*w)[i];
}
return res;
}
/**
* Méthode d'activation
* @method Neurone::fw_activate
* @param sum Valeur de la somme du vecteur (cf Neurone::fw_sum)
* @param k Valeur du biais
* @return Valeur d'activation
*/
double Neurone::fw_activate(double sum, double k)const{
return fonctionActivation.getValeurActivation(sum,k);
}
/**
* Méthode de dérivation
* @method Neurone::derive_activate
* @param sum Valeur de la somme du vecteur (cf Neurone::fw_sum)
* @param k Valeur du coefficient de sigmoid k
* @return Valeur de dérivation
*/
double Neurone::derive_activate(double sum, double k)const{
return fonctionActivation.getValeurDerivee(sum,k);
}
/**
* Méthode d'apprentissage (cf Neurone::fw_sum, cf Neurone::fw_activate, cf Neurone::derive_activate)
* @method Neurone::learn
* @param x Vecteur de poids
* @param o Valeur attendue
* @param k Valeur de l'hyperparamètre
* @param mu Taux d'apprentissage | Learning rate
*/
void Neurone::learn(std::vector<double> x,double o,double k, double mu){
double sum = fw_sum(x);
double res = fw_activate(sum,k);
double derive = derive_activate(sum,k);
for(int i=0; i<n; i++){
(*w)[i]= (*w)[i]- mu * (x[i]*derive*((o-res)*(-2)));
}
}
/**
* Affichage des poids
* @method Neurone::printWeight
*/
void Neurone::printWeight(){
for(int i=0; i<n; i++){
std::cout << "w" << i << " = " << (*w)[i] << std::endl;
}
}
/**
* Méthode de génération de poids aléatoire selon une loi normale centrée réduite
* @method Neurone::aleaWeights
*/
void Neurone::aleaWeights(){
w = new std::vector<double> (n,0.8);
std::default_random_engine generator(std::random_device{}());
std::normal_distribution<double> distribution(0,1);
for (int i=0; i<n; i++) {
(*w)[i] = distribution(generator);
}
}
/**
* @method Neurone::getWeight
* @return Vecteur de poids
*/
std::vector<double> * Neurone::getWeight(){
return w;
}
/**
* @method Neurone::getNbPoids
* @return Nombre de poids
*/
int Neurone::getNbPoids(){
return n;
}
|
