Pour l’instant, nous souhaitons construire un réseau de neurones avec un seul neurone. À titre d’exemple, supposons que nous l’utilisons pour une tâche de classification binaire, telle que la détection de spam, où 0 représente un email légitime (non-spam) et 1 représente un email spam.

Le neurone prendra en entrée des caractéristiques numériques liées aux emails et produira une sortie comprise entre 0 et 1, représentant la probabilité qu’un email soit un spam.

Voici ce qui se passe étape par étape :

1. Chaque entrée est multipliée par un poids correspondant. Les poids sont des paramètres ajustables qui déterminent l’importance de chaque entrée ;
2. Toutes les entrées pondérées sont additionnées ;
3. Un paramètre supplémentaire appelé biais est ajouté à la somme des entrées. Le biais permet au neurone de décaler sa sortie vers le haut ou vers le bas, offrant ainsi une flexibilité au modèle ;
4. La somme des entrées est ensuite transmise à une fonction d’activation. Comme nous avons un seul neurone qui produit directement la sortie finale (une probabilité), nous utiliserons la fonction sigmoïde, qui compresse les valeurs dans l’intervalle $(0, 1)$.

Classe Neurone

Un neurone doit stocker ses poids et son biais, ce qui fait d'une classe un moyen naturel de regrouper ces propriétés associées.

class Neuron:
    def __init__(self, n_inputs):  
        self.weights = ...
        self.bias = ...

• weights : une liste de valeurs initialisées aléatoirement qui déterminent l'importance de chaque entrée (n_inputs correspond au nombre d'entrées) pour le neurone ;
• bias : une valeur initialisée aléatoirement qui aide le neurone à prendre des décisions flexibles.

Les poids et le biais doivent être initialisés aléatoirement avec de petites valeurs comprises entre -1 et 1, tirées d'une distribution uniforme, afin de briser la symétrie et de garantir que différents neurones apprennent des caractéristiques différentes.

Pour récapituler, NumPy fournit la fonction random.uniform() pour générer un nombre aléatoire ou un tableau (en spécifiant l'argument size) de nombres aléatoires issus d'une distribution uniforme dans l'intervalle [low, high).

import numpy as np

np.random.uniform(low, high, size=...)

Propagation avant

De plus, la classe Neuron doit inclure une méthode activate(), qui calcule la somme pondérée des entrées et applique la fonction d'activation (sigmoïde dans notre cas).

En effet, si l'on dispose de deux vecteurs de même longueur (weights et inputs), la somme pondérée peut être calculée à l'aide du produit scalaire de ces vecteurs :

Cela permet de calculer la somme pondérée en une seule ligne de code grâce à la fonction numpy.dot(), ce qui évite l'utilisation d'une boucle. Le biais peut ensuite être ajouté directement au résultat pour obtenir input_sum_with_bias. La sortie est ensuite calculée en appliquant la fonction d'activation sigmoïde :

def activate(self, inputs):
    input_sum_with_bias = ...
    output = ...

    return output

Fonctions d'activation

La formule de la fonction sigmoïde est la suivante, où $z$ représente la somme pondérée des entrées avec le biais ajouté (valeur de sortie brute) pour ce neurone particulier :

En utilisant cette formule, la sigmoïde peut être implémentée comme une fonction simple en Python :

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

La formule de la fonction ReLU est la suivante, qui attribue essentiellement à la sortie la valeur de $z$ si elle est positive et 0 sinon :

def relu(z):
    return np.maximum(0, z)