 Ejecuta este instructivo como un notebook en Colab |
 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 Keras escrito previamente, 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 del instructivo se profundiza en el código de entrenamiento utilizado para este modelo y en garantizar su compatibilidad 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 las fuentes de sesgo del 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 generar 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 bucket 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 Google Cloud
En la guía de Google Cloud Configurar 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:
Instala virtualenv y crea un entorno virtual que use Python 3.
Activa ese entorno.
Completa los pasos de la siguiente sección para instalar el SDK de Google Cloud.
Configura el proyecto de Google Cloud
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the AI Platform Training & Prediction and Compute Engine 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.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the AI Platform Training & Prediction and Compute Engine APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
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.
-
Crear una cuenta de servicio:
-
En la consola de Google Cloud, ve a la página Crear cuenta de servicio.
- Ingresa un nombre en el campo Nombre de cuenta de servicio.
- Opcional: en el campo Descripción de la cuenta de servicio, ingresa una descripción.
- Haz clic en Crear.
- Haz clic en el campo Seleccionar una función. En Todos los roles, selecciona AI Platform > Administrador de AI Platform.
- Haz clic en Agregar otra función.
-
Haz clic en el campo Seleccionar una función. En Todas las funciones, selecciona Storage > Administrador de objeto de Storage.
-
Haz clic en Listo para crear la cuenta de servicio.
No cierres la ventana del navegador. La usarás en la próxima tarea.
-
-
Crea una clave de cuenta de servicio para la autenticación:
- En la consola de Google Cloud, haz clic en la dirección de correo electrónico de la cuenta de servicio que creaste.
- Haga clic en Claves.
- Haz clic en Agregar clave -> Crear nueva clave.
- Haz clic en Crear. Se descargará un archivo de claves JSON en tu computadora.
- Haz clic en Cerrar.
-
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 bucket 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 bucket de Cloud Storage. AI Platform ejecuta el código de este paquete. En este instructivo, AI Platform también guarda un modelo de entrenamiento que surge de tu trabajo en el mismo bucket. Entonces puedes crear una versión de modelo de AI Platform basada en este resultado para entregar predicciones en línea.
Establece el nombre de tu bucket de Cloud Storage como una variable del 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 bucket 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 bucket 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 de modelo guardado de TensorFlow en tu bucket 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 localmente:
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 el modelo de forma local
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 bucket 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 la consola de Google Cloud.
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 bucket 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 entrenar diferentes ensayos 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 Summary
Event 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. El trabajo de entrenamiento de la guía de inicio rápido sobre entrenamiento exportó un directorio de modelo guardado de TensorFlow con marca de tiempo a tu bucket 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 | head -n 1)
# Create model version based on that SavedModel directory
gcloud ai-platform versions create $MODEL_VERSION \
--model $MODEL_NAME \
--region $REGION \
--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 \
--region $REGION \
--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
El primer paso del procesamiento quita ciertas características de los datos y 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 y >50K a 0 y 1:
| 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 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 disminución de la tasa de aprendizaje para fomentar que los parámetros del modelo hagan cambios más pequeños a medida que avanza 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 de 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 servicio, 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 de 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; para ello, sigue los pasos de la guía de inicio rápido sobre predicción.
Realice una limpieza
Para 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.
Alternativamente, 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
- Visualiza el código de entrenamiento completo usado en esta guía, que estructura el código para aceptar hiperparámetros personalizados como marcas de línea de comandos.
- Obtén información sobre el código de empaquetado para un trabajo de entrenamiento de AI Platform.
- Obtén información sobre cómo implementar un modelo para entregar predicciones.