Une Carte des Familles d'Algorithmes ML

Le machine learning va bien au-delà de la classification supervisée. Ce guide couvre chaque grande famille d'algorithmes — de l'apprentissage par renforcement au calcul évolutionnaire — avec les intuitions, les compromis et des indications pratiqués pour savoir quand chacune excelle.

Familles d'Algorithmes en un Coup d'Œil

---

Apprentissage Supervisé

La famille la plus déployée. Vous fournissez des données d'entraînement étiquetées ; le modèle apprend la correspondance.

Algorithmes de classification

Algorithmes de régression

La plupart des algorithmes de classification ont des variantes de régression : Régression Linéaire, Ridge/Lasso, Arbre de Décision Régresseur, Random Forest Régresseur, Gradient Boosting Régresseur, SVR, k-NN Régresseur.

Insight clé : quand utiliser quoi

                    Données tabulaires ?
                    /           \
                 Oui             Non
                  /                \
         < 100K lignes ?     Images/Texte/Audio ?
         /         \              |
       Oui         Non           Oui
       /             \            |
  Régression      XGBoost/     Deep Learning
  Logistique      LightGBM     (CNN, Transformer)
  Random Forest  (performance)
  (interprétable)

Le gradient boosting (XGBoost, LightGBM, CatBoost) domine les données tabulaires. Le deep learning gagné sur les données non structurées. N'utilisez pas de réseaux de neurones sur du tabulaire sans avoir d'abord essayé le boosting.

---

Apprentissage Non Supervisé

Pas d'étiquettes. L'objectif est de découvrir des structurés, des patterns ou des représentations compressées.

Clustering

Regrouper les points de données similaires.

from sklearn.cluster import HDBSCAN
import numpy as np

clusterer = HDBSCAN(min_cluster_size=15, min_samples=5)
labels = clusterer.fit_predict(X)
# labels == -1 signifie bruit/outlier

Réduction de Dimensionnalité

Compresser des données haute dimension en préservant la structuré.

Détection d'Anomalies

Trouver les points de données qui ne correspondent pas au pattern normal.

---

Apprentissage Auto-Supervisé

Le modèle crée ses propres étiquettes à partir des données brutes — aucune annotation manuelle nécessaire. C'est ainsi que les modèles de fondation modernes (LLMs, vision transformers) sont pré-entraînés.

Techniques

Pourquoi c'est important

Pré-entraînement auto-supervisé sur des données massives non étiquetées → fine-tuning sur un petit dataset étiqueté. C'est le paradigme dominant de l'IA moderne : pré-entraîner une fois, fine-tuner pour de nombreuses tâches.

---

Apprentissage par Renforcement (RL)

Un agent apprend en interagissant avec un environnement, en recevant des récompenses et en ajustant sa politique pour maximiser la récompense cumulative.

Concepts fondamentaux

        ┌───────────────┐
        │  Environnement│
        └───┬───────┬───┘
   état s   │       │  récompense r
            ▼       │
        ┌───────────┴───┐
        │     Agent     │
        │   π(a|s)      │──── action a ────►
        └───────────────┘

Familles d'algorithmes

Méthodes basées sur la valeur

Apprennent Q(s,a) et choisissent l'action avec le Q le plus élevé.

Méthodes basées sur la politique

Apprennent la politique π(a|s) directement.

Méthodes basées sur un modèle

Apprennent un modèle de l'environnement et planifient dedans.

Applications du RL

Démarrer avec le RL

import gymnasium as gym

# Problème de contrôle classique
env = gym.make("CartPole-v1")
obs, info = env.reset()

for _ in range(1000):
    action = env.action_space.sample()  # politique aléatoire
    obs, reward, terminated, truncated, info = env.step(action)
    if terminated or truncated:
        obs, info = env.reset()

Bibliothèques clés : Gymnasium (environnements), Stable-Baselines3 (algorithmes), CleanRL (implémentations mono-fichier), RLlib (RL distribué scalable), TorchRL (natif PyTorch).

---

Algorithmes Évolutionnaires & Génétiques

Inspirés de l'évolution biologique : population → évaluation du fitness → sélection → croisement → mutation → répéter.

Concepts fondamentaux

Génération 0 :  [A] [B] [C] [D] [E]     ← population aléatoire
                 ↓ évaluer le fitness
Fitness :        7   3   9   5   8
                 ↓ sélection (les plus aptes survivent)
Parents :       [A] [C] [E]
                 ↓ croisement + mutation
Génération 1 :  [AC'] [CE'] [CA'] [EA'] [EC']
                 ↓ répéter...

Variantes d'algorithmes

Quand l'évolutionnaire bat la descente de gradient

• Objectifs non différentiables — structurés discrètes, problèmes combinatoires
• Paysages multimodaux — nombreux optima locaux où les méthodes de gradient se bloquent
• Recherche d'architecture — faire évoluer les structurés de réseaux de neurones (NAS)
• IA de jeux — faire évoluer des stratégies pour les PNJ
• Ordonnancement/routage — job shop, tournées de véhicules, emplois du temps
• Conception matérielle — optimisation de circuits, conception d'antennes

Exemple pratiqué : CMA-ES

import cma

# Minimiser une fonction avec CMA-ES
def objective(x):
    return sum((xi - 3)**2 for xi in x)  # minimum en [3, 3, 3, ...]

es = cma.CMAÉvolutionStrategy([0] * 10, 0.5)  # 10 dim, sigma initial=0.5
es.optimize(objective)
print(es.result.xbest)  # → proche de [3, 3, 3, ...]

Bibliothèques clés

---

Méthodes Probabilistes & Bayésiennes

Modélisent l'incertitude explicitement en utilisant des distributions de probabilité.

Approches principales

Optimisation Bayésienne pour les hyperparamètres

from skopt import gp_minimize

def train_and_evaluate(params):
    learning_rate, n_estimators = params
    # Entraîner le modèle, retourner l'erreur de validation
    model = XGBClassifier(learning_rate=learning_rate,
                          n_estimators=int(n_estimators))
    model.fit(X_train, y_train)
    return -accuracy_score(y_val, model.predict(X_val))

result = gp_minimize(
    train_and_evaluate,
    [(1e-4, 1.0, "log-uniform"),  # learning_rate
     (50, 500)],                   # n_estimators
    n_calls=50
)

Bibliothèques clés

---

Méta-Apprentissage (« Apprendre à Apprendre »)

Algorithmes qui améliorent leur capacité d'apprentissage à travers les tâches.

---

Approches Hybrides & Émergentes

IA Neuro-symbolique

Combiner les réseaux de neurones (reconnaissance de patterns) avec le raisonnement symbolique (logique, règles).

• Démonstration Automatique de Théorèmes Neurale — utiliser des réseaux de neurones pour guider la recherche de preuves
• Programmation Différentiable avec Logique — DeepProbLog, Scallop
• LLM + Graphes de Connaissances — ancrer les sorties des modèles de langage dans des connaissances structurées

Réseaux de Neurones sur Graphes (GNN)

Apprendre directement sur des données structurées en graphes.

Applications : prédiction de propriétés moléculaires, analyse de réseaux sociaux, détection de fraude, systèmes de recommandation.

Modèles de Diffusion

Apprennent à débruiter les données — le socle de l'IA générative moderne.

1. Processus direct : Ajouter progressivement du bruit aux données
2. Processus inverse : Un réseau de neurones apprend à retirer le bruit étape par étape
3. Génération : Partir de bruit pur, débruiter itérativement

Utilisés dans : Stable Diffusion, DALL-E 3, Sora (vidéo), génération de structurés protéiques.

---

Choisir la Bonne Famille

Ressources

• [Reinforcement Learning: An Introduction](�0� — Sutton & Barto (gratuit en ligne)
• Spinning Up in Deep RL — Ressource éducative RL d'OpenAI
• Introduction to Évolutionary Computing — Eiben & Smith
• [Probabilistic Machine Learning](�0� — Kevin Murphy (gratuit en ligne)
• Dive into Deep Learning — Manuel interactif de deep learning
• Papers With Code — Benchmarks état de l'art pour toutes les familles ML

:::