Ottenere inferenze batch di TabNet

Tabella BigQuery

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

• 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:

• L'origine dati deve iniziare con una riga di intestazione contenente 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 il ruolo Storage Object Creator all'account di servizio Vertex AI in quel progetto.
• Devi racchiudere tutte le stringhe tra virgolette doppie (").

Console Google Cloud

Utilizza la console Google Cloud per richiedere un'inferenza batch.

1. Nella console Google Cloud , nella sezione Vertex AI, vai alla pagina Inferenza batch.

   Vai a Inferenza batch

2. Fai clic su Crea per aprire la finestra Nuova inferenza batch.
3. Per Definisci l'inferenza batch, completa i seguenti passaggi:
   1. Inserisci un nome per l'inferenza batch.
   2. In Nome modello, seleziona il nome del modello da utilizzare per questa inferenza batch.
   3. In Versione, seleziona la versione del modello da utilizzare per questa inferenza batch.
   4. Per Seleziona origine, seleziona se i dati di input dell'origine sono un file CSV in Cloud Storage o una tabella in BigQuery.
      • Per i file CSV, specifica la posizione Cloud Storage in cui si trova il file di input CSV.
      • Per le tabelle BigQuery, specifica l'ID progetto in cui si trova la tabella, l'ID set di dati BigQuery e l'ID tabella o visualizzazione 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, inseriscilo nel campo ID progetto Google Cloud. Vertex AI crea un nuovo set di dati di output.
        • 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 Model Monitoring per le inferenze batch è disponibile in Anteprima. Consulta i Prerequisiti per aggiungere la configurazione del rilevamento della distorsione al job di inferenza batch.
   1. Fai clic per attivare l'opzione Abilita il monitoraggio dei modelli per questa inferenza batch.
   2. Seleziona un'origine dati di addestramento. Inserisci il percorso o la posizione dei dati per l'origine dati di addestramento selezionata.
   3. (Facoltativo) Nella sezione Soglie di avviso, specifica le soglie in corrispondenza delle quali 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 crearne uno nuovo facendo clic su Gestisci canali di notifica. La console supporta i canali di notifica PagerDuty, Slack e Pub/Sub.
5. Fai clic su Crea.

API: BigQuery

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

{
  "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
  },

}

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"

$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

{
  "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",
}

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());
    }
  }
}

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

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

{
  "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
  },

}

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"

$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

{
  "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",
}

BigQuery

Set di dati di output

Se utilizzi BigQuery, l'output dell'inferenza batch viene archiviato 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) è 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 suo nome (BQ_DATASET_NAME) seguendo questi passaggi:

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

   Vai a Inferenza batch

2. Seleziona l'inferenza che hai creato.
3. Il set di dati di output è indicato in Posizione di esportazione. Il nome del set di dati è formattato nel seguente modo: prediction_MODEL_NAME_TIMESTAMP

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 un'inferenza (ovvero dove TARGET_COLUMN_NAME = null).

• Tabella degli errori
  

  Questa tabella contiene una riga per ogni errore non critico rilevato durante l'inferenza batch. Ogni errore non critico corrisponde a una riga nei dati di input per cui Vertex AI non è riuscita a restituire una previsione.

Tabella delle previsioni

Il nome della tabella (BQ_PREDICTIONS_TABLE_NAME) è formato aggiungendo `predictions_` con il timestamp dell'inizio del job di inferenza batch: predictions_TIMESTAMP

Per recuperare le inferenze, vai alla pagina BigQuery.

Vai a BigQuery

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 e scores sono 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 minimizzatore dell'obiettivo di ottimizzazione. Ad esempio, se l'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 quantili, Vertex AI fornisce valori e inferenze dei quantili, oltre al minimizzatore dell'obiettivo di ottimizzazione. I valori dei quantili vengono impostati durante l'addestramento del modello. Le inferenze quantile sono i valori di inferenza associati ai valori quantile.

Puoi trovare l'importanza delle caratteristiche anche nella tabella delle inferenze. Per accedere all'importanza di una funzionalità BQ_FEATURE_NAME, esegui la seguente query:

SELECT predicted_TARGET_COLUMN_NAME.feature_importance.BQ_FEATURE_NAME FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME
  

Tabella 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
         

• 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 inferenza batch vengono restituiti come oggetti CSV in una nuova cartella nel bucket specificato. Il nome della cartella è il nome del modello, preceduto da "prediction-" e seguito dal timestamp dell'inizio del job di inferenza batch. Puoi trovare il nome della cartella Cloud Storage nella scheda Previsioni batch del modello.

• Oggetti di previsione

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

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

  Gli oggetti di errore sono 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 cui Vertex AI non è riuscita a restituire un'inferenza (ad esempio, se una caratteristica non annullabile era null).

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

L'importanza delle funzionalità non è disponibile per i risultati dell'inferenza batch restituiti in Cloud Storage.

Classificazione

I modelli di classificazione restituiscono un punteggio di affidabilità.

Il punteggio di confidenza indica la forza con cui il modello associa ogni classe o etichetta a un elemento di test. Più alto è il numero, maggiore è la certezza del modello che l'etichetta deve essere applicata a quell'elemento. Decidi tu quanto deve essere alto il punteggio di affidabilità per accettare i risultati del modello.

Regressione

I modelli di regressione restituiscono un valore di inferenza.

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

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