Visualizar datos de alta dimensión con MDS

Introducción

La escalamiento multidimensional (MDS, por sus siglas en inglés) es una técnica que se utiliza para visualizar datos de alta dimensión en un espacio de menor dimensión (por lo general 2D o 3D) mientras se conservan las distancias entre pares de puntos de datos lo máximo posible. A menudo se utiliza en el análisis y visualización exploratoria de datos.

En este tutorial, recorreremos los pasos para realizar MDS en un conjunto de datos ruidoso generado utilizando la biblioteca scikit-learn en Python.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no puede automatizarse debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Importar bibliotecas

En primer lugar, necesitamos importar las bibliotecas necesarias. Utilizaremos numpy, matplotlib, scikit-learn y 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

Generar datos

A continuación, generaremos un conjunto de datos ruidoso utilizando numpy. Generaremos 20 muestras con 2 características cada una.

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()

Añadir ruido a los datos

Luego, añadiremos ruido a las distancias entre pares de puntos de datos utilizando 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

Realizar MDS

Luego, realizaremos MDS en el conjunto de datos ruidoso utilizando la clase MDS de scikit-learn. Utilizaremos la opción de disimilitud precomputada ya que ya hemos calculado las distancias entre pares de puntos de datos. También estableceremos el número de componentes en 2 para la visualización 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_

Realizar MDS no métrico

También realizaremos MDS no métrico en el mismo conjunto de datos para comparación. Utilizaremos las mismas opciones que MDS, excepto que estableceremos la opción métrica en 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)

Reescalar y rotar los datos

Luego, reescalaremos y rotaremos los datos para la visualización utilizando 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)

Visualizar los resultados

Finalmente, visualizaremos los resultados utilizando matplotlib. Graficaremos la posición real de los puntos de datos, la posición de los puntos de datos utilizando MDS y la posición de los puntos de datos utilizando MDS no métrico. También graficaremos las distancias entre pares de puntos de datos utilizando 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()

Resumen

En este tutorial, aprendimos cómo realizar MDS en un conjunto de datos ruidoso utilizando scikit-learn en Python. También aprendimos cómo visualizar los resultados utilizando matplotlib. MDS es una técnica útil para visualizar datos de alta dimensión en un espacio de menor dimensión mientras se conservan las distancias entre pares de puntos de datos lo máximo posible.