Crea una rutina de predicción personalizada 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 implementar un modelo entrenado por Keras en AI Platform Prediction y entregar predicciones mediante una rutina de predicción personalizada. Esto te permite personalizar el modo en que AI Platform Prediction responde a cada solicitud de predicción.

En este ejemplo, usarás una rutina de predicción personalizada para procesar previamente la entrada de predicción mediante su escalamiento y para procesar posteriormente el resultado de la predicción mediante la conversión de los resultados de probabilidad de softmax en strings de etiqueta.

En este instructivo, se presentan los siguientes pasos:

  • Entrenar un modelo Keras simple de forma local
  • Crear y, luego, implementar una rutina de predicción personalizada en AI Platform Prediction
  • Entrega solicitudes de predicción de esa implementación.

Conjunto de datos

En este instructivo, se usa el conjunto de datos Iris de R. A. Fisher, un pequeño conjunto de datos popular para probar el funcionamiento de las técnicas de aprendizaje automático. Cada instancia tiene cuatro atributos numéricos, que son diferentes medidas de una flor, y una etiqueta objetivo que la marca como uno de los tres tipos de iris: Iris setosa, Iris versicolor o Iris virginica.

En este instructivo, se usa la copia del conjunto de datos Iris incluida en la biblioteca de scikit-learn.

Objetivo

El objetivo es entrenar un modelo que use las medidas de una flor como entrada para predecir qué tipo de iris es.

Este instructivo se centra más en el uso de este modelo con AI Platform Prediction que en el diseño del modelo en sí.

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

  • AI Platform Prediction
  • Cloud Storage

Obtén información sobre los precios de AI Platform Prediction y los precios de Cloud Storage. Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

Debes completar varios pasos antes de poder entrenar y, luego, implementar un modelo en AI Platform Prediction:

  • 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:

  • Python 3
  • virtualenv
  • El SDK de Cloud

La guía de Google Cloud Configurar un entorno de programación de Python brinda 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 utilice 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 Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al 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.
  6. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

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

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

    Habilita las API

  9. 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 cuenta de servicio:

    1. En Cloud Console, ve a la página Crear cuenta de servicio.

      Ir a Crear cuenta de servicio

    2. Ingresa un nombre en el campo Nombre de cuenta de servicio.
    3. Opcional: en el campo Descripción de la cuenta de servicio, ingresa una descripción.
    4. Haga clic en Crear.
    5. Haz clic en el campo Seleccionar una función. En Todas las funciones, selecciona Machine Learning Engine > Administrador de ML Engine.
    6. Haz clic en Agregar otra función.
    7. Haz clic en el campo Seleccionar una función. En Todas las funciones, selecciona Storage > Administrador de objeto de Storage.

    8. Haz clic en Listo para crear la cuenta de servicio.

      No cierres la ventana del navegador. La usarás en la próxima tarea.

  2. Crea una clave de cuenta de servicio para la autenticación:

    1. En Cloud Console, haz clic en la dirección de correo electrónico de la cuenta de servicio que creaste.
    2. Haz clic en Claves.
    3. Haz clic en Agregar clave -> Crear nueva clave.
    4. Haga clic en Crear. Se descargará un archivo de claves JSON en tu computadora.
    5. Haga clic en Cerrar.
  3. 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.

Crea un bucket de Cloud Storage

Para implementar una rutina de predicción personalizada, debes subir los artefactos de tu modelo entrenado y tu código personalizado a Cloud Storage.

Establece el nombre de tu bucket 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 AI Platform Prediction esté disponible y crea otra variable de entorno.

REGION="us-central1"

Crea un 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

Compila y entrena un modelo de Keras

A menudo sucede que no puedes usar tus datos sin procesar para entrenar un modelo de aprendizaje automático. Incluso si puedes hacerlo, se recomienda procesar previamente los datos antes de usarlos para el entrenamiento, ya que esto puede mejorar tu modelo.

Si suponemos que esperas que la entrada para la predicción tenga el mismo formato que tus datos de entrenamiento, debes aplicar un procesamiento previo idéntico durante el entrenamiento y la predicción a fin de garantizar que tu modelo realice predicciones coherentes.

En esta sección, crea un módulo de procesamiento previo y úsalo como parte del entrenamiento. Luego, exporta un procesador previo con las características aprendidas durante el entrenamiento de modo que puedas usarlo en tu rutina de predicción personalizada más tarde.

Instala dependencias para el entrenamiento local

El entrenamiento local requiere varias dependencias; utiliza lo siguiente:

pip install numpy scikit-learn 'tensorflow=2.3'

Escribe tu procesador previo

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.

Crea preprocess.py, que contiene una clase para realizar el siguiente escalamiento:

import numpy as np

class MySimpleScaler(object):
  def __init__(self):
    self._means = None
    self._stds = None

  def preprocess(self, data):
    if self._means is None: # during training only
      self._means = np.mean(data, axis=0)

    if self._stds is None: # during training only
      self._stds = np.std(data, axis=0)
      if not self._stds.all():
        raise ValueError('At least one column has standard deviation of 0.')

    return (data - self._means) / self._stds

Observa que una instancia de MySimpleScaler guarda los medios y las desviaciones estándar de cada columna de atributos en el primer uso. Luego, usa estas estadísticas de resumen para escalar los datos que encuentra más adelante.

Esto te permite almacenar características de la distribución del entrenamiento y usarlas para realizar un procesamiento previo idéntico en el momento de la predicción.

Entrena un modelo

A continuación, usa preprocess.MySimpleScaler para realizar un procesamiento previo de los datos de iris y, luego, entrena una red neuronal simple con Keras.

Al final, exporta el modelo entrenado por Keras como un archivo HDF5 (.h5) y exporta la instancia MySimpleScaler como un archivo pickle (.pkl):

import pickle

from sklearn.datasets import load_iris
import tensorflow as tf

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
num_classes = len(iris.target_names)
X = scaler.preprocess(iris.data)
y = tf.keras.utils.to_categorical(iris.target, num_classes=num_classes)

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(num_classes, activation=tf.nn.softmax))
model.compile(
  optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=1)

model.save('model.h5')
with open ('preprocessor.pkl', 'wb') as f:
  pickle.dump(scaler, f)

Implementa una rutina de predicción personalizada

Si deseas implementar una rutina de predicción personalizada para entregar predicciones desde tu modelo entrenado, haz lo siguiente:

  • Crea un predictor personalizado para que administre las solicitudes.
  • Empaqueta tu predictor y tu módulo de procesamiento previo.
  • Sube los artefactos de tu modelo y tu código personalizado a Cloud Storage.
  • Implementa tu rutina de predicción personalizada en AI Platform Prediction.

Crea un predictor personalizado

Para implementar una rutina de predicción personalizada, debes crear una clase que implemente la interfaz de Predictor. Esta le indica a AI Platform Prediction cómo cargar un modelo y cómo administrar las solicitudes de predicción.

Escribe el siguiente código en predictor.py:

import os
import pickle

import numpy as np
from sklearn.datasets import load_iris
import tensorflow as tf

class MyPredictor(object):
  def __init__(self, model, preprocessor):
    self._model = model
    self._preprocessor = preprocessor
    self._class_names = load_iris().target_names

  def predict(self, instances, **kwargs):
    inputs = np.asarray(instances)
    preprocessed_inputs = self._preprocessor.preprocess(inputs)
    outputs = self._model.predict(preprocessed_inputs)
    if kwargs.get('probabilities'):
      return outputs.tolist()
    else:
      return [self._class_names[index] for index in np.argmax(outputs, axis=1)]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.h5')
    model = tf.keras.models.load_model(model_path)

    preprocessor_path = os.path.join(model_dir, 'preprocessor.pkl')
    with open(preprocessor_path, 'rb') as f:
      preprocessor = pickle.load(f)

    return cls(model, preprocessor)

Ten en cuenta que, además de usar el procesador previo que definiste durante el entrenamiento, este predictor realiza un paso de procesamiento posterior que convierte el resultado de softmax de la red neuronal (un arreglo que denota la probabilidad de cada etiqueta de ser la correcta) en la etiqueta con la mayor probabilidad.

Sin embargo, si el predictor recibe un argumento de palabra clave probabilities con el valor True, muestra el arreglo de probabilidad en su lugar. En la última parte de este instructivo, se muestra cómo proporcionar este argumento de palabra clave.

Empaqueta un código personalizado

Debes empaquetar predictor.py y preprocess.py como un paquete de distribución de fuente .tar.gz y proporcionar el paquete a AI Platform Prediction para que pueda usar el código personalizado a fin de entregar predicciones.

Escribe el siguiente setup.py para definir el paquete:

from setuptools import setup

setup(
    name='my_custom_code',
    version='0.1',
    scripts=['predictor.py', 'preprocess.py'])

Luego, ejecuta el siguiente comando para crear dist/my_custom_code-0.1.tar.gz:

python setup.py sdist --formats=gztar

Sube artefactos del modelo y código personalizado a Cloud Storage

Antes de implementar el modelo en la entrega, AI Platform Prediction necesita acceder a los siguientes archivos en Cloud Storage:

  • model.h5 (artefacto de modelo)
  • preprocessor.pkl (artefacto de modelo)
  • my_custom_code-0.1.tar.gz (código personalizado)

Los artefactos de modelo deben almacenarse juntos en un directorio de modelo, al que el predictor pueda acceder como el argumento model_dir en su método de clase from_path. No es necesario que el código personalizado esté en el mismo directorio. Ejecuta los comandos siguientes para subir tus archivos:

gsutil cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gsutil cp model.h5 preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Implementa tu rutina de predicción personalizada

Crea un recurso de modelo y un recurso de versión para implementar una rutina de predicción personalizada. En primer lugar, define las variables de entorno con los siguientes nombres de los recursos:

MODEL_NAME='IrisPredictor'
VERSION_NAME='v1'

Luego, crea tu modelo de la siguiente manera:

gcloud ai-platform models create $MODEL_NAME \
  --regions $REGION

A continuación, crea una versión. En este paso, proporciona las rutas de acceso a los artefactos y al código personalizado que subiste a Cloud Storage:

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME \
  --model $MODEL_NAME \
  --runtime-version 2.3 \
  --python-version 3.7 \
  --origin gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/ \
  --package-uris gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz \
  --prediction-class predictor.MyPredictor

Obtén más información sobre las opciones que debes especificar cuando implementas una rutina de predicción personalizada.

Entrega predicciones en línea

Para probar tu implementación, envía una solicitud de predicción en línea. Primero, instala la biblioteca cliente de la API de Google para Python:

pip install --upgrade google-api-python-client

Luego, envía dos instancias de datos de iris a tu versión implementada. Para ello, ejecuta el siguiente código de Python:

import googleapiclient.discovery

instances = [
  [6.7, 3.1, 4.7, 1.5],
  [4.6, 3.1, 1.5, 0.2],
]

service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}/versions/{}'.format(PROJECT_ID, MODEL_NAME, VERSION_NAME)

response = service.projects().predict(
    name=name,
    body={'instances': instances}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])
['versicolor', 'setosa']

Envía argumentos de palabras clave

Cuando envías una solicitud de predicción a una rutina de predicción personalizada, puedes proporcionar campos adicionales en el cuerpo de la solicitud. El método predict del predictor los recibe como campos del diccionario **kwargs.

Con el siguiente código, se envía la misma solicitud que antes, sin embargo, esta vez se agrega un campo probabilities al cuerpo de la solicitud:

response = service.projects().predict(
    name=name,
    body={'instances': instances, 'probabilities': True}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])
[[0.0019204545533284545, 0.8623144626617432, 0.13576509058475494], [0.999488353729248, 0.000511515187099576, 1.293626752385535e-07]]

Realice una limpieza

Para limpiar todos los recursos de GCP usados en este proyecto, puedes borrar el proyecto de GCP que utilizaste para el instructivo.

Alternativamente, puedes limpiar recursos individuales; para ello, ejecuta los siguientes comandos:

# Delete version resource
gcloud ai-platform versions delete $VERSION_NAME --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 gs://$BUCKET_NAME/custom_prediction_routine_tutorial

Pasos siguientes