Instruction CREATE MODEL

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' }
  [, 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 ]
  [, FEEDBACK_TYPE = {'EXPLICIT' | 'IMPLICIT'} ]
  [, NUM_FACTORS = int64_value ]
  [, USER_COL = string_value ]
  [, ITEM_COL = string_value ]
  [, RATING_COL = string_value ]
  [, WALS_ALPHA = float64_value ])

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 au 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 n'ont besoin de transmettre que 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_listrequiert 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' }

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' (version bêta) permet de créer un modèle en important un modèle TensorFlow dans BigQuery ML. Consultez la section Instruction CREATE MODEL pour importer des modèles TensorFlow pour en savoir plus.

'MATRIX_FACTORIZATION' (version bêta) permet de mettre en œuvre la 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 les modèles de factorisation matricielle.

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

La 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, 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.

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.

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 des régressions logistiques et multiclasses.

Par défaut, les données d'entraînement servant à créer des modèles de régression logistique multiclasses 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, utilisez 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 section Instruction CREATE MODEL pour importer des 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.

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
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
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
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. 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 et non array autres que TIMESTAMP, BigQuery ML effectue une transformation d'encodage one-hot. Cette transformation génère une caractéristique distincte pour chaque valeur unique de la colonne.
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;