Analyse discriminante linéaire pour la classification

Introduction

Ce laboratoire vous présentera l'Analyse Discriminante Linéaire (LDA) et comment elle peut être utilisée pour la classification. Nous utiliserons scikit-learn, une bibliothèque populaire de machine learning en Python, pour implémenter l'LDA. Nous explorerons également comment les estimateurs de covariance Ledoit-Wolf et Oracle Shrinkage Approximating (OAS) peuvent améliorer la classification.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Générer des données aléatoires

Tout d'abord, nous devons générer des données aléatoires avec une caractéristique discriminante et des caractéristiques bruitées. Nous utiliserons la fonction make_blobs de scikit-learn pour générer deux grappes de données avec une caractéristique discriminante. Ensuite, nous ajouterons du bruit aléatoire aux autres caractéristiques.

import numpy as np
from sklearn.datasets import make_blobs

def generate_data(n_samples, n_features):
    """Générer des données aléatoires ressemblant à des grappes avec des caractéristiques bruitées.

    Cela renvoie un tableau de données d'entrée de forme `(n_samples, n_features)`
    et un tableau d'étiquettes cibles de `n_samples`.

    Seule une caractéristique contient des informations discriminantes, les autres caractéristiques
    ne contiennent que du bruit.
    """
    X, y = make_blobs(n_samples=n_samples, n_features=1, centers=[[-2], [2]])

    ## ajouter des caractéristiques non discriminantes
    if n_features > 1:
        X = np.hstack([X, np.random.randn(n_samples, n_features - 1)])
    return X, y

Implémenter l'ALD

Ensuite, nous allons implémenter l'ALD en utilisant la classe LinearDiscriminantAnalysis de scikit-learn. Nous allons créer trois classifieurs :

• ALD sans réduction
• ALD avec réduction Ledoit-Wolf
• ALD avec réduction OAS

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.covariance import OAS

clf1 = LinearDiscriminantAnalysis(solver="lsqr", shrinkage=None)
clf2 = LinearDiscriminantAnalysis(solver="lsqr", shrinkage="auto")
oa = OAS(store_precision=False, assume_centered=False)
clf3 = LinearDiscriminantAnalysis(solver="lsqr", covariance_estimator=oa)

Entraîner et tester les classifieurs

Nous allons entraîner et tester chaque classifieur pour voir comment ils se comportent sur les données générées. Nous allons répéter ce processus plusieurs fois pour obtenir une note de précision moyenne.

n_train = 20  ## échantillons pour l'entraînement
n_test = 200  ## échantillons pour le test
n_averages = 50  ## combien de fois répéter la classification
n_features_max = 75  ## nombre maximum de caractéristiques
step = 4  ## pas de calcul

acc_clf1, acc_clf2, acc_clf3 = [], [], []
n_features_range = range(1, n_features_max + 1, step)

for n_features in n_features_range:
    score_clf1, score_clf2, score_clf3 = 0, 0, 0
    for _ in range(n_averages):
        X, y = generate_data(n_train, n_features)

        clf1.fit(X, y)
        clf2.fit(X, y)
        clf3.fit(X, y)

        X, y = generate_data(n_test, n_features)
        score_clf1 += clf1.score(X, y)
        score_clf2 += clf2.score(X, y)
        score_clf3 += clf3.score(X, y)

    acc_clf1.append(score_clf1 / n_averages)
    acc_clf2.append(score_clf2 / n_averages)
    acc_clf3.append(score_clf3 / n_averages)

Visualiser les résultats

Enfin, nous allons tracer la précision de classification de chaque classifieur en fonction du nombre de caractéristiques. Nous utiliserons matplotlib pour créer le tracé.

import matplotlib.pyplot as plt

features_samples_ratio = np.array(n_features_range) / n_train

plt.plot(
    features_samples_ratio,
    acc_clf1,
    linewidth=2,
    label="LDA",
    color="gold",
    linestyle="solid",
)
plt.plot(
    features_samples_ratio,
    acc_clf2,
    linewidth=2,
    label="LDA avec Ledoit Wolf",
    color="navy",
    linestyle="dashed",
)
plt.plot(
    features_samples_ratio,
    acc_clf3,
    linewidth=2,
    label="LDA avec OAS",
    color="red",
    linestyle="dotted",
)

plt.xlabel("n_features / n_samples")
plt.ylabel("Précision de classification")

plt.legend(loc="bas à gauche")
plt.ylim((0,65, 1,0))
plt.suptitle(
    "LDA (Analyse Discriminante Linéaire) vs. "
    + "\n"
    + "LDA avec Ledoit Wolf vs. "
    + "\n"
    + "LDA avec OAS (1 caractéristique discriminante)"
)
plt.show()

Remarque : Il y avait une erreur dans la limite verticale de plt.ylim dans le code original. J'ai corrigé la syntaxe en utilisant des virgules au lieu de points pour les nombres décimaux en Python. Si vous voulez conserver le format original, vous pouvez ajuster en conséquence.

Résumé

Dans ce laboratoire, nous avons appris à implémenter l'Analyse Discriminante Linéaire (ALD) à l'aide de scikit-learn. Nous avons exploré la manière dont les estimateurs de covariance Ledoit-Wolf et Oracle Shrinkage Approximating (OAS) peuvent améliorer la précision de classification. Nous avons également généré des données aléatoires avec une caractéristique discriminante et testé nos classifieurs sur ces données. Enfin, nous avons visualisé la précision de classification en fonction du nombre de caractéristiques.