Perceptron désigne le type le plus simple de réseau de neurones, composé d’un seul neurone. Pour traiter des problèmes plus complexes, un modèle appelé perceptron multicouche (MLP) est utilisé. Un perceptron multicouche contient une ou plusieurs couches cachées qui permettent au réseau d’apprendre des motifs complexes dans les données.

La structure d’un perceptron multicouche comprend :

1. Couche d’entrée : reçoit les données d’entrée ;
2. Couches cachées : traitent les données et extraient des motifs significatifs ;
3. Couche de sortie : produit la prédiction ou la classification finale.

Chaque couche est composée de plusieurs neurones, et la sortie d’une couche sert d’entrée à la couche suivante.

Poids et biais des couches

Avant de mettre en œuvre une couche, il est important de comprendre comment stocker les poids et biais de chaque neurone qui la compose. Dans le chapitre précédent, vous avez appris à stocker les poids d’un seul neurone sous forme de vecteur et son biais sous forme de scalaire (nombre unique).

Puisqu’une couche est constituée de plusieurs neurones, il est naturel de représenter les poids sous forme de matrice, où chaque ligne correspond aux poids d’un neurone spécifique. Par conséquent, les biais peuvent être représentés par un vecteur, dont la longueur est égale au nombre de neurones.

Pour une couche avec $3$ entrées et $2$ neurones, ses poids seront stockés dans une matrice $2 \times 3$ $W$ et ses biais dans un vecteur $2 \times 1$ $b$, qui sont les suivants :

Ici, l’élément $W_{ij}$ représente le poids de la $j$-ième entrée vers le $i$-ième neurone, donc la première ligne contient les poids du premier neurone, et la deuxième ligne contient les poids du deuxième neurone. L’élément $b_i$ représente le biais du $i$-ième neurone (deux neurones – deux biais).

Propagation avant

Effectuer la propagation avant pour chaque couche consiste à activer chacun de ses neurones en calculant la somme pondérée des entrées, en ajoutant le biais, puis en appliquant la fonction d’activation.

Précédemment, pour un seul neurone, la somme pondérée des entrées était réalisée en calculant un produit scalaire entre le vecteur d’entrée et le vecteur de poids, puis en ajoutant le biais.

Puisque chaque ligne de la matrice de poids contient le vecteur de poids d’un neurone particulier, il suffit désormais d’effectuer un produit scalaire entre chaque ligne de la matrice et le vecteur d’entrée. Heureusement, c’est exactement ce que fait la multiplication matricielle :

Pour ajouter les biais aux sorties des neurones respectifs, il convient également d’ajouter un vecteur de biais :

Enfin, la fonction d’activation est appliquée au résultat — sigmoïde ou ReLU, dans notre cas. La formule résultante pour la propagation avant dans la couche est la suivante :

où $a$ est le vecteur des activations (sorties) des neurones.

Classe Layer

Les éléments fondamentaux du perceptron sont ses couches ; il est donc logique de créer une classe distincte Layer. Ses attributs incluent :

• inputs : un vecteur d'entrées (n_inputs est le nombre d'entrées) ;
• outputs : un vecteur de valeurs de sortie brutes (avant l'application de la fonction d'activation) des neurones (n_neurons est le nombre de neurones) ;
• weights : une matrice de poids ;
• biases : un vecteur de biais ;
• activation_function : la fonction d'activation utilisée dans la couche.

Comme dans l'implémentation d'un seul neurone, les weights et biases seront initialisés avec des valeurs aléatoires comprises entre -1 et 1 tirées d'une distribution uniforme.

class Layer:
    def __init__(self, n_inputs, n_neurons, activation_function):
        self.inputs = np.zeros((n_inputs, 1))
        self.outputs = np.zeros((n_neurons, 1))
        self.weights = ...
        self.biases = ...
        self.activation = activation_function

Les attributs inputs et outputs seront utilisés ultérieurement lors de la rétropropagation, il est donc pertinent de les initialiser comme des tableaux NumPy remplis de zéros.

La propagation avant peut être implémentée dans la méthode forward(), où les outputs sont calculés à partir du vecteur inputs en utilisant NumPy, selon la formule ci-dessus :

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs
    self.outputs = ...
    # Applying the activation function
    return ...