Introduction

Les réseaux de neurones artificiels (ANN pour Artificial Neural Networks en anglais) sont une technique d'apprentissage automatique inspirée du fonctionnement du cerveau humain. Ils sont utilisés pour résoudre une variété de problèmes, tels que la classification d'images, la reconnaissance de la parole, la prédiction de séries temporelles et la traduction automatique.Dans cet article, nous allons explorer les réseaux de neurones artificiels, leur fonctionnement et leur utilisation.



Le fonctionnement d'un réseau de neurones artificiels
Un réseau de neurones artificiels est composé de plusieurs couches de neurones artificiels, qui sont connectés entre eux pour former un graphe. Chaque couche est composée d'un certain nombre de neurones artificiels, qui sont organisés en une structure appelée une matrice.
Les neurones artificiels sont des unités de traitement qui reçoivent des entrées, les traitent et produisent des sorties. Les entrées sont pondérées par des poids, qui sont ajustés lors de l'apprentissage. Les sorties des neurones d'une couche servent d'entrées pour la couche suivante.
Le processus de traitement des entrées par un neurone est appelé une activation. Les activations sont calculées en prenant la somme pondérée des entrées et en y appliquant une fonction d'activation. Cette fonction permet d'introduire une non-linéarité dans le modèle, ce qui lui permet de modéliser des relations plus complexes.
Les réseaux de neurones artificiels sont entraînés à partir d'un ensemble de données d'apprentissage, qui sont utilisées pour ajuster les poids des connexions entre les neurones. Le processus d'ajustement des poids est appelé l'apprentissage. Le but de l'apprentissage est de trouver les poids qui minimisent une fonction de coût, qui mesure l'écart entre les sorties du modèle et les sorties attendues.
Il existe plusieurs techniques d'apprentissage pour les réseaux de neurones artificiels, telles que la rétropropagation de l'erreur et l'apprentissage par renforcement.

Les différentes architectures de réseaux de neurones artificiels
Il existe plusieurs architectures de réseaux de neurones artificiels, chacune adaptée à des tâches spécifiques. Nous allons en examiner quelques-unes ci-dessous :

Les réseaux de neurones à couche unique
Les réseaux de neurones à couche unique sont les réseaux de neurones les plus simples. Ils sont composés d'une seule couche de neurones artificiels. Ils sont souvent utilisés pour la classification binaire ou la régression linéaire.
Les réseaux de neurones multicouches
Les réseaux de neurones multicouches, également appelés réseaux de neurones profonds, sont des réseaux de neurones qui ont plusieurs couches de neurones artificiels. Ils sont souvent utilisés pour la classification d'images, la reconnaissance de la parole et la prédiction de séries temporelles. Ils peuvent avoir des dizaines, voire des centaines de couches.
Les réseaux de neurones récurrents
Un réseau de neurones récurrent est un réseau de neurones qui permet de traiter des données séquentielles telles que des séquences de mots, des séries temporelles ou des signaux audio. Contrairement aux réseaux de neurones classiques, qui traitent chaque entrée de manière indépendante des autres, les RNN utilisent des boucles qui permettent de conserver une mémoire des entrées précédentes.

La rétropropagation de l'erreur, également appelée rétropropagation du gradient, est la méthode la plus couramment utilisée pour entraîner les réseaux de neurones. Elle est basée sur l'algorithme de descente de gradient.
Le principe de la rétropropagation est de calculer la contribution de chaque neurone aux erreurs commises par le réseau. L'erreur est propagée de la couche de sortie vers la couche d'entrée, en utilisant la chaîne de règle de dérivation. À chaque étape, les poids de chaque connexion sont ajustés pour minimiser l'erreur.
Le processus de rétropropagation peut être décrit en plusieurs étapes :

• Initialisation des poids du réseau avec des valeurs aléatoires.
• Présentation d'un exemple d'entraînement au réseau.
• Propagation de l'entrée dans le réseau, couche par couche, pour calculer la sortie du réseau.
• Calcul de l'erreur entre la sortie du réseau et la sortie attendue.
• Propagation de l'erreur de la sortie vers l'entrée, couche par couche, en utilisant la règle de la chaîne.
• Ajustement des poids de chaque connexion, en utilisant l'algorithme de descente de gradient, pour minimiser l'erreur.
• Répétition des étapes 2 à 6 pour tous les exemples d'entraînement.

Le processus de rétropropagation est répété jusqu'à ce que la fonction de coût soit suffisamment petite, ou jusqu'à ce que le modèle ne s'améliore plus. À ce stade, le modèle est considéré comme entraîné.
La rétropropagation est un processus intensif en calcul et en mémoire, car il nécessite le stockage des activations et des gradients de toutes les couches du réseau. Cependant, grâce aux améliorations de la puissance de calcul, elle reste la méthode la plus couramment utilisée pour entraîner les réseaux de neurones.

Un exemple simple d'un ANN avec Tensorflow

Importer les bibliothèques nécessaires:

Code Sélectionner Étendre import tensorflow as tf import numpy as np

Préparer les données:

Code Sélectionner Étendre X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) y = np.array([[0], [1], [1], [0]])

Définir les paramètres du modèle:

Code Sélectionner Étendre n_input = 2 n_hidden = 2 n_output = 1

Définir les poids et les biais:

Code Sélectionner Étendre weights = {     'hidden': tf.Variable(tf.random.normal([n_input, n_hidden])),     'output': tf.Variable(tf.random.normal([n_hidden, n_output])) } biases = {     'hidden': tf.Variable(tf.random.normal([n_hidden])),     'output': tf.Variable(tf.random.normal([n_output])) }

Définir la fonction d'activation:

Code Sélectionner Étendre def sigmoid(x):     return 1 / (1 + tf.exp(-x))

Définir le modèle:

Code Sélectionner Étendre def forward_propagation(x):     hidden_layer = tf.add(tf.matmul(x, weights['hidden']), biases['hidden'])     hidden_layer = sigmoid(hidden_layer)     output_layer = tf.add(tf.matmul(hidden_layer, weights['output']), biases['output'])     output_layer = sigmoid(output_layer)     return output_layer

Définir la fonction de coût:

Code Sélectionner Étendre def cost(y_pred, y_true):     return tf.reduce_mean(tf.square(y_pred - y_true))

Définir l'optimiseur et le taux d'apprentissage:

Code Sélectionner Étendre learning_rate = 0.1 optimizer = tf.optimizers.SGD(learning_rate)

Définir la boucle d'entraînement:
n_epochs = 10000
for epoch in range(n_epochs):
    with tf.GradientTape() as tape:
        y_pred = forward_propagation(X)
        loss = cost(y_pred, y)
        gradients = tape.gradient(loss, [weights['hidden'], weights['output'], biases['hidden'], biases['output']])
    optimizer.apply_gradients(zip(gradients, [weights['hidden'], weights['output'], biases['hidden'], biases['output']]))
    if epoch % 1000 == 0:
        print("Epoch:", epoch, "loss:", loss.numpy())
Dans cette boucle d'entraînement, on utilise la méthode  GradientTape  pour enregistrer les gradients et mettre à jour les poids et les biais en utilisant l'optimiseur. La fonction zip  est utilisée pour associer chaque gradient à son paramètre correspondant.  Une fois l'entraînement terminé, on peut utiliser le modèle pour prédire de nouvelles valeurs:

prediction = forward_propagation(np.array([[0, 1]]))
print(prediction.numpy())

Voici le même exemple avec la bibliothèque KERAS (beaucoup plus simple )

• Importer les bibliothèques nécessaires :

import tensorflow as tf
from tensorflow import keras
import numpy as np

• Préparer les données :

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

• Définir le modèle :

model = keras.Sequential([
    keras.layers.Dense(2, input_dim=2, activation='sigmoid'),
    keras.layers.Dense(1, activation='sigmoid')
])

• Compiler le modèle :

model.compile(loss='mean_squared_error', optimizer='sgd')

• Entraîner le modèle :

model.fit(X, y, epochs=10000, verbose=0)

• Tester le modèle :

prediction = model.predict(np.array([[0, 1]]))
print(prediction)
Dans cet exemple, nous avons utilisé la classe
Sequential de Keras pour définir notre modèle, qui est constitué de deux couches denses avec une fonction d'activation sigmoïde. Nous avons ensuite compilé le modèle en utilisant une fonction de perte de moyenne des erreurs au carré (MSE) et un optimiseur stochastique de descente de gradient (SGD).
Enfin, nous avons entraîné le modèle en utilisant la méthode fit et avons effectué une prédiction en utilisant la méthode predict

Keras est une bibliothèque haut niveau pour la création de modèles de réseaux de neurones, elle est plus simple à utiliser pour les tâches courantes, mais offre moins de liberté qu'une bibliothèque comme TensorFlow pour des tâches plus avancées.