Hashing Feature Transformation

Einführung

In diesem Lab wird gezeigt, wie die Hash-Funktionsumwandlung mit vollkommen zufälligen Bäumen verwendet wird, um Daten in eine hochdimensionale, dünn besetzte Darstellung zu kartieren, die für die Klassifizierung nützlich sein kann. Die Kartierung ist vollständig unüberwacht und sehr effizient.

Tipps für die VM

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 der 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

In diesem Schritt importieren wir die erforderlichen Bibliotheken für dieses Lab.

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import make_circles
from sklearn.ensemble import RandomTreesEmbedding, ExtraTreesClassifier
from sklearn.decomposition import TruncatedSVD
from sklearn.naive_bayes import BernoulliNB

Synthetisches Dataset erstellen

In diesem Schritt erstellen wir ein synthetisches Dataset.

X, y = make_circles(factor=0.5, random_state=0, noise=0.05)

Verwenden von RandomTreesEmbedding zum Transformieren von Daten

In diesem Schritt werden wir RandomTreesEmbedding verwenden, um die Daten zu transformieren.

hasher = RandomTreesEmbedding(n_estimators=10, random_state=0, max_depth=3)
X_transformed = hasher.fit_transform(X)

Visualisierung des Ergebnisses nach der Dimensionalitätsreduzierung mit Truncated SVD

In diesem Schritt werden wir das Ergebnis nach der Dimensionalitätsreduzierung mit Truncated SVD visualisieren.

svd = TruncatedSVD(n_components=2)
X_reduced = svd.fit_transform(X_transformed)

Lernen eines Naiven Bayes - Klassifikators auf den transformierten Daten

In diesem Schritt werden wir einen Naiven Bayes - Klassifikator auf den transformierten Daten lernen.

nb = BernoulliNB()
nb.fit(X_transformed, y)

Lernen eines ExtraTreesClassifier zum Vergleich

In diesem Schritt werden wir einen ExtraTreesClassifier lernen, um einen Vergleich durchzuführen.

trees = ExtraTreesClassifier(max_depth=3, n_estimators=10, random_state=0)
trees.fit(X, y)

Streudiagramm von ursprünglichen und reduzierten Daten

In diesem Schritt werden wir ein Streudiagramm von ursprünglichen und reduzierten Daten erstellen.

fig = plt.figure(figsize=(9, 8))

ax = plt.subplot(221)
ax.scatter(X[:, 0], X[:, 1], c=y, s=50, edgecolor="k")
ax.set_title("Original Data (2d)")
ax.set_xticks(())
ax.set_yticks(())

ax = plt.subplot(222)
ax.scatter(X_reduced[:, 0], X_reduced[:, 1], c=y, s=50, edgecolor="k")
ax.set_title(
    "Truncated SVD reduction (2d) of transformed data (%dd)" % X_transformed.shape[1]
)
ax.set_xticks(())
ax.set_yticks(())

Plot der Entscheidung im ursprünglichen Raum

In diesem Schritt werden wir die Entscheidung im ursprünglichen Raum plotten.

h = 0.01
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

## transform grid using RandomTreesEmbedding
transformed_grid = hasher.transform(np.c_[xx.ravel(), yy.ravel()])
y_grid_pred = nb.predict_proba(transformed_grid)[:, 1]

ax = plt.subplot(223)
ax.set_title("Naive Bayes on Transformed data")
ax.pcolormesh(xx, yy, y_grid_pred.reshape(xx.shape))
ax.scatter(X[:, 0], X[:, 1], c=y, s=50, edgecolor="k")
ax.set_ylim(-1.4, 1.4)
ax.set_xlim(-1.4, 1.4)
ax.set_xticks(())
ax.set_yticks(())

## transform grid using ExtraTreesClassifier
y_grid_pred = trees.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]

ax = plt.subplot(224)
ax.set_title("ExtraTrees predictions")
ax.pcolormesh(xx, yy, y_grid_pred.reshape(xx.shape))
ax.scatter(X[:, 0], X[:, 1], c=y, s=50, edgecolor="k")
ax.set_ylim(-1.4, 1.4)
ax.set_xlim(-1.4, 1.4)
ax.set_xticks(())
ax.set_yticks(())

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Transformation von Merkmalen mit Hilfe von völlig zufälligen Bäumen verwendet, um Daten in eine hochdimensionale, dünn besetzte Repräsentation zu kartieren, die für die Klassifizierung nützlich sein kann. Wir haben auch gelernt, wie man die Partitionen visualisiert, die von mehreren Bäumen gegeben werden, und wie die Transformation für die nichtlineare Dimensionsreduzierung oder die nichtlineare Klassifizierung verwendet werden kann. Anschließend haben wir gezeigt, wie man Naiven Bayes auf den transformierten Daten anwendet und ihn mit einem auf den ursprünglichen Daten gelernten ExtraTreesClassifier verglichen.