Obtén predicciones por lotes a partir de un modelo entrenado personalizado

En esta página, se muestra cómo obtener predicciones por lotes a partir de tus modelos entrenados personalizados mediante la consola de Google Cloud o la API de Vertex AI.

Para realizar una solicitud de predicción por lotes, especifica una fuente de entrada y una ubicación de salida, ya sea Cloud Storage o BigQuery, en la que Vertex AI almacena los resultados de las predicciones.

Para minimizar el tiempo de procesamiento, las ubicaciones de entrada y salida deben estar en la misma región o multirregión. Por ejemplo, si la entrada está en us-central1, el resultado puede estar en us-central1 o US, pero no en europe-west4. Para obtener más información, consulta Ubicaciones de Cloud Storage y Ubicaciones de BigQuery.

Tu entrada y salida también deben estar en la misma región o multirregión que tu modelo.

Requisitos de los datos de entrada

La entrada para las solicitudes por lotes especifica los elementos que se enviarán a tu modelo para la predicción. Se admiten los siguientes formatos de entrada:

Líneas JSON

Usa un archivo de líneas JSON para especificar una lista de instancias de entrada a fin de hacer predicciones. Almacena el archivo de líneas JSON en un bucket de Cloud Storage.

Ejemplo 1

En el siguiente ejemplo, se muestra un archivo de líneas JSON en el que cada línea contiene un arreglo:

[1, 2, 3, 4]
[5, 6, 7, 8]

Esto es lo que se envía al contenedor de predicción en el cuerpo de la solicitud HTTP:

Todos los demás contenedores

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

Contenedores de PyTorch

{"instances": [
{ "data": [1, 2, 3, 4] },
{ "data": [5, 6, 7, 8] } ]}

Ejemplo 2

En el siguiente ejemplo, se muestra un archivo de líneas JSON en el que cada línea contiene un objeto.

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

Esto es lo que se envía al contenedor de predicción en el cuerpo de la solicitud HTTP. Ten en cuenta que el mismo cuerpo de solicitud se envía a todos los contenedores.

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

Ejemplo 3

Para los contenedores compilados previamente de PyTorch, asegúrate de unir cada instancia en un campo data según lo requiera el controlador predeterminado de TorchServe, Vertex AI no unirá tus instancias por ti. Por ejemplo:

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

Esto es lo que se envía al contenedor de predicción en el cuerpo de la solicitud HTTP:

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

TFRecord

Guarda las instancias de entrada en el formato TFRecord. De manera opcional, puedes comprimir los archivos TFRecord con Gzip. Almacena los archivos TFRecord en un bucket de Cloud Storage.

Vertex AI lee cada instancia en tus archivos TFRecord como objetos binarios y, luego, codifica en base64 la instancia como objeto JSON con una sola clave llamada b64.

Esto es lo que se envía al contenedor de predicción en el cuerpo de la solicitud HTTP:

Todos los demás contenedores

{"instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Contenedores de PyTorch

{"instances": [ { "data": {"b64": "b64EncodedASCIIString" } }, { "data": {"b64": "b64EncodedASCIIString" } }
]}

Asegúrate de que el contenedor de predicción sepa cómo decodificar la instancia.

CSV

Especifica una instancia de entrada por fila en un archivo CSV. La primera fila debe ser una fila de encabezado. Debes encerrar todas las strings entre comillas dobles ("). No aceptamos valores de celdas que incluyan caracteres de salto de línea. Los valores sin comillas se leen como números de punto flotante.

En el siguiente ejemplo, se muestra un archivo CSV con dos instancias de entrada:

"input1","input2","input3"
0.1,1.2,"cat1"
4.0,5.0,"cat2"

Esto es lo que se envía al contenedor de predicción en el cuerpo de la solicitud HTTP:

Todos los demás contenedores

{"instances": [ [0.1,1.2,"cat1"], [4.0,5.0,"cat2"] ]}

Contenedores de PyTorch

{"instances": [
{ "data": [0.1,1.2,"cat1"] },
{ "data": [4.0,5.0,"cat2"] } ]}

Lista de archivos

Crea un archivo de texto en el que cada fila sea el URI de Cloud Storage a un archivo. Vertex AI lee el contenido de cada archivo como objeto binario y, luego, codifica en base64 la instancia como un objeto JSON con una sola clave llamada b64.

Si planeas usar la consola de Google Cloud para obtener predicciones por lotes, pega la lista de archivos directamente en la consola de Google Cloud. De lo contrario, guarda tu lista de archivos en un bucket de Cloud Storage.

En el ejemplo siguiente, se muestra una lista de archivos con dos instancias de entrada:

gs://path/to/image/image1.jpg
gs://path/to/image/image2.jpg

Esto es lo que se envía al contenedor de predicción en el cuerpo de la solicitud HTTP:

Todos los demás contenedores

{ "instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Contenedores de PyTorch

{ "instances": [ { "data": { "b64": "b64EncodedASCIIString" } }, { "data": { "b64": "b64EncodedASCIIString" } }
]}

Asegúrate de que el contenedor de predicción sepa cómo decodificar la instancia.

BigQuery

Especifica una tabla de BigQuery como projectId.datasetId.tableId. Vertex AI transforma cada fila de la tabla en una instancia JSON.

Por ejemplo, si tu tabla contiene lo siguiente:

Columna 1 Columna 2 Columna 3
1.0 3.0 "Cat1"
2.0 4.0 "Cat2"

Esto es lo que se envía al contenedor de predicción en el cuerpo de la solicitud HTTP:

Todos los demás contenedores

{"instances": [ [1.0,3.0,"cat1"], [2.0,4.0,"cat2"] ]}

Contenedores de PyTorch

{"instances": [
{ "data": [1.0,3.0,"cat1"] },
{ "data": [2.0,4.0,"cat2"] } ]}

A continuación, se muestra cómo los tipos de datos de BigQuery se convierten en JSON:

Tipo de BigQuery Tipo de JSON Valor de ejemplo
String String "abc"
Integer Integer 1
Número de punto flotante Número de punto flotante 1.2
Numérica Número de punto flotante 4925.000000000
Booleano Booleano true
TimeStamp String "2019-01-01 23:59:59.999999+00:00"
Fecha String "2018-12-31"
Tiempo String "23:59:59.999999"
DateTime String "2019-01-01T00:00:00"
Registro Objeto { "A": 1,"B": 2}
Tipo repetido Array[Type] [1, 2]
Registro anidado Objeto {"A": {"a": 0}, "B": 1}

Datos de partición

La predicción por lotes usa MapReduce para fragmentar la entrada en cada réplica. Para usar las características de MapReduce, la entrada debe ser particionable.

Vertex AI particiona automáticamente la entrada de BigQuery, la lista de archivos y la entrada de líneas JSON.

Vertex AI no particiona los archivos CSV de forma automática porque no se admiten de forma natural las particiones. Las filas de los archivos CSV no son autodescriptivas, no están escritas y pueden contener líneas nuevas. Recomendamos no usar la entrada CSV para aplicaciones sensibles a la capacidad de procesamiento.

Para la entrada TFRecord, asegúrate de particionar de forma manual los datos. Para ello, divide las instancias en archivos más pequeños y pasa los archivos al trabajo con un comodín (por ejemplo, gs://my-bucket/*.tfrecord). La cantidad de archivos debe ser al menos la cantidad de réplicas especificada.

Filtra y transforma datos de entrada

Puedes filtrar o transformar la entrada por lotes si especificas instanceConfig en la solicitud BatchPredictionJob.

El filtrado te permite excluir ciertos campos que están en los datos de entrada de tu solicitud de predicción o incluir solo un subconjunto de campos de los datos de entrada en tu solicitud de predicción, sin tener que hacer ningún procesamiento previo o posterior personalizado en el contenedor de predicción. Esto es útil cuando tu archivo de datos de entrada tiene columnas adicionales que el modelo no necesita, como claves o datos adicionales.

La transformación te permite enviar las instancias a tu contenedor de predicción en formato array o object JSON. Consulta instanceType para obtener más información.

Por ejemplo, si tu tabla de entrada contiene lo siguiente:

customerId col1 col2
1001 1 2
1002 5 6

Además, especifica el siguiente instanceConfig:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "excludedFields":"customerId"
    "instanceType":"object"
  }
}

Luego, las instancias en tu solicitud de predicción se envían como objetos JSON y la columna customerId se excluye:

{"col1":1,"col2":2}
{"col1":5,"col2":6}

Ten en cuenta que si especificas instanceConfig, se producirá el mismo resultado:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "includedFields": ["col1","col2"]
    "instanceType":"object"
  }
}

Para obtener una demostración de cómo usar los filtros de atributos, consulta el notebook Predicción personalizada por lotes de modelos con filtrado de atributos.

Solicitar una predicción por lotes

Para las solicitudes de predicción por lotes, puedes usar la consola de Google Cloud o la API de Vertex AI. Según la cantidad de elementos de entrada que hayas enviado, una tarea de predicción por lotes puede tardar un tiempo en completarse.

Cuando solicitas una predicción por lotes, el contenedor de predicción se ejecuta como la cuenta de servicio personalizada que proporciona el usuario. Las operaciones de lectura o escritura, como la lectura de instancias de predicción desde la fuente de datos o la escritura de los resultados de la predicción, se realizan mediante el agente de servicio de Vertex AI, que, de forma predeterminada, tiene acceso a BigQuery y Cloud Storage.

Consola de Google Cloud

Usa la consola de Google Cloud para solicitar una predicción por lotes.

  1. En la consola de Google Cloud, en la sección Vertex AI, ve a la página Predicciones por lotes.

Ir a la página Batch predictions

  1. Haz clic en Crear para abrir la ventana Nueva predicción por lotes.

  2. Para Definir la predicción por lotes, sigue estos pasos:

    1. Ingresa un nombre para la predicción por lotes.

    2. En Nombre del modelo, selecciona el nombre del modelo que usarás para esta predicción por lotes.

    3. En Seleccionar fuente, selecciona la fuente que se aplicará a tus datos de entrada:

      • Si el formato que diste a tu entrada incluye líneas JSON, CSV o TFRecord, selecciona Archivo en Cloud Storage (líneas JSON, CSV, TFRecord, TFRecord y Gzip). Luego, especifica tu archivo de entrada en el campo Ruta de acceso de origen.
      • Si usas una lista de archivos como entrada, selecciona Archivos en Cloud Storage (otro) y pega tu lista de archivos en el siguiente cuadro de texto.
      • Para la entrada de BigQuery, selecciona ruta de BigQuery. Si seleccionas BigQuery como entrada, también debes seleccionar BigQuery como salida y clave de encriptación administrada por Google. La clave de encriptación administrada por el cliente (CMEK) no es compatible con BigQuery como entrada/salida.

    4. En el campo Ruta de destino, especifica el directorio de Cloud Storage en el que quieres que Vertex AI almacene el resultado de la predicción por lotes.

    5. De manera opcional, marca Habilitar atribuciones de atributos para este modelo a fin de obtener atribuciones de atributos como parte de la respuesta de predicción por lotes. Luego, haz clic en Editar para configurar la explicación. (La edición de la configuración de las explicaciones es opcional si configuraste previamente los ajustes de las explicaciones para el modelo, y lo necesitas).

    6. Especifica las opciones de procesamiento para el trabajo de predicción por lotes: Cantidad de nodos de procesamiento, Tipo de máquina y (opcionalmente) Tipo de acelerador y Recuento de aceleradores

  3. Opcional: El análisis de Supervisión de modelos para predicciones por lotes está disponible en vista previa. Consulta los Requisitos previos para agregar configuración de detección de sesgo a tu trabajo de predicción por lotes.

    1. Haz clic para activar o desactivar Habilitar la supervisión del modelo para esta predicción por lotes.

    2. Selecciona una fuente de datos de entrenamiento. Ingresa la ruta de acceso o la ubicación de los datos para la fuente de datos de entrenamiento que seleccionaste.

    3. Opcional: En Límites de alerta, especifica los límites para activar las alertas.

    4. En Notificaciones por correo electrónico, ingresa una o más direcciones de correo electrónico separadas por comas para recibir alertas cuando un modelo supere un umbral de alertas.

    5. En los Canales de notificaciones, agrega canales de Cloud Monitoring para recibir alertas cuando un modelo exceda un umbral de alertas (opcional). Puedes seleccionar canales existentes de Cloud Monitoring o crear uno nuevo haciendo clic en Administrar canales de notificaciones. La consola es compatible con los canales de notificaciones de PagerDuty, Slack y Pub/Sub.

  4. Haz clic en Crear.

API

Usa la API de Vertex AI para enviar solicitudes de predicción por lotes. Selecciona una pestaña según la herramienta que uses para obtener predicciones por lotes:

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION_ID: Región en la que se almacena el modelo y se ejecuta el trabajo de predicción por lotes Por ejemplo, us-central1

  • PROJECT_ID: El ID del proyecto.

  • BATCH_JOB_NAME: el nombre visible del trabajo de predicción por lotes.

  • MODEL_ID: el ID del modelo que se usará para hacer predicciones.

  • INPUT_FORMAT: el formato de tus datos de entrada: jsonl, csv, tf-record, tf-record-gzip o file-list.

  • INPUT_URI: el URI de Cloud Storage de tus datos de entrada. Puede contener comodines.

  • OUTPUT_DIRECTORY: URI de Cloud Storage de un directorio en el que quieres que Vertex AI guarde los resultados.

  • MACHINE_TYPE: los recursos de máquina que se usarán para este trabajo de predicción por lotes.

    De manera opcional, puedes configurar el campo machineSpec para usar aceleradores, pero el siguiente ejemplo no lo demuestra.

  • BATCH_SIZE: La cantidad de instancias que se enviarán en cada solicitud de predicción, el valor predeterminado es 64. El aumento del tamaño del lote puede provocar una mayor capacidad de procesamiento, pero también puede provocar tiempos de espera de solicitudes.

  • STARTING_REPLICA_COUNT: la cantidad de nodos para este trabajo de predicción por lotes.

Método HTTP y URL: 

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Cuerpo JSON de la solicitud:

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "INPUT_FORMAT",
    "gcsSource": {
      "uris": ["INPUT_URI"],
    },
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY",
    },
  },
  "dedicatedResources" : {
    "machineSpec" : {
      "machineType": MACHINE_TYPE
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT
  },
  "manualBatchTuningParameters": {
    "batch_size": BATCH_SIZE,
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "INPUT_URI"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

En el siguiente ejemplo, reemplaza PREDICTIONS_FORMAT por jsonl. Para obtener información sobre cómo reemplazar los otros marcadores de posición, consulta la pestaña REST & CMD LINE de esta sección.

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.BatchDedicatedResources;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.protobuf.Value;
import java.io.IOException;

public class CreateBatchPredictionJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelName = "MODEL_NAME";
    String instancesFormat = "INSTANCES_FORMAT";
    String gcsSourceUri = "GCS_SOURCE_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String gcsDestinationOutputUriPrefix = "GCS_DESTINATION_OUTPUT_URI_PREFIX";
    createBatchPredictionJobSample(
        project,
        displayName,
        modelName,
        instancesFormat,
        gcsSourceUri,
        predictionsFormat,
        gcsDestinationOutputUriPrefix);
  }

  static void createBatchPredictionJobSample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String gcsSourceUri,
      String predictionsFormat,
      String gcsDestinationOutputUriPrefix)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {

      // Passing in an empty Value object for model parameters
      Value modelParameters = ValueConverter.EMPTY_VALUE;

      GcsSource gcsSource = GcsSource.newBuilder().addUris(gcsSourceUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setGcsSource(gcsSource)
              .build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setGcsDestination(gcsDestination)
              .build();
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-2")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_K80)
              .setAcceleratorCount(1)
              .build();
      BatchDedicatedResources dedicatedResources =
          BatchDedicatedResources.newBuilder()
              .setMachineSpec(machineSpec)
              .setStartingReplicaCount(1)
              .setMaxReplicaCount(1)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .setDedicatedResources(dedicatedResources)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

Python

Si deseas obtener información para instalar o actualizar el SDK de Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de Python. 

def create_batch_prediction_job_dedicated_resources_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    instances_format: str = "jsonl",
    machine_type: str = "n1-standard-2",
    accelerator_count: int = 1,
    accelerator_type: Union[str, aiplatform_v1.AcceleratorType] = "NVIDIA_TESLA_K80",
    starting_replica_count: int = 1,
    max_replica_count: int = 1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        instances_format=instances_format,
        machine_type=machine_type,
        accelerator_count=accelerator_count,
        accelerator_type=accelerator_type,
        starting_replica_count=starting_replica_count,
        max_replica_count=max_replica_count,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

Importancia de los atributos

Si deseas que los valores de importancia de los atributos se muestren para tus predicciones, establece la propiedad generateExplanation en true. Ten en cuenta que los modelos de previsión no admiten la importancia de las funciones, por lo que no puedes incluirla en tus solicitudes de predicción por lotes.

La importancia de las funciones, a veces llamadas atribuciones de funciones, es parte de Vertex Explainable AI.

Solo puedes establecer generateExplanation como true si tienesconfigurado tu Model para obtener explicaciones o si especificas el campo explanationSpec del BatchPredictionJob.

Elige el tipo de máquina y el recuento de réplicas

El escalamiento horizontal mediante el aumento de la cantidad de réplicas mejora la capacidad de procesamiento de forma más lineal y predecible que mediante el uso de tipos de máquinas más grandes.

En general, te recomendamos que especifiques el tipo de máquina más pequeño posible para tu trabajo y aumentes la cantidad de réplicas.

Para obtener una rentabilidad, te recomendamos que elijas el recuento de réplicas de modo que tu trabajo de predicción por lotes se ejecute durante al menos 10 minutos. Esto se debe a que se te factura por hora de procesamiento de réplica de los nodos, lo que incluye aproximadamente 5 minutos que tarda cada inicio en una réplica. No es rentable procesarlos solo durante unos segundos y, luego, apagarlos.

Como guía general, para miles de instancias, recomendamos un starting_replica_count de decenas. Para millones de instancias, recomendamos una starting_replica_count en los cientos. También puedes utilizar la siguiente fórmula para estimar la cantidad de réplicas:

N / (T * (60 / Tb))

Aquí:

  • N: Es la cantidad de lotes en el trabajo. Por ejemplo, 1 millón de instancias / tamaño de 100 lotes = 10,000 lotes.
  • T: Es el tiempo deseado para el trabajo de predicción por lotes. Por ejemplo, 10 minutos.
  • Tb: Es el tiempo en segundos que tarda una réplica en procesar un solo lote. Por ejemplo, 1 segundo por lote en un tipo de máquina de 2 núcleos.

En nuestro ejemplo, 10,000 lotes / (10 minutos * (60 / 1s)) se redondea a 17 réplicas.

A diferencia de la predicción en línea, los trabajos de predicción por lotes no realizan un ajuste de escala automático. Como todos los datos de entrada se conocen de antemano, el sistema los particiona en cada réplica cuando se inicia el trabajo. El sistema usa el parámetro starting_replica_count; se ignora el parámetro max_replica_count.

Todas estas recomendaciones son lineamientos aproximados. No se garantiza que se proporcione una capacidad de procesamiento óptima para cada modelo. No proporcionan predicciones exactas sobre el tiempo de procesamiento ni el costo. Tampoco necesariamente capturan las mejores compensaciones de costo y capacidad de procesamiento para cada situación. Úsalas como punto de partida razonable y ajústalas según sea necesario. Para medir las características, como la capacidad de procesamiento del modelo, ejecuta el notebook Encuentra el tipo de máquina ideal.

Para máquinas aceleradas por GPU o TPU

Sigue los lineamientos para modelos solo de CPU con las siguientes consideraciones adicionales:

  • Es posible que necesites más CPU y GPU (p. ej., para el procesamiento previo de los datos).
  • Los tipos de máquinas de GPU tardan más en iniciarse (10 minutos), por lo que es posible que desees orientar tiempos más largos (por ejemplo, al menos 20 minutos en lugar de 10 minutos) para el trabajo de predicción por lotes a fin de que una proporción razonable del tiempo y del costo se dediquen a generar predicciones.

Recupera los resultados de las predicciones por lotes

Cuando se completa una tarea de predicción por lotes, el resultado de la predicción se almacena en el bucket de Cloud Storage o la ubicación de BigQuery que especificaste en la solicitud.

Resultado de la predicción por lotes de ejemplo

La carpeta de salida contiene un conjunto de archivos de líneas de JSON.

Los archivos se denominan {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. La cantidad de archivos no deterministas debido a la naturaleza distribuida de la predicción por lotes.

Cada línea del archivo corresponde a una instancia de la entrada y tiene los siguientes pares clave-valor:

  • prediction: contiene el valor que muestra el contenedor de predicción.
  • instance: para FileList, contiene el URI de Cloud Storage. En todos los demás formatos de entrada, contiene el valor que se envió al contenedor de predicción en el cuerpo de la solicitud HTTP.

Ejemplo 1

Si la solicitud HTTP contiene lo siguiente:

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

Y el contenedor de predicción muestra lo siguiente:

{
  "predictions": [
    [0.1,0.9],
    [0.7,0.3]
  ],
}

El archivo de salida jsonl es el siguiente:

{ "instance": [1, 2, 3, 4], "prediction": [0.1,0.9]}
{ "instance": [5, 6, 7, 8], "prediction": [0.7,0.3]}

Ejemplo 2

Si la solicitud HTTP contiene lo siguiente:

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

Y el contenedor de predicción muestra lo siguiente:

{
  "predictions": [
    {"result":1},
    {"result":0}
  ],
}

El archivo de salida jsonl es el siguiente:

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

Usar Explainable AI

No recomendamos ejecutar explicaciones basadas en atributos en una gran cantidad de datos. Esto se debe a que cada entrada puede distribuirse a miles de solicitudes según el conjunto de valores de atributos posibles, lo que puede aumentar el tiempo de procesamiento y el costo de forma masiva. En general, un conjunto de datos pequeño es suficiente para comprender la importancia de los atributos.

La predicción por lotes no admite explicaciones basadas en ejemplos.

¿Qué sigue?