Visualiser les données à haute dimension avec l'analyse en composantes principales multi-dimensionnelles (MDS)

Introduction

L'analyse en composantes principales multi-dimensionnelles (MDS) est une technique utilisée pour visualiser des données à haute dimension dans un espace à basse dimension (généralement 2D ou 3D) tout en conservant au maximum les distances entre paires de points de données. Elle est souvent utilisée dans l'analyse exploratoire de données et la visualisation.

Dans ce tutoriel, nous allons parcourir les étapes de réalisation de l'analyse en composantes principales multi-dimensionnelles sur un ensemble de données bruité généré à l'aide de la bibliothèque scikit-learn en Python.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

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

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.

Skills Graph

Importation des bibliothèques

Tout d'abord, nous devons importer les bibliothèques nécessaires. Nous utiliserons numpy, matplotlib, scikit-learn et PCA de scikit-learn.

import numpy as np
from matplotlib import pyplot as plt
from matplotlib.collections import LineCollection
from sklearn import manifold
from sklearn.metrics import euclidean_distances
from sklearn.decomposition import PCA

Générer des données

Ensuite, nous allons générer un ensemble de données bruité à l'aide de numpy. Nous allons générer 20 échantillons avec 2 caractéristiques chacun.

EPSILON = np.finfo(np.float32).eps
n_samples = 20
seed = np.random.RandomState(seed=3)
X_true = seed.randint(0, 20, 2 * n_samples).astype(float)
X_true = X_true.reshape((n_samples, 2))
## Center the data
X_true -= X_true.mean()

Ajouter du bruit aux données

Nous allons ensuite ajouter du bruit aux distances entre paires de points de données à l'aide de numpy.

similarities = euclidean_distances(X_true)

## Add noise to the similarities
noise = np.random.rand(n_samples, n_samples)
noise = noise + noise.T
noise[np.arange(noise.shape[0]), np.arange(noise.shape[0])] = 0
similarities += noise

Effectuer l'analyse en composantes principales multi-dimensionnelles (MDS)

Nous allons ensuite effectuer l'analyse en composantes principales multi-dimensionnelles sur l'ensemble de données bruité à l'aide de la classe MDS de scikit-learn. Nous utiliserons l'option de dissimilarité prédéfinie car nous avons déjà calculé les distances entre paires de points de données. Nous définirons également le nombre de composantes sur 2 pour une visualisation en 2D.

mds = manifold.MDS(
    n_components=2,
    max_iter=3000,
    eps=1e-9,
    random_state=seed,
    dissimilarity="precomputed",
    n_jobs=1,
    normalized_stress="auto",
)
pos = mds.fit(similarities).embedding_

Effectuer l'analyse en composantes principales multi-dimensionnelles non métrique (Non-Metric MDS)

Nous allons également effectuer l'analyse en composantes principales multi-dimensionnelles non métrique sur le même ensemble de données pour la comparaison. Nous utiliserons les mêmes options que pour l'analyse en composantes principales multi-dimensionnelles, sauf que nous définirons l'option métrique sur False.

nmds = manifold.MDS(
    n_components=2,
    metric=False,
    max_iter=3000,
    eps=1e-12,
    dissimilarity="precomputed",
    random_state=seed,
    n_jobs=1,
    n_init=1,
    normalized_stress="auto",
)
npos = nmds.fit_transform(similarities, init=pos)

Rééchelle et faites tourner les données

Nous allons ensuite rééchelle et faire tourner les données pour la visualisation à l'aide de l'Analyse en Composantes Principales (PCA) de scikit-learn.

## Rescale the data
pos *= np.sqrt((X_true**2).sum()) / np.sqrt((pos**2).sum())
npos *= np.sqrt((X_true**2).sum()) / np.sqrt((npos**2).sum())

## Rotate the data
clf = PCA(n_components=2)
X_true = clf.fit_transform(X_true)
pos = clf.fit_transform(pos)
npos = clf.fit_transform(npos)

Visualiser les résultats

Enfin, nous allons visualiser les résultats à l'aide de matplotlib. Nous tracerons la position réelle des points de données, la position des points de données en utilisant l'analyse en composantes principales multi-dimensionnelles (MDS) et la position des points de données en utilisant l'analyse en composantes principales multi-dimensionnelles non métrique (Non-Metric MDS). Nous tracerons également les distances entre paires de points de données à l'aide de LineCollection de matplotlib.

fig = plt.figure(1)
ax = plt.axes([0.0, 0.0, 1.0, 1.0])

s = 100
plt.scatter(X_true[:, 0], X_true[:, 1], color="navy", s=s, lw=0, label="True Position")
plt.scatter(pos[:, 0], pos[:, 1], color="turquoise", s=s, lw=0, label="MDS")
plt.scatter(npos[:, 0], npos[:, 1], color="darkorange", s=s, lw=0, label="NMDS")
plt.legend(scatterpoints=1, loc="best", shadow=False)

similarities = similarities.max() / (similarities + EPSILON) * 100
np.fill_diagonal(similarities, 0)
## Plot the edges
start_idx, end_idx = np.where(pos)
## a sequence of (*line0*, *line1*, *line2*), where::
##            linen = (x0, y0), (x1, y1),... (xm, ym)
segments = [
    [X_true[i, :], X_true[j, :]] for i in range(len(pos)) for j in range(len(pos))
]
values = np.abs(similarities)
lc = LineCollection(
    segments, zorder=0, cmap=plt.cm.Blues, norm=plt.Normalize(0, values.max())
)
lc.set_array(similarities.flatten())
lc.set_linewidths(np.full(len(segments), 0.5))
ax.add_collection(lc)

plt.show()

Résumé

Dans ce tutoriel, nous avons appris comment effectuer l'analyse en composantes principales multi-dimensionnelles (MDS) sur un ensemble de données bruité à l'aide de scikit-learn en Python. Nous avons également appris comment visualiser les résultats à l'aide de matplotlib. L'analyse en composantes principales multi-dimensionnelles est une technique utile pour visualiser des données à haute dimension dans un espace de dimension inférieure tout en conservant au maximum les distances entre paires de points de données.