Obtén predicciones en línea con scikit-learn

En esta muestra, se entrena un modelo para predecir el nivel de ingresos de una persona según el Conjunto de datos de ingresos del censo. Después de entrenar y guardar el modelo de manera local, impleméntalo en AI Platform Prediction y consúltalo para obtener predicciones en línea.

Puedes implementar y entregar canalizaciones de scikit-learn en AI Platform Prediction. El módulo de canalización de scikit-learn te permite aplicar varias transformaciones de datos antes de realizar el entrenamiento con un estimador. Esto encapsula múltiples pasos en el procesamiento de datos y garantiza que se usen los mismos datos de entrenamiento en cada paso.

Este instructivo también está disponible en GitHub como un notebook de Jupyter.

Cómo trasladar el modelo a AI Platform Prediction

Puedes trasladar el modelo a AI Platform Prediction para obtener predicciones mediante estos cinco pasos:

• Guarda tu modelo en un archivo.
• Sube el modelo guardado a Cloud Storage.
• Crea un recurso de modelo en AI Platform Prediction.
• Crea una versión del modelo; para ello, vincula tu modelo guardado.
• Haz una predicción en línea.

Antes de comenzar

Completa los siguientes pasos para configurar una cuenta de GCP, activar la API de AI Platform Prediction y, también, instalar y activar el SDK de Cloud.

Configura el proyecto de GCP

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. 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. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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

Configura el entorno

Elige una de las siguientes opciones para configurar tu entorno de manera local en macOS o en un entorno remoto en Cloud Shell.

Si eres usuario de macOS, te recomendamos que configures tu entorno mediante el uso de la pestaña MACOS a continuación. Cloud Shell, que se muestra en la pestaña CLOUD SHELL, está disponible en macOS, Linux y Windows. Cloud Shell ofrece una forma rápida de probar AI Platform Prediction, pero no es adecuada para el trabajo de desarrollo continuo.

macOS

1. Verifica la instalación de Python
   Confirma que tienes Python instalado y, si es necesario, instálalo.

   python -V

2. Verifica la instalación de pip
pip es el administrador de paquetes de Python y se incluye en sus versiones actuales. Para verificar si ya tienes pip instalado, ejecuta el comando pip --version. De lo contrario, consulta cómo instalar pip.

   Puedes actualizar pip con el siguiente comando:

   pip install -U pip

   Consulta la documentación de pip para obtener más detalles.

3. Instala virtualenv
virtualenv es una herramienta que sirve para crear entornos de Python aislados. Para verificar si ya tienes virtualenv instalado, ejecuta el comando virtualenv --version. De lo contrario, instala virtualenv con el comando siguiente:

   pip install --user --upgrade virtualenv

   Si deseas crear un entorno de desarrollo aislado para esta guía, crea un entorno virtual nuevo en virtualenv. Por ejemplo, el siguiente comando activa un entorno llamado aip-env:

   virtualenv aip-env
   source aip-env/bin/activate

4. A los fines de este instructivo, ejecuta el resto de los comandos dentro de tu entorno virtual.

   Obtén más información sobre el uso de virtualenv. Para salir de virtualenv, ejecuta deactivate.

Cloud Shell

1. Abre la consola de Google Cloud.

   La consola de Google Cloud

2. Haz clic en el botón Activar Cloud Shell en la parte superior de la ventana de la consola.

   

   Se abrirá una sesión de Cloud Shell dentro de un marco nuevo en la parte inferior de la consola y, en ella, se mostrará una ventana de la línea de comandos. La sesión de Shell puede tardar unos segundos en inicializar.

   

   Tu sesión de Cloud Shell está lista para usarse.

3. Configura la herramienta de línea de comandos de gcloud a fin de usar el proyecto seleccionado.

   gcloud config set project [selected-project-id]

   donde [selected-project-id] es el ID del proyecto. (omite los corchetes).

Instala frameworks

macOS

En el entorno virtual, ejecuta el siguiente comando para instalar las versiones de scikit-learn y Pandas que se usan en la versión 2.11 del entorno de ejecución de AI Platform Prediction:

(aip-env)$ pip install scikit-learn==1.0.2 pandas==1.3.5

Cuando proporcionas los números de versión en el comando anterior, garantizas que las dependencias del entorno virtual coincidan con las de la versión del entorno de ejecución. Esto ayuda a evitar comportamientos inesperados cuando el código se ejecuta en AI Platform Prediction.

Para obtener más detalles, información de solución de problemas y opciones de instalación, consulta las instrucciones de instalación de cada framework:

• Instrucciones de instalación de scikit-learn
• Instrucciones de instalación de Pandas

Cloud Shell

Ejecuta el siguiente comando para instalar scikit-learn y Pandas:

pip install --user scikit-learn pandas

Para obtener más detalles, opciones de instalación y también información que te ayude a solucionar problemas, consulta las instrucciones de instalación para cada marco de trabajo:

• Instrucciones de instalación de scikit-learn
• Instrucciones de instalación de Pandas

Descarga los datos

UC Irvine Machine Learning Repository aloja el Conjunto de datos de ingresos del censo que se usa en esta muestra para el entrenamiento. Consulta Acerca de los datos para obtener más información.

• El archivo de entrenamiento es adult.data.
• El archivo de evaluación es adult.test.

Nota: El archivo adult.test.csv tiene un carácter innecesario de punto al final de cada línea.

Entrena y guarda un modelo

Para entrenar y guardar un modelo, completa los siguientes pasos:

1. Carga los datos en un DataFrame de Pandas a fin de prepararlos para su uso con scikit-learn.
2. Entrena un modelo simple en scikit-learn.
3. Guarda el modelo en un archivo que se pueda subir a AI Platform Prediction.

Si ya tienes un modelo entrenado para subir, consulta cómo exportar tu modelo.

Carga y transforma datos

Puedes exportar objetos Pipeline mediante la versión de joblib incluida en scikit-learn o pickle, del mismo modo en que exportas estimadores de scikit-learn. En el ejemplo siguiente, se usan las canalizaciones para convertir atributos categóricos individuales en valores numéricos y combinarlos, y se usa un RandomForestClassifier a fin de entrenar el modelo.

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.

from sklearn.externals import joblib
import json
import numpy as np
import os
import pandas as pd
import pickle
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import FeatureUnion
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import LabelBinarizer

# Define the format of your input data, including unused columns.
# These are the columns from the census data files.
COLUMNS = (
    'age',
    'workclass',
    'fnlwgt',
    'education',
    'education-num',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'capital-gain',
    'capital-loss',
    'hours-per-week',
    'native-country',
    'income-level'
)

# Categorical columns are columns that need to be turned into a numerical value to be used by scikit-learn
CATEGORICAL_COLUMNS = (
    'workclass',
    'education',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'native-country'
)


# Load the training census dataset
with open('./census_data/adult.data', 'r') as train_data:
    raw_training_data = pd.read_csv(train_data, header=None, names=COLUMNS)

# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
train_features = raw_training_data.drop('income-level', axis=1).as_matrix().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = (raw_training_data['income-level'] == ' >50K').as_matrix().tolist()


# Load the test census dataset
with open('./census_data/adult.test', 'r') as test_data:
    raw_testing_data = pd.read_csv(test_data, names=COLUMNS, skiprows=1)
# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
test_features = raw_testing_data.drop('income-level', axis=1).as_matrix().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
test_labels = (raw_testing_data['income-level'] == ' >50K.').as_matrix().tolist()


# Since the census data set has categorical features, we need to convert
# them to numerical values. We'll use a list of pipelines to convert each
# categorical column and then use FeatureUnion to combine them before calling
# the RandomForestClassifier.
categorical_pipelines = []

# Each categorical column needs to be extracted individually and converted to a numerical value.
# To do this, each categorical column will use a pipeline that extracts one feature column via
# SelectKBest(k=1) and a LabelBinarizer() to convert the categorical value to a numerical one.
# A scores array (created below) will select and extract the feature column. The scores array is
# created by iterating over the COLUMNS and checking if it is a CATEGORICAL_COLUMN.
for i, col in enumerate(COLUMNS[:-1]):
    if col in CATEGORICAL_COLUMNS:
        # Create a scores array to get the individual categorical column.
        # Example:
        #  data = [39, 'State-gov', 77516, 'Bachelors', 13, 'Never-married', 'Adm-clerical',
        #         'Not-in-family', 'White', 'Male', 2174, 0, 40, 'United-States']
        #  scores = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        #
        # Returns: [['Sate-gov']]
        scores = []
        # Build the scores array
        for j in range(len(COLUMNS[:-1])):
            if i == j: # This column is the categorical column we want to extract.
                scores.append(1) # Set to 1 to select this column
            else: # Every other column should be ignored.
                scores.append(0)
        skb = SelectKBest(k=1)
        skb.scores_ = scores
        # Convert the categorical column to a numerical value
        lbn = LabelBinarizer()
        r = skb.transform(train_features)
        lbn.fit(r)
        # Create the pipeline to extract the categorical feature
        categorical_pipelines.append(
            ('categorical-{}'.format(i), Pipeline([
                ('SKB-{}'.format(i), skb),
                ('LBN-{}'.format(i), lbn)])))

# Create pipeline to extract the numerical features
skb = SelectKBest(k=6)
# From COLUMNS use the features that are numerical
skb.scores_ = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0]
categorical_pipelines.append(('numerical', skb))

# Combine all the features using FeatureUnion
preprocess = FeatureUnion(categorical_pipelines)

# Create the classifier
classifier = RandomForestClassifier()

# Transform the features and fit them to the classifier
classifier.fit(preprocess.transform(train_features), train_labels)

# Create the overall model as a single pipeline
pipeline = Pipeline([
    ('union', preprocess),
    ('classifier', classifier)
])

Exporta el modelo

Para exportar tu modelo, puedes usar joblib o la biblioteca pickle de Python:

joblib

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.

from sklearn.externals import joblib

# Export the model to a file
joblib.dump(pipeline, 'model.joblib')

pickle

# Export the model to a file
with open('model.pkl', 'wb') as model_file:
  pickle.dump(pipeline, model_file)

Requisitos para nombrar los archivos del modelo

El archivo del modelo guardado que subas a Cloud Storage debe llamarse model.pkl o model.joblib, según la biblioteca que hayas usado. Esta restricción garantiza que AI Platform Prediction use el mismo patrón que se usó durante la exportación para reconstruir el modelo en la importación.

Biblioteca usada para exportar el modelo	Nombre de modelo correcto
pickle	model.pkl
sklearn.externals.joblib	model.joblib

En futuras iteraciones de tu modelo, organiza tu bucket de Cloud Storage para que cada modelo nuevo tenga un directorio dedicado.

Almacena el modelo en Cloud Storage

A los efectos de este instructivo, es más fácil usar un bucket dedicado de Cloud Storage en el mismo proyecto que usas para AI Platform Prediction.

Si usas un bucket en un proyecto diferente, debes asegurarte de que la cuenta de servicio de AI Platform Prediction pueda acceder al modelo en Cloud Storage. Sin los permisos correspondientes, la solicitud para crear una versión del modelo en AI Platform Prediction fallará. Obtén más información sobre cómo otorgar permisos para el almacenamiento.

Configura tu bucket de Cloud Storage

En esta sección se muestra cómo crear un bucket nuevo. Puedes usar un bucket existente, pero debe estar en la misma región en la que planeas ejecutar los trabajos de AI Platform. Además, si no forma parte del proyecto que usas para ejecutar AI Platform Prediction, debes otorgar acceso a las cuentas de servicio de AI Platform Prediction de forma explícita.

1. Especifica un nombre para el bucket nuevo. El nombre debe ser único en todos los depósitos en Cloud Storage.

   BUCKET_NAME="YOUR_BUCKET_NAME"

   Por ejemplo, usa el nombre de tu proyecto con -aiplatform agregado:

   PROJECT_ID=$(gcloud config list project --format "value(core.project)")
   BUCKET_NAME=${PROJECT_ID}-aiplatform

2. Comprueba el nombre del bucket que creaste.

   echo $BUCKET_NAME

3. Selecciona una región para tu depósito y establece una variable de entorno REGION.

   Usa la misma región en la que planeas ejecutar trabajos de AI Platform Prediction. Consulta las regiones disponibles para los servicios de AI Platform Prediction.

   Por ejemplo, con el siguiente código, se crea una REGION y se la configura como us-central1:

   REGION=us-central1

4. Crea el bucket nuevo:

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

Sube el archivo del modelo exportado a Cloud Storage

Ejecuta el siguiente comando para subir tu archivo del modelo guardado a tu bucket en Cloud Storage:

gcloud storage cp ./model.joblib gs://your_bucket_name/model.joblib

Establece el formato de los datos para la predicción

Antes de enviar una solicitud de predicción en línea, debes dar formato a los datos de prueba a fin de prepararlos para que los use el servicio de predicción de AI Platform Prediction. Asegúrate de que el formato de las instancias de entrada coincida con lo que requiere el modelo.

Nota: Para limpiar tus datos, asegúrate de que las strings estén entre comillas dobles ("), en lugar de comillas simples ('). Esto ayuda a evitar que se genere un error de análisis de JSON.

gcloud

Crea un archivo input.json con cada instancia de entrada en una línea separada. En el ejemplo siguiente, se usan las diez primeras instancias de datos de la lista test_features que se definió en los pasos anteriores.

    [25, "Private", 226802, "11th", 7, "Never-married", "Machine-op-inspct", "Own-child", "Black", "Male", 0, 0, 40, "United-States"]
    [38, "Private", 89814, "HS-grad", 9, "Married-civ-spouse", "Farming-fishing", "Husband", "White", "Male", 0, 0, 50, "United-States"]
    [28, "Local-gov", 336951, "Assoc-acdm", 12, "Married-civ-spouse", "Protective-serv", "Husband", "White", "Male", 0, 0, 40, "United-States"]
    [44, "Private", 160323, "Some-college", 10, "Married-civ-spouse", "Machine-op-inspct", "Husband", "Black", "Male", 7688, 0, 40, "United-States"]
    [18, "?", 103497, "Some-college", 10, "Never-married", "?", "Own-child", "White", "Female", 0, 0, 30, "United-States"]
    [34, "Private", 198693, "10th", 6, "Never-married", "Other-service", "Not-in-family", "White", "Male", 0, 0, 30, "United-States"]
    [29, "?", 227026, "HS-grad", 9, "Never-married", "?", "Unmarried", "Black", "Male", 0, 0, 40, "United-States"]
    [63, "Self-emp-not-inc", 104626, "Prof-school", 15, "Married-civ-spouse", "Prof-specialty", "Husband", "White", "Male", 3103, 0, 32, "United-States"]
    [24, "Private", 369667, "Some-college", 10, "Never-married", "Other-service", "Unmarried", "White", "Female", 0, 0, 40, "United-States"]
    [55, "Private", 104996, "7th-8th", 4, "Married-civ-spouse", "Craft-repair", "Husband", "White", "Male", 0, 0, 10, "United-States"]

Ten en cuenta que el formato de las instancias de entrada debe coincidir con lo que tu modelo espera. En este ejemplo, el modelo del censo requiere 14 características, por lo que la entrada debe ser una matriz de forma (num_instances, 14).

API de REST

Crea un archivo input.json con cada instancia de entrada en una línea separada. En el ejemplo siguiente, se usan las diez primeras instancias de datos de la lista test_features que se definió en los pasos anteriores.

{
  "instances": [

    [25, "Private", 226802, "11th", 7, "Never-married", "Machine-op-inspct", "Own-child", "Black", "Male", 0, 0, 40, "United-States"],
    [38, "Private", 89814, "HS-grad", 9, "Married-civ-spouse", "Farming-fishing", "Husband", "White", "Male", 0, 0, 50, "United-States"],
    [28, "Local-gov", 336951, "Assoc-acdm", 12, "Married-civ-spouse", "Protective-serv", "Husband", "White", "Male", 0, 0, 40, "United-States"],
    [44, "Private", 160323, "Some-college", 10, "Married-civ-spouse", "Machine-op-inspct", "Husband", "Black", "Male", 7688, 0, 40, "United-States"],
    [18, "?", 103497, "Some-college", 10, "Never-married", "?", "Own-child", "White", "Female", 0, 0, 30, "United-States"],
    [34, "Private", 198693, "10th", 6, "Never-married", "Other-service", "Not-in-family", "White", "Male", 0, 0, 30, "United-States"],
    [29, "?", 227026, "HS-grad", 9, "Never-married", "?", "Unmarried", "Black", "Male", 0, 0, 40, "United-States"],
    [63, "Self-emp-not-inc", 104626, "Prof-school", 15, "Married-civ-spouse", "Prof-specialty", "Husband", "White", "Male", 3103, 0, 32, "United-States"],
    [24, "Private", 369667, "Some-college", 10, "Never-married", "Other-service", "Unmarried", "White", "Female", 0, 0, 40, "United-States"],
    [55, "Private", 104996, "7th-8th", 4, "Married-civ-spouse", "Craft-repair", "Husband", "White", "Male", 0, 0, 10, "United-States"]
  ]
}

Ten en cuenta que el formato de las instancias de entrada debe coincidir con lo que tu modelo espera. En este ejemplo, el modelo de censo requiere 14 atributos, por lo que la entrada debe ser una matriz de forma (num_instances, 14).

Obtén más información sobre cómo dar formato a la entrada para la predicción en línea.

Prueba el modelo con predicciones locales

Puedes usar el comando de gcloud ai-platform local predict para probar cómo en tu modelo se entregan predicciones antes de que lo implementes en AI Platform Prediction. Con el comando se usan dependencias en tu entorno local para realizar predicciones y mostrar resultados en el mismo formato que se emplea con gcloud ai-platform predict a fin de realizar predicciones en línea. La prueba local de las predicciones puede ayudarte a descubrir errores antes de incurrir en costos por las solicitudes de predicción en línea.

Para el argumento --model-dir, especifica un directorio que contenga tu modelo de aprendizaje automático exportado, ya sea en tu máquina local o en Cloud Storage. Para el argumento --framework, especifica tensorflow, scikit-learn o xgboost. No puedes usar el comando de gcloud ai-platform local predict con una rutina de predicción personalizada.

En el siguiente ejemplo, se muestra cómo realizar predicciones locales:

gcloud ai-platform local predict --model-dir LOCAL_OR_CLOUD_STORAGE_PATH_TO_MODEL_DIRECTORY/ \
  --json-instances LOCAL_PATH_TO_PREDICTION_INPUT.JSON \
  --framework NAME_OF_FRAMEWORK

Implementa modelos y versiones

AI Platform Prediction organiza los modelos entrenados mediante recursos de modelo y versión. Un modelo de AI Platform Prediction es un contenedor para las versiones del modelo de aprendizaje automático.

Para implementar un modelo, crea un recurso del modelo en AI Platform Prediction, crea una versión de ese modelo y, luego, vincula la versión con el archivo del modelo almacenado en Cloud Storage.

Crea un recurso de modelo

En AI Platform Prediction, se usan recursos de modelo para organizar diferentes versiones del modelo.

Debes decidir en este momento si deseas que las versiones que pertenecen a este modelo usen un extremo regional o el extremo global. Para la mayoría de los casos, elige un extremo regional. Si necesitas una funcionalidad que solo esté disponible en los tipos de máquina heredadas (MLS1), usa el extremo global.

También debes decidir en este momento si deseas que las versiones que corresponden a este modelo exporten los registros cuando entreguen predicciones. En los siguientes ejemplos, no se habilita el registro. Aprende cómo habilitar el registro.

Console

1. Abre la página Modelos de AI Platform Prediction en la consola de Google Cloud:

   Ir a la página Modelos

2. Haz clic en el botón Modelo nuevo en la parte superior de la página Modelos. Esto te llevará a la página Crear modelo.

3. Ingresa un nombre único para tu modelo en el campo Nombre del modelo.

4. Cuando se selecciona la casilla de verificación Usar extremos regionales, AI Platform Prediction usa un extremo regional. Si prefieres usar el extremo global, desmarca la casilla de verificación Usar extremos regionales.

5. En la lista desplegable Región, selecciona una ubicación para tus nodos de predicción. Las regiones disponibles dependen de si usas un extremo regional o el global.

6. Haz clic en Crear.

7. Verifica que regresaste a la página Modelos y que el modelo nuevo aparezca en la lista.

gcloud

Extremo regional

Ejecuta el siguiente comando:

gcloud ai-platform models create MODEL_NAME \
  --region=REGION

Reemplaza lo siguiente:

• MODEL_NAME: Es el nombre que elijas para tu modelo.
• REGION: la región del extremo regional en la que deseas que se ejecuten los nodos de predicción. Debe ser una región que admita los tipos de máquina (N1) de Compute Engine.

Si no especificas la marca --region, la CLI de gcloud te pedirá que selecciones un extremo regional (o que uses us-central en el extremo global).

Como alternativa, puedes establecer la propiedad ai_platform/region en una región específica a fin de asegurarte de que la CLI de gcloud siempre use el extremo regional correspondiente para AI Platform Prediction, incluso cuando no se especifica la marca --region. (Esta configuración no se aplica a los comandos del grupo de comandos gcloud ai-platform operations).

Extremo global

Ejecuta el siguiente comando:

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

Reemplaza lo siguiente:

• MODEL_NAME: Es el nombre que elijas para tu modelo.
• REGION: la región del extremo global en la que deseas que se ejecuten los nodos de predicción. Debe ser una región que admita tipos de máquina heredadas (MLS1).

Si no especificas la marca --regions, la CLI de gcloud te pedirá que selecciones un extremo regional (o que uses us-central1 en el extremo global).

API de REST

Extremo regional

1. Para darle formato a tu solicitud, coloca el objeto del modelo en el cuerpo de la solicitud. Como mínimo, especifica el nombre de tu modelo; para ello, reemplaza MODEL_NAME en la siguiente muestra:

   {
     "name": "MODEL_NAME"
   }
   

2. Realiza una llamada a la API de REST a la siguiente URL y reemplaza PROJECT_ID por tu ID del proyecto de Google Cloud:

   POST https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models/
   

   Reemplaza lo siguiente:

   • REGION: la región del extremo regional en la que se implementará tu modelo. Debe ser una región que admita los tipos de máquina (N1) de Compute Engine.

   • PROJECT_ID es el ID del proyecto de Google Cloud.

   Por ejemplo, puedes realizar la siguiente solicitud con el comando curl. Este comando autoriza la solicitud mediante las credenciales asociadas a la instalación de Google Cloud CLI.

   curl -X POST -H "Content-Type: application/json" \
     -d '{"name": "MODEL_NAME"}' \
     -H "Authorization: Bearer `gcloud auth print-access-token`" \
     "https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models"
   

   La API muestra una respuesta similar a la que se ve a continuación:

   {
     "name": "projects/PROJECT_ID/models/MODEL_NAME",
     "regions": [
       "REGION"
     ]
   }
   

Extremo global

1. Para darle formato a tu solicitud, coloca el objeto del modelo en el cuerpo de la solicitud. Como mínimo, especifica el nombre de tu modelo. Para esto, reemplaza MODEL_NAME en la siguiente muestra y especifica una región mediante el reemplazo de REGION por una región que admita los tipos de máquinas heredadas (MLS1):

   {
     "name": "MODEL_NAME",
     "regions": ["REGION"]
   }
   

2. Realiza una llamada a la API de REST a la siguiente URL y reemplaza PROJECT_ID por tu ID del proyecto de Google Cloud:

   POST https://ml.googleapis.com/v1/projects/PROJECT_ID/models/
   

   Por ejemplo, puedes realizar la siguiente solicitud con el comando curl. Este comando autoriza la solicitud mediante las credenciales asociadas a la instalación de Google Cloud CLI.

   curl -X POST -H "Content-Type: application/json" \
     -d '{"name": "MODEL_NAME", "regions": ["REGION"]}' \
     -H "Authorization: Bearer `gcloud auth print-access-token`" \
     "https://ml.googleapis.com/v1/projects/PROJECT_ID/models"
   

   La API muestra una respuesta similar a la que se ve a continuación:

   {
     "name": "projects/PROJECT_ID/models/MODEL_NAME",
     "regions": [
       "REGION"
     ]
   }
   

Consulta la API del modelo de AI Platform Prediction para obtener más detalles.

Crea una versión de modelo

Ahora estás listo para crear una versión del modelo con el modelo entrenado que subiste antes a Cloud Storage. Cuando creas una versión, puedes especificar una serie de parámetros. En la siguiente lista, se describen parámetros comunes; algunos de ellos son obligatorios:

• name: Debe ser único en el modelo de AI Platform Prediction.

• deploymentUri: Es la ruta de acceso a tu directorio de modelos en Cloud Storage.

  • Si implementas un modelo de TensorFlow, este es un directorio de modelos guardados.
  • Si implementas un modelo scikit-learn o XGBoost, este es el directorio que contiene tu archivo model.joblib, model.pkl o model.bst.
  • Si estás implementando una rutina de predicción personalizada, este es el directorio que contiene todos los artefactos de tu modelo. El tamaño total de este directorio debe ser de 500 MB o menos.

• framework: TENSORFLOW, SCIKIT_LEARN o XGBOOST.

• runtimeVersion: Es una versión del entorno de ejecución basada en las dependencias que se necesitan en el modelo. Si implementas un modelo de scikit-learn o XGBoost, debe ser 1.4 como mínimo. Si planeas usar la versión del modelo para la predicción por lotes, debes usar la versión 2.1 o anterior del entorno de ejecución.

• pythonVersion: Debe establecerse en “3.5” (en las versiones del entorno de ejecución abarcadas desde la 1.4 hasta la 1.14) o “3.7” (en las versiones 1.15 y posteriores) para que sea compatible con archivos de modelos exportados mediante Python 3. También se puede establecer en “2.7” si se usa con la versión 1.15 o con versiones anteriores del entorno de ejecución.

• machineType (opcional): Es el tipo de máquina virtual que se usa en AI Platform Prediction para los nodos que entregan predicciones. Obtén más información sobre los tipos de máquinas. Si no está configurado, el valor predeterminado es n1-standard-2 en extremos regionales y mls1-c1-m2 en el extremo global.

  Si tu versión del modelo usa un tipo de máquina (N1) de Compute Engine y menos de dos nodos, se excluye del Acuerdo de Nivel de Servicio (ANS) de AI Platform Training y Prediction .

  En otras palabras, si usas un tipo de máquina (N1) de Compute Engine, debes configurar manualScaling.nodes o autoScaling.minNodes como 2 o más para que la versión del modelo esté cubierta por el ANS.

  Además, el uso del ajuste de escala automático con GPU está disponible en vista previa. Por lo tanto, las versiones del modelo que usan ajuste de escala automático con GPU no están cubiertas por el ANS.

Obtén más información sobre cada uno de estos parámetros y sobre otros parámetros menos comunes en la referencia de la API para el recurso de la versión.

Además, si creaste el modelo en un extremo regional, asegúrate de crear la versión en el mismo extremo regional.

Console

1. Abre la página Modelos de AI Platform Prediction en la consola de Google Cloud:

   Ir a la página Modelos

2. En la página Modelos, selecciona el nombre del recurso de modelo que quieres usar para crear tu versión. Esto te llevará a la página Detalles del modelo.

3. Haz clic en el botón Nueva versión en la parte superior de la página Detalles del modelo. Esto te lleva a la página Crear versión.

4. Ingresa el nombre de la versión en el campo Nombre. De forma opcional, ingresa una descripción para tu versión en el campo Descripción.

5. Ingresa la siguiente información sobre cómo entrenaste tu modelo en los cuadros desplegables correspondientes:

   • Selecciona la versión de Python que usaste para entrenar el modelo.
   • Selecciona el framework y la versión del framework.
   • Selecciona la Versión de entorno de ejecución del AA. Obtén más información sobre las versiones del entorno de ejecución de AI Platform Prediction.

6. Selecciona un tipo de máquina para ejecutar la predicción en línea.

7. En el campo URI del modelo, ingresa la ubicación del depósito de Cloud Storage en la que subiste tu archivo de modelo. Puedes usar el botón Explorar para buscar la ruta de acceso correcta.

   Asegúrate de especificar la ruta de acceso al directorio que contiene el archivo, no la ruta de acceso al archivo de modelo. Por ejemplo, usa gs://your_bucket_name/model-dir/, en lugar de gs://your_bucket_name/model-dir/saved_model.pb o gs://your_bucket_name/model-dir/model.pkl.

8. Selecciona una opción de escalamiento para la implementación de la predicción en línea:

   • Si seleccionas "Ajuste de escala automático", se muestra el campo opcional Cantidad mínima de nodos. Puedes ingresar el número mínimo de nodos que se ejecutarán en todo momento, cuando el servicio se haya reducido.

   • Si seleccionas “Ajuste de escala manual” debes ingresar la cantidad de nodos que deseas que se ejecuten en todo momento.

   Obtén información sobre cómo las opciones de escalamiento difieren según el tipo de máquina.

   Obtén más información sobre los precios de los costos de predicción.

9. Para terminar de crear tu versión modelo, haz clic en Guardar.

gcloud

1. Establece variables de entorno para almacenar la ruta al directorio de Cloud Storage en el que se encuentra el objeto binario del modelo, el nombre del modelo, el nombre de la versión y el framework que hayas elegido.

   Cuando creas una versión con la CLI de gcloud, puedes proporcionar el nombre del framework en letras mayúsculas con guiones bajos (por ejemplo, SCIKIT_LEARN) o en minúsculas con guiones (por ejemplo, scikit-learn). Ambas opciones conducen a un comportamiento idéntico.

   Reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

   MODEL_DIR="gs://your_bucket_name/"
   VERSION_NAME="[YOUR-VERSION-NAME]"
   MODEL_NAME="[YOUR-MODEL-NAME]"
   FRAMEWORK="[YOUR-FRAMEWORK_NAME]"
   

2. Crea la versión:

   gcloud ai-platform versions create $VERSION_NAME \
     --model=$MODEL_NAME \
     --origin=$MODEL_DIR \
     --runtime-version=2.11 \
     --framework=$FRAMEWORK \
     --python-version=3.7 \
     --region=REGION \
     --machine-type=MACHINE_TYPE
   

   Reemplaza lo siguiente:

   • REGION: la región del extremo regional en la que creaste el modelo. Si creaste el modelo en el extremo global, omite la marca --region.

   • MACHINE_TYPE: Un tipo de máquina que determina los recursos de procesamiento disponibles para tus nodos de predicción.

   La creación de la versión toma unos minutos. Cuando esté lista, verás el siguiente resultado:

   Creating version (this might take a few minutes)......done.

3. Obtén información sobre tu versión nueva:

   gcloud ai-platform versions describe $VERSION_NAME \
     --model=$MODEL_NAME
   

   Deberías ver un resultado similar a este:

   createTime: '2018-02-28T16:30:45Z'
   deploymentUri: gs://your_bucket_name
   framework: [YOUR-FRAMEWORK-NAME]
   machineType: mls1-c1-m2
   name: projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]
   pythonVersion: '3.7'
   runtimeVersion: '2.11'
   state: READY

API de REST

1. Dale formato al cuerpo de tu solicitud para que contenga el objeto de la versión. En este ejemplo, se especifican los valores de name, deploymentUri, runtimeVersion, framework y machineType de la versión. Reemplaza [VALUES_IN_BRACKETS] por los valores adecuados siguientes:

   {
     "name": "[YOUR-VERSION-NAME]",
     "deploymentUri": "gs://your_bucket_name/",
     "runtimeVersion": "2.11",
     "framework": "[YOUR_FRAMEWORK_NAME]",
     "pythonVersion": "3.7",
     "machineType": "[YOUR_MACHINE_TYPE]"
   }
   

2. Haz una llamada a la API de REST en la ruta de acceso y reemplaza [VALUES_IN_BRACKETS] por los siguientes valores adecuados:

   POST https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions
   

   Reemplaza REGION por la región del extremo regional en la quecreaste tu modelo. Si creaste el modelo en el extremo global, usa ml.googleapis.com.

   Por ejemplo, puedes realizar la siguiente solicitud con el comando curl:

   curl -X POST -H "Content-Type: application/json" \
     -d '{"name": "[YOUR-VERSION-NAME]", "deploymentUri": "gs://your_bucket_name/", "runtimeVersion": "2.11", "framework": "[YOUR_FRAMEWORK_NAME]", "pythonVersion": "3.7", "machineType": "[YOUR_MACHINE_TYPE]"}' \
     -H "Authorization: Bearer `gcloud auth print-access-token`" \
     "https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions"
   

   La creación de la versión toma unos minutos. Cuando esté lista, debes ver un resultado similar a esto:

   {
     "name": "projects/[YOUR-PROJECT-ID]/operations/create_[YOUR-MODEL-NAME]_[YOUR-VERSION-NAME]-[TIMESTAMP]",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.ml.v1.OperationMetadata",
       "createTime": "2018-07-07T02:51:50Z",
       "operationType": "CREATE_VERSION",
       "modelName": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]",
       "version": {
         "name": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]",
         "deploymentUri": "gs://your_bucket_name",
         "createTime": "2018-07-07T02:51:49Z",
         "runtimeVersion": "2.11",
         "framework": "[YOUR_FRAMEWORK_NAME]",
         "machineType": "[YOUR_MACHINE_TYPE]",
         "pythonVersion": "3.7"
       }
     }
   }
   

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

Una vez que creas una versión de manera correcta, AI Platform Prediction inicia un servidor nuevo que está listo para entregar solicitudes de predicción.

En esta sección, se muestra lo siguiente:

1. Cómo probar el modelo con gcloud mediante el envío de solicitudes para conjuntos de datos más pequeños.
2. Cómo enviar solicitudes más grandes para el conjunto de datos de prueba completo con la biblioteca cliente de Python y ver los primeros diez resultados.

gcloud

En esta sección, se explica cómo enviar una solicitud de predicción con el archivo input.json que creaste en el paso anterior.

Nota: Si eliges enviar una solicitud para todo el conjunto de datos de prueba, ten en cuenta que la cantidad máxima de datos que se pueden enviar en una sola solicitud es de 1.5 MB. Debido a que el tamaño del conjunto de datos de prueba del censo excede este límite, debes dividir el conjunto a la mitad y enviar dos solicitudes.

1. Establece las variables de entorno para el nombre del modelo, de la versión y del archivo de entrada: Reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

   MODEL_NAME="[YOUR-MODEL-NAME]"
   VERSION_NAME="[YOUR-VERSION-NAME]"
   INPUT_FILE="input.json"
   

2. Envía la solicitud de predicción:

   gcloud ai-platform predict --model $MODEL_NAME --version \
     $VERSION_NAME --json-instances $INPUT_FILE
   

   Los resultados de la predicción muestran True si se estima que los ingresos de la persona serán mayores a $50,000 por año, y False en caso contrario. Como ejemplo, los primeros diez resultados pueden ser similares a los siguientes:

   [False, False, False, True, False, False, False, False, False, False]
   

API de REST

En esta sección, se explica cómo enviar una solicitud de predicción con el archivo input.json que creaste en el paso anterior.

Nota: Si eliges enviar una solicitud para todo el conjunto de datos de prueba, ten en cuenta que la cantidad máxima de datos que se pueden enviar en una sola solicitud es de 1.5 MB. Debido a que el tamaño del conjunto de datos de prueba del censo excede este límite, debes dividir el conjunto a la mitad y enviar dos solicitudes.

Envía las solicitudes de predicción:

curl -X POST -H "Content-Type: application/json" -d @input.json \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
"https://ml.googleapis.com/v1/projects/${PROJECT_ID}/models/${MODEL_NAME}/versions/${VERSION_NAME}:predict"

Los resultados de la predicción muestran True si se estima que los ingresos de la persona serán mayores a $50,000 por año, y False en caso contrario. Los resultados de la predicción se muestran en la consola como una lista de valores booleanos. Como ejemplo, tus primeros diez resultados pueden parecer similares a los siguientes:

{"predictions": [false, false, false, true, false, false, false, false, false, false]}

Python

Esta muestra usa la biblioteca cliente de Python para enviar solicitudes de predicción en todo el conjunto de datos del censo e imprime los primeros diez resultados. Consulta más información sobre cómo usar la biblioteca cliente de Python.

Nota: La cantidad máxima de datos que se pueden enviar en una sola solicitud es de 1.5 MB. Debido a que el tamaño del conjunto de datos de prueba del censo excede este límite, en el ejemplo siguiente, se divide el conjunto de datos a la mitad y se envían dos solicitudes.

Reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

import googleapiclient.discovery

# Fill in your PROJECT_ID, VERSION_NAME and MODEL_NAME before running
# this code.

PROJECT_ID = [YOUR PROJECT_ID HERE]
VERSION_NAME = [YOUR VERSION_NAME HERE]
MODEL_NAME = [YOUR MODEL_NAME HERE]

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

# Due to the size of the data, it needs to be split in 2
first_half = test_features[:int(len(test_features)/2)]
second_half = test_features[int(len(test_features)/2):]

complete_results = []
for data in [first_half, second_half]:
    responses = service.projects().predict(
        name=name,
        body={'instances': data}
    ).execute()

    if 'error' in responses:
        print(response['error'])
    else:
        complete_results.extend(responses['predictions'])

# Print the first 10 responses
for i, response in enumerate(complete_results[:10]):
    print('Prediction: {}\tLabel: {}'.format(response, test_labels[i]))

Los resultados de la predicción muestran True si se estima que los ingresos de la persona serán mayores a $50,000 por año, y False en caso contrario. Como ejemplo, los primeros diez resultados pueden ser similares a los siguientes:

Prediction: False Label: False
Prediction: False Label: False
Prediction: True  Label: True
Prediction: True  Label: True
Prediction: False Label: False
Prediction: False Label: False
Prediction: False Label: False
Prediction: True  Label: True
Prediction: False Label: False
Prediction: False Label: False

Obtén más información sobre los parámetros de entrada en los detalles de las solicitudes de predicción de la API de AI Platform Prediction.

Acerca de los datos

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

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

Pasos siguientes

• Prueba este instructivo como un notebook de Jupyter en GitHub.
• Consulta más muestras de notebooks de scikit-learn en GitHub.