Algorithme de rétro propagation du gradient
Algorithme-retro-propagation-du-gradient
L'algorithme de rétropropagation du gradient est l'algorithme classiquement utilisé pour l'entraînement des réseaux de neurones à propagation avant tels que le perceptron multi-couche. Dans cette article, nous verrons comment le coder en python from scratch c'est à dire en partant de rien.
L'idée derrière la propagation du gradient est d'imiter le fonctionnement neuronale humain. Un neurone humain à plusieurs dendrite desquelles il reçoit des signaux d'entrée sur lesquelles il effectuera des opérations afin d'obtenir un signal de sortie qu'il partagera au autres neurones au à l'aide de son axone.
En cela, nous remarquons que le fonctionnement d'un perceptron multi-couches ou plus généralement d'un réseau de neurones à propagation avant est fortement inspiré du neurones humain.
En effet, comme ce dernier, le réseau neuronale à propagation avant a des entrées, à des sortie et l'information de sortie est différente de l'information d'entrée car quand celle ci circule dans le réseau elle est modifié par diverses calculs mathématiques.
Les réseau de neurones à propagation avant sont généralement utilisé pour des problème de d'apprentissage supervisée tels que la
classification ou encore la
régression. Le point commun entre ces deux problème est que l'on dispose de plusieurs entrée mais aussi de la sortie désirée pour chacune des entrées. Le problème à résoudre consiste donc à construire une fonction ou un modèle mathématique qui en fonction de ces entrée donnerons une sortie proche de celle attendu. C'est ce problème que résous l'algorithme de rétropropagation du gradient en modifiant les différents poids des neurones.
Pour cela, nous allons utiliser le jeu de données
Iris.csv. Ce jeu de données contient des 4 mesures qui ont été prélevées sur 3 espèces de fleurs : setosa, versicolor, virginica. Il s'agit de la longueur de sépale, la largeur de sépale, la longueur de pétale et la largeur de pétale. Ils contient 150 exemple et 20 exemples de chaque espèces.
Extrait du jeu de données :
5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
6.0,2.9,4.5,1.5,Iris-versicolor
5.7,2.6,3.5,1.0,Iris-versicolor
7.9,3.8,6.4,2.0,Iris-virginica
6.4,2.8,5.6,2.2,Iris-virginica
Généralement, une couche cachée suffit pour résoudre la plus part de problème. C'est pour cela que le réseau que nous implémenterons ensemble n'aura qu'une couche cachée. Libre à vous de le modifier si vous voulez en rajouter plus.
Initialisation aléatoire de tous les poids du réseau
def init_network(nb_entree, nb_neurones_caches, nb_sortie):
mlp=[]
hidden_layer_weights=[]
for i in range (0, nb_neurones_caches):
hidden_layer_weights.append([])
for j in range (0, len( nb_entree)):
hidden_layer_weights[i].append(random.random())
output_layer_weights=[]
for i in range (0, nb_sortie):
output_layer_weights.append([])
for j in range (0, len( nb_neurones_caches)):
output_layer_weights[i].append(random.random())
mlp=[hidden_layer_weights,output_layer_weights]
return mlp
La fonction d'activation
def sigmoid_activation(poids, entree):
Y=0
for i in range (0,len( poids)):
Y+=poids[i]+entree[i]
return (1/(1+math.exp(-Y)))
La propagation avant où foward propagate
def propagation_avant(network, entree):
previous_input_next_step=entree
input_next_step=entree
for i in range (0, len(network)):
for j in range (0, len( network[i])):
input_next_step.append(sigmoid_activation(network[i][j], previous_input_next_step))
previous_input_next_step=input_next_step
input_next_step=[]
#input_next_step.append(sigmoid_activation(network[i][0], entree))
print (previous_input_next_step)
Choix aléatoire d’un exemple i de la base B et calcul de la sortie Y pour cet exemple avec la formule ( Il s'agit de : en anglais).
La rétropropagation ou backpropagation
Une fois la propagation avant terminé, le réseau de neurones à produit une sortie qui doit être corrigé .
L'algorithme de rétropropagation du gradient construit une fonction qui va produire la sortie désirée selon l'entrées en modifiant les poids du réseau de neurones.
Technically, the backpropagation algorithm is a method for training the weights in a multilayer feed-forward neural network. As such, it requires a network structure to be defined of one or more layers where one layer is fully connected to the next layer. A standard network structure is one input layer, one hidden layer, and one output layer.
Backpropagation can be used for both classification and regression problems, but we will focus on classification in this tutorial.
Entrée : Une base constituée B de k exemple
1-
2-
A l'image du perceptron le calcul de la sortie de chaque neurones est effectué en faisant la somme des produits des entrées Xn et des poids Wn et en rajoutant le bias 0.
Puis cette somme est envoyé dans une fonction de d'activation généralement la fonction sigmoid
error = (expected - output) * transfer_derivative(output)
error = (weight_k * error_j) * transfer_derivative(output)
weight = weight + learning_rate * error * input
4-
la dérivé de la sigmoid est
Les poids de tous les neurones du réseau sont corrigés. Pour cela, pour tous les neurones, en partant du dernier :
En effet, un cellule neuronale humaine reçoit plusieurs signaux d'entrée au travers de ses dendrites et
Application à Iris.csv
Charger le Jeu de données Iris.csv
#Chargement du fichier iris.csv
import csv
iris_data=[]
iris_classe=[]
with open('iris.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
iris_data.append([float(row[0]),float(row[1]),float(row[2]),float(row[3])])
iris_classe.append(row[4])
Écrivez quelque chose ...
