La descente de dégradé à Python

La descente de gradient est un algorithme qui nous aide à trouver l'erreur minimale ou où la valeur de perte est moindre. Nous choisissons n'importe quel point sur la fonction, puis nous nous déplaçons lentement vers la direction négative afin que nous puissions atteindre l'erreur minimale. Mais tout en se déplaçant, nous nous soucions également de la valeur d'erreur, qui est la valeur qui est soustraite de la prédiction et de la valeur de vérité. De plus, cela ne devrait pas devenir négatif.

Nous pouvons mieux le comprendre à partir de l'exemple suivant:

Supposons qu'une machine convertit les kilomètres en miles.

Mais nous n'avons pas la formule pour convertir les kilomètres en miles. Nous savons que les deux valeurs sont linéaires, ce qui signifie que si nous double les kilomètres, alors les kilomètres doublent également.

La formule est présentée de cette façon:

Kilomètres = kilomètres * c

Ici, C est une constante, et nous ne connaissons pas la valeur exacte de la constante.

Nous avons une certaine valeur de vérité universelle comme indice. La table de vérité est donnée ci-dessous:

Nous allons maintenant utiliser une valeur aléatoire de C et déterminer le résultat.

Donc, nous utilisons la valeur de C comme 0.5, et la valeur des kilomètres est de 100. Qui nous donne 50 comme réponse. Comme nous le savons très bien, selon le tableau de vérité, la valeur devrait être 62.137. Donc, l'erreur que nous devons découvrir comme ci-dessous:

error = vérité - calculé

= 62.137 - 50

= 12.137

De la même manière, nous pouvons voir le résultat dans l'image ci-dessous:

Maintenant, nous avons une erreur de 12.137. Comme discuté précédemment, la relation entre les miles et les kilomètres est linéaire. Donc, si nous augmentons la valeur de la constante al aléatoire C, nous pourrions obtenir moins d'erreur.

Cette fois, nous changeons simplement la valeur de C à partir de 0.5 à 0.6 et atteignez la valeur d'erreur de 2.137, comme indiqué dans l'image ci-dessous:

Maintenant, notre taux d'erreur s'améliore de 12.317 à 2.137. Nous pouvons toujours améliorer l'erreur en utilisant plus de suppositions sur la valeur de C. Nous supposons que la valeur de C sera 0.6 à 0.7, et nous avons atteint l'erreur de sortie de -7.863.

Cette fois, l'erreur traverse le tableau de vérité et la valeur réelle. Ensuite, nous traversons l'erreur minimale. Donc, à partir de l'erreur, nous pouvons dire que notre résultat de 0.6 (erreur = 2.137) valait mieux que 0.7 (erreur = -7.863).

Pourquoi n'avons-nous pas essayé avec les petits changements ou le taux d'apprentissage de la valeur constante de C? Nous allons juste changer la valeur C de 0.6 à 0.61, pas à 0.7.

La valeur de c = 0.61, nous donne une erreur moindre de 1.137 qui est meilleur que le 0.6 (erreur = 2.137).

Maintenant, nous avons la valeur de C, qui est 0.61, et il donne une erreur de 1.137 uniquement à partir de la valeur correcte de 62.137.

Il s'agit de l'algorithme de descente de gradient qui aide à découvrir l'erreur minimale.

Code python:

Nous convertissons le scénario ci-dessus en programmation Python. Nous initialisons toutes les variables dont nous avons besoin pour ce programme Python. Nous définissons également la méthode kilo_mile, où nous passons un paramètre C (constant).

Dans le code ci-dessous, nous définissons uniquement les conditions d'arrêt et l'itération maximale. Comme nous l'avons mentionné, le code s'arrêtera soit lorsque l'itération maximale a été obtenue ou la valeur d'erreur supérieure à la précision. En conséquence, la valeur constante atteint automatiquement la valeur de 0.6213, qui a une erreur mineure. Donc, notre descente de gradient fonctionnera également comme celle-ci.

Descente de dégradé à Python

Nous importons les packages requis et avec les ensembles de données intégrés Sklearn. Ensuite, nous définissons le taux d'apprentissage et plusieurs itérations comme indiqué ci-dessous dans l'image:

Nous avons montré la fonction sigmoïde dans l'image ci-dessus. Maintenant, nous convertissons cela en une forme mathématique, comme indiqué dans l'image ci-dessous. Nous importons également l'ensemble de données intégré Sklearn, qui a deux fonctionnalités et deux centres.

Maintenant, nous pouvons voir les valeurs de x et de forme. La forme montre que le nombre total de lignes est de 1000 et les deux colonnes comme nous avons précédé.

Nous ajoutons une colonne à la fin de chaque ligne x pour utiliser le biais comme valeur formable, comme indiqué ci-dessous. Maintenant, la forme de x est de 1000 lignes et trois colonnes.

Nous remontons également le Y, et maintenant il a 1000 lignes et une colonne comme indiqué ci-dessous:

Nous définissons également la matrice de poids à l'aide de la forme du X comme indiqué ci-dessous:

Maintenant, nous avons créé le dérivé du sigmoïde et supposé que la valeur de X serait après avoir traversé la fonction d'activation sigmoïde, que nous avons montrée auparavant.

Ensuite, nous boucles jusqu'à ce que le nombre d'itérations que nous avons déjà réglées ait été atteinte. Nous découvrons les prédictions après avoir traversé les fonctions d'activation sigmoïde. Nous calculons l'erreur, et nous calculons le gradient pour mettre à jour les poids comme indiqué ci-dessous dans le code. Nous enregistrons également la perte sur chaque époque sur la liste des histoires pour afficher le graphique de perte.

Maintenant, nous pouvons les voir à chaque époque. L'erreur diminue.

Maintenant, nous pouvons voir que la valeur de l'erreur réduit en continu. C'est donc un algorithme de descente dégradé.