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

Limitaciones y requisitos

Ten en cuenta las siguientes limitaciones y requisitos cuando obtengas predicciones 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, 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.
• No se admiten los modelos de Model Garden.
• Los modelos de BigQuery ML no son modelos entrenados personalizados. Sin embargo, la información de esta página se puede usar para obtener predicciones por lotes de un modelo de BigQuery ML en las siguientes condiciones:
  • El modelo de BigQuery ML debe estar registrado en Vertex AI Model Registry.
  • Para usar una tabla de BigQuery como entrada, debes configurar InstanceConfig.instanceType en "object" con la API de Vertex AI.

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:

[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 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. No recomendamos 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:

Además, especifica el siguiente instanceConfig:

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

A continuación, las instancias en tu solicitud de predicción 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 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 y 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.

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

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 un starting_replica_count de cientos. También puedes usar 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 esperado 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 necesariamente proporcionan 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 anteriores (que también se aplican a los modelos solo de CPU) con las siguientes consideraciones adicionales:

• Es posible que necesites más CPU y GPU (por ejemplo, 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 es determinista, 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 una lista de archivos, 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 de líneas JSON 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 de líneas JSON 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.

Notebooks

¿Qué sigue?

• Obtén información sobre los recursos de Compute para la predicción.