Obtener inferencias por lotes a partir de un modelo entrenado personalizado

En esta página se explica cómo obtener inferencias por lotes de tus modelos entrenados personalizados mediante la consola de Google Cloud o la API de Vertex AI.

Para hacer una solicitud de inferencia por lotes, debes especificar una fuente de entrada y una ubicación de salida, que puede ser Cloud Storage o BigQuery, donde Vertex AI almacena los resultados de la inferencia por lotes.

Limitaciones y requisitos

Ten en cuenta las siguientes limitaciones y requisitos al obtener inferencias por lotes:

• 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, la salida puede estar en us-central1 o US, pero no en europe-west4. Para obtener más información, consulta las ubicaciones de Cloud Storage y las ubicaciones de BigQuery.
• Las entradas y salidas también deben estar en la misma región o multirregión que el modelo.
• Los modelos de BigQuery ML no son modelos entrenados de forma personalizada. Sin embargo, la información de esta página se puede usar para obtener inferencias por lotes de un modelo de BigQuery ML en las siguientes condiciones:
  • El modelo de BigQuery ML debe registrarse en Vertex AI Model Registry.
  • Para usar una tabla de BigQuery como entrada, debes definir InstanceConfig.instanceType en "object" mediante la API Vertex AI.
• El tiempo de espera para cargar un modelo de inferencia por lotes es de unos 40 minutos. Si ves el siguiente mensaje de error, usa un modelo más pequeño para las inferencias por lotes: Error: model server never became ready. Please validate that your model file or container configuration are valid.

Requisitos de los datos de entrada

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Datos de partición

La inferencia por lotes usa MapReduce para fragmentar la entrada de cada réplica. Para usar las funciones de MapReduce, la entrada debe poder particionarse.

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

Vertex AI no particiona automáticamente los archivos CSV porque no son compatibles con las particiones de forma natural. Las filas de los archivos CSV no son autodescriptivas, no tienen tipo y pueden contener saltos de línea. No recomendamos usar entradas CSV en aplicaciones sensibles al rendimiento.

En el caso de las entradas TFRecord, asegúrate de particionar los datos manualmente dividiendo las instancias en archivos más pequeños y transfiriendo los archivos al trabajo con un comodín (por ejemplo, gs://my-bucket/*.tfrecord). El número de archivos debe ser al menos el número de réplicas especificado.

Filtrar y transformar datos de entrada

Puedes filtrar y transformar la entrada por lotes especificando instanceConfig en tu solicitud BatchPredictionJob.

La filtración te permite excluir determinados campos de los datos de entrada de tu solicitud de inferencia o incluir solo un subconjunto de campos de los datos de entrada en tu solicitud de inferencia, sin tener que realizar ningún preprocesamiento o postprocesamiento personalizado en el contenedor de inferencia. Esto resulta útil cuando el archivo de datos de entrada tiene columnas adicionales que el modelo no necesita, como claves o datos adicionales.

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

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

y especifica los siguientes instanceConfig:

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

A continuación, las instancias de tu solicitud de inferencia se envían como objetos JSON y se excluye la columna customerId:

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

Ten en cuenta que, si especificas lo siguiente, instanceConfig, obtendrás el mismo resultado:

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

Para ver una demostración de cómo usar los filtros de características, consulta el cuaderno Inferencia por lotes de modelos personalizados con filtros de características.

Solicitar una inferencia por lotes

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

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

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

{
  "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,
  }
}

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"

$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

{
  "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",
}

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_T4)
              .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());
    }
  }
}

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

Elegir el tipo de máquina y el número de réplicas

Escalar horizontalmente aumentando el número de réplicas mejora el rendimiento de forma más lineal y predecible que usando tipos de máquina más grandes.

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

Para que sea rentable, le recomendamos que elija un número de réplicas de forma que su trabajo de inferencia por lotes se ejecute durante al menos 10 minutos. Esto se debe a que se te cobra por cada hora de nodo de réplica, lo que incluye los aproximadamente 5 minutos que tarda cada réplica en iniciarse. No es rentable procesar datos solo durante unos segundos y, después, cerrar el servicio.

Como norma general, para miles de instancias, recomendamos un starting_replica_count de decenas. En el caso de millones de instancias, recomendamos un starting_replica_count de cientos. También puede usar la siguiente fórmula para estimar el número de réplicas:

N / (T * (60 / Tb))

Donde:

• N: número de lotes de la tarea. Por ejemplo, 1 millón de instancias/100 (tamaño del lote) = 10.000 lotes.
• T: el tiempo previsto para la tarea de inferencia por lotes. Por ejemplo, 10 minutos.
• Tb: 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 / 1 s)) se redondea a 17 réplicas.

A diferencia de la inferencia online, las tareas de inferencia por lotes no se escalan automáticamente. Como todos los datos de entrada se conocen de antemano, el sistema particiona los datos 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 directrices aproximadas. No necesariamente proporcionan un rendimiento óptimo para todos los modelos. No proporcionan estimaciones exactas del tiempo de procesamiento ni del coste. Además, no siempre reflejan la mejor relación coste-rendimiento en cada caso. Úsalos como punto de partida razonable y ajústalos según sea necesario. Para medir características como el rendimiento de tu modelo, ejecuta el cuaderno Finding ideal machine type (Encontrar el tipo de máquina ideal).

Para máquinas aceleradas por GPU o TPU

Sigue las directrices anteriores (que también se aplican a los modelos solo con CPU) y ten en cuenta lo siguiente:

• Es posible que necesites más CPUs y GPUs (por ejemplo, para el preprocesamiento de datos).
• Los tipos de máquina con GPU tardan más en iniciarse (10 minutos), por lo que te recomendamos que elijas tiempos más largos (por ejemplo, al menos 20 minutos en lugar de 10) para la tarea de inferencia por lotes, de forma que se dedique una proporción razonable del tiempo y el coste a generar inferencias.

Recuperar resultados de inferencia por lotes

Cuando se completa una tarea de inferencia por lotes, el resultado de la inferencia se almacena en el segmento de Cloud Storage o en la ubicación de BigQuery que hayas especificado en tu solicitud.

Resultado de inferencia por lotes de ejemplo

La carpeta de salida contiene un conjunto de archivos JSON Lines.

Los archivos se denominan {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. El número de archivos no es determinista debido a la naturaleza distribuida de la inferencia 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 devuelto por el contenedor.
• instance: en el caso de una lista de archivos, contiene el URI de Cloud Storage. En el caso de los demás formatos de entrada, contiene el valor que se ha enviado al contenedor 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]
]}

El contenedor devuelve lo siguiente:

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

El archivo de salida JSON Lines 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}
]}

El contenedor devuelve lo siguiente:

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

El archivo de salida JSON Lines 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 las características en una gran cantidad de datos. Esto se debe a que cada entrada puede generar miles de solicitudes en función del conjunto de valores de características posibles, lo que puede provocar un aumento masivo del tiempo y el coste de procesamiento. Por lo general, un conjunto de datos pequeño es suficiente para comprender la importancia de las funciones.

La inferencia por lotes no admite explicaciones basadas en ejemplos.

Notebooks

Siguientes pasos

• Consulta información sobre los recursos de computación para la inferencia.