Previsioni batch

In questa pagina viene spiegato come fornire più righe di dati alle tabelle AutoML contemporaneamente e come ricevere una previsione per ogni riga.

Introduzione

Dopo aver creato (addestrato) un modello, puoi effettuare una richiesta asincrona per un gruppo di previsioni utilizzando il metodo batchPredict. Fornisci i dati di input al metodo batchPredict in formato tabella. Ogni riga fornisce valori per le funzionalità che hai addestrato al modello. Il metodo batchPredict invia tali dati al modello e restituisce previsioni per ogni riga di dati.

I modelli devono essere riaddestrati periodicamente in modo che possano continuare a fornire previsioni. Per le previsioni senza importanza della caratteristica, un modello deve essere riaddestrato ogni due anni. Per le previsioni con importanza della caratteristica, un modello deve essere addestrato ogni sei mesi.

Richiesta di una previsione batch

Per le previsioni batch, devi specificare un'origine dati e una destinazione dei risultati in una tabella BigQuery o in un file CSV in Cloud Storage. Non è necessario utilizzare la stessa tecnologia per l'origine e la destinazione. Ad esempio, potresti utilizzare BigQuery per l'origine dati e un file CSV in Cloud Storage per la destinazione dei risultati. Utilizza i passaggi appropriati tra le due attività descritte di seguito, a seconda dei requisiti.

L'origine dati deve contenere dati tabulari che includono tutte le colonne 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 di previsione, ma non vengono utilizzate per generare la previsione.

Utilizzo delle tabelle BigQuery

I nomi delle colonne e dei tipi di dati dei tuoi dati di input devono corrispondere ai dati utilizzati nei dati di addestramento. Le colonne possono essere ordinate in modo diverso rispetto ai dati di addestramento.

Requisiti della tabella BigQuery

  • Le tabelle delle origini dati BigQuery non devono superare i 100 GB.
  • Devi utilizzare un set di dati BigQuery su più aree geografiche nelle località US o EU.
  • Se la tabella si trova in un progetto diverso, devi fornire il ruolo BigQuery Data Editor all'account di servizio AutoML Tables del progetto. Scopri di più.

Richiesta della previsione batch

Console

  1. Vai alla pagina AutoML Tables in Google Cloud Console.

    Vai alla pagina Tabelle AutoML

  2. Seleziona Modelli e apri il modello che vuoi utilizzare.

  3. Seleziona la scheda Testa e utilizza.

  4. Fai clic su Previsione batch.

  5. Per Set di dati di input, seleziona Tabella da BigQuery e fornisci gli ID progetto, set di dati e tabella per l'origine dati.

  6. Per Risultato, seleziona Progetto BigQuery e fornisci l'ID progetto per la destinazione dei risultati.

  7. Se vuoi vedere in che modo ogni funzionalità ha influito sulla previsione, seleziona Genera importanza delle caratteristiche.

    La generazione dell'importanza delle caratteristiche aumenta il tempo e le risorse di calcolo necessarie per la previsione. L'importanza delle funzionalità locali non è disponibile con una destinazione dei risultati di Cloud Storage.

  8. Fai clic su Invia previsione batch per richiedere la previsione batch.

    Pagina di previsione batch di AutoML Tables

REST &CMD LINE

Puoi richiedere previsioni batch utilizzando il metodo models.batchPredict.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • endpoint: automl.googleapis.com per la località globale e eu-automl.googleapis.com per l'area geografica dell'UE.
  • project-id: il tuo ID progetto Google Cloud.
  • location: la località della risorsa: us-central1 per il mondo globale o eu per l'Unione europea.
  • model-id: l'ID del modello. Ad esempio, TBL543.
  • dataset-id: l'ID del set di dati BigQuery in cui si trovano i dati di previsione.

  • table-id: l'ID della tabella BigQuery in cui si trovano i dati di previsione.

    AutoML Tables crea una sottocartella per i risultati della previsione denominati prediction-<model_name>-<timestamp> in project-id.dataset-id.table-id.

Metodo HTTP e URL: 

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

Corpo JSON richiesta: 

{
  "inputConfig": {
    "bigquerySource": {
      "inputUri": "bq://project-id.dataset-id.table-id"
    },
  },
  "outputConfig": {
    "bigqueryDestination": {
      "outputUri": "bq://project-id"
    },
  },
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

Curling

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict"

PowerShell

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

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

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict" | Select-Object -Expand Content
La previsione batch è un'operazione a lunga esecuzione. Puoi eseguire un sondaggio per conoscere lo stato dell'operazione o attendere che torni. Scopri di più.

Per ottenere l'importanza delle funzionalità locali, aggiungi il parametro feature_importance ai dati della richiesta. Per saperne di più, consulta importanza delle funzionalità locali.

Java

Se le risorse si trovano nell'area geografica UE, devi impostare esplicitamente l'endpoint. Scopri di più. 

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.BigQueryDestination;
import com.google.cloud.automl.v1beta1.BigQuerySource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class TablesBatchPredictBigQuery {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "bq://YOUR_PROJECT_ID.bqDatasetID.bqTableId";
    String outputUri = "bq://YOUR_PROJECT_ID";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from BigQuery
      BigQuerySource bigQuerySource = BigQuerySource.newBuilder().setInputUri(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setBigquerySource(bigQuerySource).build();

      // Configure where to store the output in BigQuery
      BigQueryDestination bigQueryDestination =
          BigQueryDestination.newBuilder().setOutputUri(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setBigqueryDestination(bigQueryDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      BatchPredictResult response = future.get();
      System.out.println("Batch Prediction results saved to BigQuery.");
    }
  }
}

Python

La libreria client per AutoML Tables include metodi Python aggiuntivi che semplificano l'utilizzo dell'API AutoML Tables. Questi metodi si riferiscono a set di dati e modelli in base al nome anziché all'ID. I nomi del set di dati e del modello devono essere univoci. Per ulteriori informazioni, consulta la sezione Riferimento client.

Se le risorse si trovano nell'area geografica UE, devi impostare esplicitamente l'endpoint. Scopri di più. 

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# bq_input_uri = 'bq://my-project.my-dataset.my-table'
# bq_output_uri = 'bq://my-project'
# params = {}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

# Query model
response = client.batch_predict(bigquery_input_uri=bq_input_uri,
                                bigquery_output_uri=bq_output_uri,
                                model_display_name=model_display_name,
                                params=params)
print("Making batch prediction... ")
# `response` is a async operation descriptor,
# you can register a callback for the operation to complete via `add_done_callback`:
# def callback(operation_future):
#   result = operation_future.result()
# response.add_done_callback(callback)
#
# or block the thread polling for the operation's results:
response.result()
# AutoML puts predictions in a newly generated dataset with a name by a mask "prediction_" + model_id + "_" + timestamp
# here's how to get the dataset name:
dataset_name = response.metadata.batch_predict_details.output_info.bigquery_output_dataset

print("Batch prediction complete.\nResults are in '{}' dataset.\n{}".format(
    dataset_name, response.metadata))

Utilizzo di file CSV in Cloud Storage

I nomi delle colonne e dei tipi di dati dei tuoi dati di input devono corrispondere ai dati utilizzati nei dati di addestramento. Le colonne possono essere ordinate in modo diverso rispetto ai dati di addestramento.

Requisiti dei file CSV

  • La prima riga dell'origine dati deve contenere il nome delle colonne.

  • Le dimensioni di ogni file di origine dati non devono superare i 10 GB.

    Puoi includere più file, fino a un massimo di 100 GB.

  • Il bucket Cloud Storage deve essere conforme ai requisiti per i bucket.

  • Se il bucket Cloud Storage si trova in un progetto diverso da quello in cui utilizzi AutoML Tables, devi fornire il ruolo Storage Object Creator all'account di servizio AutoML Tables in tale progetto. Scopri di più.

Console

  1. Vai alla pagina AutoML Tables in Google Cloud Console.

    Vai alla pagina Tabelle AutoML

  2. Seleziona Modelli e apri il modello che vuoi utilizzare.

  3. Seleziona la scheda Testa e utilizza.

  4. Fai clic su Previsione batch.

  5. Per Set di dati di input, seleziona CSV da Cloud Storage e fornisci l'URI del bucket per la tua origine dati.

  6. In Risultato, seleziona Bucket Cloud Storage e fornisci l'URI del bucket per il tuo bucket di destinazione.

  7. Se vuoi vedere in che modo ogni funzionalità ha influito sulla previsione, seleziona Genera importanza delle caratteristiche.

    La generazione dell'importanza delle caratteristiche aumenta il tempo e le risorse di calcolo necessarie per la previsione. L'importanza delle funzionalità locali non è disponibile con una destinazione dei risultati di Cloud Storage.

  8. Fai clic su Invia previsione batch per richiedere la previsione batch.

    Pagina di previsione batch di AutoML Tables

REST &CMD LINE

Puoi richiedere previsioni batch utilizzando il metodo models.batchPredict.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • endpoint: automl.googleapis.com per la località globale e eu-automl.googleapis.com per l'area geografica dell'UE.
  • project-id: il tuo ID progetto Google Cloud.
  • location: la località della risorsa: us-central1 per il mondo globale o eu per l'Unione europea.
  • model-id: l'ID del modello. Ad esempio, TBL543.
  • input-bucket-name: il nome del bucket Cloud Storage in cui si trovano i dati di previsione.
  • input-directory-name: il nome della directory Cloud Storage in cui si trovano i dati di previsione.
  • object-name: nome dell'oggetto Cloud Storage in cui si trovano i dati di previsione.
  • output-bucket-name: il nome del bucket Cloud Storage per i risultati della previsione.
  • output-directory-name: nome della directory di Cloud Storage per i risultati della previsione.

    AutoML Tables crea una sottocartella per i risultati della previsione denominati prediction-<model_name>-<timestamp> in gs://output-bucket-name/output-directory-name. Devi disporre delle autorizzazioni di scrittura per questo percorso.

Metodo HTTP e URL: 

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

Corpo JSON richiesta: 

{
  "inputConfig": {
    "gcsSource": {
      "inputUris": [
        "gs://input-bucket-name/input-directory-name/object-name.csv"
      ]
    },
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://output-bucket-name/output-directory-name"
     },
  },
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

Curling

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict"

PowerShell

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

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

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict" | Select-Object -Expand Content
La previsione batch è un'operazione a lunga esecuzione. Puoi eseguire un sondaggio per conoscere lo stato dell'operazione o attendere che torni. Scopri di più.

Per ottenere l'importanza delle funzionalità locali, aggiungi il parametro feature_importance ai dati della richiesta. Per saperne di più, consulta importanza delle funzionalità locali.

Java

Se le risorse si trovano nell'area geografica UE, devi impostare esplicitamente l'endpoint. Scopri di più. 

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.GcsDestination;
import com.google.cloud.automl.v1beta1.GcsSource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class BatchPredict {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl";
    String outputUri = "gs://YOUR_BUCKET_ID/path_to_save_results/";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from a GCS bucket
      GcsSource gcsSource = GcsSource.newBuilder().addInputUris(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setGcsSource(gcsSource).build();

      // Configure where to store the output in a GCS bucket
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setGcsDestination(gcsDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      BatchPredictResult response = future.get();
      System.out.println("Batch Prediction results saved to specified Cloud Storage bucket.");
    }
  }
}

Node.js

Se le risorse si trovano nell'area geografica UE, devi impostare esplicitamente l'endpoint. Scopri di più. 


/**
 * Demonstrates using the AutoML client to request prediction from
 * automl tables using GCS.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const modelId = '[MODEL_ID]' e.g., "TBL4704590352927948800";
// const inputUri = '[GCS_PATH]' e.g., "gs://<bucket-name>/<csv file>",
// `The Google Cloud Storage URI containing the inputs`;
// const outputUriPrefix = '[GCS_PATH]'
// e.g., "gs://<bucket-name>/<folder-name>",
// `The destination Google Cloud Storage URI for storing outputs`;

const automl = require('@google-cloud/automl');

// Create client for prediction service.
const automlClient = new automl.v1beta1.PredictionServiceClient();

// Get the full path of the model.
const modelFullId = automlClient.modelPath(projectId, computeRegion, modelId);

async function batchPredict() {
  // Construct request
  const inputConfig = {
    gcsSource: {
      inputUris: [inputUri],
    },
  };

  // Get the Google Cloud Storage output URI.
  const outputConfig = {
    gcsDestination: {
      outputUriPrefix: outputUriPrefix,
    },
  };

  const [, operation] = await automlClient.batchPredict({
    name: modelFullId,
    inputConfig: inputConfig,
    outputConfig: outputConfig,
  });

  // Get the latest state of long-running operation.
  console.log(`Operation name: ${operation.name}`);
  return operation;
}

batchPredict();

Python

La libreria client per AutoML Tables include metodi Python aggiuntivi che semplificano l'utilizzo dell'API AutoML Tables. Questi metodi si riferiscono a set di dati e modelli in base al nome anziché all'ID. I nomi del set di dati e del modello devono essere univoci. Per ulteriori informazioni, consulta la sezione Riferimento client.

Se le risorse si trovano nell'area geografica UE, devi impostare esplicitamente l'endpoint. Scopri di più. 

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# gcs_input_uri = 'gs://YOUR_BUCKET_ID/path_to_your_input_csv'
# gcs_output_uri = 'gs://YOUR_BUCKET_ID/path_to_save_results/'
# params = {}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

# Query model
response = client.batch_predict(
    gcs_input_uris=gcs_input_uri,
    gcs_output_uri_prefix=gcs_output_uri,
    model_display_name=model_display_name,
    params=params
)
print("Making batch prediction... ")
# `response` is a async operation descriptor,
# you can register a callback for the operation to complete via `add_done_callback`:
# def callback(operation_future):
#   result = operation_future.result()
# response.add_done_callback(callback)
#
# or block the thread polling for the operation's results:
response.result()

print("Batch prediction complete.\n{}".format(response.metadata))

Recupero dei risultati in corso...

Recupero dei risultati delle previsioni in BigQuery

Se hai specificato BigQuery come destinazione di output, i risultati della tua richiesta di previsione batch vengono restituiti come nuovo set di dati nel progetto BigQuery specificato. Il set di dati BigQuery è il nome del modello preceduto da "previsione_" e aggiunto al timestamp dell'inizio del job di previsione. Il nome del set di dati BigQuery è disponibile in Previsioni recenti nella pagina Previsione batch della scheda Testa e utilizza per il tuo modello.

Il set di dati BigQuery contiene due tabelle: predictions e errors. La tabella errors contiene una riga per ogni riga della richiesta di previsione, in cui le tabelle AutoML non possono restituire una previsione (ad esempio, se una caratteristica non null era nulla). La tabella predictions contiene una riga per ogni previsione restituita.

Nella tabella predictions, AutoML Tables restituisce i dati di previsione e crea una nuova colonna per i risultati della previsione preimpostando"prevedito_" sul nome della colonna target. La colonna Risultati previsione contiene una struttura BigQuery nidificata contenente i risultati della previsione.

Per recuperare i risultati della previsione, puoi utilizzare una query nella console BigQuery. Il formato della query dipende dal tipo di modello.

Classificazione binaria:

SELECT predicted_<target-column-name>[OFFSET(0)].tables AS value_1,
predicted_<target-column-name>[OFFSET(1)].tables AS value_2
FROM <bq-dataset-name>.predictions

"value_1" e "value_2", sono indicatori di luogo, puoi sostituireli con valori di destinazione o un equivalente.

Classificazione di più classi:

SELECT predicted_<target-column-name>[OFFSET(0)].tables AS value_1,
predicted_<target-column-name>[OFFSET(1)].tables AS value_2,
predicted_<target-column-name>[OFFSET(2)].tables AS value_3,
...
predicted_<target-column-name>[OFFSET(4)].tables AS value_5
FROM <bq-dataset-name>.predictions

"value_1", "value_2" e così via sono indicatori di luogo, puoi sostituirli con i valori target o un equivalente.

Regressione:

SELECT predicted_<target-column-name>[OFFSET(0)].tables.value,
predicted_<target-column-name>[OFFSET(0)].tables.prediction_interval.start,
predicted_<target-column-name>[OFFSET(0)].tables.prediction_interval.end
FROM <bq-dataset-name>.predictions

Recupero dei risultati in Cloud Storage

Se hai specificato Cloud Storage come destinazione di output, i risultati della tua richiesta di previsione batch vengono restituiti come file CSV in una nuova cartella nel bucket specificato. Il nome della cartella è il nome del modello, preceduto da "previsione", con il timestamp di inizio del job di previsione. Puoi trovare il nome della cartella Cloud Storage in Previsioni recenti nella parte inferiore della pagina Previsione batch della scheda Testa e utilizza per il tuo modello.

La cartella di Cloud Storage contiene due tipi di file: file di errore e file di previsione. Se i risultati sono di grandi dimensioni, vengono creati file aggiuntivi.

I file di errore sono denominati errors_1.csv, errors_2.csv e così via. Contengono una riga di intestazione e una riga per ogni riga della richiesta di previsione relativa alle tabelle AutoML che non sono in grado di restituire una previsione.

I file di previsione sono denominati tables_1.csv, tables_2.csv e così via. Contengono una riga di intestazione con i nomi delle colonne e una riga per ogni previsione restituita.

Nei file di previsione, AutoML Tables restituisce i dati di previsione e crea una o più nuove colonne per i risultati della previsione, a seconda del tipo di modello:

Classificazione:

Per ogni valore potenziale della colonna target, viene aggiunta una colonna denominata <target-column-name>_<value>_score ai risultati. Questa colonna contiene il punteggio, o la stima, del valore per questo valore.

Regressione:

Il valore previsto per quella riga viene restituito in una colonna denominata predicted_<target-column-name>. Per l'output CSV non viene restituito l'intervallo di previsione.

L'importanza delle funzionalità locali non è disponibile per i risultati in Cloud Storage.

Interpretare i risultati

Il modo in cui interpreti i risultati dipende dal problema aziendale che stai risolvendo e da come vengono distribuiti i tuoi dati.

Interpretare i risultati per i modelli di classificazione

I risultati delle previsioni per i modelli di classificazione (binari e multiclasse) restituiscono un punteggio di probabilità per ogni valore potenziale della colonna target. Devi decidere come vuoi utilizzare i punteggi. Ad esempio, per ottenere una classificazione binaria dai punteggi forniti, devi identificare un valore di soglia. Se ci sono due classi, "A" e "B", dovresti classificare l'esempio come "A" se il punteggio per "A" è maggiore della soglia scelta e "B". Per i set di dati non bilanciati, la soglia potrebbe avvicinarsi al 100% o allo 0%.

Puoi utilizzare il grafico della curva di richiamo della precisione, il grafico della curva dell'operatore del ricevitore e altre statistiche pertinenti per etichetta nella pagina Valuta del tuo modello in Cloud Console per vedere in che modo la modifica della soglia cambia le metriche di valutazione. Questo può aiutarvi a determinare il modo migliore per utilizzare i valori dei punteggi per interpretare i risultati delle previsioni.

Interpretare i risultati per i modelli di regressione

Per i modelli di regressione viene restituito un valore previsto e per molti problemi puoi utilizzare tale valore direttamente. Puoi utilizzare anche l'intervallo di previsione, se viene restituito e se un intervallo è adatto al tuo problema aziendale.

Interpretare i risultati dell'importanza delle funzionalità locali

Per informazioni sull'interpretazione dei risultati dell'importanza delle funzionalità locali, consulta la sezione Importanza delle funzionalità locali.

Passaggi successivi