Je viens de bloquer sur la matrice et . round qui me résiste sur la fin, il me dit que ce n'est pas applicable j'ai l'impression . Le but est de simplifier au maximum un NN en script python pour faire un doc pdf qui va avec pour expliquer plus facilement sa composition et fonctionnement . Pourquoi il m'insulte sur la fin , utilisation de la petite réf de base indiquer dans le lien ci joint, malgré tous c'est le flop. Comme d'habitude je bloque sur des format happymeal.
https://numpy.org/doc/stable/referen...py.matrix.html
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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()
ERREUR EST LA SUIVANTE :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
Traceback (most recent call last):
  File "D:\Disque 1\clé usb tom\INFORMATIQUE\cyber tom\neuronne artificiel\neurone python.py", line 104, in <module>
    print("Sortie prédite: \n" + str(np.matrix.round(NN.forward(X),2)))
TypeError: descriptor 'round' for 'numpy.ndarray' objects doesn't apply to a 'NoneType' object