t-SNE

Fonctions :

  • TSNE()

    La fonction TSNE() (t-Distributed Stochastic Neighbor Embedding) est une technique de réduction de dimensionnalité non linéaire, principalement utilisée pour visualiser des données à haute dimension en 2D ou 3D. Elle préserve les relations locales entre les points, permettant de révéler des structures complexes et des regroupements dans les données.

    Importation :

    from sklearn.manifold import TSNE

    Attributs :

    Paramètre Type Description Valeur par défaut
    n_components int Nombre de dimensions dans l'espace réduit (généralement 2 ou 3 pour visualisation). 2
    perplexity float Mesure liée au nombre effectif de voisins pris en compte. Contrôle l’équilibre entre préservation des structures locales et globales. 30.0
    early_exaggeration float Facteur d’exagération pour renforcer la séparation initiale entre les points pendant l’optimisation. 12.0
    learning_rate float Taux d’apprentissage pour l’optimisation (gradient descent). 200.0
    n_iter int Nombre total d’itérations de l’algorithme d’optimisation. 1000
    n_iter_without_progress int Nombre d’itérations sans amélioration du coût avant arrêt anticipé. 300
    min_grad_norm float Seuil minimal pour le gradient afin de considérer la convergence. 1e-7
    metric str ou callable Métrique utilisée pour calculer la distance entre les points d’entrée. "euclidean"
    init str ou ndarray Méthode d’initialisation des points dans l’espace réduit ("random", "pca" ou un tableau numpy). "random"
    verbose int Niveau de verbosité pour afficher les informations durant l’exécution. 0
    random_state int, RandomState instance ou None Graine aléatoire pour assurer la reproductibilité. None
    method str Méthode d’approximation : "barnes_hut" (rapide) ou "exact". "barnes_hut"
    angle float Angle d’approximation pour la méthode "barnes_hut" (précision vs vitesse). 0.5

    Exemple de code :

    from sklearn.manifold import TSNE
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# Charger un jeu de données exemple (Iris)
data = load_iris()
X = data.data
y = data.target

# Créer l'objet TSNE et réduire à 2 dimensions
tsne = TSNE(n_components=2, random_state=42)

# Appliquer TSNE sur les données
X_embedded = tsne.fit_transform(X)

# Affichage des points dans le nouvel espace 2D
plt.figure(figsize=(8,6))
for label in set(y):
    plt.scatter(
        X_embedded[y == label, 0],
        X_embedded[y == label, 1],
        label=data.target_names[label]
    )

plt.legend()
plt.title("Projection TSNE du jeu de données Iris")
plt.xlabel("Composante 1")
plt.ylabel("Composante 2")
plt.show()

    Explication du code :

    from sklearn.manifold import TSNE importe la classe TSNE du module de réduction de dimension de scikit-learn, utilisée pour projeter des données en espace de dimension plus faible en conservant la structure locale.

from sklearn.datasets import load_iris importe la fonction load_iris qui charge le célèbre jeu de données Iris (fleurs avec 4 caractéristiques et 3 classes).

import matplotlib.pyplot as plt importe la bibliothèque matplotlib pour créer des graphiques.


    Chargement des données Iris
     data = load_iris() charge les données Iris dans un objet data. X = data.data extrait les caractéristiques (4 dimensions). y = data.target récupère les étiquettes/classes (3 classes). 
    Création de l’objet TSNE
     tsne = TSNE(n_components=2, random_state=42) crée un objet TSNE qui réduira les données à 2 dimensions pour faciliter la visualisation. Le paramètre random_state garantit la reproductibilité. 
    Application de TSNE
     X_embedded = tsne.fit_transform(X) ajuste TSNE aux données d’entrée X et calcule la projection 2D dans X_embedded. 
    Visualisation des données projetées
     plt.figure(figsize=(8,6)) crée une figure pour le graphique.
for label in set(y): itère sur chaque classe unique pour afficher ses points distinctement.
plt.scatter(X_embedded[y == label, 0], X_embedded[y == label, 1], label=data.target_names[label]) affiche les points projetés en 2D correspondant à la classe label avec une couleur spécifique.

plt.legend() ajoute la légende avec le nom des classes.
plt.title("Projection TSNE du jeu de données Iris") ajoute un titre au graphique.
plt.xlabel("Composante 1") et plt.ylabel("Composante 2") ajoutent les étiquettes des axes.

plt.show() affiche la figure.

Cette visualisation montre comment TSNE réduit les 4 dimensions des données Iris à 2 dimensions tout en regroupant les points par classe, facilitant ainsi l’interprétation visuelle des clusters naturels dans les données.