Online Learning : Guide Complet — Apprentissage en Flux Continu

Résumé

L’apprentissage en ligne, ou Online Learning, désigne une famille d’algorithmes de machine learning capables de mettre à jour leurs paramètres à chaque nouvelle arrivée de donnée, sans jamais nécessiter de ré-entraînement complet sur l’historique. Contrairement aux méthodes classiques qui exigent un dataset statique et une phase d’entraînement centralisée, l’algorithme d’Online Learning incorpore chaque observation au fur et à mesure, ce qui le rend idéal pour les flux de données en temps réel, la détection d’anomalies, et les environnements où la distribution des données évolue avec le temps (concept drift). Dans ce guide complet, nous explorerons le principe mathématique du Perceptron mis à jour en ligne, l’algorithme Passive-Aggressive, le concept de regret bound, et l’approche FTRL (Follow-the-Regularized-Leader). Nous verrons également comment implémenter ces algorithmes en Python avec scikit-learn, étudierons les hyperparamètres clés, et examinerons quatre cas d’usage concrets.

Principe Mathématique de l’Online Learning

Le Perceptron en ligne

Le point de départ de l’apprentissage en ligne est le Perceptron en ligne. À chaque étape t, le modèle reçoit un exemple (x_t, y_t) où x_t est le vecteur de caractéristiques et y_t ∈ {-1, +1} est l’étiquette réelle. Le modèle effectue d’abord une prédiction :

ŷ_t = signe(w_t · x_t)

Puis, il vérifie si la prédiction est correcte. Si y_t · (w_t · x_t) ≤ 0 (c’est-à-dire si l’exemple est mal classifié), le modèle met à jour ses poids :

w_{t+1} = w_t + y_t · x_t

Dans le cas contraire (y_t · (w_t · x_t) > 0), aucune mise à jour n’est effectuée : w_{t+1} = w_t. C’est le comportement Passive : si tout fonctionne correctement, le modèle ne change rien. Il préserve les connaissances acquises et ne gaspille pas de ressources computationnelles.

L’algorithme Passive-Aggressive

L’algorithme Passive-Aggressive (PA), introduit par Crammer et al. en 2006, généralise ce principe. Il introduit une marge de tolérance et adapte l’intensité de la mise à jour en fonction de l’erreur. Le principe est le suivant : w_{t+1} = w_t + τ · y_t · x_t où :

• τ = loss_t / ||x_t||²
• loss_t = max(0, 1 – y_t · (w_t · x_t))

La loss loss_t mesure à quel point la prédiction actuelle respecte la marge désirée. Si l’exemple est correctement classifié avec une marge suffisante (y_t · (w_t · x_t) ≥ 1), la loss est nulle et τ = 0 : le modèle reste Passive. En revanche, si l’exemple viole la marge, le modèle devient Aggressif : il modifie ses poids proportionnellement à l’erreur commise, avec un pas τ automatiquement ajusté selon la norme du vecteur d’entrée.

Il existe trois variantes principales de l’algorithme Passive-Aggressive :

• PA-0 : la version de base décrite ci-dessus, sans borne sur le pas d’apprentissage.
• PA-I : introduit un paramètre de régularisation C qui borne le pas τ ≤ C, évitant les mises à jour trop brutales.
• PA-II : modifie l’objectif d’optimisation pour inclure un terme de régularisation L2 sur la mise à jour.

Le Regret Bound

Dans la théorie de l’apprentissage en ligne, la métrique centrale est le regret bound (borne de regret). Le regret mesure la différence entre le nombre total d’erreurs commises par l’algorithme en ligne sur T exemples, et le nombre d’erreurs du meilleur classifieur fixe possible sur les mêmes données :

Régret(T) = Σ_{t=1}^{T} ℓ_t(w_t) – min_w Σ_{t=1}^{T} ℓ_t(w)

où ℓ_t(w) est la fonction de loss au temps t. Un bon algorithme d’apprentissage en ligne garantit que Régret(T) ≤ O(√T), ce qui signifie que le regret moyen par exemple converge vers zéro à mesure que T augmente. Autrement dit, sur le long terme, l’algorithme en ligne performe aussi bien que le meilleur classifieur fixe en hindsight (après coup).

Pour le Perceptron en ligne, la borne classique est :

(Nombre d’erreurs) ≤ (R² · ||w*||²) / γ²

où R est le rayon maximal des données, w est le séparateur optimal, et γ est la marge géométrique. Cette borne ne dépend pas du nombre total d’exemples T*, ce qui est remarquable.

FTRL (Follow-the-Regularized-Leader)

Pour les problèmes à très grande échelle (milliards de caractéristiques, comme dans la publicité en ligne ou le filtrage de texte), l’algorithme de référence est FTRL (Follow-the-Regularized-Leader). Au lieu de mettre à jour le modèle à chaque étape de manière isolée, FTRL choisit à chaque itération le poids qui minimise la somme des losses passées plus un terme de régularisation :

w_{t+1} = argmin_w [ Σ_{s=1}^{t} ℓ_s(w) + R(w) ]

où R(w) est un terme de régularisation, souvent une combinaison de normes L1 et L2. La régularisation L1 encourage la parcimonie (beaucoup de poids exactement nuls), ce qui est crucial lorsque le nombre de caractéristiques est colossal. FTRL est utilisé en production par Google pour le Click-Through Rate (CTR) prediction sur des modèles comptant des centaines de milliards de paramètres.

Intuition : Le Médecin qui Affine son Diagnostic

L’apprentissage en ligne, c’est comme un médecin qui affine son diagnostic avec chaque nouveau patient.

Imaginez un jeune médecin qui sort de la faculté. Son premier réflexe serait de consulter l’intégralité de ses manuels entre chaque consultation pour recalibrer toutes ses connaissances — ce serait évidemment impossible en pratique. Au lieu de cela, le médecin ajuste sa compréhension au fur et à mesure. Il accumule de l’expérience clinique à chaque rencontre.

• Mode Passive : quand un patient arrive avec un rhume classique, les symptômes correspondent exactement à ce que le médecin connaisait déjà. Il n’a pas besoin de changer quoi que ce soit dans son modèle mental. Son diagnostic est bon, sa prescription est adaptée, il continue. C’est le comportement Passive-Aggressive dans sa phase Passive : si l’erreur est nulle (la prédiction est correcte), le poids ne bouge pas.
• Mode Aggressive : quand un patient le surprend — un symptôme inhabituel, une réaction inattendue à un traitement — le médecin corrige son modèle mental. Il se dit : « Ah, je n’avais pas considéré cette possibilité jusqu’à présent. » La correction est proportionnelle à la surprise : plus le cas est étonnant, plus la mise à jour est importante. C’est exactement le mécanisme de τ = loss / ||x||² dans l’algorithme Passive-Aggressive.

Là où le batch learning consisterait à réétudier tous les manuels de médecine après chaque nouveau patient (extrêmement coûteux et inutile), l’Online Learning permet au médecin de grandir continuellement tout en restant opérationnel. C’est l’apprentissage tel qu’il se produit naturellement chez les êtres vivants : progressif, incrémental, et adaptatif.

Implémentation Python avec scikit-learn

SGDClassifier avec partial_fit sur un flux de données simulé

La bibliothèque scikit-learn offre une implémentation pratique de l’apprentissage en ligne via SGDClassifier. La méthode partial_fit() permet de mettre à jour le modèle par mini-lots, ce qui simule un véritable flux de données.

Comparaison Batch vs Online : exemple de code

Comparons les performances d’un classifieur batch (entraînement sur toutes les données d’un coup) avec celles d’un classifieur en ligne (mise à jour incrémentale). Le code suivant illustre cette comparaison sur un jeu de données synthétique.

import numpy as np
from sklearn.linear_model import SGDClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt

# 1. Générer un jeu de données synthétique
X, y = make_classification(
    n_samples=10000, n_features=20,
    n_informative=10, n_redundant=5,
    random_state=42, flip_y=0.05
)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 2. Approche BATCH : entraînement classique
batch_clf = SGDClassifier(
    loss='hinge', penalty='l2', alpha=0.0001,
    random_state=42, max_iter=1000, tol=1e-3
)
batch_clf.fit(X_train, y_train)
batch_accuracy = accuracy_score(y_test, batch_clf.predict(X_test))
print(f"Batch Accuracy : {batch_accuracy:.4f}")

# 3. Approche ONLINE : partial_fit par mini-lots
online_clf = SGDClassifier(
    loss='hinge', penalty='l2', alpha=0.0001,
    random_state=42
)
classes = np.unique(y_train)
chunk_size = 100
online_accuracies = []

for start in range(0, len(X_train), chunk_size):
    end = start + chunk_size
    X_chunk = X_train[start:end]
    y_chunk = y_train[start:end]
    online_clf.partial_fit(X_chunk, y_chunk, classes=classes)
    acc = accuracy_score(y_test, online_clf.predict(X_test))
    online_accuracies.append(acc)

final_online_accuracy = online_accuracies[-1]
print(f"Online Accuracy : {final_online_accuracy:.4f}")

# 4. Visualisation de la convergence
plt.figure(figsize=(10, 6))
plt.plot(range(len(online_accuracies)), online_accuracies,
         label='Online Learning (partial_fit)', color='blue', linewidth=2)
plt.axhline(y=batch_accuracy, color='red', linestyle='--',
            label=f'Batch Learning ({batch_accuracy:.3f})')
plt.xlabel('Nombre de mini-lots traités')
plt.ylabel('Précision sur le jeu de test')
plt.title('Convergence : Online Learning vs Batch Learning')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

Le graphique de convergence montre généralement que l’Online Learning rattrape progressivement les performances du batch learning. Après avoir vu suffisamment d’exemples, les deux approches atteignent des niveaux de précision comparables. L’avantage décisif de l’approche en ligne : elle fonctionne sans jamais charger l’ensemble du jeu de données en mémoire.

Détection de Concept Drift avec ADWIN

Le concept drift désigne un changement dans la distribution sous-jacente des données au fil du temps. L’algorithme ADWIN (Adaptive Windowing) détecte automatiquement ces changements en surveillant la moyenne d’une fenêtre glissante.

import numpy as np
from collections import deque

class ADWINDetector:
    """Implémentation simplifiée du détecteur ADWIN pour la détection de drift
    dans un flux de données en Online Learning."""

    def __init__(self, delta=0.002, min_window=10):
        self.delta = delta
        self.min_window = min_window
        self.window = deque()
        self.drift_detected = False
        self.change_point = None

    def _hoeffding_bound(self, n):
        """Borne de Hoeffding pour la détection de changement."""
        return np.sqrt(np.log(2.0 / self.delta) / (2.0 * n))

    def add_element(self, value):
        """Ajoute un nouvel élément et vérifie si un drift est détecté."""
        self.window.append(value)

        if len(self.window) < 2 * self.min_window:
            return False

        # Tester différentes tailles de sous-fenêtres
        n = len(self.window)
        for cut in range(self.min_window, n - self.min_window):
            W0 = list(self.window)[:cut]
            W1 = list(self.window)[cut:]

            mu0 = np.mean(W0)
            mu1 = np.mean(W1)
            eps = self._hoeffding_bound(cut) + self._hoeffding_bound(n - cut)

            if abs(mu0 - mu1) > eps:
                # Drift détecté : on réduit la fenêtre
                self.window = deque(list(self.window)[cut:])
                self.drift_detected = True
                self.change_point = len(self.window)
                return True

        self.drift_detected = False
        return False

# Simulation de concept drift
np.random.seed(0)
detector = ADWINDetector(delta=0.01)
stream = []
drifts_notified = []

for t in range(500):
    if t < 250:
        # Distribution A : moyenne 0.3
        value = np.random.normal(loc=0.3, scale=0.1)
    else:
        # Distribution B : moyenne 0.7 (drift au point 250)
        value = np.random.normal(loc=0.7, scale=0.1)

    stream.append(value)
    if detector.add_element(value):
        drifts_notified.append(t)

print(f"Drift détecté au temps : {drifts_notified}")
print(f"Véritable point de drift : 250")

Lorsqu’un concept drift est détecté, l’algorithme d’Online Learning peut réinitialiser partiellement ses poids ou augmenter son taux d’apprentissage temporairement pour s’adapter plus rapidement à la nouvelle distribution.

Hyperparamètres Clés

Le réglage des hyperparamètres est crucial pour la performance de l’algorithme d’Online Learning. Voici les principaux :

learning_rate

Le taux d’apprentissage contrôle la taille de chaque mise à jour. Dans SGDClassifier, trois stratégies sont disponibles :

• constant : η(t) = eta0 (taux fixe, nécessite un bon choix manuel)
• optimal : η(t) = 1 / (alpha * (t + t_0)) (recommandé par défaut)
• invscaling : η(t) = eta0 / pow(t, power_t) (décroissance douce)

En général, un taux qui décroît avec le temps est préférable : au début, le modèle ne sait rien et doit apprendre vite ; progressivement, il affine ses connaissances avec des pas de plus en plus petits.

loss

La fonction de loss détermine l’objectif d’optimisation :

• hinge : loss du SVM linéaire (marge maximale). C’est la plus proche de l’algorithme Passive-Aggressive.
• log_loss : régression logistique avec probabilités calibrées.
• modified_huber : variante lisse de la hinge loss, tolérante aux outliers.
• squared_hinge : hinge loss au carré, pénalise davantage les violations de marge.

penalty

La régularisation empêche le surajustement et contrôle la complexité du modèle :

• l2 (Ridge) : pénalise les poids importants, favorise des poids petits mais non nuls.
• l1 (Lasso) : favorise la parcimonie, met certains poids exactement à zéro.
• elasticnet : combinaison pondérée de L1 et L2.

alpha

Le paramètre alpha contrôle la force de la régularisation. Une valeur trop faible conduit au surajustement (le modèle mémorise le bruit), tandis qu’une valeur trop forte empêche l’apprentissage (le modèle reste trop simple). Les valeurs typiques se situent entre 10⁻⁶ et 10⁻³.

Avantages et Limites de l’Online Learning

Avantages

1. Efficacité mémoire : le modèle ne stocke jamais l’historique complet des données. La mémoire utilisée est indépendante du nombre total d’observations, ce qui permet de traiter des flux de données infinis avec une empreinte mémoire constante.
2. Adaptabilité en temps réel : l’algorithme peut s’adapter immédiatement à des changements dans la distribution des données. Si les préférences des utilisateurs évoluent, si les patterns de fraude se transforment, le modèle suit sans ré-entraînement manuel.
3. Rapidité de prise en main : pour les applications où les premières prédictions sont cruciales, l’Online Learning commence à apprendre dès le premier exemple. Pas besoin d’attendre un dataset complet.
4. Évolutivité : dans les environnements distribués, chaque nœud peut traiter son propre flux de données et les modèles peuvent être agrégés périodiquement. C’est l’architecture derrière les systèmes de recommandation de Netflix et les moteurs de publicité de Google.
5. Compatibilité concept drift : avec des détecteurs comme ADWIN, l’Online Learning peut non seulement s’adapter au drift mais aussi alerter les opérateurs quand un changement structurel se produit.

Limites

1. Sensibilité au bruit : un outlier aberrant peut dégrader significativement le modèle si le pas d’apprentissage n’est pas correctement régularisé. Des mécanismes de robustesse (comme PA-I avec borne C) sont nécessaires.
2. Dépendance à l’ordre : contrairement au batch learning, les résultats peuvent varier selon l’ordre d’arrivée des exemples. Un tri non aléatoire du flux peut biaiser l’apprentissage.
3. Debugging difficile : sans accès à l’historique complet des données, diagnostiquer une régression de performance est plus complexe. La traçabilité des décisions requiert un logging minutieux.
4. Pas de convergence garantie sur données non séparables : si les données ne sont pas linéairement séparables (même approximativement), le Perceptron en ligne peut osciller indéfiniment sans converger vers un optimum stable.
5. Évaluation en continu : contrairement au batch learning où l’on dispose d’un jeu de validation fixe, évaluer les performances en ligne nécessite des protocoles spécifiques comme le prequential evaluation (prédire puis apprendre, en boucle).

Quatre Cas d’Usage Concrets

1. Détection de fraude bancaire en temps réel

Les transactions frauduleuses évoluent constamment : les fraudeurs adaptent leurs techniques dès qu’un pattern de détection est identifié. Un classifieur d’Online Learning (typiquement Passive-Aggressive ou FTRL) analyse chaque transaction au moment où elle se produit. Si une transaction inhabituelle est identifiée, le modèle incorpore immédiatement cette information. Lorsqu’un nouveau schéma de fraude apparaît, le modèle s’adapte en quelques minutes plutôt qu’en quelques semaines (comme avec un réentraînement batch nocturne). Les banques comme Capital One et Stripe utilisent ces approches pour protéger des milliards de transactions quotidiennes.

2. Filtrage de spam et classification de texte

Le spam évolue avec le temps : les spammeurs changent leurs mots-clés, leurs techniques d’obfuscation, leurs domaines d’envoi. Un classifieur d’Online Learning traite chaque email à son arrivée. Si un email initialement classifié comme légitime s’avère être du spam (signalé par l’utilisateur), le modèle met à jour ses poids immédiatement. La méthode partial_fit de scikit-learn est parfaitement adaptée à ce scénario : chaque lot de 100 ou 1000 emails constitue une mise à jour incrémentale du classifieur. Gmail utilise des techniques similaires à très grande échelle.

3. Systèmes de recommandation adaptatifs

Les préférences des utilisateurs changent : un utilisateur intéressé par les films d’action en janvier pourrait préférer des comédies romantiques en été. Un système de recommandation basé sur l’Online Learning actualise en continu le profil de chaque utilisateur à chaque interaction (clic, visionnage, achat, abandon). L’algorithme FTRL-PROX de Google, utilisé pour la prédiction de CTR (Click-Through Rate), traite des centaines de milliers de requêtes par seconde avec des modèles de plusieurs milliards de paramètres, en ne mettant à jour que les poids correspondant aux caractéristiques activées.

4. IoT et maintenance prédictive

Dans un environnement industriel connecté, des capteurs transmettent en continu des mesures de température, vibration, pression, etc. Un modèle d’Online Learning peut détecter en temps réel une dérivation progressive des signaux avant qu’une panne ne survienne. Si le comportement d’une machine change (usure, changement de matière première, variation ambiante), le modèle détecte le concept drift via ADWIN et s’adapte automatiquement. Cela évite les arrêts de production coûteux tout en maintenant une précision de prédiction élevée, sans intervention humaine ni ré-entraînement planifié.

Conclusion

L’Online Learning est une approche puissante et élégante d’apprentissage automatique qui permet aux modèles de grandir continuellement à partir de flux de données, sans ré-entraînement coûteux. Des fondations théoriques solides — le Perceptron en ligne, l’algorithme Passive-Aggressive, les regret bounds, et FTRL — garantissent que ces méthodes ne sont pas seulement des heuristiques pratiques, mais des algorithmes avec des garanties de convergence prouvées. L’implémentation avec SGDClassifier et partial_fit dans scikit-learn rend ces techniques accessibles à tout praticien. Que ce soit pour la détection de fraude, le filtrage de spam, les recommandations personnalisées ou la maintenance prédictive, l’Online Learning offre un cadre robuste pour construire des systèmes intelligents qui apprennent toute leur vie, exactement comme les êtres vivants.

Voir aussi

• Calculer le Totient d’un Carré en Cube avec Python : Guide Pratique et Astuces
• Créer des Ellipses Croisées en Python : Guide Complet pour la Visualisation et la Manipulation