← Retour au blog
DEEP LEARNING 3 mai 2023

Introduction au Deep Learning — Concepts Fondamentaux & Code

Deep LearningTensorFlowKerasNeural NetworksPython

Introduction

Le deep learning est une branche révolutionnaire de l'intelligence artificielle qui s'inspire de la structure et du fonctionnement du cerveau humain. Contrairement aux approches traditionnelles du machine learning qui nécessitent une extraction manuelle des caractéristiques, le deep learning permet aux algorithmes d'apprendre automatiquement les représentations hiérarchiques des données.

Ces dernières années, le deep learning a transformé des domaines comme la vision par ordinateur, le traitement du langage naturel et la reconnaissance vocale. Des architectures comme les réseaux de neurones convolutifs (CNN) et les transformateurs ont établi de nouveaux standards de performance dans leurs domaines respectifs.

Dans cet article, nous explorerons les concepts fondamentaux du deep learning, découvrirez comment les réseaux de neurones fonctionnent, et mettrez en pratique votre apprentissage avec un exemple concret utilisant TensorFlow et Keras.

Les réseaux de neurones artificiels

Un réseau de neurones artificiel est une structure mathématique inspirée par les réseaux de neurones biologiques. Il est composé de couches interconnectées de neurones, où chaque neurone reçoit une entrée, effectue un calcul, et produit une sortie.

Architecture d'un réseau de neurones

Un réseau de neurones typique se compose de trois types de couches :

  • Couche d'entrée (Input Layer) : Reçoit les données brutes
  • Couches cachées (Hidden Layers) : Effectuent des transformations successives des données
  • Couche de sortie (Output Layer) : Produit la prédiction finale

Équation fondamentale d'un neurone

Chaque neurone applique une transformation linéaire suivie d'une fonction d'activation non-linéaire :

$y = f(\sum w_{i} \cdot x_{i} + b)$

Où :

  • xi : Entrées du neurone
  • wi : Poids (paramètres à apprendre)
  • b : Biais (offset)
  • f : Fonction d'activation (ReLU, Sigmoid, Tanh, etc.)
  • y : Sortie du neurone

Fonctions d'activation courantes

Les fonctions d'activation introduisent la non-linéarité, permettant aux réseaux d'apprendre des relations complexes :

  • ReLU (Rectified Linear Unit) : f(x) = max(0, x) — la plus populaire pour les couches cachées
  • Sigmoid : f(x) = 1 / (1 + e-x) — sortie entre 0 et 1
  • Softmax : Convertit les scores en probabilités — idéal pour la classification multi-classe
  • Tanh : f(x) = (ex - e-x) / (ex + e-x) — sortie entre -1 et 1

Entraînement d'un réseau de neurones

L'entraînement d'un réseau de neurones consiste à ajuster les poids et les biais pour minimiser une fonction de perte (loss function) qui mesure la différence entre les prédictions et les vraies valeurs.

La rétropropagation (Backpropagation)

La rétropropagation est l'algorithme fondamental pour entraîner les réseaux de neurones. Elle fonctionne en deux passes :

  1. Passe avant (Forward Pass) : Les données transitent à travers le réseau, et chaque neurone effectue ses calculs
  2. Passe arrière (Backward Pass) : L'erreur est calculée à la sortie, puis rétropropagée à travers le réseau pour mettre à jour les poids

Cet algorithme utilise la règle de la chaîne du calcul différentiel pour calculer les gradients de la fonction de perte par rapport à chaque poids.

La descente de gradient (Gradient Descent)

La descente de gradient est une technique d'optimisation qui ajuste les paramètres du modèle dans la direction qui réduit la perte :

$w ← w - α \cdot ∇L(w)$

Où :

  • α : Le taux d'apprentissage (learning rate) — contrôle la taille des pas
  • ∇L(w) : Le gradient de la fonction de perte par rapport aux poids

Variantes de descente de gradient

  • SGD (Stochastic Gradient Descent) : Met à jour les poids sur chaque exemple d'entraînement — plus bruyant mais plus rapide
  • Adam : Combine les avantages de SGD et RMSprop — très populaire et généralement très efficace
  • RMSprop : Adapte le taux d'apprentissage pour chaque paramètre

Tutoriel pratique avec TensorFlow et Keras

Passons à la pratique ! Nous allons créer un réseau de neurones simple pour classer des images du dataset Fashion MNIST en utilisant TensorFlow et Keras.

1. Installation

Commencez par installer TensorFlow via pip :

pip install tensorflow

2. Importation des bibliothèques

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt

3. Chargement du dataset Fashion MNIST

Fashion MNIST contient 70 000 images en niveaux de gris de 28×28 pixels, répartis en 10 catégories (t-shirt, pantalon, pull, robe, manteau, sandal, chemise, sneaker, sac, botte).

# Charger le dataset
(train_images, train_labels), (test_images, test_labels) = keras.datasets.fashion_mnist.load_data()

# Afficher les informations du dataset
print(f"Nombre d'images d'entraînement: {train_images.shape[0]}")
print(f"Dimensions de chaque image: {train_images.shape[1:]} pixels")
print(f"Nombre de catégories: {len(np.unique(train_labels))}")

4. Prétraitement des données

Nous devons normaliser les images (valeurs entre 0 et 1) et aplatir les images 2D en vecteurs 1D pour le réseau :

# Normaliser les images en divisant par 255.0
train_images = train_images.astype('float32') / 255.0
test_images = test_images.astype('float32') / 255.0

# Aplatir les images de (28, 28) à (784,)
train_images_flat = train_images.reshape(-1, 28 * 28)
test_images_flat = test_images.reshape(-1, 28 * 28)

5. Création du modèle

Créons un réseau de neurones simple avec une couche cachée :

model = keras.Sequential([
    layers.Flatten(input_shape=(28, 28)),  # Aplatit les images
    layers.Dense(128, activation='relu'),   # Couche cachée avec 128 neurones
    layers.Dropout(0.2),                    # Régularisation pour éviter le surapprentissage
    layers.Dense(10, activation='softmax')  # Couche de sortie pour 10 catégories
])

# Afficher l'architecture du modèle
model.summary()

6. Compilation du modèle

Nous devons spécifier l'optimiseur, la fonction de perte et les métriques :

model.compile(
    optimizer='adam',  # Optimiseur Adam
    loss='sparse_categorical_crossentropy',  # Pour la classification multi-classe
    metrics=['accuracy']  # Métrique pour évaluer la performance
)

7. Entraînement du modèle

Entraînons le modèle pendant 10 épochs :

history = model.fit(
    train_images_flat,
    train_labels,
    epochs=10,
    batch_size=128,
    validation_split=0.1,  # 10% des données pour validation
    verbose=1
)

8. Évaluation du modèle

Évaluons la performance du modèle sur les données de test :

test_loss, test_accuracy = model.evaluate(test_images_flat, test_labels, verbose=0)
print(f"Précision sur les données de test: {test_accuracy * 100:.2f}%")

9. Faire des prédictions

Utilisons le modèle entraîné pour faire des prédictions :

# Faire des prédictions sur les 5 premières images de test
predictions = model.predict(test_images_flat[:5])

# Obtenir les classes prédites
predicted_classes = np.argmax(predictions, axis=1)

# Noms des catégories
class_names = ['T-shirt', 'Pantalon', 'Pull', 'Robe', 'Manteau',
               'Sandal', 'Chemise', 'Sneaker', 'Sac', 'Botte']

for i in range(5):
    print(f"Image {i}: Prédiction={class_names[predicted_classes[i]]}, "
          f"Vrai label={class_names[test_labels[i]]}")

10. Visualisation de l'entraînement

Visualisons comment la perte et la précision ont évolué au cours de l'entraînement :

plt.figure(figsize=(12, 4))

# Graphique de la perte
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Perte d\'entraînement')
plt.plot(history.history['val_loss'], label='Perte de validation')
plt.xlabel('Epoch')
plt.ylabel('Perte')
plt.title('Perte au cours de l\'entraînement')
plt.legend()

# Graphique de la précision
plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Précision d\'entraînement')
plt.plot(history.history['val_accuracy'], label='Précision de validation')
plt.xlabel('Epoch')
plt.ylabel('Précision')
plt.title('Précision au cours de l\'entraînement')
plt.legend()

plt.tight_layout()
plt.show()

Applications du Deep Learning

Le deep learning a révolutionné plusieurs domaines :

Vision par ordinateur

Les réseaux convolutifs (CNN) excellent dans les tâches de vision, permettant la détection d'objets, la segmentation sémantique et la reconnaissance faciale avec une précision surhumaine.

Traitement du langage naturel (NLP)

Les transformateurs et les modèles de langage de grande taille (LLM) ont révolutionné la traduction, la génération de texte et la compréhension du langage naturel.

Reconnaissance vocale

Les réseaux de neurones profonds ont considérablement amélioré les systèmes de reconnaissance vocale, permettant des assistants vocaux comme Siri, Alexa et Google Assistant.

Traduction automatique

Les architectures seq2seq et transformateurs ont permis des systèmes de traduction automatique de haute qualité, comme Google Translate.

Jeux et robotique

L'apprentissage par renforcement (deep RL) a permis des systèmes comme AlphaGo et AlphaZero de maîtriser des jeux complexes, et a des applications prometteuses en robotique.

Défis et limitations

Malgré son succès spectaculaire, le deep learning présente plusieurs défis :

Interprétabilité (Black Box)

Les modèles de deep learning sont souvent des "boîtes noires" dont il est difficile de comprendre comment ils prennent des décisions. C'est problématique dans les domaines critiques comme la santé ou la justice.

Exigences en données

Les réseaux profonds nécessitent généralement d'énormes quantités de données d'entraînement pour généraliser correctement. Obtenir ces données peut être coûteux et chronophage.

Coût computationnel

L'entraînement de modèles profonds, particulièrement les LLM, consomme énormément de ressources computationnelles et d'électricité, posant des défis écologiques et économiques.

Biais et équité

Les modèles apprennent des biais présents dans les données d'entraînement. Sans une attention particulière, les modèles peuvent perpétuer ou amplifier les discriminations existantes.

Surapprentissage

Les modèles complexes peuvent mémoriser les données d'entraînement plutôt que d'apprendre des patterns généralisables, ce qui réduit la performance sur de nouvelles données.

Conclusion

Le deep learning est une technologie puissante qui a transformé l'intelligence artificielle et de nombreux domaines applicatifs. Nous avons couvert les concepts fondamentaux — réseaux de neurones, rétropropagation, descente de gradient — et les avez mis en pratique avec un exemple concret utilisant TensorFlow et Keras.

Le chemin vers la maîtrise du deep learning nécessite de la pratique continue. Je vous encourage à expérimenter avec différentes architectures, datasets et hyperparamètres. Des ressources excellentes comme TensorFlow.org, Keras.io et les cours en ligne comme celui de Andrew Ng sur Coursera peuvent approfondir votre apprentissage.

Le deep learning continue d'évoluer rapidement, avec des innovations constants comme les transformateurs, l'apprentissage par renforcement et la fusion multimodale. Restez curieux, continuez à apprendre, et explorez les frontières de cette technologie fascinante !

← Retour au blog