t-SNE et UMAP : L’Art de la Visualisation Non-Linéaire

1 Introduction : Les Limites des Méthodes Linéaires

Dans les articles précédents, nous avons exploré le PCA et le LDA, deux techniques puissantes qui projettent les données sur des lignes ou des plans. Elles sont excellentes pour capturer des structures linéaires, mais que se passe-t-il si la structure de nos données est beaucoup plus complexe ?

Imaginez des données qui forment des “rubans” enroulés, des clusters imbriqués ou des formes de “lunes”. Une projection linéaire écrasera ces structures et nous donnera une vision trompeuse de nos données.

Pour visualiser ces relations complexes, nous avons besoin d’outils plus sophistiqués, capables de “déplier” ces structures non-linéaires. C’est le domaine des algorithmes de réduction de dimensionnalité non-linéaire, et deux d’entre eux règnent en maîtres pour la visualisation : t-SNE et UMAP.

2 t-SNE : Révéler les Voisinages

t-SNE (t-Distributed Stochastic Neighbor Embedding) est un algorithme qui a révolutionné la visualisation de données de grande dimension. Son objectif principal n’est pas de préserver les grandes distances ou la structure globale, mais de préserver la structure de voisinage locale.

2.1 L’Intuition

L’idée est de modéliser la similarité entre les points de données comme une probabilité : les points proches ont une forte probabilité d’être “choisis” l’un par l’autre, tandis que les points éloignés ont une probabilité très faible. t-SNE tente ensuite de créer une carte en 2D ou 3D où cette distribution de probabilités de voisinage est la mieux préservée possible.

Il utilise pour cela la distribution de Student (t) pour modéliser les similarités dans l’espace de faible dimension, ce qui a pour effet de bien séparer les groupes de points distincts.

2.2 L’Hyperparamètre Clé : perplexity

Le principal paramètre à régler est la perplexity. Il peut être vu comme une estimation du nombre de voisins proches que chaque point considère. Une valeur typique se situe entre 5 et 50. Un choix judicieux de ce paramètre est crucial pour obtenir une bonne visualisation.

Avertissement Crucial sur l’Interprétation

t-SNE est un outil de visualisation, pas d’analyse quantitative.

• La taille des clusters dans un graphique t-SNE n’a pas de signification.
• La distance entre les clusters n’est pas directement interprétable. Deux clusters qui apparaissent éloignés pourraient en réalité être plus proches que deux autres qui semblent plus resserrés.

L’objectif de t-SNE est de répondre à la question : “Quels sont les points qui sont voisins les uns des autres ?”.

3 UMAP : L’Alternative Moderne et Rapide

UMAP (Uniform Manifold Approximation and Projection) est un algorithme plus récent, souvent présenté comme le successeur de t-SNE. Il est basé sur des concepts mathématiques plus avancés (topologie, théorie des variétés), mais son objectif est similaire.

3.1 Avantages par rapport à t-SNE

• Vitesse : UMAP est beaucoup plus rapide que t-SNE, ce qui le rend utilisable sur des jeux de données beaucoup plus grands.
• Préservation de la Structure Globale : En plus de bien préserver les structures locales, UMAP fait souvent un meilleur travail pour conserver la structure globale des données. Les relations entre les clusters (leur proximité relative) sont donc souvent plus significatives qu’avec t-SNE.

Pour ces raisons, UMAP est de plus en plus souvent l’outil de premier choix pour la visualisation non-linéaire.

4 Atelier Pratique : Visualiser les Chiffres Manuscrits

Le jeu de données digits de Scikit-learn est parfait pour cet atelier. Il contient des images de chiffres manuscrits de 0 à 9. Chaque image est de 8x8 pixels, ce qui nous donne un jeu de données à 64 dimensions. Notre but est de visualiser ces 64 dimensions en seulement 2D et de voir si les 10 classes de chiffres forment des groupes distincts.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_digits
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import umap # Assurez-vous d'avoir installé umap-learn : pip install umap-learn

# 1. Charger les données
digits = load_digits()
X, y = digits.data, digits.target

# 2. Mise à l'échelle des données
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Appliquer les 3 méthodes de réduction de dimensionnalité
print("--- Application des algorithmes de réduction de dimensionnalité ---")
print("PCA...")
pca = PCA(n_components=2, random_state=42)
X_pca = pca.fit_transform(X_scaled)

print("t-SNE... (peut prendre un moment)")
tsne = TSNE(n_components=2, perplexity=30, random_state=42)
X_tsne = tsne.fit_transform(X_scaled)

print("UMAP...")
umap_reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, random_state=42)
X_umap = umap_reducer.fit_transform(X_scaled)
print("Terminé.")

# 4. Créer un DataFrame pour la visualisation
df = pd.DataFrame({
    'y': y,
    'PC1': X_pca[:, 0],
    'PC2': X_pca[:, 1],
    'tSNE1': X_tsne[:, 0],
    'tSNE2': X_tsne[:, 1],
    'UMAP1': X_umap[:, 0],
    'UMAP2': X_umap[:, 1]
})

# 5. Visualisation Comparative
fig, axes = plt.subplots(1, 3, figsize=(24, 8))
fig.suptitle('Comparaison des Méthodes de Réduction de Dimensionnalité sur les Données "Digits"', fontsize=20)

# Graphique PCA
sns.scatterplot(x='PC1', y='PC2', hue='y', data=df, palette='Spectral', s=50, alpha=0.8, ax=axes[0])
axes[0].set_title('PCA', fontsize=16)

# Graphique t-SNE
sns.scatterplot(x='tSNE1', y='tSNE2', hue='y', data=df, palette='Spectral', s=50, alpha=0.8, ax=axes[1])
axes[1].set_title('t-SNE', fontsize=16)

# Graphique UMAP
sns.scatterplot(x='UMAP1', y='UMAP2', hue='y', data=df, palette='Spectral', s=50, alpha=0.8, ax=axes[2])
axes[2].set_title('UMAP', fontsize=16)

for ax in axes:
    ax.legend(title='Chiffre')

plt.show()

Interprétation des Résultats

• PCA : La projection linéaire du PCA montre une certaine structure. On peut voir que certains groupes de chiffres (comme le 0, le 6, le 4) commencent à se séparer, mais il y a beaucoup de chevauchement au centre.
• t-SNE : Le résultat est spectaculaire. t-SNE a réussi à “déplier” la structure des données et à former des clusters très distincts et bien séparés pour chacun des 10 chiffres. C’est un exemple parfait de sa capacité à préserver les voisinages locaux.
• UMAP : UMAP produit un résultat très similaire à celui de t-SNE, avec des clusters également très bien définis. Certains pourraient argumenter que la séparation est encore plus nette et que la structure globale est légèrement mieux préservée. De plus, son exécution a été beaucoup plus rapide.

5 Conclusion

Le PCA reste un excellent outil de base, mais lorsque vous êtes confronté à des données complexes et que votre objectif est la visualisation exploratoire, t-SNE et UMAP sont des outils indispensables. Ils vous permettent de créer des cartes 2D intuitives à partir de données de grande dimension, révélant des structures qui seraient autrement invisibles.

• t-SNE est l’outil de référence, célèbre pour ses visualisations esthétiques qui mettent en valeur les groupes.
• UMAP est son successeur moderne, plus rapide et souvent meilleur pour préserver un équilibre entre structure locale et globale.

Et maintenant ?

Nous avons maintenant une boîte à outils complète pour réduire la dimensionnalité de nos données. Dans notre dernier post de cette série, nous allons mettre tout cela en pratique dans un projet de synthèse pour voir comment la réduction de dimensionnalité peut s’intégrer dans un workflow de Machine Learning complet, de la préparation des données à la modélisation.

6 Exercices

Exercise 1  

Question 1

Pourquoi utiliserait-on t-SNE ou UMAP plutôt que le PCA pour la visualisation ?

1. Parce qu’ils sont toujours plus rapides que le PCA.
2. Parce qu’ils sont des méthodes supervisées qui utilisent les étiquettes.
3. Parce qu’ils peuvent révéler des structures complexes et non-linéaires que le PCA ne peut pas capturer.
4. Parce qu’ils sont plus faciles à interpréter quantitativement.

Question 2

Quel est l’objectif principal de l’algorithme t-SNE ?

1. Maximiser la variance globale des données.
2. Préserver la structure de voisinage locale des points.
3. Maximiser la séparation entre des classes prédéfinies.
4. Sélectionner un sous-ensemble des variables originales.

Question 3

Quelle est l’une des mises en garde les plus importantes lors de l’interprétation d’un graphique t-SNE ?

1. Les couleurs des points n’ont aucune signification.
2. La taille des clusters et la distance entre eux ne sont pas directement interprétables.
3. L’algorithme ne fonctionne que pour les données en 2D.
4. Le graphique est toujours le même, peu importe les hyperparamètres.

Question 4

L’hyperparamètre perplexity de t-SNE peut être intuitivement compris comme…

1. …le nombre de dimensions de sortie.
2. …une estimation du nombre de voisins proches que chaque point considère.
3. …le nombre maximum d’itérations de l’algorithme.
4. …la complexité du jeu de données.

Question 5

Quel est le principal avantage de UMAP par rapport à t-SNE ?

1. UMAP est un algorithme linéaire, donc plus simple.
2. UMAP est nettement plus rapide et préserve souvent mieux la structure globale des données.
3. UMAP ne nécessite aucun réglage d’hyperparamètres.
4. UMAP produit toujours des visualisations plus esthétiques.

Question 6

Dans l’atelier pratique sur les chiffres manuscrits, qu’a-t-on observé ?

1. Le PCA a produit la meilleure séparation visuelle des 10 chiffres.
2. Les trois méthodes (PCA, t-SNE, UMAP) ont donné des résultats quasiment identiques.
3. t-SNE et UMAP ont créé des clusters très distincts pour chaque chiffre, surpassant largement le PCA.
4. Seul le PCA a réussi à fonctionner sur ce jeu de données.

Question 7

t-SNE et UMAP sont avant tout des outils pour…

1. …la classification supervisée.
2. …la régression.
3. …la visualisation exploratoire de données.
4. …le nettoyage de données.

Question 8

Pour quel type de données t-SNE et UMAP sont-ils particulièrement adaptés ?

1. Des données avec une structure parfaitement linéaire.
2. Des données formant des structures complexes comme des “lunes” ou des “rubans”.
3. Des jeux de données avec une seule variable.
4. Des données temporelles uniquement.

Question 9

Si deux clusters apparaissent très éloignés sur un graphique t-SNE, que peut-on conclure avec certitude ?

1. Que ces deux groupes sont très dissimilaires dans l’espace d’origine.
2. Qu’il faut être prudent, car la distance inter-cluster n’est pas une mesure fiable.
3. Que le cluster le plus grand est plus dense.
4. Que l’algorithme a échoué.

Question 10

Pourquoi UMAP est-il de plus en plus considéré comme l’outil de premier choix pour la visualisation non-linéaire ?

1. Parce qu’il est plus ancien et mieux établi que t-SNE.
2. Parce qu’il est plus lent mais plus précis.
3. Parce qu’il offre un excellent compromis entre vitesse et qualité de la visualisation (structures locales et globales).
4. Parce qu’il est inclus par défaut dans toutes les bibliothèques Python.