Comienza

Antes de usar Cloud Machine Learning Engine con este instructivo, debes estar familiarizado con el aprendizaje automático y con TensorFlow. Para obtener más información, consulta el Curso intensivo de aprendizaje automático con la API de TensorFlow. Para obtener más recursos educativos sobre el aprendizaje automático, consulta Learn with Google IA.

Descripción general

En este documento, se proporciona una explicación de principio a fin sobre entrenamiento y predicción en Cloud Machine Learning Engine. Conocerás una muestra que usa un conjunto de datos del censo para realizar las siguientes acciones:

  • Crea una aplicación de entrenamiento TensorFlow y valídala de manera local.
  • Ejecuta tu trabajo de entrenamiento en una sola instancia de trabajador en la nube.
  • Ejecuta tu trabajo de entrenamiento como un trabajo de entrenamiento distribuido en la nube.
  • Optimiza tus hiperparámetros con el ajuste de hiperparámetros.
  • Implementa un modelo para asistir la predicción.
  • Solicita una predicción en línea y ve la respuesta.
  • Solicita una predicción de lote.

Qué compilarás

Con la muestra, se compila un modelo amplio y profundo para la predicción de la categoría de ingresos según el conjunto de datos de ingresos del censo de Estados Unidos. Las dos siguientes son las categorías de ingresos (también conocidas como etiquetas):

  • >50K: Mayor a 50,000 dólares
  • <=50K: Inferior o igual a 50,000 dólares

Los modelos amplios y profundos usan redes neuronales profundas (DNN) para aprender abstracciones de alto nivel sobre características complejas o interacciones entre estas características. Estos modelos luego combinan las salidas de la DNN con una regresión lineal realizada en características más simples. Esto proporciona un equilibrio entre potencia y velocidad que es efectivo en muchos problemas de datos estructurados.

Puedes obtener más información sobre modelos amplios y profundos en la entrada de blog de Google Research llamada Aprendizaje amplio y profundo: Better Together con TensorFlow.

La muestra define el modelo con la clase compilada previamente DNNCombinedLinearClassifier de TensorFlow. La muestra define las transformaciones de datos particulares del conjunto de datos del censo, luego asigna estas características (potencialmente) transformadas a la DNN o a la parte lineal del modelo.

Costos

En este instructivo, se usan componentes facturables de Google Cloud Platform, que incluyen los siguientes elementos:

  • Cloud Machine Learning Engine para:
    • Entrenamiento
    • Predicción
  • Cloud Storage para:
    • Almacenar datos de entrada para entrenamiento
    • Realizar la etapa de pruebas del paquete de aplicaciones de entrenamiento
    • Escribir artefactos de entrenamiento
    • Almacenar archivos de datos de entrada para la predicción por lotes

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Configura y prueba tu entorno de Cloud

Completa los siguientes pasos para configurar una cuenta de GCP, activar la API de Cloud ML Engine y también 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. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes 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 forma local en macOS o en un entorno remoto en Cloud Shell.

Para los usuarios de macOS, se recomienda configurar su entorno con 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 Cloud Machine Learning Engine, pero no es adecuada para el trabajo de desarrollo en curso.

macOS

  1. Comprueba la instalación de Python.
    Confirma que 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 está instalado pip cuando ejecutes 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. Comprueba si ya está instalado virtualenv cuando ejecutes virtualenv --version. De lo contrario, instala virtualenv:

    pip install --user --upgrade virtualenv

    Para crear un entorno de desarrollo aislado en 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 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 Google Cloud Shell en la parte superior de la ventana de la consola.

    Activa Google Cloud Shell

    Se abrirá una sesión de Cloud Shell dentro de un marco nuevo en la parte inferior de la consola y se mostrará un mensaje de línea de comandos. Es posible que esta sesión tarde unos segundos en inicializarse.

    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 de cierre).

Verifica los componentes del SDK de Google Cloud

Para verificar que los componentes del SDK de Google Cloud estén instalados, realiza las siguientes acciones:

  1. Enumera tus modelos:

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

    Listed 0 items.

    Después de comenzar a crear modelos, puedes verlos listados con este comando.

  3. Si instalaste gcloud anteriormente, actualiza gcloud:

    gcloud components update

Instala TensorFlow

Para instalar TensorFlow, ejecuta el siguiente comando:

pip install --user --upgrade tensorflow

Verifica la instalación:

python -c "import tensorflow as tf; print('TensorFlow version {} is installed.'.format(tf.VERSION))"

Puedes ignorar cualquier advertencia de que la biblioteca TensorFlow no se compiló para usar ciertas instrucciones.

Para obtener más información sobre la instalación de TensorFlow, incluidas otras opciones de instalación y también información sobre solución de problemas, consulta la documentación de TensorFlow

Compatibilidad con la versión de Python

En Cloud ML Engine, se ejecuta Python 2.7 de forma predeterminada, y el ejemplo de este instructivo usa Python 2.7.

Python 3.5 está disponible para entrenamiento cuando usa la versión 1.4 o superior del entorno de ejecución de Cloud ML Engine. La predicción en línea y por lotes funciona con modelos entrenados, independientemente de si se entrenaron con Python 2 o con Python 3.

Consulta cómo enviar un trabajo de entrenamiento con Python 3.5.

Descarga el código para este instructivo

  1. Descarga la muestra del repositorio de GitHub.

macOS

  1. Descarga y extrae el archivo ZIP de muestra de Cloud ML Engine.

    Descargar el archivo zip

  2. Abre una ventana de terminal y navega al directorio que contiene el directorio extraído cloudml-samples-master.

  3. Navega al directorio cloudml-samples-master > census > estimator. Los comandos en este instructivo se deben ejecutar desde el directorio estimator.

    cd cloudml-samples-master/census/estimator
    

Cloud Shell

  1. Ingresa el siguiente comando para descargar el archivo ZIP de muestra de Cloud ML Engine:

    wget https://github.com/GoogleCloudPlatform/cloudml-samples/archive/master.zip
    
  2. Descomprime el archivo para extraer el directorio cloudml-samples-master.

    unzip master.zip
    
  3. Navega al directorio cloudml-samples-master > census > estimator. Los comandos en este instructivo se deben ejecutar desde el directorio estimator.

    cd cloudml-samples-master/census/estimator
    

Desarrolla y valida tu aplicación de entrenamiento de manera local

Antes de ejecutar tu aplicación de entrenamiento en la nube, haz que se ejecute de manera local. Los entornos locales proporcionan un flujo de trabajo de desarrollo y validación eficiente para que puedas realizar iteraciones rápidamente. Además, no se generarán cargos por recursos en la nube cuando depures tu aplicación de forma local.

Obtén tus datos de entrenamiento

Los archivos de datos relevantes, adult.data y adult.test, están alojados en un depósito de Cloud Storage público. Para los fines de esta muestra, usa las versiones en Cloud Storage que se sometieron a una limpieza trivial, en lugar de los datos de fuente originales. Para obtener más información sobre los datos, consulta los siguientes puntos.

Puedes leer los archivos directamente desde Cloud Storage o copiarlos a tu entorno local. Para los fines de esta muestra, descargarás las muestras de entrenamiento local y las subirás en tu propio depósito de Cloud Storage a fin de realizar el entrenamiento en la nube.

  1. Descarga los datos a un directorio de archivos local y configura las variables que apuntan a los archivos de datos descargados:

    mkdir data
    gsutil -m cp gs://cloud-samples-data/ml-engine/census/data/* data/
    
  2. Configura las variables TRAIN_DATA y EVAL_DATA en tus rutas de archivo locales. Por ejemplo, con los siguientes comandos, se establecen las variables en rutas locales.

    TRAIN_DATA=$(pwd)/data/adult.data.csv
    EVAL_DATA=$(pwd)/data/adult.test.csv
    

Los datos se almacenan en formato de valores separados por comas, como se muestra en la siguiente vista previa del archivo adult.data:

39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K
38, Private, 215646, HS-grad, 9, Divorced, Handlers-cleaners, Not-in-family, White, Male, 0, 0, 40, United-States, <=50K
53, Private, 234721, 11th, 7, Married-civ-spouse, Handlers-cleaners, Husband, Black, Male, 0, 0, 40, United-States, <=50K
...

Instala dependencias

macOS

Para instalar TensorFlow de forma local, recomendamos usar un entorno virtual. Consulta cómo realizar las siguientes acciones:

Si estás familiarizado con Docker, puedes completar este instructivo dentro de un contenedor de TensorFlow. Consulta cómo instalar TensorFlow con Docker.

La muestra ofrece un archivo requirements.txt que se puede usar para instalar las dependencias requeridas por el proyecto. Dentro de tu entorno virtual, ingresa el siguiente comando:

  pip install --user -r ../requirements.txt

Cuando ejecutes este comando se instalará TensorFlow 1.10, el cual se usa en el instructivo.

Cloud Shell

Aunque TensorFlow está instalado en Cloud Shell, debes ejecutar el archivo de muestra requirements.txt para asegurarte de que estás usando la misma versión de TensorFlow que requiere la muestra.

  pip install --user -r ../requirements.txt

Cuando ejecutes este comando se instalará TensorFlow 1.10, el cual se usa en el instructivo.

Ejecuta un trabajo de entrenamiento local

Un trabajo local de entrenamiento carga tu programa de entrenamiento de Python y luego inicia un proceso de entrenamiento en un entorno similar al de un trabajo de entrenamiento activo en la nube de Cloud ML Engine.

  1. Especifica un directorio de salida y configura una variable MODEL_DIR. Con el siguiente comando, se establece MODEL_DIR en un valor de output.

    MODEL_DIR=output
    
  2. Se recomienda borrar el contenido del directorio de salida por si aún contiene datos de una ejecución de entrenamiento anterior. Con el siguiente comando, se borran todos los datos del directorio output.

    rm -rf $MODEL_DIR/*
    
  3. Para ejecutar tu entrenamiento de manera local, ejecuta el siguiente comando:

    gcloud ml-engine local train \
        --module-name trainer.task \
        --package-path trainer/ \
        --job-dir $MODEL_DIR \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100
    

De manera predeterminada, el registro detallado está desactivado. Puedes habilitarlo si configuras la etiqueta --verbosity en DEBUG. En un ejemplo posterior se muestra cómo habilitarlo.

Inspecciona los registros de resumen con Tensorboard

Para ver los resultados de la evaluación, puedes usar la herramienta de visualización llamada TensorBoard. Con TensorBoard, puedes visualizar tu grafo de TensorFlow, trazar métricas cuantitativas sobre la ejecución de tu grafo y mostrar datos adicionales como imágenes que pasan a través del grafo. Tensorboard está disponible como parte de la instalación de TensorFlow.

Sigue los pasos a continuación para iniciar TensorBoard y señalarlo en los registros de resumen producidos durante el entrenamiento, tanto durante como después de la ejecución.

macOS

  1. Inicia TensorBoard:

    tensorboard --logdir=$MODEL_DIR
    
  2. Cuando hayas comenzado a ejecutar TensorBoard, puedes acceder a él en tu navegador en http://localhost:6006.

Cloud Shell

  1. Inicia TensorBoard:

    tensorboard --logdir=$MODEL_DIR --port=8080
    
  2. Selecciona "Vista previa en el puerto 8080" en el menú Vista previa Web en la parte superior de la línea de comandos.

Haz clic en accuracy (precisión) para ver representaciones gráficas de cómo cambia la precisión a medida que tu trabajo avanza.

Grafo de precisión de Tensorboard

Puedes apagar TensorBoard en cualquier momento cuando escribas ctrl+c en la línea de comandos.

Ejecuta un trabajo de entrenamiento local en modo distribuido

Puedes probar si tu modelo funciona con el entorno de ejecución distribuido de Cloud ML Engine cuando ejecutes un trabajo de entrenamiento local con el indicador --distributed.

  1. Especifica un directorio de salida y establece la variable MODEL_DIR nuevamente. Con el siguiente comando, se establece MODEL_DIR en un valor de output-dist.

    MODEL_DIR=output-dist
    
  2. Borra el contenido del directorio de output por si aún contiene datos de una ejecución de entrenamiento anterior.

    rm -rf $MODEL_DIR/*
    
  3. Ejecuta el comando local train con la opción --distributed. Asegúrate de colocar la marca encima del -- que separa los argumentos del usuario de los argumentos de la línea de comandos.

    gcloud ml-engine local train \
        --module-name trainer.task \
        --package-path trainer/ \
        --job-dir $MODEL_DIR \
        --distributed \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100
    

Inspecciona el resultado

Los archivos de salida se escriben en el directorio especificado por --job-dir, que se estableció en output-dist:

ls -R output-dist/

Deberías ver un resultado similar a este:

checkpoint
eval
events.out.tfevents.1488577094.<host-name>
export
graph.pbtxt
model.ckpt-1000.data-00000-of-00001
model.ckpt-1000.index
model.ckpt-1000.meta
model.ckpt-2.data-00000-of-00001
model.ckpt-2.index
model.ckpt-2.meta

output-dist//eval:
events.out.tfevents.<timestamp>.<host-name>
events.out.tfevents.<timestamp><host-name>
events.out.tfevents.<timestamp>.<host-name>

output-dist//export:
census

output-dist//export/census:
<timestamp>

output-dist//export/census/<timestamp>:
saved_model.pb
variables
...

Inspecciona los registros

Inspecciona los registros de resumen con Tensorboard de la misma forma que para el trabajo de entrenamiento de una sola instancia, excepto que debes cambiar el valor --logdir a fin de que coincida con el nombre del directorio de salida que usaste para el modo distribuido.

macOS

  1. Inicia TensorBoard:

    tensorboard --logdir=$MODEL_DIR
    
  2. Cuando hayas comenzado a ejecutar TensorBoard, puedes acceder a él en tu navegador en http://localhost:6006.

Cloud Shell

  1. Inicia TensorBoard:

    tensorboard --logdir=$MODEL_DIR --port=8080
    
  2. Selecciona "Vista previa en el puerto 8080" en el menú Vista previa Web en la parte superior de la línea de comandos.

Configura tu depósito de Cloud Storage

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 configura una variable de entorno "REGION".

    Por ejemplo, el siguiente código crea una REGION y se configura 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 utiliza en las instrucciones de introducción.

Sube los archivos de datos a tu depósito de Cloud Storage.

  1. Usa gsutil para copiar los dos archivos a tu depósito de Cloud Storage.

    gsutil cp -r data gs://$BUCKET_NAME/data
    
  2. Configura las variables TRAIN_DATA y EVAL_DATA para apuntar a los archivos.

    TRAIN_DATA=gs://$BUCKET_NAME/data/adult.data.csv
    EVAL_DATA=gs://$BUCKET_NAME/data/adult.test.csv
    
  3. Usa gsutil nuevamente para copiar el archivo de prueba JSON test.json en tu depósito de Cloud Storage.

    gsutil cp ../test.json gs://$BUCKET_NAME/data/test.json
    
  4. Configura la variable TEST_JSON para apuntar al archivo.

    TEST_JSON=gs://$BUCKET_NAME/data/test.json
    

Ejecuta un trabajo de entrenamiento de instancia única en la nube

Ya con un trabajo de entrenamiento validado que se ejecuta en modo de instancia única y distribuido, ahora estás listo para ejecutar un trabajo de entrenamiento en la nube. Comenzarás con la solicitud de un trabajo de entrenamiento de instancia única.

Usa el nivel de escala predeterminado BASIC para ejecutar un trabajo de entrenamiento de instancia única. La solicitud inicial de trabajo puede tardar unos minutos en iniciarse, pero los trabajos posteriores se ejecutan más rápidamente. Esto habilita una iteración rápida a medida que desarrollas y validas tu trabajo de entrenamiento.

  1. Selecciona un nombre para la ejecución de entrenamiento inicial que la distinga de cualquier ejecución de entrenamiento posterior. Por ejemplo, puedes agregar un número para representar la iteración.

    JOB_NAME=census_single_1
    
  2. Especifica un directorio para el resultado generado por Cloud ML Engine mediante la configuración de una variable OUTPUT_PATH que vas a incluir cuando solicites trabajos de entrenamiento y predicción. OUTPUT_PATH representa la ubicación de almacenamiento en Cloud Storage totalmente calificada para puntos de control de modelo, resúmenes y exportaciones. Puedes usar la variable BUCKET_NAME que definiste en un paso anterior.

    Recomendamos usar el nombre del trabajo como el directorio de salida. Por ejemplo, la siguiente OUTPUT_PATH apunta a un directorio llamado census_single_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Ejecuta el siguiente comando para enviar un trabajo de entrenamiento en la nube que use un proceso único. Esta vez, configura la etiqueta --verbosity en DEBUG para que puedas inspeccionar el resultado del registro completo y recuperar métricas de precisión y pérdida, entre otras. El resultado también contiene una serie de otros mensajes de advertencia que puedes ignorar para los fines de este ejemplo.

    gcloud ml-engine jobs submit training $JOB_NAME \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --eval-steps 100 \
        --verbosity DEBUG
    

Puedes supervisar el progreso de tu trabajo de entrenamiento cuando mires el resultado de la línea de comandos o en ML Engine > Trabajos en Google Cloud Platform Console.

Inspecciona el resultado

En el entrenamiento en la nube, los resultados se producen en Cloud Storage. En este ejemplo, los resultados se guardan en OUTPUT_PATH, para enumerarlos, ejecuta el siguiente comando:

gsutil ls -r $OUTPUT_PATH

Los resultados deben ser similares a los resultados del entrenamiento local (arriba).

Inspecciona los registros de Stackdriver

Los registros son una forma útil de comprender el comportamiento de tu código de entrenamiento en la nube. Cuando se ejecuta un trabajo de entrenamiento en Cloud ML Engine, se capturan todas las secuencias stdout y stderr y las instrucciones de registro. Estos registros se almacenan en Stackdriver Logging y son visibles tanto durante como después de la ejecución.

La forma más fácil de encontrar los registros para tu trabajo es seleccionar tu trabajo en ML Engine > Trabajos en la GCP Console y hacer clic en "Ver registros".

Si dejas seleccionados "Todos los registros", verás todos los registros de todos los trabajadores. También puedes seleccionar una tarea específica: Con master-replica-0 tienes una visión general de la ejecución del trabajo desde la perspectiva de la instancia principal.

Debido a que seleccionaste el registro detallado, puedes inspeccionar el resultado del registro completo. Busca el término accuracy en los registros:

captura de pantalla de la consola de Stackdriver Logging para trabajos de ML Engine

Si quieres ver estos registros en tu terminal, puedes hacerlo desde la línea de comandos con el siguiente comando:

gcloud ml-engine jobs stream-logs $JOB_NAME

Consulta todas las opciones para gcloud ml-engine jobs stream-logs.

Inspecciona los registros de resumen con Tensorboard

Puedes inspeccionar el comportamiento de tu trabajo de entrenamiento cuando inicies TensorBoard y lo apuntes a los registros de resumen producidos durante el entrenamiento, tanto durante como después de la ejecución.

Debido a que con los programas de entrenamiento se escriben resúmenes directamente en una ubicación de Cloud Storage, Tensorboard puede leerlos automáticamente sin copiar manualmente los archivos de eventos.

macOS

  1. Inicia TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH
    
  2. Cuando hayas comenzado a ejecutar TensorBoard, puedes acceder a él en tu navegador en http://localhost:6006.

Cloud Shell

  1. Inicia TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH --port=8080
    
  2. Selecciona "Vista previa en el puerto 8080" en el menú Vista previa Web en la parte superior de la línea de comandos.

Haz clic en accuracy (precisión) para ver representaciones gráficas de cómo cambia la precisión a medida que tu trabajo avanza.

Puedes apagar TensorBoard en cualquier momento cuando escribas ctrl+c en la línea de comandos.

Ejecuta el entrenamiento distribuido en la nube

Para aprovechar la infraestructura escalable de Google cuando ejecutes trabajos de entrenamiento, configura tu trabajo de entrenamiento para que se ejecute en modo distribuido.

No es necesario realizar cambios de código para ejecutar este modelo como un proceso distribuido en Cloud ML Engine.

Para ejecutar un trabajo distribuido, configura --scale-tier en cualquier nivel superior al básico. Para obtener más información sobre los niveles de escala, consulta la documentación de nivel de escala.

  1. Selecciona un nombre para tu trabajo de entrenamiento distribuido que lo distinga de otros trabajos de entrenamiento. Por ejemplo, podrías usar dist a fin de representar lo distribuido y un número para representar la iteración.

    JOB_NAME=census_dist_1
    
  2. Especifica OUTPUT_PATH para incluir el nombre del trabajo a fin de que no vuelvas a usar puntos de control de forma involuntaria entre trabajos. Es posible que tengas que redefinir BUCKET_NAME si iniciaste una sesión de línea de comandos nueva desde la última vez que lo definiste. Por ejemplo, la siguiente OUTPUT_PATH apunta a un directorio llamado census-dist-1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Ejecuta el siguiente comando para enviar un trabajo de capacitación en la nube que use varios trabajadores. Ten en cuenta que el trabajo puede tardar unos minutos en comenzar.

    Coloca --scale-tier sobre el -- que separa los argumentos del usuario de los argumentos de la línea de comandos. Por ejemplo, el siguiente comando usa un nivel de escala de STANDARD_1:

    gcloud ml-engine jobs submit training $JOB_NAME \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        --scale-tier STANDARD_1 \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --verbosity DEBUG  \
        --eval-steps 100
    

Puedes supervisar el progreso de tu trabajo cuando miras el resultado de la línea de comandos o en ML Engine > Trabajos en Google Cloud Platform Console.

Inspecciona los registros

Inspecciona los registros de Stackdriver y los registros de resumen de la misma manera que lo hiciste para el trabajo de entrenamiento de instancia única.

Para los registros de Stackdriver: Selecciona tu trabajo de ML Engine > Trabajos en GCP Console y haz clic en Ver registros o usa el siguiente comando desde tu terminal:

gcloud ml-engine jobs stream-logs $JOB_NAME

Para TensorBoard:

macOS

  1. Inicia TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH
    
  2. Cuando hayas comenzado a ejecutar TensorBoard, puedes acceder a él en tu navegador en http://localhost:6006.

Cloud Shell

  1. Inicia TensorBoard:

    tensorboard --logdir=$OUTPUT_PATH --port=8080
    
  2. Selecciona "Vista previa en el puerto 8080" en el menú Vista previa Web en la parte superior de la línea de comandos.

Ajuste de hiperparámetros

En Cloud ML Engine, se ofrece ajuste de hiperparámetros para ayudarte a maximizar la precisión predictiva de tu modelo. La muestra de censo almacena los ajustes de configuración del hiperparámetro en un archivo YAML llamado hptuning_config.yaml y también incluye el archivo en la solicitud de entrenamiento con la variable --config.

  1. Selecciona un nombre de trabajo nuevo y crea una variable que haga referencia al archivo de configuración.

    HPTUNING_CONFIG=../hptuning_config.yaml
    JOB_NAME=census_core_hptune_1
    TRAIN_DATA=gs://$BUCKET_NAME/data/adult.data.csv
    EVAL_DATA=gs://$BUCKET_NAME/data/adult.test.csv
    
  2. Especifica OUTPUT_PATH para incluir el nombre del trabajo a fin de que no vuelvas a usar puntos de control de forma involuntaria entre trabajos. Es posible que tengas que redefinir BUCKET_NAME si iniciaste una sesión de línea de comandos nueva desde la última vez que lo definiste. Por ejemplo, la siguiente OUTPUT_PATH apunta a un directorio llamado census_core_hptune_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Ejecuta el siguiente comando para enviar un trabajo de entrenamiento que no solo use varios trabajadores, sino que también use el ajuste de hiperparámetros.

    gcloud ml-engine jobs submit training $JOB_NAME \
        --stream-logs \
        --job-dir $OUTPUT_PATH \
        --runtime-version 1.10 \
        --config $HPTUNING_CONFIG \
        --module-name trainer.task \
        --package-path trainer/ \
        --region $REGION \
        --scale-tier STANDARD_1 \
        -- \
        --train-files $TRAIN_DATA \
        --eval-files $EVAL_DATA \
        --train-steps 1000 \
        --verbosity DEBUG  \
        --eval-steps 100
    

Para obtener más información sobre el ajuste de hiperparámetros, consulta la descripción general del ajuste de hiperparámetros.

Implementa un modelo para asistir la predicción

  1. Elige un nombre para tu modelo, este debe comenzar con una letra y contener solo letras, números y guiones bajos. Por ejemplo:

    MODEL_NAME=census
    
  2. Crea un modelo de Cloud ML Engine:

    gcloud ml-engine models create $MODEL_NAME --regions=$REGION
    
  3. Selecciona el resultado de trabajo para usar. La siguiente muestra usa el trabajo llamado census_dist_1.

    OUTPUT_PATH=gs://$BUCKET_NAME/census_dist_1
    
  4. Busca la ruta completa de tus objetos binarios de modelo entrenados y exportados:

    gsutil ls -r $OUTPUT_PATH/export
    
  5. Busca un directorio llamado $OUTPUT_PATH/export/census/<timestamp> y copia esta ruta del directorio (sin los : al final) y configura la variable de entorno MODEL_BINARIES en su valor. Por ejemplo:

    MODEL_BINARIES=gs://$BUCKET_NAME/census_dist_1/export/census/1487877383942/

    En el que $BUCKET_NAME es el nombre del depósito de Cloud Storage y census_dist_1 es el directorio de salida.

  6. Ejecuta el siguiente comando para crear una versión v1:

    gcloud ml-engine versions create v1 \
        --model $MODEL_NAME \
        --origin $MODEL_BINARIES \
        --runtime-version 1.10
    

Puedes obtener una lista de tus modelos con el comando models list.

gcloud ml-engine models list

Envía una solicitud de predicción en línea a un modelo implementado

Ahora puedes enviar solicitudes de predicción a tu modelo. Por ejemplo, con el siguiente comando, se envía una solicitud de predicción en línea con un archivo test.json que descargaste como parte del repositorio de muestra de GitHub.

gcloud ml-engine predict \
    --model $MODEL_NAME \
    --version v1 \
    --json-instances ../test.json

La respuesta incluye las probabilidades de cada etiqueta (>50K y <=50K) según la entrada de datos en test.json, se indica así si el ingreso previsto es mayor que o menor que 50,000 dólares.

La respuesta es similar a la que se muestra a continuación:

CLASSES       PROBABILITIES
[u'0', u'1']  [0.9969545602798462, 0.0030454816296696663]

Envía un trabajo de predicción por lotes

El servicio de predicción por lotes es útil si tienes grandes cantidades de datos y no hay requisitos de latencia para recibir los resultados de predicción. Para esto, se usa el mismo formato que la predicción en línea, pero se requiere que los datos se almacenen en Cloud Storage.

  1. Configura un nombre para el trabajo.

    JOB_NAME=census_prediction_1
    
  2. Configura la ruta de salida.

    OUTPUT_PATH=gs://$BUCKET_NAME/$JOB_NAME
    
  3. Envía el trabajo de predicción.

    gcloud ml-engine jobs submit prediction $JOB_NAME \
        --model $MODEL_NAME \
        --version v1 \
        --data-format JSON \
        --region $REGION \
        --input-paths $TEST_JSON \
        --output-path $OUTPUT_PATH/predictions
    

A diferencia de los comandos anteriores, este se muestra inmediatamente. Comprueba el progreso del trabajo y espera a que termine:

gcloud ml-engine jobs describe $JOB_NAME

Deberías ver state: SUCCEEDED una vez que se completa el trabajo, esto puede tomar varios minutos. También puedes ver los registros de trabajos en tu terminal con el siguiente comando

gcloud ml-engine jobs stream-logs $JOB_NAME

De forma alternativa, puedes verificar el progreso en ML Engine > Trabajos en GCP Console.

Después de que el trabajo se realice correctamente, puedes hacer lo siguiente:

  • Lee el resumen de resultados.

    gsutil cat $OUTPUT_PATH/predictions/prediction.results-00000-of-00001
    

    Deberías ver un resultado similar al siguiente:

    {"probabilities": [0.9962924122810364, 0.003707568161189556], "logits": [-5.593664646148682], "classes": 0, "logistic": [0.003707568161189556]}
    
  • Enumera los otros archivos que se produjeron en el trabajo con el comando gsutil ls.

    gsutil ls -r $OUTPUT_PATH
    

En comparación con la predicción en línea, la predicción por lotes tiene las siguientes características:

  • Es más lento para esta pequeña cantidad de instancias (pero es más adecuado si tienes muchas).
  • Puede mostrar un resultado en un orden diferente al de la entrada (pero el índice numérico permite que cada resultado coincida con su instancia de entrada correspondiente, esto no es necesario para la predicción en línea, ya que los resultados se muestran en el mismo orden que las instancias de entrada originales).

Una vez que las predicciones están disponibles, el siguiente paso generalmente es transferir estas predicciones a una base de datos o a una canalización de procesamiento de datos.

En este ejemplo, se implementó el modelo antes de ejecutar la predicción por lotes, pero es posible omitir ese paso si especificas el URI de los objetos binarios del modelo cuando envíes el trabajo de predicción por lotes. Una ventaja de generar predicciones a partir de un modelo antes de implementarlo es que puedes evaluar el rendimiento del modelo en diferentes conjuntos de datos de evaluación para ayudarte a decidir si el modelo cumple con tus criterios de implementación.

Limpieza

Si terminaste de analizar los resultados de tus ejecuciones de entrenamiento y predicción, puedes evitar generar cargos adicionales a tu cuenta de GCP para los directorios de Cloud Storage usados en esta guía con los siguientes pasos:

  1. Abre una ventana de terminal (si no está abierta).

  2. Usa el comando gsutil rm con la marca -r para borrar el directorio que contiene tu trabajo más reciente:

    gsutil rm -r gs://$BUCKET_NAME/$JOB_NAME
    

Si se ejecuta correctamente, el comando mostrará un mensaje similar a este:

Removing gs://my-awesome-bucket/just-a-folder/cloud-storage.logo.png#1456530077282000...
Removing gs://my-awesome-bucket/...

Repite el comando en cualquier otro directorio que hayas creado para esta muestra.

De forma alternativa, si no tienes otros datos almacenados en el depósito, puedes ejecutar el comando gsutil rm -r en el depósito.

Acerca de los datos

El Conjunto de datos de ingresos del censo, que usa esta muestra para el entrenamiento, está alojado en UC Irvine Machine Learning Repository.

Datos del censo de cortesía de Lichman, M. (2013). UCI Machine Learning Repository http://archive.ics.uci.edu/ml. Irvine, CA: University of California, School of Information and Computer Science. Este conjunto de datos está disponible públicamente para que cualquier persona pueda usarlo según los siguientes términos proporcionados por la fuente del conjunto de datos: http://archive.ics.uci.edu/ml, y se brinda “TAL CUAL”, sin ninguna garantía, expresa o implícita, de Google. Google renuncia a toda responsabilidad de cualquier daño, directo o indirecto, como resultado del uso del conjunto de datos.

¿Qué sigue?

Ahora completaste la explicación de un ejemplo de Cloud ML Engine que usa datos de censos para entrenamiento y predicción. Validaste el trabajo de entrenamiento de manera local, lo ejecutaste en la nube, tanto en modo de instancia única como en modo distribuido, usaste el ajuste de hiperparámetro para mejorar el modelo y también el modelo a fin de obtener predicciones en línea y por lotes.

Los siguientes recursos pueden ayudarte a obtener más información sobre Cloud ML Engine.

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Cloud ML Engine para TensorFlow