Exportar modelos

En esta página, se muestra cómo exportar modelos de BigQuery ML. Puedes exportar modelos de BigQuery ML a Cloud Storage y usarlos para la predicción en línea o editarlos en Python. Puedes exportar un modelo de BigQuery ML mediante lo siguiente:

• Usa la consola de Google Cloud
• Mediante la sentencia EXPORT MODEL.
• Usa el comando bq extract en la herramienta de línea de comandos de bq.
• Usa el envío de un trabajo extract a través de la API o las bibliotecas cliente

Puedes 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

Exporta muestras y formatos 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 una muestra de archivos que se escriben en el bucket de Cloud Storage.

Tipo de modelo	Formato del modelo de exportación	Archivos exportados de muestra
AUTOML_CLASSIFIER	Modelo guardado de TensorFlow (TF 2.1.0)	gcs_bucket/   assets/     f1.txt     f2.txt   saved_model.pb   variables/     variables.data-00-of-01     variables.index
AUTOML_REGRESSOR
CODIFICADOR AUTOMÁTICO	Modelo guardado de TensorFlow (TF 1.15 o posterior)
DNN_CLASSIFIER
DNN_REGRESSOR
DNN_LINEAR_COMBINED_CLASSIFIER
DNN_LINEAR_COMBINED_REGRESSOR
KMEANS
LINEAR_REGRESSOR
LOGISTIC_REG
MATRIX_FACTORIZATION
PCA
TRANSFORM_ONLY
BOOSTED_TREE_CLASSIFIER	Booster (XGBoost 0.82)	gcs_bucket/   assets/     0.txt     1.txt     model_metadata.json   main.py   model.bst   xgboost_predictor-0.1.tar.gz     ....      predictor.py     .... main.py es para la ejecución local. Consulta Implementación de modelos para obtener más detalles.
BOOSTED_TREE_REGRESSOR
RANDOM_FOREST_REGRESSOR
RANDOM_FOREST_REGRESSOR
TENSORFLOW (importado)	Modelo guardado de TensorFlow	Los mismos archivos que estaban presentes cuando se importó el modelo

Nota: El procesamiento previo de los datos automático que se hace durante la creación del modelo, como la estandarización y la codificación de etiquetas, se guarda en los archivos exportados como parte del grafo de modelo guardado de TensorFlow y en los archivos externos de Booster. El procesamiento previo explícito es innecesario antes de pasar los datos para la predicción. Por lo general, la entrada debe coincidir con la que se usa para ML.PREDICT de BigQuery ML. Todos los valores numéricos de las firmas del modelo exportado se convierten como tipo de datos FLOAT64. Además, todos los campos STRUCT se deben expandir en campos independientes. Por ejemplo, se debe cambiar el nombre del campo f1 en STRUCT f2 a f2_f1 y pasarlo como una columna independiente.

Exporta modelo entrenado con TRANSFORM

Si el modelo está entrenado con la cláusula TRANSFORM, un modelo de procesamiento previo adicional ejecuta la misma lógica en la cláusula TRANSFORM y se guarda en formato de modelo guardado de TensorFlow en el subdirectorio transform. Puedes implementar un modelo entrenado con la cláusula TRANSFORM en Vertex AI y de forma local. Para obtener más información, consulta Implementación de modelos.

Formato del modelo de exportación	Archivos exportados de muestra
Modelo de predicción: Modelo guardado de TensorFlow o Booster (XGBoost 0.82). Modelo de procesamiento previo para la cláusula TRANSFORM: modelo guardado de TensorFlow (TF 2.5 o versiones posteriores)	gcs_bucket/   ....(model files)   transform/     assets/         f1.txt/         f2.txt/     saved_model.pb     variables/         variables.data-00-of-01         variables.index

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 declaración SELECT. Por lo tanto, deberás convertir manualmente los datos de entrada antes de que lo haga el feed al modelo de procesamiento previo.

Tipos de datos admitidos

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

Tipo de entrada TRANSFORM	Muestras de entrada de TRANSFORM	Muestras de entrada del modelo de procesamiento previo exportado
INT64	10, 11	tf.constant(   [10, 11],   dtype=tf.int64)
NUMERIC	NUMERIC 10, NUMERIC 11	tf.constant(   [10, 11],   dtype=tf.float64)
BIGNUMERIC	BIGNUMERIC 10, BIGNUMERIC 11	tf.constant(   [10, 11],   dtype=tf.float64)
FLOAT64	10.0, 11.0	tf.constant(   [10, 11],   dtype=tf.float64)
BOOL	TRUE, FALSE	tf.constant(   [True, False],   dtype=tf.bool)
STRING	'abc', 'def'	tf.constant(   ['abc', 'def'],   dtype=tf.string)
BYTES	b'abc', b'def'	tf.constant(   ['abc', 'def'],   dtype=tf.string)
DATE	DATE '2020-09-27', DATE '2020-09-28'	tf.constant(   [     '2020-09-27',     '2020-09-28'   ],   dtype=tf.string) "%F" format
DATETIME	DATETIME '2023-02-02 02:02:01.152903', DATETIME '2023-02-03 02:02:01.152903'	tf.constant(   [     '2023-02-02 02:02:01.152903',     '2023-02-03 02:02:01.152903'   ],   dtype=tf.string) "%F %H:%M:%E6S" format
TIME	TIME '16:32:36.152903', TIME '17:32:36.152903'	tf.constant(   [     '16:32:36.152903',     '17:32:36.152903'   ],   dtype=tf.string) "%H:%M:%E6S" format
TIMESTAMP	TIMESTAMP '2017-02-28 12:30:30.45-08', TIMESTAMP '2018-02-28 12:30:30.45-08'	tf.constant(   [     '2017-02-28 20:30:30.4 +0000',     '2018-02-28 20:30:30.4 +0000'   ],   dtype=tf.string) "%F %H:%M:%E1S %z" format
ARRAY	['a', 'b'], ['c', 'd']	tf.constant(   [['a', 'b'], ['c', 'd']],   dtype=tf.string)
ARRAY< STRUCT< INT64, FLOAT64>>	[(1, 1.0), (2, 1.0)], [(2, 1.0), (3, 1.0)]	tf.sparse.from_dense(   tf.constant(     [       [0, 1.0, 1.0, 0],       [0, 0, 1.0, 1.0]     ],     dtype=tf.float64))
NULL	NULL, NULL	tf.constant(   [123456789.0e10, 123456789.0e10],   dtype=tf.float64) tf.constant(   [1234567890000000000, 1234567890000000000],   dtype=tf.int64) tf.constant(   [' __MISSING__ ', ' __MISSING__ '],   dtype=tf.string)

Funciones de SQL compatibles

Cuando exportas 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, 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, 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 string
  • 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 procesamiento previo 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

Cuando se exportan modelos, se aplican las siguientes limitaciones:

• La exportación de modelos no se admite si se usó alguno de los siguientes atributos durante el entrenamiento:

  • Los tipos de funciones ARRAY, TIMESTAMP o GEOGRAPHY estaban presentes en los datos de entrada.

• Los modelos exportados para los tipos de modelos AUTOML_REGRESSOR y AUTOML_CLASSIFIER no admiten la implementación de Vertex AI para la predicción en línea.

• 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 disminuir el tamaño del modelo si alcanzas el límite.

• Para modelos entrenados con la cláusula TRANSFORM de BigQuery ML para el procesamiento previo de los atributos manuales, consulta Tipos de datos y las funciones admitidas para la exportación.

• Los modelos entrenados con la cláusula TRANSFORMde BigQuery ML antes del 18 de septiembre de 2023, se deben volver a entrenar antes de que se puedan implementar a través de Model Registry para la predicción en línea.

• Durante la exportación del modelo, ARRAY<STRUCT<INT64, FLOAT64>>, ARRAY y TIMESTAMP son compatibles como datos transformados previamente, pero no son compatibles como datos postransformados.

Exporta modelos de BigQuery ML

Para exportar un modelo, haz lo siguiente:

Console

1. Abre la página BigQuery en la consola de Google Cloud.
   

   Ir a la página de BigQuery

2. En el panel de navegación, en la sección Recursos (Resources), expande tu proyecto y haz clic en un conjunto de datos para expandirlo. Busca el modelo que deseas exportar y haz clic en él.

3. En el lado derecho de la ventana, haz clic en Export Model (Exportar modelo).

   

4. En el diálogo Exportar modelo a Cloud Storage, haz lo siguiente:

   • En Elegir ubicación de Cloud Storage, busca la ubicación de la carpeta o el depósito al que deseas exportar el modelo.
   • Para exportar el modelo, haz clic en Exportar.

Para verificar el progreso del trabajo, busca en la parte superior de la página el Historial de trabajo para un trabajo de exportación.

SQL

La sentencia EXPORT MODEL te permite exportar modelos de BigQuery ML a Cloud Storage con la sintaxis de consulta de GoogleSQL.

Para exportar un modelo de BigQuery ML en la consola de Google Cloud con la instrucción EXPORT MODEL, sigue estos pasos:

1. En la consola de Google Cloud, abre la página de BigQuery.

   Ir a BigQuery

2. Haz clic en Redactar consulta nueva.

3. En el campo Editor de consultas, escribe la sentencia EXPORT MODEL.

   En la siguiente consulta, se exporta un modelo llamado myproject.mydataset.mymodel a un bucket de Cloud Storage con el URI gs://bucket/path/to/saved_model/.

    EXPORT MODEL `myproject.mydataset.mymodel`
    OPTIONS(URI = 'gs://bucket/path/to/saved_model/')
    

4. Haz clic en Ejecutar. Cuando se completa la consulta, aparece lo siguiente en el panel Resultados de la consulta: Successfully exported model.

bq

Nota: Para exportar un modelo con la herramienta de línea de comandos de bq, debes tener la versión 2.0.56 o posterior de la herramienta de bq que está incluida con la versión 287.0.0 y posteriores de la CLI de gcloud. Para ver la instalación de la versión de la herramienta de bq, usa bq version y, si es necesario, actualiza la CLI de gcloud con gcloud components update.

Usa el comando bq extract con la marca --model.

Proporciona la marca --destination_format y elige el formato del modelo exportado (opcional). Proporciona la marca --location y establece el valor según la ubicación (opcional).

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

Aquí:

• location es el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes establecer el valor de la marca en asia-northeast1. Puedes configurar un valor predeterminado para la ubicación mediante el archivo .bigqueryrc.
• destination_format es el formato para el modelo exportado: ML_TF_SAVED_MODEL (predeterminado) o ML_XGBOOST_BOOSTER.
• project_id es el ID del proyecto.
• dataset es el nombre del conjunto de datos de origen.
• model es el modelo que exportas.
• bucket es el nombre del depósito de Cloud Storage al que deseas exportar los datos. El conjunto de datos de BigQuery y el depósito de Cloud Storage deben estar en la misma ubicación.
• model_folder es el nombre de la carpeta en la que se escribirán los archivos del modelo que se exportó.

Ejemplos:

Por ejemplo, mediante el siguiente comando, se exporta mydataset.mymodel en formato de modelo guardado de TensorFlow a un depósito de Cloud Storage llamado mymodel_folder.

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

El valor predeterminado de destination_format es ML_TF_SAVED_MODEL.

El siguiente comando exporta mydataset.mymodel en formato booster de XGBoost a un depósito de Cloud Storage llamado mymodel_folder.

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

API

Para exportar el modelo, crea un trabajo extract y propaga la configuración del trabajo.

Especifica tu ubicación en la propiedad location de la sección jobReference del recurso de trabajo (opcional).

1. Crea un trabajo de extracción que apunte al modelo de BigQuery ML y al destino de Cloud Storage.

2. Especifica el modelo de origen mediante el objeto de configuración sourceModel que contiene el ID del proyecto, el ID del conjunto de datos y el ID del modelo.

3. La propiedad destination URI(s) debe estar completamente calificada en el formato gs://bucket/model_folder.

4. Configura la propiedad configuration.extract.destinationFormat para especificar el formato de destino. Por ejemplo, para exportar un modelo de árbol mejorado, establece esta propiedad en el valor ML_XGBOOST_BOOSTER.

5. Para verificar el estado del trabajo, llama a jobs.get(job_id) con el ID del trabajo que se muestra en la solicitud inicial.

   • Si se muestra status.state = DONE, el trabajo se completó de forma correcta.
   • Si la propiedad status.errorResult está presente, la solicitud falló y ese objeto incluirá información que describa qué salió mal.
   • Si status.errorResult está ausente, el trabajo finalizó de forma correcta, aunque puede que haya habido algunos errores recuperables. Los errores recuperables se enumeran en la propiedad status.errors del objeto de trabajo que se muestra.

Notas sobre la API:

• Se recomienda que generes un ID único y lo pases como jobReference.jobId cuando llames a jobs.insert para crear un trabajo. Este enfoque es más resistente a las fallas de la red porque el cliente puede sondear o reintentar con el ID de trabajo conocido.

• Llamar a jobs.insert con un ID de trabajo determinado es idempotente. En otras palabras, puedes volver a intentarlo tantas veces como desees con el mismo ID de trabajo y, como máximo, solo una de esas operaciones funcionará.

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Implementación del modelo

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

Implementación de Vertex AI

Formato del modelo de exportación	Implementación
Modelo guardado de Tensorflow (modelos que no son de AutoML)	Implementa un modelo guardado de TensorFlow. Debes crear el archivo del modelo guardado con una versión compatible de TensorFlow.
Modelo guardado de Tensorflow (modelos de AutoML)	No compatible.
Booster de XGBoost	Usa una rutina de predicción personalizada. En el caso de los modelos de XGBoost Booster, la información de procesamiento previo y posterior se guarda en los archivos exportados, y una rutina de predicción personalizada te permite implementar el modelo con los archivos exportados adicionales. Debes crear los archivos del modelo con una versión compatible de XGBoost.

Implementación local

Formato del modelo de exportación	Implementación
Modelo guardado de Tensorflow (modelos que no son de AutoML)	El modelo guardado es un formato estándar y puedes implementarlo en el contenedor de Docker de Tensorflow Serving. También puedes aprovechar la ejecución local de la predicción en línea de Vertex AI.
Modelo guardado de Tensorflow (modelos de AutoML)	Ejecuta el contenedor de AutoML.
Booster de XGBoost	Para ejecutar modelos booster de XGBoost de manera local, puedes usar el archivo main.py exportado: Descarga todos los archivos desde Cloud Storage al directorio local. Descomprime el archivo predictor.py de xgboost_predictor-0.1.tar.gz en el directorio local. Ejecuta main.py (consulta las instrucciones en main.py).

Formato del resultado de la predicción

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

CODIFICADOR AUTOMÁTICO

Formato del resultado de la predicción	Ejemplo de resultado
+------------------------+------------------------+------------------------+ | 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

Formato del resultado de la predicción	Ejemplo de resultado
+------------------------------------------+ | predictions | +------------------------------------------+ | [{"scores":[FLOAT], "classes":[STRING]}] | +------------------------------------------+	+---------------------------------------------+ | predictions | +---------------------------------------------+ | [{"scores":[1, 2], "classes":['a', 'b']}, | | {"scores":[3, 0.2], "classes":['a', 'b']}] | +---------------------------------------------+

AUTOML_REGRESSOR

Formato del resultado de la predicción	Ejemplo de resultado
+-----------------+ | predictions | +-----------------+ | [FLOAT] | +-----------------+	+-----------------+ | predictions | +-----------------+ | [1.8, 2.46] | +-----------------+

BOOSTED_TREE_CLASSIFIER y RANDOM_FOREST_CLASSIFIER

Formato del resultado de la predicción	Ejemplo de resultado
+-------------+--------------+-----------------+ | 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

Formato del resultado de la predicción	Ejemplo de resultado
+-----------------+ | predicted_label | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | predicted_label | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

DNN_CLASSIFIER

Formato del resultado de la predicción

Ejemplo de resultado

+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | 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

Formato del resultado de la predicción	Ejemplo de resultado
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

DNN_LINEAR_COMBINED_CLASSIFIER

Formato del resultado de la predicción

Ejemplo de resultado

+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | 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

Formato del resultado de la predicción	Ejemplo de resultado
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

KMEANS

Formato del resultado de la predicción	Ejemplo de resultado
+--------------------+--------------+---------------------+ | 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

Formato del resultado de la predicción	Ejemplo de resultado
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

LOGISTIC_REG

Formato del resultado de la predicción	Ejemplo de resultado
+-------------+--------------+-----------------+ | 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: Por el momento, solo admitimos un usuario de entrada y los primeros 50 pares de resultado (predicted_rating, predicted_item) ordenados por predicted_rating de forma descendente.

Formato del resultado de la predicción	Ejemplo de resultado
+--------------------+--------------+ | PREDICTED_RATING | PREDICTED_ITEM | +------------------+----------------+ | [FLOAT] | [STRING] | +------------------+----------------+	+--------------------+--------------+ | PREDICTED_RATING | PREDICTED_ITEM | +------------------+----------------+ | [5.5, 1.7] | ['A', 'B'] | +------------------+----------------+ | [7.2, 2.7] | ['B', 'A'] | +------------------+----------------+

TENSORFLOW (importado)

Formato del resultado de la predicción
El mismo que el del modelo importado

PCA

Formato del resultado de la predicción	Ejemplo de resultado
+-------------------------+---------------------------------+ | PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS | +-------------------------+---------------------------------+ | [INT64] | [FLOAT] | +-------------------------+---------------------------------+	+-------------------------+---------------------------------+ | PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS | +-------------------------+---------------------------------+ | [1, 2] | [1.2, 5.0] | +-------------------------+---------------------------------+

TRANSFORM_ONLY

Formato del resultado de la predicción
Igual que las columnas especificadas en la cláusula TRANSFORM del modelo

Visualización del modelo XGBoost

Puedes visualizar los árboles mejorados mediante la API de Python plot_tree después de la exportación del modelo. Por ejemplo, puedes aprovechar Colab sin instalar las dependencias:

1. Exporta el modelo de árbol mejorado a un bucket de Cloud Storage.
2. Descarga el archivo model.bst del depósito de Cloud Storage.
3. En un notebook de Colab, sube el archivo model.bst a Files.

4. Ejecuta el siguiente código en el 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
   

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

Nota: Usamos el codificador de etiquetas a fin de codificar atributos categóricos, de modo que puedas obtener la categoría correspondiente para un valor de división del archivo de vocabulario en el directorio “assets/” dentro del depósito de Cloud Storage de exportación de modelos. Por ejemplo, cuando veas “f0 < 2.95” en un nodo, puedes hallar la categoría correspondiente en el archivo de vocabulario si buscas el tercer elemento.

En la actualidad, no guardamos nombres de atributos en el modelo, por lo que verás nombres como “f0”, “f1”, etcétera. Puedes encontrar los nombres de los atributos correspondientes en el archivo exportado assets/model_metadata.json con estos nombres (como “f0”) como índices.

Permisos necesarios

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

Permisos de BigQuery

• Para exportar el modelo, debes tener permisos bigquery.models.export como mínimo. Los siguientes roles predefinidos de Identity and Access Management (IAM) tienen permisos bigquery.models.export:

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

• Como mínimo, para ejecutar un trabajo de exportación, debes tener permisos bigquery.jobs.create. Las siguientes funciones predefinidas de IAM tienen permisos bigquery.jobs.create:

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

Permisos de Cloud Storage

• Para escribir los datos en un depósito de Cloud Storage existente, debes tener permisos storage.objects.create. Las siguientes funciones predefinidas de IAM tienen permisos storage.objects.create:

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

Para obtener más información sobre los permisos y los roles de IAM en BigQuery ML, consulta Control de acceso.

Consideraciones de ubicación

Cuando elijas una ubicación para tus datos, ten en cuenta esta información:

Coloca los buckets de Cloud Storage en la misma ubicación para exportar datos:
• Si tu conjunto de datos de BigQuery está en la multirregión EU, el bucket de Cloud Storage que contiene los datos que exportas debe estar en la misma ubicación o dentro de la multirregión. Por ejemplo, si tu conjunto de datos de BigQuery está en la multirregión EU, el bucket de Cloud Storage puede estar ubicado en la región europe-west1 de Bélgica, que está dentro de EU.

  Si tu conjunto de datos está en la multirregión US, puedes exportar datos a un bucket de Cloud Storage en cualquier ubicación.

• Si tu conjunto de datos está en una región, el bucket de Cloud Storage debe estar en la misma región. Por ejemplo, si tu conjunto de datos está en la región asia-northeast1 de Tokio, tu bucket de Cloud Storage no puede estar en la multirregión ASIA.
Desarrolla un plan de administración de datos:
• Si eliges un recurso de almacenamiento regional, como un conjunto de datos de BigQuery o un bucket de Cloud Storage, debes desarrollar un plan para administrar tus datos geográficamente.

Para obtener más información sobre las ubicaciones de Cloud Storage, consulta Ubicaciones de depósitos en la documentación de Cloud Storage.

Traslada los datos de BigQuery entre ubicaciones

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

Política de cuotas

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

Precios

No se aplican cargos 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 exportan los datos, se te cobra por almacenarlos en Cloud Storage. Para obtener más información, consulta la página Precios de Cloud Storage.

¿Qué sigue?

• Consulta el instructivo Exporta un modelo de BigQuery ML para la predicción en línea.