Fonction ReLu en Python

Relu ou fonction d'activation linéaire rectifiée est le choix d'activation le plus commun dans le monde de l'apprentissage profond. Relu fournit des résultats à la pointe de la technologie et est à la fois très efficace sur le plan computationnel.

Le concept de base de la fonction d'activation Relu est le suivant :

Return 0 if the input is negative otherwise return the input as it is.

Nous pouvons le représenter mathématiquement comme suit :

Le pseudo code pour Relu est comme suit :

if input > 0:
	return input
else:
	return 0

Dans ce tutoriel, nous allons apprendre à implémenter notre propre fonction ReLu, à connaître certains de ses inconvénients et à découvrir une meilleure version de ReLu.

Lecture recommandée : Algèbre linéaire pour l'apprentissage machine [Partie 1/2]

Commençons!

Implémentation de la fonction ReLu en Python

Écrivons notre propre implémentation de Relu en Python. Nous utiliserons la fonction max intégrée pour l'implémenter.

Le code pour ReLu est le suivant :

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

Pour tester la fonction, exécutons-la sur quelques entrées.

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)))

Code Complet

Le code complet est donné ci-dessous :

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

Gradient de la fonction ReLu

Voyons quel serait le gradient (dérivée) de la fonction ReLu. En dérivant, nous obtiendrons la fonction suivante :

f'(x) = 1, x>=0
      = 0, x<0

Nous pouvons voir que pour des valeurs de x inférieures à zéro, le gradient est de 0. Cela signifie que les poids et les biais de certains neurones ne sont pas mis à jour. Cela peut poser un problème dans le processus d'entraînement.

Pour surmonter ce problème, nous avons la fonction Leaky ReLu. Apprenons-en davantage la prochaine fois.

Fonction Leaky ReLu

La fonction Leaky ReLu est une improvisation de la fonction ReLu régulière. Pour résoudre le problème du gradient nul pour les valeurs négatives, Leaky ReLu attribue une composante linéaire extrêmement petite de x aux entrées négatives.

Mathématiquement, nous pouvons exprimer Leaky ReLu comme :

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

Mathématiquement :

• f(x)=1 (x<0)

Voici a une petite constante comme le 0,01 que nous avons pris ci-dessus.

Graphiquement, cela peut être montré comme :

Le gradient de Leaky ReLu

Calculons le gradient de la fonction Leaky ReLu. Le gradient peut être :

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

Dans ce cas, le gradient pour les entrées négatives est non nul. Cela signifie que tous les neurones seront mis à jour.

Implémentation de Leaky ReLu en Python

L'implémentation de Leaky ReLu est donnée ci-dessous :

def relu(x):
  if x>0 :
    return x
  else :
    return 0.01*x

Essayons-le sur place.

 
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)))

Code Complet

Le code complet pour Leaky ReLu est donné ci-dessous :

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 portait sur la fonction ReLu en Python. Nous avons également vu une version améliorée de la fonction ReLu. La Leaky ReLu résout le problème des gradients nuls pour les valeurs négatives dans la fonction ReLu.