Einführung

Bei der Auswahl eines binären Klassifizierungsmodells für Tabellendaten habe ich beschlossen, schnell ein schnelles, nicht Deep-Learning-Modell auszuprobieren: Gradient Boosting Decision Trees (GBDT). In diesem Artikel wird der Prozess der Erstellung eines Jupyter Notebook-Skripts mit BigQuery als Datenquelle und dem XGBoost-Algorithmus zur Modellierung beschrieben.

Vollständiges Skript

Für diejenigen, die es vorziehen, ohne Erklärung direkt in das Skript einzusteigen, hier ist es. Bitte passen Sie den Projektnamen, den Datensatznamen und den Tabellennamen an Ihr Projekt an.

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 `..`
"""

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

Erläuterung

Laden von Daten aus BigQuery

Früher wurden Daten in Cloud Storage als CSV-Dateien gespeichert, aber das langsame Laden der Daten verringerte die Effizienz unserer Lernprozesse und veranlasste den Wechsel zu BigQuery für eine schnellere Datenverarbeitung.

Einrichten des BigQuery-Clients

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

Dieser Code initialisiert einen BigQuery-Client mit Google Cloud-Anmeldeinformationen, die über Umgebungsvariablen oder das Google Cloud SDK eingerichtet werden können.

Daten abfragen und laden

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

Diese Funktion führt eine SQL-Abfrage aus und gibt die Ergebnisse als DataFrame in Pandas zurück, was eine effiziente Datenverarbeitung ermöglicht.

Trainieren des Modells mit XGBoost

XGBoost ist ein leistungsstarker Algorithmus für maschinelles Lernen, der Gradient Boosting nutzt und häufig für Klassifizierungs- und Regressionsprobleme verwendet wird.

https://arxiv.org/pdf/1603.02754

Modellinitialisierung

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

Hier wird die XGBClassifier-Klasse instanziiert, wobei der Protokollverlust als Bewertungsmetrik verwendet wird.

Datenaufteilung

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)

Diese Funktion teilt die Daten in Trainings- und Validierungssätze auf, was für das Testen der Modellleistung und die Vermeidung einer Überanpassung von entscheidender Bedeutung ist.

Parameteroptimierung

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 führt eine Kreuzvalidierung durch, um die beste Parameterkombination für das Modell zu finden.

Modellbewertung

Die Leistung des Modells wird anhand von Präzision, Rückruf, F1-Score und Protokollverlust im Validierungsdatensatz bewertet.

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)

Ergebnisse ausgeben

Wenn Sie das Notebook ausführen, erhalten Sie die folgende Ausgabe mit den besten Parametern und den Modellbewertungsmetriken.

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}

Weitere Informationen

Verwendung von Google Cloud Storage als Datenquelle

In manchen Fällen kann es sinnvoller sein, Daten aus Google Cloud Storage statt aus BigQuery zu laden. Die folgende Funktion liest eine CSV-Datei aus Cloud Storage und gibt sie als DataFrame in Pandas zurück und kann austauschbar mit der Funktion „load_data_from_bigquery“ verwendet werden.

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

Anwendungsbeispiel:

bucket_name = ''
file_path = ''

df = load_data_from_gcs(bucket_name, file_path)

Ein Modell mit LightGBM trainieren

Wenn Sie LightGBM anstelle von XGBoost verwenden möchten, können Sie im selben Setup einfach den XGBClassifier durch LGBMClassifier ersetzen.

import lightgbm as lgb
model = lgb.LGBMClassifier()

Abschluss

Zukünftige Artikel werden sich mit der Verwendung von BigQuery ML (BQML) für Schulungen befassen.