Predicciones con scikit-learn y XGBoost

El servicio de predicción en línea de AI Platform Prediction administra los recursos de procesamiento en la nube para ejecutar tus modelos. Estos modelos pueden ser modelos de scikit-learn o de XGBoost que hayas entrenado en otro lugar (de forma local o a través de otro servicio) y exportado a un archivo. En esta página, se describe el proceso para obtener predicciones en línea de estos modelos exportados mediante AI Platform Prediction.

Descripción general

En este instructivo, debes entrenar un modelo simple para predecir las especies de flores mediante el conjunto de datos Iris. Después de entrenar y guardar el modelo de manera local, debes implementarlo en AI Platform Prediction y consultarlo para obtener predicciones 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.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

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

    Habilita las API

  5. Instala e inicializa el SDK de Cloud.

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

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

Cloud Shell

  1. Abre Google Cloud Console.

    Google Cloud Console

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

    Activar Google Cloud Shell

    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.

    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 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 tu entorno virtual, ejecuta el siguiente comando para instalar las versiones de scikit-learn, XGBoost y Pandas que se usan en la versión de entorno de ejecución 1.15 de AI Platform Prediction:

(cmle-env)$ pip install scikit-learn==0.20.2 xgboost==0.81 pandas==0.24.0

Cuando proporcionas los números de versión en el comando anterior, garantizas que las dependencias de tu 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:

Cloud Shell

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

pip install --user scikit-learn xgboost pandas

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:

Versiones de scikit-learn y XGBoost

Las versiones del entorno de ejecución de AI Platform Prediction se actualizan de forma periódica a fin de incluir asistencia para los nuevos lanzamientos de scikit-learn y XGBoost. Consulta los detalles completos de cada versión del entorno de ejecución.

Entrena y guarda un modelo

Comienza por entrenar un modelo simple para el conjunto de datos Iris.

scikit-learn

Si sigues el ejemplo de scikit-learn sobre la persistencia del modelo, puedes entrenar y exportar un modelo como se muestra a continuación:

from sklearn.externals import joblib
from sklearn import datasets
from sklearn import svm

# Load the Iris dataset
iris = datasets.load_iris()

# Train a classifier
classifier = svm.SVC()
classifier.fit(iris.data, iris.target)

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

Para exportar el modelo, también tienes la opción de usar la biblioteca pickle de la siguiente manera:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(classifier, model_file)

XGBoost

Puedes exportar el modelo con el método "save_model" del objeto Booster.

A los fines de este instructivo, scikit-learn se usa con XGBoost solo para importar el conjunto de datos Iris.

from sklearn import datasets
import xgboost as xgb

# Load the Iris dataset
iris = datasets.load_iris()

# Load data into DMatrix object
dtrain = xgb.DMatrix(iris.data, label=iris.target)

# Train XGBoost model
bst = xgb.train({}, dtrain, 20)

# Export the classifier to a file
bst.save_model('./model.bst')

Para exportar el modelo, también tienes la opción de usar la biblioteca pickle de la siguiente manera:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(bst, model_file)

Requisitos para nombrar los archivos del modelo

Para la predicción en línea, el archivo de modelo guardado que subas a Cloud Storage debe llamarse model.pkl, model.joblib o model.bst, según la biblioteca que hayas usado. Esta restricción garantiza que AI Platform Prediction usará el mismo patrón que se usó durante la exportación para reconstruir el modelo en la importación.

Este requisito no se aplica si creas una rutina de predicción personalizada (versión Beta).

scikit-learn

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

XGBoost

Biblioteca usada para exportar el modelo Nombre de modelo correcto
pickle model.pkl
joblib model.joblib
xgboost.Booster model.bst

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

Almacena el modelo en Cloud Storage

Para los fines de este instructivo, es más fácil usar un depósito dedicado de Cloud Storage en el mismo proyecto que usas para AI Platform Prediction.

Si usas un depósito 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 de AI Platform Prediction fallará. Obtén más información sobre cómo otorgar permisos para el almacenamiento.

Configura el 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 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 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 -aiplatform agregado:

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

    echo $BUCKET_NAME
  3. Selecciona una región para el 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 depósito nuevo:

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

Sube el archivo del modelo exportado a Cloud Storage

Ejecuta el siguiente comando para subir el modelo que exportaste anteriormente en este instructivo a tu depósito en Cloud Storage:

gsutil cp ./model.joblib gs://$BUCKET_NAME/model.joblib

Puedes usar el mismo depósito de Cloud Storage para varios archivos de modelo. Cada archivo de modelo debe estar en su propio directorio dentro del depósito.

Formato de datos para la predicción

gcloud

Crea un archivo input.json con cada instancia de entrada en una línea separada de la siguiente manera:

[6.8,  2.8,  4.8,  1.4]
[6.0,  3.4,  4.5,  1.6]

Ten en cuenta que el formato de las instancias de entrada debe coincidir con lo que se espera en tu modelo. En este ejemplo, el modelo Iris requiere 4 funciones, por lo que tu entrada debe ser una matriz de forma (num_instances, 4).

API de REST

Crea un archivo input.json con el formato de una lista simple de anuncios flotantes, con cada instancia de entrada en una línea separada de la siguiente manera:

{
  "instances": [

    [6.8,  2.8,  4.8,  1.4],
    [6.0,  3.4,  4.5,  1.6]

  ]
}

Ten en cuenta que el formato de las instancias de entrada debe coincidir con lo que se espera en tu modelo. En este ejemplo, el modelo Iris requiere 4 funciones, por lo que tu entrada debe ser una matriz de forma (num_instances, 4).

Para XGBoost, no se admite la representación dispersa de instancias de entrada en AI Platform Prediction. Si el valor de un atributo es cero, usa 0.0 en la entrada correspondiente. Si falta el valor de una función, usa NaN en la entrada correspondiente.

Consulta más información sobre cómo dar formato a las entradas para predicciones en línea.

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

Console

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

    Abre Modelos en Cloud Console

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

  3. Ingresa un nombre único para tu modelo en el campo Nombre del modelo. Usa la lista desplegable Región a fin de seleccionar una ubicación para los nodos de predicción.

  4. Haz clic en Crear.

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

gcloud

En el siguiente comando, reemplaza MODEL_NAME por el nombre que desees para tu modelo. Reemplaza REGION por la región en la que quieres que se ejecuten los nodos de predicción. Debes elegir una región que admita la predicción en línea.

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

Mediante este comando, se crea un modelo en el extremo global. Como alternativa, puedes crear el modelo en un extremo regional.

API de REST

A continuación, se describen los pasos para crear un modelo en el extremo global. Como alternativa, puedes crear un modelo en un extremo regional.

  1. Para darle formato a la solicitud, coloca el objeto del modelo en el cuerpo de la solicitud. Como mínimo, especifica el nombre de tu modelo. Para hacerlo, reemplaza MODEL_NAME en los siguientes ejemplos y especifica una región mediante el reemplazo de REGION por una región que admita la predicción en línea.

    {
      "name": "MODEL_NAME",
      "regions": ["REGION"]
    }
    
  2. Haz una llamada a la API de REST en la siguiente ruta de acceso y reemplaza PROJECT_ID por el ID del proyecto de Google Cloud:

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

    Por ejemplo, puedes realizar la siguiente solicitud con cURL:

    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.

  • 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 mls1-c1-m2.

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. En la página Modelos, selecciona el nombre del recurso de modelo que te gustaría usar para crear tu versión. Esto te lleva a la página Detalles del modelo.

    Abrir Modelos en Cloud Console

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

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

  4. Ingresa la siguiente información sobre cómo entrenaste 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 en la que subiste tu archivo del 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.

  7. 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. El valor predeterminado de este campo es 0.

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

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

  8. 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 herramienta de gcloud, puedes proporcionar el nombre del marco de trabajo 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 siguientes:

    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=1.15 \
      --framework $FRAMEWORK \
      --python-version=3.7
    

    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 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: '1.15'
    state: READY

API de REST

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

      {
        "name": "[YOUR-VERSION-NAME]",
        "deploymentUri": "gs://your_bucket_name/"
        "runtimeVersion": "1.15"
        "framework": "[YOUR_FRAMEWORK_NAME]"
        "pythonVersion": "3.7"
      }
    
  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://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.15", "framework": "[YOUR_FRAMEWORK_NAME]", "pythonVersion": "3.7"}' \
          -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 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": "1.15",
            "framework": "[YOUR_FRAMEWORK_NAME]",
            "machineType": "mls1-c1-m2",
            "pythonVersion": "3.7"
          }
        }
      }
    

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

Una vez que hayas creado de forma correcta una versión del modelo, en AI Platform Prediction se inicia un servidor nuevo que está listo para entregar solicitudes de predicción.

gcloud

  1. Establece las variables de entorno para el nombre de tu modelo, el nombre de la versión y el nombre de tu archivo de entrada:

    MODEL_NAME="iris"
    VERSION_NAME="v1"
    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
    

Python

En esta muestra, se supone que estás familiarizado con la biblioteca cliente de Google Cloud para Python. Si no estás familiarizado con ella, consulta Usa la biblioteca cliente de Python.

import googleapiclient.discovery

def predict_json(project, model, instances, version=None):
    """Send json data to a deployed model for prediction.
    Args:
        project (str): project where the AI Platform Prediction Model is deployed.
        model (str): model name.
        instances ([[float]]): List of input instances, where each input
           instance is a list of floats.
        version: str, version of the model to target.
    Returns:
        Mapping[str: any]: dictionary of prediction results defined by the
            model.
    """
    # Create the AI Platform Prediction service object.
    # To authenticate set the environment variable
    # GOOGLE_APPLICATION_CREDENTIALS=<path_to_service_account_file>
    service = googleapiclient.discovery.build('ml', 'v1')
    name = 'projects/{}/models/{}'.format(project, model)

    if version is not None:
        name += '/versions/{}'.format(version)

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

    if 'error' in response:
        raise RuntimeError(response['error'])

    return response['predictions']

Obtén más información sobre cada uno de estos parámetros en la API de AI Platform Prediction para la entrada de predicción.

Próximos pasos