Ottieni previsioni batch da un modello addestrato personalizzato

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

Per effettuare una richiesta di previsione batch, devi specificare un'origine di input e una posizione di output, Cloud Storage o BigQuery, in cui Vertex AI archivia 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 scoprire di più, consulta le località di Cloud Storage e le località di BigQuery.

Anche l'input e l'output devono trovarsi nella stessa regione o in più regioni del 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 contenitori

{"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 eseguirà il wrapping delle 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 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. Se vuoi, puoi comprimere i file TFRecord con Gzip. Archiviare i file TFRecord in un bucket Cloud Storage.

Vertex AI legge ogni istanza nei file TFRecord come file binario, quindi in base64 codifica l'istanza 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 contenitori

{"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. Tutte le stringhe devono essere racchiuse tra virgolette doppie ("). Non accettiamo valori di cella inclusi i caratteri di nuova riga. 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 di previsione nel corpo della richiesta HTTP:

Tutti gli altri contenitori

{"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 rappresenta l'URI Cloud Storage di un file. Vertex AI legge i contenuti di ogni file come file binario, quindi base64 codifica l'istanza 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. Altrimenti, salva l'elenco dei 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 contenitori

{ "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 tua tabella contiene:

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 contenitori

{"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
In virgola mobile In virgola mobile 1.2
Numerico In virgola mobile 4925,000000000
Booleano Booleano true
TimeStamp Stringa "01-01-2019 23:59:59.999999+00:00"
Data Stringa "31/12/2018"
Tempo Stringa "23:59:59.999999"
DateTime Stringa "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}

Partizione dei dati

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

Vertex AI partiziona automaticamente BigQuery, l'elenco di file e l'input di linee JSON.

Vertex AI non esegue automaticamente il partizionamento dei file CSV perché non sono naturalmente compatibili con la partizione. Le righe nei file CSV non sono autodescrittive, digitate e potrebbero contenere nuove righe. Sconsigliamo di utilizzare input CSV per 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 specificato.

Filtrare e trasformare i dati di input

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

L'applicazione di filtri consente di escludere dalla richiesta di previsione determinati campi presenti nei dati di input o di includere solo un sottoinsieme di campi dei dati di input nella richiesta di previsione, senza dover eseguire alcuna pre/post-elaborazione personalizzata nel container di previsione. Questo è utile quando il file di dati di input ha colonne aggiuntive di cui il modello non ha bisogno, come chiavi o dati aggiuntivi.

La trasformazione 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:

customerId col1 col2
1001 1 2
1002 5 6

e specifichi quanto segue instanceConfig:

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

Quindi, 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 specificare instanceConfig come segue si ottiene lo stesso risultato:

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

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

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 sezione Vertex AI della console Google Cloud, vai alla pagina Previsioni batch.

Vai alla pagina Previsioni batch

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

  2. Per Definisci 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. In Seleziona origine, seleziona l'origine applicabile ai 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 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 chiave di crittografia di output e 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 della spiegazione. (La modifica delle impostazioni di spiegazione è facoltativa se in precedenza hai configurato le impostazioni di spiegazione per il modello, altrimenti è obbligatoria.)

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

  3. Facoltativo: l'analisi di Model Monitoring 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 località dei dati per l'origine dati di addestramento selezionata.

    3. (Facoltativo) In Soglie di avviso, specifica le soglie su 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 di 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

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

REST

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

  • LOCATION_ID: regione in cui viene archiviato il modello ed 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. Può contenere caratteri jolly.

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

  • MACHINE_TYPE: le risorse 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 delle dimensioni 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:

arricciatura

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

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

Nell'esempio seguente, sostituisci PREDICTIONS_FORMAT con jsonl. Per informazioni su come sostituire gli altri segnaposto, consulta la scheda REST & CMD LINE in 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_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

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per 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,
    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 i valori relativi all'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 includerli nelle richieste di previsione 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 aumentando il numero di repliche migliora la velocità effettiva in modo più lineare e prevedibile rispetto all'uso di tipi di macchina 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 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. Il motivo è che il costo viene fatturato per ora nodo di replica, che include i 5 minuti circa necessari per l'avvio di ogni replica. Non è conveniente elaborare per pochi secondi e poi arrestarsi.

Come indicazione generale, per migliaia di istanze, consigliamo un starting_replica_count nella decina. Per milioni di istanze, consigliamo un starting_replica_count. Puoi anche utilizzare la seguente forumla 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 dimensione batch = 10.000 batch.
  • T: tempo desiderato per il job di previsione batch. ad esempio 10 minuti.
  • Da confermare: il tempo in secondi necessario affinché una replica elabori un singolo batch. Ad esempio, 1 secondo per batch su un tipo di macchina a 2 core.

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

A differenza della previsione online, i job di previsione batch non hanno la scalabilità automatica. Poiché tutti i dati di input sono noti in anticipo, il sistema li partiziona in ogni replica all'avvio del job. Il sistema utilizza il parametro starting_replica_count; il parametro max_replica_count viene ignorato.

Questi consigli sono solo linee guida approssimative. Non è garantito che offrano una velocità effettiva ottimale per ogni modello. Non forniscono previsioni esatte sui tempi e sui costi di elaborazione. Inoltre, non individuano necessariamente i migliori compromessi in termini di costo e velocità effettiva per ogni scenario. Usali come punto di partenza ragionevole e modificali secondo necessità. Per misurare caratteristiche come la velocità effettiva del modello, esegui il blocco note Finding ideal machine type.

Per macchine con accelerazione GPU o TPU

Segui le linee guida per i modelli solo CPU, tenendo conto delle seguenti considerazioni aggiuntive:

  • Potresti aver bisogno di più CPU e GPU (ad es. per la pre-elaborazione dei dati).
  • L'avvio dei tipi di macchine GPU richiede più tempo (10 minuti), pertanto ti consigliamo di scegliere come target tempi più lunghi (ad esempio almeno 20 minuti anziché 10 minuti) per il job di previsione batch, in modo che venga spesa una proporzione ragionevole del tempo e dei costi per la generazione di previsioni.

Recupera i risultati della previsione batch

Al completamento di un'attività di previsione batch, 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 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 deterministici 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 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 è:

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

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

Utilizzare Explainable AI

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

La previsione batch non supporta le spiegazioni basate su esempi.

Passaggi successivi