Mehrdimensionale Skalierung auf sphärischen Daten

Einführung

Das Manifold Learning ist ein Teilgebiet der Maschinellen Lerntechniken, das sich mit dem Lernen der zugrunde liegenden Struktur von hochdimensionalen Daten befasst. In diesem Lab werden wir verschiedene Manifold Learning-Techniken auf einem sphärischen Datensatz anwenden. Wir werden die Dimensionsreduzierung verwenden, um einige Intuition bezüglich der Manifold Learning-Methoden zu gewinnen.

VM-Tipps

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Bibliotheken importieren

Wir beginnen mit dem Import der erforderlichen Bibliotheken. Wir werden scikit-learn, matplotlib und numpy verwenden.

from time import time
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import NullFormatter
from sklearn import manifold
from sklearn.utils import check_random_state

import mpl_toolkits.mplot3d

Sphärischen Datensatz erstellen

Als nächstes werden wir einen sphärischen Datensatz erstellen. Wir werden eine Kugel erstellen, die Pole abtrennen und einen dünnen Schnitt entlang ihrer Seite vornehmen. Dies wird es den Manifold Learning-Techniken ermöglichen, es "aufzuspannen", während es auf zwei Dimensionen projiziert wird.

n_neighbors = 10
n_samples = 1000

random_state = check_random_state(0)
p = random_state.rand(n_samples) * (2 * np.pi - 0.55)
t = random_state.rand(n_samples) * np.pi

indices = (t < (np.pi - (np.pi / 8))) & (t > ((np.pi / 8)))
colors = p[indices]
x, y, z = (
    np.sin(t[indices]) * np.cos(p[indices]),
    np.sin(t[indices]) * np.sin(p[indices]),
    np.cos(t[indices]),
)

fig = plt.figure(figsize=(15, 8))
plt.suptitle(
    "Manifold Learning with %i points, %i neighbors" % (1000, n_neighbors), fontsize=14
)

ax = fig.add_subplot(251, projection="3d")
ax.scatter(x, y, z, c=p[indices], cmap=plt.cm.rainbow)
ax.view_init(40, -10)

sphere_data = np.array([x, y, z]).T

Lokale lineare Einbettung (Locally Linear Embedding, LLE) als Manifold Learning durchführen

Wir werden nun die Lokale lineare Einbettung (LLE) als Manifold Learning durchführen. LLE ist eine leistungsstarke Technik, die es ermöglicht, komplizierte Mannigfaltigkeiten mit einer geringen Anzahl von Proben aufzudecken. Wir werden vier Variationen von LLE verwenden und deren Ergebnisse vergleichen.

methods = ["standard", "ltsa", "hessian", "modified"]
labels = ["LLE", "LTSA", "Hessian LLE", "Modified LLE"]

for i, method in enumerate(methods):
    t0 = time()
    trans_data = (
        manifold.LocallyLinearEmbedding(
            n_neighbors=n_neighbors, n_components=2, method=method
        )
     .fit_transform(sphere_data)
     .T
    )
    t1 = time()
    print("%s: %.2g sec" % (methods[i], t1 - t0))

    ax = fig.add_subplot(252 + i)
    plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
    plt.title("%s (%.2g sec)" % (labels[i], t1 - t0))
    ax.xaxis.set_major_formatter(NullFormatter())
    ax.yaxis.set_major_formatter(NullFormatter())
    plt.axis("tight")

Isomap Manifold Learning durchführen

Als nächstes werden wir das Isomap Manifold Learning durchführen. Isomap ist eine nichtlineare Dimensionsreduktionstechnik, die eine niedrigerdimensionale Einbettung der Daten sucht, die die geodätischen Distanzen zwischen allen Punktpaaren aufrechterhält.

t0 = time()
trans_data = (
    manifold.Isomap(n_neighbors=n_neighbors, n_components=2)
  .fit_transform(sphere_data)
  .T
)
t1 = time()
print("%s: %.2g sec" % ("ISO", t1 - t0))

ax = fig.add_subplot(257)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("%s (%.2g sec)" % ("Isomap", t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")

Mehrdimensionale Skalierung (Multi-dimensional Scaling, MDS) durchführen

Wir werden nun die Mehrdimensionale Skalierung (MDS) als Manifold Learning durchführen. MDS ist eine Technik, die eine niedrigdimensionale Darstellung der Daten sucht, in der die Distanzen zwischen den Punkten den Distanzen im ursprünglichen hochdimensionalen Raum entsprechen.

t0 = time()
mds = manifold.MDS(2, max_iter=100, n_init=1, normalized_stress="auto")
trans_data = mds.fit_transform(sphere_data).T
t1 = time()
print("MDS: %.2g sec" % (t1 - t0))

ax = fig.add_subplot(258)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("MDS (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")

Spektrale Einbettung (Spectral Embedding) durchführen

Als nächstes werden wir die Spektrale Einbettung als Manifold Learning durchführen. Die Spektrale Einbettung ist eine Technik, die eine niedrigdimensionale Darstellung der Daten sucht, die die paarweisen Distanzen zwischen den Punkten erhält.

t0 = time()
se = manifold.SpectralEmbedding(n_components=2, n_neighbors=n_neighbors)
trans_data = se.fit_transform(sphere_data).T
t1 = time()
print("Spectral Embedding: %.2g sec" % (t1 - t0))

ax = fig.add_subplot(259)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("Spectral Embedding (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")

t-verteilte stochastische Nachbar-Einbettung (t-distributed Stochastic Neighbor Embedding, t-SNE) durchführen

Schließlich werden wir die t-verteilte stochastische Nachbar-Einbettung (t-SNE) als Manifold Learning durchführen. t-SNE ist eine Technik, die eine niedrigdimensionale Darstellung der Daten sucht, die die lokalen Distanzen zwischen den Punkten erhält.

t0 = time()
tsne = manifold.TSNE(n_components=2, random_state=0)
trans_data = tsne.fit_transform(sphere_data).T
t1 = time()
print("t-SNE: %.2g sec" % (t1 - t0))

ax = fig.add_subplot(2, 5, 10)
plt.scatter(trans_data[0], trans_data[1], c=colors, cmap=plt.cm.rainbow)
plt.title("t-SNE (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter())
ax.yaxis.set_major_formatter(NullFormatter())
plt.axis("tight")

plt.show()

Zusammenfassung

In diesem Lab haben wir verschiedene Manifold Learning-Techniken auf einem sphärischen Datensatz angewendet. Wir haben die Locally Linear Embedding (LLE), Isomap, Mehrdimensionale Skalierung (MDS), Spektrale Einbettung und t-verteilte stochastische Nachbar-Einbettung (t-SNE) verwendet, um einige Intuitionen zu den Manifold Learning-Methoden zu gewinnen. Diese Techniken sind nützlich für die Analyse und Visualisierung von hochdimensionalen Daten.