Intégration BigQuery et XGBoost : un didacticiel Jupyter Notebook pour la classification binaire

Introduction

En sélectionnant un modèle de classification binaire pour les données tabulaires, j'ai décidé d'essayer rapidement un modèle d'apprentissage rapide et non profond : les arbres de décision à stimulation de gradient (GBDT). Cet article décrit le processus de création d'un script Jupyter Notebook en utilisant BigQuery comme source de données et l'algorithme XGBoost pour la modélisation.

Scénario complet

Pour ceux qui préfèrent se lancer directement dans le script sans explication, le voici. Veuillez ajuster le nom du projet, le nom de l'ensemble de données et le nom de la table en fonction de votre projet.

import xgboost as xgb
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.metrics import precision_score, recall_score, f1_score, log_loss
from google.cloud import bigquery

# Function to load data from BigQuery
def load_data_from_bigquery(query):
    client = bigquery.Client()
    query_job = client.query(query)
    df = query_job.to_dataframe()
    return df

def compute_metrics(labels, predictions, prediction_probs):
    precision = precision_score(labels, predictions, average='macro')
    recall = recall_score(labels, predictions, average='macro')
    f1 = f1_score(labels, predictions, average='macro')
    loss = log_loss(labels, prediction_probs)
    return {
        'precision': precision,
        'recall': recall,
        'f1': f1,
        'loss': loss
    }

# Query in BigQuery
query = """
SELECT *
FROM `<project_name>.<dataset_name>.<table_name>`
"""

# Loading data
df = load_data_from_bigquery(query)

# Target data
y = df["reaction"]

# Input data
X = df.drop(columns=["reaction"], axis=1)

# Splitting data into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=1)

# Training the XGBoost model
model = xgb.XGBClassifier(eval_metric='logloss')

# Setting the parameter grid
param_grid = {
    'max_depth': [3, 4, 5],
    'learning_rate': [0.01, 0.1, 0.2],
    'n_estimators': [100, 200, 300],
    'subsample': [0.8, 0.9, 1.0]
}

# Initializing GridSearchCV
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=3, scoring='accuracy', verbose=1, n_jobs=-1)

# Executing the grid search
grid_search.fit(X_train, y_train)

# Displaying the best parameters
print("Best parameters:", grid_search.best_params_)

# Model with the best parameters
best_model = grid_search.best_estimator_

# Predictions on validation data
val_predictions = best_model.predict(X_val)
val_prediction_probs = best_model.predict_proba(X_val)

# Predictions on training data
train_predictions = best_model.predict(X_train)
train_prediction_probs = best_model.predict_proba(X_train)

# Evaluating the model (validation data)
val_metrics = compute_metrics(y_val, val_predictions, val_prediction_probs)
print("Optimized Validation Metrics:", val_metrics)

# Evaluating the model (training data)
train_metrics = compute_metrics(y_train, train_predictions, train_prediction_probs)
print("Optimized Training Metrics:", train_metrics)

Explication

Charger des données depuis BigQuery

Auparavant, les données étaient stockées dans Cloud Storage sous forme de fichiers CSV, mais la lenteur du chargement des données réduisait l'efficacité de nos processus d'apprentissage, ce qui nous incitait à passer à BigQuery pour un traitement plus rapide des données.

Configuration du client BigQuery

from google.cloud import bigquery
client = bigquery.Client()

Ce code initialise un client BigQuery à l'aide des informations d'identification Google Cloud, qui peuvent être configurées via des variables d'environnement ou le SDK Google Cloud.

Interrogation et chargement de données

def load_data_from_bigquery(query):
    query_job = client.query(query)
    df = query_job.to_dataframe()
    return df

Cette fonction exécute une requête SQL et renvoie les résultats sous forme de DataFrame dans Pandas, permettant un traitement efficace des données.

Entraîner le modèle avec XGBoost

XGBoost est un algorithme d'apprentissage automatique hautes performances utilisant l'augmentation de gradient, largement utilisé pour les problèmes de classification et de régression.

https://arxiv.org/pdf/1603.02754

Initialisation du modèle

import xgboost as xgb
model = xgb.XGBClassifier(eval_metric='logloss')

Ici, la classe XGBClassifier est instanciée, en utilisant la perte de journal comme métrique d'évaluation.

Fractionnement des données

from sklearn.model_selection import train_test_split
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=1)

Cette fonction divise les données en ensembles d'entraînement et de validation, ce qui est crucial pour tester les performances du modèle et éviter le surajustement.

Optimisation des paramètres

from sklearn.model_selection import GridSearchCV
param_grid = {
    'max_depth': [3, 4, 5],
    'learning_rate': [0.01, 0.1, 0.2],
    'n_estimators': [100, 200, 300],
    'subsample': [0.8, 0.9, 1.0]
}
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=3, scoring='accuracy', verbose=1, n_jobs=-1)
grid_search.fit(X_train, y_train)

GridSearchCV effectue une validation croisée pour trouver la meilleure combinaison de paramètres pour le modèle.

Évaluation du modèle

Les performances du modèle sont évaluées en utilisant la précision, le rappel, le score F1 et la perte de journal sur l'ensemble de données de validation.

def compute_metrics(labels, predictions, prediction_probs):
    from sklearn.metrics import precision_score, recall_score, f1_score, log_loss
    return {
        'precision': precision_score(labels, predictions, average='macro'),
        'recall': recall_score(labels, predictions, average='macro'),
        'f1': f1_score(labels, predictions, average='macro'),
        'loss': log_loss(labels, prediction_probs)
    }
val_metrics = compute_metrics(y_val, val_predictions, val_prediction_probs)
print("Optimized Validation Metrics:", val_metrics)

Résultats de sortie

Lorsque vous exécutez le notebook, vous obtiendrez le résultat suivant montrant les meilleurs paramètres et les métriques d'évaluation du modèle.

Best parameters: {'learning_rate': 0.2, 'max_depth': 5, 'n_estimators': 300, 'subsample': 0.9}
Optimized Validation Metrics: {'precision': 0.8919952583956949, 'recall': 0.753797304483842, 'f1': 0.8078981867164722, 'loss': 0.014006406471894417}
Optimized Training Metrics: {'precision': 0.8969556573175115, 'recall': 0.7681976753444204, 'f1': 0.8199353049298048, 'loss': 0.012475375680566196}

Informations Complémentaires

Utiliser Google Cloud Storage comme source de données

Dans certains cas, il peut être plus approprié de charger des données depuis Google Cloud Storage plutôt que depuis BigQuery. La fonction suivante lit un fichier CSV à partir de Cloud Storage et le renvoie sous forme de DataFrame dans Pandas. Elle peut être utilisée de manière interchangeable avec la fonction load_data_from_bigquery.

from google.cloud import storage

def load_data_from_gcs(bucket_name, file_path):
    client = storage.Client()
    bucket = client.get_bucket(bucket_name)
    blob = bucket.blob(file_path)
    data = blob.download_as_text()
    df = pd.read_csv(io.StringIO(data), encoding='utf-8')
    return df

Exemple d'utilisation :

bucket_name = '<bucket-name>'
file_path = '<file-path>'

df = load_data_from_gcs(bucket_name, file_path)

Entraîner un modèle avec LightGBM

Si vous souhaitez utiliser LightGBM au lieu de XGBoost, vous pouvez simplement remplacer le XGBClassifier par LGBMClassifier dans la même configuration.

import lightgbm as lgb
model = lgb.LGBMClassifier()

Conclusion

Les prochains articles couvriront l'utilisation de BigQuery ML (BQML) pour la formation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!