Ottieni previsioni batch da un modello con addestramento 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, specifica un input sorgente e una posizione di output, Cloud Storage o BigQuery, dove Vertex AI archivia i risultati della previsione 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 apprendere vedi Località Cloud Storage e Località di BigQuery

L'input e l'output devono inoltre trovarsi nella stessa regione o in più regioni del tuo un modello di machine learning.

  • Il modello BigQuery ML deve essere registrato con Vertex AI Model Registry.
  • Per utilizzare una tabella BigQuery come input, devi impostare InstanceConfig.instanceType a "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. Archiviare 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 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 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 TFRecord standard. Puoi facoltativamente comprimi 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 e poi la codifica 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 un 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 con rappresentazione 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 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 . Vertex AI 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 previsioni batch, incolla 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 container

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

Ecco cosa viene inviato al contenitore 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 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 "01-01-2019 23:59:59.999999+00:00"
Data Stringa "31-12-2018"
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 di 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 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 a capo. 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 nel tuo BatchPredictionJob richiesta.

L'opzione Filtri consente di escludere determinati campi presenti nei dati di input. dalla richiesta di previsione o includere solo un sottoinsieme di campi dell'input i dati nella richiesta di previsione, senza dover configurare pre-elaborazione o post-elaborazione nel container 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 container di previsione in 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 produrrà 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 l'API Vertex AI. In base al numero di input che hai inviato, viene visualizzata una di previsione batch può richiedere del tempo.

Quando richiedi una previsione batch, il container di previsione viene eseguito come servizio personalizzato fornito dall'utente Google Cloud. Lo strumento di lettura/scrittura operazioni come la lettura delle istanze di previsione dall'origine dati i risultati delle previsioni, vengono eseguiti utilizzando il servizio Vertex AI di Google 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 in batch.

    3. Per Seleziona origine, seleziona l'origine applicabile alla tua 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 on Cloud Storage (other) e incolla l'elenco dei file in nel campo seguente.
      • Per l'input BigQuery, seleziona Percorso BigQuery. Se selezioni BigQuery come input, devi anche selezionare BigQuery come output e crittografia gestita da Google chiave. La chiave di crittografia gestita dal cliente (CMEK) non è supportata utilizzando 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. (Facoltativo) Puoi selezionare Attiva attribuzioni delle caratteristiche per questo modello per ottenere le attribuzioni delle caratteristiche come parte della risposta della previsione batch. Poi fai clic su Modifica per configurare impostazioni di spiegazione. (Editing le impostazioni di spiegazione sono facoltative se in precedenza avevi configurato impostazioni di spiegazione per il modello e altrimenti richiesto).

    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 a cui attivare gli avvisi.

    4. Per le 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 batch. Seleziona una scheda a seconda dello strumento utilizzato 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 creare per le previsioni.

  • INPUT_FORMAT: il formato del tuo input di dati: 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.

    Facoltativamente, puoi configurare il machineSpec per utilizzare 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 maggiore velocità effettiva, 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. 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, 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 API Java Vertex AI documentazione di riferimento.

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 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, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta 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 destinazione. Per utilizzare 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 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 vengano restituiti valori di importanza delle caratteristiche per le previsioni, imposta il valore generateExplanation a 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 il tuo 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, 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 di 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: il tempo previsto per il job di previsione 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 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 necessariamente offrono una velocità effettiva 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 il 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 pre-elaborazione 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 batch in modo che una proporzione ragionevole di tempo e costi venga spesa per la generazione delle previsioni.

Recuperare i risultati della previsione 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 dei file la previsione.

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

  • prediction: contiene il valore restituito dal container di previsione.
  • instance: per un elenco di file, contiene l'URI Cloud Storage. Per tutti altri formati di input, contiene il valore inviato alla 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}}

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 portare a un enorme aumento dei tempi 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