Kategorie: Deep Learning

t-Distributed Stochastic Neighbor Embedding (t-SNE) ist eine Methode zur Visualisierung von Daten, die in der Datenanalyse und im Machine Learning verwendet wird. t-SNE wurde von Laurens van der Maaten und Geoffrey Hinton entwickelt und ist eine Erweiterung der Stochastic Neighbor Embedding (SNE)-Methode.

Das Ziel von t-SNE ist es, eine hochdimensionale Datenstruktur in eine niedrigdimensionale Darstellung zu transformieren, die leichter interpretierbar ist. t-SNE erreicht dies, indem es eine Wahrscheinlichkeitsverteilung über Paare von Datenpunkten in der hochdimensionalen und niedrigdimensionalen Darstellung modelliert und versucht, die Kullback-Leibler-Divergenz zwischen diesen Verteilungen zu minimieren.

In diesem Beitrag werden wir die Schritte zur Implementierung von t-SNE in Python erläutern.

Schritt 1: Laden der Daten und Vorbereitung: Der erste Schritt bei der Implementierung von t-SNE besteht darin, die Daten zu laden und vorzubereiten. Wir verwenden den Iris-Datensatz als Beispiel. Der Datensatz besteht aus 150 Blumen, von denen jede 4 Merkmale (Länge und Breite von Kelch- und Kronblättern) aufweist und in 3 Klassen unterteilt ist.

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target

Schritt 2: Skalieren der Daten: Da t-SNE ein Verfahren der linearen Algebra ist, ist es wichtig, dass alle Merkmale auf den gleichen Skalen liegen. Wir skalieren die Daten, um sicherzustellen, dass die Merkmale auf die gleiche Weise beitragen.

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Schritt 3: Durchführen von t-SNE: Als nächstes führen wir t-SNE mit den skalierten Daten durch. Wir verwenden die TSNE-Klasse aus der Scikit-learn-Bibliothek und setzen den Parameter n_components auf die Anzahl der Dimensionen, auf die wir die Daten reduzieren möchten.

from sklearn.manifold import TSNE
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X_scaled)

Schritt 4: Visualisierung der Ergebnisse: Nachdem wir t-SNE durchgeführt haben, können wir die Ergebnisse visualisieren. Wir verwenden Matplotlib, um eine Streudiagramm der Datenpunkte zu zeichnen und die Punkte nach ihrer Klassenzugehörigkeit zu färben.

import matplotlib.pyplot as plt
plt.scatter(X_tsne[:,0], X_tsne[:,1], c=y)
plt.xlabel('t-SNE Dimension 1')
plt.ylabel('t-SNE Dimension 2')
plt.show()

Das Ergebnis von t-SNE ist ein zweidimensionaler Datensatz, der aus den beiden t-SNE-Dimensionen besteht. Wir können sehen, dass die drei verschiedenen Klassen von Blumen voneinander getrennt sind, was darauf hindeutet, dass t-SNE eine gute Arbeit bei der Visualisierung der Daten geleistet hat.

Das ist eine grundlegende Implementierung von t-Distributed Stochastic Neighbor Embedding in Python. Beachten Sie, dass es viele andere Möglichkeiten gibt, den Algorithmus anzupassen und zu erweitern, um eine bessere Vorhersagegenauigkeit zu erzielen.

Schritt 5: Anpassung der Hyperparameter: Wie bei jedem Machine-Learning-Algorithmus ist es wichtig, die Hyperparameter zu optimieren, um die Leistung des Modells zu verbessern. Bei t-SNE gibt es zwei wichtige Hyperparameter: die Perplexität (perplexity) und die Anzahl der Iterationen (n_iter).

Die Perplexität kontrolliert, wie eng die Wahrscheinlichkeitsverteilungen in der niedrigdimensionalen Darstellung sind. Eine höhere Perplexität führt zu einer glatteren Verteilung, während eine niedrigere Perplexität zu einer spitzen Verteilung führt. Die Anzahl der Iterationen bestimmt, wie viele Iterationen des Gradientenabstiegs durchgeführt werden sollen.

Wir können eine Schleife verwenden, um verschiedene Werte für perplexity und n_iter auszuprobieren und die Leistung des Modells zu evaluieren.

import numpy as np
perplexities = [5, 10, 20, 30, 40, 50]
n_iters = [250, 500, 750, 1000, 1500, 2000]
best_score = np.inf
best_params = {}
for p in perplexities:
    for n in n_iters:
        tsne = TSNE(n_components=2, perplexity=p, n_iter=n, random_state=42)
        X_tsne = tsne.fit_transform(X_scaled)
        score = tsne.kl_divergence_
        if score < best_score:
            best_score = score
            best_params['perplexity'] = p
            best_params['n_iter'] = n
print("Best Parameters:", best_params)
print("Best Score:", best_score)

In diesem Beispiel verwenden wir eine Schleife, um verschiedene Kombinationen von perplexity und n_iter auszuprobieren und die beste Kombination von Hyperparametern zu finden. Die kl_divergence_-Eigenschaft von t-SNE gibt an, wie gut die niedrigdimensionale Darstellung den Daten entspricht. Wir wählen die Kombination von Hyperparametern aus, die den niedrigsten Wert für kl_divergence_ hat.

Schritt 6: Verwendung von t-SNE mit anderen Algorithmen: t-SNE kann als Vorverarbeitungsschritt für viele Machine-Learning-Algorithmen verwendet werden, um die Leistung zu verbessern und die Rechenzeit zu reduzieren. Wir können die niedrigdimensionale Darstellung von t-SNE als Eingabe für andere Algorithmen verwenden, wie z.B. k-Means-Clustering oder Support Vector Machines (SVM).

from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3)
kmeans.fit(X_tsne)
y_pred = kmeans.predict(X_tsne)
plt.scatter(X_tsne[:,0], X_tsne[:,1], c=y_pred)
plt.xlabel('t-SNE Dimension 1')
plt.ylabel('t-SNE Dimension 2')
plt.show()

In diesem Beispiel verwenden wir t-SNE als Vorverarbeitungsschritt für k-Means-Clustering. Wir trainieren den k-Means-Clustering-Algorithmus mit der niedrigdimensionalen Darstellung von t-SNE und färben die Punkte entsprechend den zugewiesenen Clustern. Wir können sehen, dass die Clustergrenzen in der niedrigdimensionalen Darstellung deutlicher sind als in der ursprünglichen hochdimensionalen Darstellung.

Das ist eine grundlegende Implementierung von t-Distributed Stochastic Neighbor Embedding in Python. t-SNE kann als mächtiges Werkzeug zur Visualisierung und Vorverarbeitung von Daten verwendet werden, um die Leistung von Machine-Learning-Modellen zu verbessern und ein besseres Verständnis der Daten zu ermöglichen. Beachten Sie jedoch, dass t-SNE eine nichtlineare Methode ist und daher nicht immer die beste Wahl für alle Datensätze ist. Es ist wichtig, verschiedene Visualisierungsmethoden auszuprobieren und diejenige auszuwählen, die am besten für den jeweiligen Datensatz geeignet ist.