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 forma local, lo implementas en Cloud ML Engine y lo consultas para obtener predicciones en línea.

Puedes implementar y entregar canalizaciones scikit-learn en Cloud ML Engine. Ten en cuenta que Cloud ML Engine solo admite transformaciones scikit-learn compiladas previamente como componentes en la canalización.

El modulo canalización en scikit-learn te permite aplicar múltiples transformaciones de datos antes de entrenar 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.

Lleva tu modelo a Cloud ML Engine

Puedes llevar tu modelo a Cloud ML Engine para obtener predicciones en cinco pasos:

  • Guarda tu modelo en un archivo.
  • Sube el modelo guardado a Cloud Storage.
  • Crea un recurso modelo en Cloud ML Engine.
  • 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 Cloud ML Engine y también instalar y activar el SDK de Cloud.

Configura tu proyecto de GCP

  1. Sign in to your Google Account.

    If you don't already have one, sign up for a new account.

  2. Select or create a Google Cloud Platform project.

    Go to the Manage resources page

  3. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

  4. Habilita las Cloud Machine Learning Engine y Compute Engine API necesarias.

    Habilita las API

  5. Install and initialize the Cloud SDK.

Configura tu entorno

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

Para los usuarios de macOS, se recomienda configurar su entorno con 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 proporciona una forma rápida de probar Cloud Machine Learning Engine, pero no es adecuada para el trabajo de desarrollo en curso.

macOS

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

    python -V
  2. Comprueba la instalación de pip.
    pip es el administrador de paquetes de Python, incluido con las versiones actuales de Python. Comprueba si ya está instalado pip cuando ejecutes 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 para crear entornos aislados de Python. Comprueba si ya está instalado virtualenv cuando ejecutes virtualenv --version. De lo contrario, instala virtualenv:

    pip install --user --upgrade virtualenv

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

    virtualenv cmle-env
    source cmle-env/bin/activate
  4. A los fines de este instructivo, ejecuta el resto de los comandos dentro de tu entorno virtual.

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

Cloud Shell

  1. Abre Google Cloud Platform Console.

    Google Cloud Platform Console

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

    Activa Google Cloud Shell

    Se abrirá una sesión de Cloud Shell dentro de un marco nuevo en la parte inferior de la consola y se mostrará un mensaje de línea de comandos. Es posible que esta sesión tarde unos segundos en inicializarse.

    Sesión de Cloud Shell

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

  3. Configura la herramienta de línea de comandos de gcloud para usar tu proyecto seleccionado.

    gcloud config set project [selected-project-id]

    en el que [selected-project-id] es tu ID del proyecto (Omite los corchetes de cierre).

Verifica los componentes del SDK de Google Cloud

Para verificar que los componentes del SDK de Google Cloud estén instalados, realiza las siguientes acciones:

  1. Enumera tus modelos:

    gcloud ml-engine models list
  2. Si no creaste ningún modelo anteriormente, el comando muestra una lista vacía:

    Listed 0 items.

    Después de comenzar a crear modelos, puedes verlos listados con este comando.

  3. Si instalaste gcloud anteriormente, actualiza gcloud:

    gcloud components update

Instala marcos de trabajo

macOS

Dentro de tu entorno virtual, ejecuta el siguiente comando para instalar scikit-learn, Pandas y joblib:

(cmle-env)$ pip install scikit-learn pandas joblib

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

Cloud Shell

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

pip install --user scikit-learn pandas joblib

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

Descarga los datos

El Conjunto de datos de ingresos del censo, que usa esta muestra para el entrenamiento, está alojado en UC Irvine Machine Learning Repository. 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

Entrena y guarda un modelo

A fin de entrenar y guardar un modelo, completa los siguientes pasos:

  1. Carga los datos en un marco de datos de Pandas a fin de prepararlos para su uso con XGBoost.
  2. Entrena un modelo simple en XGBoost.
  3. Guarda el modelo en un archivo que se pueda subir a Cloud ML Engine.

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

Carga y transforma datos

Puedes exportar objetos Pipeline con joblib o pickle de forma similar a como se exportan los estimadores scikit-learn. En el siguiente ejemplo, se usan canalizaciones para convertir características categóricas individuales en valores numéricos, las combina y usa una RandomForestClassifier para entrenar el modelo.

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 tu modelo

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

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 de modelo guardado que subas en Cloud Storage debe llamarse model.pkl o model.joblib, dependiendo de la biblioteca que usaste. Esta restricción garantiza que en Cloud ML Engine se 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 del modelo correcto
pickle model.pkl
joblib model.joblib

Para futuras iteraciones de tu modelo, organiza tu depósito de Cloud Storage a fin de que cada modelo nuevo tenga un directorio dedicado.

Almacena tu modelo en Cloud Storage

A los fines de este instructivo, es más fácil usar un depósito de Cloud Storage dedicado en el mismo proyecto que estés usando para Cloud ML Engine.

Si estás usando un depósito en un proyecto diferente, debes asegurarte de que tu cuenta de servicio de Cloud ML Engine pueda acceder a tu modelo en Cloud Storage. Sin los permisos adecuados, tu solicitud para crear una versión del modelo de Cloud ML Engine tendrá errores. Obtén más información sobre otorgar permisos para el almacenamiento.

Configura tu depósito de Cloud Storage

En esta sección, se muestra cómo crear un depósito nuevo. Puedes usar un depósito existente, pero si no es parte del proyecto que usas para ejecutar Cloud ML Engine, debes otorgar acceso de forma explícita a las cuentas de servicio de Cloud ML Engine.

  1. Especifica un nombre para tu depósito 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 -mlengine agregado:

    PROJECT_ID=$(gcloud config list project --format "value(core.project)")
    BUCKET_NAME=${PROJECT_ID}-mlengine
  2. Comprueba el nombre del depósito que creaste.

    echo $BUCKET_NAME
  3. Selecciona una región para tu depósito y configura una variable de entorno "REGION".

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

    REGION=us-central1
  4. Crea el depósito nuevo:

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

    Nota: Usa la misma región donde planeas ejecutar trabajos de Cloud ML Engine. En el ejemplo, se usa us-central1 porque esa es la región que se utiliza en las instrucciones de introducción.

Sube el archivo del modelo exportado a Cloud Storage

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

gsutil cp ./model.joblib gs://your_bucket_name/model.joblib

Formato de datos para la predicción

Antes de enviar una solicitud de predicción en línea, debes dar formato a los datos de prueba para prepararlos a fin de que los use el servicio de predicción de Cloud ML Engine. Asegúrate de que el formato de tus instancias de entrada coincida con lo que espera tu modelo.

gcloud

Crea un archivo input.json con cada instancia de entrada en una línea separada. El siguiente ejemplo usa las diez primeras instancias de datos en la lista de test_features que se definió en 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 de Census requiere 14 características, por lo que tu entrada debe ser una matriz de forma (num_instances, 14).

API de REST

Crea un archivo input.json con formato con cada instancia de entrada en una línea separada. El siguiente ejemplo usa las diez primeras instancias de datos en la lista de test_features que se definió en 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 Census requiere 14 características, por lo que tu entrada debe ser una matriz de forma (num_instances, 14).

Consulta más información sobre darle formato a tu entrada para la predicción en línea.

Prueba tu modelo con predicciones locales

Puedes usar gcloud para implementar tu modelo en predicciones locales. Este paso opcional te ayuda a ahorrar tiempo, ya que comprueba la validez de tu modelo antes de implementarlo en Cloud ML Engine. Cuando usas el archivo del modelo que subiste a Cloud Storage, puedes ejecutar la predicción en línea de forma local y obtener una vista previa de los resultados que mostraría el servidor de predicción de Cloud ML Engine.

Usa la predicción local con un subconjunto pequeño de tus datos de prueba para depurar una falta de coincidencia entre las funciones de entrenamiento y de entrega. Por ejemplo, si los datos que envías con tu solicitud de predicción no coinciden con lo que espera tu modelo, puedes averiguarlo antes de que se generen costos por las solicitudes de predicción en la nube en línea.

Obtén más información sobre el uso de gcloud local predict.

  1. Establece las variables de entorno para el directorio de Cloud Storage que contiene tu modelo ("gs://your-bucket/"), el marco de trabajo y el nombre de tu archivo de entrada, si aún no lo has hecho:

    MODEL_DIR="gs://your-bucket/"
    INPUT_FILE="input.json"
    FRAMEWORK="SCIKIT_LEARN"
    
  2. Envía la solicitud de predicción:

    gcloud ml-engine local predict --model-dir=$MODEL_DIR \
        --json-instances $INPUT_FILE \
        --framework $FRAMEWORK
    

Implementa modelos y versiones

Cloud ML Engine organiza tus modelos entrenados con los recursos de modelos y versiones. Un modelo de Cloud ML Engine es un contenedor para las versiones de tu modelo de aprendizaje automático.

Para implementar un modelo, crea un recurso del modelo en Cloud ML Engine, una versión de ese modelo y vincula la versión del modelo al archivo del modelo almacenado en Cloud Storage.

Crea un recurso del modelo

En Cloud ML Engine, se usan los recursos del modelo para organizar diferentes versiones de tu modelo.

Console

  1. Abre la página de modelos de Cloud ML Engine en GCP Console:

    Abrir modelos en GCP Console

  2. Si es necesario, crea el modelo para agregar tu versión nueva a:

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

    2. Ingresa un nombre único para tu modelo en el cuadro Nombre del modelo. De forma opcional, ingresa una descripción para tu modelo en el campo Descripción.

    3. Haz clic en Guardar.

    4. Verifica que hayas regresado a la página Modelos y que tu modelo nuevo aparezca en la lista.

gcloud

Crea un recurso del modelo para tus versiones del modelo y completa el nombre deseado de tu modelo sin los corchetes:

    gcloud ml-engine models create "[YOUR-MODEL-NAME]"

API de REST

  1. Dale formato a tu solicitud y coloca el objeto del modelo en el cuerpo de la solicitud. Como mínimo, debes especificar un nombre para tu modelo. Completa con el nombre que desees sin los corchetes:

      {"name": "[YOUR-MODEL-NAME]" }
    
  2. Haz una llamada a la API de REST en la siguiente ruta de acceso y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    Por ejemplo, puedes realizar la siguiente solicitud con cURL:

      curl -X POST -H "Content-Type: application/json" \
        -d '{"name": "[YOUR-MODEL-NAME]"}' \
        -H "Authorization: Bearer `gcloud auth print-access-token`" \
        "https://ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models"
    

    Deberías ver un resultado similar a este:

      {
        "name": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]",
        "regions": [
          "us-central1"
        ]
      }
    

Consulta la API del modelo de Cloud ML Engine para más detalles.

Crea una versión del modelo

Ahora estás listo para crear una versión del modelo con el modelo entrenado que subiste previamente a Cloud Storage. Cuando creas una versión, necesitas especificar los siguientes parámetros:

  • name: Debe ser único dentro del modelo de Cloud ML Engine.
  • deploymentUri: La ruta de acceso al directorio donde se almacena el archivo del modelo exportado. Asegúrate de especificar la ruta de acceso al directorio que contiene el archivo, no la ruta de acceso al archivo del modelo.
    • Ruta de acceso al modelo - gs://your_bucket_name/model.pkl
    • Ruta de acceso al directorio que contiene el modelo - gs://your_bucket_name/
  • framework: "SCIKIT_LEARN" o "XGBOOST"
  • runtimeVersion: Se debe configurar en "1.4" o superior para asegurarte de que estás usando una versión de Cloud ML Engine que admita scikit-learn y XGBoost.
  • pythonVersion: Se debe configurar en "3.5" para que sea compatible con los archivos del modelo exportados mediante Python 3. Si no se configura, el valor predeterminado es "2.7".

Consulta más información sobre cada uno de estos parámetros en la API de Cloud ML Engine para un recurso de la versión.

Consulta los detalles completos de cada versión del entorno de ejecución.

Console

  1. En la página Modelos, selecciona el nombre del recurso del modelo que te gustaría usar para crear tu versión. Esto te lleva a la página Detalles del modelo.

    Abrir modelos en GCP Console

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

  3. Ingresa tu 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.

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

  5. De forma opcional, selecciona un tipo de máquina para ejecutar la predicción en línea. El valor predeterminado de este campo es "CPU de un núcleo".

  6. En el campo URI del modelo, ingresa la ubicación del depósito de Cloud Storage donde subiste tu archivo del modelo. Puedes usar el botón "Explorar" para encontrar 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 del modelo. Por ejemplo, usa "gs://your_bucket_name/" en lugar de "gs://your_bucket_name/model.pkl".

  7. Selecciona una opción de escalamiento para la implementación de predicción en línea: Escalamiento automático o escalamiento manual.

    • Si seleccionas "Escalamiento automático", se muestra el campo opcional Cantidad mínima de nodos. Puedes ingresar la cantidad mínima de nodos que quieres que se ejecuten en todo momento cuando el servicio haya reducido su escala. El valor predeterminado de este campo es 0.

    • Si seleccionas "Escalamiento manual", se muestra el campo obligatorio Cantidad de nodos. Debes ingresar la cantidad de nodos que deseas que se ejecuten en todo momento.

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

  8. Para terminar de crear tu versión del 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 modelo binario, el nombre de tu modelo, el nombre de tu versión y tu elección de marco de trabajo ("SCIKIT_LEARN" o "XGBOOST"). 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="SCIKIT_LEARN"
    
  2. Crea la versión:

      gcloud ml-engine versions create $VERSION_NAME \
          --model $MODEL_NAME --origin $MODEL_DIR \
          --runtime-version=1.12 --framework $FRAMEWORK \
          --python-version=3.5
    

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

      Creating version (this might take a few minutes)......done.
    
  3. Obtén información sobre tu versión nueva:

      gcloud ml-engine 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: SCIKIT_LEARN
      machineType: mls1-highmem-1
      name: projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]
      pythonVersion: '3.5'
      runtimeVersion: '1.12'
      state: READY
    

API de REST

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

      {
        "name": "[YOUR-VERSION-NAME]",
        "deploymentUri": "gs://your_bucket_name/"
        "runtimeVersion": "1.12"
        "framework": "SCIKIT_LEARN"
        "pythonVersion": "3.5"
      }
    
  2. Haz una llamada a la API de REST en la siguiente ruta de acceso y reemplaza [VALUES_IN_BRACKETS] por los valores adecuados:

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

    Por ejemplo, puedes realizar la siguiente solicitud con cURL:

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

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

      {
        "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": "1.12",
            "framework": "SCIKIT_LEARN",
            "machineType": "mls1-highmem-1",
            "pythonVersion": "3.5"
          }
        }
      }
    

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

Una vez que hayas creado correctamente una versión, en Cloud ML Engine se inicia un servidor nuevo que está listo para entregar las solicitudes de predicción.

En esta sección, se muestra lo siguiente:

  1. Cómo probar tu modelo con gcloud por medio del envió de solicitudes de 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

Esta sección explica cómo enviar una solicitud de predicción con el archivo input.json que creaste en un paso anterior.

  1. Establece las variables del entorno para el nombre de tu modelo, el de la versión y el de tu 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 ml-engine predict --model $MODEL_NAME --version \
      $VERSION_NAME --json-instances $INPUT_FILE
    

    Los resultados de la predicción muestran True si se pronostica que los ingresos de la persona serán mayores a $50,000 por año, y False si es lo contrario. Como ejemplo, tus primeros diez resultados pueden parecer 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.

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 pronostica que los ingresos de la persona serán mayores a $50,000 por año, y False si es lo 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

En esta muestra, se usa la biblioteca cliente de Python para enviar solicitudes de predicción en todo el conjunto de datos del censo y también imprime los primeros diez resultados. Consulta más información sobre cómo usar la biblioteca cliente de Python.

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 pronostica que los ingresos de la persona serán mayores a $50,000 por año, y False si es lo contrario. Como ejemplo, tus primeros diez resultados pueden parecer 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

Para obtener más información sobre cada parámetro de entrada, consulta los detalles de la solicitud de predicción de la API de Cloud ML Engine.

Acerca de los datos

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

Datos del censo de cortesía de: Lichman, M. (2013). UCI Machine Learning Repository http://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 cualquier persona pueda usarlo según los siguientes términos proporcionados por la fuente del conjunto de datos: http://archive.ics.uci.edu/ml, y se brinda “TAL CUAL”, sin ninguna garantía, expresa o implícita, de Google. Google renuncia a toda responsabilidad de cualquier daño, directo o indirecto, como resultado del uso del conjunto de datos.

¿Qué sigue?

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Cloud ML Engine para XGBoost y scikit-learn