Ottenere inferenze batch da un modello con addestramento personalizzato

Questa pagina mostra come ottenere inferenze batch dai tuoi modelli addestrati personalizzati utilizzando la console Google Cloud o l'API Agent Platform.

Per effettuare una richiesta di inferenza batch, specifica un'origine di input e una posizione di output, Cloud Storage o BigQuery, in cui Gemini Enterprise Agent Platform archivia i risultati dell'inferenza batch.

Limitazioni e requisiti

Tieni presenti le seguenti limitazioni e i seguenti requisiti quando ottieni inferenze in batch:

  • Per ridurre al minimo i tempi di elaborazione, le località di input e output devono trovarsi nella stessa regione o multiregione. Ad esempio, se l'input è in us-central1, l'output può essere in us-central1 o US, ma non in europe-west4. Per saperne di più, consulta Località di Cloud Storage e Località di BigQuery.
  • Anche l'input e l'output devono trovarsi nella stessa regione o multiregione del modello.
  • A differenza dell'inferenza online, i job di inferenza batch non eseguono la scalabilità automatica. Poiché tutti i dati di input sono noti in anticipo, il sistema li suddivide in partizioni per ogni replica all'avvio del job. Il sistema utilizza il parametro starting_replica_count. Il parametro max_replica_count viene ignorato.
  • I modelli BigQuery ML non sono modelli addestrati personalizzati. Tuttavia, le informazioni in questa pagina possono essere utilizzate per ottenere inferenze batch da un modello BigQuery ML alle seguenti condizioni:
    • Il modello BigQuery ML deve essere registrato in Gemini Enterprise Agent Platform Model Registry.
    • Per utilizzare una tabella BigQuery come input, devi impostare InstanceConfig.instanceType su "object" utilizzando l'API Agent Platform.
  • Il caricamento di un modello di inferenza batch va in timeout dopo circa 40 minuti. Se visualizzi il seguente messaggio di errore, utilizza un modello più piccolo per le inferenze batch: Error: model server never became ready. Please validate that your model file or container configuration are valid.
  • I service account personalizzati sono supportati solo per il server di modelli, non per il client di inferenza batch che esegue operazioni di lettura e scrittura dei dati da e verso Cloud Storage e BigQuery.

Requisiti dei dati di input

L'input per le richieste batch specifica gli elementi da inviare al modello per l'inferenza. Sono supportati i seguenti formati di input:

JSON Lines

Utilizza un file JSON Lines per specificare un elenco di istanze di input su cui fare inferenze. Archivia il file in un bucket Cloud Storage.

Esempio 1

L'esempio seguente mostra un file JSON Lines in cui ogni riga contiene un array:

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

Ecco cosa viene inviato al container nel corpo della richiesta HTTP:

Tutti gli altri container

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

Container PyTorch

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

Esempio 2

L'esempio seguente mostra un file JSON Lines in cui ogni riga contiene un oggetto.

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

Ecco cosa viene inviato al container nel corpo della richiesta HTTP. Tieni presente che lo stesso corpo della richiesta viene inviato a tutti i container.

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

Esempio 3

Per i container predefiniti di PyTorch, assicurati di inserire ogni istanza in un campo data, come richiesto dal gestore predefinito di TorchServe; Gemini Enterprise Agent Platform non inserisce le istanze per te. Ad esempio:

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

Ecco cosa viene inviato al container di inferenza nel corpo della richiesta HTTP:

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

TFRecord

Salva le istanze di input nel formato TFRecord. Se vuoi, puoi comprimere i file TFRecord con Gzip. Archivia i file TFRecord in un bucket Cloud Storage.

Agent Platform legge ogni istanza nei file TFRecord come binaria e poi la codifica in base64 come oggetto JSON con una singola chiave denominata b64.

Ecco cosa viene inviato al container nel corpo della richiesta HTTP:

Tutti gli altri container

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

Container PyTorch

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

Assicurati che il container sappia come decodificare l'istanza.

CSV

Specifica un'istanza di input per riga in un file CSV. La prima riga deve essere una riga di intestazione. Devi racchiudere tutte le stringhe tra virgolette doppie ("). La piattaforma degli agenti non accetta valori di celle che contengono nuove righe. I valori non racchiusi tra virgolette vengono letti come numeri in virgola mobile.

L'esempio seguente mostra un file CSV con due istanze di input:

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

Ecco cosa viene inviato al container nel corpo della richiesta HTTP:

Tutti gli altri container

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

Container PyTorch

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

Elenco dei file

Crea un file di testo in cui ogni riga è l'URI Cloud Storage di un file. Agent Platform legge i contenuti di ogni file come binario e poi codifica in base64 l'istanza come oggetto JSON con una singola chiave denominata b64.

Se prevedi di utilizzare la console Google Cloud per ottenere inferenze batch, incolla l'elenco di file direttamente nella console Google Cloud . In caso contrario, salva l'elenco in un bucket Cloud Storage.

L'esempio seguente mostra un elenco di file con due istanze di input:

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

Ecco cosa viene inviato al container nel corpo della richiesta HTTP:

Tutti gli altri container

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

Container PyTorch

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

Assicurati che il container sappia come decodificare l'istanza.

BigQuery

Specifica una tabella BigQuery come projectId.datasetId.tableId. Agent Platform trasforma ogni riga della tabella in un'istanza JSON.

Ad esempio, se la tabella contiene quanto segue:

Colonna 1 Colonna 2 Colonna 3
1.0 3,0 "Cat1"
2.0 4.0 "Cat2"

Ecco cosa viene inviato al container nel corpo della richiesta HTTP:

Tutti gli altri container

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

Container PyTorch

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

Ecco come i tipi di dati BigQuery vengono convertiti in JSON:

Tipo BigQuery Tipo JSON Valore di esempio
Stringa Stringa "abc"
Numero intero Numero intero 1
Numero in virgola mobile Numero in virgola mobile 1.2
Numerico Numero in virgola mobile 4925.000000000
Booleano Booleano true
TimeStamp Stringa "2019-01-01 23:59:59.999999+00:00"
Data Stringa "2018-12-31"
Ora Stringa "23:59:59.999999"
DateTime Stringa "2019-01-01T00:00:00"
Registra Oggetto { "A": 1,"B": 2}
Tipo ripetuto Array[Type] [1, 2]
Record nidificato Oggetto {"A": {"a": 0}, "B": 1}

Partiziona i dati

L'inferenza batch utilizza MapReduce per suddividere l'input in shard per ogni replica. Per utilizzare le funzionalità di MapReduce, l'input deve essere partizionabile.

Gemini Enterprise Agent Platform partiziona automaticamente gli input di BigQuery, elenco di file e righe JSON.

Gemini Enterprise Agent Platform non partiziona automaticamente i file CSV perché non sono naturalmente adatti al partizionamento. Le righe nei file CSV non sono autodescrittive, sono tipizzate e possono contenere ritorni a capo. Sconsigliamo di utilizzare l'input CSV per le applicazioni sensibili alla velocità effettiva.

Per l'input TFRecord, assicurati di partizionare manualmente i dati suddividendo le istanze in file più piccoli e passando i file al job con un carattere jolly (ad esempio, gs://my-bucket/*.tfrecord). Il numero di file deve essere almeno pari al numero di repliche specificate.

Filtra e trasforma i dati di input

Puoi filtrare e trasformare l'input batch specificando instanceConfig nella richiesta BatchPredictionJob.

Il filtro ti consente di escludere determinati campi presenti nei dati di input dalla richiesta di inferenza o di includere solo un sottoinsieme di campi dei dati di input nella richiesta di inferenza, senza dover eseguire alcuna pre-elaborazione o post-elaborazione personalizzata nel container di inferenza. Questo è utile quando il file di dati di input contiene colonne aggiuntive non necessarie per il modello, ad esempio chiavi o dati aggiuntivi.

La trasformazione ti consente di inviare le istanze al container in formato JSON array o object. Per saperne di più, consulta instanceType.

Ad esempio, se la tabella di input contiene quanto segue:

customerId col1 col2
1001 1 2
1002 5 6

e specifichi il seguente instanceConfig:

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

Successivamente, le istanze nella richiesta di inferenza vengono inviate come oggetti JSON e la colonna customerId viene esclusa:

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

Tieni presente che specificando il seguente instanceConfig si otterrebbe lo stesso risultato:

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

Per una dimostrazione su come utilizzare i filtri delle caratteristiche, consulta il notebook Inferenza batch del modello personalizzato con filtro delle caratteristiche.

Richiedi un'inferenza batch

Per le richieste di inferenza in batch, puoi utilizzare la console Google Cloud o l'API Agent Platform. A seconda del numero di elementi di input che hai inviato, un'attività di inferenza batch può richiedere un po' di tempo per essere completata.

Quando richiedi un'inferenza batch, il container di inferenza viene eseguito come service account personalizzato fornito dall'utente. Le operazioni di lettura e scrittura, come la lettura delle istanze di inferenza dall'origine dati o la scrittura dei risultati dell'inferenza, vengono eseguite utilizzando l'agente di servizio Gemini Enterprise Agent Platform, che per impostazione predefinita ha accesso a BigQuery e Cloud Storage.

Console Google Cloud

Utilizza la console Google Cloud per richiedere un'inferenza batch.

  1. Nella console Google Cloud , nella sezione Agent Platform, vai alla pagina Previsioni in batch.

Vai alla pagina Previsioni in batch

  1. Fai clic su Crea per aprire la finestra Nuova previsione in batch.

  2. In Definisci le previsioni in batch, completa i seguenti passaggi:

    1. Inserisci un nome per l'inferenza batch.

    2. In Nome modello, seleziona il nome del modello da utilizzare per questa inferenza batch.

    3. In Seleziona origine, seleziona l'origine applicabile ai tuoi dati di input:

      • Se hai formattato l'input come JSON Lines, CSV o TFRecord, seleziona File su Cloud Storage (JSON Lines, CSV, TFRecord, TFRecord Gzip). Poi specifica il file di input nel campo Percorso di origine.
      • Se utilizzi un elenco di file come input, seleziona File su Cloud Storage (altro) e incolla l'elenco di file nel campo seguente.
      • Per l'input BigQuery, seleziona Percorso BigQuery. Se selezioni BigQuery come input, devi selezionare anche BigQuery come output e Google-managed encryption key. Le chiavi di crittografia gestite dal cliente (CMEK) non sono supportate con BigQuery come input/output.

    4. Nel campo Percorso di destinazione, specifica la directory Cloud Storage in cui vuoi che Agent Platform archivi l'output dell'inferenza batch.

    5. Facoltativamente, puoi selezionare Abilita attribuzioni delle caratteristiche per questo modello per ottenere le attribuzioni delle caratteristiche nell'ambito della risposta dell'inferenza batch. Poi fai clic su Modifica per configurare le impostazioni di spiegazione. (La modifica delle impostazioni di spiegazione è facoltativa se hai configurato in precedenza le impostazioni di spiegazione per il modello, altrimenti è obbligatoria.)

    6. Specifica le opzioni di computing per il job di inferenza batch: Numero di nodi di computing, Tipo di macchina e (facoltativamente) Tipo di acceleratore e Numero di acceleratori.

  3. (Facoltativo) L'analisi di Model Monitoring per le inferenze batch è disponibile in Anteprima. Consulta i Prerequisiti per aggiungere la configurazione del rilevamento del disallineamento al job di inferenza batch.

    1. Fai clic per attivare l'opzione Abilita il monitoraggio dei modelli per queste previsioni in batch.

    2. Seleziona un'origine dati di addestramento. Inserisci il percorso dei dati o la posizione per l'origine dati di addestramento selezionata.

    3. (Facoltativo) In Soglie di avviso, specifica le soglie per l'attivazione degli avvisi.

    4. In Email di notifica, inserisci uno o più indirizzi email separati da virgole per ricevere avvisi quando un modello supera una soglia di avviso.

    5. (Facoltativo) Per Canali di notifica, aggiungi canali Cloud Monitoring per ricevere avvisi quando un modello supera una soglia di avviso. Puoi selezionare canali Cloud Monitoring esistenti o crearne uno nuovo facendo clic su Gestisci canali di notifica. La console Google Cloud supporta i canali di notifica PagerDuty, Slack e Pub/Sub.

  4. Fai clic su Crea.

API

Utilizza l'API Agent Platform per inviare richieste di inferenza batch. Seleziona una scheda a seconda dello strumento che utilizzi per ottenere le inferenze batch.

REST

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • LOCATION_ID: la regione in cui è archiviato il modello e in cui viene eseguito il job di previsioni in batch. Ad esempio, us-central1.

  • PROJECT_ID: il tuo ID progetto. .

  • BATCH_JOB_NAME: nome visualizzato del job di previsione in batch.

  • MODEL_ID: l'ID del modello da utilizzare per fare previsioni.

  • INPUT_FORMAT: il formato dei dati di input: jsonl, csv, tf-record, tf-record-gzip o file-list.

  • INPUT_URI: l'URI Cloud Storage dei dati di input. Può contenere caratteri jolly.

  • OUTPUT_DIRECTORY: URI Cloud Storage di una directory in cui vuoi che la piattaforma dell'agente salvi l'output.

  • MACHINE_TYPE: le risorse della macchina da utilizzare per questo job di previsione in batch.

    Se vuoi, puoi configurare il campo machineSpec per utilizzare gli acceleratori, ma l'esempio seguente non lo dimostra.

  • BATCH_SIZE: il numero di istanze da inviare in ogni richiesta di previsione; il valore predefinito è 64. L'aumento delle dimensioni del batch può portare a un throughput più elevato, ma può anche causare timeout delle richieste.

  • STARTING_REPLICA_COUNT: il numero di nodi per questo job di previsione in batch.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

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

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

$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

Dovresti ricevere una risposta JSON simile alla seguente:

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Agent Platform per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Agent Platform Java.

Per eseguire l'autenticazione in Agent Platform, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente, sostituisci PREDICTIONS_FORMAT con jsonl. Per scoprire come sostituire gli altri segnaposto, consulta la scheda REST & CMD LINE di questa sezione.

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

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installa l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API 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,
    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,
        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

BigQuery

L'esempio REST precedente utilizza Cloud Storage per l'origine e la destinazione. Per utilizzare invece BigQuery, apporta le seguenti modifiche:

  • Modifica il campo inputConfig come segue:

    "inputConfig": {
   "instancesFormat": "bigquery",
   "bigquerySource": {
      "inputUri": "bq://SOURCE_PROJECT_ID.SOURCE_DATASET_NAME.SOURCE_TABLE_NAME"
   }
}

  • Modifica il campo outputConfig come segue:

    "outputConfig": {
   "predictionsFormat":"bigquery",
   "bigqueryDestination":{
      "outputUri": "bq://DESTINATION_PROJECT_ID.DESTINATION_DATASET_NAME.DESTINATION_TABLE_NAME"
   }
 }

  • Sostituisci quanto segue:

    • SOURCE_PROJECT_ID: l'ID del progetto Google Cloud di origine
    • SOURCE_DATASET_NAME: il nome del set di dati BigQuery di origine
    • SOURCE_TABLE_NAME: il nome della tabella di origine BigQuery
    • DESTINATION_PROJECT_ID: l'ID del progetto Google Cloud di destinazione
    • DESTINATION_DATASET_NAME: il nome del set di dati BigQuery di destinazione
    • DESTINATION_TABLE_NAME: il nome della tabella di destinazione BigQuery

Importanza delle caratteristiche

Se vuoi che vengano restituiti i valori di importanza delle caratteristiche per le tue inferenze, imposta la proprietà generateExplanation su true. Tieni presente che i modelli di previsione non supportano l'importanza delle caratteristiche, pertanto non puoi includerla nelle richieste di inferenza batch.

L'importanza delle caratteristiche, a volte chiamata attribuzione delle caratteristiche, fa parte di Vertex Explainable AI.

Puoi impostare generateExplanation su true solo se hai configurato Model per le spiegazioni o se specifichi il campo explanationSpec di BatchPredictionJob.

Scegli il tipo di macchina e il numero di repliche

La scalabilità orizzontale, che aumenta il numero di repliche, migliora la velocità effettiva in modo più lineare e prevedibile rispetto all'utilizzo di tipi di macchine più grandi.

In generale, ti consigliamo di specificare il tipo di macchina più piccolo possibile per il tuo job e di aumentare il numero di repliche.

Per l'efficacia in termini di costi, ti consigliamo di scegliere un numero di repliche tale che il job di inferenza batch venga eseguito per almeno 10 minuti. Questo perché ti viene addebitato il costo per ora nodo di replica, che include i circa 5 minuti necessari per l'avvio di ogni replica. Non è conveniente elaborare per pochi secondi e poi arrestare l'istanza.

In linea generale, per migliaia di istanze, consigliamo un valore di starting_replica_count nell'ordine delle decine. Per milioni di istanze, consigliamo un valore starting_replica_count nell'ordine delle centinaia. Puoi anche utilizzare la seguente formula per stimare il numero di repliche:

N / (T * (60 / Tb))

Dove:

  • N: il numero di batch nel job. Ad esempio, 1 milione di istanze / dimensione batch 100 = 10.000 batch.
  • T: il tempo previsto per il job di inferenza batch. Ad esempio, 10 minuti.
  • Tb: il tempo in secondi necessario a una replica per elaborare un singolo batch. Ad esempio, 1 secondo per batch su un tipo di macchina con 2 core.

Nel nostro esempio, 10.000 batch / (10 minuti * (60 / 1s)) viene arrotondato per eccesso a 17 repliche.

Questi consigli sono tutti indicativi. Non forniscono necessariamente un throughput ottimale per ogni modello. Non forniscono stime esatte del tempo e dei costi di elaborazione. Inoltre, non necessariamente catturano i migliori compromessi tra costi e throughput per ogni scenario. Utilizzali come punto di partenza ragionevole e modificali in base alle tue esigenze. Per misurare caratteristiche come il throughput del tuo modello, esegui il notebook Ricerca del tipo di macchina ideale.

Per le macchine con accelerazione GPU o TPU

Segui le linee guida precedenti (che si applicano anche ai modelli solo CPU), con le seguenti considerazioni aggiuntive:

  • Potresti aver bisogno di più CPU e GPU (ad esempio per la pre-elaborazione dei dati).
  • I tipi di macchine GPU richiedono più tempo per l'avvio (10 minuti), quindi potresti voler impostare tempi più lunghi (ad esempio, almeno 20 minuti anziché 10 minuti) per il job di inferenza batch, in modo che una parte ragionevole del tempo e dei costi venga spesa per la generazione delle inferenze.

Recupera i risultati dell'inferenza batch

Al termine di un'attività di inferenza batch, l'output dell'inferenza viene archiviato nel bucket Cloud Storage o nella posizione BigQuery che hai specificato nella richiesta.

Esempio di risultato dell'inferenza batch

La cartella di output contiene un insieme di file JSON Lines.

I file sono denominati {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. Il numero di file non è deterministico, a causa della natura distribuita dell'inferenza batch.

Ogni riga del file corrisponde a un'istanza dell'input e contiene le seguenti coppie chiave-valore:

  • prediction: contiene il valore restituito dal container.
  • instance: per un elenco di file, contiene l'URI Cloud Storage. Per tutti gli altri formati di input, contiene il valore inviato al container nel corpo della richiesta HTTP.

Esempio 1

Se la richiesta HTTP contiene:

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

Il container restituisce:

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

Il file di output JSON Lines è:

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

Esempio 2

Se la richiesta HTTP contiene:

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

Il container restituisce:

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

Il file di output JSON Lines è:

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

Endpoint rivolto agli utenti

Per migliorare l'osservabilità e ridurre il numero di quote da gestire, il server di modelli è disponibile come endpoint della piattaforma agente rivolto agli utenti. La configurazione di una delle seguenti funzionalità comporterà il deployment del modello in un endpoint rivolto agli utenti:

  • Prenotazioni condivise
  • VM spot
  • Flex-start VM

Utilizza l'AI spiegabile

Sconsigliamo di eseguire spiegazioni basate sulle caratteristiche su una grande quantità di dati. Questo perché ogni input può potenzialmente espandersi in migliaia di richieste in base all'insieme di possibili valori delle caratteristiche, il che potrebbe comportare un aumento significativo dei tempi e dei costi di elaborazione. In generale, un set di dati di piccole dimensioni è sufficiente per comprendere l'importanza delle caratteristiche.

L'inferenza batch non supporta le spiegazioni basate su esempi.

Notebook

Passaggi successivi