Obtén predicciones en línea

La predicción en línea de Cloud Machine Learning Engine es un servicio optimizado para ejecutar tus datos mediante modelos alojados con la menor latencia posible. Envías lotes pequeños de datos al servicio y tus predicciones se muestran en la respuesta.

Obtén más información sobre la predicción en línea frente a la predicción por lotes o consulta una descripción general de los conceptos de predicción.

Antes de comenzar

Para solicitar predicciones, primero debes realizar las siguientes acciones:

  • Optimiza tu grafo para la predicción y asegúrate de que el tamaño del archivo de tu modelo guardado no supere el límite predeterminado de 250 MB de Cloud ML Engine.

  • Verifica que tus datos de entrada tengan el formato correcto para la predicción en línea.

Regiones

La predicción en línea de Cloud ML Engine se encuentra actualmente disponible en las siguientes regiones:

  • us-central1
  • europe-west1
  • us-east1
  • asia-northeast1

A fin de comprender por completo las regiones disponibles para los servicios de entrenamiento y predicción de Cloud ML Engine, consulta la guía de regiones.

Crea modelos y versiones

Toma las siguientes decisiones importantes sobre cómo ejecutar la predicción en línea cuando crees los recursos de modelo y versión:

Recurso creado Decisión especificada en la creación de recursos
Modelo Región en la que se ejecutan las predicciones
Modelo Habilita el registro de predicciones en línea
Versión Versión del entorno de ejecución que se usa
Versión Versión de Python que se usa
Versión Tipo de máquina que se usa para la predicción en línea

No puedes actualizar los parámetros de configuración enumerados anteriormente después de la creación inicial del modelo o la versión. Si es necesario cambiar estos parámetros de configuración, crea un modelo nuevo o recurso de la versión con la configuración nueva y vuelve a implementar tu modelo.

Tipos de máquina disponibles para la predicción en línea

La predicción en línea actualmente admite CPU de un núcleo con 2 GB de RAM. Si te interesa unirte a los programas Alfa para otro hardware, comunícate con el equipo de comentarios de Cloud ML Engine.

Consulta la información sobre los precios de estos tipos de máquinas.

Solicita registros para solicitudes de predicción en línea

El servicio de predicción de Cloud ML Engine no proporciona información registrada sobre las solicitudes de forma predeterminada debido a que los registros generan un costo. La predicción en línea a una frecuencia alta de consultas por segundo (QPS) puede producir una cantidad sustancial de registros, que están sujetos a la política de precios de Stackdriver.

A fin de aceptar el registro de predicciones en línea, puedes configurar tu modelo para generar registros cuando crees el recurso de modelo.

gcloud

Incluye el marcador --enable-logging cuando crees tu modelo con el comando gcloud ml-engine models create.

Python

Cuando crees tu modelo con projects.models.create, configura onlinePredictionLogging en True en el recurso de modelo.

Dale formato a tu entrada para la predicción en línea

Dale formato a tus instancias como strings JSON

El formato básico de la predicción en línea es una lista de tensores de datos de instancia. Pueden ser listas sin formato de valores o miembros de un objeto JSON, según cómo configuraste las entradas en la aplicación de entrenamiento.

En este ejemplo, se muestra un tensor de entrada y una clave de instancia:

{"values": [1, 2, 3, 4], "key": 1}

La composición de la string JSON puede ser compleja, siempre y cuando siga estas reglas:

  • El nivel superior de los datos de instancia debe ser un objeto JSON, un diccionario de pares de claves/valores.

  • Los valores individuales en un objeto de instancia pueden ser strings, números o listas. No puedes incorporar objetos JSON.

  • Las listas deben contener solo elementos del mismo tipo (incluidas otras listas). No puedes mezclar valores numéricos y strings.

Pasa las instancias de entrada para la predicción en línea como el cuerpo del mensaje de la llamada projects.predict.

gcloud

  1. Asegúrate de que tu archivo de entrada sea un archivo de texto con cada instancia en forma de objeto JSON, una instancia por línea.

    {"values": [1, 2, 3, 4], "key": 1}
    {"values": [5, 6, 7, 8], "key": 2}
    

API de REST

  1. Haz que cada instancia sea un artículo en una lista y nombra instances al miembro de la lista.

    {"instances": [{"values": [1, 2, 3, 4], "key": 1}]}
    

Datos binarios en la entrada de predicción

No es posible darles a los datos binarios el formato de strings codificadas en UTF-8 que admite JSON. Si tienes datos binarios en tus entradas, debes usar la codificación base64 para representarlos. Se requiere el siguiente formato especial:

  • Tu string codificada debe tener el formato de un objeto JSON con una clave única llamada b64. El ejemplo de Python 2.7 siguiente codifica un búfer de datos JPEG sin procesar usando la biblioteca base64 para crear una instancia:

    {"image_bytes": {"b64": base64.b64encode(jpeg_data)}}
    

    En Python 3.5, la codificación base64 genera una secuencia de bytes. Debes convertir esto en una string para que pueda serializarse con JSON.

    {'image_bytes': {'b64': base64.b64encode(jpeg_data).decode()}}
    
  • En tu código de modelo TensorFlow, debes asignar los alias de los tensores de entrada y salida binarios de modo que finalicen con “_bytes”.

Solicita predicciones

Envía tus instancias de datos de entrada como una string JSON en una solicitud de predicción para solicitar una predicción en línea. Si deseas dar formato al cuerpo de la solicitud y la respuesta, consulta los detalles de la solicitud de predicción.

Si no especificas una versión del modelo, se usa la versión predeterminada del modelo en tu solicitud de predicción.

gcloud

  1. Crea variables de entorno para conservar los parámetros, incluido un valor de la versión si decides especificar una versión de modelo en particular:

    MODEL_NAME="[YOUR-MODEL-NAME]"
    INPUT_DATA_FILE="instances.json"
    VERSION_NAME="[YOUR-VERSION-NAME]"
    
  2. Usa gcloud ml-engine predict para enviar instancias a un modelo implementado. Ten en cuenta que --version es opcional.

    gcloud ml-engine predict --model $MODEL_NAME  \
                       --version $VERSION_NAME \
                       --json-instances $INPUT_DATA_FILE
    
  3. La herramienta de gcloud analiza la respuesta y, luego, imprime las predicciones en tu terminal en un formato legible. Puedes especificar un formato de salida diferente, como JSON o CSV, si usas el marcador --format con tu comando de predicción. Ver formatos de salida disponibles.

Python

Puedes usar la biblioteca cliente de las API de Google para Python a fin de llamar a la API de Cloud Machine Learning Engine sin crear solicitudes HTTP de forma manual. Antes de ejecutar el siguiente ejemplo de código, debes configurar la autenticación.

def predict_json(project, model, instances, version=None):
    """Send json data to a deployed model for prediction.

    Args:
        project (str): project where the Cloud ML Engine Model is deployed.
        model (str): model name.
        instances ([Mapping[str: Any]]): Keys should be the names of Tensors
            your deployed model expects as inputs. Values should be datatypes
            convertible to Tensors, or (potentially nested) lists of datatypes
            convertible to tensors.
        version: str, version of the model to target.
    Returns:
        Mapping[str: any]: dictionary of prediction results defined by the
            model.
    """
    # Create the ML Engine 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']

Java

Puedes usar la biblioteca cliente de las API de Google para Java a fin de llamar a la API de Cloud Machine Learning Engine sin crear solicitudes HTTP de forma manual. Antes de ejecutar el siguiente ejemplo de código, debes configurar la autenticación.

/*
 * Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpContent;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpRequestFactory;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.UriTemplate;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.discovery.Discovery;
import com.google.api.services.discovery.model.JsonSchema;
import com.google.api.services.discovery.model.RestDescription;
import com.google.api.services.discovery.model.RestMethod;
import java.io.File;

/*
 * Sample code for doing Cloud Machine Learning Engine online prediction in Java.
 */

public class OnlinePredictionSample {
  public static void main(String[] args) throws Exception {
    HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
    JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
    Discovery discovery = new Discovery.Builder(httpTransport, jsonFactory, null).build();

    RestDescription api = discovery.apis().getRest("ml", "v1").execute();
    RestMethod method = api.getResources().get("projects").getMethods().get("predict");

    JsonSchema param = new JsonSchema();
    String projectId = "YOUR_PROJECT_ID";
    // You should have already deployed a model and a version.
    // For reference, see https://cloud.google.com/ml-engine/docs/deploying-models.
    String modelId = "YOUR_MODEL_ID";
    String versionId = "YOUR_VERSION_ID";
    param.set(
        "name", String.format("projects/%s/models/%s/versions/%s", projectId, modelId, versionId));

    GenericUrl url =
        new GenericUrl(UriTemplate.expand(api.getBaseUrl() + method.getPath(), param, true));
    System.out.println(url);

    String contentType = "application/json";
    File requestBodyFile = new File("input.txt");
    HttpContent content = new FileContent(contentType, requestBodyFile);
    System.out.println(content.getLength());

    GoogleCredential credential = GoogleCredential.getApplicationDefault();
    HttpRequestFactory requestFactory = httpTransport.createRequestFactory(credential);
    HttpRequest request = requestFactory.buildRequest(method.getHttpMethod(), url, content);

    String response = request.execute().parseAsString();
    System.out.println(response);
  }
}

Solución de problemas de la predicción en línea

Los errores comunes en la predicción en línea incluyen los siguientes:

  • Errores por falta de memoria
  • Formato incorrecto de los datos de entrada

Intenta disminuir el tamaño de tu modelo antes de implementarlo en Cloud ML Engine para la predicción.

Ve más detalles en Solución de problemas de la predicción en línea.

¿Qué sigue?

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

Enviar comentarios sobre…

Cloud ML Engine para TensorFlow