Les fonctions d'activation de type Rectifié

ReLU (Rectified Linear Unit)

La fonction d'activation ReLU, abréviation de "Rectified Linear Unit", est une fonction linéaire qui ajoute de la non-linéarité au réseau de neurones, lui permettant ainsi d'apprendre des motifs complexes. Bien qu'elle ressemble à une fonction linéaire, elle est un choix populaire en raison de sa simplicité et de ses avantages.

$$ ReLU(x) = \begin{cases} 0 & \text{ for } x \lt 0 \\ x & \text{ for } x \geq 0 \end{cases} $$ $$ ReLU'(x) = \begin{cases} 0 & \text{ for } x \lt 0 \\ 1 & \text{ for } x \geq 0 \end{cases} $$

def relu(x):
    return 0 if x < 0 else x

def relu_d(x):
    return 0 if x < 0 else 1

Avantages :

• La fonction d'activation ReLU est plus efficace en termes de calcul, car elle implique des opérations mathématiques plus simples que la fonction sigmoïde et tanh.
• Bien qu'elle ressemble à une fonction linéaire, elle ajoute de la non-linéarité au réseau de neurones, ce qui permet d'apprendre des motifs complexes.
• Elle ne souffre pas du vanishing gradient problem. Elle n'est pas bornée sur sa partie positive, ce qui élimine le problème de saturation du gradient.

Inconvénients :

• Le Dying ReLU. En effet, ReLU élimine systématiquement les valeurs négatives en les remplaçant par 0, entraînant ainsi la désactivation de certaines unités. Cela conduit à un gradient nul pour ces unités, ce qui signifie qu'il n'y aura pas de mise à jour de poids pendant la rétropropagation. Les neurones qui se retrouvent dans cet état ne répondront plus à la déviation de l'entrée ou à l'erreur, compromettant ainsi la capacité du modèle à s'adapter correctement aux données.
• Elle n'est pas dérivable en 0.

Utilisations :

Pour les couches cachées des réseaux de neurones, l'utilisation de la fonction d'activation ReLU est recommandée. Elle est plus avantageuse en termes de coûts de calcul que les fonctions sigmoid et tanh, ce qui en fait généralement le choix le plus judicieux. En outre, ReLU est plus rapide que ces dernières. En raison de sa nature, dans les couches cachées, seuls quelques neurones sont activés simultanément, ce qui permet un calcul efficace et facile.

Leaky ReLU

La fonction d'activation Leaky ReLU, une variante de la fonction ReLU, est utilisée pour résoudre le problème du Dying ReLU. Contrairement à la fonction ReLU qui remplace toutes les entrées négatives par 0, la fonction Leaky ReLU remplace les entrées négatives par une valeur très petite, mais proportionnelle à l'entrée. Cela permet d'éviter la saturation du gradient à 0, même pour les unités dont l'entrée est négative.

$$ LeakyReLU(x) = \begin{cases} 0.01 x & \text{ for } x \lt 0 \\ x & \text{ for } x \geq 0 \end{cases} $$ $$ LeakyReLU'(x) = \begin{cases} 0.01 & \text{ for } x \lt 0 \\ 1 & \text{ for } x \geq 0 \end{cases} $$

def leaky_relu(x):
    return .001 * x if x < 0 else x

def leaky_relu_d(x):
    return .001 if x < 0 else 1

Avantages :

• Elle est similaire à ReLU en termes d'efficacité de calcul et de non-linéarité ajoutée, par conséquent elle dispose des mêmes avantages.
• La fonction Leaky ReLU évite le problème du Dying ReLU, ce qui permet une mise à jour des poids même pour les unités avec une entrée négative.

Inconvénients :

• Le coefficient est constant et peut être choisie par l'utilisateur. Il n'y a pas de méthode automatique pour adapter cette valeur aux données d'entrée.

Utilisations :

• Comme pour ReLU, Leaky ReLU est recommandée pour les couches cachées d'un réseau de neurones. Cependant, bien qu'elle évite l'un des inconvénients de ReLU, son utilisation ne garantit pas nécessairement de meilleures performances.

Parametric & Randomized ReLU

La fonction d'activation Parametric ReLU est une autre variante de la fonction ReLU. Contrairement à la fonction Leaky ReLU, la valeur de α n'est pas définie par l'utilisateur, mais elle est apprise pendant la période d'entraînement, en même temps que les poids et les biais.

$$ PReLU(\alpha, x) = \begin{cases} \alpha x & \text{ for } x \lt 0 \\ x & \text{ for } x \geq 0 \end{cases} $$ $$ PReLU'(\alpha, x) = \begin{cases} \alpha & \text{ for } x \lt 0 \\ 1 & \text{ for } x \geq 0 \end{cases} $$ $$ \alpha = \frac{\sum^{m-1}_{i=0} min(w_i, 0)}{m} $$ avec $w_i$ le poids correspondant à l'entrée $i$ et $m$ le nombre total d'entrée dans la couche.

def prelu(alpha, x):
    return alpha * x if x < 0 else x

def prelu_d(alpha, x):
    return alpha if x < 0 else 1

Avantages :

• PReLU est similaire à ReLU en termes d'efficacité de calcul et de non-linéarité ajoutée, par conséquent elle dispose des mêmes avantages.
• Le coefficient α est un paramètre appris, ce qui évite le problème de choix de la valeur constante dans la fonction Leaky ReLU.
• La fonction PReLU peut potentiellement offrir de meilleures performances que la fonction Leaky ReLU en permettant une adaptation de la pente pour les entrées négatives, en fonction des données et du modèle de réseau de neurones utilisé.

Inconvénients :

• Tout comme Leaky ReLU, le choix initial de la valeur du coefficient de pente est un hyperparamètre qui doit être défini par l'utilisateur.
• PReLU peut avoir un plus grand nombre de paramètres à entraîner par rapport à ReLU, car un coefficient de pente est associé à chaque unité.

Utilisations :

Pour les utilisations, la fonction PReLU doit être utilisée dans les couches cachées du réseau de neurones, tout comme la fonction Leaky ReLU.

Randomized ReLU

Notez qu'il est également possible de générer alpha aléatoirement pour chaque activation lors de la phase d'entrainement. En général, on appelle cette fonction "randomized ReLU". Cette approche est conçue pour introduire une certaine régularisation stochastique dans le réseau, ce qui peut aider à éviter le sur-apprentissage et à améliorer les performances en général.

$$ RReLU(\alpha, x) = \begin{cases} \alpha x & \text{ for } x \lt 0 \\ x & \text{ for } x \geq 0 \end{cases} \text{with $\alpha$ a random variable} $$ $$ RReLU'(\alpha, x) = \begin{cases} \alpha & \text{ for } x \lt 0 \\ 1 & \text{ for } x \geq 0 \end{cases} \text{with $\alpha$ a random variable} $$

import random
random.seed(42) # for consistence between rrelu and its derivative

def rrelu(x):
    alpha = random.uniform(0, 1)
    return alpha * x if x < 0 else x

def rrelu_d(x):
    alpha = random.uniform(0, 1)
    return alpha if x < 0 else 1

On pourra reprendre le graphique de parametric ReLU pour avoir une représentation de cette fonction.