Détection d’Anomalies par Autoencodeur : Guide Complet

Résumé

La détection d’anomalies par autoencodeur est une approche puissante et élégante du machine learning non supervisé qui repose sur un principe fondamental : un modèle entraîné exclusivement sur des données normales ne parviendra pas à reconstruire fidèlement des données anormales. Cette asymétrie entre reconstruction normale et reconstruction anormale constitue le signal même de la détection. Contrairement aux méthodes statistiques classiques qui nécessitent une modélisation explicite de la distribution des données, l’autoencodeur apprend automatiquement une représentation compacte du comportement normal, rendant cette approche particulièrement adaptée aux données complexes et de haute dimension. Ce guide complet explore les fondements mathématiques, l’intuition profonde derrière cette méthode, et fournit une implémentation complète en Python avec PyTorch.

Principe Mathématique

Le cœur de la détection d’anomalies par autoencodeur repose sur un mécanisme d’apprentissage par reconstruction. Considérons le processus formel suivant :

Un autoencodeur est un réseau de neurones composé de deux parties principales. D’une part, l’encodeur $f_\theta$ qui projette une donnée d’entrée $x \in \mathbb{R}^d$ dans un espace latent de dimension réduite $z = f_\theta(x) \in \mathbb{R}^k$, où $k < d$. D’autre part, le décodeur $g_\phi$ qui tente de reconstruire la donnée originale à partir de la représentation latente : $\hat{x} = g_\phi(z) = g_\phi(f_\theta(x))$.

L’entraînement se fait en minimisant une fonction de perte de reconstruction sur un ensemble de données normales (sans anomalies) :

$$\mathcal{L}(\theta, \phi) = \frac{1}{N} \sum_{i=1}^{N} ||x_i – \hat{x}i||^2 = \frac{1}{N} \sum ||x_i – g_\phi(f_\theta(x_i))||^2$$}^{N

Cette loss de type erreur quadratique moyenne (MSE) force le réseau à apprendre les caractéristiques structurelles essentielles des données normales. La contrainte de dimension réduite dans l’espace latent $z$ empêche l’autoencodeur de simplement apprendre une fonction identité — il doit sélectionner et compresser l’information pertinente.

Pendant la phase d’inférence, le mécanisme de détection s’opère ainsi : pour toute nouvelle donnée $x$, on calcule le score d’anomalie comme l’erreur de reconstruction :

$$\text{score}(x) = ||x – \hat{x}||^2 \quad \text{ou} \quad \text{score}(x) = ||x – \hat{x}||_1$$

La norme L² (MSE) est la plus couramment utilisée car elle pénalise fortement les grandes erreurs, ce qui est souhaitable pour détecter des anomalies très éloignées du comportement normal. La norme L¹ (MAE) est plus robuste aux petits bruits et peut être préférée lorsque les données normales présentent une variabilité naturelle importante.

Le seuil de décision $\tau$ est déterminé empiriquement à partir des erreurs de reconstruction calculées sur les données normales d’entraînement. On utilise typiquement un percentile élevé, comme le percentile 99 :

$$\tau = \text{percentile}{99}({\text{score}(x_i) : x_i \in D})$$}

La règle de décision finale est alors simple et efficace :

$$x \text{ est classifié comme anomalie } \iff \text{score}(x) > \tau$$

Ce choix du percentile 99 est un compromis : il garantit un taux de faux positifs théorique d’environ 1 % sur les données normales tout en restant suffisamment sensible pour capturer des anomalies significatives. Selon le contexte applicatif, on peut ajuster ce seuil — un percentile plus élevé (99,5 %) réduit les faux positifs mais risque de manquer des anomalies subtiles, tandis qu’un percentile plus bas (95 %) augmente la sensibilité au prix de davantage d’alertes erronées.

Intuition

Pour comprendre pourquoi cette méthode fonctionne si bien, imaginons une analogie visuelle. Supposons que nous entraînions un autoencodeur sur des milliers de portraits de visages humains normaux. Progressivement, le réseau apprend les relations structurelles fondamentales : deux yeux espacés d’une certaine distance, un nez au centre, une bouche en dessous, des oreilles sur les côtés. Il internalise une sorte de « grammaire du visage normal ».

Maintenant, présentons-lui un visage anormal — un visage avec trois yeux. L’autoencodeur, n’ayant jamais rencontré cette configuration pendant son entraînement, ne dispose d’aucun moyen dans son espace latent pour représenter un troisième œil. Il va donc essayer de reconstruire ce qu’il connaît : un visage à deux yeux. Le résultat sera une reconstruction très éloignée de l’entrée originale, générant une erreur de reconstruction massive.

C’est précisément cette erreur qui signale l’anomalie. L’autoencodeur agit comme un expert artisan qui ne connaît que les œuvres authentiques. Quand on lui présente une contrefaçon, il ne parvient pas à la reproduire fidèlement car son expérience est uniquement constituée d’originaux. Son incapacité à reconstruire le faux trahit la nature anormale de l’objet.

Cette intuition se généralise bien au-delà des images. Pour des données tabulaires (transactions financières, mesures de capteurs, logs serveurs), l’autoencodeur apprend les corrélations normales entre les variables. Si une transaction présente une combinaison inhabituelle de montant, de localisation et d’heure, l’autoencodeur — habitué aux combinaisons normales — produira une reconstruction approximative, et l’erreur élevée révélera l’anomalie.

La beauté de cette approche réside dans son automaticité : contrairement à un expert humain qui devrait manuellement définir des règles métier complexes (« une transaction de plus de 10 000 € à 3h du matin depuis un pays inhabituel est suspecte »), l’autoencodeur découvre lui-même la structure du normal et détecte implicitement tout ce qui s’en écarte.

Implémentation Python avec PyTorch

Voici une implémentation complète et commentée d’un système de détection d’anomalies par autoencodeur sur des données tabulaires, utilisant PyTorch.

Installation des dépendances

pip install torch scikit-learn numpy matplotlib seaborn

Architecture de l’Autoencodeur

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score, roc_curve, classification_report
import matplotlib.pyplot as plt
import seaborn as sns


class AutoEncoder(nn.Module):
    """Autoencodeur pour la détection d'anomalies sur données tabulaires."""

    def __init__(self, input_dim: int, latent_dim: int, hidden_dims: list = None):
        super(AutoEncoder, self).__init__()

        if hidden_dims is None:
            hidden_dims = [64, 32]

        # Construction de l'encodeur
        encoder_layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            encoder_layers.append(nn.Linear(prev_dim, h_dim))
            encoder_layers.append(nn.ReLU())
            encoder_layers.append(nn.BatchNorm1d(h_dim))
            prev_dim = h_dim
        encoder_layers.append(nn.Linear(prev_dim, latent_dim))
        self.encoder = nn.Sequential(*encoder_layers)

        # Construction du décodeur (miroir de l'encodeur)
        decoder_layers = []
        prev_dim = latent_dim
        for h_dim in reversed(hidden_dims):
            decoder_layers.append(nn.Linear(prev_dim, h_dim))
            decoder_layers.append(nn.ReLU())
            decoder_layers.append(nn.BatchNorm1d(h_dim))
            prev_dim = h_dim
        decoder_layers.append(nn.Linear(prev_dim, input_dim))
        self.decoder = nn.Sequential(*decoder_layers)

    def forward(self, x):
        """Passe avant complète : encodage puis décodage."""
        z = self.encoder(x)
        x_hat = self.decoder(z)
        return x_hat

    def encode(self, x):
        """Retourne uniquement la représentation latente."""
        return self.encoder(x)

    def reconstruction_error(self, x):
        """Calcule l'erreur de reconstruction par échantillon (MSE)."""
        x_hat = self.forward(x)
        # Erreur au niveau de chaque échantillon (pas de moyenne globale)
        mse = torch.mean((x - x_hat) ** 2, dim=1)
        return mse

Préparation des données et entraînement

def train_autoencoder(X_normal, latent_dim=8, hidden_dims=None,
                      learning_rate=1e-3, batch_size=64, n_epochs=100,
                      patience=10, device='cpu'):
    """
    Entraîne un autoencodeur sur des données normales.

    Args:
        X_normal: np.array de données normales (sans anomalies)
        latent_dim: dimension de l'espace latent
        hidden_dims: dimensions des couches cachées
        learning_rate: taux d'apprentissage
        batch_size: taille des lots
        n_epochs: nombre maximal d'époques
        patience: patience pour l'arrêt anticipé
        device: 'cpu' ou 'cuda'

    Returns:
        model, scaler, loss_history, errors_train: modèle entraîné,
            standardiseur, historique de perte, erreurs d'entraînement
    """
    # Normalisation des données
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X_normal)

    # Conversion en tenseurs PyTorch
    X_tensor = torch.FloatTensor(X_scaled).to(device)
    dataset = TensorDataset(X_tensor, X_tensor)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    input_dim = X_scaled.shape[1]
    model = AutoEncoder(
        input_dim=input_dim,
        latent_dim=latent_dim,
        hidden_dims=hidden_dims
    ).to(device)

    criterion = nn.MSELoss()
    optimizer = optim.Adam(
        model.parameters(), lr=learning_rate, weight_decay=1e-5
    )
    scheduler = optim.lr_scheduler.ReduceLROnPlateau(
        optimizer, mode='min', factor=0.5, patience=5
    )

    best_loss = float('inf')
    patience_counter = 0
    best_state = None
    loss_history = []

    print(f"Entraînement : {input_dim} entrées, {latent_dim} dimensions latentes")
    print(f"Échantillons d'entraînement : {len(X_scaled)}")

    for epoch in range(n_epochs):
        model.train()
        epoch_loss = 0.0
        n_batches = 0

        for batch_x, _ in dataloader:
            optimizer.zero_grad()
            x_hat = model(batch_x)
            loss = criterion(x_hat, batch_x)
            loss.backward()
            optimizer.step()

            epoch_loss += loss.item()
            n_batches += 1

        avg_loss = epoch_loss / n_batches
        loss_history.append(avg_loss)
        scheduler.step(avg_loss)

        # Arrêt anticipé
        if avg_loss < best_loss:
            best_loss = avg_loss
            patience_counter = 0
            best_state = {k: v.clone() for k, v in model.state_dict().items()}
        else:
            patience_counter += 1
            if patience_counter >= patience:
                print(f"Arrêt anticipé à l'époque {epoch+1}")
                break

        if (epoch + 1) % 10 == 0:
            print(f"Époque {epoch+1}/{n_epochs} | Perte: {avg_loss:.6f}")

    # Chargement des meilleurs poids
    if best_state is not None:
        model.load_state_dict(best_state)

    # Calcul des erreurs de reconstruction sur l'ensemble d'entraînement
    model.eval()
    with torch.no_grad():
        errors_train = model.reconstruction_error(X_tensor).cpu().numpy()

    return model, scaler, loss_history, errors_train

Détection et seuillage

def detect_anomalies(model, scaler, X, threshold):
    """
    Détecte les anomalies en comparant l'erreur de reconstruction au seuil.

    Args:
        model: Autoencodeur entraîné
        scaler: Standardiseur fitted sur les données normales
        X: np.array de données à évaluer
        threshold: seuil de décision (erreur de reconstruction)

    Returns:
        is_anomaly: bool array (True = anomalie)
        scores: erreurs de reconstruction par échantillon
    """
    X_scaled = scaler.transform(X)
    X_tensor = torch.FloatTensor(X_scaled)\
                  .to(next(model.parameters()).device)

    model.eval()
    with torch.no_grad():
        scores = model.reconstruction_error(X_tensor).cpu().numpy()

    is_anomaly = scores > threshold
    return is_anomaly, scores


def compute_threshold_from_normal(model, scaler, X_normal, percentile=99):
    """Calcule le seuil de détection à partir de données normales."""
    X_scaled = scaler.transform(X_normal)
    X_tensor = torch.FloatTensor(X_scaled)\
                  .to(next(model.parameters()).device)

    model.eval()
    with torch.no_grad():
        errors = model.reconstruction_error(X_tensor).cpu().numpy()

    threshold = np.percentile(errors, percentile)
    print(f"Seuil de détection (percentile {percentile}): {threshold:.6f}")
    print(f"Erreur moyenne sur données normales: {np.mean(errors):.6f}")
    print(f"Erreur max sur données normales: {np.max(errors):.6f}")
    return threshold

Évaluation et visualisation

def evaluate_model(scores, labels, threshold):
    """
    Évalue les performances de détection.

    Args:
        scores: erreurs de reconstruction
        labels: vraies étiquettes (1 = anomalie, 0 = normal)
        threshold: seuil de décision

    Returns:
        dict avec les métriques d'évaluation
    """
    predictions = (scores > threshold).astype(int)
    auc_roc = roc_auc_score(labels, scores)

    print("\\n" + "=" * 50)
    print("RÉSULTATS DE LA DÉTECTION D'ANOMALIES")
    print("=" * 50)
    print(f"AUC-ROC: {auc_roc:.4f}")
    print(f"Seuil: {threshold:.6f}")
    print(f"Taux d'anomalies détectées: {np.mean(predictions)*100:.2f}%")
    print(f"Vraies anomalies dans le dataset: {np.mean(labels)*100:.2f}%")
    print("\\nRapport de classification:")
    print(classification_report(
        labels, predictions, target_names=['Normal', 'Anomalie']
    ))
    return {'auc_roc': auc_roc, 'threshold': threshold}


def plot_results(loss_history, scores_normal, scores_anomaly, threshold):
    """Génère les visualisations de la détection."""
    fig, axes = plt.subplots(1, 2, figsize=(14, 5))

    # Courbe de perte d'entraînement
    axes[0].plot(loss_history, linewidth=2, color='#2196F3')
    axes[0].set_xlabel('Époque', fontsize=12)
    axes[0].set_ylabel('Perte de reconstruction (MSE)', fontsize=12)
    axes[0].set_title("Convergence de l'entraînement", fontsize=14)
    axes[0].grid(True, alpha=0.3)
    axes[0].set_yscale('log')

    # Distribution des scores de reconstruction
    axes[1].hist(scores_normal, bins=50, alpha=0.6,
                 label='Données normales', color='#4CAF50', density=True)
    if len(scores_anomaly) > 0:
        axes[1].hist(scores_anomaly, bins=50, alpha=0.6,
                     label='Anomalies', color='#F44336', density=True)
    axes[1].axvline(x=threshold, color='#FF9800', linestyle='--',
                    linewidth=2,
                    label=f'Seuil = {threshold:.4f}')
    axes[1].set_xlabel('Erreur de reconstruction (MSE)', fontsize=12)
    axes[1].set_ylabel('Densité', fontsize=12)
    axes[1].set_title('Distribution des scores', fontsize=14)
    axes[1].legend(fontsize=11)
    axes[1].grid(True, alpha=0.3)

    plt.tight_layout()
    plt.savefig('anomaly_detection_results.png', dpi=150)
    plt.show()

Exemple complet d’utilisation

def generate_synthetic_data(n_normal=5000, n_anomaly=200,
                            n_features=20, random_state=42):
    """
    Génère des données synthétiques pour tester la détection d'anomalies.

    Les données normales suivent une distribution gaussienne multivariée
    avec des corrélations entre variables. Les anomalies sont générées
    avec des distributions décalées et des variances plus élevées.
    """
    rng = np.random.RandomState(random_state)

    # Données normales : gaussienne multivariée avec corrélations
    mean = rng.randn(n_features) * 0.5
    A = rng.randn(n_features, n_features) * 0.3
    cov = A @ A.T + np.eye(n_features) * 0.5
    X_normal = rng.multivariate_normal(mean, cov, size=n_normal)

    # Données anormales : mélange de plusieurs distributions décalées
    n_groups = 4
    anomalies_per_group = n_anomaly // n_groups
    anomaly_parts = []

    for i in range(n_groups):
        shift_mean = mean + rng.randn(n_features) * rng.uniform(3, 8)
        shift_cov = cov * rng.uniform(1.5, 4.0)
        X_anom = rng.multivariate_normal(
            shift_mean, shift_cov, size=anomalies_per_group
        )
        anomaly_parts.append(X_anom)

    X_anomaly = np.vstack(anomaly_parts)
    X = np.vstack([X_normal, X_anomaly])
    y = np.concatenate([np.zeros(n_normal), np.ones(n_anomaly)])

    return X, y


# ═══════════════════════════════════════════════════
# EXÉCUTION COMPLÈTE
# ═══════════════════════════════════════════════════

if __name__ == '__main__':
    # Configuration
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print(f"Utilisation du device: {device}")

    # Génération des données
    X, y = generate_synthetic_data(
        n_normal=8000, n_anomaly=400, n_features=30
    )
    print(f"Dataset: {X.shape[0]} échantillons, {X.shape[1]} features")
    print(f"Taux de contamination: {np.mean(y)*100:.2f}%")

    # Split : données normales uniquement pour l'entraînement
    X_train_normal = X[y == 0]
    X_test = X
    y_test = y

    # Entraînement
    model, scaler, loss_history, train_errors = train_autoencoder(
        X_train_normal,
        latent_dim=8,
        hidden_dims=[128, 64, 32],
        learning_rate=1e-3,
        batch_size=128,
        n_epochs=200,
        patience=15,
        device=device
    )

    # Calcul du seuil sur les données normales d'entraînement
    threshold = compute_threshold_from_normal(
        model, scaler, X_train_normal, percentile=99
    )

    # Détection sur l'ensemble de test
    _, test_scores = detect_anomalies(
        model, scaler, X_test, threshold
    )

    # Évaluation
    scores_normal = test_scores[y_test == 0]
    scores_anomaly = test_scores[y_test == 1]

    evaluate_model(test_scores, y_test, threshold)

    # Visualisation
    plot_results(loss_history, scores_normal, scores_anomaly, threshold)

Hyperparamètres

Le choix des hyperparamètres est crucial pour la performance de la détection d’anomalies. Voici les paramètres les plus importants et leurs recommandations pratiques.

Dimension de l’espace latent (latent_dim)

C’est l’hyperparamètre le plus influent. Un espace latent trop grand permet à l’autoencodeur de mémoriser les données d’entraînement, y compris le bruit, ce qui réduit sa capacité à détecter des anomalies. Un espace trop petit perd trop d’information et produit des erreurs de reconstruction élevées même pour des données normales.

Recommandation : commencer avec latent_dim = input_dim // 4 et ajuster. Pour des données de 30 dimensions, un latent de 6 à 8 fonctionne généralement bien. Pour des données de 100+ dimensions, on peut aller jusqu’à 16-32.

Percentile du seuil (threshold_percentile)

Ce paramètre contrôle le compromis entre faux positifs et faux négatifs. Un percentile de 99 signifie qu’environ 1 % des données normales seront classifiées à tort comme anomalies.

Recommandation :
– Percentile 99 : bon équilibre par défaut, adapté à la plupart des cas d’utilisation
– Percentile 99,5 ou 99,9 : pour les environnements où les alertes sont coûteuses (surveillance médicale, aérospatial)
– Percentile 95 à 98 : pour la détection précoce où on préfère des faux positifs à des faux négatifs (cybersécurité, fraude bancaire)

Taux d’apprentissage (learning_rate)

Un taux trop élevé empêche la convergence fine nécessaire pour une bonne reconstruction. Un taux trop bas ralentit l’entraînement et peut mener à un sous-apprentissage.

Recommandation : 1e-3 avec un scheduler ReduceLROnPlateau (facteur 0,5, patience 5) est un excellent point de départ. Réduire à 5e-4 pour des données très bruitées.

Nombre et taille des couches (n_layers, hidden_dims)

Une architecture trop profonde peut souffrir de vanishing gradients et surajuster. Une architecture trop simple ne capture pas les relations complexes.

Recommandation : 3 à 5 couches cachées avec des dimensions décroissantes puis croissantes. Par exemple [128, 64, 32] pour l’encodeur (le décodeur étant symétrique). Utiliser systématiquement ReLU comme fonction d’activation et BatchNorm1d pour stabiliser l’entraînement.

Avantages et Limites

Avantages

• Entièrement non supervisé : ne nécessite aucune étiquette d’anomalie pour l’entraînement, ce qui est précieux car les anomalies sont rares et mal étiquetées en pratique
• Capacité à modéliser des relations non linéaires complexes entre les variables, là où les méthodes linéaires comme l’ACP échouent
• Adaptabilité aux données de haute dimension : images, séries temporelles multivariées, données tabulaires riches
• Pas d’hypothèse distributionnelle forte : ne suppose pas que les données normales suivent une distribution gaussienne ou particulière
• Scalabilité : l’inférence est extrêmement rapide (une seule passe avant du réseau de neurones), adaptée au temps réel
• Flexibilité architecturale : on peut utiliser des convolutions pour les images, des LSTMs ou des Transformers pour les séries temporelles, des réseaux de neurones à graphes pour les données relationnelles

Limites

• Nécessite des données d’entraînement propres : si les données d’entraînement contiennent des anomalies non détectées, le modèle peut apprendre à les reconstruire et les manquer lors de l’inférence
• Sensibilité au choix d’hyperparamètres : la dimension latente et le seuil ont un impact majeur sur les résultats
• Difficulté avec les anomalies subtiles : si une anomalie est très proche du comportement normal (anomalie contextuelle), l’erreur de reconstruction peut être insuffisante pour la détecter
• Interprétabilité limitée : contrairement à un Isolation Forest qui donne des scores explicites par feature, l’autoencodeur est une boîte noire — il est difficile de comprendre pourquoi un échantillon a été détecté comme anomalie
• Coût d’entraînement : l’entraînement d’un autoencodeur profond sur de grands volumes de données peut être significativement plus lent que des méthodes traditionnelles
• Dérive conceptuelle : si la distribution des données normales évolue avec le temps, le modèle doit être périodiquement réentraîné pour rester performant

4 Cas d’Usage Concrets

1. Détection de fraude bancaire

Les institutions financières analysent des millions de transactions quotidiennement. Un autoencodeur entraîné sur des transactions normales apprend les patterns habituels : montants typiques, horaires normaux, marchands fréquents, localisations géographiques cohérentes. Une transaction frauduleuse — par exemple un achat de 5 000 € à l’étranger à 4h du matin sur un nouveau site marchand — produira une erreur de reconstruction élevée car cette combinaison s’écarte significativement du comportement normal du client. Les grandes banques utilisent cette approche en production avec des taux de détection dépassant 92 %.

2. Surveillance industrielle et maintenance prédictive

Dans une usine, des capteurs IoT mesurent en continu la température, les vibrations, la pression et le courant électrique de chaque machine. Un autoencodeur entraîné sur le comportement normal de la machine détecte les signes avant-coureurs de défaillance bien avant qu’une alarme ne se déclenche. Une augmentation subtile mais anormale des vibrations couplée à une légère hausse de température peut être le signe d’un roulement en cours d’usure. Détecter cette anomalie quelques jours avant la panne permet une maintenance planifiée plutôt qu’un arrêt d’urgence coûteux.

3. Cybersécurité et détection d’intrusions réseau

Les flux réseau (NetFlow, paquets IP) présentent des patterns normaux prévisibles : protocoles utilisés, volumes de données, horaires d’activité, destinations habituelles. Un autoencodeur entraîné sur le trafic normal d’un réseau d’entreprise détecte les activités inhabituelles : un serveur interne qui commence à communiquer avec une adresse IP étrangère inconnue, un volume de données sortantes anormalement élevé, ou des connexions à des ports inhabituels. Cette approche est particulièrement efficace contre les attaques zero-day qui ne correspondent à aucune signature connue des systèmes de détection classiques.

4. Qualité manufacturière et contrôle visuel

Dans la production de semi-conducteurs, d’écrans OLED ou de composants automobiles, la détection de défauts microscopiques est critique. Des autoencodeurs convolutionnels (CAE) entraînés sur des images de produits sans défauts détectent les microfissures, les particules, les variations de couleur invisibles à l’œil nu. L’avantage par rapport aux méthodes supervisées est qu’il suffit de collecter des images de produits conformes — pas besoin d’exemples de chaque type de défaut possible, ce qui serait impossible car les défauts sont par nature rares et variés.

Voir aussi

• Maîtriser les Arrangements Maximaux en Python : Guide Complet et Astuces pour Développeurs
• Trouver la Médiane d’un Flux de Données en Python – Question d’Entretien