Obtén predicciones por lotes

Solicitar una predicción por lotes es una solicitud asíncrona (en lugar de una predicción en línea, que es una solicitud síncrona). Puedes solicitar predicciones por lotes directamente desde el recurso del modelo, no es necesario que implementes el modelo en un extremo. Para los tipos de datos que admiten predicciones por lotes y en línea, usa predicciones por lotes cuando no necesites una respuesta inmediata y quieras procesar datos acumulados mediante una sola solicitud.

Para realizar una predicción por lotes, especifica una fuente de entrada y una ubicación de salida en la que Vertex AI almacena los resultados de las predicciones. Las entradas y salidas dependen del tipo de modelo con el que trabajas. Por ejemplo, las predicciones por lotes para el tipo de modelo de imagen de AutoML requieren un archivo de líneas JSON de entrada y el nombre de un bucket de Cloud Storage para almacenar el resultado.

Entrada de solicitudes por lotes

La entrada para las solicitudes por lotes especifica los elementos que se enviarán a tu modelo para la predicción. En el siguiente contenido, se proporcionan los requisitos de formato de entrada para cada tipo de modelo.

Entrenamiento personalizado

Para obtener predicciones por lotes de un modelo de entrenamiento personalizado, prepara tus datos de entrada de una de las siguientes maneras:

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 muestran dos instancias en un archivo de líneas JSON de entrada:

[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:

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

Ejemplo 2

En el siguiente ejemplo, se muestran dos instancias en un archivo de línea JSON de entrada en el que el contenedor de predicción espera 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:

{"instances": [
  {"values": [1, 2, 3, 4], "key": 1},
  {"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 de tus archivos TFRecord como binaria y, luego, codifica en Base64 la instancia como un 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:

{"instances": [
 {"b64","b64EncodedASCIIString"},
 {"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. Debe encerrar todas las strings entre comillas dobles ("). No aceptamos valores de celdas con 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:

{"instances": [
 [0.1,1.2,"cat1"],
 [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, base64 codifica 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:

{"instances": [
 {"b64","b64EncodedASCIIString"},
 {"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:

{"instances": [
 [1.0,3.0,"cat1"],
 [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}

Imagen

Usa un archivo de líneas JSON a fin de especificar una lista de imágenes para hacer predicciones y, luego, almacénalo en un bucket de Cloud Storage. En el siguiente ejemplo, se muestra una sola línea en un archivo de líneas JSON de entrada.

{"content": "gs://sourcebucket/datasets/images/source_image.jpg", "mimeType": "image/jpeg"}

Tabular

Para los datos tabulares, puedes usar un archivo CSV en un bucket de Cloud Storage o una tabla en BigQuery. Puedes proporcionar datos de predicción como un CSV en Cloud Storage o como una tabla en BigQuery. Te recomendamos usar el mismo formato de entrada para tus datos de entrenamiento y predicción. Debido a que Vertex AI trata todos los campos de entrada CSV como strings, un formato de entrada diferente en el entrenamiento y la predicción puede generar un error. Por ejemplo, si entrenaste tu modelo con datos en BigQuery, es mejor usar una tabla de BigQuery como fuente para tus predicciones por lotes.

La fuente de datos debe contener datos tabulares que incluyan todas las columnas, en cualquier orden, que se usaron para entrenar el modelo. Puedes incluir columnas que no estaban en los datos de entrenamiento o que estaban en los datos de entrenamiento, pero que no se usaron para el entrenamiento. Estas columnas adicionales se incluyen en el resultado de la predicción, pero no se usan para generar la predicción.

No es necesario que uses el mismo destino que los datos de predicción para tus resultados. Por ejemplo, si usaste BigQuery para la fuente de datos de predicción, puedes enviar los resultados a un archivo CSV en Cloud Storage.

Requisitos de la tabla de BigQuery

  • Las tablas de fuentes de datos de BigQuery no deben superar los 100 GB.
  • Debes usar un conjunto de datos de BigQuery multirregional en las ubicaciones US o EU.
  • Si la tabla está en un proyecto diferente, debes proporcionar la función BigQuery Data Editor a la cuenta de servicio de Vertex AI en ese proyecto.

Requisitos del archivo CSV

  • La fuente de datos debe comenzar con una fila de encabezado con los nombres de las columnas.
  • Cada archivo de fuente de datos no debe superar los 10 GB. Puedes incluir varios archivos, hasta un máximo de 100 GB.
  • Si el bucket de Cloud Storage está en un proyecto, pero usas Vertex AI en un proyecto diferente, debes proporcionar la función Storage Object Creator a la cuenta de servicio de Vertex AI en ese proyecto.
  • Debes encerrar todas las strings entre comillas dobles (”).

Requisitos de previsión

Además de los requisitos de la tabla de BigQuery o los archivos CSV, la entrada para modelos de previsión también debe cumplir con los siguientes requisitos:

  • Todos los valores de la columna de tiempo deben estar presentes y ser válidos.
  • La frecuencia de los datos de la tabla de predicción por lotes debe ser la misma que la de los datos de entrenamiento. No puedes tener filas faltantes en la serie temporal. Inserta manualmente las filas que faltan según el conocimiento de dominios adecuados.
  • Las series temporales con marcas de tiempo duplicadas se quitan de las predicciones. Para incluirlas, quita las marcas de tiempo duplicadas.
  • Proporciona datos históricos de cada serie temporal que se predecirá. Para obtener las predicciones más precisas, la cantidad de datos debe ser igual a la ventana de contexto que se estableció en el entrenamiento. Si proporcionas menos datos, Vertex AI rellena los datos con valores vacíos. Por ejemplo, si la ventana de contexto es de 14 días, proporciona al menos 14 días de datos históricos.
  • La previsión comienza en la primera fila de una serie temporal (ordenada por tiempo) con un valor nulo en la columna de destino. El valor nulo debe ser continuo dentro de la serie temporal. Por ejemplo, si la columna de destino está ordenada por tiempo, no puedes tener valores como “1”, “2”, “nulo”, “3”, “4”, “nulo”, “nulo” para una sola serie temporal. En el caso de los archivos CSV, Vertex AI considera una string vacía como nula y, para BigQuery, los valores nulos son compatibles de forma nativa.

Texto

Análisis de opiniones y clasificación

Usa un archivo de líneas JSON a fin de especificar una lista de documentos para hacer predicciones y, luego, almacénalo en un bucket de Cloud Storage. En el siguiente ejemplo, se muestra una sola línea en un archivo de líneas JSON de entrada.

{"content": "gs://sourcebucket/datasets/texts/source_text.txt", "mimeType": "text/plain"}

Extracción de entidades

Para la extracción de entidades, puedes incluir texto intercalado o referencias a documentos que estén en un bucket de Cloud Storage. Para cada documento, también puedes agregar un campo key a la entrada.

Por lo general, los resultados de la predicción por lotes asignan las entradas y salidas con el campo instance, que incluye los campos content y mimeType. Si usas el campo key en tu entrada, el resultado de la predicción por lotes reemplaza al campo instance con el campo key. Esto ayuda a simplificar la salida de la predicción por lotes si, por ejemplo, tu entrada incluye fragmentos de texto grandes.

En el siguiente ejemplo, se muestra un archivo de líneas JSONL que incluye referencias a documentos y fragmentos de texto intercalados con el campo key y sin él.

{"content": "gs://sourcebucket/datasets/texts/source_text.txt", "mimeType": "text/plain"}
{"content": "gs://bucket/sample.txt", "mimeType": "text/plain", "key": "sample-file"}
{"content": "Text snippet", "mimeType": "text/plain"}
{"content": "Sample text snippet", "mimeType": "text/plain", "key": "sample-snippet"}

Video

Usa un archivo de líneas JSON para especificar una lista de videos a fin de hacer predicciones y, luego, almacénalo en un bucket de Cloud Storage. Puedes especificar Infinity para el campo timeSegmentEnd a fin de precisar el final del video. En el siguiente ejemplo, se muestra una sola línea en un archivo de líneas JSON de entrada.

{'content': 'gs://sourcebucket/datasets/videos/source_video.mp4', 'mimeType': 'video/mp4', 'timeSegmentStart': '0.0s', 'timeSegmentEnd': '2.366667s'}

Solicitar una predicción por lotes

Para las solicitudes de predicción por lotes, puedes usar Google Cloud Console 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.

Google Cloud Console

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

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

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

    Entrenamiento personalizado

    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 Versión, selecciona la versión del modelo que se usará para esta predicción por lotes.
    4. En Seleccionar fuente, haz lo siguiente:
      • Si tu formato de tu entrada son 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.
    5. 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.
    6. 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).
    7. 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

    Imagen, texto o video

    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 Ruta de acceso de origen, especifica la ubicación de Cloud Storage en la que se encuentra el archivo de entrada de líneas JSONL.
    4. Para la Ruta de acceso destino, especifica una ubicación de Cloud Storage en la que se almacenen los resultados de la predicción por lotes. El objetivo de tu modelo determina el formato de Resultado está determinado por. Por ejemplo, los modelos de AutoML para objetivos de texto generan archivos de líneas JSON.

    Tabular

    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 si tus datos de entrada de origen son un archivo CSV en Cloud Storage o una tabla en BigQuery.
      • Para los archivos CSV, especifica la ubicación de Cloud Storage en la que se encuentra el archivo de entrada CSV.
      • Para las tablas de BigQuery, especifica el ID del proyecto en el que se encuentra la tabla, el ID del conjunto de datos de BigQuery y el ID de vista o la tabla de BigQuery.
    4. En el Resultado, selecciona CSV o BigQuery.
      • Para CSV, especifica el bucket de Cloud Storage en el que Vertex AI almacenará tu resultado.
      • Para BigQuery, puedes especificar un ID del proyecto o un conjunto de datos existente:
        • Para especificar el ID del proyecto, ingresa el ID en el campo ID del proyecto de Google Cloud. Vertex AI crea un nuevo conjunto de datos de salida.
        • Para especificar un conjunto de datos existente, ingresa su ruta de BigQuery en el campo ID del proyecto de Google Cloud, como bq://projectid.datasetid.
      • Si especificaste BigQuery como tu destino de salida y deseas que se muestren los valores de importancia de las funciones para las predicciones, marca la casilla de verificación Generar importancia de las funciones.

        La importancia de los atributos no es compatible cuando se muestran los datos de predicción en Cloud Storage o para modelos de previsión.

  4. Opcional: El análisis de Supervisión de modelos está disponible para los modelos tabulares entrenados y personalizados de AutoML. Consulta los Requisitos 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.

    3. Ingresa la ruta de datos de entrenamiento para la fuente de datos de entrenamiento que seleccionaste.

  5. Haga clic en Crear.

API

Usa la API de Vertex AI para enviar solicitudes de predicción por lotes.

Entrenamiento personalizado

Selecciona una pestaña según la herramienta que uses para obtener predicciones por lotes:

LÍNEA DE REST Y CMD

Para obtener una referencia de la API de REST, consulta BatchPredictionJob.

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

  • LOCATION: 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 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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/batchPredictionJobs

Cuerpo JSON de la solicitud:

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT/locations/LOCATION/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 application-default print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/batchPredictionJobs"

PowerShell

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

$cred = gcloud auth application-default 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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/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/us-central1/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT/locations/us-central1/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

Si deseas obtener información para instalar y usar la biblioteca cliente de Vertex AI, consulta las bibliotecas cliente de Vertex AI. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

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 y usar la biblioteca cliente de Vertex AI, consulta las bibliotecas cliente de Vertex AI. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI 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,
    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,
        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 establecergenerateExplanation atrue si tienesconfigurado tuModel para obtener explicaciones o si especificas elBatchPredictionJob deexplanationSpec Campo.

Imagen

El siguiente ejemplo de predicción por lotes funciona para los objetivos de clasificación y detección de objetos.

LÍNEA DE REST Y CMD

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

  • LOCATION: Región en la que se almacena el modelo y se ejecuta el trabajo de predicción por lotes. Por ejemplo: us-central1.
  • PROJECT: el ID de tu proyecto
  • BATCH_JOB_NAME: el nombre visible del trabajo por lotes
  • MODEL_ID: El ID del modelo que se usará para hacer predicciones
  • THRESHOLD_VALUE (opcional): Vertex AI solo muestra predicciones que tienen puntuaciones de confianza con al menos este valor. El puerto predeterminado es 0.0.
  • MAX_PREDICTIONS (opcional): Vertex AI muestra estas numerosas predicciones que a partir de las predicciones que tienen las puntuaciones de confianza más altas. El predeterminado es 10.
  • URI: el URI de Cloud Storage en el que se encuentra el archivo de líneas JSON de entrada.
  • BUCKET: tu bucket de Cloud Storage
  • PROJECT_NUMBER: es el número de tu proyecto.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/batchPredictionJobs

Cuerpo JSON de la solicitud:

{
    "displayName": "BATCH_JOB_NAME",
    "model": "projects/PROJECT/locations/LOCATION/models/MODEL_ID",
    "modelParameters": {
      "confidenceThreshold": THRESHOLD_VALUE,
      "maxPredictions": MAX_PREDICTIONS
    },
    "inputConfig": {
        "instancesFormat": "jsonl",
        "gcsSource": {
            "uris": ["URI"],
        },
    },
    "outputConfig": {
        "predictionsFormat": "jsonl",
        "gcsDestination": {
            "outputUriPrefix": "OUTPUT_BUCKET",
        },
    },
}

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 application-default print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/batchPredictionJobs"

PowerShell

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

$cred = gcloud auth application-default 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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/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/us-central1/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT/locations/us-central1/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "CONTENT"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "BUCKET"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
  "modelDisplayName": "MODEL_NAME",
  "modelObjective": "MODEL_OBJECTIVE"
}

Puedes consultar el estado del trabajo por lotes mediante BATCH_JOB_ID hasta que el state sea JOB_STATE_SUCCEEDED.

Python

Si deseas obtener información para instalar y usar la biblioteca cliente de Vertex AI, consulta las bibliotecas cliente de Vertex AI. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Python.