Relever les défis des données manquantes avec XGBoost

XGBoost a acquis une large reconnaissance pour ses performances impressionnantes dans de nombreux concours Kaggle, ce qui en fait un choix privilégié pour relever les défis complexes d'apprentissage automatique. Connu pour son efficacité dans le traitement de grands ensembles de données, ce puissant algorithme se distingue par sa praticité et son efficacité.

Dans cet article, nous appliquerons XGBoost à l'ensemble de données Ames Housing pour démontrer ses capacités uniques. En nous appuyant sur notre discussion précédente sur le Gradient Boosting Regressor (GBR), nous explorerons les fonctionnalités clés qui différencient XGBoost du GBR, y compris son approche avancée de la gestion des valeurs manquantes et des données catégorielles.

Commençons.

Aperçu

Cet article est divisé en quatre parties ; ils sont:

Introduction à XGBoost et configuration initiale
Démonstration de la gestion native des valeurs manquantes par XGBoost
Démonstration de la gestion native des données catégorielles par XGBoost
Optimisation de XGBoost avec RFECV pour la sélection des fonctionnalités

Introduction à XGBoost et configuration initiale

XGBoost, qui signifie eXtreme Gradient Boosting, est une implémentation open source optimisée et très efficace de l'algorithme d'amplification de gradient. Il s'agit d'une bibliothèque d'apprentissage automatique populaire conçue pour la vitesse, les performances et l'évolutivité.

Contrairement à la plupart des outils d'apprentissage automatique que vous connaissez peut-être dans la bibliothèque scikit-learn, XGBoost fonctionne de manière indépendante. Pour installer XGBoost, vous devrez installer Python sur votre système. Une fois que c'est prêt, vous pouvez installer XGBoost à l'aide de pip, le programme d'installation du package Python. Ouvrez votre ligne de commande ou votre terminal et entrez la commande suivante :

pip install xgboost

Cette commande téléchargera et installera le package XGBoost et ses dépendances.

Bien que XGBoost et le Gradient Boosting Regressor (GBR) soient tous deux basés sur l'augmentation du gradient, il existe des différences clés qui distinguent XGBoost :

Gère les valeurs manquantes : XGBoost a une approche avancée pour gérer les valeurs manquantes. Par défaut, XGBoost apprend intelligemment la meilleure direction pour gérer les valeurs manquantes pendant la formation, alors que GBR exige que toutes les valeurs manquantes soient gérées en externe avant d'ajuster le modèle.
Prend en charge les fonctionnalités catégorielles de manière native : contrairement au régresseur d'amplification de gradient dans scikit-learn, qui nécessite que les variables catégorielles soient prétraitées dans des formats numériques ; XGBoost peut gérer directement les fonctionnalités catégorielles.
Incorpore la régularisation : L'une des fonctionnalités uniques de XGBoost est son composant de régularisation intégré. Contrairement à GBR, XGBoost applique à la fois la régularisation L1 et L2, ce qui permet de réduire le surajustement et d'améliorer les performances du modèle, en particulier sur des ensembles de données complexes.

Cette liste préliminaire met en évidence certains des principaux avantages de XGBoost par rapport au gradient Boosting Regressor traditionnel. Il est important de noter que ces points ne sont pas exhaustifs mais visent à vous donner une idée de quelques distinctions importantes à prendre en compte lors du choix d’un algorithme pour vos projets de machine learning.

Démonstration de la gestion native des valeurs manquantes par XGBoost

En apprentissage automatique, la manière dont nous traitons les valeurs manquantes peut avoir un impact significatif sur les performances de nos modèles. Traditionnellement, des techniques telles que l'imputation (remplissage des valeurs manquantes avec la moyenne, la médiane ou le mode d'une colonne) sont utilisées avant d'introduire les données dans la plupart des algorithmes. Cependant, XGBoost offre une alternative intéressante en gérant nativement les valeurs manquantes pendant le processus de formation du modèle. Cette fonctionnalité simplifie non seulement le pipeline de prétraitement, mais peut également conduire à des modèles plus robustes en tirant parti des capacités intégrées de XGBoost.

L'extrait de code suivant montre comment XGBoost peut être utilisé avec des ensembles de données contenant des valeurs manquantes sans aucune imputation préalable :

# Import XGBoost to demonstrate native handling of missing values
import pandas as pd
import xgboost as xgb
from sklearn.model_selection import cross_val_score

# Load the dataset
Ames = pd.read_csv('Ames.csv')

# Select numeric features with missing values
cols_with_missing = Ames.isnull().any()
X = Ames.loc[:, cols_with_missing].select_dtypes(include=['int', 'float'])
y = Ames['SalePrice']

# Check and print the total number of missing values
total_missing_values = X.isna().sum().sum()
print(f"Total number of missing values: {total_missing_values}")

# Initialize XGBoost regressor with default settings, emphasizing the seed for reproducibility
xgb_model = xgb.XGBRegressor(seed=42)

# Perform 5-fold cross-validation
scores = cross_val_score(xgb_model, X, y, cv=5, scoring='r2')

# Calculate and display the average R-squared score
mean_r2 = scores.mean()
print(f"XGB with native imputing, average R² score: {mean_r2:.4f}")

Ce bloc de code devrait afficher :

Total number of missing values: 829
XGB with native imputing, average R² score: 0.7547

Dans l'exemple ci-dessus, XGBoost est appliqué directement aux colonnes numériques contenant des données manquantes. Notamment, aucune mesure n'a été prise pour imputer ou supprimer ces valeurs manquantes avant la formation du modèle. Cette capacité est particulièrement utile dans les scénarios réels où les données contiennent souvent des valeurs manquantes et où l'imputation manuelle peut introduire des biais ou du bruit indésirable.

L'approche de XGBoost en matière de gestion des valeurs manquantes simplifie non seulement le processus de préparation des données, mais améliore également la capacité du modèle à traiter des données désordonnées du monde réel. Cette fonctionnalité, entre autres, fait de XGBoost un outil puissant dans l'arsenal de tout data scientist, en particulier lorsqu'il s'agit de grands ensembles de données ou d'ensembles de données contenant des informations incomplètes.

Démonstration de la gestion native des données catégorielles par XGBoost

La gestion efficace des données catégorielles est cruciale dans l’apprentissage automatique, car elles contiennent souvent des informations précieuses qui peuvent influencer de manière significative les prédictions du modèle. Les modèles traditionnels nécessitent que les données catégorielles soient converties en formats numériques, comme l'encodage à chaud, avant la formation. Cela peut conduire à un espace de fonctionnalités de grande dimension, en particulier avec des fonctionnalités comportant plusieurs niveaux. XGBoost, cependant, peut gérer directement les variables catégorielles lorsqu'elles sont converties en type de données category dans pandas. Cela peut entraîner des gains de performances et une utilisation plus efficace de la mémoire.

Nous pouvons commencer par sélectionner quelques fonctionnalités catégorielles. Considérons des fonctionnalités telles que « Neighbourhood », « BldgType » et « HouseStyle ». Ces caractéristiques sont choisies en fonction de leur impact potentiel sur la variable cible, qui dans notre cas est le prix de l'immobilier.

# Demonstrate native handling of categorical features
import pandas as pd
import xgboost as xgb
from sklearn.model_selection import cross_val_score

# Load the dataset
Ames = pd.read_csv('Ames.csv')

# Convert specified categorical features to 'category' type
for col in ['Neighborhood', 'BldgType', 'HouseStyle']:
    Ames[col] = Ames[col].astype('category')

# Include some numeric features for a balanced model
selected_features = ['OverallQual', 'GrLivArea', 'YearBuilt', 'TotalBsmtSF', '1stFlrSF',
                     'Neighborhood', 'BldgType', 'HouseStyle']
X = Ames[selected_features]
y = Ames['SalePrice']

# Initialize XGBoost regressor with native handling for categorical data
xgb_model = xgb.XGBRegressor(
    seed=42,
    enable_categorical=True
)

# Perform 5-fold cross-validation
scores = cross_val_score(xgb_model, X, y, cv=5, scoring='r2')

# Calculate the average R-squared score
mean_r2 = scores.mean()

print(f"Average model R² score with selected categorical features: {mean_r2:.4f}")

Dans cette configuration, nous activons l'option enable_categorical=True dans la configuration de XGBoost. Ce paramètre est crucial car il demande à XGBoost de traiter les fonctionnalités marquées comme « catégorie » dans leur forme native, en tirant parti de ses optimisations internes pour la gestion des données catégorielles. Le résultat de notre modèle est présenté ci-dessous :

Average model R² score with selected categorical features: 0.8543

Ce score reflète une performance modérée tout en gérant directement les fonctionnalités catégorielles sans étapes de prétraitement supplémentaires comme l'encodage à chaud. Il démontre l’efficacité de XGBoost dans la gestion de types de données mixtes et souligne comment l’activation d’une prise en charge native peut rationaliser les processus de modélisation et améliorer la précision prédictive.

Se concentrer sur un ensemble sélectionné de fonctionnalités simplifie le pipeline de modélisation et utilise pleinement les capacités intégrées de XGBoost, conduisant potentiellement à des modèles plus interprétables et plus robustes.

Optimisation de XGBoost avec RFECV pour la sélection des fonctionnalités

La sélection des fonctionnalités est essentielle à la création de modèles d’apprentissage automatique efficaces et interprétables. L'Élimination récursive des fonctionnalités avec validation croisée (RFECV) rationalise le modèle en supprimant de manière itérative les fonctionnalités moins importantes et en validant l'ensemble restant via la validation croisée. Ce processus simplifie non seulement le modèle, mais améliore également potentiellement ses performances en se concentrant sur les attributs les plus informatifs.

Bien que XGBoost puisse gérer nativement les fonctionnalités catégorielles lors de la création de modèles, cette fonctionnalité n'est pas directement prise en charge dans le contexte des méthodes de sélection de fonctionnalités telles que RFECV, qui reposent sur des opérations nécessitant une saisie numérique (par exemple, le classement des fonctionnalités par importance). . Par conséquent, pour utiliser efficacement RFECV avec XGBoost, nous convertissons les caractéristiques catégorielles en codes numériques à l'aide de la méthode .cat.codes de Pandas :

# Perform Cross-Validated Recursive Feature Elimination for XGB
import pandas as pd
import xgboost as xgb
from sklearn.feature_selection import RFECV
from sklearn.model_selection import cross_val_score

# Load the dataset
Ames = pd.read_csv('Ames.csv')

# Convert selected features to 'object' type to treat them as categorical
for col in ['MSSubClass', 'YrSold', 'MoSold']:
    Ames[col] = Ames[col].astype('object')

# Convert all object-type features to categorical and then to codes
categorical_features = Ames.select_dtypes(include=['object']).columns
for col in categorical_features:
    Ames[col] = Ames[col].astype('category').cat.codes

# Select features and target
X = Ames.drop(columns=['SalePrice', 'PID'])
y = Ames['SalePrice']

# Initialize XGBoost regressor
xgb_model = xgb.XGBRegressor(seed=42, enable_categorical=True)

# Initialize RFECV
rfecv = RFECV(estimator=xgb_model, step=1, cv=5,
              scoring='r2', min_features_to_select=1)

# Fit RFECV
rfecv.fit(X, y)

# Print the optimal number of features and their names
print("Optimal number of features: ", rfecv.n_features_)
print("Best features: ", X.columns[rfecv.support_])

Ce script identifie 36 caractéristiques optimales, montrant leur pertinence pour prédire les prix de l'immobilier :

Optimal number of features:  36
Best features:  Index(['GrLivArea', 'MSZoning', 'LotArea', 'Neighborhood', 'Condition1',
       'OverallQual', 'OverallCond', 'YearBuilt', 'YearRemodAdd', 'MasVnrArea',
       'ExterQual', 'BsmtQual', 'BsmtExposure', 'BsmtFinType1', 'BsmtFinSF1',
       'TotalBsmtSF', 'HeatingQC', 'CentralAir', '1stFlrSF', '2ndFlrSF',
       'BsmtFullBath', 'KitchenQual', 'Functional', 'Fireplaces',
       'FireplaceQu', 'GarageCars', 'GarageArea', 'GarageCond', 'WoodDeckSF',
       'ScreenPorch', 'MoSold', 'SaleType', 'SaleCondition', 'GeoRefNo',
       'Latitude', 'Longitude'],
      dtype='object')

Après avoir identifié les meilleures fonctionnalités, il est crucial d’évaluer leurs performances sur différents sous-ensembles de données :

# Build on the block of code above
# Cross-validate the final model using only the selected features
final_model = xgb.XGBRegressor(seed=42, enable_categorical=True)
cv_scores = cross_val_score(final_model, X.iloc[:, rfecv.support_], y, cv=5, scoring='r2')

# Calculate the average R-squared score
mean_r2 = cv_scores.mean()

print(f"Average Cross-validated R² score with remaining features: {mean_r2:.4f}")

Avec un score R² moyen de 0,8980, le modèle présente une efficacité élevée, soulignant l'importance des caractéristiques sélectionnées :

Average Cross-validated R² score with remaining features: 0.8980

Cette méthode de sélection de fonctionnalités utilisant RFECV aux côtés de XGBoost, notamment avec la gestion correcte des données catégorielles via .cat.codes, optimise les performances prédictives du modèle. Affiner l’espace des fonctionnalités améliore à la fois l’interprétabilité du modèle et son efficacité opérationnelle, s’avérant être une stratégie inestimable dans les tâches prédictives complexes.

Lectures complémentaires

Apis

API sklearn.feature.selection.RFECV

Tutoriels

Guide d'installation de XGBoost
Guide de l'utilisateur Pandas sur le type de données catégorielles

Ensemble de données et dictionnaire de données sur le logement Ames

Ensemble de données Ames
Dictionnaire de données Ames

Résumé

Dans cet article, nous avons présenté quelques fonctionnalités importantes de XGBoost. De l'installation à la mise en œuvre pratique, nous avons exploré comment XGBoost gère nativement divers problèmes de données, tels que les valeurs manquantes et les données catégorielles, simplifiant considérablement le processus de préparation des données. De plus, nous avons démontré l'optimisation de XGBoost à l'aide de RFECV (Recursive Feature Elimination with Cross-Validation), une méthode robuste de sélection de fonctionnalités qui améliore la simplicité du modèle et les performances prédictives.

Concrètement, vous avez appris :

Gestion native des valeurs manquantes par XGBoost : vous avez pu constater par vous-même comment XGBoost traite les ensembles de données comportant des entrées manquantes sans nécessiter d'imputation préalable, facilitant ainsi un processus de modélisation plus simple et potentiellement plus précis.
Gestion efficace des données catégorielles par XGBoost : contrairement aux modèles traditionnels qui nécessitent un encodage, XGBoost peut gérer directement les variables catégorielles lorsqu'elles sont correctement formatées, ce qui entraîne des gains de performances et une meilleure gestion de la mémoire.
Amélioration de XGBoost avec RFECV pour une sélection optimale des fonctionnalités : nous avons parcouru le processus d'application de RFECV à XGBoost, montrant comment identifier et conserver les fonctionnalités les plus percutantes, améliorant ainsi l'efficacité et l'interprétabilité du modèle.

Avez-vous des questions ? Veuillez poser vos questions dans les commentaires ci-dessous et je ferai de mon mieux pour y répondre.