Modélisation de la régression dans Ads Data Hub

Les régressions linéaires et logistiques sont des modèles de machine learning qui permettent de générer des prédictions significatives à partir de données publicitaires.

• La régression linéaire crée une fonction permettant d'ajuster une ligne aux données de façon à minimiser la distance entre les points de données et la ligne. Ce modèle peut ensuite être utilisé pour prédire une valeur numérique en fonction d'entrées, telles que la valeur vie d'un utilisateur en fonction des achats, des interactions antérieures, etc.
• La régression logistique est utilisée pour les problèmes de classification prédictive. Le modèle peut être de deux types, selon le nombre de variables que vous fournissez :
  • La régression logistique binaire répond à une question "oui/non" (par exemple, la probabilité qu'un événement de conversion se produise).
  • La régression logistique multiclasse permet de prédire plusieurs valeurs possibles (par exemple, si un client présente une "valeur faible", une "valeur moyenne" ou une "valeur élevée").

La régression linéaire et la régression logistique apprennent toutes deux à partir de données d'entraînement (ici, vos données publicitaires), offrant ainsi un modèle prédictif pour prendre des décisions publicitaires. En règle générale, plus vous fournissez de données de grande qualité, plus vous améliorez la précision de votre modèle. Les deux modèles offrent de meilleures performances lorsqu'ils reçoivent des données d'entraînement regroupées efficacement.

Remarque : L'activation d'audience et les enchères personnalisées ne sont pas encore disponibles pour la modélisation de la régression.

Confidentialité différentielle

La régression linéaire et la régression logistique utilisent toutes deux la confidentialité différentielle qui est un système de contrôle de la confidentialité différent de celui utilisé par les autres opérations dans Ads Data Hub. La confidentialité différentielle s'assure de la confidentialité des utilisateurs finaux en injectant du bruit dans vos résultats pendant le processus d'entraînement. Ce niveau de bruit est suffisamment faible pour que les résultats restent utiles, mais suffisamment élevé pour que les utilisateurs finaux ne puissent pas être identifiés. De plus, le niveau de bruit n'est pas déterministe, de sorte que les résultats présentent un niveau de bruit incohérent, permettant ainsi de mieux préserver la confidentialité de l'utilisateur final.

Important : La confidentialité différentielle et la vérification des différences sont deux concepts différents. La vérification des différences désigne les exigences d'agrégation qui régissent la taille minimale de cohorte pour un nombre donné d'utilisateurs dans un résultat.

Limitation des requêtes

Vous êtes limité à 100 requêtes de modélisation de la régression logistique et linéaire par "jour de données" lorsque vous utilisez le EPSILON_PER_MODEL par défaut. Un jour de données correspond aux événements générés au cours d'une journée spécifique. Ces événements correspondent aux dates de début et de fin que vous indiquez lors de l'exécution de votre requête, ainsi qu'à celles servant lors de la création des tables utilisées par votre requête (par exemple, les tables temporaires utilisées pour l'entraînement). Autrement dit, les données d'un même jour ne peuvent pas être utilisées dans plus de 100 modèles. Si vous choisissez une valeur supérieure à la valeur par défaut pour EPSILON_PER_MODEL, vous pourrez créer moins de modèles, mais ils seront de meilleure qualité. Si vous choisissez des valeurs inférieures pour EPSILON_PER_MODEL, vous pourrez entraîner un plus grand nombre de modèles, mais ils seront de moins bonne qualité.

Important : Vous ne pouvez pas exécuter plus de 100 requêtes de régression linéaire et logistique par jour de données avec la valeur EPSILON_PER_MODEL par défaut.

Fonctionnement

Le processus comprend les étapes essentielles suivantes :

1. Préparer les données d'entraînement
2. Créer un modèle
3. Collecter des insights à partir du modèle

Préparer les données d'entraînement

Comme indiqué ci-dessus, vous obtiendrez généralement de meilleurs résultats si vous utilisez des ensembles de données volumineux et de haute qualité. De plus, étant donné que les données d'entrée sont mises à l'échelle selon la méthode min-max, les données faiblement groupées ou celles qui présentent des anomalies importantes peuvent affecter le modèle en déplaçant la moyenne.

Par défaut, Ads Data Hub sélectionne aléatoirement 18 % de vos données d'entraînement à utiliser pour la validation. Le pourcentage de données utilisé pour la validation peut être contrôlé par l'option data_split_eval_fraction.

Créer un modèle

Spécifiez les paramètres et les données d'entrée pour l'entraînement de votre modèle.

Important : Si vous utilisez les mêmes données d'entraînement pour créer plusieurs modèles, stockez-les dans une table temporaire plutôt que de créer une table dans la query_statement. Cela permet d'éviter le filtrage des lignes en raison de la vérification des différences.

Bonnes pratiques

L'un des facteurs les plus importants dans la qualité d'un modèle est la taille de l'ensemble d'entraînement. Cependant, le compromis entre taille et qualité varie en fonction du problème et des facteurs présentés ci-dessous. Faites-nous part de votre expérience. * Nous avons constaté une justesse supérieure à 0,70 pour les modèles de régression logistique créés à partir d'ensembles d'entraînement comptant au moins 100 000 utilisateurs. * Nous avons constaté que le coefficient de détermination (r-carré) est supérieur à 0,70 pour les modèles de régression linéaire créés à partir d'ensembles d'entraînement comptant au moins 800 000 utilisateurs.

D'autres facteurs peuvent réduire la qualité d'un modèle. * Modèles logistiques dans lesquels une classe est beaucoup plus représentée que les autres. Plus précisément, lorsqu'une étiquette comporte peu d'utilisateurs dans l'ensemble d'entraînement, le fait de disposer d'un grand nombre d'utilisateurs dans l'ensemble d'entraînement avec d'autres étiquettes ne sera probablement pas très utile pour la justesse du modèle sur une petite étiquette. Par exemple, il est moins intéressant de disposer de 20 000 et 1 000 utilisateurs dans l'ensemble d'entraînement pour deux étiquettes que de 10 000 et 2 000. * Données de caractéristiques qui ne fournissent pas de signal fort aux étiquettes. * Données brutes nécessitant une extraction de caractéristiques plus approfondie. Par exemple, certains champs peuvent avoir un très grand nombre de valeurs possibles. Pour améliorer les données de ce type, vous pouvez transformer les valeurs en une caractéristique avec un plus petit nombre de catégories ou de buckets.

Collecter des insights

Vous pouvez appeler des fonctions pour évaluer les performances de votre modèle sur les données de validation, inspecter des caractéristiques et des informations sur les itérations d'entraînement (comme les pondérations sous-jacentes utilisées par un modèle pendant la prédiction) et générer des prédictions sur des données inconnues.

Instruction CREATE MODEL

L'instruction CREATE MODEL crée un modèle avec le nom et l'ensemble de données que vous spécifiez. Si le nom du modèle existe déjà, CREATE MODEL remplace le modèle existant.

Remarque : Ads Data Hub vous recommande de créer la table utilisée pour l'entraînement en dehors de l'instruction CREATE MODEL. Cette bonne pratique facilite l'itération des paramètres d'entraînement du modèle et le tri des problèmes.

Syntaxe de CREATE MODEL

CREATE MODEL
model_name
OPTIONS
(
  // model_option_list:
  // Required parameter.
  MODEL_TYPE = { 'ADH_LINEAR_REGRESSION' | 'ADH_LOGISTIC_REGRESSION'}

  // Optional tuning parameters.
  [, L1_REG = float64_value ]
  [, L2_REG = float64_value ]
  [, DATA_SPLIT_EVAL_FRACTION = float64_value ]
  [, OPTIMIZE_STRATEGY = { 'AUTO_STRATEGY' | 'BATCH_GRADIENT_DESCENT' |
                           'NORMAL_EQUATION' } ]
  [, MAX_ITERATIONS = int64_value ]
  [, LEARN_RATE_STRATEGY = { 'LINE_SEARCH' | 'CONSTANT' } ]
  [, LEARN_RATE = float64_value ]
  [, EARLY_STOP = { TRUE | FALSE } ]
  [, MIN_REL_PROGRESS = float64_value ]
  [, LS_INIT_LEARN_RATE = float64_value ]
  [, EPSILON_PER_MODEL = float64_value ]
  [, AUTOMATIC_IMPUT_SCALING = bool_value ]
  [, MIN_MAX_SCALED_COLS = [string_value, string_value... ] ]
  [, STANDARD_SCALED_COLS = [string_value, string_value... ] ]
  [, QUANTILE_BUCKETIZED_COLS = [
        STRUCT(string_value AS col_name, int64_value AS num_buckets), 
       STRUCT(string_value AS col_name, int64_value AS num_buckets)... ] ]
)
AS query_statement

model_name

Nom alphanumérique, pouvant comprendre des traits de soulignement et des tirets. Il ne peut pas contenir de point. Si le nom de modèle fourni existe déjà, l'ancien modèle sera remplacé.

query_statement

Spécifie la requête SQL standard permettant de générer les données d'entraînement. Si vous créez plusieurs modèles à l'aide des mêmes données d'entraînement, créez une table temporaire avec les données d'entraînement et référencez-la ici. Cette méthode évite les erreurs potentielles de vérification des différences dues à l'effacement ou au spam ultérieur.

model_option_list

model_type

(Obligatoire) Seule option obligatoire. Il peut s'agir de adh_linear_regression ou adh_logistic_regression.

l1_reg

(Facultatif) La quantité de régularisation L1 appliquée. La régularisation L1 pénalise les pondérations proportionnellement à la somme de leurs valeurs absolues. Peut être tout nombre non négatif. La valeur par défaut est zéro.

l2_reg

(Facultatif) La quantité de régularisation L2 appliquée. La régularisation L2 pénalise les pondérations proportionnellement à la racine carrée de la somme des carrés des pondérations. Peut être tout nombre non négatif. La valeur par défaut est zéro.

data_split_eval_fraction

(Facultatif) Doit être comprise entre 0,01 et 0,99, la valeur par défaut étant 0,18. Détermine la fraction des données qui se trouve dans l'ensemble d'évaluation. Cela affecte la justesse du modèle en réduisant le nombre de lignes qu'il finit par comporter, mais augmente également le nombre de modèles qu'un utilisateur peut exécuter. Voici un graphique de cette relation en supposant que CHAQUE modèle sur un ensemble de données spécifique présente la même fraction :

Fraction de validation	Requêtes autorisées
0,01	7
0,1	8
0,15	8
0,18	9
0,2	9
0,3	10
0,5	14
0,9	50

optimize_strategy

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

Arguments

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 surapprentissage (le nombre d'exemples d'entraînement est inférieur à 10 • 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 (logistique uniquement) 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 (linéaire uniquement) 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.

max_iterations

(Facultatif) Nombre d'itérations ou d'étapes d'entraînement. Étant donné que cette requête crée un arbre pour chaque itération, il s'agit également du nombre d'arbres. Doit être un entier supérieur à 1. Valeur par défaut : 20.

learn_rate_strategy

(Facultatif, logistique uniquement) 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

(Facultatif, logistique uniquement) 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

float64_value peut être n'importe quel nombre à virgule flottante de 64 bits. Valeur par défaut : 0,1 (10 %).

early_stop

(Facultatif) 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

TRUE pour "oui", FALSE pour "non". Valeur par défaut : TRUE.

min_rel_progress

(Facultatif) 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

float64_value peut être n'importe quel nombre à virgule flottante de 64 bits. Valeur par défaut : 0,1 (10 %).

ls_init_learn_rate

(Facultatif) 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 LEARN_RATE du modèle 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

float64_value peut être n'importe quel nombre à virgule flottante de 64 bits.

epsilon_per_model

(Facultatif) Spécifie la quantité du budget Privacy Budget à utiliser pour l'entraînement de ce modèle. Chaque client Ads Data se voit attribuer un budget Privacy Budget de 10,0 par jour de données. Un modèle entraîné avec succès utilisera EPSILON_PER_MODEL du budget pour chaque jour de données au cours de la période spécifiée lors de l'exécution de la requête. En utilisant la valeur par défaut de ln(3)/10, cela permettra de créer environ 100 modèles. Si vous utilisez une valeur plus élevée, vous pourrez créer moins de modèles, mais ils seront de meilleure qualité. Si vous utilisez une valeur inférieure, vous pourrez créer davantage de modèles de qualité inférieure.

Arguments

float64_value peut être n'importe quel nombre positif à virgule flottante de 64 bits inférieur à ln(3), qui correspond à environ 1,0986. La valeur par défaut est ln(3)/10.

automatic_input_scaling

(Facultatif) Si la valeur est définie sur TRUE, min_max_scaling est automatiquement appliqué à toutes les colonnes de caractéristiques numériques, comme si les noms de colonnes étaient explicitement appelés dans l'option min_max_scaled_cols, à l'exception des colonnes ayant été explicitement appelées dans les options standard_scaled_cols ou quantile_bucketized_cols.

Arguments

bool_value est de type BOOL. Valeur par défaut : TRUE.

min_max_scaled_cols

(Facultatif) Met à l'échelle chacune des colonnes de caractéristiques numerical_expression spécifiées dans une plage de 0 à 1, avec un plafonnement à MIN et MAX sur toutes les lignes. Les mêmes valeurs MIN et MAX sont automatiquement utilisées dans la prédiction. Si les données de prédiction se situent en dehors de la plage [MIN, MAX], elles sont limitées à 0 ou 1.

Arguments

Tableau de string_value, où chaque string_value est de type STRING et représente le nom de la colonne à transformer.

standard_scaled_cols

(Facultatif) Standardise les colonnes de caractéristiques numerical_expression spécifiées sur toutes les lignes. Les valeurs STDDEV et MEAN calculées pour standardiser l'expression sont automatiquement utilisés dans la prédiction.

Arguments

Tableau de string_value, où chaque string_value est de type STRING et représente le nom de la colonne à transformer.

quantile_bucketized_cols

Répartit en buckets les colonnes de caractéristiques numériques continues spécifiées sous la forme d'une STRING avec le nom du bucket comme valeur basée sur les quantiles. Les mêmes quantiles sont automatiquement utilisés dans la prédiction.

Arguments

Tableau de STRUCT(string_value AS col_name, int64_value AS num_buckets), où chaque string_value est une valeur de type STRING représentant le nom de la colonne numérique continue à transformer et chaque int64_value correspond au nombre de bins dans lesquels diviser les valeurs numériques.

Validation

• Chaque jour de données de la période spécifiée pour cette requête doit disposer d'un budget Privacy Budget suffisant, c'est-à-dire plus de EPSILON_PER_MODEL, sans quoi la requête échouera.
• S'ils sont spécifiés, les paramètres de réglage facultatifs seront validés pour les périodes indiquées au-dessus.
• Seul le paramètre model_type obligatoire doit être spécifié explicitement.
• Une colonne de l'ensemble d'entraînement doit être nommée "label". Il n'est actuellement pas possible d'utiliser plusieurs étiquettes.
• La colonne d'étiquette ne peut pas contenir de valeurs NULL. Si la colonne d'étiquette comporte des valeurs NULL, la requête échoue.
• Aucune des colonnes de caractéristiques ne peut être dérivée de l'user_id.
• Chaque ligne doit représenter exactement un utilisateur unique. Une ligne ne peut pas représenter des données de plusieurs utilisateurs. Cela peut se produire avec certaines jointures, par exemple une jointure croisée (CROSS JOIN).
• Aucun utilisateur ne peut figurer sur deux lignes distinctes.
• Pour des raisons de confidentialité, seules les options décrites dans la section de syntaxe sont utilisables. Les autres options disponibles dans la documentation sur la requête BQML CREATE MODEL ne sont actuellement pas acceptées.

Fonctions d'évaluation

ML.EVALUATE

La fonction ML.EVALUATE permet d'évaluer les métriques du modèle. La fonction ML.EVALUATE peut être utilisée avec des modèles de régression linéaire ou de régression logistique.

SELECT
  *
FROM ML.EVALUATE(MODEL `linear_model_test`);

ML.ROC_CURVE

La fonction ML.ROC_CURVE permet d'évaluer les métriques spécifiques à la régression logistique. ML.ROC_CURVE ne permet d'évaluer que les modèles de régression logistique.

SELECT
  *
FROM ML.ROC_CURVE(MODEL `logistic_model_test`);

Fonctions de prédiction

ML.PREDICT

La fonction ML.PREDICT permet de prédire les résultats à l'aide du modèle. Les résultats obtenus avec ML.PREDICT sont soumis aux mêmes contrôles de confidentialité que les autres résultats dans Ads Data Hub. En savoir plus sur les contrôles de confidentialité

Régression linéaire

/* This example outputs the average value for labels that the model predicted */
SELECT
  AVG(predicted_label) AS average_predicted_label
FROM
  ML.PREDICT(MODEL `linear_model_test`, TABLE tmp.linear_training_set);

Régression logistique

/* This example outputs the model's prediction and probabilities for said prediction over individual users. It groups by label and prediction, counting the number of users in each prediction */
SELECT
  label,
  predicted_label, /* one of the two input labels, depending on which label has the higher predicted probability */
  COUNT(*) AS num /* a tally of users */
FROM
  ML.PREDICT(MODEL `logistic_model_test`, TABLE tmp.logistic_training_set)
GROUP BY 1, 2;

Fonctions d'inspection de modèles et de caractéristiques

ML.TRAINING_INFO

La fonction ML.TRAINING_INFO vous permet d'afficher des informations sur les itérations d'entraînement d'un modèle.

SELECT
  *
FROM ML.TRAINING_INFO(MODEL `logistic_model_test`);

ML.FEATURE_INFO

La fonction ML.FEATURE_INFO vous permet d'afficher des informations sur les caractéristiques d'entrée nécessaires à l'entraînement d'un modèle.

SELECT
  *
FROM ML.FEATURE_INFO(MODEL `logistic_model_test`);

ML.WEIGHTS

La fonction ML.WEIGHTS vous permet d'afficher les pondérations sous-jacentes utilisées par un modèle lors de la prédiction.

SELECT
  *
FROM ML.WEIGHTS(MODEL `linear_model_test`);

Exemples

Créer un modèle

Les exemples suivants utilisent tous l'exemple de table natality pour montrer comment créer un modèle.

Données d'entraînement dans la sélection interne (linéaire)

L'exemple suivant utilise le poids de naissance, le genre, les semaines de gestation, l'âge de la mère et l'origine ethnique de la mère pour prédire le poids de naissance d'un enfant.

CREATE MODEL `natality_model`
OPTIONS
  (model_type='adh_linear_regression') AS
SELECT
  weight_pounds as label,
  is_male,
  gestation_weeks,
  mother_age,
  CAST(mother_race AS string) AS mother_race
FROM
  `bigquery-public-data.samples.natality`
WHERE
  weight_pounds IS NOT NULL

Données d'entraînement dans la sélection interne (logistique)

L'exemple suivant utilise le poids de naissance, le genre, les semaines de gestation, l'âge de la mère et l'origine ethnique de la mère pour prédire le genre d'un enfant.

CREATE MODEL `natality_model`
OPTIONS
  (model_type='adh_logistic_regression') AS
SELECT
  weight_pounds,
  is_male as label,
  gestation_weeks,
  mother_age,
  CAST(mother_race AS string) AS mother_race
FROM
  `bigquery-public-data.samples.natality`
WHERE
  weight_pounds IS NOT NULL