La fonction d'activation sigmoïde - Implémentation Python

Dans ce tutoriel, nous allons apprendre sur la fonction d'activation sigmoïde. La fonction sigmoïde renvoie toujours une sortie entre 0 et 1.

Après ce tutoriel, vous saurez :

• Qu'est-ce qu'une fonction d'activation ?
• Comment implémenter la fonction sigmoïde en Python ?
• Comment tracer la fonction sigmoïde en python ?
• Où utilisons-nous la fonction sigmoïde ?
• Quels sont les problèmes causés par la fonction d'activation sigmoïde ?
• Meilleures alternatives à la fonction d'activation sigmoïde.

Qu'est-ce qu'une fonction d'activation ?

Une fonction d'activation est une fonction mathématique qui contrôle la sortie d'un réseau de neurones. Les fonctions d'activation aident à déterminer si un neurone doit être activé ou non.

Certaines des fonctions d'activation populaires sont :

• Étape binaire
• Linéaire
• Sigmoïde
• Tanh
• ReLU
• Leaky ReLU
• Softmax

L'activation est responsable de l'ajout de non-linéarité à la sortie d'un modèle de réseau de neurones. Sans une fonction d'activation, un réseau de neurones est simplement une régression linéaire.

L'équation mathématique pour calculer la sortie d'un réseau de neurones est :

Dans ce tutoriel, nous allons nous concentrer sur la fonction d'activation sigmoïde. Cette fonction vient de la fonction sigmoïde en mathématiques.

Commençons par discuter de la formule de la fonction.

La formule de la fonction d'activation sigmoïde

Mathématiquement, vous pouvez représenter la fonction d'activation sigmoïde comme :

Vous pouvez voir que le dénominateur sera toujours supérieur à 1, donc la sortie sera toujours comprise entre 0 et 1.

Implémentation de la fonction d'activation sigmoïd en Python

Dans cette section, nous allons apprendre comment implémenter la fonction d'activation sigmoïde en Python.

Nous pouvons définir la fonction en python comme :

import numpy as np 
def sig(x):
 return 1/(1 + np.exp(-x))

Essayons de faire fonctionner la fonction sur quelques entrées.

import numpy as np 
def sig(x):
 return 1/(1 + np.exp(-x))


x = 1.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = -10.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = 0.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = 15.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

x = -2.0
print('Applying Sigmoid Activation on (%.1f) gives %.1f' % (x, sig(x)))

Sortie :

Applying Sigmoid Activation on (1.0) gives 0.7
Applying Sigmoid Activation on (-10.0) gives 0.0
Applying Sigmoid Activation on (0.0) gives 0.5
Applying Sigmoid Activation on (15.0) gives 1.0
Applying Sigmoid Activation on (-2.0) gives 0.1

Tracer l'activation sigmoïde en utilisant Python

Pour tracer l'activation sigmoïde, nous utiliserons la bibliothèque Numpy :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-10, 10, 50)   
p = sig(x)
plt.xlabel("x") 
plt.ylabel("Sigmoid(x)")  
plt.plot(x, p) 
plt.show()

Sortie :

Nous pouvons voir que la sortie est entre 0 et 1.

La fonction sigmoïde est couramment utilisée pour prédire des probabilités, car cette probabilité se situe toujours entre 0 et 1.

Un des inconvénients de la fonction sigmoïde est qu'en fin de région les valeurs Y réagissent très peu au changement des valeurs X.

Cela entraîne un problème connu sous le nom de problème de gradient qui disparaît.

Le gradient qui disparaît ralentit le processus d'apprentissage et est donc indésirable.

Discutons de quelques alternatives qui contournent ce problème.

fonction d'activation ReLu

Une meilleure alternative qui résout ce problème de gradient descendant est la fonction d'activation ReLu.

La fonction d'activation ReLu renvoie 0 si l'entrée est négative, sinon elle renvoie l'entrée telle quelle.

Mathématiquement, il est représenté comme :

Vous pouvez l'implémenter en Python comme suit :

def relu(x):
    return max(0.0, x)

Voyons comment cela fonctionne sur quelques données.

def relu(x):
    return max(0.0, x)
 
x = 1.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = -10.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = 0.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = 15.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))
x = -20.0
print('Applying Relu on (%.1f) gives %.1f' % (x, relu(x)))

Sortie :

Applying Relu on (1.0) gives 1.0
Applying Relu on (-10.0) gives 0.0
Applying Relu on (0.0) gives 0.0
Applying Relu on (15.0) gives 15.0
Applying Relu on (-20.0) gives 0.0

Le problème avec ReLu est que le gradient pour les entrées négatives est nul.

Ceci conduit à nouveau au problème de la disparition du gradient (gradient nul) pour les entrées négatives.

Pour résoudre ce problème, nous avons une autre alternative connue sous le nom de fonction d'activation Leaky ReLu.

Fonction d'activation Leaky ReLu

Le ReLu desserré aborde le problème des gradients nuls pour les valeurs négatives, en donnant une composante linéaire extrêmement petite de x aux entrées négatives.

Mathématiquement, nous pouvons le définir comme :

f(x)= 0.01x, x<0
    = x,   x>=0

Vous pouvez l'implémenter en Python en utilisant :

def leaky_relu(x):
  if x>0 :
    return x
  else :
    return 0.01*x
  
x = 1.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = -10.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = 0.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = 15.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

x = -20.0
print('Applying Leaky Relu on (%.1f) gives %.1f' % (x, leaky_relu(x)))

Sortie :

Applying Leaky Relu on (1.0) gives 1.0
Applying Leaky Relu on (-10.0) gives -0.1
Applying Leaky Relu on (0.0) gives 0.0
Applying Leaky Relu on (15.0) gives 15.0
Applying Leaky Relu on (-20.0) gives -0.2

Conclusion

Ce tutoriel concernait la fonction d'activation Sigmoïde. Nous avons appris à implémenter et à tracer la fonction en python.