Fonction ReLu en Python

Relu ou fonction d'activation linéaire rectifiée est le choix le plus courant de fonction d'activation dans le monde de l'apprentissage profond. Relu fournit des résultats à la pointe de la technologie et est en même temps 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 le suivant :

if input > 0:
	return input
else:
	return 0

Dans ce tutoriel, nous allons apprendre comment implémenter notre propre fonction ReLu, découvrir certains de ses inconvénients et apprendre une version améliorée de ReLu.

Lecture recommandée : Algèbre linéaire pour le apprentissage automatique [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, lançons-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 différenciant, 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 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 plus à ce sujet ensuite.

Fonction ReLu fuyante

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 donne 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)
• (αx)+1 (x>=0)(x)

Ici, a est une petite constante comme le 0,01 que nous avons prise 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 n'est pas nul. Cela signifie que tous les neurones seront mis à jour.

Implémentation de Leaky ReLu en Python

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

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

Essayons-le sur les entrées sur site.

 
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.