Esta versión heredada de AI Platform Training está obsoleta y dejará de estar disponible en Google Cloud después del 31 de enero de 2025. Migra tus recursos al entrenamiento personalizado de Vertex AI para obtener nuevas funciones de aprendizaje automático que no están disponibles en AI Platform.

Se usó la API de Cloud Translation para traducir esta página.

Entrena un modelo de AA con scikit-learn y XGBoost

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 de entrenamiento de un modelo con scikit-learn y XGBoost mediante AI Platform Training.

Descripción general

En este instructivo, entrenas un modelo simple para predecir las especies de flores, con el conjunto de datos Iris. Después de ajustar el código de entrenamiento de modelos para que descargue datos de Cloud Storage y suba el archivo del modelo guardado a Cloud Storage, debes crear un paquete de aplicación de entrenamiento y usarlo a fin de ejecutar el entrenamiento en AI Platform Training.

Cómo entrenar el modelo en AI Platform Training

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

Crea el módulo de entrenamiento de Python
- Agrega un código para descargar los datos desde Cloud Storage de modo que AI Platform Training pueda usarlos.
- Agrega un código para exportar y guardar el modelo en Cloud Storage después de que AI Platform Training 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, la habilitación de la facturación y las API, la configuración de un bucket de Cloud Storage para usarlo con AI Platform Training y la instalación de scikit-learn o XGBoost de forma local. Si ya tienes todo instalado y configurado, ve directo a la sección sobre cómo crear el 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 Training y, además, instalar y activar el SDK de Cloud.

Configura el proyecto de GCP

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the AI Platform Training & Prediction and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the AI Platform Training & Prediction and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Configura el 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 que configures tu entorno mediante el uso de 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 Training, pero no es conveniente para el trabajo de desarrollo continuo.

macOS

Verifica la instalación de Python
Confirma que tienes Python instalado y, si es necesario, instálalo.
```
python -V
```
Verifica la instalación de pip
pip es el administrador de paquetes de Python y se incluye en sus versiones actuales. Para verificar si ya tienes pip instalado, 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.
Instala virtualenv
virtualenv es una herramienta que sirve para crear entornos de Python aislados. Para verificar si ya tienes virtualenv instalado, ejecuta el comando virtualenv --version. De lo contrario, instala virtualenv con el comando siguiente:
```
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 aip-env:
```
virtualenv aip-env
source aip-env/bin/activate
```
A los fines de este instructivo, ejecuta el resto de los comandos dentro de tu entorno virtual.
Obtén más información sobre el uso de virtualenv. Para salir de virtualenv, ejecuta deactivate.

Cloud Shell

Abre la consola de Google Cloud.

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

Se abrirá una sesión de Cloud Shell dentro de un marco nuevo en la parte inferior de la consola y, en ella, se mostrará una ventana de la línea de comandos. La sesión de Shell puede tardar unos segundos en inicializar.

Tu sesión de Cloud Shell está lista para usarse.
Configura la herramienta de línea de comandos de gcloud a fin de usar el proyecto seleccionado.
```
gcloud config set project [selected-project-id]
```
donde [selected-project-id] es el ID del proyecto. (omite los corchetes).

Instala frameworks

macOS

En tu entorno virtual, ejecuta el siguiente comando para instalar las versiones de scikit-learn, XGBoost y Pandas que se usan en AI Platform Training versión del entorno de ejecución 2.11:

(aip-env)$ pip install scikit-learn==1.0.2 xgboost==1.6.2 pandas==1.3.5

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

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

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, opciones de instalación y también información que te ayude a solucionar problemas, consulta las instrucciones de instalación para cada marco de trabajo:

Configura tu bucket de Cloud Storage

Necesitarás un bucket de Cloud Storage para almacenar el código de entrenamiento y las dependencias. A los fines de este instructivo, es más fácil usar un bucket dedicado de Cloud Storage en el mismo proyecto que usas para AI Platform Training.

Si usas un bucket en un proyecto diferente, debes asegurarte de que la cuenta de servicio de AI Platform Training pueda acceder al código de entrenamiento y a las dependencias en Cloud Storage. Sin los permisos adecuados, el trabajo de entrenamiento fallará. Consulta cómo otorgar permisos para el almacenamiento.

Asegúrate de usar o configurar un bucket en la misma región que usas para ejecutar tus trabajos de entrenamiento. Consulta las regiones disponibles para los servicios de AI Platform Training.

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

Especifica un nombre para el bucket 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 -aiplatform agregado:
```
PROJECT_ID=$(gcloud config list project --format "value(core.project)")
BUCKET_NAME=${PROJECT_ID}-aiplatform
```
Comprueba el nombre del bucket que creaste.
```
echo $BUCKET_NAME
```
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 Training. Consulta las regiones disponibles para los servicios de AI Platform Training.

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

Crea el bucket nuevo:

gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

Crea el 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 el 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 bucket 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 Training 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/

Con el siguiente código, se descargan los datos mediante gsutil y, luego, se desvían 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/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 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 AI Platform Training lo ejecute. En este ejemplo, el módulo entrena un modelo en los datos de entrenamiento de Iris (iris_data y iris_target) y exporta el modelo entrenado a un archivo para guardarlo. Si deseas usar AI Platform Prediction a fin de obtener predicciones en línea después del entrenamiento, debes asignarle un nombre al archivo del modelo en función de la biblioteca que uses para exportarlo. Obtén más información sobre los requisitos para asignar nombre al 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

Para la predicción en línea, el archivo de modelo guardado que subas a Cloud Storage debe llamarse model.pkl, model.joblib o model.bst, según la biblioteca que hayas usado. Esta restricción garantiza que AI Platform Prediction usará 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 usada para exportar el modelo	Nombre de modelo correcto
`pickle`	`model.pkl`
`sklearn.externals.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 bucket de Cloud Storage para que cada modelo nuevo tenga un directorio dedicado.

Sube el modelo guardado a Cloud Storage.

Si usas un depósito de Cloud Storage fuera del proyecto de Google Cloud que usas para ejecutar AI Platform Training, asegúrate de que AI Platform Training tenga acceso al 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 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

En la línea de comandos, crea un directorio local:
```
mkdir iris_sklearn_trainer
```
Crea un nuevo archivo llamado __init__.py:
```
touch iris_sklearn_trainer/__init__.py
```
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.
Confirma que tu paquete de aplicación de entrenamiento esté configurado de forma correcta:
```
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

En la línea de comandos, crea un directorio local:
```
mkdir iris_xgboost_trainer
```
Crea un nuevo archivo llamado __init__.py:
```
touch iris_xgboost_trainer/__init__.py
```
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.
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 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 el 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 el 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 la solicitud de trabajo de entrenamiento:

BUCKET_NAME: Es el nombre del 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 Training. 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 el trabajo de entrenamiento. Usa una de las regiones disponibles para el servicio de capacitación de AI Platform Training. Asegúrate de que tu bucket de Cloud Storage esté en la misma región.
RUNTIME_VERSION: Debes especificar una versión del entorno de ejecución de AI Platform Training que sea compatible con scikit-learn. En este ejemplo, es 2.11.
PYTHON_VERSION: Es la versión de Python que se usa para el trabajo. Para este instructivo, especifica Python 3.7.
SCALE_TIER: 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, las variables de entorno en 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=2.11
    PYTHON_VERSION=3.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=2.11
    PYTHON_VERSION=3.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 los registros de entrenamiento (opcional)

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

Para visualizar los registros de tu trabajo de entrenamiento:

Console

Abre la página Trabajos de AI Platform Training.

Abrir Trabajos en la consola de Google Cloud
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.
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 ver los registros en tu terminal con gcloud ai-platform jobs stream-logs.

gcloud ai-platform jobs stream-logs $JOB_NAME

Verifica el 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.

gcloud storage ls gs://$BUCKET_NAME/iris_*

Resultado de ejemplo:

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

¿Qué sigue?

Obtén predicciones en línea con scikit-learn en AI Platform Training.
Descubre cómo usar niveles de escala personalizados a fin de definir tu configuración del clúster para el entrenamiento.