Comment former un réseau neuronal Perceptron de base

Examinons de plus près ces instructions.

Configuration du réseau et organisation des données

input_dim =3

La dimensionnalité est réglable. Nos données d'entrée, si vous vous en souvenez, consistent en des coordonnées tridimensionnelles, nous avons donc besoin de trois nœuds d'entrée. Ce programme ne prend pas en charge plusieurs nœuds de sortie, mais nous intégrerons la dimensionnalité de sortie réglable dans une future expérience.

learning_rate =0,01

Nous discuterons du taux d'apprentissage dans un prochain article.

Poids =np.random.rand(input_dim) #Poids[0] =0.5 #Poids[1] =0.5 #Poids[2] =0.5

Les poids sont généralement initialisés à des valeurs aléatoires. La fonction numpy random.rand() génère un tableau de longueur input_dim peuplé de valeurs aléatoires réparties sur l'intervalle [0, 1). Cependant, les valeurs de poids initiales influencent les valeurs de poids finales produites par la procédure d'entraînement, donc si vous souhaitez évaluer les effets d'autres variables (telles que la taille de l'ensemble d'entraînement ou le taux d'apprentissage), vous pouvez supprimer ce facteur de confusion en définissant tous les pondérations à une constante connue au lieu d'un nombre généré aléatoirement.

Training_Data =pandas.read_excel("3D_data.xlsx")

J'utilise la bibliothèque pandas pour importer des données d'entraînement à partir d'une feuille de calcul Excel. Le prochain article entrera plus en détail sur les données d'entraînement.

Expected_Output =Training_Data.output Training_Data =Training_Data.drop(['output'], axe=1)

L'ensemble de données d'apprentissage comprend des valeurs d'entrée et des valeurs de sortie correspondantes. La première instruction sépare les valeurs de sortie et les stocke dans un tableau séparé, et l'instruction suivante supprime les valeurs de sortie de l'ensemble de données d'apprentissage.

Training_Data =np.asarray(Training_Data) training_count =len(Training_Data[:,0])

Je convertis l'ensemble de données d'entraînement, qui est actuellement une structure de données de pandas, en un tableau numpy, puis je regarde la longueur de l'une des colonnes pour déterminer le nombre de points de données disponibles pour l'entraînement.

Calcul des valeurs de sortie

pour l'époque dans la plage(0,5) :

La durée d'une séance d'entraînement dépend du nombre de données d'entraînement disponibles. Cependant, vous pouvez continuer à optimiser les poids en entraînant le réseau plusieurs fois à l'aide du même ensemble de données. Les avantages de l'entraînement ne disparaissent pas simplement parce que le réseau a déjà vu ces données d'entraînement. Chaque passage complet à travers l'ensemble d'entraînement complet est appelé une époque.

pour les données dans la plage (0, training_count) :

La procédure contenue dans cette boucle se produit une fois pour chaque ligne de l'ensemble d'apprentissage, où « ligne » fait référence à un groupe de valeurs de données d'entrée et à la valeur de sortie correspondante (dans notre cas, un groupe d'entrée se compose de trois nombres représentant x, y , et z composants d'un point dans l'espace à trois dimensions).

Output_Sum =np.sum(np.multiply(Training_Data[datum,:], Weights))

Le nœud de sortie doit additionner les valeurs délivrées par les trois nœuds d'entrée. Mon implémentation Python le fait en effectuant d'abord une multiplication par élément du tableau Training_Data et les Poids tableau, puis calcul de la somme des éléments du tableau produit par cette multiplication.

si Output_Sum <0 :Output_Value =0 autre:Output_Value =1

Une instruction if-else applique la fonction d'activation du pas unitaire :si la somme est inférieure à zéro, la valeur générée par le nœud de sortie est 0 ; si la somme est égale ou supérieure à zéro, la valeur de sortie est un.

Mise à jour des poids

Lorsque le premier calcul de sortie est terminé, nous avons des valeurs de poids, mais elles ne nous aident pas à réaliser la classification car elles sont générées de manière aléatoire. Nous transformons le réseau de neurones en un système de classification efficace en modifiant à plusieurs reprises les poids de sorte qu'ils reflètent progressivement la relation mathématique entre les données d'entrée et les valeurs de sortie souhaitées. La modification du poids est accomplie en appliquant la règle d'apprentissage suivante pour chaque ligne de l'ensemble d'entraînement :

\[w_{new} =w+(\alpha\times(output_{expected}-output_{calculated})\times input)\]

Le symbole \( \alpha \) désigne le taux d'apprentissage. Ainsi, pour calculer une nouvelle valeur de poids, nous multiplions la valeur d'entrée correspondante par le taux d'apprentissage et par la différence entre la sortie attendue (qui est fournie par l'ensemble d'apprentissage) et la sortie calculée, puis le résultat de cette multiplication est ajouté à la valeur de poids actuelle. Si nous définissons delta (\(\delta\) ) comme (\(output_{expected} - output_{calculated}\)), nous pouvons le réécrire comme

\[w_{new} =w+(\alpha\times\delta\times input)\]

Voici comment j'ai implémenté la règle d'apprentissage en Python :

error =Expected_Output[datum] - Output_Value pour n dans la plage (0, input_dim):Weights[n] =Weights[n] + learning_rate*error*Training_Data[datum,n]

Conclusion

Vous disposez maintenant d'un code que vous pouvez utiliser pour entraîner un Perceptron à une seule couche et à un seul nœud de sortie. Nous explorerons plus de détails sur la théorie et la pratique de la formation en réseau de neurones dans le prochain article.