Primeros pasos: Entrenamiento y predicción con Keras

Logotipo de Colab Ejecuta este instructivo como un notebook en Colab Logotipo de GitHub Visualiza el notebook en GitHub

En este instructivo, se muestra cómo entrenar una red neuronal en AI Platform mediante la API secuencial de Keras y cómo entregar predicciones a partir de ese modelo.

Keras es una API de alto nivel para compilar y entrenar modelos de aprendizaje profundo. tf.keras es la implementación de TensorFlow de esta API.

En las dos primeras partes del instructivo, se explica cómo entrenar un modelo en AI Platform mediante un código de Keras escrito con anterioridad, cómo implementar el modelo entrenado en AI Platform y cómo entregar predicciones en línea desde el modelo implementado.

En la última parte de este instructivo, se habla sobre el código de entrenamiento que se usa para el modelo y sobre el proceso de asegurarse de que sea compatible de con AI Platform. Si quieres obtener más información sobre cómo compilar modelos de aprendizaje automático en Keras, consulta instructivos sobre Keras de TensorFlow.

Conjunto de datos

En este instructivo, se usa el conjunto de datos de ingresos del censo de Estados Unidos que brinda UC Irvine Machine Learning Repository. Este conjunto de datos contiene información sobre personas proveniente de una base de datos del censo de 1994 en el que se incluyen edad, educación, estado civil, ocupación y si ganan, o no, más de $50,000 al año.

Objetivo

El objetivo es entrenar una red neuronal profunda (DNN) mediante Keras que prediga si una persona gana más de $50,000 al año (etiqueta objetivo) en función de otra información sobre la persona (atributos) proveniente del censo.

Este instructivo se centra más en el uso de este modelo con AI Platform que en el diseño del modelo en sí. Sin embargo, cuando se compilan sistemas de aprendizaje automático, siempre es importante considerar los posibles problemas y las consecuencias no deseadas. Consulta el ejercicio sobre equidad del Curso intensivo de aprendizaje automático para obtener más información sobre fuentes de sesgo en el conjunto de datos del censo y sobre la equidad del aprendizaje automático en general.

Costos

En este instructivo se usan componentes facturables de Google Cloud (Google Cloud):

  • AI Platform Training
  • AI Platform Prediction
  • Cloud Storage

Obtén información sobre los precios de AI Platform Training, AI Platform Prediction y Cloud Storage, y usa la calculadora de precios para calcular una estimación de costos en función del uso previsto.

Antes de comenzar

Debes completar varios pasos antes de poder entrenar e implementar un modelo en AI Platform:

  • Configura el entorno de desarrollo local.
  • Configura un proyecto de Google Cloud que tenga habilitadas la facturación y las API necesarias.
  • Crea un depósito de Cloud Storage para almacenar el paquete de entrenamiento y el modelo entrenado.

Configura el entorno de desarrollo local

Para completar este instructivo, necesitarás lo siguiente:

  • Git
  • Python 3
  • virtualenv
  • El SDK de Cloud

En la guía de Google Cloud Configura un entorno de desarrollo de Python, se brindan instrucciones detalladas para cumplir con estos requisitos. En los siguientes pasos, se brinda un conjunto abreviado de instrucciones:

  1. Instala Python 3.

  2. Instala virtualenv y crea un entorno virtual que use Python 3.

  3. Activa ese entorno.

  4. Completa los pasos en la siguiente sección para instalar el SDK de Cloud.

Configura el proyecto de Google Cloud

  1. Accede a tu Cuenta de Google.

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

  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir a la página del selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

  4. Habilita las API de AI Platform Training & Prediction and Compute Engine.

    Habilita las API

  5. Instala e inicializa el SDK de Cloud.

Autentica la cuenta de GCP

Para configurar la autenticación, debes crear una clave de cuenta de servicio y establecer una variable de entorno para la ruta de acceso del archivo a la clave de la cuenta de servicio.

  1. Crea una clave de cuenta de servicio para realizar la autenticación:
    1. En Cloud Console, ve a la página Crear clave de la cuenta de servicio.

      Ir a la página Crea una clave de la cuenta de servicio
    2. En la lista desplegable de Cuenta de servicio, selecciona Nueva cuenta de servicio.
    3. Ingresa un nombre en el campo Nombre de cuenta de servicio.
    4. En la lista desplegable Función, selecciona Machine Learning Engine > Administrador de ML Engine y Almacenamiento > Administrador de objeto de almacenamiento.

      Nota: En el campo Función, se autoriza el acceso de tu cuenta de servicio a los recursos. Puedes ver y cambiar este campo más adelante con Cloud Console. Si desarrollas una app de producción, es posible que tengas que especificar permisos más detallados que Machine Learning Engine > Administrador de ML Engine y Almacenamiento > Administrador de objeto de almacenamiento. Para obtener más información, consulta el control de acceso de AI Platform.
    5. Haz clic en Crear. Se descargará en tu computadora un archivo JSON que contiene tu clave.
  2. Configura la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en la ruta de acceso del archivo JSON que contiene la clave de tu cuenta de servicio. Esta variable solo se aplica a tu sesión actual de shell. Por lo tanto, si abres una sesión nueva, deberás volver a configurar la variable.

Cree un depósito de Cloud Storage

Cuando envías un trabajo de entrenamiento mediante el SDK de Cloud, subes un paquete de Python que contiene tu código de entrenamiento a un depósito de Cloud Storage. AI Platform ejecuta el código de este paquete. En este instructivo, AI Platform también guarda un modelo entrenado que surge de tu trabajo en el mismo depósito. De este modo, puedes crear una versión del modelo de AI Platform para entregar predicciones en línea basada en este resultado.

Establece el nombre de tu depósito de Cloud Storage como una variable de entorno. Debe ser único en todos los depósitos de Cloud Storage:

BUCKET_NAME="your-bucket-name"

Selecciona una región en la que estén disponibles AI Platform Training y AI Platform Prediction, y crea otra variable de entorno. Por ejemplo:

REGION="us-central1"

Crea tu depósito de Cloud Storage en esta región y, a continuación, usa la misma región para el entrenamiento y la predicción. Ejecuta el siguiente comando para crear el depósito si todavía no existe:

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

Guía de inicio rápido para entrenar en AI Platform

En esta sección del instructivo, se explica cómo enviar un trabajo de entrenamiento a AI Platform. Este trabajo ejecuta un código de muestra que utiliza Keras para entrenar una red neuronal profunda en los datos del censo de Estados Unidos. El resultado es el modelo entrenado como un directorio modelo guardado de TensorFlow en tu depósito de Cloud Storage.

Obtén un código de entrenamiento y dependencias

Primero, descarga el código de entrenamiento y cambia el directorio de trabajo:

# Clone the repository of AI Platform samples
git clone --depth 1 https://github.com/GoogleCloudPlatform/cloudml-samples

# Set the working directory to the sample code directory
cd cloudml-samples/census/tf-keras

Ten en cuenta que el código de entrenamiento se estructura como un paquete de Python en el subdirectorio trainer/:

# `ls` shows the working directory's contents. The `p` flag adds trailing
# slashes to subdirectory names. The `R` flag lists subdirectories recursively.
ls -pR
.:
README.md  requirements.txt  trainer/

./trainer:
__init__.py  model.py  task.py  util.py

A continuación, instala las dependencias de Python necesarias para entrenar el modelo de forma local:

pip install -r requirements.txt

Cuando ejecutas el trabajo de entrenamiento en AI Platform, las dependencias se preinstalan según la versión del entorno de ejecución que elijas.

Entrena tu modelo localmente

Antes de entrenar en AI Platform, entrena el trabajo localmente para verificar que la estructura del archivo y el empaquetado sean correctas.

Para un trabajo complejo o de uso intensivo de recursos, recomendamos hacer un entrenamiento local en una muestra pequeña de tu conjunto de datos para verificar tu código. Luego puedes ejecutar tu trabajo en AI Platform para entrenar todo el conjunto de datos.

Esta muestra ejecuta un trabajo relativamente rápido en un pequeño conjunto de datos, por lo que el entrenamiento local y el trabajo de AI Platform ejecutan el mismo código en los mismos datos.

Ejecuta el siguiente comando para entrenar el modelo localmente:

# This is similar to `python -m trainer.task --job-dir local-training-output`
# but it better replicates the AI Platform environment, especially
# for distributed training (not applicable here).
gcloud ai-platform local train \
  --package-path trainer \
  --module-name trainer.task \
  --job-dir local-training-output

Observa el progreso del entrenamiento en tu shell. Cuando finaliza, la aplicación del entrenamiento exporta el modelo entrenado e imprime un mensaje como el siguiente:

Model exported to:  local-training-output/keras_export/1553709223

Entrena tu modelo con AI Platform

A continuación, envía un trabajo de entrenamiento a AI Platform. Esto ejecuta el modelo de entrenamiento en la nube y exporta el modelo entrenado a Cloud Storage.

Primero, asígnale un nombre a tu trabajo de entrenamiento y elige un directorio dentro de tu depósito de Cloud Storage para guardar archivos intermedios y de resultados. Establécelas como variables de entorno. Por ejemplo:

JOB_NAME="my_first_keras_job"
JOB_DIR="gs://$BUCKET_NAME/keras-job-dir"

Ejecuta el siguiente comando para empaquetar el directorio trainer/, subirlo al --job-dir especificado y, luego, indicarle a AI Platform que ejecute el módulo trainer.task desde ese paquete.

La marca --stream-logs te permite ver los registros de entrenamiento en la shell. También puedes ver los registros y otros detalles del trabajo en Google Cloud Console.

gcloud ai-platform jobs submit training $JOB_NAME \
  --package-path trainer/ \
  --module-name trainer.task \
  --region $REGION \
  --python-version 3.7 \
  --runtime-version 1.15 \
  --job-dir $JOB_DIR \
  --stream-logs

Esto puede demorar más que el entrenamiento local, pero puedes ver el progreso del entrenamiento en la shell de forma parecida. Cuando finaliza, el trabajo de entrenamiento exporta el modelo entrenado en tu depósito de Cloud Storage e imprime un mensaje como el siguiente:

INFO    2019-03-27 17:57:11 +0000   master-replica-0        Model exported to:  gs://your-bucket-name/keras-job-dir/keras_export/1553709421
INFO    2019-03-27 17:57:11 +0000   master-replica-0        Module completed; cleaning up.
INFO    2019-03-27 17:57:11 +0000   master-replica-0        Clean up finished.
INFO    2019-03-27 17:57:11 +0000   master-replica-0        Task completed successfully.

Ajuste de hiperparámetros

Tienes la opción de realizar un ajuste de hiperparámetros mediante el archivo de configuración incluido hptuning_config.yaml. Este archivo le indica a AI Platform que ajuste el tamaño del lote y la tasa de aprendizaje para entrenarse a través de diferentes pruebas a fin de maximizar la precisión.

En este ejemplo, el código de entrenamiento usa una devolución de llamada de TensorBoard, que crea SummaryEvent de TensorFlow durante el entrenamiento. AI Platform usa estos eventos para rastrear la métrica que deseas optimizar. Obtén más información sobre el ajuste de hiperparámetros en AI Platform Training.

gcloud ai-platform jobs submit training ${JOB_NAME}_hpt \
  --config hptuning_config.yaml \
  --package-path trainer/ \
  --module-name trainer.task \
  --region $REGION \
  --python-version 3.7 \
  --runtime-version 1.15 \
  --job-dir $JOB_DIR \
  --stream-logs

Guía de inicio rápido para predicciones en línea en AI Platform

En esta sección, se muestra cómo utilizar AI Platform y el modelo entrenado de la sección anterior para predecir el nivel de ingresos de una persona a partir de la información del censo sobre ellos.

Crea recursos de modelos y versiones en AI Platform

Para entregar predicciones en línea mediante el modelo que entrenaste y exportaste en la guía de inicio rápido sobre entrenamiento, crea un recurso de modelo en AI Platform y un recurso de versión dentro de este. El recurso de versión es lo que realmente usa tu modelo entrenado para entregar predicciones. Esta estructura te permite ajustar y volver a entrenar tu modelo muchas veces, y organizar todas las versiones juntas en AI Platform. Obtén más información sobre modelos y versiones.

Primero, nombra y crea el recurso de modelo:

MODEL_NAME="my_first_keras_model"

gcloud ai-platform models create $MODEL_NAME \
  --regions $REGION
Created ml engine model [projects/your-project-id/models/my_first_keras_model].

A continuación, crea la versión del modelo. Mediante el trabajo de entrenamiento de la guía de inicio rápido sobre entrenamiento se exportó un directorio de modelo guardado de TensorFlow con marca de tiempo en tu depósito de Cloud Storage. AI Platform usa este directorio para crear una versión del modelo. Obtén más información sobre los modelos guardados y AI Platform.

Tal vez puedas encontrar la ruta a este directorio en los registros de tu trabajo de entrenamiento. Busca una línea como la que se muestra a continuación:

Model exported to:  gs://your-bucket-name/keras-job-dir/keras_export/1545439782

Ejecuta el siguiente comando a fin de identificar tu directorio de modelo guardado y úsalo para crear un recurso de versión del modelo:

MODEL_VERSION="v1"

# Get a list of directories in the `keras_export` parent directory. Then pick
# the directory with the latest timestamp, in case you've trained multiple
# times.
SAVED_MODEL_PATH=$(gsutil ls $JOB_DIR/keras_export | tail -n 1)

# Create model version based on that SavedModel directory
gcloud ai-platform versions create $MODEL_VERSION \
  --model $MODEL_NAME \
  --runtime-version 1.15 \
  --python-version 3.7 \
  --framework tensorflow \
  --origin $SAVED_MODEL_PATH

Prepara las entradas para la predicción

A fin de recibir predicciones válidas y útiles, debes procesar las entradas para las predicciones de la misma manera en que se procesaron los datos del entrenamiento. En un sistema de producción, se recomienda crear una canalización de procesamiento previo que pueda usarse de forma idéntica en el momento del entrenamiento y de la predicción.

Para este ejercicio, usa el código de carga de datos del paquete de entrenamiento a fin de seleccionar una muestra aleatoria de los datos de evaluación. Estos datos están en el formato que se usó para evaluar la precisión después de cada ciclo de entrenamiento, por lo que se puede usar para enviar predicciones de prueba sin más procesamiento previo.

Abre el intérprete de Python (python) desde tu directorio de trabajo actual para ejecutar los siguientes fragmentos de código:

from trainer import util

_, _, eval_x, eval_y = util.load_data()

prediction_input = eval_x.sample(20)
prediction_targets = eval_y[prediction_input.index]

prediction_input
age workclass education_num marital_status occupation relationship race capital_gain capital_loss hours_per_week native_country
1,979 0.901213 1 1.525542 2 9 0 4 -0.144792 -0.217132 -0.437544 38
2,430 -0.922154 3 -0.419265 4 2 3 4 -0.144792 -0.217132 -0.034039 38
4,214 -1.213893 3 -0.030304 4 10 1 4 -0.144792 -0.217132 1.579979 38
10,389 -0.630415 3 0.358658 4 0 3 4 -0.144792 -0.217132 -0.679647 38
14,525 -1.505632 3 -1.586149 4 7 3 0 -0.144792 -0.217132 -0.034039 38
15,040 -0.119873 5 0.358658 2 2 0 4 -0.144792 -0.217132 -0.841048 38
8,409 0.244801 3 1.525542 2 9 0 4 -0.144792 -0.217132 1.176475 6
10,628 0.098931 1 1.525542 2 9 0 4 0.886847 -0.217132 -0.034039 38
10,942 0.390670 5 -0.030304 2 4 0 4 -0.144792 -0.217132 4.727315 38
5,129 1.120017 3 1.136580 2 12 0 4 -0.144792 -0.217132 -0.034039 38
2,096 -1.286827 3 -0.030304 4 11 3 4 -0.144792 -0.217132 -1.648058 38
12,463 -0.703350 3 -0.419265 2 7 5 4 -0.144792 4.502280 -0.437544 38
8,528 0.536539 3 1.525542 4 3 4 4 -0.144792 -0.217132 -0.034039 38
7,093 -1.359762 3 -0.419265 4 6 3 2 -0.144792 -0.217132 -0.034039 38
12,565 0.536539 3 1.136580 0 11 2 2 -0.144792 -0.217132 -0.034039 38
5,655 1.338821 3 -0.419265 2 2 0 4 -0.144792 -0.217132 -0.034039 38
2,322 0.682409 3 1.136580 0 12 3 4 -0.144792 -0.217132 -0.034039 38
12,652 0.025997 3 1.136580 2 11 0 4 -0.144792 -0.217132 0.369465 38
4,755 -0.411611 3 -0.419265 2 11 0 4 -0.144792 -0.217132 1.176475 38
4,413 0.390670 6 1.136580 4 4 1 4 -0.144792 -0.217132 -0.034039 38

Ten en cuenta que los campos categóricos, como occupation, ya fueron convertidos a números enteros (con la misma asignación que se usó para el entrenamiento). Los campos numéricos, como age, se analizaron sobre la base de una puntuación z. Algunos campos se eliminaron de los datos originales. Compara la entrada de predicción con los datos sin procesar de los mismos ejemplos:

import pandas as pd

_, eval_file_path = util.download(util.DATA_DIR)
raw_eval_data = pd.read_csv(eval_file_path,
                            names=util._CSV_COLUMNS,
                            na_values='?')

raw_eval_data.iloc[prediction_input.index]
age workclass fnlwgt education education_num marital_status occupation relationship race gender capital_gain capital_loss hours_per_week native_country income_bracket
1,979 51 Local-gov 99,064 Masters 14 Married-civ-spouse Prof-specialty Husband White Male 0 0 35 United-States <=50K
2,430 26 Private 197,967 HS-grad 9 Never-married Craft-repair Own-child White Male 0 0 40 United-States <=50K
4,214 22 Private 221,694 Some-college 10 Never-married Protective-serv Not-in-family White Male 0 0 60 United-States <=50K
10,389 30 Private 96,480 Assoc-voc 11 Never-married Adm-clerical Own-child White Female 0 0 32 United-States <=50K
14,525 18 Private 146,225 10th 6 Never-married Other-service Own-child Amer-Indian-Eskimo Female 0 0 40 United-States <=50K
15,040 37 Self-emp-not-inc 50,096 Assoc-voc 11 Married-civ-spouse Craft-repair Husband White Male 0 0 30 United-States <=50K
8,409 42 Private 102,988 Masters 14 Married-civ-spouse Prof-specialty Husband White Male 0 0 55 Ecuador >50K
10,628 40 Local-gov 284,086 Masters 14 Married-civ-spouse Prof-specialty Husband White Male 7,688 0 40 United-States >50K
10,942 44 Self-emp-not-inc 52,505 Some-college 10 Married-civ-spouse Farming-fishing Husband White Male 0 0 99 United-States <=50K
5,129 54 Private 106,728 Bachelors 13 Married-civ-spouse Tech-support Husband White Male 0 0 40 United-States <=50K
2,096 21 Private 190,916 Some-college 10 Never-married Sales Own-child White Female 0 0 20 United-States <=50K
12,463 29 Private 197,565 HS-grad 9 Married-civ-spouse Other-service Wife White Female 0 1,902 35 United-States >50K
8,528 46 Private 193,188 Masters 14 Never-married Exec-managerial Unmarried White Male 0 0 40 United-States <=50K
7,093 20 Private 273,147 HS-grad 9 Never-married Machine-op-inspct Own-child Black Male 0 0 40 United-States <=50K
12,565 46 Private 203,653 Bachelors 13 Divorced Sales Other-relative Black Male 0 0 40 United-States <=50K
5,655 57 Private 174,662 HS-grad 9 Married-civ-spouse Craft-repair Husband White Male 0 0 40 United-States <=50K
2,322 48 Private 232,149 Bachelors 13 Divorced Tech-support Own-child White Female 0 0 40 United-States <=50K
12,652 39 Private 82,521 Bachelors 13 Married-civ-spouse Sales Husband White Male 0 0 45 United-States >50K
4,755 33 Private 330,715 HS-grad 9 Married-civ-spouse Sales Husband White Male 0 0 55 United-States <=50K
4,413 44 State-gov 128,586 Bachelors 13 Never-married Farming-fishing Not-in-family White Male 0 0 40 United-States <=50K

Exporta la entrada de la predicción en un archivo JSON delimitado por saltos de línea:

import json

with open('prediction_input.json', 'w') as json_file:
  for row in prediction_input.values.tolist():
    json.dump(row, json_file)
    json_file.write('\n')

Sal del intérprete de Python (exit()). En tu shell, examina prediction_input.json:

cat prediction_input.json
[0.9012127751273994, 1.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.43754385253479555, 38.0]
[-0.9221541171760282, 3.0, -0.4192650914017433, 4.0, 2.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[-1.2138928199445767, 3.0, -0.030303770229214273, 4.0, 10.0, 1.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.5799792247041626, 38.0]
[-0.6304154144074798, 3.0, 0.35865755094331475, 4.0, 0.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.6796466218034705, 38.0]
[-1.5056315227131252, 3.0, -1.5861490549193304, 4.0, 7.0, 3.0, 0.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[-0.11987268456252011, 5.0, 0.35865755094331475, 2.0, 2.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.8410484679825871, 38.0]
[0.24480069389816542, 3.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.176474609256371, 6.0]
[0.0989313425138912, 1.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, 0.8868473744801746, -0.21713186390175285, -0.03403923708700391, 38.0]
[0.39067004528243965, 5.0, -0.030303770229214273, 2.0, 4.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 4.7273152251969375, 38.0]
[1.1200168022038106, 3.0, 1.1365801932883728, 2.0, 12.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[-1.2868274956367138, 3.0, -0.030303770229214273, 4.0, 11.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -1.6480576988781703, 38.0]
[-0.7033500900996169, 3.0, -0.4192650914017433, 2.0, 7.0, 5.0, 4.0, -0.14479173735784842, 4.5022796885373735, -0.43754385253479555, 38.0]
[0.5365393966667138, 3.0, 1.525541514460902, 4.0, 3.0, 4.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[-1.3597621713288508, 3.0, -0.4192650914017433, 4.0, 6.0, 3.0, 2.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[0.5365393966667138, 3.0, 1.1365801932883728, 0.0, 11.0, 2.0, 2.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[1.338820829280222, 3.0, -0.4192650914017433, 2.0, 2.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[0.6824087480509881, 3.0, 1.1365801932883728, 0.0, 12.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
[0.0259966668217541, 3.0, 1.1365801932883728, 2.0, 11.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 0.3694653783607877, 38.0]
[-0.4116113873310685, 3.0, -0.4192650914017433, 2.0, 11.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.176474609256371, 38.0]
[0.39067004528243965, 6.0, 1.1365801932883728, 4.0, 4.0, 1.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]

La herramienta de línea de comandos de gcloud acepta JSON delimitado por saltos de línea para la predicción en línea; este modelo de Keras en particular espera una lista plana de números en cada ejemplo de entrada.

AI Platform requiere un formato diferente cuando solicitas predicciones en línea a la API de REST sin usar la herramienta de gcloud. La forma en la que estructuras tu modelo puede cambiar también la forma en la que debes formatear los datos para la predicción. Obtén más información sobre cómo formatear datos para la predicción en línea.

Envía la solicitud de predicción en línea

Usa gcloud para enviar tu solicitud de predicción en línea:

gcloud ai-platform predict \
  --model $MODEL_NAME \
  --version $MODEL_VERSION \
  --json-instances prediction_input.json
DENSE_4
[0.6854287385940552]
[0.011786997318267822]
[0.037236183881759644]
[0.016223609447479248]
[0.0012015104293823242]
[0.23621389269828796]
[0.6174039244651794]
[0.9822691679000854]
[0.3815768361091614]
[0.6715215444564819]
[0.001094043254852295]
[0.43077391386032104]
[0.22132840752601624]
[0.004075437784194946]
[0.22736871242523193]
[0.4111979305744171]
[0.27328649163246155]
[0.6981356143951416]
[0.3309604525566101]
[0.20807647705078125]

Dado que la última capa del modelo usa una función sigmoidea para su activación, los resultados entre 0 y 0.5 representan predicciones negativas (“<=50K”) y los resultados entre 0.5 y 1 representan predicciones positivas (“>50K”).

Desarrolla el modelo Keras desde cero

En este punto, has entrenado un modelo de aprendizaje automático en AI Platform, has implementado un modelo entrenado como un recurso de versión en AI Platform, y has recibido predicciones en línea de la implementación. En la siguiente sección se explica cómo recrear el código Keras usado para entrenar tu modelo. Se tratan las siguientes parte del desarrollo de un modelo de aprendizaje automático para su uso con AI Platform:

  • Descarga y preprocesamiento de datos
  • Diseño y entrenamiento del modelo
  • Visualización del entrenamiento y exportación del modelo entrenado

Si bien esta sección proporciona información más detallada sobre las tareas realizadas en las partes anteriores, si quieres obtener más información sobre el uso de tf.keras, consulta la guía de Keras de TensorFlow. Si deseas obtener más información sobre cómo estructurar un código como un paquete de entrenamiento para AI Platform, consulta Empaqueta una aplicación de entrenamiento y haz referencia al código de entrenamiento completo, que se estructura como un paquete de Python.

Importa bibliotecas y define constantes

Primero, importa las bibliotecas de Python necesarias para el entrenamiento:

import os
from six.moves import urllib
import tempfile

import numpy as np
import pandas as pd
import tensorflow as tf

# Examine software versions
print(__import__('sys').version)
print(tf.__version__)
print(tf.keras.__version__)

Luego, define algunas constantes útiles:

  • Información para descargar datos de entrenamiento y evaluación
  • Información requerida para que Pandas interprete los datos y convierta los campos categóricos en atributos numéricos
  • Hiperparámetros para entrenamiento, como tasa de aprendizaje y tamaño de lote
### For downloading data ###

# Storage directory
DATA_DIR = os.path.join(tempfile.gettempdir(), 'census_data')

# Download options.
DATA_URL = 'https://storage.googleapis.com/cloud-samples-data/ai-platform' \
           '/census/data'
TRAINING_FILE = 'adult.data.csv'
EVAL_FILE = 'adult.test.csv'
TRAINING_URL = '%s/%s' % (DATA_URL, TRAINING_FILE)
EVAL_URL = '%s/%s' % (DATA_URL, EVAL_FILE)

### For interpreting data ###

# These are the features in the dataset.
# Dataset information: https://archive.ics.uci.edu/ml/datasets/census+income
_CSV_COLUMNS = [
    'age', 'workclass', 'fnlwgt', 'education', 'education_num',
    'marital_status', 'occupation', 'relationship', 'race', 'gender',
    'capital_gain', 'capital_loss', 'hours_per_week', 'native_country',
    'income_bracket'
]

_CATEGORICAL_TYPES = {
  'workclass': pd.api.types.CategoricalDtype(categories=[
    'Federal-gov', 'Local-gov', 'Never-worked', 'Private', 'Self-emp-inc',
    'Self-emp-not-inc', 'State-gov', 'Without-pay'
  ]),
  'marital_status': pd.api.types.CategoricalDtype(categories=[
    'Divorced', 'Married-AF-spouse', 'Married-civ-spouse',
    'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'
  ]),
  'occupation': pd.api.types.CategoricalDtype([
    'Adm-clerical', 'Armed-Forces', 'Craft-repair', 'Exec-managerial',
    'Farming-fishing', 'Handlers-cleaners', 'Machine-op-inspct',
    'Other-service', 'Priv-house-serv', 'Prof-specialty', 'Protective-serv',
    'Sales', 'Tech-support', 'Transport-moving'
  ]),
  'relationship': pd.api.types.CategoricalDtype(categories=[
    'Husband', 'Not-in-family', 'Other-relative', 'Own-child', 'Unmarried',
    'Wife'
  ]),
  'race': pd.api.types.CategoricalDtype(categories=[
    'Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other', 'White'
  ]),
  'native_country': pd.api.types.CategoricalDtype(categories=[
    'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba', 'Dominican-Republic',
    'Ecuador', 'El-Salvador', 'England', 'France', 'Germany', 'Greece',
    'Guatemala', 'Haiti', 'Holand-Netherlands', 'Honduras', 'Hong', 'Hungary',
    'India', 'Iran', 'Ireland', 'Italy', 'Jamaica', 'Japan', 'Laos', 'Mexico',
    'Nicaragua', 'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland',
    'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan', 'Thailand',
    'Trinadad&Tobago', 'United-States', 'Vietnam', 'Yugoslavia'
  ]),
  'income_bracket': pd.api.types.CategoricalDtype(categories=[
    '<=50K', '>50K'
  ])
}

# This is the label (target) we want to predict.
_LABEL_COLUMN = 'income_bracket'

### Hyperparameters for training ###

# This the training batch size
BATCH_SIZE = 128

# This is the number of epochs (passes over the full training data)
NUM_EPOCHS = 20

# Define learning rate.
LEARNING_RATE = .01

Descarga y procesa previamente los datos

Descarga los datos

A continuación, define funciones para descargar datos de entrenamiento y evaluación. Estas funciones también corrigen pequeñas irregularidades en el formato de los datos.

def _download_and_clean_file(filename, url):
  """Downloads data from url, and makes changes to match the CSV format.

  The CSVs may use spaces after the comma delimters (non-standard) or include
  rows which do not represent well-formed examples. This function strips out
  some of these problems.

  Args:
    filename: filename to save url to
    url: URL of resource to download
  """
  temp_file, _ = urllib.request.urlretrieve(url)
  with tf.gfile.Open(temp_file, 'r') as temp_file_object:
    with tf.gfile.Open(filename, 'w') as file_object:
      for line in temp_file_object:
        line = line.strip()
        line = line.replace(', ', ',')
        if not line or ',' not in line:
          continue
        if line[-1] == '.':
          line = line[:-1]
        line += '\n'
        file_object.write(line)
  tf.gfile.Remove(temp_file)

def download(data_dir):
  """Downloads census data if it is not already present.

  Args:
    data_dir: directory where we will access/save the census data
  """
  tf.gfile.MakeDirs(data_dir)

  training_file_path = os.path.join(data_dir, TRAINING_FILE)
  if not tf.gfile.Exists(training_file_path):
    _download_and_clean_file(training_file_path, TRAINING_URL)

  eval_file_path = os.path.join(data_dir, EVAL_FILE)
  if not tf.gfile.Exists(eval_file_path):
    _download_and_clean_file(eval_file_path, EVAL_URL)

  return training_file_path, eval_file_path

Usa estas funciones a fin de descargar los datos para entrenamiento, y verifica que cuentas con archivos CSV para entrenamiento y evaluación:

training_file_path, eval_file_path = download(DATA_DIR)

A continuación, carga estos archivos mediante Pandas y examina los datos:

# This census data uses the value '?' for fields (column) that are missing data.
# We use na_values to find ? and set it to NaN values.
# https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html

train_df = pd.read_csv(training_file_path, names=_CSV_COLUMNS, na_values='?')
eval_df = pd.read_csv(eval_file_path, names=_CSV_COLUMNS, na_values='?')

En la siguiente tabla, se muestra un extracto de los datos (train_df.head()) antes del preprocesamiento:

age workclass fnlwgt education education_num marital_status occupation relationship race gender capital_gain capital_loss hours_per_week native_country income_bracket
0 39 State-gov 77516 Bachelors 13 Never-married Adm-clerical Not-in-family White Male 2,174 0 40 United-States <=50K
1 50 Self-emp-not-inc 83,311 Bachelors 13 Married-civ-spouse Exec-managerial Husband White Male 0 0 13 United-States <=50K
2 38 Private 215,646 HS-grad 9 Divorced Handlers-cleaners Not-in-family White Male 0 0 40 United-States <=50K
3 53 Private 234,721 11 7 Married-civ-spouse Handlers-cleaners Husband Black Male 0 0 40 United-States <=50K
4 28 Private 338,409 Bachelors 13 Married-civ-spouse Prof-specialty Wife Black Female 0 0 40 Cuba <=50K

Procesa los datos de manera previa

Con el primer paso del procesamiento previo se quitan ciertas características de los datos y se convierte atributos categóricos en valores numéricos para usarlos con Keras.

Obtén más información sobre la ingeniería de atributos y el sesgo en los datos.

UNUSED_COLUMNS = ['fnlwgt', 'education', 'gender']

def preprocess(dataframe):
  """Converts categorical features to numeric. Removes unused columns.

  Args:
    dataframe: Pandas dataframe with raw data

  Returns:
    Dataframe with preprocessed data
  """
  dataframe = dataframe.drop(columns=UNUSED_COLUMNS)

  # Convert integer valued (numeric) columns to floating point
  numeric_columns = dataframe.select_dtypes(['int64']).columns
  dataframe[numeric_columns] = dataframe[numeric_columns].astype('float32')

  # Convert categorical columns to numeric
  cat_columns = dataframe.select_dtypes(['object']).columns
  dataframe[cat_columns] = dataframe[cat_columns].apply(lambda x: x.astype(
    _CATEGORICAL_TYPES[x.name]))
  dataframe[cat_columns] = dataframe[cat_columns].apply(lambda x: x.cat.codes)
  return dataframe

prepped_train_df = preprocess(train_df)
prepped_eval_df = preprocess(eval_df)

En la siguiente tabla (prepped_train_df.head()), se muestra cómo cambiaron los datos con el preprocesamiento. Observa que income_bracket, la etiqueta que tu modelo predecirá una vez finalizado el entrenamiento, cambió de <=50K>50K01:

age workclass education_num marital_status occupation relationship race capital_gain capital_loss hours_per_week native_country income_bracket
0 39.0 6 13.0 4 0 1 4 2,174.0 0.0 40.0 38 0
1 50.0 5 13.0 2 3 0 4 0.0 0.0 13.0 38 0
2 38.0 3 9.0 0 5 1 4 0.0 0.0 40.0 38 0
3 53.0 3 7.0 2 5 0 2 0.0 0.0 40.0 38 0
4 28.0 3 13.0 2 9 5 2 0.0 0.0 40.0 4 0

A continuación, separa los datos en atributos (“x”) y etiquetas (“y”), y transforma los arreglos de etiquetas en un formato que se pueda usar con tf.data.Dataset más adelante:

# Split train and test data with labels.
# The pop() method will extract (copy) and remove the label column from the dataframe
train_x, train_y = prepped_train_df, prepped_train_df.pop(_LABEL_COLUMN)
eval_x, eval_y = prepped_eval_df, prepped_eval_df.pop(_LABEL_COLUMN)

# Reshape label columns for use with tf.data.Dataset
train_y = np.asarray(train_y).astype('float32').reshape((-1, 1))
eval_y = np.asarray(eval_y).astype('float32').reshape((-1, 1))

Escalar los datos de entrenamiento a fin de que cada columna de atributos numéricos tenga una media de 0 y una desviación estándar de 1 puede mejorar tu modelo.

En un sistema de producción, se recomienda guardar las medias y las desviaciones estándar de tu conjunto de entrenamiento y usarlas para realizar una transformación idéntica en los datos de prueba en el momento de la predicción. Para mayor practicidad en este ejercicio, combina de manera temporal los datos de entrenamiento y evaluación a fin de escalarlos:

def standardize(dataframe):
  """Scales numerical columns using their means and standard deviation to get
  z-scores: the mean of each numerical column becomes 0, and the standard
  deviation becomes 1. This can help the model converge during training.

  Args:
    dataframe: Pandas dataframe

  Returns:
    Input dataframe with the numerical columns scaled to z-scores
  """
  dtypes = list(zip(dataframe.dtypes.index, map(str, dataframe.dtypes)))
  # Normalize numeric columns.
  for column, dtype in dtypes:
      if dtype == 'float32':
          dataframe[column] -= dataframe[column].mean()
          dataframe[column] /= dataframe[column].std()
  return dataframe

# Join train_x and eval_x to normalize on overall means and standard
# deviations. Then separate them again.
all_x = pd.concat([train_x, eval_x], keys=['train', 'eval'])
all_x = standardize(all_x)
train_x, eval_x = all_x.xs('train'), all_x.xs('eval')

En la siguiente tabla (train_x.head()), se muestra cómo se ven los datos procesados de manera previa en su totalidad:

age workclass education_num marital_status occupation relationship race capital_gain capital_loss hours_per_week native_country
0 0.025997 6 1.136580 4 0 1 4 0.146933 -0.217132 -0.034039 38
1 0.828278 5 1.136580 2 3 0 4 -0.144792 -0.217132 -2.212964 38
2 -0.046938 3 -0.419265 0 5 1 4 -0.144792 -0.217132 -0.034039 38
3 1.047082 3 -1.197188 2 5 0 2 -0.144792 -0.217132 -0.034039 38
4 -0.776285 3 1.136580 2 9 5 2 -0.144792 -0.217132 -0.034039 4

Diseña y entrena el modelo

Crea conjuntos de datos de entrenamiento y validación

Crea una función de entrada para convertir características y etiquetas en un tf.data.Dataset para entrenamiento o evaluación:

def input_fn(features, labels, shuffle, num_epochs, batch_size):
  """Generates an input function to be used for model training.

  Args:
    features: numpy array of features used for training or inference
    labels: numpy array of labels for each example
    shuffle: boolean for whether to shuffle the data or not (set True for
      training, False for evaluation)
    num_epochs: number of epochs to provide the data for
    batch_size: batch size for training

  Returns:
    A tf.data.Dataset that can provide data to the Keras model for training or
      evaluation
  """
  if labels is None:
    inputs = features
  else:
    inputs = (features, labels)
  dataset = tf.data.Dataset.from_tensor_slices(inputs)

  if shuffle:
    dataset = dataset.shuffle(buffer_size=len(features))

  # We call repeat after shuffling, rather than before, to prevent separate
  # epochs from blending together.
  dataset = dataset.repeat(num_epochs)
  dataset = dataset.batch(batch_size)
  return dataset

A continuación, crea estos conjuntos de datos de entrenamiento y evaluación. Usa los hiperparámetros NUM_EPOCHS y BATCH_SIZE definidos con anterioridad para establecer cómo el conjunto de datos de entrenamiento le proporcionará ejemplos al modelo durante el entrenamiento. Establece el conjunto de datos de validación a fin de brindar todos sus ejemplos en un solo lote, para un solo paso de validación al final de cada ciclo de entrenamiento.

# Pass a numpy array by using DataFrame.values
training_dataset = input_fn(features=train_x.values,
                    labels=train_y,
                    shuffle=True,
                    num_epochs=NUM_EPOCHS,
                    batch_size=BATCH_SIZE)

num_eval_examples = eval_x.shape[0]

# Pass a numpy array by using DataFrame.values
validation_dataset = input_fn(features=eval_x.values,
                    labels=eval_y,
                    shuffle=False,
                    num_epochs=NUM_EPOCHS,
                    batch_size=num_eval_examples)

Diseña un modelo de Keras

Diseña tu red neuronal mediante la API secuencial de Keras.

Esta red neuronal profunda (DNN) tiene diferentes capas ocultas y la última capa utiliza una función de activación sigmoidea para arrojar como resultado un valor entre 0 y 1:

  • La capa de entrada tiene 100 unidades con la función de activación ReLU.
  • La capa oculta tiene 75 unidades con la función de activación ReLU.
  • La capa oculta tiene 50 unidades con la función de activación ReLU.
  • La capa oculta tiene 25 unidades con la función de activación ReLU.
  • La capa de resultados tiene 1 unidad con una función de activación sigmoidea.
  • El optimizador utiliza la función de pérdida de entropía cruzada binaria, apropiada para un problema de clasificación binario como este.

Siéntete libre de cambiar estas capas para tratar de mejorar el modelo:

def create_keras_model(input_dim, learning_rate):
  """Creates Keras Model for Binary Classification.

  Args:
    input_dim: How many features the input has
    learning_rate: Learning rate for training

  Returns:
    The compiled Keras model (still needs to be trained)
  """
  Dense = tf.keras.layers.Dense
  model = tf.keras.Sequential(
    [
        Dense(100, activation=tf.nn.relu, kernel_initializer='uniform',
                input_shape=(input_dim,)),
        Dense(75, activation=tf.nn.relu),
        Dense(50, activation=tf.nn.relu),
        Dense(25, activation=tf.nn.relu),
        Dense(1, activation=tf.nn.sigmoid)
    ])

  # Custom Optimizer:
  # https://www.tensorflow.org/api_docs/python/tf/train/RMSPropOptimizer
  optimizer = tf.keras.optimizers.RMSprop(
      lr=learning_rate)

  # Compile Keras model
  model.compile(
      loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
  return model

A continuación, crea el objeto del modelo de Keras:

num_train_examples, input_dim = train_x.shape
print('Number of features: {}'.format(input_dim))
print('Number of examples: {}'.format(num_train_examples))

keras_model = create_keras_model(
    input_dim=input_dim,
    learning_rate=LEARNING_RATE)

Luego de examinar el modelo con keras_model.summary(), el resultado debería ser algo así:

Number of features: 11
Number of examples: 32561
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Colocations handled automatically by placer.
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
dense (Dense)                (None, 100)               1200
_________________________________________________________________
dense_1 (Dense)              (None, 75)                7575
_________________________________________________________________
dense_2 (Dense)              (None, 50)                3800
_________________________________________________________________
dense_3 (Dense)              (None, 25)                1275
_________________________________________________________________
dense_4 (Dense)              (None, 1)                 26
=================================================================
Total params: 13,876
Trainable params: 13,876
Non-trainable params: 0
_________________________________________________________________

Entrena y evalúa el modelo

Define una caída en la tasa de aprendizaje a fin de fomentar que los parámetros del modelo hagan cambios pequeños durante el entrenamiento:

# Setup Learning Rate decay.
lr_decay_cb = tf.keras.callbacks.LearningRateScheduler(
    lambda epoch: LEARNING_RATE + 0.02 * (0.5 ** (1 + epoch)),
    verbose=True)

# Setup TensorBoard callback.
JOB_DIR = os.getenv('JOB_DIR')
tensorboard_cb = tf.keras.callbacks.TensorBoard(
      os.path.join(JOB_DIR, 'keras_tensorboard'),
      histogram_freq=1)

Por último, entrena el modelo. Proporciona el steps_per_epoch adecuado para que el modelo entrene en todo el conjunto de datos de entrenamiento (con los ejemplos de BATCH_SIZE para cada paso) durante cada ciclo de entrenamiento. Ordena al modelo que calcule la precisión de la validación con un gran lote de validación al final de cada ciclo de entrenamiento.

history = keras_model.fit(training_dataset,
                          epochs=NUM_EPOCHS,
                          steps_per_epoch=int(num_train_examples/BATCH_SIZE),
                          validation_data=validation_dataset,
                          validation_steps=1,
                          callbacks=[lr_decay_cb, tensorboard_cb],
                          verbose=1)

El progreso del entrenamiento puede verse de la siguiente manera:

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.cast instead.

Epoch 00001: LearningRateScheduler reducing learning rate to 0.02.
Epoch 1/20
254/254 [==============================] - 1s 5ms/step - loss: 0.6986 - acc: 0.7893 - val_loss: 0.3894 - val_acc: 0.8329

Epoch 00002: LearningRateScheduler reducing learning rate to 0.015.
Epoch 2/20
254/254 [==============================] - 1s 4ms/step - loss: 0.3574 - acc: 0.8335 - val_loss: 0.3861 - val_acc: 0.8131

...

Epoch 00019: LearningRateScheduler reducing learning rate to 0.010000038146972657.
Epoch 19/20
254/254 [==============================] - 1s 4ms/step - loss: 0.3239 - acc: 0.8512 - val_loss: 0.3334 - val_acc: 0.8496

Epoch 00020: LearningRateScheduler reducing learning rate to 0.010000019073486329.
Epoch 20/20
254/254 [==============================] - 1s 4ms/step - loss: 0.3279 - acc: 0.8504 - val_loss: 0.3174 - val_acc: 0.8523

Visualiza el entrenamiento y exporta el modelo entrenado

Visualiza el entrenamiento

Importa matplotlib para ver el proceso de aprendizaje del modelo durante el período de entrenamiento. (Si es necesario, primero instálalo con pip install matplotlib).

from matplotlib import pyplot as plt

Traza la pérdida del modelo (entropía cruzada binaria) y la precisión, según se midió al final de cada ciclo de entrenamiento:

# Visualize History for Loss.
plt.title('Keras model loss')
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['training', 'validation'], loc='upper right')
plt.show()

# Visualize History for Accuracy.
plt.title('Keras model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.legend(['training', 'validation'], loc='lower right')
plt.show()

Con el tiempo, la pérdida disminuye y la precisión aumenta. Sin embargo, ¿convergen en un nivel estable? ¿Existen grandes diferencias entre las métricas de entrenamiento y validación (un signo de sobreajuste)?

Obtén más información sobre cómo mejorar tu modelo de aprendizaje automático. A continuación, puedes ajustar los hiperparámetros o la arquitectura del modelo y volver a entrenarlo.

Exporta el modelo para entregarlo

Usa tf.contrib.saved_model.save_keras_model para exportar un directorio del modelo guardado de TensorFlow. Este es el formato que requiere AI Platform cuando creas un recurso de versión de modelo.

Dado que no todos los optimizadores se pueden exportar al formato modelo guardado, es posible que veas advertencias durante el proceso de exportación. Mientras exportes con éxito un grafo de entrega, AI Platform puede usar el modelo guardado para entregar predicciones.

# Export the model to a local SavedModel directory
export_path = tf.contrib.saved_model.save_keras_model(keras_model, 'keras_export')
print("Model exported to: ", export_path)
WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.
For more information, please see:
  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md
  * https://github.com/tensorflow/addons
If you depend on functionality not listed there, please file an issue.

WARNING:tensorflow:This model was compiled with a Keras optimizer (<tensorflow.python.keras.optimizers.RMSprop object at 0x7fc198c4e400>) but is being saved in TensorFlow format with `save_weights`. The model's weights will be saved, but unlike with TensorFlow optimizers in the TensorFlow format the optimizer's state will not be saved.

Consider using a TensorFlow optimizer from `tf.train`.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/network.py:1436: update_checkpoint_state (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.train.CheckpointManager to manage checkpoints rather than manually editing the Checkpoint proto.
WARNING:tensorflow:Model was compiled with an optimizer, but the optimizer is not from `tf.train` (e.g. `tf.train.AdagradOptimizer`). Only the serving graph was exported. The train and evaluate graphs were not added to the SavedModel.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:205: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.
INFO:tensorflow:Signatures INCLUDED in export for Classify: None
INFO:tensorflow:Signatures INCLUDED in export for Regress: None
INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default']
INFO:tensorflow:Signatures INCLUDED in export for Train: None
INFO:tensorflow:Signatures INCLUDED in export for Eval: None
INFO:tensorflow:No assets to save.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: keras_export/1553710367/saved_model.pb
Model exported to:  b'keras_export/1553710367'

Puedes exportar un directorio del modelo guardado a tu sistema de archivos local o a Cloud Storage, siempre que tengas los permisos necesarios. En el entorno actual, otorgaste acceso a Cloud Storage mediante la autenticación de la cuenta de Google Cloud y la configuración de la variable de entorno GOOGLE_APPLICATION_CREDENTIALS. Los trabajos de entrenamiento de AI Platform también pueden exportarse directamente a Cloud Storage, ya que las cuentas de servicio de AI Platform tienen acceso a los depósitos de Cloud Storage en su propio proyecto.

Intenta exportar directamente a Cloud Storage:

JOB_DIR = os.getenv('JOB_DIR')

# Export the model to a SavedModel directory in Cloud Storage
export_path = tf.contrib.saved_model.save_keras_model(keras_model, JOB_DIR + '/keras_export')
print("Model exported to: ", export_path)
WARNING:tensorflow:This model was compiled with a Keras optimizer (<tensorflow.python.keras.optimizers.RMSprop object at 0x7fc198c4e400>) but is being saved in TensorFlow format with `save_weights`. The model's weights will be saved, but unlike with TensorFlow optimizers in the TensorFlow format the optimizer's state will not be saved.

Consider using a TensorFlow optimizer from `tf.train`.
WARNING:tensorflow:Model was compiled with an optimizer, but the optimizer is not from `tf.train` (e.g. `tf.train.AdagradOptimizer`). Only the serving graph was exported. The train and evaluate graphs were not added to the SavedModel.
INFO:tensorflow:Signatures INCLUDED in export for Classify: None
INFO:tensorflow:Signatures INCLUDED in export for Regress: None
INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default']
INFO:tensorflow:Signatures INCLUDED in export for Train: None
INFO:tensorflow:Signatures INCLUDED in export for Eval: None
INFO:tensorflow:No assets to save.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: gs://your-bucket-name/keras-job-dir/keras_export/1553710379/saved_model.pb
Model exported to:  b'gs://your-bucket-name/keras-job-dir/keras_export/1553710379'

Ahora puedes implementar este modelo en AI Platform y entregar predicciones mediante los pasos de la guía de inicio rápido sobre predicción.

Realiza una limpieza

Si deseas limpiar todos los recursos de Google Cloud que se usaron en este proyecto, puedes borrar el proyecto de Google Cloud que usaste para el instructivo.

De manera alternativa, puedes limpiar recursos individuales; para ello, ejecuta los siguientes comandos:

# Delete model version resource
gcloud ai-platform versions delete $MODEL_VERSION --quiet --model $MODEL_NAME

# Delete model resource
gcloud ai-platform models delete $MODEL_NAME --quiet

# Delete Cloud Storage objects that were created
gsutil -m rm -r $JOB_DIR

# If training job is still running, cancel it
gcloud ai-platform jobs cancel $JOB_NAME --quiet

Si tu depósito de Cloud Storage no contiene ningún otro objeto y quieres borrarlo, ejecuta gsutil rm -r gs://$BUCKET_NAME.

Próximos pasos