Generazione di previsioni batch da un modello con addestramento personalizzato

Questa pagina mostra come ottenere previsioni collettive 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 della previsione batch.

Limitazioni e requisiti

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

  • Per ridurre al minimo i tempi di elaborazione, le posizioni 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 Località di Cloud Storage e Località di BigQuery.
  • Anche l'input e l'output devono trovarsi nella stessa regione o area multiregionale del modello.
  • I modelli di Model Garden non sono supportati.
  • I modelli BigQuery ML non sono modelli addestrati in base alle esigenze. Tuttavia, le informazioni in questa pagina possono essere utilizzate per ottenere previsioni batch da un modello BigQuery ML alle seguenti condizioni:
    • Il modello BigQuery ML deve essere registrato in Vertex AI Model Registry.
    • Per utilizzare una tabella BigQuery come input, devi impostare InstanceConfig.instanceType su "object" utilizzando l'API Vertex AI.

Requisiti dei dati di input

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

Righe JSON

Utilizza un file JSON Lines per specificare un elenco di istanze di input per le quali fare le tue predizioni. 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 contenitore 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 contenitore 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 di PyTorch, assicurati di racchiudere ogni istanza in un data campo come richiesto dall'handler predefinito di TorchServe; Vertex AI non racchiude 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 contenitore 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. Memorizza i file TFRecord in un bucket Cloud Storage.

Vertex AI 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 contenitore 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 contenitore di previsione sappia 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 ("). Vertex AI non accetta valori di celle contenenti 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 contenitore 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 è l'URI Cloud Storage di un file. Vertex AI legge i contenuti di ogni file come binari e poi codifica l'istanza in base64 come oggetto JSON con una singola chiave denominata b64.

Se prevedi di utilizzare la console Google Cloud per ottenere le previsioni batch, incolla l'elenco dei 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 contenitore 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 contenitore di previsione sappia 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 "Cat1"
2.0 4.0 "Cat2"

Ecco cosa viene inviato al contenitore 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
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[Tipo] [1, 2]
Record nidificato Oggetto {"A": {"a": 0}, "B": 1}

Dati della partizione

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

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

Vertex AI non esegue automaticamente la partizione dei file CSV perché non sono naturalmente adatti alla partizione. Le righe nei file CSV non sono autodescrittive, non sono digitate e possono contenere interruzioni di riga. Sconsigliamo di utilizzare l'input CSV per le applicazioni sensibili alla produttività.

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'espressione generica (ad es. gs://my-bucket/*.tfrecord). Il numero di file deve essere almeno uguale 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 previsione o di includere solo un sottoinsieme di campi dei dati di input nella richiesta di previsione, senza dover eseguire alcuna preelaborazione o post-elaborazione personalizzata nel contenitore di previsione. Questo è utile quando il file di dati di input contiene colonne aggiuntive di cui il modello non ha bisogno, ad esempio chiavi o dati aggiuntivi.

La trasformazione ti consente di inviare le istanze al tuo contenitore di previsione in formato JSON array o object. Per ulteriori informazioni, 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 previsione vengono inviate come oggetti JSON e la colonna customerId viene esclusa:

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

Tieni presente che la specifica del seguente instanceConfig produrrebbe lo stesso risultato:

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

Per una dimostrazione su come utilizzare i filtri delle funzionalità, consulta il notebook Predizione batch del modello personalizzato con filtri delle funzionalità.

Richiedere 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 inviati, il completamento di un'attività di previsione batch può richiedere del tempo.

Quando richiedi una previsione in batch, il relativo container viene eseguito come account 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 di 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 Predizioni 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 in batch.

    3. Per 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). Quindi, specifica il file di input nel Percorso di origine.
      • Se utilizzi un elenco di file come input, seleziona File su Cloud Storage (altro) e incolla l'elenco nel campo seguente.
      • Per l'input BigQuery, seleziona Percorso BigQuery. Se selezioni BigQuery come input, devi selezionare anche 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 memorizzi l'output della previsione batch.

    5. Se vuoi, puoi selezionare Abilita attribuzioni delle caratteristiche per questo modello per visualizzare le attribuzioni delle caratteristiche nella risposta della previsione batch. Poi fai clic su Modifica per configurare le impostazioni della spiegazione. La modifica delle impostazioni di spiegazione è facoltativa se hai configurato precedentemente le impostazioni di spiegazione per il modello ed è obbligatoria in caso contrario.

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

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

    1. Fai clic per attivare l'opzione Attiva il monitoraggio dei modelli 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 per attivare gli avvisi.

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

    5. (Facoltativo) Per Canali di notifica, aggiungi i 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 Google Cloud 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 in batch. Seleziona una scheda a seconda dello strumento che utilizzi per ottenere le previsioni batch.

REST

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

  • LOCATION_ID: regione in cui è archiviato il modello e viene eseguito il job di previsione in 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 le predizioni.

  • 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 simboli 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.

    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 della dimensione del batch può portare a una maggiore throughput, ma può anche causare timeout delle richieste.

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

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

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare 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 REST & CMD LINE scheda 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, 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

BigQuery

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

  • Modifica il campo inputConfig nel seguente modo:

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

  • Modifica il campo outputConfig nel seguente modo:

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

  • Sostituisci quanto segue:

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

Importanza delle caratteristiche

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

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 mediante l'aumento del numero di repliche migliora il throughput 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 un'ottimizzazione dei costi, ti consigliamo di scegliere il numero di repliche in modo che il job di previsione batch venga eseguito per almeno 10 minuti. Questo perché ti viene addebitato un costo per ora nodo replica, che include i circa 5 minuti necessari per l'avvio di ogni replica. Non è conveniente elaborare i dati solo per alcuni secondi e poi spegnere il dispositivo.

Come linea guida generale, per migliaia di istanze consigliamo un valore di starting_replica_count compreso tra 10 e 100. Per milioni di istanze, consigliamo un valore starting_replica_count compreso tra le 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 del batch 100 = 10.000 batch.
  • T: l'ora prevista per il job di previsione in 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 a 2 core.

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

A differenza della previsione online, i job di previsione in batch non sono scalabili automaticamente. Poiché tutti i dati di input sono noti in anticipo, il sistema partiziona i dati 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 tutte linee guida approssimative. Non necessariamente offrono una produttività ottimale per ogni modello. Non forniscono previsioni precise del tempo e del costo di elaborazione. Inoltre, non necessariamente rilevano i migliori compromessi tra costo e throughput per ogni scenario. Utilizzali come punto di partenza ragionevole e modificali in base alle necessità. Per misurare caratteristiche come la throughput per il tuo modello, esegui il notebook Trovare il tipo di macchina ideale.

Per 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 preelaborazione dei dati).
  • I tipi di macchine GPU richiedono più tempo per l'avvio (10 minuti), quindi ti consigliamo di scegliere come target periodi di tempo più lunghi (ad esempio almeno 20 minuti anziché 10) per il job di previsione in batch in modo che una proporzione ragionevole di tempo e costi venga spesa per la generazione delle previsioni.

Recuperare i risultati delle previsioni batch

Al termine di un'attività di previsione batch, l'output della previsione viene archiviato nel bucket Cloud Storage o nella posizione BigQuery specificata nella richiesta.

Esempio di risultato di 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 è deterministico, a causa della natura distribuita della previsione batch.

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

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

Esempio 1

Se la richiesta HTTP contiene:

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

Il contenitore di previsione 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 contenitore di previsione 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}}

Utilizzare l'IA spiegabile

Non è consigliabile eseguire spiegazioni basate su funzionalità su una grande quantità di dati. Questo perché ogni input può potenzialmente generare migliaia di richieste in base all'insieme di possibili valori delle funzionalità, il che può comportare un aumento significativo del tempo e dei costi di elaborazione. In generale, è sufficiente un piccolo set di dati per comprendere l'importanza delle funzionalità.

La previsione in batch non supporta le spiegazioni basate su esempi.

Notebooks

Passaggi successivi