Esportazione modelli

Questa pagina mostra come esportare i modelli BigQuery ML. Puoi esportare i modelli BigQuery ML in Cloud Storage e utilizzarli per la previsione online o modificarli in Python. Puoi esportare un modello BigQuery ML:

• Utilizzo della consoleGoogle Cloud .
• Utilizzo dell'istruzione EXPORT MODEL.
• Utilizzo del comando bq extract nello strumento a riga di comando bq.
• Invio di un job extract tramite l'API o le librerie client.

Puoi esportare i seguenti tipi di modelli:

• AUTOENCODER
• AUTOML_CLASSIFIER
• AUTOML_REGRESSOR
• BOOSTED_TREE_CLASSIFIER
• BOOSTED_TREE_REGRESSOR
• DNN_CLASSIFIER
• DNN_REGRESSOR
• DNN_LINEAR_COMBINED_CLASSIFIER
• DNN_LINEAR_COMBINED_REGRESSOR
• KMEANS
• LINEAR_REG
• LOGISTIC_REG
• MATRIX_FACTORIZATION
• RANDOM_FOREST_CLASSIFIER
• RANDOM_FOREST_REGRESSOR
• TENSORFLOW (modelli TensorFlow importati)
• PCA
• TRANSFORM_ONLY

Esportare formati ed esempi di modelli

La tabella seguente mostra i formati di destinazione dell'esportazione per ogni tipo di modello BigQuery ML e fornisce un esempio di file scritti nel bucket Cloud Storage.

Esportare il modello addestrato con TRANSFORM

Se il modello viene addestrato con la clausola TRANSFORM, un modello di pre-elaborazione aggiuntivo esegue la stessa logica nella clausola TRANSFORM e viene salvato nel formato SavedModel di TensorFlow nella sottodirectory transform. Puoi eseguire il deployment di un modello addestrato con la clausola TRANSFORM in Vertex AI e localmente. Per ulteriori informazioni, consulta la sezione Deployment dei modelli.

Il modello non contiene le informazioni sull'ingegneria delle funzionalità eseguita al di fuori della clausola TRANSFORM durante l'addestramento. Ad esempio, qualsiasi elemento nella dichiarazione SELECT . Pertanto, devi convertire manualmente i dati di input prima di inserirli nel modello di preelaborazione.

Tipi di dati supportati

Quando esporti modelli addestrati con la clausola TRANSFORM, i seguenti tipi di dati sono supportati per l'inserimento nella clausola TRANSFORM.

Funzioni SQL supportate

Quando esporti modelli addestrati con la clausola TRANSFORM, puoi utilizzare le seguenti funzioni SQL all'interno della clausola TRANSFORM.

• Operatori
  • +, -, *, /, =, <, >, <=, >=, !=, <>, [NOT] BETWEEN, [NOT] IN, IS [NOT] NULL, IS [NOT] TRUE, IS [NOT] FALSE, NOT, AND, OR.
• Espressioni condizionali
  • CASE expr, CASE, COALESCE, IF, IFNULL, NULLIF.
• Funzioni matematiche
  • ABS, ACOS, ACOSH, ASINH, ATAN, ATAN2, ATANH, CBRT, CEIL, CEILING, COS, COSH, COT, COTH, CSC, CSCH, EXP, FLOOR, IS_INF, IS_NAN, LN, LOG, LOG10, MOD, POW, POWER, SEC, SECH, SIGN, SIN, SINH, SQRT, TAN, TANH.
• Funzioni di conversione
  • CAST AS INT64, CAST AS FLOAT64, CAST AS NUMERIC, CAST AS BIGNUMERIC, CAST AS STRING, SAFE_CAST AS INT64, SAFE_CAST AS FLOAT64
• Funzioni stringa
  • CONCAT, LEFT, LENGTH, LOWER, REGEXP_REPLACE, RIGHT, SPLIT, SUBSTR, SUBSTRING, TRIM, UPPER.
• Funzioni data
  • Date, DATE_ADD, DATE_SUB, DATE_DIFF, DATE_TRUNC, EXTRACT, FORMAT_DATE, PARSE_DATE, SAFE.PARSE_DATE.
• Funzioni di data/ora
  • DATETIME, DATETIME_ADD, DATETIME_SUB, DATETIME_DIFF, DATETIME_TRUNC, EXTRACT, PARSE_DATETIME, SAFE.PARSE_DATETIME.
• Funzioni temporali
  • TIME, TIME_ADD, TIME_SUB, TIME_DIFF, TIME_TRUNC, EXTRACT, FORMAT_TIME, PARSE_TIME, SAFE.PARSE_TIME.
• Funzioni di timestamp
  • TIMESTAMP, TIMESTAMP_ADD, TIMESTAMP_SUB, TIMESTAMP_DIFF, TIMESTAMP_TRUNC, FORMAT_TIMESTAMP, PARSE_TIMESTAMP, SAFE.PARSE_TIMESTAMP, TIMESTAMP_MICROS, TIMESTAMP_MILLIS, TIMESTAMP_SECONDS, EXTRACT, STRING, UNIX_MICROS, UNIX_MILLIS, UNIX_SECONDS.
• Funzioni di pre-elaborazione manuale
  • ML.IMPUTER, ML.HASH_BUCKETIZE, ML.LABEL_ENCODER, ML.MULTI_HOT_ENCODER, ML.NGRAMS, ML.ONE_HOT_ENCODER, ML.BUCKETIZE, ML.MAX_ABS_SCALER, ML.MIN_MAX_SCALER, ML.NORMALIZER, ML.QUANTILE_BUCKETIZE, ML.ROBUST_SCALER, ML.STANDARD_SCALER.

Limitazioni

Quando esporti i modelli, si applicano le seguenti limitazioni:

• L'esportazione del modello non è supportata se durante l'addestramento è stata utilizzata una delle seguenti funzionalità:

  • I tipi di funzionalità ARRAY, TIMESTAMP o GEOGRAPHY erano presenti nei dati di input.

• I modelli esportati per i tipi di modello AUTOML_REGRESSOR e AUTOML_CLASSIFIER non supportano il deployment di Vertex AI per la previsione online.

• Il limite di dimensione del modello è di 1 GB per l'esportazione del modello di fattorizzazione matriciale. Le dimensioni del modello sono proporzionali a num_factors, quindi puoi ridurre num_factors durante l'addestramento per ridurre le dimensioni del modello se raggiungi il limite.

• Per i modelli addestrati con la clausola BigQuery ML TRANSFORM per la preelaborazione manuale delle funzionalità, consulta i tipi di dati e le funzioni supportati per l'esportazione.

• I modelli addestrati con la clausola BigQuery ML TRANSFORM prima del 18 settembre 2023 devono essere riaddestrati prima di poter essere eseguiti il deployment tramite Model Registry per la previsione online.

• Durante l'esportazione del modello, ARRAY<STRUCT<INT64, FLOAT64>>, ARRAY e TIMESTAMP sono supportati come dati pre-trasformati, ma non come dati post-trasformati.

Esportare modelli BigQuery ML

Per esportare un modello:

bq --location=location extract \
--destination_format format \
--model project_id:dataset.model \
gs://bucket/model_folder

bq extract --model \
'mydataset.mymodel' \
gs://example-bucket/mymodel_folder

bq extract --model \
--destination_format ML_XGBOOST_BOOSTER \
'mydataset.mytable' \
gs://example-bucket/mymodel_folder

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.ExtractJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.ModelId;

// Sample to extract model to GCS bucket
public class ExtractModel {

  public static void main(String[] args) throws InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectName = "bigquery-public-data";
    String datasetName = "samples";
    String modelName = "model";
    String bucketName = "MY-BUCKET-NAME";
    String destinationUri = "gs://" + bucketName + "/path/to/file";
    extractModel(projectName, datasetName, modelName, destinationUri);
  }

  public static void extractModel(
      String projectName, String datasetName, String modelName, String destinationUri)
      throws InterruptedException {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      ModelId modelId = ModelId.of(projectName, datasetName, modelName);

      ExtractJobConfiguration extractConfig =
          ExtractJobConfiguration.newBuilder(modelId, destinationUri).build();

      Job job = bigquery.create(JobInfo.of(extractConfig));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to extract due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Model extract successful");
    } catch (BigQueryException ex) {
      System.out.println("Model extraction job was interrupted. \n" + ex.toString());
    }
  }
}

Deployment del modello

Puoi eseguire il deployment del modello esportato in Vertex AI e localmente. Se la clausola TRANSFORM del modello contiene funzioni di data, ora, data e ora o timestamp, devi utilizzare la libreria bigquery-ml-utils nel container. L'eccezione è se esegui il deployment tramite Model Registry, che non richiede modelli esportati o container di pubblicazione.

Deployment di Vertex AI

Deployment locale

Formato di output della previsione

Questa sezione fornisce il formato dell'output di previsione dei modelli esportati per ogni tipo di modello. Tutti i modelli esportati supportano la previsione batch e possono gestire più righe di input contemporaneamente. Ad esempio, in ciascuno dei seguenti esempi di formato di output sono presenti due righe di input.

AUTOENCODER

+------------------------+------------------------+------------------------+
|      LATENT_COL_1      |      LATENT_COL_2      |           ...          |
+------------------------+------------------------+------------------------+
|       [FLOAT]          |         [FLOAT]        |           ...          |
+------------------------+------------------------+------------------------+
        

+------------------+------------------+------------------+------------------+
|   LATENT_COL_1   |   LATENT_COL_2   |   LATENT_COL_3   |   LATENT_COL_4   |
+------------------------+------------+------------------+------------------+
|    0.21384512    |    0.93457112    |    0.64978097    |    0.00480489    |
+------------------+------------------+------------------+------------------+
        

AUTOML_CLASSIFIER

+------------------------------------------+
| predictions                              |
+------------------------------------------+
| [{"scores":[FLOAT], "classes":[STRING]}] |
+------------------------------------------+
        

+---------------------------------------------+
| predictions                                 |
+---------------------------------------------+
| [{"scores":[1, 2], "classes":['a', 'b']},   |
|  {"scores":[3, 0.2], "classes":['a', 'b']}] |
+---------------------------------------------+
        

AUTOML_REGRESSOR

+-----------------+
| predictions     |
+-----------------+
| [FLOAT]         |
+-----------------+
        

+-----------------+
| predictions     |
+-----------------+
| [1.8, 2.46]     |
+-----------------+
        

BOOSTED_TREE_CLASSIFIER e RANDOM_FOREST_CLASSIFIER

+-------------+--------------+-----------------+
| LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL |
+-------------+--------------+-----------------+
| [FLOAT]     | [STRING]     | STRING          |
+-------------+--------------+-----------------+
        

+-------------+--------------+-----------------+
| LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL |
+-------------+--------------+-----------------+
| [0.1, 0.9]  | ['a', 'b']   | ['b']           |
+-------------+--------------+-----------------+
| [0.8, 0.2]  | ['a', 'b']   | ['a']           |
+-------------+--------------+-----------------+
        

BOOSTED_TREE_REGRESSOR E RANDOM_FOREST_REGRESSOR

+-----------------+
| predicted_label |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| predicted_label |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
        

DNN_CLASSIFIER

+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| [INT64]       | [STRING]    | INT64     | STRING  | FLOAT                  | [FLOAT]| [FLOAT]       |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
        

+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| [0, 1]        | ['a', 'b']  | [0]       | ['a']   | [0.36]                 | [-0.53]| [0.64, 0.36]  |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| [0, 1]        | ['a', 'b']  | [0]       | ['a']   | [0.2]                  | [-1.38]| [0.8, 0.2]    |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
        

DNN_REGRESSOR

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
        

DNN_LINEAR_COMBINED_CLASSIFIER

+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| [INT64]       | [STRING]    | INT64     | STRING  | FLOAT                  | [FLOAT]| [FLOAT]       |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
        

+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| [0, 1]        | ['a', 'b']  | [0]       | ['a']   | [0.36]                 | [-0.53]| [0.64, 0.36]  |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
| [0, 1]        | ['a', 'b']  | [0]       | ['a']   | [0.2]                  | [-1.38]| [0.8, 0.2]    |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+
        

DNN_LINEAR_COMBINED_REGRESSOR

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
        

KMEANS

+--------------------+--------------+---------------------+
| CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID |
+--------------------+--------------+---------------------+
| [FLOAT]            | [INT64]      | INT64               |
+--------------------+--------------+---------------------+
        

+--------------------+--------------+---------------------+
| CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID |
+--------------------+--------------+---------------------+
| [1.2, 1.3]         | [1, 2]       | [1]                 |
+--------------------+--------------+---------------------+
| [0.4, 0.1]         | [1, 2]       | [2]                 |
+--------------------+--------------+---------------------+
        

LINEAR_REG

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
       

LOGISTIC_REG

+-------------+--------------+-----------------+
| LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL |
+-------------+--------------+-----------------+
| [FLOAT]     | [STRING]     | STRING          |
+-------------+--------------+-----------------+
        

+-------------+--------------+-----------------+
| LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL |
+-------------+--------------+-----------------+
| [0.1, 0.9]  | ['a', 'b']   | ['b']           |
+-------------+--------------+-----------------+
| [0.8, 0.2]  | ['a', 'b']   | ['a']           |
+-------------+--------------+-----------------+
        

MATRIX_FACTORIZATION

Nota:al momento supportiamo solo l'acquisizione di un utente di input e l'output delle 50 coppie (predicted_rating, predicted_item) principali ordinate in base a predicted_rating in ordine decrescente.

+--------------------+--------------+
| PREDICTED_RATING | PREDICTED_ITEM |
+------------------+----------------+
| [FLOAT]          | [STRING]       |
+------------------+----------------+
        

+--------------------+--------------+
| PREDICTED_RATING | PREDICTED_ITEM |
+------------------+----------------+
| [5.5, 1.7]       | ['A', 'B']     |
+------------------+----------------+
| [7.2, 2.7]       | ['B', 'A']     |
+------------------+----------------+
        

TENSORFLOW (importato)

PCA

+-------------------------+---------------------------------+
| PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS |
+-------------------------+---------------------------------+
|       [INT64]           |             [FLOAT]             |
+-------------------------+---------------------------------+
        

+-------------------------+---------------------------------+
| PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS |
+-------------------------+---------------------------------+
|       [1, 2]            |             [1.2, 5.0]          |
+-------------------------+---------------------------------+
        

TRANSFORM_ONLY

Visualizzazione del modello XGBoost

Puoi visualizzare gli alberi potenziati utilizzando l'API Python plot_tree dopo l'esportazione del modello. Ad esempio, puoi utilizzare Colab senza installare le dipendenze:

1. Esporta il modello ad albero potenziato in un bucket Cloud Storage.
2. Scarica il file model.bst dal bucket Cloud Storage.
3. In un notebook di Colab, carica il file model.bst su Files.

4. Esegui questo codice nel notebook:

   import xgboost as xgb
   import matplotlib.pyplot as plt
   
   model = xgb.Booster(model_file="model.bst")
   num_iterations = <iteration_number>
   for tree_num in range(num_iterations):
     xgb.plot_tree(model, num_trees=tree_num)
   plt.show
   

Questo esempio traccia più alberi (un albero per iterazione):

Al momento non salviamo i nomi delle funzionalità nel modello, quindi vedrai nomi come "f0", "f1" e così via. Puoi trovare i nomi delle funzionalità corrispondenti nel file assets/model_metadata.json esportato utilizzando questi nomi (ad esempio "f0") come indici.

Autorizzazioni obbligatorie

Per esportare un modello BigQuery ML in Cloud Storage, devi disporre delle autorizzazioni per accedere al modello BigQuery ML, per eseguire un job di esportazione e per scrivere i dati nel bucket Cloud Storage.

Autorizzazioni BigQuery

• Per esportare il modello, devi disporre almeno delle autorizzazioni bigquery.models.export. I seguenti ruoli IAM (Identity and Access Management) predefiniti dispongono delle autorizzazioni bigquery.models.export:

  • bigquery.dataViewer
  • bigquery.dataOwner
  • bigquery.dataEditor
  • bigquery.admin

• Come minimo, per eseguire un job di esportazione, devi disporre delle autorizzazioni bigquery.jobs.create. I seguenti ruoli IAM predefiniti dispongono delle autorizzazioni bigquery.jobs.create:

  • bigquery.user
  • bigquery.jobUser
  • bigquery.admin

Autorizzazioni Cloud Storage

• Per scrivere i dati in un bucket Cloud Storage esistente, devi disporre delle autorizzazioni storage.objects.create. I seguenti ruoli IAM predefiniti dispongono delle autorizzazioni storage.objects.create:

  • storage.objectCreator
  • storage.objectAdmin
  • storage.admin

Per saperne di più su ruoli e autorizzazioni IAM in BigQuery ML, consulta Controllo dell'accesso.

Spostare i dati BigQuery tra le località

Non puoi modificare la posizione di un set di dati dopo la creazione, ma puoi crearne una copia.

Criteri per le quote

Per informazioni sulle quote dei job di esportazione, vedi Job di esportazione nella pagina Quote e limiti.

Prezzi

L'esportazione dei modelli BigQuery ML non prevede costi, ma è soggetta a quote e limiti di BigQuery. Per ulteriori informazioni sui prezzi di BigQuery, consulta la pagina Prezzi.

Una volta esportati i dati, ti viene addebitato il costo di archiviazione dei dati in Cloud Storage. Per maggiori informazioni sui prezzi di Cloud Storage, consulta la pagina Prezzi di Cloud Storage.

Passaggi successivi

• Segui il tutorial Esportare un modello BigQuery ML per la previsione online.