Crea una rutina de predicción personalizada con scikit-learn

Ejecuta este instructivo como un notebook en Colab

Visualiza el notebook en GitHub

Beta

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Descripción general

En este instructivo, se muestra cómo implementar un modelo entrenado de scikit-learn 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 de manera previa la entrada de predicción mediante su escalamiento y hacer un procesamiento posterior de la salida de predicción mediante la conversión de los números de clase en strings de etiqueta.

En este instructivo, se presentan los siguientes pasos:

• Entrena un modelo de scikit-learn sencillo en forma local (en este notebook).
• Crea y, luego, implementa una rutina de predicción personalizada para 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 AI Platform Prediction. precios y Cloud Storage precios, y usar la página de precios Calculadora para generar una estimación de 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 Google Cloud

Nota: Este instructivo fue diseñado para Python 3, pero también puede aplicarse a Python 2.

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

1. Instala Python 3.

2. Instalación virtualenv y crear un entorno virtual que use Python 3.

3. Activa ese entorno.

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

Configura el proyecto de Google Cloud

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

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Enable the APIs

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

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

   Enable the APIs

10. Install the Google Cloud CLI.

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

1. Crear una cuenta de servicio:

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

      Ve 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. Haz clic en Crear.
   5. Haz clic en el campo Seleccionar una función. En Todos los roles, selecciona AI Platform > Administrador de AI Platform.
   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.

      Nota: Las funciones que seleccionas permiten que tu cuenta de servicio acceda a los recursos. Puedes ver y cambiar estos roles más adelante con la consola de Google Cloud. Si desarrollas una app de producción, es posible que debas especificar roles con menos permisos que el administrador de AI Platform y el administrador de objetos de almacenamiento. A fin de obtener más información, consulta el control de acceso para AI Platform Prediction.

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

   Ejemplo: Linux o macOS

   Reemplaza [PATH] con la ruta del archivo JSON que contiene la clave de tu cuenta de servicio.

   export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

   Por ejemplo:

   export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

   Ejemplo: Windows

   Reemplaza [PATH] con la ruta de acceso del archivo JSON que contiene la clave de tu cuenta de servicio y [FILE_NAME] con el nombre del archivo.

   Con PowerShell:

   $env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

   Por ejemplo:

   $env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\[FILE_NAME].json"

   Con el símbolo del sistema:

   set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

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 la región de AI Platform Prediction disponibles y crear otra variable de entorno.

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:

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

Cómo compilar y entrenar un modelo de scikit-learn

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>=1.16.0 scikit-learn==0.20.2

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 procesar de manera previa los datos de iris y, luego, entrenar un modelo con scikit-learn.

Al final, exporta tu modelo entrenado como un archivo joblib (.joblib) y exporta tu instancia MySimpleScaler como un archivo pickle (.pkl):

Nota: Para exportar un artefacto de modelo joblib compatible con AI Platform Prediction, debes usar la versión de joblib que se distribuye con scikit-learn, no la versión independiente. Para importar esta biblioteca en Python, usa la declaración from sklearn.externals import joblib.

import pickle

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
X = scaler.preprocess(iris.data)
y = iris.target

model = RandomForestClassifier()
model.fit(X, y)

joblib.dump(model, 'model.joblib')
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
from sklearn.externals import joblib

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)
    if kwargs.get('probabilities'):
      probabilities = self._model.predict_proba(preprocessed_inputs)
      return probabilities.tolist()
    else:
      outputs = self._model.predict(preprocessed_inputs)
      return [self._class_names[class_num] for class_num in outputs]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.joblib')
    model = joblib.load(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 en el que convierte la salida de la predicción de índices de clase (0, 1 o 2) en strings de etiquetas (el nombre del tipo de flor).

Sin embargo, si el predictor recibe un argumento de palabra clave probabilities con el valor True, muestra un arreglo de probabilidad en su lugar, que indica la probabilidad de que cada una de las tres clases sea la etiqueta correcta (según el modelo). En la última parte de este instructivo, se muestra cómo proporcionar un argumento de palabra clave durante la predicción.

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.joblib (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:

gcloud storage cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gcloud storage cp model.joblib preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Implementa tu rutina de predicción personalizada

Crear un recurso de modelo y una versión recurso para implementar tu 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 1.13 \
  --python-version 3.5 \
  --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

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']

Nota: Este código usa las credenciales que configuraste durante el proceso de autenticación paso para realizar la solicitud de predicción en línea.

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.0, 1.0, 0.0], [1.0, 0.0, 0.0]]

Realice una limpieza

Para limpiar todos los recursos de GCP usados en este proyecto, puedes borrar el GCP proyecto que usaste en 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
gcloud storage rm gs://$BUCKET_NAME/custom_prediction_routine_tutorial --recursive

Pasos siguientes

• Obtén más información sobre las rutinas de predicción personalizadas.
• Obtén información sobre cómo exportar un modelo para entregar predicciones sin una rutina de predicción personalizada.