Ottieni previsioni batch da un modello con addestramento personalizzato

Questa pagina mostra come ottenere previsioni batch dai modelli addestrati personalizzati utilizzando la console Google Cloud o l'API Vertex AI.

Per effettuare una richiesta di previsione batch, specifica un'origine di input e una posizione di output, Cloud Storage o BigQuery, in cui Vertex AI memorizza i risultati delle previsioni.

Per ridurre al minimo i tempi di elaborazione, le località di input e output devono trovarsi nella stessa regione o in più regioni. 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.

Gli input e gli output devono inoltre trovarsi nella stessa regione o in più regioni del tuo modello.

Requisiti dei dati di input

L'input per le richieste batch specifica gli elementi da inviare al modello per la previsione. Supportiamo i seguenti formati di input:

Righe JSON

Utilizza un file JSON Lines per specificare un elenco di istanze di input su cui fare previsioni. Archiviare il file JSON Lines 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 di previsione 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 di previsione 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 PyTorch, assicurati di eseguire il wrapping di ogni istanza in un campo data come richiesto dal gestore predefinito di TorchServe; Vertex AI non esegue il wrapping delle istanze al posto tuo. 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 previsione 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. Puoi facoltativamente comprimere i file TFRecord con Gzip. Archivia i file TFRecord in un bucket Cloud Storage.

Vertex AI legge ogni istanza nei file TFRecord come binaria, quindi codifica l'istanza in base64 come oggetto JSON con una singola chiave denominata b64.

Ecco cosa viene inviato al container di previsione 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 di previsione 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. È necessario racchiudere tutte le stringhe tra virgolette doppie ("). Non si accettano valori di celle inclusi i caratteri di nuova riga. I valori non 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 di previsione 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 corrisponde all'URI Cloud Storage di un file. Vertex AI legge i contenuti di ogni file come binario, quindi codifica l'istanza in base64 come oggetto JSON con una singola chiave denominata b64.

Se prevedi di utilizzare la console Google Cloud per ottenere previsioni batch, incolla l'elenco dei file direttamente nella console Google Cloud. In caso contrario, salva l'elenco di file 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 di previsione 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 di previsione sappia come decodificare l'istanza.

BigQuery

Specifica una tabella BigQuery come projectId.datasetId.tableId. Vertex AI 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 "Gatto1"
2.0 4.0 "Gatto2"

Ecco cosa viene inviato al container di previsione 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 di BigQuery vengono convertiti in JSON:

Tipo BigQuery Tipo JSON Valore di esempio
String String "abc"
Integer Integer 1
In virgola mobile In virgola mobile 1.2
Numerico In virgola mobile 4925,000000000
Booleano Booleano true
TimeStamp String "01-01-2019 23:59:59.999999+00:00"
Data String "31-12-2018"
Tempo String "23:59:59.999999"
DateTime String "2019-01-01T00:00:00"
Record Oggetto { "A": 1,"B": 2}
Tipo ripetuto Array[Tipo] [1, 2]
Record nidificato Oggetto {"A": {"a": 0}, "B": 1}

Dati di partizione

La previsione batch utilizza MapReduce per eseguire lo sharding dell'input su ogni replica. Per utilizzare le funzionalità MapReduce, l'input deve essere partizionabile.

Vertex AI partiziona automaticamente BigQuery, elenco dei file e input di righe JSON.

Vertex AI non partiziona automaticamente i file CSV perché non sono compatibili con la partizione naturale. Le righe nei file CSV non sono autodescrittive, sono digitate e possono contenere nuove righe. Sconsigliamo di utilizzare l'input CSV per applicazioni sensibili alla velocità effettiva.

Per l'input TFRecord, assicurati di eseguire manualmente il partizionamento dei 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 specificato.

Filtra e trasforma i dati di input

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

L'applicazione di filtri consente di escludere alcuni campi nei dati di input della richiesta di previsione o di includere solo un sottoinsieme di campi dai dati di input nella richiesta di previsione, senza dover eseguire alcuna pre-elaborazione personalizzata nel container di previsione. Ciò è utile quando il file di dati di input contiene colonne aggiuntive che il modello non ha bisogno, ad esempio chiavi o dati aggiuntivi.

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

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

customerId col1 col2
1001 1 2
1002 5 6

e specifichi i seguenti valori instanceConfig:

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

A questo punto, le istanze nella richiesta di previsione vengono inviate come oggetti JSON e la colonna customerId viene esclusa:

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

Tieni presente che se specifichi il seguente valore instanceConfig, otterrai lo stesso risultato:

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

Per una dimostrazione su come utilizzare i filtri delle caratteristiche, consulta il blocco note Previsione batch di modelli personalizzati con filtri delle caratteristiche.

Richiedi una previsione batch

Per le richieste di previsione batch, puoi utilizzare la console Google Cloud o l'API Vertex AI. A seconda del numero di elementi di input che hai inviato, il completamento di un'attività di previsione batch può richiedere del tempo.

Quando richiedi una previsione batch, il container di previsione viene eseguito come account di servizio personalizzato fornito dall'utente. Le operazioni di lettura/scrittura, come la lettura delle istanze di previsione dall'origine dati o la scrittura dei risultati della previsione, vengono eseguite utilizzando l'agente di servizio Vertex AI, che per impostazione predefinita ha accesso a BigQuery e Cloud Storage.

Console Google Cloud

Utilizza la console Google Cloud per richiedere una previsione batch.

  1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Previsioni batch.

Vai alla pagina Previsioni batch

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

  2. Per Definire la previsione batch, completa i seguenti passaggi:

    1. Inserisci un nome per la previsione batch.

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

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

      • Se hai formattato l'input come JSON Lines, CSV o TFRecord, seleziona File on Cloud Storage (JSON Lines, CSV, TFRecord, TFRecord Gzip). Quindi specifica il file di input nel campo Percorso di origine.
      • Se utilizzi un elenco di file come input, seleziona File in Cloud Storage (altro) e incolla l'elenco dei file nella casella di testo seguente.
      • Per l'input di BigQuery, seleziona Percorso BigQuery. Se selezioni BigQuery come input, devi anche selezionare BigQuery come output e la chiave di crittografia gestita da Google. La chiave di crittografia gestita dal cliente (CMEK) non è supportata con BigQuery come input/output.

    4. Nel campo Percorso di destinazione, specifica la directory Cloud Storage in cui vuoi che Vertex AI archivi l'output della previsione batch.

    5. Facoltativamente, puoi selezionare Abilita attribuzioni delle caratteristiche per questo modello per ottenere le attribuzioni delle caratteristiche come parte della risposta della previsione batch. Quindi, fai clic su Modifica per configurare le impostazioni di spiegazione. La modifica delle impostazioni di spiegazione è facoltativa se in precedenza hai configurato le impostazioni di spiegazione per il modello, altrimenti richiesta.

    6. Specifica le opzioni di calcolo per il job di previsione batch: Numero di nodi di calcolo, Tipo di macchina e, facoltativamente, Tipo di acceleratore e Numero acceleratori

  3. (Facoltativo) L'analisi del monitoraggio dei modelli per le previsioni batch è disponibile in Anteprima. Consulta i prerequisiti per l'aggiunta della configurazione del rilevamento del disallineamento al job di previsione batch.

    1. Fai clic per attivare Abilita il monitoraggio del modello per questa previsione batch.

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

    3. (Facoltativo) In Soglie di avviso, specifica le soglie in cui attivare gli 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 i canali di notifica, aggiungi canali Cloud Monitoring per ricevere avvisi quando un modello supera una soglia di avviso. Puoi selezionare i canali Cloud Monitoring esistenti o crearne uno nuovo facendo clic su Gestisci canali di notifica. La console supporta i canali di notifica PagerDuty, Slack e Pub/Sub.

  4. Fai clic su Crea.

API

Utilizzare l'API Vertex AI per inviare richieste di previsione batch. Seleziona una scheda in base allo strumento che utilizzi per ottenere previsioni batch:

REST

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

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

  • PROJECT_ID: il tuo ID progetto.

  • BATCH_JOB_NAME: nome visualizzato per il job di previsione 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: URI Cloud Storage dei dati di input. Possono contenere caratteri jolly.

  • OUTPUT_DIRECTORY: URI Cloud Storage di una directory in cui vuoi che Vertex AI salvi l'output.

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

    Facoltativamente, 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 della dimensione del batch può portare a una velocità effettiva più elevata, ma può anche causare timeout delle richieste.

  • STARTING_REPLICA_COUNT: il numero di nodi per questo job di previsione 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 delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

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

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

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

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

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 per la configurazione di Java nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Nel seguente esempio, 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 per Python, vedi Installare l'SDK Vertex AI per Python. Per maggiori informazioni, 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,
    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

Importanza delle caratteristiche

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

L'importanza delle caratteristiche, a volte chiamata attribuzioni 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 aumentando il numero di repliche migliora la velocità effettiva in modo più lineare e prevedibile rispetto all'utilizzo di tipi di macchina più grandi.

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

Per una maggiore convenienza, ti consigliamo di scegliere il conteggio delle repliche in modo che il job di previsione batch venga eseguito per almeno 10 minuti. Questo perché ti viene addebitato il costo per ora nodo di replica, che include circa 5 minuti necessari per l'avvio di ciascuna replica. Non è conveniente elaborare solo pochi secondi e poi arrestarlo.

Come guida generale, per migliaia di casi, consigliamo un starting_replica_count a decine. Per milioni di istanze, consigliamo un starting_replica_count tra centinaia. Puoi anche utilizzare la forumla seguente per stimare il numero di repliche:

N / (T * (60 / Tb))

Dove:

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

Nel nostro esempio, 10.000 batch / (10 minuti * (60 / 1s)) vengono arrotondati a 17 repliche.

A differenza della previsione online, i job di previsione batch non scalano automaticamente. Poiché tutti i dati di input sono noti in anticipo, il sistema esegue il partizionamento dei dati per ogni replica all'avvio del job. Il sistema utilizza il parametro starting_replica_count; il parametro max_replica_count viene ignorato.

Questi consigli sono tutte linee guida approssimative. Non è garantito che offrano una velocità effettiva ottimale per ogni modello. Non forniscono previsioni precise su tempi e costi di elaborazione. Inoltre, non necessariamente offrono i migliori miglioramenti in termini di costi/velocità effettiva. Usali come un buon punto di partenza e modificali in base alle necessità. Per misurare caratteristiche come la velocità effettiva per il tuo modello, esegui il blocco note Finding ideal machine type (Trova il tipo di macchina ideale).

Per macchine con accelerazione GPU o TPU

Segui le linee guida per i modelli solo CPU con le seguenti considerazioni aggiuntive:

  • Potresti aver bisogno di più CPU e GPU (ad esempio per la pre-elaborazione dei dati).
  • L'avvio dei tipi di macchine GPU richiede più tempo (10 minuti), quindi ti conviene scegliere come target tempi più lunghi (ad esempio, almeno 20 minuti invece di 10 minuti) per il job di previsione batch, in modo da destinare una proporzione ragionevole di tempo e costi alla generazione delle previsioni.

Recuperare i risultati delle previsioni batch

Quando un'attività di previsione batch è completa, l'output della previsione viene archiviato nel bucket Cloud Storage o nella località BigQuery specificata nella richiesta.

Esempio di risultato della previsione batch

La cartella di output contiene un set 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 della previsione batch.

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

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

Esempio 1

Se la richiesta HTTP contiene:

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

Il container di previsione restituisce:

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

Quindi, il file di output jsonl sarà:

{ "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 di previsione restituisce:

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

Quindi, il file di output jsonl sarà:

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

Usa Explainable AI

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

La previsione batch non supporta le spiegazioni basate su esempi.

Passaggi successivi