Exportar modelos

En esta página se explica cómo exportar modelos de BigQuery ML. Puedes exportar modelos de BigQuery ML a Cloud Storage y usarlos para hacer predicciones online o editarlos en Python. Puedes exportar un modelo de BigQuery ML de las siguientes formas:

• Con la Google Cloud consola.
• Usar la instrucción EXPORT MODEL.
• Usando el comando bq extract en la herramienta de línea de comandos bq.
• Enviar un trabajo de extract a través de la API o las bibliotecas de cliente.

Puede exportar los siguientes 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 importados de TensorFlow)
• PCA
• TRANSFORM_ONLY

Exportar formatos y muestras de modelos

En la siguiente tabla se muestran los formatos de destino de exportación de cada tipo de modelo de BigQuery ML y se proporciona un ejemplo de los archivos que se escriben en el segmento de Cloud Storage.

Exportar un modelo entrenado con TRANSFORM

Si el modelo se entrena con la cláusula TRANSFORM, un modelo de preprocesamiento adicional realiza la misma lógica en la cláusula TRANSFORM y se guarda en formato TensorFlow SavedModel en el subdirectorio transform. Puedes desplegar un modelo entrenado con la cláusula TRANSFORM en Vertex AI y de forma local. Para obtener más información, consulta el artículo sobre el despliegue de modelos.

El modelo no contiene la información sobre la ingeniería de funciones realizada fuera de la cláusula TRANSFORM durante el entrenamiento. Por ejemplo, cualquier elemento de la instrucción SELECT . Por lo tanto, tendrás que convertir manualmente los datos de entrada antes de introducirlos en el modelo de preprocesamiento.

Tipos de datos admitidos

Cuando se exportan modelos entrenados con la cláusula TRANSFORM, se admiten los siguientes tipos de datos para la cláusula TRANSFORM.

Funciones de SQL admitidas

Cuando exportes modelos entrenados con la cláusula TRANSFORM, puedes usar las siguientes funciones de SQL dentro de la cláusula TRANSFORM.

• Operadores
  • +, -, *, /, =, <, >, <=, >=, !=, <>, [NOT] BETWEEN, [NOT] IN, IS [NOT] NULL, IS [NOT] TRUE, IS [NOT] FALSE, NOT, AND, OR.
• Expresiones condicionales
  • CASE expr, CASE, COALESCE, IF, IFNULL y NULLIF.
• Funciones 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 y TANH.
• Funciones de conversión
  • CAST AS INT64, CAST AS FLOAT64, CAST AS NUMERIC, CAST AS BIGNUMERIC, CAST AS STRING, SAFE_CAST AS INT64, SAFE_CAST AS FLOAT64
• Funciones de cadena
  • CONCAT, LEFT, LENGTH, LOWER, REGEXP_REPLACE, RIGHT, SPLIT, SUBSTR, SUBSTRING, TRIM, UPPER.
• Funciones de fecha
  • Date, DATE_ADD, DATE_SUB, DATE_DIFF, DATE_TRUNC, EXTRACT, FORMAT_DATE, PARSE_DATE, SAFE.PARSE_DATE.
• Funciones de fecha y hora
  • DATETIME, DATETIME_ADD, DATETIME_SUB, DATETIME_DIFF, DATETIME_TRUNC, EXTRACT, PARSE_DATETIME, SAFE.PARSE_DATETIME.
• Funciones de tiempo
  • TIME, TIME_ADD, TIME_SUB, TIME_DIFF, TIME_TRUNC, EXTRACT, FORMAT_TIME, PARSE_TIME, SAFE.PARSE_TIME.
• Funciones de marca de tiempo
  • 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.
• Funciones de preprocesamiento 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.

Limitaciones

Se aplican las siguientes limitaciones al exportar modelos:

• No se puede exportar el modelo si se ha usado alguna de las siguientes funciones durante el entrenamiento:

  • Se han detectado tipos de funciones ARRAY, TIMESTAMP o GEOGRAPHY en los datos de entrada.

• Los modelos exportados de los tipos AUTOML_REGRESSOR y AUTOML_CLASSIFIER no se pueden desplegar en Vertex AI para hacer predicciones online.

• El límite de tamaño del modelo es de 1 GB para la exportación de modelos de factorización de matrices. El tamaño del modelo es aproximadamente proporcional a num_factors, por lo que puedes reducir num_factors durante el entrenamiento para reducir el tamaño del modelo si alcanzas el límite.

• En el caso de los modelos entrenados con la cláusula TRANSFORM de BigQuery ML para el preprocesamiento manual de características, consulta los tipos de datos y las funciones admitidos para la exportación.

• Los modelos entrenados con la cláusula BigQuery MLTRANSFORM antes del 18 de septiembre del 2023 deben volver a entrenarse para poder desplegarse a través de Model Registry para hacer predicciones online.

• Durante la exportación del modelo, se admiten ARRAY<STRUCT<INT64, FLOAT64>>, ARRAY y TIMESTAMP como datos pretransformados, pero no como datos postransformados.

Exportar modelos de BigQuery ML

Para exportar un modelo, sigue estos pasos:

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

Despliegue de modelo

Puedes desplegar el modelo exportado en Vertex AI y de forma local. Si la cláusula TRANSFORM del modelo contiene funciones de fecha, de fecha y hora, de hora o de marca de tiempo, debes usar la biblioteca bigquery-ml-utils en el contenedor. La excepción es si despliegas a través de Model Registry, que no necesita modelos exportados ni contenedores de servicio.

Despliegue de Vertex AI

Despliegue local

Formato de salida de la predicción

En esta sección se proporciona el formato de salida de las predicciones de los modelos exportados para cada tipo de modelo. Todos los modelos exportados admiten la predicción por lotes, por lo que pueden gestionar varias filas de entrada a la vez. Por ejemplo, hay dos filas de entrada en cada uno de los siguientes ejemplos de formato de salida.

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 y 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 Y 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: Actualmente, solo admitimos la introducción de un usuario y la obtención de los 50 pares principales (predicted_rating, predicted_item) ordenados por predicted_rating de forma 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

Visualización de modelos XGBoost

Puedes visualizar los árboles reforzados con la API de Python plot_tree después de exportar el modelo. Por ejemplo, puedes usar Colab sin instalar las dependencias:

1. Exporta el modelo de árbol reforzado a un segmento de Cloud Storage.
2. Descarga el archivo model.bst del segmento de Cloud Storage.
3. En un cuaderno de Colab, sube el archivo model.bst a Files.

4. Ejecuta el siguiente código en el cuaderno:

   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
   

En este ejemplo se representan varios árboles (un árbol por iteración):

Actualmente, no guardamos los nombres de las funciones en el modelo, por lo que verás nombres como "f0", "f1" y así sucesivamente. Puedes encontrar los nombres de las funciones correspondientes en el archivo assets/model_metadata.json exportado usando estos nombres (como "f0") como índices.

Permisos obligatorios

Para exportar un modelo de BigQuery ML a Cloud Storage, necesitas permisos para acceder al modelo de BigQuery ML, permisos para ejecutar un trabajo de exportación y permisos para escribir los datos en el segmento de Cloud Storage.

Permisos de BigQuery

• Para exportar un modelo, como mínimo debes tener permisos de bigquery.models.export. Los siguientes roles predefinidos de gestión de identidades y accesos (IAM) tienen permisos bigquery.models.export:

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

• Para ejecutar una tarea de exportación, como mínimo debes tener los permisos bigquery.jobs.create. Los siguientes roles de gestión de identidades y accesos predefinidos tienen permisos de bigquery.jobs.create:

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

Permisos de Cloud Storage

• Para escribir los datos en un segmento de Cloud Storage, debe tener los permisos storage.objects.create. Los siguientes roles de gestión de identidades y accesos predefinidos tienen permisos de storage.objects.create:

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

Para obtener más información sobre los roles y permisos de gestión de identidades y accesos en BigQuery ML, consulta el artículo sobre el control de acceso.

Mover datos de BigQuery entre ubicaciones

No puede cambiar la ubicación de un conjunto de datos después de crearlo, pero sí puede hacer una copia del conjunto de datos.

Política de cuotas

Para obtener información sobre las cuotas de los trabajos de exportación, consulta la sección Trabajos de exportación de la página Cuotas y límites.

Precios

No se cobra por exportar modelos de BigQuery ML, pero las exportaciones están sujetas a las cuotas y los límites de BigQuery. Para obtener más información sobre los precios de BigQuery, consulta la página Precios.

Una vez que se hayan exportado los datos, se te cobrará por almacenarlos en Cloud Storage. Para obtener más información sobre los precios de Cloud Storage, consulta la página Precios de Cloud Storage.

Siguientes pasos

• Sigue el tutorial Exportar un modelo de BigQuery ML para hacer predicciones online.