Ampia copertura Previsioni batch dettagliate

Questa pagina mostra come effettuare una richiesta di previsione batch al modello di classificazione o regressione addestrato utilizzando la console Google Cloud o l'API Vertex AI.

Una richiesta di previsione batch è una richiesta asincrona (al contrario di previsione online, che è una richiesta sincrona). Le previsioni batch vengono richieste direttamente senza la necessità di eseguire il deployment del modello su un endpoint. Per i dati tabulari, utilizza le previsioni batch quando non hai bisogno di una risposta immediata e vuoi elaborare i dati accumulati utilizzando una singola richiesta.

Per effettuare una richiesta di previsione batch, specifica un'origine di input e un formato di output in cui Vertex AI memorizza i risultati delle predizioni.

Prima di iniziare

Prima di poter effettuare una richiesta di previsione batch, è necessario addestrare un modello.

Dati di input

I dati di input per le richieste di previsione batch sono i dati utilizzati dal modello per fare le previsioni. Per i modelli di classificazione o regressione, puoi fornire input in uno dei due formati:

  • tabelle BigQuery
  • Oggetti CSV in Cloud Storage

Ti consigliamo di utilizzare lo stesso formato per i dati di input che hai utilizzato per l'addestramento del modello. Ad esempio, se hai addestrato il modello utilizzando i dati in BigQuery, è meglio utilizzare una tabella BigQuery come input per la previsione batch. Poiché Vertex AI tratta tutti i campi di input CSV come le stringhe, la combinazione dei formati dei 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 non erano presenti nei dati di addestramento o che erano presenti nei dati di addestramento, ma escluse dall'uso per l'addestramento. Queste colonne aggiuntive sono incluse nell'output, ma non influiscono sui risultati della previsione.

Requisiti dei dati di input

Tabella BigQuery

Se scegli una tabella BigQuery come input, devi assicurarti che seguenti:

  • 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 alla classe 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 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 il ruolo Storage Object Creator all'account di servizio Vertex AI in quel progetto.
  • Devi racchiudi 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 utilizzavi come input, puoi inviare i risultati in un oggetto CSV in Cloud Storage.

Effettua una richiesta di previsione batch al 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 per questa previsione batch.
    3. In Versione, seleziona la versione del modello da utilizzare per questa previsione batch.
    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, seleziona CSV o BigQuery.
      • Per CSV, specifica il bucket Cloud Storage in cui Vertex AI memorizza l'output.
      • Per BigQuery, puoi specificare un ID progetto o un set di dati esistente:
        • Per specificare l'ID progetto, inserisci l'ID progetto nella casella ID progetto 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.
  4. (Facoltativo) L'analisi del monitoraggio dei modelli per le 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 rispetto alle quali 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 i canali di 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, apporta 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 il valore vengono scritte le previsioni). Specifica l'ID progetto e, facoltativamente, un ID set di dati esistente. Se specifichi solo l'ID progetto, Vertex AI crea un nuovo set di dati di output. Utilizza il seguente modulo: 
    bq://bqprojectId.bqDatasetId
  • MACHINE_TYPE: le risorse di calcolo da utilizzare per questo job di previsione batch. Scopri di più.
  • STARTING_REPLICA_COUNT: il numero iniziale di nodi per questo job di previsione batch. Il numero di nodi può essere aumentato o diminuito in base al carico fino al numero massimo di nodi, ma non scenderà mai al di sotto di questo numero.
  • MAX_REPLICA_COUNT: il numero massimo di nodi per questo job di previsione batch. La il numero di nodi può essere aumentato o diminuito in base al carico, ma non supererà mai massimo. (Facoltativo) Il valore predefinito è 10.

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": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

}

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_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
  },
  "generateExplanation": false,
  "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 autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

Nell'esempio seguente, sostituisci INSTANCES_FORMAT e PREDICTIONS_FORMAT con "bigquery". Per scoprire come sostituire gli altri sostituenti, consulta la scheda "REST & 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.

Nell'esempio seguente, imposta "instances_format" e "predictions_format" in "bigquery". Per scoprire come impostare gli altri parametri, consulta REST e Scheda CMD LINE" di questa sezione. 
from google.cloud import aiplatform_v1beta1
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value


def create_batch_prediction_job_bigquery_sample(
    project: str,
    display_name: str,
    model_name: str,
    instances_format: str,
    bigquery_source_input_uri: str,
    predictions_format: str,
    bigquery_destination_output_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform_v1beta1.JobServiceClient(client_options=client_options)
    model_parameters_dict = {}
    model_parameters = json_format.ParseDict(model_parameters_dict, Value())

    batch_prediction_job = {
        "display_name": display_name,
        # Format: 'projects/{project}/locations/{location}/models/{model_id}'
        "model": model_name,
        "model_parameters": model_parameters,
        "input_config": {
            "instances_format": instances_format,
            "bigquery_source": {"input_uri": bigquery_source_input_uri},
        },
        "output_config": {
            "predictions_format": predictions_format,
            "bigquery_destination": {"output_uri": bigquery_destination_output_uri},
        },
        # optional
        "generate_explanation": True,
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_batch_prediction_job(
        parent=parent, batch_prediction_job=batch_prediction_job
    )
    print("response:", response)

API: Cloud Storage

REST

Puoi utilizzare batchPredictionJobs.create per richiedere una previsione batch.

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

  • LOCATION_ID: regione in cui è archiviato il modello e viene eseguito il job di previsione 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. Possono essere presenti più di uno. Ogni URI ha il seguente formato: 
    gs://bucketName/pathToFileName
  • OUTPUT_URI_PREFIX: percorso di una destinazione Cloud Storage in cui vengono scritte le previsioni. Vertex AI scrive le previsioni batch in un campo sottodirectory di questo percorso. Imposta questo valore su una stringa con il formato seguente: 
    gs://bucketName/pathToOutputDirectory
  • MACHINE_TYPE: le risorse della macchina da utilizzare per questo job di previsione batch. Scopri di più.
  • STARTING_REPLICA_COUNT: il numero iniziale di nodi per questo job di previsione batch. Il numero di nodi può essere aumentato o diminuito in base al carico fino al numero massimo di nodi, ma non scenderà mai al di sotto di questo numero.
  • MAX_REPLICA_COUNT: il numero massimo di nodi per questo job di previsione batch. La il numero di nodi può essere aumentato o diminuito in base al carico, ma non supererà mai massimo. (Facoltativo) Il valore predefinito è 10.

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": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

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

PowerShell

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

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

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

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT__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
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  }
  "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",
}

Recuperare i risultati delle previsioni batch

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

BigQuery

Set di dati di output

Se utilizzi BigQuery, l'output della previsione batch viene archiviato in un set di dati di output. Se avessi fornito su Vertex AI, il nome del set di dati (BQ_DATASET_NAME) è il nome che hai fornito in precedenza. Se non hai fornito un set di dati di output, Vertex AI ne ha creato uno per te. Puoi trovare il nome (BQ_DATASET_NAME) seguendo 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 è indicato in Posizione di 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).

  • 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 da aggiungendo "predictions_" con il timestamp relativo alla data e all'ora della previsione batch job avviato: predictions_TIMESTAMP

Per recuperare le previsioni, vai alla pagina BigQuery.

Vai a BigQuery

Il formato della query dipende dal tipo di modello:

Classificazione:

SELECT predicted_TARGET_COLUMN_NAME.classes AS classes,
predicted_TARGET_COLUMN_NAME.scores AS scores
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

classes è l'elenco delle potenziali classi, mentre scores è l'elenco i punteggi di confidenza corrispondenti.

Regressione:

SELECT predicted_TARGET_COLUMN_NAME.value
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

Se il modello utilizza l'inferenza probabilistica, predicted_TARGET_COLUMN_NAME.value contiene il ridotto a icona del obiettivo di ottimizzazione. Ad esempio, se l'obiettivo dell'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 tuo modello utilizza l'inferenza probabilistica con i quantili, Vertex AI fornisce valori dei quantili e previsioni oltre al minimo obiettivo di ottimizzazione. I valori del quantile vengono impostati durante l'addestramento del modello. Le predizioni quantili sono i valori di previsione associati ai valori quantili.

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 tuo modello, preceduto da "previsione-" con il timestamp che indica quando il job di previsione batch è stato avviato. Puoi trovare il nome della cartella Cloud Storage nella scheda Previsioni batch del tuo modello.

La cartella Cloud Storage contiene due tipi di oggetti:
  • Oggetti di previsione

    Gli oggetti della 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 per ogni previsione. Negli oggetti di previsione, Vertex AI restituisce i dati di previsione e crea una o più nuove colonne per i risultati di previsione in base al tipo di modello:

    • Classificazione: per ogni valore potenziale della colonna target, un valore colonna denominata TARGET_COLUMN_NAME_VALUE_score viene aggiunto ai risultati. Questa colonna contiene il punteggio, o la confidenza una stima per quel valore.
    • Regressione: il valore previsto per la riga viene restituito in una colonna. denominato predicted_TARGET_COLUMN_NAME. L'intervallo di previsione non viene restituito per l'output CSV.
  • Oggetti di errore

    Gli oggetti di errore vengono denominati "errors_1.csv", "errors_2.csv" e così via. Contengono una riga di intestazione e una riga per ogni riga dei dati di input per la quale Vertex AI non è stato in grado di restituire una previsione (ad esempio, se una funzionalità non obbligatoria era null).

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

Interpreta i risultati della previsione

Classificazione

I modelli di classificazione restituiscono un punteggio di confidenza.

Il punteggio di confidenza indica il livello di associazione di ogni modello una classe o un'etichetta con un elemento di test. Più alto è il numero, maggiore è la certezza del modello che l'etichetta debba essere applicata a quell'elemento. Sei tu a decidere quanto in alto il punteggio di confidenza deve consentire l'accettazione dei risultati del modello.

Regressione

I modelli di regressione restituiscono un valore di previsione.

Se il modello utilizza l'inferenza probabilistica, il campo value contiene il minimizzatore dell'obiettivo di ottimizzazione. Ad esempio, se lo scopo dell'ottimizzazione è minimize-rmse, il campo value contiene il valore medio. Se è minimize-mae, il campo value contiene il valore mediano.

Se il tuo modello utilizza l'inferenza probabilistica con i quantili, Vertex AI fornisce valori dei quantili e previsioni oltre al minimo obiettivo di ottimizzazione. I valori del quantile vengono impostati durante l'addestramento del modello. Le predizioni quantili sono i valori di previsione associati ai valori quantili.

Passaggi successivi