Entrenamiento con XGBoost y scikit-learn

El servicio de entrenamiento de AI Platform 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 AI Platform.

Descripción general

En este instructivo, entrenarás 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 AI Platform.

Este instructivo usa Python 2.7.

Cómo entrenar tu modelo en AI Platform

Después de que completes el proceso de configuración inicial, podrás entrenar tu modelo en AI Platform en tres pasos:

  • Crear un módulo de entrenamiento de Python
    • Agregar código para descargar tus datos desde Cloud Storage de modo que AI Platform pueda usarlos
    • Agregar código para exportar y guardar el modelo en Cloud Storage después de que AI Platform finalice el entrenamiento del modelo
  • Preparar un paquete de aplicación de entrenamiento
  • Enviar 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 usar con AI Platform y, además, la instalación de scikit-learn o XGBoost de forma local. 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 AI Platform y, también, instalar y activar el SDK de Cloud.

Configura tu proyecto de GCP

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En GCP Console, en la página de selección de proyecto, selecciona o crea un proyecto de GCP.

    Ir a la página de selección de proyecto

  3. Asegúrate de tener habilitada la facturación para tu proyecto de Google Cloud Platform. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita lasAI Platform ("Cloud Machine Learning Engine") and Compute EngineAPIAPI.

    Habilita lasAPI

  5. Instala e inicializa el SDK de Cloud.

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.

Si eres usuario de macOS, te recomendamos configurar tu entorno mediante la pestaña MACOS a continuación. 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 AI Platform, pero no es adecuado para el trabajo de desarrollo continuo.

macOS

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

    python -V
  2. Verifica la instalación de pip
    . pip es el administrador de paquetes de Python, que se incluye en las versiones actuales de Python. Para verificar si ya tienes instalado pip, ejecuta el comando pip --version. De lo contrario, 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. De lo contrario, instala virtualenv:

    pip install --user --upgrade virtualenv

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

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

    Consulta más información sobre cómo usar 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 Google Cloud Shell en la parte superior de la ventana de la consola.

    Activar Google Cloud Shell

    Se abrirá una sesión de Cloud Shell dentro de un marco nuevo 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 que use tu proyecto seleccionado.

    gcloud config set project [selected-project-id]

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

Verifica los componentes del SDK de Google Cloud

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

  1. Genera una lista de tus modelos con el siguiente comando:

    gcloud ai-platform 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 ya instalaste gcloud, actualiza con el siguiente comando:

    gcloud components update

Instala marcos de trabajo

macOS

Dentro de tu entorno virtual, ejecuta el comando siguiente para instalar las versiones de scikit-learn, XGBoost y Pandas que se utilizan en la versión 1.14 del entorno de ejecución de AI Platform:

(cmle-env)$ pip install scikit-learn==0.20.2 xgboost==0.81 pandas==0.24.0

Cuando proporciones los números de versión en el comando anterior, asegúrate de que las dependencias de tu entorno virtual coincidan con las dependencias de la versión del entorno de ejecución. Esto ayuda a prevenir comportamientos inesperados cuando tu código se ejecuta en AI Platform.

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

Cloud Shell

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

pip install --user scikit-learn xgboost pandas

Para obtener más detalles, información de solución de problemas y opciones de instalación, consulta las siguientes 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 usas para AI Platform.

Si usas un depósito en un proyecto diferente, debes asegurarte de que puedes acceder con tu cuenta de servicio de AI Platform a tu código de entrenamiento y a las 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 usas para ejecutar tus trabajos de entrenamiento. Consulta las regiones disponibles para los servicios de AI Platform.

En esta sección, se muestra cómo crear un depósito nuevo. Puedes usar un depósito existente, pero debe estar en la misma región en la que planeas ejecutar los trabajos de AI Platform. Además, si no forma parte del proyecto que usas para ejecutar AI Platform, debes otorgar acceso a las cuentas de servicio de AI Platform de forma explícita.

  1. Especifica un nombre para tu depósito nuevo. El nombre debe ser único entre 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.

    Usa la misma región en la que planeas ejecutar los trabajos de AI Platform. Consulta las regiones disponibles para servicios de AI Platform.

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

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

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

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:

  • Configura y, luego, importa
  • Descarga los datos desde Cloud Storage
  • Carga los datos en Pandas
  • Entrena y guarda tu modelo
  • Sube tu archivo del modelo guardado a Cloud Storage

Para tu comodidad, el código completo de iris_training.py está alojado en GitHub, así 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
from sklearn.externals 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 AI Platform pueda acceder a ellos. Los datos usados en este instructivo están alojados en un depósito público de Cloud Storage: gs://cloud-samples-data/ai-platform/iris/

El siguiente código descarga los datos mediante gsutil y, luego, desvía los datos de 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/ai-platform/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 en Pandas

Usa Pandas si deseas 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 AI Platform. 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 AI Platform para obtener predicciones en línea después del entrenamiento, debes asignar un nombre a tu archivo del modelo según la biblioteca que usas para exportarlo. Obtén más información sobre los requisitos para asignar nombre a tu archivo del modelo.

scikit-learn

A continuación del ejemplo de scikit-learn sobre la persistencia del modelo, puedes entrenar y exportar un modelo de la manera siguiente:

# 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

Para exportar tu modelo, puedes usar 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 del modelo guardado que subas a Cloud Storage debe tener el siguiente nombre: model.pkl, model.joblib o model.bst, según la biblioteca que hayas utilizado. Esta restricción garantiza que AI Platform utilice el mismo patrón que se usó durante la exportación para reconstruir el modelo en la importación.

Este requisito no se aplica si creas una rutina de predicción personalizada (versión Beta).

scikit-learn

Biblioteca que se usó para exportar el modelo Nombre del modelo correcto
pickle model.pkl
joblib model.joblib

XGBoost

Biblioteca que se usó para exportar el modelo Nombre del 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 usas para ejecutar AI Platform, asegúrate de que AI Platform 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 como su módulo principal.

La forma 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 nuevo archivo 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 de modo correcto:

    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 nuevo archivo 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 de modo correcto:

    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 de forma local

Puedes probar tu aplicación de entrenamiento de forma local con el comando gcloud ai-platform 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 y reemplaza [VALUES-IN-BRACKETS] por los valores apropiados:

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

Prueba tu trabajo de entrenamiento de forma local:

gcloud ai-platform 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 y reemplaza [VALUES-IN-BRACKETS] por los valores apropiados:

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

Prueba tu trabajo de entrenamiento de forma local:

gcloud ai-platform local train \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE

Envía el trabajo de entrenamiento

En esta sección, usarás gcloud ai-platform 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: es el nombre de tu depósito de Cloud Storage.
  • JOB_NAME: es un nombre para el trabajo (combinaciones de mayúsculas y minúsculas, números y guiones bajos únicamente, 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: es la ruta a una ubicación de Cloud Storage para 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: es 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 AI Platform. Tiene el formato [YOUR_FOLDER_NAME.YOUR_PYTHON_FILE_NAME]. Por ejemplo, iris_sklearn_trainer.iris_training o iris_xgboost_trainer.iris_training.
  • REGION: es el nombre de la región que usas para ejecutar tu trabajo de entrenamiento. Usa una de las regiones disponibles para el servicio de entrenamiento de AI Platform. Asegúrate de que tu depósito de Cloud Storage esté en la misma región.
  • RUNTIME_VERSION: es una versión del entorno de ejecución de AI Platform que debes especificar que sea compatible con scikit-learn. En este ejemplo, es 1.14.
  • PYTHON_VERSION: es la versión de Python que se usa para el trabajo. Python 3.5 está disponible para la versión 1.4 o superior de AI Platform. Para este instructivo, especifica Python 2.7.
  • SCALE_TIER: es una especificación del clúster predefinida para que las máquinas ejecuten tu trabajo de entrenamiento. En este caso, es BASIC. También puedes usar niveles de escala personalizados a fin de definir tu propia configuración del clúster para el entrenamiento.

Para tu comodidad, a continuación se detallan las variables de entorno que se usan en este instructivo.

scikit-learn

Reemplaza [VALUES-IN-BRACKETS] por los valores adecuados como se muestra a continuación:

    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.14
    PYTHON_VERSION=2.7
    SCALE_TIER=BASIC

XGBoost

Reemplaza [VALUES-IN-BRACKETS] por los valores adecuados como se muestra a continuación:

    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.14
    PYTHON_VERSION=2.7
    SCALE_TIER=BASIC

Envía la solicitud del trabajo de entrenamiento:

gcloud ai-platform 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 ai-platform jobs describe iris_scikit_learn_[DATE]_[TIME]

or continue streaming the logs with the command

  $ gcloud ai-platform jobs stream-logs iris_scikit_learn_[DATE]_[TIME]

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

Visualiza tus registros de entrenamiento (opcional)

AI Platform captura todas las transmisiones stdout y stderr y las instrucciones de registro. Estos registros se almacenan en Logging y son visibles tanto durante como después de la ejecución.

Para visualizar los registros de tu trabajo de entrenamiento, sigue estos pasos:

Console

  1. Abre la página Trabajos de AI Platform.

    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 Logging donde puedes buscar y filtrar los registros para tu trabajo de entrenamiento seleccionado.

gcloud

Puedes ver los registros en tu terminal con gcloud ai-platform jobs stream-logs.

gcloud ai-platform 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 AI Platform para predicciones en línea

A fin de 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 con anterioridad en este instructivo para implementar el modelo con gcloud ai-platform versions create.

Próximos pasos

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

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.