UMAP

Fonctions :

• umap.UMAP()

  La fonction umap.UMAP() réalise une réduction de dimensionnalité non linéaire, similaire à t-SNE, mais souvent plus rapide et capable de préserver à la fois les structures locales et globales des données. Elle est largement utilisée pour visualiser des données complexes en 2D ou 3D tout en conservant la topologie sous-jacente.

  Importation :

  import umap

  Attributs :

  Paramètre	Type	Description	Valeur par défaut
  n_neighbors	int	Nombre de voisins locaux utilisés pour la construction du graphe de voisinage.	15
  n_components	int	Dimension finale de l’espace réduit (ex : 2 pour visualisation).	2
  metric	str ou callable	Métrique utilisée pour calculer la distance entre points dans l’espace d’origine.	"euclidean"
  min_dist	float	Distance minimale entre points dans l’espace réduit, contrôlant la compacité des clusters.	0.1
  spread	float	Contrôle l’étalement global des points dans l’espace réduit.	1.0
  set_op_mix_ratio	float	Poids pour combiner les opérateurs d’intersection et d’union lors de la construction du graphe.	1.0
  local_connectivity	int	Nombre minimum de voisins locaux connectés à chaque point.	1
  repulsion_strength	float	Force de répulsion entre les points dans l’espace réduit.	1.0
  negative_sample_rate	int	Nombre d’échantillons négatifs utilisés pour optimiser la perte.	5
  transform_queue_size	float	Taille de la file d’attente utilisée pour le calcul lors de la transformation de nouveaux points.	4.0
  learning_rate	float	Taux d’apprentissage pour l’optimisation.	1.0
  init	str ou ndarray	Méthode d’initialisation des embeddings ("spectral" ou "random").	"spectral"
  verbose	bool	Affiche les logs pendant l’entraînement si True.	False
  random_state	int, RandomState instance ou None	Graine aléatoire pour la reproductibilité.	None

  Exemple de code :

  📋 Copy

  import umap
  import numpy as np
  import matplotlib.pyplot as plt
  from sklearn.datasets import load_iris
  
  # Charger le dataset Iris (4 features)
  data = load_iris()
  X = data.data
  y = data.target
  
  # Initialiser et appliquer UMAP (réduction à 2 dimensions)
  reducer = umap.UMAP(n_components=2, random_state=42)
  X_umap = reducer.fit_transform(X)
  
  # Visualiser la projection 2D
  plt.scatter(X_umap[:, 0], X_umap[:, 1], c=y, cmap='Spectral', s=50)
  plt.title('Projection UMAP du dataset Iris')
  plt.xlabel('UMAP 1')
  plt.ylabel('UMAP 2')
  plt.colorbar(boundaries=np.arange(4)-0.5).set_ticks(np.arange(3))
  plt.show()

  

  Explication du code :

  import numpy as np importe la bibliothèque NumPy, utilisée pour la manipulation de tableaux numériques.
  
  import matplotlib.pyplot as plt importe matplotlib, qui sert à créer des graphiques.
  
  import umap importe la bibliothèque UMAP, utilisée pour la réduction de dimension non linéaire.
  
  from sklearn.datasets import load_digits importe la fonction load_digits, qui charge un jeu de données d’images de chiffres manuscrits.

  Chargement des données

  digits = load_digits() charge le jeu de données des chiffres manuscrits (1797 images, 64 features).
  
  X = digits.data récupère les données des images sous forme de vecteurs 64 dimensions.
  
  y = digits.target récupère les étiquettes des chiffres (0 à 9).

  Application d’UMAP

  umap_model = umap.UMAP(n_neighbors=15, n_components=2, metric='euclidean', random_state=42) crée un objet UMAP configuré pour réduire les données à 2 dimensions, avec 15 voisins pris en compte et distance euclidienne.
  
  X_umap = umap_model.fit_transform(X) ajuste UMAP sur les données X puis projette les données dans un espace 2D.

  Visualisation des résultats

  plt.figure(figsize=(10, 8)) crée une figure pour le graphique.
  
  scatter = plt.scatter(X_umap[:, 0], X_umap[:, 1], c=y, cmap='Spectral', s=10) trace les points projetés en 2D, colorés selon le chiffre représenté.
  
  plt.colorbar(scatter, label='Chiffre') ajoute une barre de couleurs pour les labels.
  
  plt.title("Projection UMAP du jeu de données digits") ajoute un titre au graphique.
  
  plt.xlabel("Composante 1") et plt.ylabel("Composante 2") ajoutent les labels des axes.
  
  plt.show() affiche la figure.
  
  Cette visualisation montre comment UMAP réduit efficacement la dimensionnalité des données en conservant la structure locale et globale, permettant d’observer la séparation naturelle des chiffres dans l’espace réduit.