Introducción

Al seleccionar un modelo de clasificación binaria para datos tabulares, decidí probar rápidamente un modelo de aprendizaje rápido y no profundo: árboles de decisión de impulso de gradiente (GBDT). Este artículo describe el proceso de creación de un script de Jupyter Notebook utilizando BigQuery como fuente de datos y el algoritmo XGBoost para modelado.

Guión completo

Para aquellos que prefieren saltar directamente al guión sin la explicación, aquí está. Ajuste el nombre del proyecto, el nombre del conjunto de datos y el nombre de la tabla para que se ajusten a su proyecto.

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)

Explicación

Cargando datos desde BigQuery

Anteriormente, los datos se almacenaban en Cloud Storage como archivos CSV, pero la lenta carga de datos estaba reduciendo la eficiencia de nuestros procesos de aprendizaje, lo que provocó el cambio a BigQuery para un manejo de datos más rápido.

Configurar el cliente de BigQuery

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

Este código inicializa un cliente de BigQuery usando las credenciales de Google Cloud, que se pueden configurar mediante variables de entorno o el SDK de Google Cloud.

Consultar y cargar datos

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

Esta función ejecuta una consulta SQL y devuelve los resultados como un DataFrame en Pandas, lo que permite un procesamiento de datos eficiente.

Entrenando el modelo con XGBoost

XGBoost es un algoritmo de aprendizaje automático de alto rendimiento que utiliza aumento de gradiente, ampliamente utilizado para problemas de clasificación y regresión.

https://arxiv.org/pdf/1603.02754

Inicialización del modelo

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

Aquí, se crea una instancia de la clase XGBClassifier, utilizando la pérdida de registros como métrica de evaluación.

División de datos

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)

Esta función divide los datos en conjuntos de entrenamiento y validación, lo cual es crucial para probar el rendimiento del modelo y evitar el sobreajuste.

Optimización de parámetros

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 realiza una validación cruzada para encontrar la mejor combinación de parámetros para el modelo.

Evaluación del modelo

El rendimiento del modelo se evalúa mediante precisión, recuperación, puntuación F1 y pérdida de registro en el conjunto de datos de validación.

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)

Resultados de salida

Cuando ejecute el cuaderno, obtendrá el siguiente resultado que muestra los mejores parámetros y las métricas de evaluación del modelo.

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}

información adicional

Usar Google Cloud Storage como fuente de datos

En algunos casos, puede ser más apropiado cargar datos desde Google Cloud Storage en lugar de BigQuery. La siguiente función lee un archivo CSV de Cloud Storage y lo devuelve como un DataFrame en Pandas, y se puede usar indistintamente con la función 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

Ejemplo de uso:

bucket_name = ''
file_path = ''

df = load_data_from_gcs(bucket_name, file_path)

Entrenando un modelo con LightGBM

Si desea utilizar LightGBM en lugar de XGBoost, simplemente puede reemplazar XGBClassifier con LGBMClassifier en la misma configuración.

import lightgbm as lgb
model = lgb.LGBMClassifier()

Conclusión

Los artículos futuros cubrirán el uso de BigQuery ML (BQML) para capacitación.