Transformation de fonctionnalités par hachage

Introduction

Ce laboratoire montre comment utiliser la transformation de fonction de hachage à l'aide d'arbres totalement aléatoires pour mapper les données à une représentation haute dimensionnelle et sparse qui peut être utile pour la classification. La carte est entièrement non supervisée et très efficace.

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 la pratique.

Parfois, vous devrez peut-être 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 votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Dans cette étape, nous allons importer les bibliothèques nécessaires pour ce laboratoire.

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

Création d'un ensemble de données synthétique

Dans cette étape, nous allons créer un ensemble de données synthétique.

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

Utiliser RandomTreesEmbedding pour transformer les données

Dans cette étape, nous allons utiliser RandomTreesEmbedding pour transformer les données.

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

Visualiser le résultat après la réduction de dimension avec Truncated SVD

Dans cette étape, nous allons visualiser le résultat après la réduction de dimension avec Truncated SVD.

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

Apprendre un classifieur Naive Bayes sur les données transformées

Dans cette étape, nous allons apprendre un classifieur Naive Bayes sur les données transformées.

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

Apprendre un ExtraTreesClassifier pour la comparaison

Dans cette étape, nous allons apprendre un ExtraTreesClassifier pour la comparaison.

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

Nuage de points de données originales et réduites

Dans cette étape, nous allons créer un nuage de points de données originales et réduites.

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("Données originales (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(
    "Réduction par Truncated SVD (2d) des données transformées (%dd)" % X_transformed.shape[1]
)
ax.set_xticks(())
ax.set_yticks(())

Tracer la décision dans l'espace d'origine

Dans cette étape, nous allons tracer la décision dans l'espace d'origine.

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

## transformer la grille à l'aide de 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 sur les données transformées")
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(())

## transformer la grille à l'aide de ExtraTreesClassifier
y_grid_pred = trees.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]

ax = plt.subplot(224)
ax.set_title("Prédictions ExtraTrees")
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(())

Sommaire

Dans ce laboratoire, nous avons appris à utiliser la transformation de fonctionnalités par hachage à l'aide d'arbres totalement aléatoires pour mapper les données à une représentation haute dimensionnelle et creuse qui peut être utile pour la classification. Nous avons également appris à visualiser les partitions données par plusieurs arbres et comment la transformation peut être utilisée pour la réduction non linéaire de la dimensionalité ou la classification non linéaire. Nous avons ensuite démontré comment utiliser Naive Bayes sur les données transformées et l'avons comparé à un ExtraTreesClassifier appris sur les données originales.