Exporter des modèles

Cette page explique comment exporter des modèles BigQuery ML. Vous pouvez exporter des modèles BigQuery ML vers Cloud Storage et les utiliser pour la prédiction en ligne, ou les modifier en langage Python. Vous pouvez exporter un modèle BigQuery ML à l'aide des méthodes suivantes :

• Utiliser la console Google Cloud.
• Utiliser l'instruction EXPORT MODEL.
• En utilisant la commande bq extract de l'outil de ligne de commande bq.
• En envoyant une tâche extract via l'API ou les bibliothèques clientes

Vous pouvez exporter les types de modèles suivants :

• 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 (modèles TensorFlow importés)
• PCA
• TRANSFORM_ONLY

Formats et exemples de modèles d'exportation

Le tableau suivant présente les formats de destination des exportations pour chaque type de modèle BigQuery ML et fournit un exemple des fichiers écrits dans le bucket Cloud Storage.

Type de modèle	Format du modèle d'exportation	Exemple de fichiers exportés
AUTOML_CLASSIFIER	TensorFlow SavedModel (version 2.1.0)	gcs_bucket/   assets/     f1.txt     f2.txt   saved_model.pb   variables/     variables.data-00-of-01     variables.index
AUTOML_REGRESSOR
AUTOENCODER	TensorFlow SavedModel (version TF 1.15 ou ultérieure)
DNN_CLASSIFIER
DNN_REGRESSOR
DNN_LINEAR_COMBINED_CLASSIFIER
DNN_LINEAR_COMBINED_REGRESSOR
KMEANS
LINEAR_REGRESSOR
LOGISTIC_REG
MATRIX_FACTORIZATION
ACP
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 est destiné à une exécution locale. Pour en savoir plus, consultez la section Déploiement du modèle.
BOOSTED_TREE_REGRESSOR
RANDOM_FOREST_REGRESSOR
RANDOM_FOREST_REGRESSOR
TENSORFLOW (importé)	Modèle SavedModel TensorFlow	Exactement les mêmes fichiers que lors de l'importation du modèle

Remarque : Le prétraitement automatique des données effectué lors de la création du modèle (tel que la standardisation et l'encodage des libellés) est enregistré dans les fichiers exportés (en tant que graphe pour TensorFlow SavedModel et dans les fichiers externes pour Booster). Un prétraitement explicite n'est pas nécessaire avant de transmettre des données pour la prédiction. L'entrée doit généralement correspondre à celle utilisée pour BigQuery ML ML.PREDICT. Toutes les valeurs numériques dans les signatures de modèle exporté sont converties en type de données FLOAT64. En outre, tous les champs STRUCT doivent être développés dans des champs distincts. Par exemple, le champ f1 de STRUCT f2 doit être renommé f2_f1 et transmis en tant que colonne distincte.

Exporter un modèle entraîné avec TRANSFORM

Si le modèle est entraîné avec la clause TRANSFORM, un modèle de prétraitement supplémentaire utilise la même logique dans la clause TRANSFORM et est enregistré au format TensorFlow SavedModel dans le sous-répertoire transform. Vous pouvez déployer un modèle entraîné avec la clause TRANSFORM sur Vertex AI ainsi qu'en local. Pour en savoir plus, consultez la section Déploiement de modèle.

Format du modèle d'exportation	Exemple de fichiers exportés
Modèle de prédiction : TensorFlow SavedModel ou Booster (XGBoost 0.82). Modèle de prétraitement pour la clause TRANSFORM : TensorFlow SavedModel (version TF 2.5 ou ultérieure)	gcs_bucket/   ....(model files)   transform/     assets/         f1.txt/         f2.txt/     saved_model.pb     variables/         variables.data-00-of-01         variables.index

Le modèle ne contient pas d'informations sur l'ingénierie des caractéristiques mise en œuvre en dehors de la clause TRANSFORM pendant l'entraînement. Par exemple, tout ce qui est dans l'instruction SELECT. Vous devez donc convertir manuellement les données d'entrée avant de les utiliser dans le modèle de prétraitement.

Types de données acceptés

Lors de l'exportation de modèles entraînés avec la clause TRANSFORM, les types de données suivants sont compatibles pour alimenter la clause TRANSFORM.

Type d'entrée TRANSFORM	Exemples d'entrées TRANSFORM	Échantillons d'entrée de modèle de prétraitement exportés
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)

Fonctions SQL compatibles

Lorsque vous exportez des modèles entraînés avec la clause TRANSFORM, vous pouvez utiliser les fonctions SQL suivantes dans la clause TRANSFORM.

• Opérateurs
  • +, -, *, /, =, <, >, <=, >=, !=, <>, [NOT] BETWEEN, [NOT] IN, IS [NOT] NULL, IS [NOT] TRUE, IS [NOT] FALSE, NOT, AND, OR.
• Expressions conditionnelles
  • CASE expr, CASE, COALESCE, IF, IFNULL, NULLIF.
• Fonctions mathématiques
  • 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.
• Fonctions de conversion
  • CAST AS INT64, CAST AS FLOAT64, CAST AS NUMERIC, CAST AS BIGNUMERIC, CAST AS STRING, SAFE_CAST AS INT64, SAFE_CAST AS FLOAT64
• Fonctions de chaîne
  • CONCAT, LEFT, LENGTH, LOWER, REGEXP_REPLACE, RIGHT, SPLIT, SUBSTR, SUBSTRING, TRIM, UPPER.
• Fonctions de date
  • Date, DATE_ADD, DATE_SUB, DATE_DIFF, DATE_TRUNC, EXTRACT, FORMAT_DATE, PARSE_DATE, SAFE.PARSE_DATE.
• Fonctions DATETIME
  • DATETIME, DATETIME_ADD, DATETIME_SUB, DATETIME_DIFF, DATETIME_TRUNC, EXTRACT, PARSE_DATETIME, SAFE.PARSE_DATETIME.
• Fonctions TIME
  • TIME, TIME_ADD, TIME_SUB, TIME_DIFF, TIME_TRUNC, EXTRACT, FORMAT_TIME, PARSE_TIME, SAFE.PARSE_TIME.
• Fonctions 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.
• Fonctions de prétraitement manuel
  • 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.

Limites

Les limites suivantes s'appliquent lors de l'exportation de modèles :

• L'exportation du modèle n'est pas possible si l'une des caractéristiques suivantes a été utilisée pendant l'entraînement :

  • Les types caractéristiques ARRAY, TIMESTAMP ou GEOGRAPHY étaient présents dans les données d'entrée.

• Les modèles exportés pour les types de modèle AUTOML_REGRESSOR et AUTOML_CLASSIFIER ne sont pas compatibles avec le déploiement de Vertex AI pour la prédiction en ligne.

• Pour l'exportation du modèle de factorisation matricielle, la taille du modèle est limitée à 1 Go. La taille du modèle est approximativement proportionnelle à num_factors. Si la limite est atteinte, vous pouvez donc réduire la valeur de num_factors pendant l'entraînement de façon à réduire la taille du modèle.

• Pour les modèles entraînés avec la clause TRANSFORM BigQuery ML pour le prétraitement manuel des caractéristiques, consultez les types de données et fonctions compatibles avec l'exportation.

• Les modèles entraînés avec la clause BigQuery MLTRANSFORM avant le 18 septembre 2023 doivent être réentraînés pour pouvoir être déployés via Model Registry pour la prédiction en ligne.

• Lors de l'exportation du modèle, ARRAY<STRUCT<INT64, FLOAT64>>, ARRAY et TIMESTAMP sont acceptés en tant que données prétransformées, mais pas en tant que données post-transformées.

Exporter des modèles BigQuery ML

Pour exporter un modèle, procédez comme suit :

Console

1. Ouvrez la page BigQuery dans la console Google Cloud.
   

   Accéder à BigQuery

2. Dans la section Ressources du panneau de navigation, développez votre projet et cliquez sur un ensemble de données pour le développer. Recherchez et cliquez sur le modèle que vous exportez.

3. Dans la fenêtre, à droite, cliquez sur Export Model (Exporter le modèle).

   

4. Dans la boîte de dialogue Exporter le modèle vers Cloud Storage, procédez comme suit :

   • Dans le champ Sélectionner l'emplacement Cloud Storage, recherchez l'emplacement du bucket ou du dossier dans lequel vous souhaitez exporter le modèle.
   • Cliquez sur Exporter pour exporter le modèle.

Pour vérifier la progression de la tâche, consultez en haut de la fenêtre de navigation l'historique de la tâche pour une tâche d'exportation.

SQL

L'instruction EXPORT MODEL vous permet d'exporter des modèles BigQuery ML vers Cloud Storage à l'aide de la syntaxe de requête GoogleSQL.

Pour exporter un modèle BigQuery ML dans la console Google Cloud à l'aide de l'instruction EXPORT MODEL, procédez comme suit :

1. Dans la console Google Cloud, ouvrez la page "BigQuery".

   Accéder à BigQuery

2. Cliquez sur Saisir une nouvelle requête.

3. Dans le champ Éditeur de requête, saisissez votre instruction EXPORT MODEL.

   La requête suivante permet d'exporter un modèle nommé myproject.mydataset.mymodel vers un bucket Cloud Storage avec l'URI URI gs://bucket/path/to/saved_model/.

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

4. Cliquez sur Run (Exécuter). Lorsque la requête est terminée, la ligne suivante apparaît dans le volet Résultats de la requête : Successfully exported model.

bq

Remarque : Pour exporter un modèle à l'aide de l'outil de ligne de commande bq, vous devez disposer de l'outil bq version 2.0.56 ou ultérieure, qui est inclus dans gcloud CLI version 287.0.0 et ultérieure. Pour afficher la version de l'outil bq installée, utilisez bq version et, si nécessaire, mettez à jour gcloud CLI à l'aide de gcloud components update.

Exécutez la commande bq extract avec l'option --model.

(Facultatif) Spécifiez l'option --destination_format et choisissez le format du modèle exporté. (Facultatif) Spécifiez l'option --location et définissez la valeur correspondant à votre emplacement.

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

Où :

• location est le nom du site. L'option --location est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc.
• destination_format est le format du modèle exporté : ML_TF_SAVED_MODEL (par défaut) ou ML_XGBOOST_BOOSTER.
• project_id est l'ID de votre projet.
• dataset est le nom de l'ensemble de données source.
• model est le modèle que vous exportez.
• bucket est le nom du bucket Cloud Storage vers lequel vous exportez les données. L'ensemble de données BigQuery et le bucket Cloud Storage doivent se trouver dans le même emplacement.
• model_folder est le nom du dossier dans lequel les fichiers de modèle exportés seront écrits.

Exemples :

Par exemple, la commande suivante exporte mydataset.mymodel au format TensorFlow SavedModel vers un bucket Cloud Storage nommé mymodel_folder.

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

La valeur par défaut de destination_format est ML_TF_SAVED_MODEL.

La commande suivante exporte mydataset.mymodel au format Booster XGBoost vers un bucket Cloud Storage nommé mymodel_folder.

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

API

Pour exporter le modèle, créez une tâche extract et renseignez la configuration de la tâche.

(Facultatif) Spécifiez votre emplacement dans la propriété location de la section jobReference de la ressource de tâche.

1. Créez une tâche d'extraction qui pointe vers le modèle BigQuery ML et la destination Cloud Storage.

2. Spécifiez le modèle source à l'aide de l'objet de configuration sourceModel qui contient l'ID du projet, l'ID de l'ensemble de données et l'ID du modèle.

3. La propriété destination URI(s) doit être complète, au format gs://bucket/model_folder.

4. Spécifiez le format de destination en définissant la propriété configuration.extract.destinationFormat. Par exemple, pour exporter un modèle en arbre de décision à boosting, définissez cette propriété sur la valeur ML_XGBOOST_BOOSTER.

5. Pour vérifier l'état de la tâche, appelez jobs.get(job_id) avec l'ID de la tâche renvoyée par la requête initiale.

   • Si la réponse est status.state = DONE, la tâche a bien été exécutée.
   • Si la propriété status.errorResult est présente, la requête a échoué. Cet objet inclura des informations décrivant le problème rencontré.
   • Si la propriété status.errorResult est absente, la tâche a bien été exécutée. Toutefois, des erreurs non fatales ont pu se produire. La propriété status.errors de l'objet de la tâche répertorie ces erreurs.

Remarques concernant l'API :

• Nous vous recommandons de générer un ID unique et de le transmettre en tant que jobReference.jobId lorsque vous appelez jobs.insert pour créer un job. Cette approche offre une protection plus robuste contre les pannes réseau, car le client peut lancer une requête ou effectuer de nouvelles tentatives en utilisant l'ID de job connu.

• L'appel de jobs.insert avec un ID de tâche donné est idempotent. En d'autres termes, vous pouvez effectuer autant de tentatives que vous le souhaitez avec le même ID de tâche. L'une de ces opérations tout au plus aboutira.

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Java.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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

Déploiement du modèle

Vous pouvez déployer le modèle exporté sur Vertex AI ainsi que localement. Si la clause TRANSFORM du modèle contient des fonctions de date, des fonctions de date et heure, des fonctions d'heure ou des fonctions temporelles, vous devez utiliser la bibliothèque bigquery-ml-utils dans le conteneur. La seule exception est si vous effectuez un déploiement via Model Registry, qui ne nécessite pas de modèles exportés ni de conteneurs de diffusion.

Déploiement sur Vertex AI

Format du modèle d'exportation	Déploiement
TensorFlow SavedModel (modèles autres qu'AutoML)	Déployer un modèle SavedModel TensorFlow Vous devez créer le fichier SavedModel à l'aide d'une version compatible de TensorFlow.
TensorFlow SavedModel (modèles AutoML)	Non compatible.
Booster XGBoost	Utilisez une routine de prédiction personnalisée. Pour les modèles Booster XGBoost, les informations de prétraitement et de post-traitement sont enregistrées dans les fichiers exportés, et une routine de prédiction personnalisée vous permet de déployer le modèle avec les fichiers exportés supplémentaires. Vous devez créer les fichiers du modèle à l'aide d'une version compatible de XGBoost.

Déploiement local

Format du modèle d'exportation	Déploiement
TensorFlow SavedModel (modèles autres qu'AutoML)	Le modèle SavedModel est un format standard que vous pouvez déployer dans le conteneur Docker de Tensorflow Serving. Vous pouvez également exploiter l'exécution locale de la prédiction en ligne Vertex AI.
TensorFlow SavedModel (modèles AutoML)	Exécutez le modèle dans des conteneurs.
Booster XGBoost	Pour exécuter des modèles Booster XGBoost localement, vous pouvez utiliser le fichier main.py exporté : Téléchargez tous les fichiers de Cloud Storage dans le répertoire local. Décompressez le fichier predictor.py de xgboost_predictor-0.1.tar.gz dans le répertoire local. Exécutez main.py (consultez les instructions dans main.py).

Format de sortie de la prédiction

Cette section fournit le format de sortie de la prédiction pour les modèles exportés et pour chaque type de modèle. Tous les modèles exportés sont compatibles avec la prédiction par lot. Ils peuvent gérer plusieurs lignes d'entrée à la fois. Par exemple, chacun des exemples de formats de sortie suivants contient deux lignes d'entrée.

AUTOENCODER

Format de sortie de la prédiction	Exemple de sortie
+------------------------+------------------------+------------------------+ | 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

Format de sortie de la prédiction	Exemple de sortie
+------------------------------------------+ | predictions | +------------------------------------------+ | [{"scores":[FLOAT], "classes":[STRING]}] | +------------------------------------------+	+---------------------------------------------+ | predictions | +---------------------------------------------+ | [{"scores":[1, 2], "classes":['a', 'b']}, | | {"scores":[3, 0.2], "classes":['a', 'b']}] | +---------------------------------------------+

AUTOML_REGRESSOR

Format de sortie de la prédiction	Exemple de sortie
+-----------------+ | predictions | +-----------------+ | [FLOAT] | +-----------------+	+-----------------+ | predictions | +-----------------+ | [1.8, 2.46] | +-----------------+

BOOSTED_TREE_CLASSIFIER et RANDOM_FOREST_CLASSIFIER

Format de sortie de la prédiction	Exemple de sortie
+-------------+--------------+-----------------+ | 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 et RANDOM_FOREST_REGRESSOR

Format de sortie de la prédiction	Exemple de sortie
+-----------------+ | predicted_label | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | predicted_label | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

DNN_CLASSIFIER

Format de sortie de la prédiction

Exemple de sortie

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

Format de sortie de la prédiction	Exemple de sortie
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

DNN_LINEAR_COMBINED_CLASSIFIER

Format de sortie de la prédiction

Exemple de sortie

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

Format de sortie de la prédiction	Exemple de sortie
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

KMEANS

Format de sortie de la prédiction	Exemple de sortie
+--------------------+--------------+---------------------+ | 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

Format de sortie de la prédiction	Exemple de sortie
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

LOGISTIC_REG

Format de sortie de la prédiction	Exemple de sortie
+-------------+--------------+-----------------+ | 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

Remarque : Pour le moment, nous n'acceptons que le type utilisateur en entrée et affichons les 50 meilleures paires en sortie (predicted_rating, predicted_item) triées dans l'ordre décroissant de predicted_rating.

Format de sortie de la prédiction	Exemple de sortie
+--------------------+--------------+ | PREDICTED_RATING | PREDICTED_ITEM | +------------------+----------------+ | [FLOAT] | [STRING] | +------------------+----------------+	+--------------------+--------------+ | PREDICTED_RATING | PREDICTED_ITEM | +------------------+----------------+ | [5.5, 1.7] | ['A', 'B'] | +------------------+----------------+ | [7.2, 2.7] | ['B', 'A'] | +------------------+----------------+

TENSORFLOW (importé)

Format de sortie de la prédiction
Identique au modèle importé

ACP

Format de sortie de la prédiction	Exemple de sortie
+-------------------------+---------------------------------+ | PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS | +-------------------------+---------------------------------+ | [INT64] | [FLOAT] | +-------------------------+---------------------------------+	+-------------------------+---------------------------------+ | PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS | +-------------------------+---------------------------------+ | [1, 2] | [1.2, 5.0] | +-------------------------+---------------------------------+

TRANSFORM_ONLY

Format de sortie de la prédiction
Identique aux colonnes spécifiées dans la clause TRANSFORM du modèle

Visualiser le modèle XGBoost

Vous pouvez visualiser les arbres de décision à boosting à l'aide de l'API Python plot_tree après l'exportation du modèle. Par exemple, vous pouvez exploiter Colab sans installer les dépendances :

1. Exportez le modèle d'arbre de décision à boosting vers un bucket Cloud Storage.
2. Téléchargez le fichier model.bst à partir du bucket Cloud Storage.
3. Dans un notebook Colab, importez le fichier model.bst dans Files.

4. Exécutez le code suivant dans le 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
   

Cet exemple représente plusieurs arbres (un par itération) :

Remarque : Nous utilisons l'encodeur de libellés pour encoder les caractéristiques catégorielles. Vous pouvez ainsi obtenir la catégorie correspondant à une valeur fractionnée à partir du fichier de vocabulaire du répertoire "assets/" dans le bucket Cloud Storage d'exportation du modèle. Par exemple, lorsque vous voyez "f0 < 2.95" dans un nœud, vous pouvez trouver la catégorie correspondante dans le fichier de vocabulaire en recherchant le troisième élément.

Actuellement, nous n'enregistrons pas les noms de caractéristiques dans le modèle. Vous verrez donc des noms tels que "f0", "f1", etc. Vous pouvez trouver les noms de caractéristiques correspondants dans le fichier exporté assets/model_metadata.json en utilisant ces noms (tels que "f0") comme index.

Autorisations requises

Pour exporter un modèle BigQuery ML vers Cloud Storage, vous devez disposer des autorisations d'accès au modèle BigQuery ML, des autorisations d'exécution d'une tâche d'exportation et des autorisations d'écriture des données dans le bucket Cloud Storage.

Autorisations BigQuery

• Pour exporter le modèle, vous devez au minimum disposer des autorisations bigquery.models.export. Les rôles IAM (Identity and Access Management) prédéfinis suivants disposent des autorisations bigquery.models.export :

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

• Pour exécuter une tâche d'exportation, vous devez au moins disposer des autorisations bigquery.jobs.create. Les rôles IAM prédéfinis suivants disposent des autorisations bigquery.jobs.create :

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

Autorisations Cloud Storage

• Pour écrire les données dans un bucket Cloud Storage existant, vous devez disposer des autorisations storage.objects.create. Les rôles IAM prédéfinis suivants disposent des autorisations storage.objects.create :

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

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery ML, consultez la page Contrôle des accès.

Considérations relatives aux emplacements

Lorsque vous choisissez un emplacement pour les données, envisagez d'entreprendre les actions suivantes :

Cohébergez vos buckets Cloud Storage pour exporter des données :
• Si votre ensemble de données BigQuery se trouve dans la zone multirégionale EU, le bucket Cloud Storage contenant les données que vous exportez doit se trouver dans la même zone multirégionale ou dans un emplacement inclus dans la zone multirégionale. Par exemple, si votre ensemble de données BigQuery se trouve dans la zone multirégionale EU, le bucket Cloud Storage peut être situé dans la région de Belgique europe-west1, qui se trouve dans l'Union européenne.

  Si votre ensemble de données se trouve dans la zone multirégionale US, vous pouvez exporter des données dans un bucket Cloud Storage situé à n'importe quel emplacement.

• Si votre ensemble de données se trouve dans une région, votre bucket Cloud Storage doit se situer dans la même région. Par exemple, si votre ensemble de données se trouve dans la région de Tokyo asia-northeast1, votre bucket Cloud Storage ne peut pas se trouver dans l'emplacement multirégional ASIA.
Élaborez un plan de gestion des données :
• Si vous choisissez une ressource de stockage régionale, telle qu'un ensemble de données BigQuery ou un bucket Cloud Storage, élaborez un plan de gestion géographique des données.

Pour en savoir plus sur les emplacements Cloud Storage, consultez la page Emplacements des buckets dans la documentation de Cloud Storage.

Déplacer des données BigQuery entre des emplacements

Il n'est pas possible de modifier l'emplacement d'un ensemble de données après sa création. Toutefois, vous pouvez effectuer une copie de l'ensemble de données.

Règles de quotas

Pour en savoir plus sur les quotas appliqués aux tâches d'exportation, consultez la section Tâches d'exportation de la page "Quotas et limites".

Tarifs

L'exportation de modèles BigQuery ML est gratuite, mais les exportations sont soumises aux quotas et limites de BigQuery. Pour en savoir plus sur les tarifs de BigQuery, consultez la page Tarifs.

Une fois les données exportées, leur stockage dans Cloud Storage vous est facturé. Pour en savoir plus sur les tarifs de Cloud Storage, reportez-vous à la page Tarifs.

Étapes suivantes

• Suivez le tutoriel Exporter un modèle BigQuery ML pour la prédiction en ligne.