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 :

  📋 Copy

  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.