Cómo entrenar con XGBoost y scikit-learn

El servicio de entrenamiento de Cloud Machine Learning Engine administra los recursos de procesamiento en la nube para entrenar tus modelos. En esta página, se describe el proceso para entrenar un modelo con scikit-learn y XGBoost mediante el uso de Cloud ML Engine.

Resumen

En este instructivo, entrenas un modelo simple para predecir las especies de flores, con el conjunto de datos Iris. Luego de ajustar el código del entrenamiento de tu modelo para descargar datos desde Cloud Storage y subir el archivo de tu modelo guardado a Cloud Storage, creas un paquete de aplicación de entrenamiento y lo usas para ejecutar el entrenamiento en Cloud ML Engine.

Este instructivo usa Python 2.7.

Cómo entrenar tu modelo en Cloud ML Engine

Luego de que completes el proceso de configuración inicial, puedes entrenar tu modelo en Cloud ML Engine en tres pasos:

  • Crea tu módulo de entrenamiento de Python
    • Agrega código para descargar tus datos desde Cloud Storage para que Cloud ML Engine pueda usarlos
    • Agrega código para exportar y guardar el modelo en Cloud Storage luego de que Cloud ML Engine finalice el entrenamiento del modelo
  • Prepara un paquete de aplicación de entrenamiento
  • Envía el trabajo de entrenamiento

El proceso de configuración inicial incluye la creación de un proyecto de Google Cloud Platform, la habilitación de la facturación y las API, la configuración de un depósito de Cloud Storage para usarlo con Cloud ML Engine y la instalación local de scikit-learn o XGBoost. Si ya tienes todo instalado y configurado, ve directo a cómo crear tu código de entrenamiento del modelo.

Antes de comenzar

Completa los siguientes pasos para configurar una cuenta de GCP, activar la API de Cloud ML Engine, e instalar y activar el SDK de Cloud.

Configura tu proyecto de GCP

  1. Sign in to your Google Account.

    If you don't already have one, sign up for a new account.

  2. Select or create a GCP project.

    Go to the Project selector page

  3. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

  4. Habilita las Cloud Machine Learning Engine y Compute Engine API necesarias.

    Habilita las API

  5. Install and initialize the Cloud SDK.

Configura tu entorno

Elige una de las siguientes opciones para configurar tu entorno de manera local en macOS o en un entorno remoto en Cloud Shell.

Para los usuarios de macOS, te recomendamos configurar tu entorno mediante el uso de la pestaña MACOS siguiente. Cloud Shell, que se muestra en la pestaña CLOUD SHELL, está disponible en macOS, Linux y Windows. Cloud Shell proporciona una forma rápida de probar Cloud Machine Learning Engine, pero no es adecuado para el trabajo de desarrollo continuo.

macOS

  1. Verifica la instalación de Python
    Confirma si tienes Python instalado y, si es necesario, instálalo.

    python -V
  2. Comprueba la instalación de pip.
    pip es el administrador de paquetes de Python, incluido con las versiones actuales de Python. Comprueba si ya instalaste pip por medio de la ejecución de pip --version. En caso negativo, consulta cómo instalar pip.

    Puedes actualizar pip con el siguiente comando:

    pip install -U pip

    Consulta la documentación de pip para obtener más detalles.

  3. Instala virtualenv
    virtualenv es una herramienta para crear entornos aislados de Python. Para verificar si ya tienes instalado virtualenv, ejecuta virtualenv --version. Si no, instala virtualenv:

    pip install --user --upgrade virtualenv

    Para crear un entorno de desarrollo aislado en esta guía, crea un nuevo entorno virtual en virtualenv. Por ejemplo, el siguiente comando activa un entorno llamado cmle-env:

    virtualenv cmle-env
    source cmle-env/bin/activate
  4. Para los fines de este instructivo, ejecuta el resto de los comandos dentro de tu entorno virtual.

    Consulta más información sobre el uso de virtualenv. Para salir de virtualenv, ejecuta deactivate.

Cloud Shell

  1. Abre Google Cloud Platform Console.

    Google Cloud Platform Console

  2. Haz clic en el botón Activar Cloud Shell en la parte superior de la ventana de la consola.

    Active Google Cloud Shell

    Se abrirá una sesión de Cloud Shell dentro de un nuevo marco en la parte inferior de la consola que mostrará un mensaje de línea de comandos. La sesión de shell puede tardar unos segundos en inicializar.

    Sesión de Cloud Shell

    Tu sesión de Cloud Shell está lista para usarse.

  3. Configura la herramienta de línea de comandos de gcloud para usar tu proyecto seleccionado.

    gcloud config set project [selected-project-id]

    en el que [selected-project-id] es tu ID del proyecto. (Omite los corchetes).

Verifica los componentes de SDK de Google Cloud

Para verificar que los componentes de SDK de Google Cloud están instalados, realiza lo siguiente:

  1. Haz una lista de tus modelos:

    gcloud ml-engine models list
  2. Si no has creado ningún modelo anteriormente, el comando muestra una lista vacía:

    Listed 0 items.

    Después de comenzar a crear modelos, puedes verlos en una lista con este comando.

  3. Si has instalado gcloud anteriormente, actualiza gcloud:

    gcloud components update

Instala marcos de trabajo

macOS

Dentro de tu entorno virtual, ejecuta el siguiente comando para instalar scikit-learn, XGBoost, pandas y joblib:

(cmle-env)$ pip install scikit-learn xgboost pandas joblib

Para obtener más detalles, opciones de instalación e información de solución de problemas, consulta las instrucciones de instalación para cada marco de trabajo:

Cloud Shell

Ejecuta el siguiente comando para instalar scikit-learn, XGBoost, pandas y joblib:

pip install --user scikit-learn xgboost pandas joblib

Para obtener más detalles, opciones de instalación e información de solución de problemas, consulta las instrucciones de instalación para cada marco de trabajo:

Configura tu depósito de Cloud Storage

Necesitarás un depósito de Cloud Storage para almacenar tu código de entrenamiento y dependencias. Para los fines de este instructivo, es más fácil usar un depósito de Cloud Storage dedicado en el mismo proyecto que estás usando para Cloud ML Engine.

Si usas un depósito en un proyecto diferente, debes asegurarte de que puedas acceder con tu cuenta de servicio de Cloud ML Engine a tu código de entrenamiento y dependencias en Cloud Storage. Sin los permisos adecuados, tu trabajo de entrenamiento falla. Consulta cómo otorgar permisos para el almacenamiento.

Asegúrate de usar o configurar un depósito en la misma región que estás usando para ejecutar tus trabajos de entrenamiento. Consulta las regiones disponibles para los servicios de Cloud ML Engine.

En esta sección, se muestra cómo crear un depósito nuevo. Puedes usar un depósito existente, pero si no es parte del proyecto que usas para ejecutar Cloud ML Engine, debes otorgar acceso de forma explícita a las cuentas de servicio de Cloud ML Engine.

  1. Especifica un nombre para tu depósito nuevo. El nombre debe ser único en todos los depósitos en Cloud Storage.

    BUCKET_NAME="your_bucket_name"

    Por ejemplo, usa el nombre de tu proyecto con -mlengine agregado:

    PROJECT_ID=$(gcloud config list project --format "value(core.project)")
    BUCKET_NAME=${PROJECT_ID}-mlengine
  2. Comprueba el nombre del depósito que creaste.

    echo $BUCKET_NAME
  3. Selecciona una región para tu depósito y establece una variable de entorno "REGION".

    Por ejemplo, con el siguiente código, se crea una REGION y se establece en us-central1:

    REGION=us-central1
  4. Crea el depósito nuevo:

    gsutil mb -l $REGION gs://$BUCKET_NAME

    Nota: Usa la misma región donde planeas ejecutar trabajos de Cloud ML Engine. En el ejemplo, se usa us-central1 porque esa es la región que se usa en las instrucciones de introducción.

Crea tu módulo de entrenamiento de Python

Crea un archivo, iris_training.py, que contenga el código para entrenar tu modelo. En esta sección, se proporciona una explicación sobre lo que hace cada parte del código de entrenamiento:

  • Importa y configura
  • Descarga los datos desde Cloud Storage
  • Carga los datos a pandas
  • Entrena y guarda tu modelo
  • Sube tu archivo del modelo guardado a Cloud Storage

Para tu comodidad, el código completo para iris_training.py está alojado en GitHub, por lo que puedes usarlo en este instructivo:

Configuración

Importa las siguientes bibliotecas desde Python y scikit-learn o XGBoost. Configura una variable para el nombre de tu depósito de Cloud Storage.

scikit-learn

import datetime
import os
import subprocess
import sys
import pandas as pd
from sklearn import svm
import joblib

# Fill in your Cloud Storage bucket name
BUCKET_NAME = '<YOUR_BUCKET_NAME>'

XGBoost

import datetime
import os
import subprocess
import sys
import pandas as pd
import xgboost as xgb

# Fill in your Cloud Storage bucket name
BUCKET_NAME = '<YOUR_BUCKET_NAME>'

Descarga los datos desde Cloud Storage

Durante el proceso de desarrollo típico, subes tus propios datos a Cloud Storage para que Cloud ML Engine pueda acceder a ellos. Los datos para este instructivo están alojados en un depósito de Cloud Storage público: gs://cloud-samples-data/ml-engine/iris/

El siguiente código descarga los datos con gsutil y luego desvía los datos de gsutil a stdout:

scikit-learn

iris_data_filename = 'iris_data.csv'
iris_target_filename = 'iris_target.csv'
data_dir = 'gs://cloud-samples-data/ml-engine/iris'

# gsutil outputs everything to stderr so we need to divert it to stdout.
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_data_filename),
                       iris_data_filename], stderr=sys.stdout)
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_target_filename),
                       iris_target_filename], stderr=sys.stdout)

XGBoost

iris_data_filename = 'iris_data.csv'
iris_target_filename = 'iris_target.csv'
data_dir = 'gs://cloud-samples-data/ml-engine/iris'

# gsutil outputs everything to stderr so we need to divert it to stdout.
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_data_filename),
                       iris_data_filename], stderr=sys.stdout)
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_target_filename),
                       iris_target_filename], stderr=sys.stdout)

Carga los datos a pandas

Usa pandas para cargar tus datos a los arreglos de NumPy para el entrenamiento con scikit-learn o XGBoost.

scikit-learn

# Load data into pandas, then use `.values` to get NumPy arrays
iris_data = pd.read_csv(iris_data_filename).values
iris_target = pd.read_csv(iris_target_filename).values

# Convert one-column 2D array into 1D array for use with scikit-learn
iris_target = iris_target.reshape((iris_target.size,))

XGBoost

# Load data into pandas, then use `.values` to get NumPy arrays
iris_data = pd.read_csv(iris_data_filename).values
iris_target = pd.read_csv(iris_target_filename).values

# Convert one-column 2D array into 1D array for use with XGBoost
iris_target = iris_target.reshape((iris_target.size,))

Entrena y guarda un modelo

Crea un módulo de entrenamiento para que se ejecute Cloud ML Engine. En este ejemplo, el módulo de entrenamiento entrena un modelo en los datos de entrenamiento de Iris (iris_data y iris_target) y guarda tu modelo entrenado mediante su exportación a un archivo. Si deseas usar Cloud ML Engine para obtener predicciones en línea después del entrenamiento, debes asignar un nombre a tu archivo de modelo según la biblioteca que usas para exportarlo. Obtén más información sobre los requisitos para nombrar tu archivo del modelo.

scikit-learn

Sigue el ejemplo de scikit-learn sobre la persistencia del modelo, puedes entrenar y exportar un modelo como se muestra a continuación:

# Train the model
classifier = svm.SVC(gamma='auto', verbose=True)
classifier.fit(iris_data, iris_target)

# Export the classifier to a file
model_filename = 'model.joblib'
joblib.dump(classifier, model_filename)

Para exportar el modelo, también tienes la opción de usar la biblioteca pickle de la siguiente manera:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(classifier, model_file)

XGBoost

Puedes exportar el modelo con el método "save_model" del objeto Booster.

# Load data into DMatrix object
dtrain = xgb.DMatrix(iris_data, label=iris_target)

# Train XGBoost model
bst = xgb.train({}, dtrain, 20)

# Export the classifier to a file
model_filename = 'model.bst'
bst.save_model(model_filename)

Para exportar el modelo, también tienes la opción de usar la biblioteca pickle de la siguiente manera:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(bst, model_file)

Requisitos para nombrar los archivos del modelo

El archivo de modelo guardado que subes a Cloud Storage debe llamarse model.pkl, model.joblib, o model.bst, según la biblioteca que usaste. Esta restricción garantiza que, para reconstruir el modelo en la importación, Cloud ML Engine use el mismo patrón que se usó durante la exportación.

scikit-learn

Biblioteca usada para exportar el modelo Nombre de modelo correcto
pickle model.pkl
joblib model.joblib

XGBoost

Biblioteca usada para exportar el modelo Nombre de modelo correcto
pickle model.pkl
joblib model.joblib
xgboost.Booster model.bst

En futuras iteraciones de tu modelo, organiza tu depósito de Cloud Storage para que cada modelo nuevo tenga un directorio dedicado.

Sube tu modelo guardado a Cloud Storage.

Si usas un depósito de Cloud Storage fuera del proyecto de Google Cloud Platform que estás usando para ejecutar Cloud ML Engine, asegúrate de que Cloud ML Engine tenga acceso a tu depósito.

scikit-learn

# Upload the saved model file to Cloud Storage
gcs_model_path = os.path.join('gs://', BUCKET_NAME,
    datetime.datetime.now().strftime('iris_%Y%m%d_%H%M%S'), model_filename)
subprocess.check_call(['gsutil', 'cp', model_filename, gcs_model_path],
    stderr=sys.stdout)

XGBoost

# Upload the saved model file to Cloud Storage
gcs_model_path = os.path.join('gs://', BUCKET_NAME,
    datetime.datetime.now().strftime('iris_%Y%m%d_%H%M%S'), model_filename)
subprocess.check_call(['gsutil', 'cp', model_filename, gcs_model_path],
    stderr=sys.stdout)

Crea un paquete de aplicación de entrenamiento

Con iris_training.py creado a partir de los fragmentos anteriores, crea un paquete de aplicación de entrenamiento que incluya iris_training.py como su módulo principal.

La manera más fácil (y recomendada) de crear un paquete de aplicación de entrenamiento usa gcloud para empaquetar y subir la aplicación cuando envías tu trabajo de entrenamiento. Este método requiere que crees una estructura de archivo muy simple con dos archivos:

scikit-learn

Para este instructivo, la estructura del archivo de tu paquete de aplicación de entrenamiento debe ser similar a la siguiente:

iris_sklearn_trainer/
    __init__.py
    iris_training.py
  1. En la línea de comandos, crea un directorio local:

    mkdir iris_sklearn_trainer
    
  2. Crea un archivo vacío llamado __init__.py:

    touch iris_sklearn_trainer/__init__.py
    
  3. Guarda tu código de entrenamiento como iris_training.py y guarda ese archivo dentro de tu directorio iris_sklearn_trainer. De manera alternativa, usa cURL para descargar y guardar el archivo de GitHub:

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/sklearn/iris_training.py > iris_sklearn_trainer/iris_training.py
    

    Consulta el código fuente completo en GitHub.

  4. Confirma que tu paquete de aplicación de entrenamiento esté configurado correctamente:

    ls ./iris_sklearn_trainer
      __init__.py  iris_training.py
    

XGBoost

Para este instructivo, la estructura del archivo de tu paquete de aplicación de entrenamiento debe ser similar a la siguiente:

iris_xgboost_trainer/
    __init__.py
    iris_training.py
  1. En la línea de comandos, crea un directorio local:

    mkdir iris_xgboost_trainer
    
  2. Crea un archivo vacío llamado __init__.py:

    touch iris_xgboost_trainer/__init__.py
    
  3. Guarda tu código de entrenamiento como iris_training.py y guarda ese archivo dentro de tu directorio iris_xgboost_trainer. De manera alternativa, usa cURL para descargar y guardar el archivo de GitHub:

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/xgboost/iris_training.py > iris_xgboost_trainer/iris_training.py
    

    Consulta el código fuente completo en GitHub.

  4. Confirma que tu paquete de aplicación de entrenamiento esté configurado correctamente:

    ls ./iris_xgboost_trainer
      __init__.py  iris_training.py
    

Obtén más información sobre cómo empaquetar una aplicación de entrenamiento.

Ejecuta el entrenador localmente

Puedes probar tu aplicación de entrenamiento localmente con el comando gcloud ml-engine local train. Este paso es opcional, pero es útil para la depuración.

scikit-learn

En la línea de comandos, configura las siguientes variables de entorno, reemplazando [VALUES-IN-BRACKETS] con los valores adecuados:

TRAINING_PACKAGE_PATH="./iris_sklearn_trainer/"
MAIN_TRAINER_MODULE="iris_sklearn_trainer.iris_training"

Prueba tu trabajo de entrenamiento localmente:

gcloud ml-engine local train \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE

XGBoost

En la línea de comandos, configura las siguientes variables de entorno, reemplazando [VALUES-IN-BRACKETS] con los valores adecuados:

TRAINING_PACKAGE_PATH="./iris_xgboost_trainer/"
MAIN_TRAINER_MODULE="iris_xgboost_trainer.iris_training"

Prueba tu trabajo de entrenamiento localmente:

gcloud ml-engine local train \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE

Envía el trabajo de entrenamiento

En esta sección, usas gcloud ml-engine jobs submit training para enviar tu trabajo de entrenamiento.

Especifica los parámetros del trabajo de entrenamiento

Configura las siguientes variables de entorno para cada parámetro en tu solicitud de trabajo de entrenamiento:

  • BUCKET_NAME: el nombre de tu depósito de Cloud Storage.
  • JOB_NAME: un nombre que se use para el trabajo (combinaciones de mayúsculas y minúsculas, números y guiones bajos, que comience con una letra). Por ejemplo, iris_scikit_learn_$(date +"%Y%m%d_%H%M%S") o iris_xgboost_$(date +"%Y%m%d_%H%M%S").
  • JOB_DIR: la ruta a una ubicación de Cloud Storage para usar tus archivos de salida del trabajo de entrenamiento. Por ejemplo, gs://$BUCKET_NAME/scikit_learn_job_dir o gs://$BUCKET_NAME/xgboost_job_dir.
  • TRAINING_PACKAGE_PATH: la ruta local al directorio raíz de tu aplicación de entrenamiento. Por ejemplo, ./iris_sklearn_trainer/ o ./iris_xgboost_trainer/.
  • MAIN_TRAINER_MODULE: especifica qué archivo debe ejecutar el servicio de entrenamiento de Cloud ML Engine. Tiene el formato [YOUR_FOLDER_NAME.YOUR_PYTHON_FILE_NAME]. Por ejemplo, iris_sklearn_trainer.iris_training o iris_xgboost_trainer.iris_training.
  • REGION: el nombre de la región que estás usando para ejecutar tu trabajo de entrenamiento. Usa una de las regiones disponibles para el servicio de entrenamiento de Cloud ML Engine. Asegúrate de que tu depósito de Cloud Storage esté en la misma región.
  • RUNTIME_VERSION: debes especificar una versión del entorno de ejecución de Cloud ML Engine que sea compatible con scikit-learn. En este ejemplo, 1.12.
  • PYTHON_VERSION: la versión de Python que se usa para el trabajo. Python 3.5 está disponible con Cloud ML Engine 1.4 o superior. Para este instructivo, especifique Python 2.7.
  • SCALE_TIER: una especificación del clúster predefinida para que las máquinas ejecuten tu trabajo de entrenamiento. En este caso, BASIC. También puedes usar niveles de escala personalizados para definir tu propia configuración del clúster para el entrenamiento.

Para tu comodidad, las variables de entorno para este instructivo se encuentran a continuación.

scikit-learn

Reemplaza [VALUES-IN-BRACKETS] por los valores adecuados:

    BUCKET_NAME=[YOUR-BUCKET-NAME]
    JOB_NAME="iris_scikit_learn_$(date +"%Y%m%d_%H%M%S")"
    JOB_DIR=gs://$BUCKET_NAME/scikit_learn_job_dir
    TRAINING_PACKAGE_PATH="./iris_sklearn_trainer/"
    MAIN_TRAINER_MODULE="iris_sklearn_trainer.iris_training"
    REGION=us-central1
    RUNTIME_VERSION=1.12
    PYTHON_VERSION=2.7
    SCALE_TIER=BASIC

XGBoost

Reemplaza [VALUES-IN-BRACKETS] por los valores adecuados:

    BUCKET_NAME=[YOUR-BUCKET-NAME]
    JOB_NAME="iris_xgboost_$(date +"%Y%m%d_%H%M%S")"
    JOB_DIR=gs://$BUCKET_NAME/xgboost_job_dir
    TRAINING_PACKAGE_PATH="./iris_xgboost_trainer/"
    MAIN_TRAINER_MODULE="iris_xgboost_trainer.iris_training"
    REGION=us-central1
    RUNTIME_VERSION=1.12
    PYTHON_VERSION=2.7
    SCALE_TIER=BASIC

Envía la solicitud del trabajo de entrenamiento:

gcloud ml-engine jobs submit training $JOB_NAME \
  --job-dir $JOB_DIR \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE \
  --region $REGION \
  --runtime-version=$RUNTIME_VERSION \
  --python-version=$PYTHON_VERSION \
  --scale-tier $SCALE_TIER

Debería ver un resultado similar al siguiente:

Job [iris_scikit_learn_[DATE]_[TIME]] submitted successfully.
Your job is still active. You may view the status of your job with the command

  $ gcloud ml-engine jobs describe iris_scikit_learn_[DATE]_[TIME]

or continue streaming the logs with the command

  $ gcloud ml-engine jobs stream-logs iris_scikit_learn_[DATE]_[TIME]

jobId: iris_scikit_learn_[DATE]_[TIME]
state: QUEUED

Cómo visualizar tus registros de entrenamiento (opcional)

Cloud ML Engine captura todas las secuencias stdout y stderr, y las instrucciones de registro. Estos registros se almacenan en Logging; son visibles tanto durante como después de la ejecución.

Para visualizar los registros de tu trabajo de entrenamiento:

Console

  1. Abre la página Trabajos de Cloud ML Engine.

    Abrir trabajos en GCP Console

  2. Selecciona el nombre del trabajo de entrenamiento para inspeccionar. Esto te lleva a la página Detalles del trabajo de tu trabajo de entrenamiento seleccionado.

  3. Dentro de los detalles del trabajo, selecciona el vínculo Ver registros. Esto te lleva a la página de Logging donde puedes buscar y filtrar los registros para tu trabajo de entrenamiento seleccionado.

gcloud

Puedes visualizar los registros en tu terminal con gcloud ml-engine jobs stream-logs.

gcloud ml-engine jobs stream-logs $JOB_NAME

Verifica tu archivo del modelo en Cloud Storage

Visualiza los contenidos de la carpeta del modelo de destino para verificar que tu archivo del modelo guardado haya sido subido a Cloud Storage.

gsutil ls gs://$BUCKET_NAME/iris_*

Resultado de ejemplo:

gs://bucket-name/iris_20180518_123815/:
gs://bucket-name/iris_20180518_123815/model.joblib

Implementa tu modelo en Cloud ML Engine para predicciones en línea

Para implementar tu modelo y mostrar predicciones, sigue las instrucciones para implementar modelos y versiones. Puedes usar las variables $RUNTIME_VERSION y $PYTHON_VERSION que definiste anteriormente en este instructivo para implementar el modelo con gcloud ml-engine versions create.

Pasos siguientes

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Cloud ML Engine para XGBoost y scikit-learn