Ottenere previsioni per un modello di previsione

Questa pagina mostra come creare una previsione utilizzando il modello di previsione addestrato.

Per creare una previsione, invia una richiesta di previsione batch direttamente al tuo modello di previsione, specificando un'origine di input e una posizione di output per memorizzare i risultati della previsione.

Le previsioni con AutoML non sono compatibili con il deployment dell'endpoint o con le predizioni online. Se vuoi richiedere previsioni online dal tuo modello di previsione, utilizza Flusso di lavoro tabulare per la previsione.

Puoi richiedere una previsione con spiegazioni (chiamata anche caratteristica attribuzioni) per vedere come il modello ha prodotto una previsione. La funzionalità locale i valori di importanza indicano in che misura ciascuna caratteristica ha contribuito alla previsione o il risultato finale. Per una panoramica concettuale, consulta Attribuzioni delle caratteristiche per le previsioni.

Prima di iniziare

Prima di poter creare una previsione, devi addestrare un modello di previsione.

Dati di input

I dati di input per le richieste di previsione batch sono quelli che il modello utilizza per per creare previsioni. Puoi fornire dati di input in uno dei due formati:

• Oggetti CSV in Cloud Storage
• tabelle BigQuery

Ti consigliamo di utilizzare per i dati di input lo stesso formato utilizzato per durante l'addestramento del modello. Ad esempio, se hai addestrato il modello utilizzando i dati BigQuery, è meglio utilizzare una tabella BigQuery come input per la tua previsione batch. Poiché Vertex AI tratta tutti i campi di input CSV come stringhe, la combinazione di formati di dati di addestramento e di input può causare errori.

L'origine dati deve contenere dati tabulari che includono tutte le colonne, in qualsiasi ordine, utilizzate per addestrare il modello. Puoi includere colonne che vengono presenti nei dati di addestramento o che erano nei dati di addestramento, ma esclusi per l'addestramento. Queste colonne aggiuntive sono incluse nell'output ma non influire sui risultati della previsione.

Requisiti dei dati di input

L'input per i modelli di previsione deve rispettare i seguenti requisiti:

• Tutti i valori nella colonna dell'ora devono essere presenti e validi.
• La frequenza dei dati di input deve corrispondere a quella dei dati di addestramento. Se nelle serie temporali mancano righe, devi inserirle manualmente in base alle conoscenze del dominio appropriate.
• Le serie temporali con timestamp duplicati vengono rimosse dalle previsioni. A includili, rimuovi eventuali timestamp duplicati.
• Fornisci dati storici per ogni serie temporale da prevedere. Per previsioni accurate, la quantità di dati deve corrispondere alla finestra di contesto che viene impostato durante l'addestramento del modello. Ad esempio, se la finestra di contesto è di 14 giorni, fornisci almeno 14 giorni di dati storici. Se fornisci meno dati, Vertex AI completa i dati con valori vuoti.
• La previsione inizia nella prima riga di una serie temporale (ordinata per data) con un valore nullo nella colonna di destinazione. Il valore nullo deve essere continuo all'interno delle serie temporali. Ad esempio, se la colonna di destinazione è ordinata in base al tempo, non puoi avere qualcosa come 1, 2, null, 3, 4, null, null per una singola serie temporale. Per i file CSV, Vertex AI considera una stringa vuota come nulla, mentre per BigQuery è considerata nulla. sono supportati in modo nativo.

Tabella BigQuery

Se scegli una tabella BigQuery come input, devi assicurarti di quanto segue:

• Le tabelle BigQuery che fungono da origine dati non devono essere più grandi di 100 GB.
• Se la tabella si trova in un progetto diverso, devi concedere il ruolo BigQuery Data Editor all'account di servizio Vertex AI in quel progetto.

File CSV

Se scegli un oggetto CSV in Cloud Storage come input, devi assicurarti che seguenti:

• L'origine dati deve iniziare con una riga di intestazione con i nomi delle colonne.
• Ogni oggetto dell'origine dati non deve essere più grande di 10 GB. Puoi includere più file, fino a un massimo di 100 GB.
• Se il bucket Cloud Storage si trova in un progetto diverso, devi concedere la classe il ruolo Storage Object Creator all'account di servizio Vertex AI in per il progetto.
• È necessario racchiudere tutte le stringhe tra virgolette doppie (").

Formato di output

Il formato di output della richiesta di previsione batch non deve essere necessariamente lo stesso come formato che hai utilizzato per l'input. Ad esempio, se hai utilizzato la tabella BigQuery come input, puoi generare i risultati di previsione in un oggetto CSV in Cloud Storage.

Effettua una richiesta di previsione batch al tuo modello

Per effettuare richieste di previsione batch, puoi utilizzare la console Google Cloud o l'API Vertex AI. L'origine dati di input può essere costituita da oggetti CSV archiviati in nel bucket Cloud Storage o nelle tabelle BigQuery. A seconda della quantità di dati inviati come input, un'attività di previsione batch può richiedere un po' di tempo per essere completata.

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

2. Fai clic su Crea per aprire la finestra Nuova previsione batch.
3. 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 una previsione batch.
   3. In Versione, seleziona la versione del modello.
   4. In Seleziona origine, scegli se i dati di input dell'origine sono un file CSV su Cloud Storage o una tabella in BigQuery.
      • Per i file CSV, specifica la posizione di Cloud Storage in cui si trova il file di input CSV.
      • Per le tabelle BigQuery, specifica l'ID progetto in cui automaticamente la posizione della tabella, l'ID del set di dati BigQuery ID tabella o vista BigQuery.
   5. Per Output di previsione batch, seleziona CSV o BigQuery.
      • Per CSV, specifica il bucket Cloud Storage in cui Vertex AI archivia l'output.
      • Per BigQuery, puoi specificare un ID progetto o un set di dati esistente:
        • Per specificare l'ID progetto, inseriscilo nel campo ID progetto Google Cloud. Vertex AI crea un nuovo output per te.
        • Per specificare un set di dati esistente, inserisci il relativo percorso BigQuery nel campo ID progetto Google Cloud, ad esempio bq://projectid.datasetid.
      • Facoltativo. Se la destinazione di output è BigQuery o JSONL su Cloud Storage, puoi abilitare le attribuzioni delle caratteristiche oltre alle previsioni. Per farlo, seleziona Attiva le attribuzioni delle caratteristiche per questo modello. Attribuzioni delle caratteristiche non sono supportati per il formato CSV su Cloud Storage. Scopri di più.
4. (Facoltativo) Monitoraggio del modello l'analisi delle previsioni batch è disponibile in Anteprima. Consulta le Prerequisiti per aggiungere la configurazione del rilevamento del disallineamento al tuo batch un job di previsione.
   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 a cui attivare gli avvisi.
   4. Per 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 Cloud Monitoring per ricevere avvisi quando un modello supera una soglia di avviso. Puoi selezionare i canali di Cloud Monitoring esistenti o crearne uno nuovo facendo clic su Gestisci canali di notifica. La console supporta le notifiche PagerDuty, Slack e Pub/Sub i canali di notifica.
5. Fai clic su Crea.

API: BigQuery

REST

Utilizza il metodo batchPredictionJobs.create per richiedere una previsione batch.

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 batch. Ad esempio, us-central1.
• PROJECT_ID: il tuo ID progetto
• BATCH_JOB_NAME: nome visualizzato per il job batch
• MODEL_ID: l'ID del modello da utilizzare per fare previsioni
• INPUT_URI: riferimento all'origine dati BigQuery. Nel modulo:

  bq://bqprojectId.bqDatasetId.bqTableId
  

• OUTPUT_URI: riferimento alla destinazione BigQuery (dove verranno scritti le previsioni). Specifica l'ID progetto e, facoltativamente, e un ID set di dati esistente. Utilizza il seguente modulo:

  bq://bqprojectId.bqDatasetId

  Se specifichi solo l'ID progetto, Vertex AI crea un nuovo set di dati di output. Utilizza il seguente modulo:

  bq://bqprojectId

• GENERATE_EXPLANATION: il valore predefinito è false. Impostalo su true per attivare l'opzione attribuzioni delle caratteristiche. Per scoprire di più, consulta Attribuzione delle funzionalità per le previsioni.

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": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list

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

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

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_ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
        "outputUri": bq://12345
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  },
  "outputInfo": {
    "bigqueryOutputDataset": "bq://12345.reg_model_2020_10_02_06_04
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-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.

Nel seguente esempio, sostituisci INSTANCES_FORMAT e PREDICTIONS_FORMAT con "bigquery". Per sapere come sostituire l'altro segnaposto, vedi la sezione "REST e Scheda CMD LINE" di questa sezione.

import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.BigQueryDestination;
import com.google.cloud.aiplatform.v1.BigQuerySource;
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.ModelName;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateBatchPredictionJobBigquerySample {

  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 bigquerySourceInputUri = "BIGQUERY_SOURCE_INPUT_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String bigqueryDestinationOutputUri = "BIGQUERY_DESTINATION_OUTPUT_URI";
    createBatchPredictionJobBigquerySample(
        project,
        displayName,
        modelName,
        instancesFormat,
        bigquerySourceInputUri,
        predictionsFormat,
        bigqueryDestinationOutputUri);
  }

  static void createBatchPredictionJobBigquerySample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String bigquerySourceInputUri,
      String predictionsFormat,
      String bigqueryDestinationOutputUri)
      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)) {
      JsonObject jsonModelParameters = new JsonObject();
      Value.Builder modelParametersBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonModelParameters.toString(), modelParametersBuilder);
      Value modelParameters = modelParametersBuilder.build();
      BigQuerySource bigquerySource =
          BigQuerySource.newBuilder().setInputUri(bigquerySourceInputUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setBigquerySource(bigquerySource)
              .build();
      BigQueryDestination bigqueryDestination =
          BigQueryDestination.newBuilder().setOutputUri(bigqueryDestinationOutputUri).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setBigqueryDestination(bigqueryDestination)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .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_bigquery_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    bigquery_source: str,
    bigquery_destination_prefix: str,
    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,
        bigquery_source=bigquery_source,
        bigquery_destination_prefix=bigquery_destination_prefix,
        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

API: Cloud Storage

REST

Puoi utilizzare batchPredictionJobs.create per richiedere una previsione batch.

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 batch. Ad esempio, us-central1.
• PROJECT_ID: il tuo ID progetto
• BATCH_JOB_NAME: nome visualizzato per il job batch
• MODEL_ID: l'ID del modello da utilizzare per fare previsioni
• URI: percorsi (URI) dei bucket Cloud Storage contenenti i dati di addestramento. Può essercene più di uno. Ogni URI ha il seguente formato:

  gs://bucketName/pathToFileName
  

• OUTPUT_URI_PREFIX: percorso di una destinazione Cloud Storage in cui verranno scritti i previsti. Vertex AI scrive le previsioni batch in una sottodirectory con timestamp di questo percorso. Imposta questo valore su una stringa con il formato seguente:

  gs://bucketName/pathToOutputDirectory
  

• GENERATE_EXPLANATION: il valore predefinito è false. Imposta il valore true per attivare le attribuzioni delle funzionalità. Questa opzione è disponibile solo se la destinazione di output è JSONL. Le attribuzioni delle caratteristiche non sono supportate per i file CSV su Cloud Storage. Per saperne di più, vedi Attribuzioni delle caratteristiche per la 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": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

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

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list

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_ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        "gs://bp_bucket/reg_mode_test"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  }
  "outputInfo": {
    "gcsOutputDataset": "OUTPUT_URI_PREFIX/prediction-batch_job_1 202005291958-2020-09-30T02:58:44.341643Z"
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-30T02:58:44.341643Z",
}

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_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    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,
        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

Recuperare i risultati della previsione batch

Vertex AI invia l'output delle previsioni batch alla destinazione specificato, che può essere BigQuery o Cloud Storage.

L'output di Cloud Storage per le attribuzioni delle caratteristiche non è attualmente supportato.

BigQuery

Set di dati di output

Se utilizzi BigQuery, l'output della previsione batch viene memorizzato in un set di dati di output. Se hai fornito un set di dati a Vertex AI, il nome del set di dati (BQ_DATASET_NAME) è quello che hai fornito in precedenza. Se non hai fornito un set di dati di output, Vertex AI ne ha creato uno per te. Per trovare il nome (BQ_DATASET_NAME), segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina Previsioni batch di Vertex AI.

   Vai alla pagina Previsioni batch

2. Seleziona la previsione che hai creato.
3. Il set di dati di output si trova in Località esportazione. Il nome del set di dati è formattato come segue: prediction_MODEL_NAME_TIMESTAMP

Tabelle di output

Il set di dati di output contiene una o più delle seguenti tre tabelle di output:

• Tabella delle previsioni
  

  Questa tabella contiene una riga per ogni riga dei dati di input in cui è stata richiesta una previsione (ovvero dove TARGET_COLUMN_NAME = null). Ad esempio, se l'input includeva 14 voci null per il (ad esempio le vendite per i prossimi 14 giorni), la tua richiesta di previsione restituisce 14 righe, ovvero il numero di vendite per ogni giorno. Se la richiesta di previsione supera l'orizzonte di previsione del modello, Vertex AI restituisce solo le previsioni fino all'orizzonte di previsione.

• Tabella di convalida degli errori
  

  Questa tabella contiene una riga per ogni errore non critico riscontrato durante la fase di aggregazione che si verifica prima della previsione batch. Ogni errore non critico corrisponde a una riga nei dati di input per la quale Vertex AI non ha potuto restituire una previsione.

• Tabella degli errori
  

  Questa tabella contiene una riga per ogni errore non critico riscontrato durante la previsione batch. Ogni errore non critico corrisponde a una riga nei dati di input per la quale Vertex AI non ha potuto restituire una previsione.

Tabella delle previsioni

Il nome della tabella (BQ_PREDICTIONS_TABLE_NAME) è formato dall'aggiunta di "predictions_" al timestamp dell'avvio del job di previsione batch: predictions_TIMESTAMP

Per recuperare la tabella delle previsioni:

1. Nella console, vai alla pagina BigQuery.
   Vai a BigQuery
2. Esegui questa query:

   SELECT * FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME
         

Vertex AI memorizza le previsioni nella colonna predicted_TARGET_COLUMN_NAME.value.

Se hai addestrato un modello con Temporal Fusion Transformer (TFT), puoi trovare l'output di interpretabilità del TFT nel predicted_TARGET_COLUMN_NAME.tft_feature_importance.

Questa colonna è ulteriormente suddivisa come segue:

• context_columns: caratteristiche di previsione i cui valori della finestra di contesto vengono utilizzati come input per l'encoder LSTM (Long Short-Term Memory) di TFT.
• context_weights: i pesi di importanza delle caratteristiche associati a ciascuno dei context_columns per l'istanza prevista.
• horizon_columns: funzionalità di previsione la cui orizzonte di previsione vengono utilizzati come input per il decoder TFT Long-Term Memory (LSTM).
• horizon_weights: i pesi di importanza delle caratteristiche associati a ciascuno dei horizon_columns per l'istanza prevista.
• attribute_columns: caratteristiche di previsione invariate nel tempo.
• attribute_weights: i pesi associati a ciascuno degli elementi attribute_columns.

Se il tuo modello è ottimizzato per la perdita di quantili e l'insieme di quantili include mediana, predicted_TARGET_COLUMN_NAME.value è il valore della previsione mediana. In caso contrario, predicted_TARGET_COLUMN_NAME.value è il valore di previsione al quantile più basso nel set. Ad esempio, se il tuo insieme di quantili è [0.1, 0.5, 0.9], value è la previsione per il quantile 0.5. Se il tuo set di quantili è [0.1, 0.9], value è la previsione per il quantile 0.1.

Inoltre, Vertex AI archivia i valori dei quantili e le previsioni nelle seguenti colonne:

• predicted_TARGET_COLUMN_NAME.quantile_values: i valori del parametro quantili, che vengono impostati durante l'addestramento del modello. Ad esempio, possono essere 0.1, 0.5 e 0.9.
• predicted_TARGET_COLUMN_NAME.quantile_predictions: il i valori di previsione associati ai valori dei quantili.

Se il modello utilizza l'inferenza probabilistica, predicted_TARGET_COLUMN_NAME.value contiene il minimo dell'obiettivo di ottimizzazione. Ad esempio, se il tuo obiettivo di ottimizzazione è minimize-rmse, predicted_TARGET_COLUMN_NAME.value contiene il valore medio. Se è minimize-mae, predicted_TARGET_COLUMN_NAME.value contiene il valore mediano.

Se il modello utilizza l'inferenza probabilistica con i quantili, Vertex AI archivia il quantile valori e previsioni nelle seguenti colonne:

• predicted_TARGET_COLUMN_NAME.quantile_values: i valori del parametro quantili, che vengono impostati durante l'addestramento del modello. Ad esempio, possono essere 0.1, 0.5 e 0.9.
• predicted_TARGET_COLUMN_NAME.quantile_predictions: i valori di previsione associati ai valori del quantile.

Se hai attivato le attribuzioni delle funzionalità, puoi trovarle anche nella tabella delle predizioni. Per accedere alle attribuzioni di un elemento BQ_FEATURE_NAME, esegui questa query:

SELECT explanation.attributions[OFFSET(0)].featureAttributions.BQ_FEATURE_NAME FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME
  

Per saperne di più, vedi Attribuzioni delle caratteristiche per la previsione.

Tabella di convalida degli errori

Il nome della tabella (BQ_ERRORS_VALIDATION_TABLE_NAME) viene creato aggiungendo "errors_validation" con il timestamp relativo al momento in cui job di previsione batch avviato: errors_validation_TIMESTAMP

Per recuperare la tabella di convalida degli errori:

1. Nella console, vai alla pagina BigQuery.
   Vai a BigQuery
2. Esegui questa query:

   SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_VALIDATION_TABLE_NAME
         

Il messaggio di errore è archiviato nella seguente colonna:

• errors_TARGET_COLUMN_NAME

Tabella degli errori

Il nome della tabella (BQ_ERRORS_TABLE_NAME) è formato dall'aggiunta di "errors_" al timestamp dell'avvio del job di previsione batch: errors_TIMESTAMP

Per recuperare la tabella di convalida degli errori:

1. Nella console, vai alla pagina BigQuery.
   Vai a BigQuery
2. Esegui questa query:

   SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_TABLE_NAME
         

Gli errori vengono memorizzati nelle seguenti colonne:

• errors_TARGET_COLUMN_NAME.code
• errors_TARGET_COLUMN_NAME.message

Cloud Storage

Se hai specificato Cloud Storage come destinazione di output, i risultati della richiesta di previsione batch vengono restituiti come oggetti CSV in un nel bucket specificato. Il nome della cartella è il nome del modello, preceduto da "prediction-" e seguito dal timestamp dell'inizio del job di previsione batch. Puoi trovare l'API Cloud Storage nome cartella nella scheda Previsioni batch del tuo modello.

La cartella Cloud Storage contiene due tipi di oggetti:

• Oggetti di previsione

  Gli oggetti di previsione sono denominati "predictions_1.csv", "predictions_2.csv" e così via. Contengono una riga di intestazione con i nomi delle colonne e una riga per viene restituito ogni previsione. Il numero di valori della previsione dipende dall'input della previsione e orizzonte di previsione. Ad esempio, se l'input includeva 14 voci null per il (ad esempio le vendite per i prossimi 14 giorni), la tua richiesta di previsione restituisce 14 righe, ovvero il numero di vendite per ogni giorno. Se la richiesta di previsione supera l'orizzonte di previsione del modello, Vertex AI restituisce solo le previsioni fino all'orizzonte di previsione.

  I valori di previsione vengono restituiti in una colonna denominato "predicted_TARGET_COLUMN_NAME". Per quantile le previsioni, la colonna di output contiene le previsioni dei quantili i valori dei quantili nel formato JSON.

• Oggetti di errore

  Gli oggetti errore si chiamano "errors_1.csv", "errors_2.csv" e così via. Contengono una riga di intestazione e una riga per ogni riga nei dati di input che Vertex AI non può restituire una previsione (ad esempio, se un caratteristica non nullo era nullo) per.

Nota: se i risultati sono di grandi dimensioni, vengono suddivisi in più oggetti.

Esempi di query di attribuzione delle caratteristiche in BigQuery

Esempio 1: determinare le attribuzioni per una singola previsione

Prendi in considerazione la seguente domanda:

In che misura un annuncio di un prodotto ha aumentato le vendite previste il 24 novembre in un determinato negozio?

La query corrispondente è la seguente:

SELECT
  * EXCEPT(explanation, predicted_sales),
  ROUND(predicted_sales.value, 2) AS predicted_sales,
  ROUND(
    explanation.attributions[OFFSET(0)].featureAttributions.advertisement,
    2
  ) AS attribution_advertisement
FROM
  `project.dataset.predictions`
WHERE
  product = 'product_0'
  AND store = 'store_0'
  AND date = '2019-11-24'

Esempio 2: determinare l'importanza delle caratteristiche globali

Prendi in considerazione la seguente domanda:

In che misura ciascuna funzionalità ha contribuito alle vendite previste nel complesso?

Puoi calcolare manualmente l'importanza delle caratteristiche a livello globale aggregando le attribuzioni dell'importanza delle caratteristiche locali. La query corrispondente è la seguente:

WITH

/*
* Aggregate from (id, date) level attributions to global feature importance.
*/
attributions_aggregated AS (
 SELECT
   SUM(ABS(attributions.featureAttributions.date)) AS date,
   SUM(ABS(attributions.featureAttributions.advertisement)) AS advertisement,
   SUM(ABS(attributions.featureAttributions.holiday)) AS holiday,
   SUM(ABS(attributions.featureAttributions.sales)) AS sales,
   SUM(ABS(attributions.featureAttributions.store)) AS store,
   SUM(ABS(attributions.featureAttributions.product)) AS product,
 FROM
   project.dataset.predictions,
   UNNEST(explanation.attributions) AS attributions

),

/*
* Calculate the normalization constant for global feature importance.
*/
attributions_aggregated_with_total AS (
 SELECT
   *,
   date + advertisement + holiday + sales + store + product AS total
 FROM
   attributions_aggregated
)

/*
* Calculate the normalized global feature importance.
*/
SELECT
 ROUND(date / total, 2) AS date,
 ROUND(advertisement / total, 2) AS advertisement,
 ROUND(holiday / total, 2) AS holiday,
 ROUND(sales / total, 2) AS sales,
 ROUND(store / total, 2) AS store,
 ROUND(product / total, 2) AS product,
FROM
 attributions_aggregated_with_total

Esempio di output di previsione batch in BigQuery

In un set di dati di esempio sulle vendite di liquori, nella città di "Ida Grove" ci sono quattro negozi: "Ida Grove Food Pride", "Discount Liquors of Ida Grove", "Casey's General Store #3757" e "Brew Ida Grove". store_name è il series identifier e tre dei quattro negozi richiedono le previsioni per la colonna target sale_dollars. Viene generato un errore di convalida perché non è stata richiesta alcuna previsione per "Discount Liquors of Ida Grove".

Di seguito è riportato un estratto del set di dati di input utilizzato per la previsione:

Di seguito è riportato un estratto dei risultati della previsione:

Di seguito è riportato un estratto degli errori di convalida:

Esempio di output di previsione batch per un modello ottimizzato per la perdita di quantili

L'esempio seguente è l'output della previsione in batch per un modello ottimizzato per la perdita quantile. In questo questo scenario, il modello di previsione ha previsto le vendite per i 14 giorni successivi per ogni .

I valori del quantile sono riportati nella colonna predicted_Sales.quantile_values. In questo esempio, il modello ha previsto i valori ai quantili 0.1, 0.5 e 0.9.

I valori della previsione sono indicati nella colonna predicted_Sales.quantile_predictions. Si tratta di un array di valori delle vendite, mappati ai valori dei quantili nella Colonna predicted_Sales.quantile_values. Nella prima riga vediamo che la probabilità che il valore delle vendite sia inferiore a 4484.04 è del 10%. La probabilità che il valore delle vendite sia inferiore a 5615.64 è del 50%. La probabilità che il valore delle vendite sia inferiore a 6853.29 è il 90%. La previsione per la prima riga, rappresentata come un singolo valore, è 5615.64.