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 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 ulteriori informazioni 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 model.

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 da creare le tue previsioni. 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 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 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 aggregare ogni istanza in un 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 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 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 binario e poi codifica l'istanza in base64 come oggetto JSON con una singola chiave denominata b64.

Ecco cosa viene inviato al container di previsione nel corpo della richiesta HTTP:

Tutti gli altri container

{"instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Container PyTorch

{"instances": [ { "data": {"b64": "b64EncodedASCIIString" } }, { "data": {"b64": "b64EncodedASCIIString" } }
]}

Assicurati che il container di previsione sappia come decodificare l'istanza.

CSV

Specifica un'istanza di input per riga in un file CSV. La prima riga deve essere un riga di intestazione. È necessario racchiudere tutte le stringhe tra virgolette doppie ("). Vertex AI non accetta valori di celle che contengono a capo. 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 corrisponde all'URI Cloud Storage di un . Vertex AI legge i contenuti di ogni file come binario 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. Altrimenti, salva in un bucket Cloud Storage.

L'esempio seguente mostra un elenco di file con due istanze di input:

gs://path/to/image/image1.jpg
gs://path/to/image/image2.jpg

Ecco cosa viene inviato al container di previsione nel corpo della richiesta HTTP:

Tutti gli altri container

{ "instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Container PyTorch

{ "instances": [ { "data": { "b64": "b64EncodedASCIIString" } }, { "data": { "b64": "b64EncodedASCIIString" } }
]}

Assicurati che il container di previsione sappia come decodificare l'istanza.

BigQuery

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

Ecco cosa viene inviato al container di previsione nel corpo della richiesta HTTP:

Tutti gli altri container

{"instances": [ [1.0,3.0,"cat1"], [2.0,4.0,"cat2"] ]}

Container PyTorch

{"instances": [
{ "data": [1.0,3.0,"cat1"] },
{ "data": [2.0,4.0,"cat2"] } ]}

Ecco come i tipi di dati di BigQuery vengono convertiti in JSON:

Tipo BigQuery Tipo JSON Valore di esempio
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 eseguire lo sharding dell'input su ogni replica. Per utilizzare le funzionalità MapReduce, l'input deve essere partizionabile.

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

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

Per l'input TFRecord, assicurati di eseguire manualmente il partizionamento dei dati suddividendo le istanze in file più piccoli e passando i file al job con un carattere jolly (ad esempio, gs://my-bucket/*.tfrecord). Il numero di file deve essere almeno 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. È utile quando l'input file di dati contiene colonne aggiuntive che il modello non ha bisogno, come chiavi o colonne e i dati di Google Cloud.

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 i seguenti valori instanceConfig:

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

Successivamente, le istanze nella richiesta di previsione vengono inviate come oggetti JSON customerId colonna è 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 di come utilizzare i filtri delle caratteristiche, consulta la sezione Batch di modelli personalizzati previsione con funzionalità filtri un blocco note.

Richiedi 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 l'attività 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 questo batch la previsione.

    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 di 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 Cloud Storage in cui vuoi che Vertex AI archivi il batch l'output della previsione.

    5. (Facoltativo) Puoi selezionare Attiva attribuzioni delle caratteristiche per questo modello per ottenere le attribuzioni delle caratteristiche come 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 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 Abilita il monitoraggio del modello 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 a cui attivare gli avvisi.

    4. Per 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 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 utilizzato 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 job di previsione batch viene eseguito. 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: 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 machineSpec per utilizzare acceleratori, ma l'esempio seguente non lo dimostra.

  • BATCH_SIZE: il numero di istanze da inviare in ogni previsione richiesta; il valore predefinito è 64. L'aumento della dimensione del batch può comportare ma può anche causare timeout delle richieste.

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

Metodo HTTP e URL: 

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Corpo JSON della richiesta: 

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "INPUT_FORMAT",
    "gcsSource": {
      "uris": ["INPUT_URI"],
    },
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY",
    },
  },
  "dedicatedResources" : {
    "machineSpec" : {
      "machineType": MACHINE_TYPE
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT
  },
  "manualBatchTuningParameters": {
    "batch_size": BATCH_SIZE,
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

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

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

PowerShell

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

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

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

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "INPUT_URI"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
}

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Java Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nel seguente esempio, sostituisci PREDICTIONS_FORMAT con jsonl. Per informazioni su 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, procedi nel seguente modo 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 come segue:

    "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 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 una maggiore convenienza, ti consigliamo di scegliere un numero di repliche tale che il job di previsione batch viene eseguito per almeno 10 minuti. Il motivo è che stai addebitati per ora nodo di replica, che include i circa 5 minuti all'avvio di ogni replica. Non è conveniente elaborare solo per alcuni secondi e poi si arresta.

Come guida generale, per migliaia di casi, consigliamo una starting_replica_count in decine. Per milioni di istanze, consigliano centinaia di starting_replica_count. Puoi utilizzare anche questa 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 / 100 lotti = 10.000 lotti.
  • 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 esatte di tempo e costi di elaborazione. E non acquisiscono necessariamente i migliori tra costi e velocità effettiva per ogni scenario. Usali come un buon punto di partenza punto e di regolarle in base alle necessità. Per misurare caratteristiche come per il tuo modello, esegui il comando Finding ideal machine tipo un blocco note.

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 pre-elaborazione dei dati).
  • L'avvio dei tipi di macchine GPU richiede più tempo (10 minuti), perciò è consigliabile Scegliere come target tempi più lunghi (ad es. almeno 20 minuti invece di 10 minuti) per il job di previsione batch, in modo che una ragionevole proporzione di tempo per generare previsioni.

Recuperare i risultati delle previsioni batch

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

Esempio di risultato della previsione batch

La cartella di output contiene un set di file JSON Lines.

I file sono denominati {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. Il numero di file non è deterministico, a causa della natura distribuita dei file la previsione.

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

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

Quindi il file di output di 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, un set di dati ridotto è sufficiente per comprendere l'importanza delle caratteristiche.

La previsione batch non supporta le spiegazioni basate su esempi.

Passaggi successivi