Ottieni 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.

Per ridurre al minimo i tempi di elaborazione, le località di input e output devono trovarsi nelle stesse una o 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.

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 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. Supportiamo 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 .

{ "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 PyTorch, assicurati di eseguire il wrapping di ogni istanza in una campo data come richiesto dal gestore predefinito di TorchServe; Vertex AI non esegue 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 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. 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 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 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 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 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 è l'URI Cloud Storage di un file. 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 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 file JSON in esecuzione in un'istanza Compute Engine.

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 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
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 BigQuery, elenco dei file e input di righe JSON.

Vertex AI non partiziona automaticamente i file CSV perché non sono naturalmente compatibili con la partizione. 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 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 il numero di repliche specificato.

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. Consulta: instanceType per ulteriori informazioni.

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 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 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. 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 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 di 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 computing, Tipo di macchina, e, facoltativamente, Tipo di acceleratore e Conteggio acceleratori.

  3. (Facoltativo) Monitoraggio dei modelli per le previsioni batch è disponibile Anteprima. Consulta le 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 dei dati o la posizione per l'origine dati di addestramento che hai selezionato.

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

  4. Fai clic su Crea.

API

Utilizzare l'API Vertex AI per inviare richieste di previsione batch. Seleziona una scheda a seconda dello strumento che utilizzi per ottenere le 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 in batch. Ad esempio, us-central1.

  • PROJECT_ID: il tuo ID progetto.

  • BATCH_JOB_NAME: nome visualizzato del 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: 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.

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

  • BATCH_SIZE: il numero di istanze da inviare in ogni richiesta di previsione. Il valore predefinito è 64. L'aumento delle dimensioni del batch può portare a 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, 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. 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 nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di 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.

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 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 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 caratteristiche, quindi non puoi includerla nel tuo batch richieste di previsione.

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 spiegazioni o se devi specificare 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 aumenta 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 solo per alcuni secondi e poi si arresta.

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 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)) arrotonda per eccesso 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 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 per il tuo modello, esegui il comando Finding ideal machine tipo un blocco note personalizzato.

Per macchine con accelerazione GPU o TPU

Segui le linee guida precedenti (che valgono anche per i modelli solo CPU), con i 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 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 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 è deterministico, a causa della natura distribuita della previsione batch.

Ogni riga del file corrisponde a un'istanza dell'input e presenta 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]
  ],
}

Quindi il file di output di 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

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.

Notebooks

Passaggi successivi