Introduction
Dans ce laboratoire, nous allons apprendre à transformer des caractéristiques en un espace creux de dimension plus élevée à l'aide d'un ensemble d'arbres. Nous allons ensuite entraîner un modèle linéaire sur ces caractéristiques. Nous utiliserons différents types de méthodes d'ensemble, y compris la forêt aléatoire et le gradient boosting, et comparerons leurs performances.
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 pratiquer.
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.
Préparation des données
Tout d'abord, nous allons créer un grand ensemble de données de 80 000 échantillons et le diviser en trois ensembles :
- Un ensemble pour entraîner les méthodes d'ensemble qui seront ultérieurement utilisées comme un transformateur d'ingénierie des caractéristiques
- Un ensemble pour entraîner le modèle linéaire
- Un ensemble pour tester le modèle linéaire.
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(n_samples=80_000, random_state=10)
X_full_train, X_test, y_full_train, y_test = train_test_split(
X, y, test_size=0.5, random_state=10
)
X_train_ensemble, X_train_linear, y_train_ensemble, y_train_linear = train_test_split(
X_full_train, y_full_train, test_size=0.5, random_state=10
)
Entraînement des méthodes d'ensemble
Pour chacune des méthodes d'ensemble, nous utiliserons 10 estimateurs et une profondeur maximale de 3 niveaux.
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
n_estimators = 10
max_depth = 3
random_forest = RandomForestClassifier(
n_estimators=n_estimators, max_depth=max_depth, random_state=10
)
random_forest.fit(X_train_ensemble, y_train_ensemble)
gradient_boosting = GradientBoostingClassifier(
n_estimators=n_estimators, max_depth=max_depth, random_state=10
)
_ = gradient_boosting.fit(X_train_ensemble, y_train_ensemble)
Entraînement du transformateur d'imbrication
RandomTreesEmbedding est une méthode non supervisée et ne nécessite pas d'être entraînée indépendamment.
from sklearn.ensemble import RandomTreesEmbedding
random_tree_embedding = RandomTreesEmbedding(
n_estimators=n_estimators, max_depth=max_depth, random_state=0
)
rt_model = make_pipeline(random_tree_embedding, LogisticRegression(max_iter=1000))
rt_model.fit(X_train_linear, y_train_linear)
Transformation des caractéristiques avec la forêt aléatoire et le gradient boosting
Maintenant, nous allons créer deux pipelines qui utiliseront l'imbrication ci-dessus comme étape de prétraitement. La transformation des caractéristiques se produira en appelant la méthode apply. Nous allons ensuite combiner la forêt aléatoire ou le gradient boosting avec une régression logistique dans un pipeline. Cependant, le pipeline dans scikit-learn attend un appel à transform. Par conséquent, nous avons encapsulé l'appel à apply dans un FunctionTransformer.
from sklearn.preprocessing import FunctionTransformer
from sklearn.preprocessing import OneHotEncoder
def rf_apply(X, model):
return model.apply(X)
rf_leaves_yielder = FunctionTransformer(rf_apply, kw_args={"model": random_forest})
rf_model = make_pipeline(
rf_leaves_yielder,
OneHotEncoder(handle_unknown="ignore"),
LogisticRegression(max_iter=1000),
)
rf_model.fit(X_train_linear, y_train_linear)
def gbdt_apply(X, model):
return model.apply(X)[:, :, 0]
gbdt_leaves_yielder = FunctionTransformer(
gbdt_apply, kw_args={"model": gradient_boosting}
)
gbdt_model = make_pipeline(
gbdt_leaves_yielder,
OneHotEncoder(handle_unknown="ignore"),
LogisticRegression(max_iter=1000),
)
gbdt_model.fit(X_train_linear, y_train_linear)
Évaluation des modèles
Nous pouvons finalement afficher les différentes courbes ROC pour tous les modèles.
import matplotlib.pyplot as plt
from sklearn.metrics import RocCurveDisplay
fig, ax = plt.subplots()
models = [
("RT embedding -> LR", rt_model),
("RF", random_forest),
("RF embedding -> LR", rf_model),
("GBDT", gradient_boosting),
("GBDT embedding -> LR", gbdt_model),
]
model_displays = {}
for name, pipeline in models:
model_displays[name] = RocCurveDisplay.from_estimator(
pipeline, X_test, y_test, ax=ax, name=name
)
_ = ax.set_title("ROC curve")
Sommaire
Dans ce laboratoire, nous avons appris à transformer les caractéristiques dans un espace sparse de dimension plus élevée à l'aide d'un ensemble d'arbres. Nous avons utilisé différents types de méthodes d'ensemble, y compris la forêt aléatoire et le gradient boosting, et comparé leurs performances. RandomTreesEmbedding est une méthode non supervisée et ne nécessite pas d'être entraînée indépendamment. Nous avons également appris à combiner la forêt aléatoire ou le gradient boosting avec une régression logistique à l'aide de FunctionTransformer. Enfin, nous avons évalué les performances de tous les modèles à l'aide de courbes ROC.