Instruction CREATE MODEL

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Instruction CREATE MODEL

Pour créer un modèle dans BigQuery, utilisez l'instruction BigQuery ML CREATE MODEL. Cette instruction est semblable à l'instruction LDD CREATE TABLE. Lorsque vous exécutez une requête en langage SQL standard contenant une instruction CREATE MODEL, une tâche de requête est générée automatiquement et traite votre requête.

Syntaxe de CREATE MODEL

{CREATE MODEL | CREATE MODEL IF NOT EXISTS | CREATE OR REPLACE MODEL}
model_name
[TRANSFORM (select_list)]
[OPTIONS(model_option_list)]
[AS query_statement]

model_option_list:
    MODEL_TYPE = { 'LINEAR_REG' | 'LOGISTIC_REG' | 'KMEANS' |
                   'TENSORFLOW' | 'MATRIX_FACTORIZATION' |
                   'AUTOML_CLASSIFIER' | 'AUTOML_REGRESSOR' |
                   'BOOSTED_TREE_CLASSIFIER' | 'BOOSTED_TREE_REGRESSOR' |
                   'DNN_CLASSIFIER' | 'DNN_REGRESSOR' }
    [, INPUT_LABEL_COLS = string_array ]
    [, OPTIMIZE_STRATEGY = { 'AUTO_STRATEGY' | 'BATCH_GRADIENT_DESCENT' | 'NORMAL_EQUATION' } ]
    [, L1_REG = float64_value ]
    [, L2_REG = float64_value ]
    [, MAX_ITERATIONS = int64_value ]
    [, LEARN_RATE_STRATEGY = { 'LINE_SEARCH' | 'CONSTANT' } ]
    [, LEARN_RATE = float64_value ]
    [, EARLY_STOP = { TRUE | FALSE } ]
    [, MIN_REL_PROGRESS = float64_value ]
    [, DATA_SPLIT_METHOD = { 'AUTO_SPLIT' | 'RANDOM' | 'CUSTOM' | 'SEQ' | 'NO_SPLIT' } ]
    [, DATA_SPLIT_EVAL_FRACTION = float64_value ]
    [, DATA_SPLIT_COL = string_value ]
    [, LS_INIT_LEARN_RATE = float64_value ]
    [, WARM_START = { TRUE | FALSE } ]
    [, AUTO_CLASS_WEIGHTS = { TRUE | FALSE } ]
    [, CLASS_WEIGHTS = struct_array ]
    [, NUM_CLUSTERS = int64_value ]
    [, KMEANS_INIT_METHOD = { 'RANDOM' | 'KMEANS++' | 'CUSTOM' } ]
    [, KMEANS_INIT_COL = string_value ]
    [, DISTANCE_TYPE = { 'EUCLIDEAN' | 'COSINE' } ]
    [, STANDARDIZE_FEATURES = { TRUE | FALSE } ]
    [, MODEL_PATH = string_value ]
    [, BUDGET_HOURS = float64_value ]
    [, FEEDBACK_TYPE = {'EXPLICIT' | 'IMPLICIT'} ]
    [, NUM_FACTORS = int64_value ]
    [, USER_COL = string_value ]
    [, ITEM_COL = string_value ]
    [, RATING_COL = string_value ]
    [, WALS_ALPHA = float64_value ]
    [, BOOSTER_TYPE = { 'gbtree' | 'dart'} ]
    [, NUM_PARALLEL_TREE = int64_value ]
    [, DART_NORMALIZE_TYPE = { 'tree' | 'forest'} ]
    [, TREE_METHOD = { 'auto' | 'exact' | 'approx' | 'hist'} ]
    [, MIN_TREE_CHILD_WEIGHT = float64_value ]
    [, COLSAMPLE_BYTREE = float64_value ]
    [, COLSAMPLE_BYLEVEL = float64_value ]
    [, COLSAMPLE_BYNODE = float64_value ]
    [, MIN_SPLIT_LOSS = float64_value ]
    [, MAX_TREE_DEPTH = int64_value ]
    [, SUBSAMPLE = float64_value ])
    [, ACTIVATION_FN = { 'RELU' | 'RELU6' | 'CRELU' | 'ELU' | 'SELU' | 'SIGMOID' | 'TANH' } ]
    [, BATCH_SIZE = int64_value ]
    [, DROPOUT = float64_value ]
    [, HIDDEN_UNITS = int_array ]
    [, OPTIMIZER = { 'ADAGRAD' | 'ADAM' | 'FTRL' | 'RMSPROP' | 'SGD' } ]
    [, TIME_SERIES_TIMESTAMP_COL = string_value ]
    [, TIME_SERIES_DATA_COL = string_value ]
    [, TIME_SERIES_ID_COL = string_value ]
    [, HORIZON = int64_value ]
    [, AUTO_ARIMA = { TRUE | FALSE } ]
    [, AUTO_ARIMA_MAX_ORDER = int64_value ]
    [, NON_SEASONAL_ORDER = (int64_value, int64_value, int64_value) ]
    [, DATA_FREQUENCY = { 'AUTO_FREQUENCY' | 'HOURLY' | 'DAILY' | 'WEEKLY' |
                          'MONTHLY' | 'QUARTERLY' | 'YEARLY' } ]
    [, INCLUDE_DRIFT = { TRUE | FALSE } ]
    [, HOLIDAY_REGION = { 'GLOBAL' | 'NA' | 'JAPAC' | 'EMEA' | 'LAC' | 'AE' | ... } ]

Toutes les options ne s'appliquent pas à certains types de modèles. Pour les modèles TensorFlow, consultez la page Instruction CREATE MODEL pour l'importation de modèles TensorFlow. Pour les modèles AutoML Tables, consultez la page Instruction CREATE MODEL pour l'entraînement de modèles AutoML Tables.

CREATE MODEL

Crée et entraîne un modèle dans l'ensemble de données spécifié. Si le nom du modèle existe, CREATE MODEL renvoie une erreur.

CREATE MODEL IF NOT EXISTS

Crée et entraîne un modèle uniquement si celui-ci n'existe pas déjà dans l'ensemble de données spécifié.

CREATE OR REPLACE MODEL

Crée et entraîne un modèle. Permet également de remplacer un modèle existant du même nom dans l'ensemble de données spécifié.

model_name

model_name est le nom du modèle que vous créez ou remplacez. Le nom du modèle doit être unique pour chaque ensemble de données. Aucun autre modèle, ni table ne peut porter le même nom. Le nom du modèle doit respecter les mêmes règles de dénomination que celles des tables BigQuery. Un nom de modèle peut :

  • contenir jusqu'à 1 024 caractères ;
  • contenir des lettres (majuscules ou minuscules), des chiffres et des traits de soulignement.

model_name n'est pas sensible à la casse.

Si aucun projet par défaut n'est configuré, ajoutez l'ID du projet au nom de l'ensemble de données selon le format suivant : `[PROJECT_ID].[DATASET].[MODEL]` (en intégrant les accents graves), par exemple, `myproject.mydataset.mymodel`.

TRANSFORM

L'action TRANSFORM permet de spécifier tous les prétraitements lors de la création du modèle et de les appliquer automatiquement lors de la prédiction et de l'évaluation.

Par exemple, vous pouvez créer le modèle suivant :

CREATE OR REPLACE MODEL m
  TRANSFORM(ML.FEATURE_CROSS(STRUCT(f1, f2)) as cross_f,
            ML.QUANTILE_BUCKETIZE(f3) OVER() as buckets,
            label_col)
  OPTIONS(model_type=’linear_reg’, input_label_cols=['label_col'])
AS SELECT * FROM t

Pendant la prédiction, vous n'avez pas besoin de prétraiter à nouveau l'entrée, et les mêmes transformations sont automatiquement restaurées :

SELECT * FROM ML.PREDICT(MODEL m, (SELECT f1, f2, f3 FROM table))

Lorsque la clause TRANSFORM est présente, seules les colonnes de résultats de la clause TRANSFORM sont utilisées lors de l'entraînement. Tous les résultats de query_statement qui n'apparaissent pas dans la clause TRANSFORM sont ignorés.

Les colonnes d'entrée de la clause TRANSFORM sont le résultat de query_statement. La dernière entrée utilisée lors de l'entraînement est l'ensemble des colonnes générées par la requête suivante :

SELECT (select_list) FROM (query_statement);

Les colonnes d'entrée de la clause TRANSFORM peuvent être de type SIMPLE ou ARRAY de type SIMPLE. Les types SIMPLE sont des types de données non-STRUCT et non-ARRAY.

Lors de la prédiction ML.PREDICT, les utilisateurs ont seulement besoin de transmettre les colonnes d'origine de query_statement qui sont utilisées dans la clause TRANSFORM. Les colonnes ignorées dans TRANSFORM n'ont pas à être fournies lors de la prédiction. TRANSFORM est automatiquement appliqué aux données d'entrée lors de la prédiction, y compris aux statistiques utilisées dans les fonctions d'analyse ML (par exemple, ML.QUANTILE_BUCKETIZE).

select_list

Vous pouvez transmettre les colonnes de query_statement pour l'entraînement du modèle sans transformation en utilisant *, * EXCEPT() ou en répertoriant directement les noms des colonnes.

Les colonnes de query_statement ne sont pas toutes requises dans la clause TRANSFORM. Vous pouvez donc supprimer certaines colonnes de query_statement en les omettant dans la clause TRANSFORM.

Vous pouvez transformer les entrées dans query_statement en utilisant des expressions dans select_list. select_list est semblable à une instruction SELECT normale. select_list accepte la syntaxe suivante :

  • *
  • * EXCEPT()
  • * REPLACE()
  • <var>expression</var>
  • <var>expression</var>.*

Les éléments suivants ne peuvent pas apparaître dans select_list :

  • Fonctions d'agrégation
  • Fonctions d'analyse non-ML. Toutes les fonctions d'analyse ML sont disponibles dans les fonctions de prétraitement.
  • Fonctions définies par l'utilisateur
  • Sous-requêtes
  • Colonnes anonymes. Par exemple, "a + b as c" est autorisé, contrairement à "a + b".

Les colonnes de résultats de select_list peuvent être de n'importe quel type de données accepté par BigQuery ML.

Si elles sont présentes, les colonnes suivantes doivent apparaître dans select_list sans transformation :

  • label
  • data_split_col
  • kmeans_init_col

Si ces colonnes sont renvoyées par query_statement, vous devez les référencer dans select_list par nom de colonne en dehors de toute expression, ou en utilisant *. L'utilisation d'un alias avec ces colonnes n'est pas autorisée.

model_option_list

model_option_list requiert l'option model_type. Toutes les autres options sont facultatives.

CREATE MODEL accepte les options suivantes :

MODEL_TYPE

Syntaxe

MODEL_TYPE = { 'LINEAR_REG' | 'LOGISTIC_REG' | 'KMEANS' | 'TENSORFLOW' |
'MATRIX_FACTORIZATION' | 'AUTOML_REGRESSOR' | 'AUTOML_CLASSIFIER' |
'BOOSTED_TREE_CLASSIFIER' | 'BOOSTED_TREE_REGRESSOR' | 'DNN_CLASSIFIER' |
'DNN_REGRESSOR' | 'ARIMA' }

Description

Spécifie le type de modèle. Cette option est obligatoire.

Arguments

'LINEAR_REG' : régression linéaire pour la prévision (par exemple, prévoir les ventes d'un article un jour donné). Les étiquettes ont une valeur réelle (elles ne peuvent pas avoir la valeur "+/- infinity", ni la valeur NaN).

'LOGISTIC_REG' : régression logistique pour la classification (par exemple, déterminer si un client va effectuer un achat). Ce modèle peut se présenter sous deux types différents :

  • Régression logistique binaire pour la classification (par exemple, déterminer si un client va effectuer un achat). Les étiquettes ne doivent avoir que deux valeurs possibles.
  • Régression logistique multiclasses pour la classification. Ces modèles permettent de prédire plusieurs valeurs possibles (par exemple, si une entrée est une "valeur faible", une "valeur moyenne" ou une "valeur élevée"). Chaque étiquette peut contenir jusqu'à 50 valeurs uniques. Dans BigQuery ML, l'entraînement par régression logistique multiclasses utilise un classifieur multinomial doté d'une fonction de perte d'entropie croisée.

'KMEANS' : clustering des k-moyennes pour la segmentation des données, par exemple, pour identifier des segments de clientèle. L’algorithme k-moyennes étant une technique d'apprentissage non supervisée, l'entraînement ou l'évaluation du modèle ne nécessitent pas d'étiquettes ni de données fractionnées.

'TENSORFLOW' permet de créer un modèle en important un modèle TensorFlow dans BigQuery ML. Consultez la page Instruction CREATE MODEL pour l'importation de modèles TensorFlow pour en savoir plus.

'MATRIX_FACTORIZATION' : factorisation matricielle pour les systèmes de recommandation. À titre d'exemple, la factorisation matricielle peut créer un modèle permettant de prédire la préférence d'un utilisateur pour des éléments auxquels il n'a jamais attribué de note ou avec lesquels il n'a jamais eu d'interaction. Pour cela, elle a besoin d'un ensemble d'utilisateurs et de préférences ou de notes pour un sous-ensemble d'éléments. Pour plus d'informations, consultez la page Instruction CREATE MODEL pour la factorisation matricielle.

'AUTOML_REGRESSOR' (version bêta) permet de créer un modèle de régression à l'aide d'AutoML Tables. Pour en savoir plus, consultez la page Instruction CREATE MODEL pour l'entraînement de modèles AutoML Tables.

'AUTOML_CLASSIFIER' (version bêta) permet de créer un modèle de classification à l'aide d'AutoML Tables. Pour en savoir plus, consultez la page Instruction CREATE MODEL pour l'entraînement de modèles AutoML Tables.

'BOOSTED_TREE_CLASSIFIER' (version bêta) permet de créer un modèle de classificateur d'arbre de décision à boosting à l'aide de la bibliothèque XGBoost. Pour en savoir plus, consultez la page Instruction CREATE MODEL pour les modèles en arbre de décision à boosting.

'BOOSTED_TREE_REGRESSOR' (version bêta) permet de créer un modèle de régresseur d'arbre de décision à boosting à l'aide de la bibliothèque XGBoost. Pour en savoir plus, consultez la page Instruction CREATE MODEL pour les modèles en arbre de décision à boosting.

'DNN_CLASSIFIER' (version bêta) permet de créer un modèle de classificateur de réseau de neurones profond. Pour en savoir plus, consultez la page Instruction CREATE MODEL pour les modèles DNN.

'DNN_REGRESSOR' (version bêta) permet de créer un modèle de régresseur de réseau de neurones profond. Pour en savoir plus, consultez la page Instruction CREATE MODEL pour les modèles DNN.

'ARIMA' Modèle univarié de séries temporelles basé sur ARIMA pour les prévisions de séries temporelles. Par exemple, pour une ou plusieurs séries temporelles, crée un modèle ou un ensemble de modèles de séries temporelles en une seule fois pour prévoir les points de données futurs. Pour en savoir plus, consultez la page Instruction CREATE MODEL pour les modèles de série temporelle.

INPUT_LABEL_COLS

Syntaxe

INPUT_LABEL_COLS = string_array

Description

Le(s) nom(s) de la colonne d'étiquette dans les données d'entraînement.

Arguments

string_array est une table (ARRAY) de chaînes (STRING). Les types de modèle de régression linéaire et de régression logistique ne sont compatibles qu'avec les valeurs string_array contenant un élément.

OPTIMIZE_STRATEGY

Syntaxe

OPTIMIZE_STRATEGY = { 'AUTO_STRATEGY' | 'BATCH_GRADIENT_DESCENT' | 'NORMAL_EQUATION' }

Description

La stratégie d'entraînement des modèles de régression linéaire.

Arguments

Accepte les valeurs suivantes :

'AUTO_STRATEGY' détermine la stratégie d'entraînement comme suit :

  • Si l1_reg ou warm_start est spécifié, la stratégie batch_gradient_descent est utilisée.
  • Si le nombre total de cardinalités des caractéristiques d'entraînement est supérieur à 10 000, la stratégie batch_gradient_descent est utilisée.
  • En cas de surentraînement (soit, si le nombre d'exemples d'entraînement est inférieur à 10x, où x correspond à la cardinalité totale), la stratégie batch_gradient_descent est utilisée.
  • La stratégie NORMAL_EQUATION est utilisée dans tous les autres cas.

'BATCH_GRADIENT_DESCENT' entraîne le modèle à l'aide de la méthode de descente de gradient de lot, qui optimise la fonction de perte à l'aide de la fonction de gradient.

'NORMAL_EQUATION' calcule directement la solution des moindre carrés pour résoudre le problème de régression linéaire avec la formule analytique. L'équation normale ne peut pas être utilisée dans les cas suivants :

  • l1_reg est spécifié.
  • warm_start est spécifié.
  • La cardinalité totale des caractéristiques d'entraînement est supérieure à 10 000.

La valeur par défaut est 'AUTO_STRATEGY'.

L1_REG

Syntaxe

L1_REG = float64_value

Description

La quantité de régularisation L1 appliquée.

Arguments

L'élément float64_value appartient au groupe FLOAT64. La valeur par défaut est 0.

L2_REG

Syntaxe

L2_REG = float64_value

Description

La quantité de régularisation L2 appliquée.

Arguments

L'élément float64_value appartient au groupe FLOAT64. La valeur par défaut est 0.

MAX_ITERATIONS

Syntaxe

MAX_ITERATIONS = int64_value

Description

Le nombre maximal d'itérations ou d'étapes d'entraînement.

Arguments

L'élément int64_value appartient au groupe INT64. La valeur par défaut est 20.

LEARN_RATE_STRATEGY

Syntaxe

LEARN_RATE_STRATEGY = { 'LINE_SEARCH' | 'CONSTANT' }

Description

La stratégie permettant de spécifier le taux d'apprentissage lors de l'entraînement.

Arguments

'LINE_SEARCH' utilise la méthode de recherche par ligne pour calculer le taux d'apprentissage. Le taux d'apprentissage initial pour la recherche par ligne correspond à la valeur spécifiée pour LS_INIT_LEARN_RATE.

La recherche par ligne ralentit l'entraînement et augmente le nombre d'octets traités. Toutefois, elle a tendance à converger, même avec un taux d'apprentissage initial spécifié supérieur.

'CONSTANT' définit le taux d'apprentissage sur la valeur spécifiée pour LEARN_RATE.

La valeur par défaut est 'LINE_SEARCH'.

LEARN_RATE

Syntaxe

LEARN_RATE = float64_value

Description

Taux d'apprentissage pour la descente de gradient lorsque LEARN_RATE_STRATEGY est défini sur CONSTANT. Si LEARN_RATE_STRATEGY est défini sur 'LINE_SEARCH', une erreur est renvoyée.

Arguments

L'élément float64_value appartient au groupe FLOAT64. La valeur par défaut est 0,1.

EARLY_STOP

Syntaxe

EARLY_STOP = { TRUE | FALSE }

Description

Indique si l'entraînement doit s'arrêter après la première itération pour laquelle l'amélioration de la perte relative est inférieure à la valeur spécifiée pour MIN_REL_PROGRESS.

Arguments

Il s'agit d'une valeur booléenne (BOOL). La valeur par défaut est TRUE.

MIN_REL_PROGRESS

Syntaxe

MIN_REL_PROGRESS = float64_value

Description

Valeur minimale de l'amélioration de la perte relative nécessaire pour poursuivre l'entraînement lorsque EARLY_STOP est défini sur "true". Par exemple, une valeur de 0,01 spécifie que chaque itération doit réduire la perte de 1 % pour que l'entraînement persiste.

Arguments

L'élément float64_value appartient au groupe FLOAT64. La valeur par défaut est 0,01.

DATA_SPLIT_METHOD

Syntaxe

DATA_SPLIT_METHOD = { 'AUTO_SPLIT' | 'RANDOM' | 'CUSTOM' | 'SEQ' | 'NO_SPLIT' }

Description

La méthode permettant de scinder les données d'entrée en ensembles d'entraînement et d'évaluation. Les données d'entraînement servent à entraîner le modèle. Les données d'évaluation permettent d'éviter le surentraînement via un arrêt prématuré.

Arguments

Accepte les valeurs suivantes :

'AUTO_SPLIT' : la stratégie de répartition automatique est la suivante :

  • Lorsque les données d'entrée comprennent moins de 500 lignes, toutes les lignes sont utilisées en tant que données d'entraînement.
  • Lorsque les données d'entrée comprennent entre 500 et 50 000 lignes, 20 % de ces données sont utilisées en tant que données d'évaluation dans une répartition RANDOM.
  • Lorsque les données d'entrée comprennent plus de 50 000 lignes, seules 10 000 d'entre elles sont utilisées en tant que données d'évaluation dans une répartition RANDOM.

'RANDOM' répartit les données de manière aléatoire. La répartition aléatoire est déterministe ; plusieurs entraînements différents produisent les mêmes résultats de répartition si les données d'entraînement sous-jacentes restent identiques.

'CUSTOM' répartit les données à l'aide d'une colonne de type BOOL fournie par le client. Les lignes dont la valeur est définie sur TRUE sont utilisées en tant que données d'évaluation. Les lignes dont la valeur est définie sur FALSE sont utilisées en tant que données d'entraînement.

'SEQ' répartit les données de manière séquentielle à l'aide d'une colonne fournie par le client. La colonne peut posséder n'importe quel type de données pouvant être triées : NUMERIC, BIGNUMERIC, STRING ou TIMESTAMP. Toutes les lignes dont les valeurs fractionnées sont inférieures au seuil sont utilisées en tant que données d'entraînement. Les lignes restantes, y compris les valeurs NULLs, sont utilisées en tant que données d'évaluation.

'NO_SPLIT' utilise toutes les données en tant que données d'entraînement.

La valeur par défaut est 'AUTO_SPLIT' pour les modèles de régression linéaire et de régression logistique.

La valeur par défaut est 'NO_SPLIT' pour les modèles de factorisation matricielle. Si vous décidez d'utiliser une autre méthode de répartition, assurez-vous d'avoir suffisamment de lignes dans l'ensemble d'entraînement pour tous les utilisateurs et tous les éléments, car cela déterminera la qualité du modèle créé.

Cette option n'est pas compatible avec les modèles TensorFlow ou de k-moyennes.

DATA_SPLIT_EVAL_FRACTION

Syntaxe

DATA_SPLIT_EVAL_FRACTION = float64_value

Description

Cette option est utilisée avec les répartitions 'RANDOM' et 'SEQ'. Elle spécifie la fraction des données utiles à l'évaluation, à deux décimales près.

Arguments

L'élément float64_value appartient au groupe FLOAT64. La valeur par défaut est 0,2.

DATA_SPLIT_COL

Syntaxe

DATA_SPLIT_COL = string_value

Description

Identifie la colonne permettant de répartir les données. Cette colonne ne peut pas être utilisée comme caractéristique, ni comme étiquette. Elle sera automatiquement exclue des caractéristiques.

  • Lorsque la valeur de DATA_SPLIT_METHOD est définie sur 'CUSTOM', la colonne correspondante doit être de type BOOL. Les lignes dont les valeurs sont définies sur TRUE ou NULL sont utilisées en tant que données d'évaluation. Les lignes dont les valeurs sont définies sur FALSE sont utilisées en tant que données d'entraînement.

  • Lorsque la valeur de DATA_SPLIT_METHOD est définie sur 'SEQ', les n dernières lignes par ordre de grandeur croissant dans la colonne correspondante sont utilisées en tant que données d'évaluation, où n correspond à la valeur spécifiée pour DATA_SPLIT_EVAL_FRACTION. Les premières lignes sont utilisées en tant que données d'entraînement.

Pour plus d'informations sur les types d'entrée compatibles, reportez-vous à la section Types d'entrée compatibles avec DATA_SPLIT_COL.

Pour en savoir plus sur l'utilisation de DATA_SPLIT_COL avec les types de modèles AutoML, consultez la page concernant l'instruction CREATE MODEL pour l'entraînement des modèles AutoML Tables.

Arguments

L'élément string_value appartient au groupe STRING.

LS_INIT_LEARN_RATE

Syntaxe

LS_INIT_LEARN_RATE = float64_value

Description

Définit le taux d'apprentissage initial utilisé par LEARN_RATE_STRATEGY='LINE_SEARCH'. Cette option ne peut être utilisée que si LINE_SEARCH est spécifié.

Si le modèle LEARN_RATE semble doubler à chaque itération, comme indiqué par ML.TRAINING_INFO, essayez de définir LS_INIT_LEARN_RATE sur le dernier taux d'apprentissage ayant été doublé. Le taux d'apprentissage initial optimal diffère selon chaque modèle. Un taux d'apprentissage initial adéquat pour un modèle peut être un taux d'apprentissage initial inadapté pour un autre modèle.

Arguments

L'élément float64_value appartient au groupe FLOAT64.

WARM_START

Syntaxe

WARM_START = { TRUE | FALSE }

Description

Entraîne à nouveau un modèle avec de nouvelles données d'entraînement, de nouvelles options de modèle, ou les deux. Sauf si elles ont été explicitement remplacées, les options initiales ayant servi à l'entraînement du modèle sont utilisées pour l'exécution du démarrage à chaud.

Lors d'un démarrage à chaud, le nombre d'itérations est réinitialisé pour repartir de zéro. Le nombre de TRAINING_RUN ou les colonnes TIMESTAMP peuvent servir à distinguer le démarrage à chaud de l'exécution initiale.

La valeur des options MODEL_TYPE et LABELS et le schéma de données d'entraînement doivent rester constants lors d'un démarrage à chaud. L'option warm_start n'est acceptée que pour le réentraînement des modèles LINEAR_REG, LOGISTIC_REG, KMEANS, DNN_REGRESSOR et DNN_CLASSIFIER.

Arguments

Accepte une valeur booléenne (BOOL). La valeur par défaut est FALSE.

AUTO_CLASS_WEIGHTS

Syntaxe

AUTO_CLASS_WEIGHTS = { TRUE | FALSE }

Description

Indique si les étiquettes de classe doivent être équilibrées à l'aide de pondérations pour chaque classe de manière inversement proportionnelle à la fréquence de cette classe.

À utiliser avec "boosted_tree_classifier", "DNN_CLASSIFIER" et des régressions logistique et multiclasses.

Par défaut, les données d'entraînement utilisées pour créer un modèle de régression logistique multiclasses, de classificateur d'arbre de décision à boosting ou de classificateur de DNN ne sont pas pondérées. Si les étiquettes des données d'entraînement sont déséquilibrées, le modèle peut apprendre à prédire en priorité la classe d'étiquettes la plus populaire, ce qui peut être indésirable.

Pour équilibrer chaque classe, définissez AUTO_CLASS_WEIGHTS sur TRUE. L'équilibre est effectué à l'aide de la formule suivante:

total_input_rows / (input_rows_for_class_n * number_of_unique_classes)

Arguments

Accepte une valeur booléenne (BOOL). La valeur par défaut est FALSE.

CLASS_WEIGHTS

Syntaxe

CLASS_WEIGHTS = struct_array

Description

Les pondérations à utiliser pour chaque étiquette de classe. Cette option ne peut pas être utilisée si AUTO_CLASS_WEIGHTS est spécifié.

Arguments

struct_array est une table (ARRAY) de structures (STRUCT) ; chaque STRUCT comprend une chaîne (STRING) contenant l'étiquette de classe et un FLOAT64 contenant la pondération de cette étiquette de classe. Une pondération doit figurer pour chaque étiquette de classe. La somme des pondérations n'a pas besoin d'être égale à 1. Exemple :

CLASS_WEIGHTS = [STRUCT('example_label', .2)]

NUM_CLUSTERS

Syntaxe

NUM_CLUSTERS = int64_value

Description

Pour un modèle de k-moyennes, il s'agit du nombre de clusters à identifier dans les données d'entrée.

Arguments

L'élément int64_value appartient au groupe INT64. Les valeurs autorisées sont comprises entre 2 et 100. La valeur par défaut est log10(n), où n correspond au nombre d'exemples d'entraînement.

KMEANS_INIT_METHOD

Syntaxe

KMEANS_INIT_METHOD = { 'RANDOM' | 'KMEANS++' | 'CUSTOM' }

Description

Pour un modèle de k-moyennes, il s'agit de la méthode d'initialisation des clusters.

Pour utiliser les mêmes centroïdes dans des requêtes CREATE MODEL répétées, spécifiez l'option 'CUSTOM'.

Arguments

'RANDOM' : initialise les centroïdes en sélectionnant de manière aléatoire des points de données NUM_CLUSTERS à partir des données d'entrée.

'KMEANS++' : initialise les centroïdes NUM_CLUSTERS à l'aide de l'algorithme KMEANS++. 'KMEANS++' entraîne un meilleur modèle que l'initialisation du cluster 'RANDOM'.

'CUSTOM' : initialise les centroïdes à l'aide d'une colonne fournie de type BOOL. Cette colonne est spécifiée par l'option 'KMEANS_INIT_COL'. BigQuery ML utilise les lignes dont la valeur est définie sur TRUE en tant que centroïdes initiaux. Lorsque cette option est présente et que les valeurs dans 'KMEANS_INIT_COL' sont constantes, les requêtes CREATE MODEL répétées utilisent les mêmes centroïdes.

La valeur par défaut est 'RANDOM'.

KMEANS_INIT_COL

Syntaxe

KMEANS_INIT_COL = string_value

Description

Pour un modèle de k-moyennes, identifie la colonne utilisée pour initialiser les centroïdes. Si cette colonne contient une valeur définie sur TRUE pour une ligne donnée, BigQuery ML utilise cette ligne en tant que centroïde initial.

Cette option ne peut être spécifiée que lorsque la valeur de 'KMEANS_INIT_METHOD' est définie sur 'CUSTOM'. La colonne correspondante doit être de type BOOL. L'option de modèle NUM_CLUSTERS doit être présente dans la requête et sa valeur doit être égale au nombre total de lignes TRUE de cette colonne. BigQuery ML ne peut pas utiliser cette colonne comme caractéristique. Elle sera automatiquement exclue des caractéristiques.

Arguments

L'élément string_value appartient au groupe STRING.

DISTANCE_TYPE

Syntaxe

DISTANCE_TYPE = { 'EUCLIDEAN' | 'COSINE' }

Description

Pour un modèle de k-moyennes, il s'agit du type de métriques permettant de calculer la distance entre deux points.

Arguments

Accepte les valeurs suivantes :

'EUCLIDEAN' calcule la distance entre le point x et le point y à l'aide de l'équation suivante :

$$ \lVert x-y\rVert_{2} $$

'COSINE' calcule la distance à l'aide de l'équation suivante :

$$ \sqrt{1-\frac{x \cdot y}{\lVert x\rVert_{2}\lVert y\rVert_{2}}} $$

où \( \lVert x\rVert_{2} \) représente la norme L2 pour x.

La valeur par défaut est 'EUCLIDEAN'.

STANDARDIZE_FEATURES

Syntaxe

STANDARDIZE_FEATURES = { TRUE | FALSE }

Description

Pour un modèle kmeans, indique s'il est nécessaire de standardiser les caractéristiques numériques.

Arguments

Accepte une valeur booléenne (BOOL). La valeur par défaut est TRUE.

MODEL_PATH

Syntaxe

MODEL_PATH = string_value

Description

Pour les types de modèle TensorFlow, spécifie l'emplacement du modèle TensorFlow à importer.

string_value correspond à l'emplacement d'un bucket Google Cloud Storage contenant le modèle à importer.

Consultez la page Instruction CREATE MODEL pour l'importation de modèles TensorFlow pour en savoir plus.

Exemple

MODEL_PATH = 'gs:////bucket/path/to/saved_model/*'

FEEDBACK_TYPE

Syntaxe

FEEDBACK_TYPE = { 'EXPLICIT' | 'IMPLICIT' }

Description

Spécifie le type de commentaire, pour les modèles de factorisation matricielle, qui modifie l'algorithme utilisé pendant l'entraînement.

Pour en savoir plus, reportez-vous aux modèles de factorisation matricielle.

Arguments

La valeur par défaut est 'EXPLICIT'.

NUM_FACTORS

Syntaxe

NUM_FACTORS = int64_value

Description

Spécifie le nombre de facteurs latents à utiliser pour les modèles de factorisation matricielle.

Arguments

L'élément int64_value appartient au groupe 'INT64'. Les valeurs autorisées sont comprises entre 2 et 200. La valeur par défaut est log2(n), où n correspond au nombre d'exemples d'entraînement.

USER_COL

Syntaxe

USER_COL = string_value

Description

Nom de la colonne utilisateur pour les modèles de factorisation matricielle.

Arguments

L'élément string_value appartient au groupe 'STRING'. La valeur par défaut est 'user'.

ITEM_COL

Syntaxe

ITEM_COL = string_value

Description

Nom de la colonne d'élément pour les modèles de factorisation matricielle.

Arguments

L'élément string_value appartient au groupe 'STRING'. La valeur par défaut est 'item'.

RATING_COL

Syntaxe

RATING_COL = string_value

Description

Nom de la colonne de note pour les modèles de factorisation matricielle.

Arguments

L'élément string_value appartient au groupe 'STRING'. La valeur par défaut est 'rating'.

WALS_ALPHA

Syntaxe

WALS_ALPHA = float64_value

Description

Hyperparamètre pour le modèle de factorisation matricielle 'IMPLICIT'. Pour en savoir plus, reportez-vous aux modèles de factorisation matricielle.

Arguments

L'élément float64_value appartient au groupe 'FLOAT64'. La valeur par défaut est 40.

BUDGET_HOURS

Syntaxe

BUDGET_HOURS = float64_value

Description

Définit le budget d'entraînement pour AutoML Tables, spécifié en heures. La valeur par défaut est 1.0. Sa valeur doit être comprise entre 1.0 et 72.0. Cette option ne peut être utilisée que si MODEL_TYPE est AUTOML_REGRESSOR ou AUTOML_CLASSIFIER.

Après avoir entraîné les modèles AutoML Tables, BigQuery ML compresse le modèle pour s'assurer qu'il est suffisamment petit pour l'importation, ce qui peut prendre jusqu'à 50 % du temps d'entraînement. Le temps de compression du modèle n'est pas inclus dans le budget d'entraînement.

Pour en savoir plus, consultez la page Instruction CREATE MODEL pour l'entraînement de modèles AutoML Tables.

Arguments

L'élément float64_value appartient au groupe FLOAT64.

BOOSTER_TYPE

Syntaxe

BOOSTER_TYPE =  { 'GBTREE' | 'DART'}

Description

Pour les modèles en arbre de décision à boosting, spécifiez le type de booster à utiliser, avec la valeur par défaut GBTREE.

Arguments

Les options suivantes sont disponibles :

NUM_PARALLEL_TREE

Syntaxe

NUM_PARALLEL_TREE = int64_value

Description

Nombre d'arbres parallèles créés à chaque itération. La valeur par défaut est 1. Pour entraîner une forêt d'arbres décisionnels à boosting, définissez cette valeur sur un nombre supérieur à 1.

DART_NORMALIZE_TYPE

Syntaxe

DART_NORMALIZE_TYPE = { 'TREE' | 'FOREST'}

Description

Type d'algorithme de normalisation pour booster DART. La valeur par défaut est TREE.

TREE_METHOD

Syntaxe

TREE_METHOD = { 'AUTO' | 'EXACT' | 'APPROX' | 'HIST'}

Description

Type d'algorithme de création d'arbre. La valeur par défaut est AUTO.

HIST est recommandé pour les ensembles de données volumineux afin d'accélérer l'entraînement et de réduire la consommation de ressources. Pour en savoir plus, consultez la section booster arbre.

MIN_TREE_CHILD_WEIGHT

Syntaxe

MIN_TREE_CHILD_WEIGHT = float64_value

Description

Somme minimale de poids d'instance nécessaire dans un enfant pour un partitionnement ultérieur. Si l'étape de partition d'arbre aboutit à un nœud feuille dont la somme de la pondération de l'instance est inférieure à min_tree_child_weight, le processus de compilation abandonne tout partitionnement ultérieur. Plus la valeur de min_tree_child_weight est élevée, plus l'algorithme est conservateur. Sa valeur doit être supérieure ou égale à 0, la valeur par défaut étant 1.

COLSAMPLE_BYTREE

Syntaxe

COLSAMPLE_BYTREE = float64_value

Description

Taux de sous-échantillonnage des colonnes lors de la création de chaque arbre. Le sous-échantillonnage a lieu une fois pour chaque arbre créé. Sa valeur doit être comprise entre 0 et 1, la valeur par défaut étant 1.

COLSAMPLE_BYLEVEL

Syntaxe

COLSAMPLE_BYLEVEL = float64_value

Description

Taux de sous-échantillonnage des colonnes pour chaque niveau. Le sous-échantillonnage a lieu une fois pour chaque nouveau niveau de profondeur atteint dans un arbre. Les colonnes sont sous-échantillonnées à partir de l'ensemble de colonnes choisi pour l'arbre actuel. Sa valeur doit être comprise entre 0 et 1, la valeur par défaut étant 1.

COLSAMPLE_BYNODE

Syntaxe

COLSAMPLE_BYNODE = float64_value

Description

Taux de sous-échantillonnage des colonnes pour chaque nœud (division). Le sous-échantillonnage a lieu chaque fois qu'une nouvelle division est évaluée. Les colonnes sont sous-échantillonnées à partir de l'ensemble de colonnes choisi pour le niveau actuel. Sa valeur doit être comprise entre 0 et 1, la valeur par défaut étant 1.

MIN_SPLIT_LOSS

Syntaxe

MIN_SPLIT_LOSS = float64_value

Description

Valeur minimale de la réduction de perte requise pour créer une partition ultérieure sur un nœud feuille de l'arbre. Plus la valeur de min_split_loss est élevée, plus l'algorithme est conservateur. La valeur par défaut est 0.

MAX_TREE_DEPTH

Syntaxe

MAX_TREE_DEPTH = int64_value

Description

Profondeur maximale d'un arbre. La valeur par défaut est 6.

SUBSAMPLE

Syntaxe

SUBSAMPLE = float64_value

Description

Taux de sous-échantillonnage des instances d'entraînement. Définir cette valeur sur 0,5 signifie que l'entraînement échantillonne de manière aléatoire la moitié des données d'entraînement avant la création des arbres, ce qui évite le surapprentissage. Le sous-échantillonnage a lieu une fois par itération de boosting. Cela est indépendant de la division des données de test et d'entraînement utilisée dans les options d'entraînement (80/20 aléatoire par défaut). Les données de test ne sont utilisées dans aucune itération, quel que soit le sous-échantillon. Celui-ci n'est appliqué qu'aux données d'entraînement. Sa valeur doit être comprise entre 0 et 1, la valeur par défaut étant 1.0 (utiliser toutes les données d'entraînement à chaque itération).

ACTIVATION_FN

Syntaxe

ACTIVATION_FN =  { 'RELU' | 'RELU6' | 'CRELU' | 'ELU' | 'SELU' | 'SIGMOID' | 'TANH' }

Description

Dans le cas des types de modèle de DNN, spécifie la fonction d'activation du réseau de neurones.

Arguments

Les options suivantes sont disponibles :

BATCH_SIZE

Syntaxe

BATCH_SIZE = int64_value

Description

Dans le cas des types de modèle de DNN, spécifie la taille de mini-lot des échantillons fournis au réseau de neurones.

Arguments

Sa valeur par défaut est soit 1 024, soit le nombre d'échantillons si celui-ci est inférieur à 1 024.

La valeur maximale est de 8 192.

DROPOUT

Syntaxe

DROPOUT = float64_value

Description

Dans le cas des types de modèle de DNN, spécifie le taux d'abandon des unités du réseau de neurones.

Arguments

La valeur par défaut est 0. Pour qu'elle soit valide, une entrée doit être comprise entre 0.0 et 1.0.

HIDDEN_UNITS

Syntaxe

HIDDEN_UNITS = int_array

Description

Dans le cas des types de modèle de DNN, spécifie les couches cachées du réseau de neurones.

Arguments

Tableau d'entiers représentant l'architecture des couches cachées. Si ce champ n'est pas spécifié, BigQuery ML applique une seule couche cachée ne contenant pas plus de 128 unités.

Exemple

HIDDEN_UNITS = [256, 128, 64]

Cet exemple représente une architecture à 3 couches cachées avec 256, 128 et 64 nœuds respectivement.

OPTIMIZER

Syntaxe

OPTIMIZER =  { 'ADAGRAD' | 'ADAM' | 'FTRL' | 'RMSPROP' | 'SGD' }

Description

Dans le cas des types de modèle de DNN, spécifie l'optimiseur pour l'entraînement du modèle.

Arguments

Les options suivantes sont disponibles :

TIME_SERIES_TIMESTAMP_COL

Syntaxe

TIME_SERIES_TIMESTAMP_COL = string_value

Description

Nom de la colonne d'horodatage pour les modèles de série temporelle.

Arguments

L'élément string_value appartient au groupe 'STRING'.

TIME_SERIES_DATA_COL

Syntaxe

TIME_SERIES_DATA_COL = string_value

Description

Nom de la colonne de données pour les modèles de série temporelle.

Arguments

L'élément string_value appartient au groupe 'STRING'.

TIME_SERIES_ID_COL

Syntaxe

TIME_SERIES_ID_COL = string_value

Description

Nom de la colonne "ID" pour les modèles de série temporelle. Cette colonne est utilisée lorsque l'utilisateur souhaite ajuster et prévoir plusieurs séries temporelles à l'aide d'une seule requête. Différents ID indiquent des séries temporelles distinctes.

Arguments

L'élément string_value appartient au groupe 'STRING'.

HORIZON

Syntaxe

HORIZON = int64_value

Description

Nombre de points temporels à prévoir. Lorsque vous prévoyez plusieurs séries temporelles simultanément, ce paramètre s'applique à chacune d'entre elles.

Arguments

Sa valeur est un INT64. La valeur par défaut est 1 000. La valeur maximale est 10 000.

AUTO_ARIMA

Syntaxe

AUTO_ARIMA = { TRUE | FALSE }

Description

Indique si le processus d'entraînement doit utiliser auto.ARIMA ou non. Si sa valeur est définie sur "true", l'entraînement recherche automatiquement le meilleur ordre non saisonnier (par exemple, le tuple p, d, q) et décide d'inclure ou non un terme de dérive linéaire lorsque d est égal à 1. Si sa valeur est définie sur "false", l'utilisateur doit spécifier "non_seasonal_order" dans la requête. Lorsque vous prévoyez plusieurs séries temporelles simultanément, l'algorithme auto.ARIMA doit être utilisé pour chaque série temporelle. Cette option ne doit donc pas être définie sur "false".

Arguments

Il s'agit d'une valeur booléenne (BOOL). La valeur par défaut est TRUE.

AUTO_ARIMA_MAX_ORDER

Syntaxe

AUTO_ARIMA_MAX_ORDER = <var>int64_value</var>

Description

Valeur maximale de la somme des valeurs de "p" et "q" non saisonniers. Contrôle l'espace de recherche de paramètres dans l'algorithme auto.ARIMA. Actuellement, les valeurs autorisées sont (2, 3, 4, 5). À titre de référence, pour chaque valeur, il existe (6, 10, 15, 21) modèles potentiels à évaluer si la valeur de "d" non saisonnier est définie sur 0 ou 2. Si la valeur de "d" non saisonnier est égale à 1, le nombre de modèles candidats à évaluer sera doublé, car un terme de dérive supplémentaire devra être pris en compte pour tous les modèles candidats existants. Cette option est désactivée lorsque AUTO_ARIMA est défini sur "false".

Arguments

Sa valeur est un INT64. La valeur par défaut est 5. La valeur minimale est 2 et la valeur maximale est 5.

NON_SEASONAL_ORDER

Syntaxe

NON_SEASONAL_ORDER = (int64_value, int64_value, int64_value)

Description

Tuple de "p, d, q" non saisonnier pour le modèle ARIMA. Aucune valeur par défaut n'existe. Vous devez donc toutes les spécifier. Vous devez spécifier explicitement "auto_arima" sur "false" pour utiliser cette option. Actuellement, "p" et "q" sont limités à [0, 1, 2, 3, 4, 5] et "d" à [0, 1, 2]. Lorsque vous prévoyez plusieurs séries temporelles simultanément, il est très peu probable qu'un ordre non saisonnier spécifique soit adapté à toutes les séries temporelles. L'algorithme auto.ARIMA permet donc de trouver le meilleur ordre non saisonnier pour chaque série temporelle. Par conséquent, cette option est désactivée dans ce cas.

Arguments

(int64_value, int64_value, int64_value) est un tuple de trois 'INT64'.

DATA_FREQUENCY

Syntaxe

DATA_FREQUENCY = { 'AUTO_FREQUENCY' | 'HOURLY' | 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'QUARTERLY' | 'YEARLY' }

Description

Fréquence des données de la série temporelle d'entrée. Le niveau de précision accepté le plus élevé est 'HOURLY'. Lors de la prévision simultanée de plusieurs séries temporelles, la valeur par défaut 'AUTO_FREQUENCY' de cet argument ne peut pas être modifiée.

Arguments

Accepte les valeurs suivantes :

'AUTO_FREQUENCY' : le processus d'entraînement infère automatiquement la fréquence des données, qui peut être l'une des valeurs répertoriées ci-dessous.

'HOURLY' : série temporelle horaire

'DAILY' : série temporelle quotidienne

'WEEKLY' : série temporelle hebdomadaire

'MONTHLY' : série temporelle mensuelle

'QUARTERLY' : série temporelle trimestrielle

'YEARLY' : série temporelle annuelle

La valeur par défaut est 'AUTO_FREQUENCY'.

INCLUDE_DRIFT

Syntaxe

INCLUDE_DRIFT = { TRUE | FALSE }

Description

Indique si le modèle ARIMA doit inclure ou non un terme de dérive linéaire. Le terme de dérive est applicable lorsque la valeur de "d" non saisonnier est égale à 1.

  • Lorsque auto_arima est défini sur "false", cet argument est défini par défaut sur "false". Il ne peut être définie sur "true" que si la valeur de "d" non saisonnier est égale à 1. Dans le cas contraire, il renvoie une erreur de requête non valide.

  • Lorsque auto-arima est défini sur "true", INCLUDE_DRIFT décide automatiquement d'inclure ou non un terme de dérive linéaire. Par conséquent, cette option est désactivée pour auto-ARIMA.

Arguments

Sa valeur est un BOOL. La valeur par défaut est FALSE, car auto_arima est désactivé.

HOLIDAY_REGION

Syntaxe

HOLIDAY_REGION = { 'GLOBAL' | 'NA' | 'JAPAC' | 'EMEA' | 'LAC' | 'AE' | ... }

Description

Région géographique selon laquelle les effets des jours fériés sont appliqués dans la modélisation. Par défaut, la modélisation des effets des jours fériés est désactivée. Pour l'activer, spécifiez la région concernée à l'aide de cette option.

Arguments

Accepte les valeurs suivantes :

Premier niveau : mondial

  • 'GLOBAL'

Deuxième niveau : régions continentales

  • 'NA' : Amérique du Nord
  • 'JAPAC' : Japon et Asie-Pacifique
  • 'EMEA' : Europe, Moyen-Orient et Afrique
  • 'LAC' : Amérique latine et Caraïbes

Troisième niveau : pays/régions

  • 'AE' : Émirats arabes unis
  • 'AR' : Argentine
  • 'AT' : Autriche
  • 'AU' : Australie
  • 'BE' : Belgique
  • 'BR' : Brésil
  • 'CA' : Canada
  • 'CH' : Suisse
  • 'CL' : Chili
  • 'CN' : Chine
  • 'CO' : Colombie
  • 'CZ' : Tchéquie
  • 'DE' : Allemagne
  • 'DK' : Danemark
  • 'DZ' : Algérie
  • 'EC' : Équateur
  • 'EE' : Estonie
  • 'EG' : Égypte
  • 'ES' : Espagne
  • 'FI' : Finlande
  • 'FR' : France
  • 'GB' : Royaume-Uni
  • 'GR' : Grèce
  • 'HK' : Hong Kong
  • 'HU' : Hongrie
  • 'ID' : Indonésie
  • 'IE' : Irlande
  • 'IL' : Israël
  • 'IN' : Inde
  • 'IR' : Iran
  • 'IT' : Italie
  • 'JP' : Japon
  • 'KR' : Corée du Sud
  • 'LV' : Lettonie
  • 'MA' : Maroc
  • 'MX' : Mexique
  • 'MY' : Malaisie
  • 'NG' : Nigéria
  • 'NL' : Pays-Bas
  • 'NO' : Norvège
  • 'NZ' : Nouvelle-Zélande
  • 'PE' : Pérou
  • 'PH' : Philippines
  • 'PK' : Pakistan
  • 'PL' : Pologne
  • 'PT' : Portugal
  • 'RO' : Roumanie
  • 'RS' : Serbie
  • 'RU' : Russie
  • 'SA' : Arabie saoudite
  • 'SE' : Suède
  • 'SG' : Singapour
  • 'SI' : Slovénie
  • 'SK' : Slovaquie
  • 'TH' : Thaïlande
  • 'TR' : Turquie
  • 'TW' : Taïwan
  • 'UA' : Ukraine
  • 'US' : États-Unis
  • 'VE' : Venezuela
  • 'VN' : Viêt Nam
  • 'ZA' : Afrique du Sud

query_statement

La clause AS query_statement spécifie la requête en langage SQL standard permettant de générer les données d'entraînement. Reportez-vous à la page Syntaxe des requêtes en SQL standard pour connaître la syntaxe SQL compatible avec la clause query_statement.

Toutes les colonnes référencées par query_statement sont utilisées en tant qu'entrées du modèle, à l'exception des colonnes figurant dans input_label_cols et data_split_col.

Entrées compatibles

L'instruction CREATE MODEL accepte les types de données suivants pour l'étiquette d'entrée et les colonnes de répartition des données.

Types de données compatibles avec les colonnes d'étiquette d'entrée

BigQuery ML est compatible avec différents types de données du langage SQL standard en fonction du type de modèle. Les types de données compatibles avec input_label_cols incluent :

Model type Supported label types
linear_reg INT64
NUMERIC
BIGNUMERIC
FLOAT64
logistic_reg N'importe quel type de données groupable
kmeans N'importe quel type de données groupable

Types de données compatibles avec les colonnes de répartition des données

BigQuery ML est compatible avec différents types de données du langage SQL standard en fonction de la méthode de répartition des données. Les types de données compatibles avec data_split_col incluent :

Data split method Supported column types
custom BOOL
seq INT64
NUMERIC
BIGNUMERIC
FLOAT64
TIMESTAMP

Limites

Les instructions CREATE MODEL doivent respecter les règles suivantes :

  • Chaque requête ne peut contenir qu'une seule instruction CREATE.
  • Lorsque vous utilisez une instruction CREATE MODEL, la taille du modèle doit être inférieure ou égale à 90 Mo. Dans le cas contraire, la requête échoue. En règle générale, si toutes les variables catégorielles sont des chaînes courtes, une cardinalité totale des caractéristiques (dimensions du modèle) de 5 à 10 millions est acceptée. La dimensionnalité dépend de la cardinalité et de la longueur des variables de chaîne.
  • La colonne d'étiquette ne peut pas contenir de valeurs NULL. Si la colonne d'étiquette comporte des valeurs NULL, la requête échoue.
  • Actuellement, la clause CREATE MODEL IF NOT EXISTS met toujours à jour le dernier horodatage modifié d'un modèle.
  • Pour les modèles de régression linéaire, la colonne label doit être renseignée avec des valeurs réelles (les étiquettes ne peuvent pas avoir la valeur "+/-Infinity", ni la valeur "NaN").
  • Pour les modèles de régression logistique, les colonnes d'étiquette peuvent contenir jusqu'à 50 valeurs uniques. En d'autres termes, le nombre de classes est inférieur ou égal à 50.

Transformations des variables d'entrée

BigQuery ML transforme les variables d'entrée ou les caractéristiques de la manière suivante :

Type de données d'entrée Méthode de transformation Détails
INT64
NUMERIC
BIGNUMERIC
FLOAT64		 Standardisation Pour toutes les colonnes numériques, BigQuery ML standardise et centre la colonne sur zéro avant de la transmettre à l'entraînement, à l'exception des modèles en arbre de décision à boosting. Lorsque vous créez un modèle de k-moyennes, l'option "STANDARDIZE_FEATURES" indique s'il est nécessaire de standardiser les caractéristiques numériques.
BOOL
STRING
BYTES
DATE
DATETIME
TIME		 Encodage one-hot Pour toutes les colonnes non numériques autres que les tableaux et autres que TIMESTAMP, BigQuery ML effectue une transformation d'encodage one-hot, à l'exception des modèles en arbre de décision à boosting. Cette transformation génère une caractéristique distincte pour chaque valeur unique de la colonne. La transformation d'encodage des étiquettes est appliquée pour entraîner les modèles en arbre de décision à boosting afin de convertir chaque valeur unique en une valeur numérique.
ARRAY Encodage multi-hot Pour toutes les colonnes ARRAY non numériques, BigQuery ML effectue une transformation d'encodage multi-hot. Cette transformation génère une caractéristique distincte pour chaque élément unique de la colonne ARRAY.
TIMESTAMP Transformation de l'horodatage Lorsque BigQuery ML rencontre une colonne TIMESTAMP, il procède à l'extraction d'un ensemble de composants à partir de cette colonne TIMESTAMP, puis il les transforme au moyen de la standardisation ou de l'encodage one-hot. Pour le composant de temps Unix en secondes, BigQuery ML utilise la standardisation. Pour tous les autres composants, il utilise l'encodage one-hot.

Vous pouvez utiliser la fonction ML.WEIGHTS pour visualiser la transformation d'une colonne TIMESTAMP en plusieurs colonnes de caractéristiques.
STRUCT Expansion de la structure Lorsque BigQuery ML rencontre une colonne STRUCT, les champs sont développés en colonnes simples à l'intérieur de cette colonne STRUCT. Tous les champs doivent être nommés. Les champs STRUCT imbriqués ne sont pas autorisés. Les noms de colonnes après expansion sont au format {struct_name} _ {field_name}.

Imputation

Dans le domaine statistique, l'imputation permet de remplacer des données manquantes par des valeurs. Lorsque vous entraînez un modèle dans BigQuery ML, les valeurs NULL sont considérées comme des données manquantes. Lorsque vous effectuez des prédictions dans BigQuery ML, vous pouvez vous heurter à des valeurs manquantes lorsque BigQuery ML rencontre une valeur NULL ou une valeur non répertoriée. BigQuery ML gère les données manquantes différemment, selon si celles-ci se trouvent dans une colonne numérique, une colonne à encodage one-hot ou une colonne d'horodatage.

Colonnes numériques

Lors des opérations d'entraînement et de prédiction, les valeurs NULL des colonnes numériques sont remplacées par la valeur moyenne calculée par la colonne de caractéristiques dans les données d'entrée d'origine.

Colonnes à encodage one-hot/multi-hot

Lors des opérations d'entraînement et de prédiction, les valeurs NULL des colonnes à encodage one-hot ou multi-hot sont mappées vers une catégorie supplémentaire, qui est ajoutée aux données. Une pondération de 0 est attribuée aux données non répertoriées lors de la prédiction.

Colonnes d'horodatage

Les colonnes d'horodatage (TIMESTAMP) ont recours à un mélange des méthodes d'imputation utilisées pour les colonnes standardisées et les colonnes à encodage one-hot. Pour la colonne de temps Unix générée, BigQuery ML remplace les valeurs par le temps Unix moyen des colonnes d'origine. BigQuery ML attribue le reste des valeurs générées à la catégorie NULL respective pour chacune des caractéristiques extraites.

Colonnes STRUCT

Lors des opérations d'entraînement et de prédiction, chaque champ de colonne STRUCT est imputé en fonction de son type.

Exemples d'instructions CREATE MODEL

L'instruction CREATE MODEL crée un modèle avec les options spécifiées. Si le nom du modèle existe déjà dans l'ensemble de données, l'erreur suivante est renvoyée :

Already Exists: [PROJECT_ID]:[DATASET].[MODEL]

Pour remplacer un modèle existant, utilisez plutôt l'instruction CREATE OR REPLACE MODEL.

Dans les exemples suivants, vous créez des modèles nommés mymodel dans mydataset dans votre projet par défaut.

Entraîner un modèle de régression linéaire

L'exemple suivant crée et entraîne un modèle de régression linéaire. Le taux d'apprentissage est défini sur 0,15, la régularisation L1 est définie sur 1, et le nombre maximal d'itérations d'entraînement est défini sur 5.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='LINEAR_REG',
    LS_INIT_LEARN_RATE=.15,
    L1_REG=1,
    MAX_ITERATIONS=5 ) AS
SELECT
  column1,
  column2,
  column3,
  label
FROM
  `mydataset.mytable`
WHERE
  column4 < 10

Entraîner un modèle de régression linéaire avec une répartition séquentielle des données

Dans cet exemple, vous créez un modèle de régression linéaire avec une répartition séquentielle des données. La fraction de la répartition est de 0,3. La répartition utilise la colonne timestamp en tant que base.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='LINEAR_REG',
    LS_INIT_LEARN_RATE=.15,
    L1_REG=1,
    MAX_ITERATIONS=5,
    DATA_SPLIT_METHOD='SEQ',
    DATA_SPLIT_EVAL_FRACTION=0.3,
    DATA_SPLIT_COL='timestamp' ) AS
SELECT
  column1,
  column2,
  column3,
  timestamp,
  label
FROM
  `mydataset.mytable`
WHERE
  column4 < 10

Entraîner un modèle de régression linéaire avec une répartition personnalisée des données

Dans cet exemple, vous avez fractionné manuellement vos données en une table d'entraînement et en une table d'évaluation. La table d'entraînement est nommée training_table. La table d'évaluation est nommée evaluation_table.

Cette commande crée un modèle de régression linéaire à l'aide d'une méthode de répartition personnalisée et entraîne le modèle en associant les données des tables d'évaluation et d'entraînement.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='LINEAR_REG',
    DATA_SPLIT_METHOD='CUSTOM',
    DATA_SPLIT_COL='SPLIT_COL' ) AS
SELECT
  *,
  false AS split_col
FROM
  `mydataset.training_table`
UNION ALL
SELECT
  *,
  true AS split_col
FROM
  `mydataset.evaluation_table`

Dans cet exemple, toutes les colonnes de la table d'entraînement et de la table d'évaluation sont des caractéristiques ou une étiquette. La requête utilise SELECT * et UNION ALL pour ajouter toutes les données de la colonne split_col aux données existantes.

Entraîner un modèle de régression logistique multiclasses avec des pondérations calculées automatiquement

Dans cet exemple, vous créez un modèle de régression logistique multiclasses à l'aide de l'option auto_class_weights.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='LOGISTIC_REG',
    AUTO_CLASS_WEIGHTS=TRUE ) AS
SELECT
  *
FROM
  `mydataset.mytable`

Entraîner un modèle de régression logistique multiclasses avec des pondérations spécifiées

Dans cet exemple, vous créez un modèle de régression logistique multiclasses à l'aide de l'option class_weights. Les colonnes d'étiquettes sont label1, label2 et label3.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='LOGISTIC_REG',
    CLASS_WEIGHTS=[('label1', 0.5), ('label2', 0.3), ('label3', 0.2)]) AS
SELECT
  *
FROM
  `mydataset.mytable`

Entraîner un modèle de régression logistique avec des pondérations spécifiées

Dans cet exemple, vous créez un modèle de régression logistique à l'aide de l'option class_weights.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='LOGISTIC_REG',
    CLASS_WEIGHTS=[('0', 0.9), ('1', 0.1)]) AS
SELECT
  *
FROM
  `mydataset.mytable`

Entraîner un modèle de k-moyennes

Dans cet exemple, vous créez un modèle de k-moyennes avec quatre clusters à l'aide de la valeur distance_type par défaut définie sur euclidean_distance.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='KMEANS',
    NUM_CLUSTERS=4 ) AS
SELECT
  *
FROM `mydataset.mytable`

Entraînement d'un modèle de k-moyennes avec des clusters aléatoires

Dans cet exemple, vous créez un modèle de k-moyennes avec trois clusters à l'aide de la méthode d'initialisation de clusters aléatoires.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='KMEANS',
    NUM_CLUSTERS=3,
    KMEANS_INIT_METHOD='RANDOM') AS
SELECT
  *
FROM
  `mydataset.mytable`

Entraînement d'un modèle de k-moyennes avec des clusters personnalisés

Dans cet exemple, vous créez un modèle de k-moyennes avec quatre clusters à l'aide de la méthode d'initialisation de clusters personnalisés. init_col identifie la colonne de type BOOL contenant les valeurs qui spécifient si une ligne donnée est un centroïde initial. Cette colonne ne doit contenir que trois lignes avec la valeur TRUE.

CREATE MODEL
  `mydataset.mymodel`
OPTIONS
  ( MODEL_TYPE='KMEANS',
    NUM_CLUSTERS=3,
    KMEANS_INIT_METHOD='CUSTOM',
    KMEANS_INIT_COL='init_col') AS
SELECT
  init_col,
  features
FROM
  `mydataset.mytable`

Création de modèle avec TRANSFORM, sans colonnes d'origine

La requête suivante entraîne un modèle après avoir ajouté les colonnes f1 et f2 de l'instruction SELECT pour former une nouvelle colonne c. Les colonnes f1 et f2 sont omises des données d'entraînement. L'entraînement du modèle utilise les colonnes f3 et label_col telles qu'elles apparaissent dans la source de données t.

CREATE MODEL m
  TRANSFORM(f1 + f2 as c, * EXCEPT(f1, f2))
  OPTIONS(model_type=’linear_reg’, input_label_cols=['label_col'])
AS SELECT f1, f2, f3, label_col FROM t;