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
| # language a utiliser python , télécharger anaconda (bibliothèque python),et télécharger numpy (bibliothèque mathématique)
# impoter numpy
import numpy as np
# Variable de creation d'un tableau
x_entrer = np.array(([3, 1.5], [2, 1], [4, 1.5], [3, 1], [3.5,0.5], [2,0.5], [5.5,1], [1,1], [4,1.5]), dtype=float)
# données d'entrer, données de sortie / 1 = rouge / 0 = bleu
y = np.array(([1], [0], [1],[0],[1],[0],[1],[0]), dtype=float)
# Changement de l'échelle de nos valeurs pour être entre 0 et 1
# On divise chaque entré par la valeur max des entrées
x_entrer = x_entrer/np.amax(x_entrer, axis=0)
# On récupère ce qu'il nous intéresse
# Données sur lesquelles on va s'entrainer, les 8 premières de notre matrice
X = np.split(x_entrer, [8])[0]
# Valeur que l'on veut trouver
xPrediction = np.split(x_entrer, [8])[1]
#Notre classe de réseau neuronal
class Neural_Network(object):
def __init__(self):
#Nos paramètres
self.inputSize = 2 # Nombre de neurones d'entrer
self.outputSize = 1 # Nombre de neurones de sortie
self.hiddenSize = 3 # Nombre de neurones cachés
#Nos poids
# (2x3) Matrice de poids entre les neurones d'entrer et cachés
self.W1 = np.random.randn(self.inputSize, self.hiddenSize)
# (3x1) Matrice de poids entre les neurones cachés et sortie
self.W2 = np.random.randn(self.hiddenSize, self.outputSize)
#Fonction de propagation avant
def forward(self, X):
# Multiplication matricielle entre les valeurs d'entrer et les poids W1
self.z = np.dot(X, self.W1)
# Application de la fonction d'activation (Sigmoid)
self.z2 = self.sigmoid(self.z)
# Multiplication matricielle entre les valeurs cachés et les poids W2
self.z3 = np.dot(self.z2, self.W2)
# Application de la fonction d'activation, et obtention de notre valeur de sortie final return o
o = self.sigmoid(self.z3)
# Fonction d'activation
def sigmoid(self, s):
return 1/(1+np.exp(-s))
# Dérivée de la fonction d'activation
def sigmoidPrime(self, s):
return s * (1 - s)
#Fonction de rétropropagation
def backward(self, X, y, o):
# Calcul de l'erreur
self.o_error = y - o
# Application de la dérivée de la sigmoid à cette erreur
self.o_delta = self.o_error*self.sigmoidPrime(o)
# Calcul de l'erreur de nos neurones cachés
self.z2_error = self.o_delta.dot(self.W2.T)
# Application de la dérivée de la sigmoid à cette erreur
self.z2_delta = self.z2_error*self.sigmoidPrime(self.z2)
self.W1 += X.T.dot(self.z2_delta) # On ajuste nos poids W1
self.W2 += self.z2.T.dot(self.o_delta) # On ajuste nos poids W2
#Fonction d'entrainement
def train(self, X, y):
o = self.forward(X)
self.backward(X, y, o)
#Fonction de prédiction
def predict(self):
print("Donnée prédite apres entrainement: ")
print("Entrée : \n" + str(xPrediction))
print("Sortie : \n" + str(self.forward(xPrediction)))
if(self.forward(xPrediction) < 0.5):
print("La fleur est BLEU ! \n")
else:
print("La fleur est ROUGE ! \n")
NN = Neural_Network()
for i in range(1000): #nombre d'itération
print("# " + str(i) + "\n")
print("Valeurs d'entrées: \n" + str(X))
print("Sortie actuelle: \n" + str(y))
print("Sortie prédite: \n" + str(np.matrix.round(NN.forward(X),2)))
print("\n")
NN.train(X,y)
NN.predict() |
