Bases de l'apprentissage profond

L'apprentissage profond n'est pas une mystérieuse technologie noire ; c'est essentiellement un ajusteur de fonction mathématique—donnez-lui de grandes quantités de données d'entrée-sortie, et il trouve automatiquement les relations complexes entre elles.

Par exemple : vous lui donnez un million d'images de chats, chaque image correspondant à l'étiquette « chat ». L'apprentissage profond détermine automatiquement quelles combinaisons de pixels ressemblent à un chat.

Un autre exemple : vous lui donnez un milliard de phrases en langage humain, avec le mot suivant de chaque phrase comme cible. L'apprentissage profond apprend automatiquement, étant donné le contexte précédent, quel est le mot suivant le plus probable.

L'avantage principal de l'apprentissage profond est que, à mesure que le volume de données augmente, ses performances continuent de s'améliorer.C'est quelque chose que l'apprentissage automatique traditionnel ne peut pas faire.

Dans ce chapitre, nous allons partir de zéro et décomposer étape par étape chaque composant de l'apprentissage profond :

  • Fondements mathématiques des réseaux de neurones
  • Le processus de calcul de la propagation avant
  • Le rôle des fonctions d'activation
  • Conception de la fonction de perte
  • Le principe de la rétropropagation
  • Sélection de l'optimiseur
  • Techniques de régularisation
  • Méthodes de normalisation
  • Planification du taux d'apprentissage

Enfin, nous implémentons un perceptron multicouche (MLP) complet avec PyTorch, reliant tous les points de connaissance entre eux.

Ce chapitre implique un peu de mathématiques, mais ne vous inquiétez pas—nous expliquerons chaque formule de manière intuitive plutôt que de vous demander de la mémoriser. L'essentiel est de comprendre pourquoi elle est conçue ainsi, et non comment la calculer.


Fondements mathématiques des réseaux de neurones

L'apprentissage profond repose sur trois branches des mathématiques : l'algèbre linéaire, le calcul différentiel et intégral, et la théorie des probabilités.

Vous n'avez pas besoin d'être un expert en mathématiques, mais vous devez comprendre quelques concepts fondamentaux.

Algèbre linéaire : multiplication matricielle

L'opération la plus fondamentale dans les réseaux de neurones est la multiplication matricielle.

Pourquoi utiliser des matrices ? Parce qu'elles peuvent représenter de manière concise le processus selon lequel « plusieurs entrées sont transformées par plusieurs neurones ».

Regardons d'abord un exemple intuitif :

Exemple

# ============================================
# Compréhension intuitive de la multiplication matricielle
# ============================================

import numpy as np

# Supposons que l'entrée soit un vecteur tridimensionnel : [taille, poids, âge]
# Les unités sont : centimètres, kilogrammes, années
x = np.array([175, 70, 25])  # Vecteur d'entrée, forme (3,)
print(f"Entrée x : {x}")
print(f"Forme de l'entrée : {x.shape}")

# Matrice de poids W : 2 neurones, chaque neurone reçoit 3 entrées
# La forme est (dimension de sortie, dimension d'entrée) = (2, 3)
W = np.array([
    [0.1, 0.2, 0.3],   # Poids du 1er neurone
    [0.4, 0.5, 0.6],   # Poids du 2e neurone
])
print(f"\nMatrice de poids W :\n{W}")
print(f"Forme des poids : {W.shape}")

# Biais b : un biais par neurone
b = np.array([0.1, 0.2])  # Forme (2,)
print(f"\nBiais b : {b}")
print(f"Forme du biais : {b.shape}")

# Multiplication matricielle : y = W · x + b
# Remarque : l'opérateur @ de numpy représente la multiplication matricielle
y = W @ x + b
print(f"\nSortie y : {y}")
print(f"Forme de la sortie : {y.shape}")

# Vérifions manuellement
y1 = 0.1 * 175 + 0.2 * 70 + 0.3 * 25 + 0.1  # Le 1er neurone
y2 = 0.4 * 175 + 0.5 * 70 + 0.6 * 25 + 0.2  # Le 2e neurone
print(f"\nVérification du calcul manuel : [{y1}, {y2}]")

La signification géométrique de la multiplication matricielle est une "transformation linéaire" — elle peut faire tourner, mettre à l'échelle et étirer des espaces vectoriels.

Mais les transformations linéaires seules ne suffisent pas.

Si chaque couche n'est qu'une multiplication matricielle, alors quelle que soit la profondeur du réseau, le réseau entier est équivalent à un réseau à une seule couche, car la composition de plusieurs transformations linéaires reste une transformation linéaire.

C'est pourquoi nous avons besoin de fonctions d'activation — pour introduire de la non-linéarité.

Calcul différentiel : dérivées et règle de la chaîne

Le cœur de l'entraînement des réseaux de neurones est la "descente de gradient" — trouver la direction des paramètres qui minimise la perte.

Le gradient est la "dérivée d'une fonction à plusieurs variables" — il nous indique de combien la perte change lorsque chaque paramètre change un peu.

Prenons un exemple simple :

Exemple

# ============================================
# Compréhension intuitive des dérivées
# ============================================

def f(x):
    """Une fonction simple : f(x) = x²"""
    return x ** 2

def numerical_derivative(f, x, h=1e-6):
    """Dérivée numérique : utiliser un petit incrément h pour approximer la dérivée
Définition de la dérivée : f'(x) = lim(h→0) [f(x+h) - f(x)] / h
    """

    return (f(x + h) - f(x)) / h

# Calculer la dérivée en x=3
x = 3.0
df_dx = numerical_derivative(f, x)
print(f"f({x}) = {f(x)}")
print(f"f'({x}) ≈ {df_dx}")
print(f"Solution analytique (valeur exacte) : 2 * {x} = {2 * x}")

# Comprendre la signification de la dérivée :
# La dérivée 6 signifie : en x=3, si x augmente de 1, f(x) augmente d'environ 6
x_new = x + 0.01
f_new = f(x_new)
print(f"\nx augmente de {x} à {x_new}")
print(f"f(x) passe de {f(x)} à {f_new}")
print(f"Augmentation réelle : {f_new - f(x)}")
print(f"Prédiction de la dérivée : {df_dx * 0.01}")

Pour les fonctions à plusieurs variables, nous devons calculer la dérivée partielle par rapport à chaque variable, puis les combiner en un vecteur—c'est le gradient.

La règle de la chaîne est le fondement mathématique de la rétropropagation. Elle nous permet de « décomposer couche par couche » les dérivées des fonctions composées.

Exemple

# ============================================
# Compréhension intuitive de la règle de la chaîne
# ============================================

# Considérons une fonction composée : y = f(g(x))
# Où : g(x) = x², f(z) = z³
# Alors : y = (x²)³ = x⁶

def g(x):
    return x ** 2

def f(z):
    return z ** 3

def y(x):
    return f(g(x))

# Calculer manuellement la dérivée (règle de la chaîne) :
# dy/dx = df/dz * dz/dx = 3*z² * 2*x = 3*(x²)² * 2*x = 6*x⁵

x = 2.0
z = g(x)  # z = 4
dy_dx_chain = 3 * (z ** 2) * 2 * x  # Calcul par la règle de la chaîne
print(f"Calcul par la règle de la chaîne : dy/dx = {dy_dx_chain}")

# Vérification numérique de la dérivée
def numerical_derivative_y(x, h=1e-6):
    return (y(x + h) - y(x)) / h

dy_dx_numerical = numerical_derivative_y(x)
print(f"Vérification de la dérivée numérique : dy/dx ≈ {dy_dx_numerical}")

# Solution analytique : 6*x^5 = 6*32 = 192
print(f"Solution analytique : 6 * {x}^5 = {6 * (x ** 5)}")

L’idée centrale de la règle de la chaîne est :Décomposer une fonction complexe en fonctions simples, dériver chacune, puis les multiplier ensemble.。

La rétropropagation est l’application de la règle de la chaîne dans les réseaux de neurones — en partant de la sortie, elle propage les gradients vers l’arrière, couche par couche.

Théorie des probabilités : probabilité conditionnelle

Dans les problèmes de classification, les réseaux de neurones produisent souvent une "distribution de probabilité" — étant donné une entrée, quelle est la probabilité de chaque classe.

La probabilité conditionnelle P(Y|X) représente "la probabilité que Y se produise étant donné que X s’est produit."

:.2%}

:.2%}

Exemple

# ============================================
# Utiliser un réseau de neurones pour produire une distribution de probabilité
# ============================================

import numpy as np

def softmax(x):
    """Fonction Softmax : convertit des nombres réels arbitraires en une distribution de probabilité
La somme des valeurs de sortie vaut 1, et chaque valeur est comprise entre [0, 1]
    """

    # Soustraire la valeur maximale pour éviter un débordement numérique
    exp_x = np.exp(x - np.max(x))
    return exp_x / np.sum(exp_x)

# Supposons que la dernière couche du réseau de neurones produise 3 "scores" (logits)
# Ils correspondent respectivement à "cat", "dog" et "bird"
logits = np.array([2.0, 1.0, 0.5])
print(fSortie du réseau de neurones (logits) : {logits})

# Utiliser Softmax pour convertir en probabilités
probabilities = softmax(logits)
print(fDistribution de probabilité : {probabilities})
print(fSomme des probabilités : {np.sum(probabilities)})

# Interprétation :
# P(chat|image d'entrée) ≈ 0.67
# P(chien|image d'entrée) ≈ 0.24
# P(oiseau|image d'entrée) ≈ 0.09
print("\nProbabilités des catégories :)
print(fChat : {probabilities)
print(fChien : {probabilities)
print(fOiseau : {probabilities)

Points essentiels de trois fondements mathématiques :

Branche mathématiqueConcept cléUtilisation en apprentissage profond
Algèbre linéaireMultiplication matricielle, vecteurs, tenseursReprésenter la structure du réseau, calculer efficacement la propagation avant
Calcul infinitésimalDérivées, règle de la chaîne, gradientsRétropropagation, mise à jour des paramètres
Théorie des probabilitésProbabilité conditionnelle, distribution de probabilitéIncertitude du modèle, concevoir des fonctions de perte

Propagation avant

La propagation avant est le processus de calcul par lequel les données d'entrée « traversent » le réseau de neurones, de la couche d'entrée à la couche cachée, puis à la couche de sortie.

Graphe de calcul

Représenter un réseau de neurones sous forme de graphe de calcul rend la logique de la propagation avant et de la rétropropagation plus claire.

Un graphe de calcul est constitué de nœuds (opérations) et d'arêtes (flux de données).

Graphe de calcul d'un réseau de neurones simple à deux couches :

Exemple

# ============================================
# Utiliser un graphe de calcul pour comprendre la propagation avant
# ============================================

import numpy as np

def relu(x):
    """Fonction d'activation ReLU : max(0, x)"""
    return np.maximum(0, x)

# Un réseau de neurones simple à deux couches
# Couche d'entrée (2) → couche cachée (3) → couche de sortie (2)

# Entrée : x = [x1, x2]
x = np.array([1.0, 2.0])
print(fEntrée x : {x})

# Première couche : entrée → couche cachée
W1 = np.array([
    [0.1, 0.2],  # 1er neurone caché
    [0.3, 0.4],  # 2e neurone caché
    [0.5, 0.6],  # 3e neurone caché
])
b1 = np.array([0.1, 0.2, 0.3])

# Deuxième couche : couche cachée → couche de sortie
W2 = np.array([
    [0.1, 0.2, 0.3],  # 1er neurone de sortie
    [0.4, 0.5, 0.6],  # 2e neurone de sortie
])
b2 = np.array([0.1, 0.2])

# Graphe de calcul de propagation avant
# Étape 1 : transformation linéaire de la couche cachée
z1 = W1 @ x + b1
print(f"\nTransformation linéaire de la couche cachée z1 : {z1})

# Étape 2 : fonction d'activation de la couche cachée
a1 = relu(z1)
print(fActivation de la couche cachée a1 : {a1})

# Étape 3 : transformation linéaire de la couche de sortie
z2 = W2 @ a1 + b2
print(fTransformation linéaire de la couche de sortie z2 : {z2})

# Étape 4 : activation de la couche de sortie (pour les problèmes de classification, généralement Softmax)
a2 = softmax(z2)  # Utiliser la fonction softmax définie précédemment
print(fActivation de la couche de sortie a2 : {a2})

L'avantage du graphe de calcul est que chaque étape est claire, et lors de la rétropropagation, vous calculez simplement les gradients dans l'ordre inverse.

Les réseaux de neurones du point de vue de la multiplication matricielle

Du point de vue de la multiplication matricielle, un réseau de neurones est une série de "transformations linéaires + activations non linéaires".

Chaque couche peut être abstraite comme :

aᵢ = activation(Wᵢ · aᵢ₋₁ + bᵢ)

où a₀ est l'entrée x.

Cette formule est concise mais puissante — elle peut représenter presque toutes les structures de réseaux de neurones, de la simple régression logistique aux Transformers complexes.

Remarquez la correspondance des dimensions pour la multiplication matricielle : si le vecteur d'entrée est de dimension n et que la couche suivante a m neurones, alors la matrice de poids W doit avoir la forme m×n. Ainsi, après W·x, vous obtenez un vecteur de dimension m.

Le rôle des fonctions d'activation

Comme mentionné précédemment : sans fonctions d'activation, un réseau profond est équivalent à un réseau à une seule couche.

Utilisez un exemple simple pour le prouver :

Exemple

# ============================================
# Pourquoi les fonctions d'activation sont nécessaires
# ============================================

import numpy as np

# Supposons qu'il existe un réseau à deux couches, mais qu'aucune des deux couches n'a de fonction d'activation

# Entrée
x = np.array([1.0, 2.0])

# Poids et biais de la première couche
W1 = np.array([[0.1, 0.2], [0.3, 0.4]])
b1 = np.array([0.1, 0.2])

# Poids et biais de la deuxième couche
W2 = np.array([[0.5, 0.6], [0.7, 0.8]])
b2 = np.array([0.3, 0.4])

# Calculer les deux couches séparément
z1 = W1 @ x + b1
z2 = W2 @ z1 + b2
print(f"Résultats du calcul à deux couches : {z2}")

# Fusionner en une seule couche pour le calcul
# On peut le démontrer mathématiquement : z2 = (W2·W1)·x + (W2·b1 + b2)
W_combined = W2 @ W1
b_combined = W2 @ b1 + b2
z_combined = W_combined @ x + b_combined
print(f"Résultat du calcul fusionné en une seule couche : {z_combined}")

# Les résultats sont exactement identiques !
print(f"\n"Les deux résultats sont égaux : {np.allclose(z2, z_combined)}")
print("Conclusion : sans fonctions d'activation, un réseau profond = un réseau à une seule couche")

Les fonctions d'activation sont le composant clé qui donne tout leur sens aux réseaux profonds—elles introduisent la non-linéarité et permettent au réseau d'apprendre des motifs complexes.


Les fonctions d'activation en détail

Une fonction d'activation détermine comment la sortie d'un neurone réagit à son entrée.

Une bonne fonction d'activation doit satisfaire plusieurs conditions :

  • Non-linéarité : c'est indispensable
  • Dérivabilité : afin que les gradients puissent être calculés
  • Calcul simple : la propagation avant et la rétropropagation doivent être rapides
  • Absence de saturation : les gradients ne disparaîtront ni n'exploseront

Regardons les fonctions d'activation les plus couramment utilisées.

Sigmoïde : saturation et gradients évanescents

La sigmoïde est l'une des premières fonctions d'activation. Elle ramène tout nombre réel dans l'intervalle (0, 1).

Formule : σ(x) = 1 / (1 + e⁻ˣ)

Exemple

# ============================================
# Fonction d'activation sigmoïde
# ============================================

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    """Fonction sigmoïde"""
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    """Dérivée de la sigmoïde : σ'(x) = σ(x) * (1 - σ(x))"""
    s = sigmoid(x)
    return s * (1 - s)

# Tester quelques valeurs
x_values = [-10, -5, -2, 0, 2, 5, 10]
print("x | sigmoid(x) | sigmoid'(x)")
print("-" * 40)
for x in x_values:
    s = sigmoid(x)
    d = sigmoid_derivative(x)
    print(f"{x:4} | {s:10.6f} | {d:12.6f}")

# Observation : lorsque x est très grand ou très petit, la dérivée tend vers 0
# C'est le problème du "gradient évanescent"
x_big = 10.0
print(f"\n"Lorsque x = {x_big} :")
print(f" sigmoid(x) = {sigmoid(x_big):.10f} (presque 1)")
print(f" sigmoid'(x) = {sigmoid_derivative(x_big):.10f} (presque 0)")
print("Le gradient disparaît ! Lors de la rétropropagation, le gradient ne peut pas être transmis en retour.")

Les problèmes de la sigmoïde sont évidents :

  • Lorsque |x| > 6, le gradient est presque 0, ce qui entraîne la disparition des gradients
  • La sortie n'est pas centrée en 0, ce qui affecte l'optimisation
  • Le calcul de l'exponentielle est relativement lent

En raison de ces problèmes, la sigmoïde est rarement utilisée dans les couches cachées en apprentissage profond moderne.

ReLU et variantes

ReLU (unité linéaire rectifiée) est la fonction d'activation la plus couramment utilisée aujourd'hui.

Formule : ReLU(x) = max(0, x)

Simple mais très efficace.

Exemple

# ============================================
# ReLU et ses variantes
# ============================================

import numpy as np

def relu(x):
    """ReLU:max(0, x)"""
    return np.maximum(0, x)

def relu_derivative(x):
    """Dérivée de ReLU : 1 lorsque x > 0, sinon 0"""
    return (x > 0).astype(float)

def leaky_relu(x, alpha=0.01):
    """Leaky ReLU : x lorsque x > 0, sinon alpha*x"""
    return np.where(x > 0, x, alpha * x)

def gelu(x):
    """GELU:Unité linéaire d'erreur gaussienne
C'est la fonction d'activation couramment utilisée dans les Transformers
Formule d'approximation : 0.5 * x * (1 + tanh(sqrt(2/pi) * (x + 0.044715*x^3)))
    """

    cdf = 0.5 * (1.0 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
    return x * cdf

# Test
x_values = [-5, -2, -1, 0, 1, 2, 5]
print("x | ReLU | Leaky | GELU")
print("-" * 45)
for x in x_values:
    r = relu(x)
    lr = leaky_relu(x)
    g = gelu(x)
    print(f"{x:4} | {r:4.2f} | {lr:5.2f} | {g:5.2f}")

# Avantages de ReLU :
print("\n"Avantages de ReLU :")
print("1. Calcul simple : ne nécessite que l'opération max")
print("2. Pas de saturation (intervalle positif) : le gradient est toujours 1")
print("3. Sparsité : certaines sorties de neurones sont 0, ce qui augmente la robustesse du modèle")

# Problème avec ReLU : "ReLU mourant"
print("\n"Problème avec ReLU : ReLU mourant")
print(Si l'entrée d'un neurone est toujours négative, alors :)
print(- La sortie est toujours 0)
print(- Le gradient est toujours 0)
print(- Les paramètres ne sont jamais mis à jour)
print(- Ce neurone est 'mort')

Comparaison de plusieurs fonctions d'activation courantes :

Fonction d'activationFormuleAvantagesInconvénientsScénarios applicables
Sigmoïde1/(1+e⁻ˣ)Sortie dans (0,1), interprétable comme une probabilitéGradient qui disparaît, non centrée sur zéro, calcul lentCouche de sortie pour classification binaire (rarement utilisée pour les couches cachées)
ReLUmax(0, x)Calcul rapide, non-saturation, sparsitéReLU mort, sortie non centrée sur zéroLa plupart des couches cachées (choix par défaut)
Leaky ReLUmax(αx, x)Résout le problème du ReLU mortα doit être sélectionné manuellementAlternative lorsque ReLU échoue
GELUx·Φ(x)Lisse, fonctionne bien dans les TransformersCalcul légèrement plus complexeTransformer, BERT, GPT, etc.
Swish/SwiGLUx·σ(βx)Supérieur à ReLU dans les réseaux profondsCalcul complexeGrands modèles tels que PaLM, LLaMA

Principes de sélection

Choix recommandés pour les fonctions d'activation :

  • Couche cachée: Préférez ReLU, simple et efficace
  • Si vous rencontrez un ReLU mort: Essayez Leaky ReLU ou GELU
  • Transformer: GELU ou SwiGLU est le choix standard
  • Couche de sortie de classification binaire: Sigmoid (produit une probabilité)
  • Couche de sortie de classification multi-classes: Softmax (produit une distribution de probabilités)
  • Couche de sortie de régression: Aucune activation (produit n'importe quel nombre réel)

Ne réfléchissez pas trop au choix de la fonction d'activation. Généralement, ReLU suffit. Lorsque vous confirmez que ReLU est le goulot d'étranglement, il n'est pas trop tard pour passer à d'autres.


Fonctions de perte

La fonction de perte mesure l'écart entre la "prédiction du modèle" et la "vraie réponse".

L'objectif de l'entraînement est de rendre cet écart aussi petit que possible.

Perte d'entropie croisée (classification)

La fonction de perte la plus couramment utilisée pour les problèmes de classification est la perte d'entropie croisée.

Sa signification intuitive est : « dans quelle mesure la distribution de probabilité prédite par le modèle diffère de la distribution réelle. »

Exemple

# ============================================
# Perte d'entropie croisée
# ============================================

import numpy as np

def cross_entropy_loss(probs, target_one_hot):
    """Perte d'entropie croisée
probs: distribution de probabilité prédite par le modèle, forme (batch_size, num_classes)
target_one_hot: encodage one-hot des étiquettes réelles, même forme que ci-dessus
    """

    # Ajouter epsilon pour éviter log(0)
    epsilon = 1e-12
    probs = np.clip(probs, epsilon, 1.0 - epsilon)
    # cross_entropy = -sum(target * log(pred))
    return -np.sum(target_one_hot * np.log(probs)) / len(probs)

def softmax(x):
    """Fonction Softmax"""
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# Exemple : problème de classification à trois classes, les classes sont "chat", "chien", "oiseau"

# Supposons que l'étiquette réelle soit "chat" (indice 0), encodée en one-hot
target = np.array([[1, 0, 0]])  # La bonne réponse est la classe 0

# Scénario 1 : le modèle prédit avec confiance "chat"
logits1 = np.array([[5.0, 0.5, 0.1]])  # Le chat a le score le plus élevé
probs1 = softmax(logits1)
loss1 = cross_entropy_loss(probs1, target)
print("Scénario 1 : le modèle prédit correctement avec confiance")
print(f" Distribution de probabilités : {probs1)
print(f" Perte : {loss1:.6f} (très faible)")

# Scénario 2 : Le modèle est incertain
logits2 = np.array([[1.0, 0.9, 0.8]])  # Les scores des trois classes sont similaires
probs2 = softmax(logits2)
loss2 = cross_entropy_loss(probs2, target)
print("\n"Scénario 2 : Le modèle est incertain")
print(f" Distribution de probabilités : {probs2")
print(f" Perte : {loss2:.6f} (moyenne)")

# Scénario 3 : Le modèle prédit incorrectement
logits3 = np.array([[0.1, 5.0, 0.5]])  # Le chien a le score le plus élevé
probs3 = softmax(logits3)
loss3 = cross_entropy_loss(probs3, target)
print("\n"Scénario 3 : le modèle prédit incorrectement")
print(f" Distribution de probabilité : {probs3)
print(f" Perte : {loss3:.6f} (très grande)")

Une version simplifiée de la perte d'entropie croisée : lorsque les étiquettes sont des indices de classe au lieu d'un encodage one-hot, une méthode de calcul plus efficace peut être utilisée :

loss = -log(probs[target_class])

C'est pourquoi dans PyTorch, CrossEntropyLoss accepte directement les indices de classe comme étiquettes.

Perte MSE (régression)

Pour les problèmes de régression (prédiction de valeurs continues), la perte la plus couramment utilisée est l'erreur quadratique moyenne (MSE).

Formule : MSE = mean((pred - target)²)

Exemple

# ============================================
# Perte MSE
# ============================================

import numpy as np

def mse_loss(pred, target):
    """Perte d'erreur quadratique moyenne"""
    return np.mean((pred - target) ** 2)

def mae_loss(pred, target):
    """Perte d'erreur absolue moyenne"""
    return np.mean(np.abs(pred - target))

# Exemple : prédiction des prix des maisons (unité : dix mille yuans)

# Prix réels des maisons
target = np.array([100, 200, 150])

# Scénario 1 : la prédiction est très précise
pred1 = np.array([102, 195, 148])
mse1 = mse_loss(pred1, target)
mae1 = mae_loss(pred1, target)
print("Scénario 1 : prédiction précise")
print(f" Prédiction : {pred1}")
print(f" Réel : {target}")
print(f" MSE : {mse1:.2f}")
print(f" MAE : {mae1:.2f}")

# Scénario 2 : La prédiction a une erreur importante
pred2 = np.array([102, 280, 148])  # La prédiction pour la deuxième maison est supérieure de 800,000
mse2 = mse_loss(pred2, target)
mae2 = mae_loss(pred2, target)
print("\n"Scénario 2 : Il y a une erreur importante")
print(f" Prédiction : {pred2}")
print(f" Réel : {target}")
print(f" MSE : {mse2:.2f} (fortement amplifiée par l'erreur importante)")
print(f" MAE : {mae2:.2f}")

# MSE vs MAE
print("\nMSE vs MAE:")
print("- MSE est plus sensible aux grandes erreurs (à cause de la mise au carré)")
print("- MAE est plus robuste aux valeurs aberrantes")
print("- En général, MSE est plus souvent utilisé")

Perte de prédiction du mot suivant pour les modèles de langage

L'objectif d'entraînement des grands modèles de langage (par ex., GPT) est simple : étant donné le contexte précédent, prédire le mot suivant.

Il s'agit essentiellement d'un problème de classification multi-classe — chaque mot du vocabulaire est une classe.

Exemple

# ============================================
# Fonction de perte pour les modèles de langage
# ============================================

import numpy as np

def language_model_loss(logits, targets, vocab_size):
    """Perte du modèle de langage
Essentiellement, il s'agit de la perte d'entropie croisée à chaque position.
    """

    batch_size, seq_len, _ = logits.shape
    total_loss = 0.0

    # Calculer la perte à chaque position de la séquence
    for i in range(seq_len):
        # Scores prédits à cette position
        step_logits = logits[:, i, :]
        # Convertir en probabilités
        step_probs = softmax(step_logits)
        # Index du mot cible
        step_target = targets[:, i]
        # Prendre uniquement la probabilité du mot cible
        for b in range(batch_size):
            target_idx = step_target[b]
            target_prob = step_probs[b, target_idx]
            # Perte = -log(p)
            total_loss += -np.log(target_prob + 1e-12)

    return total_loss / (batch_size * seq_len)

# Un exemple simple
vocab_size = 10000  # Supposons que la taille du vocabulaire soit de 10,000
batch_size = 2
seq_len = 3

# Sortie du modèle : (batch_size, seq_len, vocab_size)
logits = np.random.randn(batch_size, seq_len, vocab_size)

# Cibles réelles : l'indice du mot qui devrait être prédit à chaque position
targets = np.array([
    [123, 456, 789],   # Mot cible pour la première séquence
    [234, 567, 890],   # Mot cible pour la deuxième séquence
])

loss = language_model_loss(logits, targets, vocab_size)
print(f"Perte du modèle de langage : {loss:.4f}")
print("\n"Signification de cette perte :")
print("- Pour chaque position dans la séquence")
print("- Prédire le mot suivant")
print("- Calculer l'entropie croisée moyenne sur toutes les positions")

Résumé des fonctions de perte courantes :

Type de tâcheFonction de perteActivation de la couche de sortieFormat des étiquettes
Classification binaireEntropie croisée binaireSigmoïde0 ou 1
Classification multiclasseEntropie croiséeSoftmaxIndice de classe
Classification multi-étiquettesEntropie croisée binaireSigmoïdeMultiples 0/1
RégressionMSE / MAEAucuneValeur continue
Modèle de langageEntropie croiséeSoftmaxIndice de mot

Rétropropagation

La rétropropagation est l'algorithme central pour l'entraînement des réseaux de neurones.

Son objectif est de calculer le gradient de la fonction de perte par rapport à chaque paramètre, puis d'utiliser la descente de gradient pour mettre à jour les paramètres.

Dérivation via la règle de la chaîne

Nous allons utiliser un exemple simple pour dériver la rétropropagation étape par étape.

Exemple

# ============================================
# Implémenter manuellement la rétropropagation
# ============================================

import numpy as np

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

def relu_derivative(x):
    return (x > 0).astype(float)

def mse_loss(pred, target):
    return np.mean((pred - target) ** 2)

# Le réseau de neurones le plus simple : une transformation linéaire
# y = w * x + b
# Loss = (y - target)^2

# Entrée et cible
x = np.array(2.0)
target = np.array(7.0)

# Initialiser les paramètres
w = np.array(1.0)
b = np.array(0.0)

print(f"Paramètres initiaux : w = {w}, b = {b}")
print(f"Cible : {target}")

# ============================================
# Étape 1 : propagation avant
# ============================================
y = w * x + b
loss = (y - target) ** 2
print(f"\n"Propagation avant :")
print(f"  y = {y}")
print(f" loss = {loss}")

# ============================================
# Étape 2 : Rétropropagation (calcul manuel des gradients)
# ============================================
# Nous devons calculer : d_loss/d_w, d_loss/d_b

# Utilisez la règle de la chaîne étape par étape :
# loss = (y - target)^2
# d_loss/d_y = 2 * (y - target)
d_loss_d_y = 2 * (y - target)

# y = w * x + b
# d_y/d_w = x
# d_y/d_b = 1
d_y_d_w = x
d_y_d_b = 1.0

# Règle de la chaîne :
# d_loss/d_w = d_loss/d_y * d_y/d_w
# d_loss/d_b = d_loss/d_y * d_y/d_b
d_loss_d_w = d_loss_d_y * d_y_d_w
d_loss_d_b = d_loss_d_y * d_y_d_b

print(f"\n"Rétropropagation :")
print(f" d_loss/d_y = {d_loss_d_y}")
print(f" d_loss/d_w = {d_loss_d_w}")
print(f" d_loss/d_b = {d_loss_d_b}")

# ============================================
# Étape 3 : Mettre à jour les paramètres à l'aide de la descente de gradient
# ============================================
learning_rate = 0.1
w_new = w - learning_rate * d_loss_d_w
b_new = b - learning_rate * d_loss_d_b

print(f"\n"Mise à jour des paramètres :")
print(f" w: {w} -> {w_new}")
print(f" b: {b} -> {b_new}")

# Vérification : utiliser les nouveaux paramètres pour la propagation avant # Vérification : propagation avant avec de nouveaux paramètres
y_new = w_new * x + b_new
loss_new = (y_new - target) ** 2
print(f"\nVérification : Vérification :)
print(f" Ancienne prédiction : {y}, ancienne perte : {loss}" " Ancienne prédiction : {y}, ancienne perte : {loss}")
print(f" Nouvelle prédiction : {y_new}, nouvelle perte : {loss_new}" " Nouvelle prédiction : {y_new}, nouvelle perte : {loss_new}")
print(f" La perte a diminué !" " La perte a diminué !")

Bien que cet exemple soit simple, il contient toutes les idées essentielles de la rétropropagation :

  1. Propagation avant : calculer toutes les variables intermédiaires Propagation avant : calculer toutes les variables intermédiaires
  2. Rétropropagation : à partir de la sortie, utiliser la règle de la chaîne pour calculer les gradients couche par couche Rétropropagation : à partir de la sortie, utiliser la règle de la chaîne pour calculer les gradients couche par couche
  3. Mise à jour des paramètres : utiliser la descente de gradient pour mettre à jour les paramètres Mise à jour des paramètres : mettre à jour les paramètres à l'aide de la descente de gradient

Flux de gradient dans les graphes de calcul

pour les réseaux neuronaux multicouches, les gradients circulent vers l'arrière dans le graphe de calcul. Pour les réseaux neuronaux multicouches, les gradients circulent vers l'arrière à travers le graphe de calcul.

le gradient de chaque couche dépend du gradient transmis par la couche suivante. Le gradient de chaque couche dépend du gradient transmis par la couche suivante.

Exemple

# ============================================
# Rétropropagation d'un réseau à deux couches # Rétropropagation pour un réseau à deux couches
# ============================================

import numpy as np

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

def relu_derivative(x):
    return (x > 0).astype(float)

# Un réseau à deux couches # Un réseau à deux couches
# Entrée (2) → Couche cachée (3) → Sortie (1) # Entrée (2) → Couche cachée (3) → Sortie (1)

# Données # Données
x = np.array([1.0, 2.0])  # Entrée # Entrée
target = np.array([5.0])  # Sortie cible # Sortie cible

# Initialisation des paramètres # Initialisation des paramètres
W1 = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])  # (3, 2)
b1 = np.array([0.1, 0.2, 0.3])  # (3,)
W2 = np.array([[0.7, 0.8, 0.9]])  # (1, 3)
b2 = np.array([0.4])  # (1,)

print(Les paramètres initiaux ont été définis.)

# ============================================
# Propagation avant # Propagation avant
# ============================================
print("\n=== Propagation avant ===" === Propagation avant ===)

# Première couche # Première couche
z1 = W1 @ x + b1  # (3,)
a1 = relu(z1)     # (3,)
print(f"z1 = {z1}")
print(f"a1 = {a1}")

# Deuxième couche # Deuxième couche
z2 = W2 @ a1 + b2  # (1,)
a2 = z2  # RegressionTask, outputlayerNoad # Tâche de régression, pas d'activation sur la couche de sortie
print(f"z2 = {z2}")
print(f"a2 = {a2}")

# Perte # Perte
loss = np.mean((a2 - target) ** 2)
print(f"perte = {loss}")

# ============================================
# Rétropropagation # Rétropropagation
# ============================================
print("\n=== Rétropropagation ===" === Rétropropagation ===)

# Gradient de la couche de sortie # Gradient de la couche de sortie
d_loss_d_a2 = 2 * (a2 - target)  # (1,)
d_a2_d_z2 = 1.0  # Pas de fonction d'activation # Pas de fonction d'activation
d_loss_d_z2 = d_loss_d_a2 * d_a2_d_z2  # (1,)
print(f"d_loss_d_z2 = {d_loss_d_z2}")

# N° 2 gradient des paramètres de la couche # Gradients des paramètres de la deuxième couche
d_z2_d_W2 = a1  # (3,), car z2 = W2@a1 + b2 # (3,), car z2 = W2@a1 + b2
d_z2_d_b2 = 1.0  # (1,)
d_z2_d_a1 = W2[0]  # (3,)

# Calculer les gradients des paramètres # Calculer les gradients des paramètres
d_loss_d_W2 = d_loss_d_z2.reshape(-1, 1) @ d_z2_d_W2.reshape(1, -1)  # (1, 3)
d_loss_d_b2 = d_loss_d_z2 * d_z2_d_b2  # (1,)
print(f"d_loss_d_W2 = {d_loss_d_W2}")
print(f"d_loss_d_b2 = {d_loss_d_b2}")

# Gradient transmis à la couche cachée # Gradient transmis à la couche cachée
d_loss_d_a1 = d_loss_d_z2 @ d_z2_d_a1  # (3,)
print(f"d_loss_d_a1 = {d_loss_d_a1}")

# Gradient de la couche cachée # Gradient de la couche cachée
d_a1_d_z1 = relu_derivative(z1)  # (3,)
d_loss_d_z1 = d_loss_d_a1 * d_a1_d_z1  # (3,)
print(f"d_loss_d_z1 = {d_loss_d_z1}")

# Gradients des paramètres de la première couche # Gradients des paramètres de la première couche
d_z1_d_W1 = x  # (2,)
d_z1_d_b1 = 1.0  # (3,)

# Calculer les gradients des paramètres # Calculer les gradients des paramètres
d_loss_d_W1 = d_loss_d_z1.reshape(-1, 1) @ d_z1_d_W1.reshape(1, -1)  # (3, 2)
d_loss_d_b1 = d_loss_d_z1 * d_z1_d_b1  # (3,)
print(f"d_loss_d_W1 = {d_loss_d_W1}")
print(f"d_loss_d_b1 = {d_loss_d_b1}")

# ============================================
# Mise à jour des paramètres # Mise à jour des paramètres
# ============================================
print("\n=== Mise à jour des paramètres === === Mise à jour des paramètres ===)
learning_rate = 0.01

W1_new = W1 - learning_rate * d_loss_d_W1
b1_new = b1 - learning_rate * d_loss_d_b1
W2_new = W2 - learning_rate * d_loss_d_W2
b2_new = b2 - learning_rate * d_loss_d_b2

print("Les paramètres ont été mis à jour." "Les paramètres ont été mis à jour.")

Cet exemple montre le processus complet de rétropropagation. Cet exemple montre le processus complet de rétropropagation.

La règle fondamentale est : Les règles fondamentales sont :

  • Pour une couche linéaire y = Wx + b : dL/dW = (dL/dy)·xᵀ, dL/db = dL/dy Pour une couche linéaire y = Wx + b : dL/dW = (dL/dy)·xᵀ, dL/db = dL/dy
  • Pour une fonction d'activation y = f(z) : dL/dz = dL/dy ⊙ f'(z) (⊙ est une multiplication élément par élément) Pour une fonction d'activation y = f(z) : dL/dz = dL/dy ⊙ f'(z) (⊙ est une multiplication élément par élément)
  • Les gradients se propagent de l'arrière vers l'avant, et chaque couche utilise la règle de la chaîne pour "accumuler" les gradients. Les gradients se propagent de l'arrière vers l'avant, et chaque couche utilise la règle de la chaîne pour "accumuler" les gradients.

La bonne nouvelle est : les frameworks modernes d'apprentissage profond (comme PyTorch, TensorFlow) calculent automatiquement la rétropropagation pour vous. Vous n'avez qu'à définir la propagation avant, et le framework se charge de tout le calcul des gradients avec la différenciation automatique (autograd). La bonne nouvelle est : les frameworks modernes d'apprentissage profond (comme PyTorch, TensorFlow) calculent automatiquement la rétropropagation pour vous. Vous n'avez qu'à définir la propagation avant, et le framework se charge de tout le calcul des gradients avec la différenciation automatique (autograd).


Optimiseurs de descente de gradient

Après avoir calculé les gradients, nous devons utiliser un optimiseur pour mettre à jour les paramètres. Après avoir calculé les gradients, nous devons utiliser un optimiseur pour mettre à jour les paramètres.

L'optimiseur le plus simple est la descente de gradient stochastique (SGD), mais il existe de nombreux optimiseurs plus avancés. L'optimiseur le plus simple est la descente de gradient stochastique (SGD), mais il existe de nombreux optimiseurs plus avancés.

SGD : descente de gradient stochastique

Formule : θ = θ - η·∇L(θ) Formule : θ = θ - η·∇L(θ)

où η est le taux d'apprentissage. où η est le taux d'apprentissage.

Exemple

# ============================================
# Optimiseur SGD # Optimiseur SGD
# ============================================

import numpy as np

def f(x):
    """La fonction que nous voulons minimiser : f(x) = x²""" """La fonction que nous voulons minimiser : f(x) = x²"""
    return x ** 2

def f_grad(x):
    """Gradient : f'(x) = 2x""" """Gradient : f'(x) = 2x"""
    return 2 * x

# Optimisation SGD # Optimisation SGD
x = 10.0  # Valeur initiale # Valeur initiale
learning_rate = 0.1  # Taux d'apprentissage # Taux d'apprentissage
steps = 20

print(f"x initial = {x}, f(x) = {f(x)}" "x initial = {x}, f(x) = {f(x)}")
print("-" * 40)

for step in range(steps):
    grad = f_grad(x)
    x = x - learning_rate * grad  # Mise à jour SGD # Mise à jour SGD
    print(f"Étape {step+1} : x = {x:.6f}, f(x) = {f(x):.6f}")

print("-" * 40)
print(f"x final = {x:.6f}, f(x) = {f(x):.6f}" "x final = {x:.6f}, f(x) = {f(x):.6f}")
print("Optimum théorique:x = 0, f(x) = 0" "Optimum théorique: x = 0, f(x) = 0")

SGD simple mais présente des inconvénients : SGD est simple mais présente des inconvénients :

  • Utilise le même taux d'apprentissage pour tous les paramètres
  • La convergence peut être lente
  • Peut facilement rester bloqué dans des optima locaux ou des points de selle.
  • Sensible au bruit

Momentum : accélération avec Momentum

Momentum introduit déjà le concept de « vitesse » — Laissez la mise à jour du gradient avoir de l’inertie. Momentum introduit le concept de « vélocité » — donnant de l’inertie aux mises à jour du gradient.

Formule : Formule :

v = β·v + (1-β)·∇L(θ)
θ = θ - η·v

β est généralement défini à 0.9. β est généralement défini à 0.9.

Exemple

# ============================================
# Optimiseur Momentum # Optimiseur Momentum
# ============================================

import numpy as np

def f(x):
    """Fonction objectif""" """Fonction objectif"""
    return x ** 2

def f_grad(x):
    """Gradient""" """Gradient"""
    return 2 * x

def sgd_optimize(x_init, learning_rate, steps):
    """SGD pur""" """SGD pur"""
    x = x_init
    history = [x]
    for _ in range(steps):
        grad = f_grad(x)
        x = x - learning_rate * grad
        history.append(x)
    return np.array(history)

def momentum_optimize(x_init, learning_rate, beta, steps):
    """Momentum"""
    x = x_init
    v = 0.0  # Vitesse initiale # Vitesse initiale
    history = [x]
    for _ in range(steps):
        grad = f_grad(x)
        v = beta * v + (1 - beta) * grad
        x = x - learning_rate * v
        history.append(x)
    return np.array(history)

# Comparaison # Comparaison
x_init = 10.0
learning_rate = 0.1
bêta = 0.9
steps = 20

sgd_history = sgd_optimize(x_init, learning_rate, steps)
momentum_history = momentum_optimize(x_init, learning_rate, beta, steps)

print("Étape | SGD | Momentum")
print("-" * 35)
for i in range(steps + 1):
    print(f"{i:4} | {sgd_history[i]:9.6f} | {momentum_history[i]:9.6f}")

print("\nObservation : Momentum converge plus vite !)
print(Parce qu'il accumule les gradients passés, ce qui lui donne de l'inertie.)

Adam : Taux d'apprentissage adaptatif

Adam (Adaptive Moment Estimation) est actuellement l'un des optimiseurs les plus couramment utilisés.

Il combine les idées de Momentum (premier moment) et RMSProp (deuxième moment) pour maintenir un taux d'apprentissage adaptatif pour chaque paramètre.

Formule :

m = β₁·m + (1-β₁)·∇L(θ)
v = β₂·v + (1-β₂)·(∇L(θ))²
m̂ = m / (1-β₁ᵗ)
v̂ = v / (1-β₂ᵗ)
θ = θ - η·m̂ / (√v̂ + ε)

Hyperparamètres par défaut : β₁=0.9, β₂=0.999, ε=1e-8, η=1e-3.

Exemple

# ============================================
# Optimiseur Adam
# ============================================

import numpy as np

def adam_optimize(x_init, learning_rate, beta1, beta2, epsilon, steps):
    """Optimisation Adam"""
    x = x_init
    m = 0.0  # Premier moment
    v = 0.0  # Deuxième moment
    history = [x]

    for t in range(1, steps + 1):
        grad = 2 * x  # Gradient de f(x) = x²
        # Mise à jour des premier et deuxième moments
        m = beta1 * m + (1 - beta1) * grad
        v = beta2 * v + (1 - beta2) * (grad ** 2)
        # Correction du biais
        m_hat = m / (1 - beta1 ** t)
        v_hat = v / (1 - beta2 ** t)
        # Mise à jour des paramètres
        x = x - learning_rate * m_hat / (np.sqrt(v_hat) + epsilon)
        history.append(x)

    return np.array(history)

# Paramètres
x_init = 10.0
learning_rate = 0.5
beta1 = 0.9
beta2 = 0.999
epsilon = 1e-8
steps = 20

# Optimisation
history = adam_optimize(x_init, learning_rate, beta1, beta2, epsilon, steps)

print("Processus d'optimisation Adam :")
print("Étape | x | f(x)")
print("-" * 35)
for i in range(steps + 1):
    print(f"{i:4} | {history[i]:9.6f} | {history[i]**2:9.6f}")

AdamW : Correction de la décroissance des poids

AdamW est une version améliorée d'Adam — il sépare la décroissance des poids du gradient.

Cela est utile pour la régularisation.

Comparaison des optimiseurs :

OptimiseurFormuleAvantagesInconvénientsScénarios applicables
SGDθ = θ - η·∇LSimple, stableConvergence lente, sensible au taux d'apprentissageGrands ensembles de données, riche expérience en réglage des hyperparamètres
SGD + Momentumv = βv + (1-β)∇L
θ = θ - ηv
Accélère la convergence, réduit les oscillationsNécessite de régler βGénéralement meilleur que le SGD simple
AdamTaux d'apprentissage adaptatifConvergence rapide, nécessite moins de réglage des hyperparamètresPeut généraliser moins bien que SGDLa plupart des scénarios (choix par défaut)
AdamWAdam + décroissance des poidsMeilleure régularisationNécessite de régler le coefficient de décroissance des poidsTransformers, grands modèles

Suggestion de choix d’optimiseur : essayez d’abord Adam, avec le taux d’apprentissage défini à 1e-3 (3e-4 est un choix plus sûr). Si les résultats ne sont pas satisfaisants, essayez de régler les hyperparamètres ou de passer à un autre optimiseur.


Techniques de régularisation

L’objectif de la régularisation est d’éviter le surapprentissage — en aidant le modèle à bien performer sur des données non vues.

Régularisation L1/L2

Les régularisations L1 et L2 sont les méthodes de régularisation les plus élémentaires.

Elles ajoutent une pénalité sur les paramètres à la fonction de perte :

L_total = L + λ·L_reg

Régularisation L1 (Lasso) : L_reg = |w|

Régularisation L2 (Ridge) : L_reg = w²

Exemple

# ============================================
# Régularisation L1/L2
# ============================================

import numpy as np

def l1_regularization(weights, lambda_l1):
    """Régularisation L1 : renvoie le terme de régularisation et le gradient"""
    reg = lambda_l1 * np.sum(np.abs(weights))
    grad = lambda_l1 * np.sign(weights)
    return reg, grad

def l2_regularization(weights, lambda_l2):
    """Régularisation L2 : renvoie le terme de régularisation et le gradient"""
    reg = 0.5 * lambda_l2 * np.sum(weights ** 2)
    grad = lambda_l2 * weights
    return reg, grad

# Exemple
weights = np.array([1.0, -2.0, 3.0, 0.5])
print(f"Poids : {weights}")

lambda_l1 = 0.1
lambda_l2 = 0.1

l1_reg, l1_grad = l1_regularization(weights, lambda_l1)
print(f"\nTerme de régularisation L1 : {l1_reg:.4f}")
print(f"Gradient L1 : {l1_grad}")

l2_reg, l2_grad = l2_regularization(weights, lambda_l2)
print(f"\nTerme de régularisation L2 : {l2_reg:.4f}")
print(f"Gradient L2 : {l2_grad}")

print("\nL1 vs L2:")
print("- L1 : tend à produire des solutions parcimonieuses (de nombreux paramètres deviennent 0), peut être utilisé pour la sélection de caractéristiques")
print("- L2 : tend à rendre tous les paramètres très petits, mais pas nuls")
print("- En apprentissage profond, L2 est plus couramment utilisé (ou la décroissance des poids via AdamW)")

Dropout

Le Dropout est une technique de régularisation simple mais efficace : désactiver aléatoirement une partie des neurones pendant l'entraînement.

Cela force le modèle à apprendre des caractéristiques plus robustes — il ne peut pas dépendre d'un neurone spécifique.

Exemple

# ============================================
# Dropout
# ============================================

import numpy as np

def dropout_forward(x, dropout_rate, training=True):
    """Passe avant du Dropout"""
    if not training:
        # Pas de dropout pendant le test, retourner directement
        return x

    # Générer un masque : définir aléatoirement une partie des neurones à 0
    mask = (np.random.rand(*x.shape) > dropout_rate).astype(float)
    # Mise à l'échelle : aucune mise à l'échelle nécessaire au moment du test, donc diviser par (1 - dropout_rate) pendant l'entraînement
    scale = 1.0 / (1.0 - dropout_rate)
    # Appliquer le dropout
    out = x * mask * scale

    return out, mask

# Test
x = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
dropout_rate = 0.4

print(f"Entrée x : {x}")
print(f"Taux de dropout : {dropout_rate}")

# Exécuter plusieurs fois pour observer le caractère aléatoire
print("\nRésultats multiples du dropout :")
for i in range(3):
    out, mask = dropout_forward(x, dropout_rate, training=True)
    print(f" Tour {i+1}: mask={mask}, out={out}")

# Mode test
out_test = dropout_forward(x, dropout_rate, training=False)
print(f"\n"Mode test (sans Dropout): {out_test}")

Augmentation de données

L'augmentation des données est l'une des méthodes de régularisation les plus efficaces—elle crée davantage d'échantillons d'entraînement en transformant les données existantes.

Pour les images, les techniques courantes d'augmentation des données incluent : retournement, rotation, mise à l'échelle, recadrage, variation de couleur, etc.

Pour le texte, les techniques courantes d'augmentation des données incluent : remplacement de synonymes, insertion aléatoire, suppression aléatoire, rétro-traduction, etc.

Résumé des techniques de régularisation :

MéthodePrincipeAvantagesInconvénients
Régularisation L2Pénalise les poids élevésSimple et stableEffet limité
DropoutAbandonne aléatoirement des neuronesSimple et efficaceRalentit l'entraînement
Augmentation de donnéesAugmente la diversité des données d'entraînementEffet significatifNécessite des connaissances du domaine
Arrêt précoceArrêter lorsque l'ensemble de validation cesse de s'améliorerSimple et efficaceNécessite de surveiller l'ensemble de validation
Normalisation par lotsNormaliser les entrées des couchesAccélère l'entraînement, régulariseAjoute une surcharge de calcul

Normalisation par lots vs Normalisation par couches

Les techniques de normalisation peuvent accélérer l'entraînement et rendre l'optimisation plus stable.

Décalage de covariables interne

Lors de l'entraînement de réseaux profonds, la distribution des entrées de chaque couche change à mesure que les paramètres de la couche précédente changent. C'est le « décalage de covariables interne » (Internal Covariate Shift).

Cela ralentit l'entraînement car chaque couche doit constamment s'adapter à de nouvelles distributions.

L'objectif des techniques de normalisation est de maintenir stable la distribution des entrées de chaque couche.

Normalisation par lots

La normalisation par lots (BatchNorm) normalise le long de la dimension de lot.

Formule :

μ = 1/N · sum(xᵢ)
σ² = 1/N · sum((xᵢ - μ)²)
x̂ᵢ = (xᵢ - μ) / √(σ² + ε)
yᵢ = γ·x̂ᵢ + β

où γ et β sont des paramètres apprenables.

Exemple

# ============================================
# Normalisation par lots
# ============================================

import numpy as np

def batch_norm(x, gamma, beta, epsilon=1e-5, training=True, running_mean=None, running_var=None, momentum=0.1):
    """Normalisation par lots
x : entrée, forme (batch_size, features)
gamma : paramètre de mise à l'échelle
beta : paramètre de décalage
    """

    if training:
        # Mode d'entraînement : utiliser les statistiques du lot courant
        batch_mean = np.mean(x, axis=0)
        batch_var = np.var(x, axis=0)

        # Mettre à jour les statistiques glissantes (pour utilisation au moment du test)
        if running_mean is not None and running_var is not None:
            running_mean[:] = momentum * running_mean + (1 - momentum) * batch_mean
            running_var[:] = momentum * running_var + (1 - momentum) * batch_var

        # Normaliser
        x_normalized = (x - batch_mean) / np.sqrt(batch_var + epsilon)
    else:
        # Mode test : utiliser les statistiques courantes
        x_normalized = (x - running_mean) / np.sqrt(running_var + epsilon)

    # Mise à l'échelle et décalage
    out = gamma * x_normalized + beta
    return out

# Test
batch_size = 4
features = 3

# Un lot de données
x = np.array([
    [1.0, 2.0, 3.0],
    [2.0, 3.0, 4.0],
    [3.0, 4.0, 5.0],
    [4.0, 5.0, 6.0],
])
print(f"Entrée x :\n{x}")

# Paramètres initiaux
gamma = np.ones(features)  # Initialement aucune mise à l'échelle
beta = np.zeros(features)  # Initialement aucun décalage
print(f"\ngamma: {gamma}")
print(f"beta: {beta}")

# Appliquer la normalisation par lots
out = batch_norm(x, gamma, beta, training=True)
print(f"\nAprès la normalisation par lots :\n{out}")

# Vérifier : la moyenne de chaque caractéristique doit être proche de 0, la variance proche de 1
print(f"\nMoyenne normalisée : {np.mean(out, axis=0)}")
print(f"Variance normalisée : {np.var(out, axis=0)}")

Avantages de la normalisation par lots :

  • Accélère l'entraînement
  • Permet des taux d'apprentissage plus élevés
  • Réduit la sensibilité à l'initialisation
  • A un léger effet de régularisation

Inconvénients de la normalisation par lots :

  • Dépend de la taille du lot—fonctionne mal avec des lots trop petits
  • Le comportement diffère entre l'entraînement et le test
  • Ne convient pas aux modèles de séquence (par exemple, RNN, Transformer)

Normalisation par couche

La normalisation par couche (LayerNorm) normalise selon la dimension des caractéristiques au lieu de la dimension du lot.

Cela la rend indépendante de la taille du lot et très adaptée aux modèles de séquence.

Exemple

# ============================================
# Normalisation par couche
# ============================================

import numpy as np

def layer_norm(x, gamma, beta, epsilon=1e-5):
    """Normalisation par couche
x : entrée, forme (batch_size, features) ou (batch_size, seq_len, features)
    """

    # Calculer la moyenne et la variance sur la dernière dimension (dimension des caractéristiques)
    mean = np.mean(x, axis=-1, keepdims=True)
    var = np.var(x, axis=-1, keepdims=True)

    # Normaliser
    x_normalized = (x - mean) / np.sqrt(var + epsilon)

    # Mise à l'échelle et décalage
    out = gamma * x_normalized + beta
    return out

# Test
batch_size = 2
seq_len = 3
features = 4

# Simuler l'entrée dans un Transformer : (batch_size, seq_len, features)
x = np.array([
    [[1.0, 2.0, 3.0, 4.0],
     [2.0, 3.0, 4.0, 5.0],
     [3.0, 4.0, 5.0, 6.0]],
    [[4.0, 5.0, 6.0, 7.0],
     [5.0, 6.0, 7.0, 8.0],
     [6.0, 7.0, 8.0, 9.0]],
])
print(f"Forme de l'entrée x : {x.shape}")

# Initialiser les paramètres
gamma = np.ones(features)
beta = np.zeros(features)

# Appliquer la normalisation de couche
out = layer_norm(x, gamma, beta)
print(f"Forme après la normalisation de couche : {out.shape}")

# Vérifier : la moyenne à chaque position est proche de 0, la variance proche de 1
mean_check = np.mean(out, axis=-1)
var_check = np.var(out, axis=-1)
print(f"\nMoyenne à chaque position :\n{mean_check}")
print(f"Variance à chaque position :\n{var_check}")

Comparaison des deux méthodes de normalisation :

MéthodeDimension de normalisationDépend du batchScénarios applicablesModèles représentatifs
BatchNormdimension du batchOuiCNN, taille de batch fixeResNet、VGG
LayerNormdimension des caractéristiquesnonTransformer, RNN, séquences de longueur variableGPT, BERT, LLaMA

Pour les Transformers et les grands modèles de langage, LayerNorm est le choix standard. Il calcule des statistiques indépendamment à chaque position, ne dépend pas de la taille du lot et n'a pas besoin de maintenir des statistiques glissantes.


Planification du taux d'apprentissage

Le taux d'apprentissage est l'un des hyperparamètres les plus importants — trop grand, il ne convergera pas ; trop petit, la convergence est trop lente.

La planification du taux d'apprentissage consiste à ajuster dynamiquement le taux d'apprentissage pendant l'entraînement.

Préchauffage

Au début de l'entraînement, utilisez un faible taux d'apprentissage pour « warm up » et laissez le modèle se stabiliser, puis augmentez jusqu'au taux d'apprentissage cible.

Cela est particulièrement important pour le Transformer.

Recuit cosinus

Le recuit cosinus diminue progressivement le taux d'apprentissage en suivant la forme de la fonction cosinus.

Exemple

# ============================================
# Planification du taux d'apprentissage
# ============================================

import numpy as np

def warmup_schedule(step, warmup_steps, base_lr):
    """Programme de préchauffage linéaire"""
    if step < warmup_steps:
        return base_lr * (step + 1) / warmup_steps
    return base_lr

def cosine_annealing_schedule(step, total_steps, base_lr, min_lr=0.0):
    """Planification de recuit cosinus"""
    return min_lr + 0.5 * (base_lr - min_lr) * (1 + np.cos(np.pi * step / total_steps))

def warmup_cosine_schedule(step, warmup_steps, total_steps, base_lr, min_lr=0.0):
    """Préchauffage + recuit cosinus"""
    if step < warmup_steps:
        return base_lr * (step + 1) / warmup_steps
    return min_lr + 0.5 * (base_lr - min_lr) * (1 + np.cos(np.pi * (step - warmup_steps) / (total_steps - warmup_steps)))

# Paramètres
total_steps = 100
warmup_steps = 10
base_lr = 1e-3
min_lr = 1e-5

print("Différentes planifications du taux d'apprentissage :")
print("Étape | Préchauffage | Cosinus | Préchauffage+Cosinus")
print("-" * 55)

for step in range(0, total_steps + 1, 10):
    lr_warmup = warmup_schedule(step, warmup_steps, base_lr)
    lr_cosine = cosine_annealing_schedule(step, total_steps, base_lr, min_lr)
    lr_combined = warmup_cosine_schedule(step, warmup_steps, total_steps, base_lr, min_lr)
    print(f"{step:4} | {lr_warmup:.6f} | {lr_cosine:.6f} | {lr_combined:.6f}")

L'impact du taux d'apprentissage sur l'entraînement

L'impact du taux d'apprentissage :

  • Trop grand : entraînement instable, peut diverger
  • Trop petit : convergence lente, peut rester bloqué dans des optima locaux
  • Approprié : convergence rapide et stable

Une stratégie courante est le « learning rate finder » : entraîner d'abord quelques étapes avec des taux d'apprentissage augmentant de petits à grands, et regarder à quel taux d'apprentissage la perte diminue le plus rapidement.

Résumé des méthodes de planification du taux d'apprentissage :

Méthode de planificationCaractéristiquesScénarios applicables
Taux d'apprentissage fixeLe plus simplePetits modèles, tâches simples
Décroissance par paliersDiminution toutes les quelques étapesCNN, etc.
Recuit cosinusDiminution progressiveLa plupart des scénarios
Warmup + CosinusAugmenter d'abord, puis diminuerTransformer, grands modèles (recommandé)
Réduire sur plateauDiminuer lorsque l'ensemble de validation ne s'améliore pasNécessite de surveiller l'ensemble de validation

Travaux pratiques : implémenter un MLP à partir de zéro avec PyTorch

Maintenant, intégrons toutes les notions précédentes, utilisons PyTorch pour implémenter un perceptron multicouche (MLP) complet, et entraînons-le sur une tâche de classification simple.

Exemple

# ============================================
# Pipeline complet d'entraînement MLP implémenté dans PyTorch
# ============================================

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np

# ============================================
# 1. Préparer les données
# ============================================

class SimpleDataset(Dataset):
    """Un jeu de données simple de classification binaire"""

    def __init__(self, n_samples=1000, n_features=10):
        # Générer des données synthétiques
        np.random.seed(42)
        self.X = np.random.randn(n_samples, n_features).astype(np.float32)
        # Règle de classification simple : y = 1 si sum(x[:5]) > 0 sinon 0
        self.y = (np.sum(self.X[:, :5], axis=1) > 0).astype(np.int64)

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return torch.tensor(self.X[idx]), torch.tensor(self.y[idx])

# Créer un jeu de données et un chargeur de données
train_dataset = SimpleDataset(n_samples=800)
val_dataset = SimpleDataset(n_samples=200)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

print(f"Taille de l'ensemble d'entraînement : {len(train_dataset)}")
print(f"Taille de l'ensemble de validation : {len(val_dataset)}")

# ============================================
# 2. Définir le modèle
# ============================================

class MLP(nn.Module):
    """Perceptron multicouche"""

    def __init__(self, input_dim, hidden_dims, output_dim, dropout_rate=0.1):
        super().__init__()

        layers = []
        prev_dim = input_dim

        # Couche cachée
        for hidden_dim in hidden_dims:
            layers.append(nn.Linear(prev_dim, hidden_dim))
            layers.append(nn.ReLU())
            layers.append(nn.LayerNorm(hidden_dim))  # Normalisation de couche
            layers.append(nn.Dropout(dropout_rate))  # Dropout
            prev_dim = hidden_dim

        # Couche de sortie
        layers.append(nn.Linear(prev_dim, output_dim))

        self.model = nn.Sequential(*layers)

    def forward(self, x):
        return self.model(x)

# Créer le modèle
model = MLP(
    input_dim=10,
    hidden_dims=[64, 32],
    output_dim=2,
    dropout_rate=0.1
)
print("\nStructure du modèle :")
print(model)

# ============================================
# 3. Définir la fonction de perte et l'optimiseur
# ============================================

criterion = nn.CrossEntropyLoss()  # Perte d'entropie croisée
optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)  # Optimiseur AdamW

# Planificateur de taux d'apprentissage : préchauffage + recuit cosinusoïdal
total_epochs = 20
warmup_epochs = 2
total_steps = len(train_loader) * total_epochs
warmup_steps = len(train_loader) * warmup_epochs

def lr_lambda(step):
    if step < warmup_steps:
        return (step + 1) / warmup_steps
    else:
        progress = (step - warmup_steps) / (total_steps - warmup_steps)
        return 0.5 * (1 + np.cos(np.pi * progress))

scheduler = optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda)

print("\nConfiguration d'entraînement :")
print(f" Époques : {total_epochs}")
print(f" Époques de préchauffage : {warmup_epochs}")
print(f" Nombre total d'étapes : {total_steps}")
print(f" Étapes de préchauffage : {warmup_steps}")

# ============================================
# 4. Boucle d'entraînement
# ============================================

print("\nDébut de l'entraînement...")
print("-" * 50)

global_step = 0
best_val_acc = 0.0

for epoch in range(total_epochs):
    # Phase d'entraînement
    model.train()
    train_loss = 0.0
    train_correct = 0
    train_total = 0

    for batch_X, batch_y in train_loader:
        # Passe avant
        logits = model(batch_X)
        loss = criterion(logits, batch_y)

        # Rétropropagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        scheduler.step()

        # Statistiques
        train_loss += loss.item()
        predicted = torch.argmax(logits, dim=1)
        train_total += batch_y.size(0)
        train_correct += (predicted == batch_y).sum().item()

        global_step += 1

    train_loss /= len(train_loader)
    train_acc = train_correct / train_total

    # Phase de validation
    model.eval()
    val_loss = 0.0
    val_correct = 0
    val_total = 0

    with torch.no_grad():
        for batch_X, batch_y in val_loader:
            logits = model(batch_X)
            loss = criterion(logits, batch_y)

            val_loss += loss.item()
            predicted = torch.argmax(logits, dim=1)
            val_total += batch_y.size(0)
            val_correct += (predicted == batch_y).sum().item()

    val_loss /= len(val_loader)
    val_acc = val_correct / val_total

    # Enregistrer le meilleur modèle
    if val_acc > best_val_acc:
        best_val_acc = val_acc
        # Vous pouvez sauvegarder le point de contrôle du modèle ici

    # Afficher le journal
    current_lr = optimizer.param_groups[0]['lr']
    print(f"Époque {epoch+1:2d} | lr: {current_lr:.6f} | "
          f"Perte d'entraînement: {train_loss:.4f} | Exactitude d'entraînement: {train_acc:.4f} | "
          f"Perte de validation: {val_loss:.4f} | Exactitude de validation: {val_acc:.4f}")

print("-" * 50)
print(f"Entraînement terminé! Meilleure exactitude de validation: {best_val_acc:.4f}")

# ============================================
# 5. Exemple d'inférence
# ============================================

print("\nExemple d'inférence:")
model.eval()

# Quelques échantillons de test
test_samples = [
    np.array([1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=np.float32),  # Devrait être 1
    np.array([-1.0, -1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=np.float32),  # Devrait être 0
]

for i, sample in enumerate(test_samples):
    with torch.no_grad():
        input_tensor = torch.tensor(sample).unsqueeze(0)
        logits = model(input_tensor)
        probs = torch.softmax(logits, dim=1)
        predicted_class = torch.argmax(probs, dim=1).item()

    print(f" Échantillon {i+1}: {sample[:5]}...")
    print(f" Classe prédite: {predicted_class}")
    print(f" Probabilités: classe 0={probs[0,0]:.4f}, classe 1={probs[0,1]:.4f}")

Cet exemple contient toutes les composantes standard de l'entraînement en apprentissage profond:

  • Traitement des données: Dataset, DataLoader
  • Définition du modèle: MLP avec LayerNorm et Dropout
  • Fonction de perte : CrossEntropyLoss
  • Optimiseur : AdamW
  • Planificateur du taux d'apprentissage : Warmup + Cosine
  • Boucle d'entraînement : phase d'entraînement + phase de validation
  • Sauvegarde du modèle et inférence

Ce flux de travail peut être directement étendu à des tâches et des modèles plus complexes.

Autres extensions