Exportar modelos

Esta página mostra-lhe como exportar modelos do BigQuery ML. Pode exportar modelos do BigQuery ML para o Cloud Storage e usá-los para previsões online ou editá-los em Python. Pode exportar um modelo do BigQuery ML das seguintes formas:

• Usando a Trusted Cloud consola.
• Usar a declaração EXPORT MODEL.
• Usando o comando bq extract na ferramenta de linhas de comando bq.
• Enviar uma tarefa extract através da API ou das bibliotecas cliente.

Pode exportar os seguintes tipos de modelos:

• 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 (modelos do TensorFlow importados)
• PCA
• TRANSFORM_ONLY

Formatos e amostras de modelos de exportação

A tabela seguinte mostra os formatos de destino de exportação para cada tipo de modelo do BigQuery ML e fornece um exemplo de ficheiros que são escritos no contentor do Cloud Storage.

Exporte o modelo preparado com o TRANSFORM

Se o modelo for treinado com a cláusula TRANSFORM, um modelo de pré-processamento adicional executa a mesma lógica na cláusula TRANSFORM e é guardado no formato TensorFlow SavedModel no subdiretório transform. Pode implementar um modelo preparado com a cláusula TRANSFORM no Vertex AI, bem como localmente. Para mais informações, consulte o artigo Implementação de modelos.

O modelo não contém as informações sobre a engenharia de funcionalidades realizada fora da cláusula TRANSFORM durante a preparação. Por exemplo, tudo o que estiver na declaração SELECT . Por isso, tem de converter manualmente os dados de entrada antes de os introduzir no modelo de pré-processamento.

Tipos de dados suportados

Quando exporta modelos preparados com a cláusula TRANSFORM, os seguintes tipos de dados são suportados para introdução na cláusula TRANSFORM.

Funções SQL suportadas

Quando exporta modelos preparados com a cláusula TRANSFORM, pode usar as seguintes funções SQL na cláusula TRANSFORM .

• Operadores
  • +, -, *, /, =, <, >, <=, >=, !=, <>, [NOT] BETWEEN, [NOT] IN, IS [NOT] NULL, IS [NOT] TRUE, IS [NOT] FALSE, NOT, AND, OR.
• Expressões condicionais
  • CASE expr, CASE, COALESCE, IF, IFNULL, NULLIF.
• Funções matemáticas
  • 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.
• Funções de conversão
  • CAST AS INT64, CAST AS FLOAT64, CAST AS NUMERIC, CAST AS BIGNUMERIC, CAST AS STRING, SAFE_CAST AS INT64, SAFE_CAST AS FLOAT64
• Funções de texto
  • CONCAT, LEFT, LENGTH, LOWER, REGEXP_REPLACE, RIGHT, SPLIT, SUBSTR, SUBSTRING, TRIM, UPPER.
• Funções de data
  • Date, DATE_ADD, DATE_SUB, DATE_DIFF, DATE_TRUNC, EXTRACT, FORMAT_DATE, PARSE_DATE, SAFE.PARSE_DATE.
• Funções de data/hora
  • DATETIME, DATETIME_ADD, DATETIME_SUB, DATETIME_DIFF, DATETIME_TRUNC, EXTRACT, PARSE_DATETIME, SAFE.PARSE_DATETIME.
• Funções de tempo
  • TIME, TIME_ADD, TIME_SUB, TIME_DIFF, TIME_TRUNC, EXTRACT, FORMAT_TIME, PARSE_TIME, SAFE.PARSE_TIME.
• Funções de data/hora
  • 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.
• Funções de pré-processamento manual
  • 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.

Limitações

Aplicam-se as seguintes limitações quando exporta modelos:

• A exportação de modelos não é suportada se tiver sido usada alguma das seguintes funcionalidades durante a preparação:

  • Os tipos de funcionalidades ARRAY, TIMESTAMP ou GEOGRAPHY estavam presentes nos dados de entrada.

• Os modelos exportados para os tipos de modelos AUTOML_REGRESSOR e AUTOML_CLASSIFIER não suportam a implementação da Vertex AI para a previsão online.

• O limite de tamanho do modelo é de 1 GB para a exportação do modelo de fatorização de matrizes. O tamanho do modelo é aproximadamente proporcional a num_factors, pelo que pode reduzir num_factors durante a preparação para diminuir o tamanho do modelo se atingir o limite.

• Para modelos preparados com a cláusula BigQuery ML TRANSFORM para pré-processamento manual de caraterísticas, consulte os tipos de dados e as funções suportadas para exportação.

• Os modelos preparados com a cláusula BigQuery ML TRANSFORM antes de 18 de setembro de 2023 têm de ser novamente preparados antes de poderem ser implementados através do registo de modelos para a previsão online.

• Durante a exportação do modelo, ARRAY<STRUCT<INT64, FLOAT64>>, ARRAY e TIMESTAMP são suportados como dados pré-transformados, mas não são suportados como dados pós-transformados.

Exporte modelos do BigQuery ML

Para exportar um modelo:

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

Implementação de modelos

Pode implementar o modelo exportado no Vertex AI, bem como localmente. Se a cláusula TRANSFORM do modelo contiver funções de data, funções de data/hora, funções de tempo ou funções de data/hora, tem de usar a biblioteca bigquery-ml-utils no contentor. A exceção é se estiver a implementar através do Model Registry, que não precisa de modelos exportados nem de contentores de publicação.

Implementação do Vertex AI

Implementação local

Formato de saída da previsão

Esta secção apresenta o formato de saída da previsão dos modelos exportados para cada tipo de modelo. Todos os modelos exportados suportam a previsão em lote e podem processar várias linhas de entrada em simultâneo. Por exemplo, existem duas linhas de entrada em cada um dos seguintes exemplos de formato de saída.

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: atualmente, só suportamos a obtenção de um utilizador de entrada e a saída dos 50 principais pares (predicted_rating, predicted_item) ordenados por predicted_rating por ordem descendente.

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

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

TENSORFLOW (importado)

PCA

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

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

TRANSFORM_ONLY

Visualização do modelo XGBoost

Pode visualizar as árvores com reforço através da API Python plot_tree após a exportação do modelo. Por exemplo, pode tirar partido do Colab sem instalar as dependências:

1. Exporte o modelo de árvore com reforço para um contentor do Cloud Storage.
2. Transfira o ficheiro model.bst do contentor do Cloud Storage.
3. Num bloco de notas do Colab, carregue o ficheiro model.bst para Files.

4. Execute o seguinte código no bloco de notas:

   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
   

Este exemplo representa graficamente várias árvores (uma árvore por iteração):

Atualmente, não guardamos os nomes das funcionalidades no modelo, pelo que verá nomes como "f0", "f1", etc. Pode encontrar os nomes das funcionalidades correspondentes no ficheiro exportado usando estes nomes (como "f0") como índices.assets/model_metadata.json

Autorizações necessárias

Para exportar um modelo do BigQuery ML para o Cloud Storage, precisa de autorizações para aceder ao modelo do BigQuery ML, autorizações para executar uma tarefa de exportação e autorizações para escrever os dados no contentor do Cloud Storage.

Autorizações do BigQuery

• No mínimo, para exportar o modelo, tem de ter bigquery.models.export autorizações. As seguintes funções predefinidas da gestão de identidade e de acesso (IAM) têm autorizações bigquery.models.export:

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

• No mínimo, para executar uma tarefa de exportação, tem de ter autorizações bigquery.jobs.create. As seguintes funções do IAM predefinidas têm autorizações bigquery.jobs.create:

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

Autorizações do Cloud Storage

• Para escrever os dados num contentor do Cloud Storage existente, tem de ter autorizações storage.objects.create. As seguintes funções do IAM predefinidas têm autorizações storage.objects.create:

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

Para mais informações sobre as funções e as autorizações do IAM no BigQuery ML, consulte o artigo Controlo de acesso.

Mova dados do BigQuery entre localizações

Não é possível alterar a localização de um conjunto de dados após a respetiva criação, mas pode fazer uma cópia do conjunto de dados.

Política de quotas

Para informações sobre as quotas de tarefas de exportação, consulte o artigo Tarefas de exportação na página Quotas e limites.

Preços

Não existe qualquer custo para exportar modelos do BigQuery ML, mas as exportações estão sujeitas às quotas e limites do BigQuery. Para mais informações sobre os preços do BigQuery, consulte a página Preços.

Após a exportação dos dados, é-lhe cobrado o armazenamento dos dados no Cloud Storage. Para mais informações sobre os preços do Cloud Storage, consulte a página de preços do Cloud Storage.

O que se segue?

• Siga o tutorial Exporte um modelo do BigQuery ML para a previsão online.