Analyse Discriminante Quadratique : Guide complet — Principes, Exemples et Implémentation Python

Résumé — L’analyse discriminante quadratique (QDA) est une méthode de classification probabiliste qui attribue à chaque classe sa propre matrice de covariance, produisant des frontières de décision non linéaires. Ce guide couvre les principes mathématiques, l’intuition géométrique, l’implémentation Python avec scikit-learn et les cas d’usage pratiques.

Principe mathématique

L’analyse discriminante quadratique repose sur le théorème de Bayes et l’hypothèse que les données de chaque classe suivent une distribution gaussienne multivariée. Contrairement à l’analyse discriminante linéaire (LDA), le QDA ne suppose pas que toutes les classes partagent la même matrice de covariance.

Fonction discriminante

Pour chaque classe k dans {1, …, K}, on définit la fonction discriminante :

δ_k(x) = -½ log|Σ_k| – ½ (x – μ_k)^ᵀ Σ_k⁻¹ (x – μ_k) + log(π_k)

Où :

• x ∈ Rᵖ est le vecteur d’observations à classer (p caractéristiques),
• μ_k est le vecteur moyenne de la classe k,
• Σ_k est la matrice de covariance spécifique à la classe k,
• π_k est la probabilité a priori d’appartenir à la classe k,
• |Σ_k| désigne le déterminant de la matrice de covariance.

Règle de classification

L’observation x est assignée à la classe qui maximise la fonction discriminante :

ŷ = argmax_k δ_k(x)

Estimation des paramètres

Les paramètres sont estimés par maximum de vraisemblance à partir des données d’entraînement :

• Moyenne de classe : μ̂k = (1 / n_k) Σ x_i
• Covariance de classe : Σ̂k = (1 / n_k) Σ (x_i – μ̂_k)(x_i – μ̂_k)^ᵀ
• Probabilité a priori : π̂_k = n_k / n

où n_k est le nombre d’observations dans la classe k et n est le nombre total d’observations.

Frontières de décision

La frontière entre deux classes k et l est l’ensemble des points vérifiant δ_k(x) = δ_l(x). Puisque chaque classe possède sa propre matrice de covariance, cette équation fait intervenir des termes quadratiques en x, ce qui donne des frontières quadratiques (ellipses, paraboles ou hyperboles selon la géométrie des covariances).

À l’inverse, dans le cas du LDA où Σ_k = Σ pour tout k, les termes quadratiques s’annulent et les frontières sont linéaires (des hyperplans dans l’espace des caractéristiques).

Intuition géométrique

Imaginez que chaque classe forme un nuage de points dans l’espace des caractéristiques. En QDA, chaque nuage a sa propre forme :

• LDA : tous les nuages ont la même forme globale (même ellipse de covariance), seule leur position centrale diffère. Les frontières sont des droites (ou hyperplans en dimension supérieure).
• QDA : chaque nuage possède sa propre ellipse de covariance — certaines classes peuvent être très étirées dans une direction, d’autres plus compactes et sphériques. Les frontières qui séparent les classes sont des courbes quadratiques : arcs de parabole, branches d’hyperbole ou arcs d’ellipse.

Pourquoi des courbes quadratiques ?

Considérons un exemple simple en deux dimensions avec deux classes :

• Classe A : nuage très allongé horizontalement (forte variance en x, faible en y).
• Classe B : nuage rond et compact (variances similaires dans toutes les directions).

Là où les deux nuages se rapprochent, la frontière qui les sépare ne sera pas une droite : elle suivra la courbure naturelle des ellipses de covariance. Cette flexibilité permet au QDA de capturer des situations où les classes ont des dispersions hétérogènes.

Le compromis biais-variance

Cette puissance a un coût. En LDA, on estime une seule matrice de covariance partagée (soit p(p+1)/2 paramètres pour p variables). En QDA, on en estime une par classe (soit K × p(p+1)/2 paramètres). Pour p = 50 et K = 5, cela représente :

• LDA : 1 275 paramètres de covariance.
• QDA : 6 375 paramètres de covariance.

Avec peu de données d’entraînement, le QDA risque le surajustement (overfitting) car il estime beaucoup trop de paramètres par rapport à la quantité d’information disponible.

Implémentation Python

Voici une implémentation complète de l’analyse discriminante quadratique avec scikit-learn, incluant une comparaison visuelle entre LDA et QDA.

Installation des dépendances

pip install scikit-learn numpy matplotlib seaborn

Exemple de base

import numpy as np
import matplotlib.pyplot as plt
from sklearn.discriminant_analysis import (
    LinearDiscriminantAnalysis,
    QuadraticDiscriminantAnalysis,
)
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, accuracy_score

# Génération de données avec classes de dispersions différentes
rng = np.random.RandomState(42)

# Classe 0 : centrée en (-2, -2), covariance petite et isotrope
n0 = 300
X0 = rng.multivariate_normal(
    mean=[-2, -2],
    cov=[[0.5, 0], [0, 0.5]],
    size=n0
)
y0 = np.zeros(n0, dtype=int)

# Classe 1 : centrée en (2, 2), covariance grande et elliptique
n1 = 300
X1 = rng.multivariate_normal(
    mean=[2, 2],
    cov=[[3, 1.5], [1.5, 2]],
    size=n1
)
y1 = np.ones(n1, dtype=int)

# Fusion des données
X = np.vstack([X0, X1])
y = np.concatenate([y0, y1])

# Division entraînement / test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Entraînement LDA et QDA
lda = LinearDiscriminantAnalysis()
qda = QuadraticDiscriminantAnalysis()

lda.fit(X_train, y_train)
qda.fit(X_train, y_train)

# Prédictions et évaluation
for name, model in [("LDA", lda), ("QDA", qda)]:
    y_pred = model.predict(X_test)
    acc = accuracy_score(y_test, y_pred)
    print(f"--- {name} ---")
    print(f"Précision : {acc:.4f}")
    print(classification_report(y_test, y_pred, target_names=["Classe 0", "Classe 1"]))

Visualisation des frontières de décision

def plot_decision_boundary(X, y, models, names):
    fig, axes = plt.subplots(1, len(models), figsize=(6 * len(models), 5))

    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(
        np.linspace(x_min, x_max, 300),
        np.linspace(y_min, y_max, 300)
    )
    grid = np.c_[xx.ravel(), yy.ravel()]

    for ax, model, name in zip(axes, models, names):
        Z = model.predict(grid).reshape(xx.shape)
        probs = model.predict_proba(grid)[:, 1].reshape(xx.shape)

        ax.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.RdYlBu, levels=[-0.5, 0.5, 1.5])
        ax.contour(xx, yy, probs, levels=[0.5], colors="black", linewidths=2)

        ax.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlBu,
                   edgecolors="black", s=40, alpha=0.8)

        acc = accuracy_score(y, model.predict(X))
        ax.set_title(f'{name}\nPrécision : {acc:.3f}', fontsize=14)
        ax.set_xlabel("x₁")
        ax.set_ylabel("x₂")

    plt.tight_layout()
    plt.show()

# Application
plot_decision_boundary(X, y, [lda, qda], ["LDA", "QDA"])

Comparaison avec le classifieur bayésien optimal

Le QDA est l’application directe du classifieur bayésien optimal sous l’hypothèse gaussienne par classe. Si les données respectent effectivement cette hypothèse, le QDA converge vers le classifieur optimal quand la taille de l’échantillon tend vers l’infini.

print("Matrices de covariance estimées par le QDA :")
for k, cov in enumerate(qda.covariance_):
    print(f"Classe {k} :")
    print(cov)
    print(f"  Déterminant : {np.linalg.det(cov):.4f}")

Hyperparamètres

L’objet QuadraticDiscriminantAnalysis de scikit-learn possède trois hyperparamètres principaux :

Choix de régularisation

Lorsque le nombre de caractéristiques p est élevé par rapport au nombre d’observations par classe n_k, les matrices de covariance estimées peuvent devenir singulières (non inversibles). Le paramètre reg_param ajoute λI à chaque Σ̂_k :

Σ̃_k = Σ̂_k + λI

Cette régularisation de type Tikhonov garantit que les matrices restent inversibles et stabilise les prédictions.

from sklearn.model_selection import GridSearchCV

param_grid = {'reg_param': [0.0, 0.001, 0.01, 0.05, 0.1, 0.5]}
qda_grid = QuadraticDiscriminantAnalysis(store_covariance=True)
grid_search = GridSearchCV(qda_grid, param_grid, cv=5, scoring="accuracy")
grid_search.fit(X_train, y_train)

print(f"Meilleur reg_param : {grid_search.best_params_['reg_param']}")
print(f"Meilleure précision (validation croisée) : {grid_search.best_score_:.4f}")

Avantages et Limites

Avantages

• Flexibilité des frontières : Le QDA capture des séparations non linéaires entre classes, là où le LDA échouerait.
• Covariances hétérogènes : Idéal quand les classes ont des dispersions nettement différentes (c’est précisément le cas d’usage principal).
• Classification probabiliste : Fournit des probabilités d’appartenance via predict_proba(), utiles pour le seuillage et l’analyse de risque.
• Aucun hyperparamètre complexe : Contrairement aux forêts aléatoires ou aux réseaux de neurones, le QDA n’a pratiquement pas d’hyperparamètres à régler.
• Interprétabilité : Les paramètres estimés (moyennes, covariances, probabilités a priori) ont une signification statistique directe.

Limites

• Nombre de paramètres : K × p(p+1)/2 paramètres de covariance à estimer. Peut devenir prohibitif avec beaucoup de caractéristiques.
• Risque de surajustement : Avec peu de données d’entraînement et beaucoup de caractéristiques, le modèle mémorise le bruit au lieu d’apprendre la structure réelle.
• Hypothèse gaussienne : Si les distributions de classe s’écartent fortement de la normalité multivariée, les performances peuvent se dégrader.
• Matrices singulières : Quand n_k ≤ p pour une classe, la matrice de covariance estimée est singulière — nécessite une régularisation (reg_param > 0).
• Complexité prédictive : O(K × p²) par prédiction, contre O(K × p) pour le LDA. Impact perceptible en temps réel avec de grandes dimensions.

Cas d’usage

1. Diagnostic médical — Analyse de biopsies

En cancérologie, les tissus sains et tumoraux présentent souvent des signatures moléculaires avec des variances radicalement différentes : les cellules cancreuses montrent une hétérogénéité expressionnelle beaucoup plus grande que les cellules saines. Le QDA, en autorisant des covariances distinctes, capture naturellement cette asymétrie. Des études sur la classification de cancers du sein à partir de données transcriptomiques ont montré que le QDA surclassait le LDA de 4 à 7 points de précision grâce à cette capacité.

2. Finance — Détection de fraude bancaire

Les transactions frauduleuses forment une classe dont la distribution est fondamentalement différente des transactions légitimes : montants inhabituels, horaires atypiques, localisations improbables. La dispersion des transactions frauduleuses est intrinsèquement plus grande et de structure différente. Le QDA modélise ces deux régimes séparément, produisant des frontières de décision courbes qui épousent mieux la géométrie réelle des données. Le protocole d’analyse nécessite un calibrage précis des seuils, car un faux négatif peut coûter des milliers d’euros.

3. Reconnaissance de la parole

En reconnaissance vocale, chaque phonème est modélisé par une distribution gaussienne dans l’espace des coefficients cepstraux (MFCC). Les phonèmes n’ont pas la même variabilité acoustique : certains sont très stables, d’autres varient énormément selon le locuteur. Le QDA permet d’assigner à chaque phonème son propre modèle de covariance, améliorant la précision de classification par rapport au LDA, particulièrement pour les phonèmes à forte variabilité. Cette approche fonctionne également bien pour la reconnaissance de l’accent du locuteur.

4. Télédétection — Classification d’images satellites

Chaque type de couverture terrestre — forêt, zone urbaine, eaux littorales, cultures agricoles — possède une signature spectrale avec une dispersion caractéristique. Les zones urbaines présentent une hétérogénéité spectrale bien plus forte que les plans d’eau qui réfléchissent la lumière de façon uniforme. Le QDA exploite cette différence de structure de covariance pour produire des classificateurs plus précis, notamment aux frontières entre classes où les distributions se chevauchent de manière asymétrique. Cette approche est particulièrement utile pour la cartographie de l’occupation des sols à haute résolution.

QDA vs LDA : Quand choisir quoi ?

Règle pratique : Si les classes de votre problème ont des dispersions visiblement différentes (vérifiable par une analyse exploratoire des variances par classe), commencez par le QDA. Sinon, le LDA est un point de départ plus robuste.

Voir aussi

• Implémentation de l’Algorithme de Cramer et Calcul de Déterminant en Python
• Optimisez Votre Code Python avec SOP et POS : Guide Complet pour les Débutants