Créer des audiences en fonction de la valeur du client actuelle

Découvrez comment prédire la valeur du client (CLV), puis utilisez ces données pour identifier de nouveaux clients potentiels en créant des audiences similaires dans Google Ads.

Présentation

Ce tutoriel explique comment prédire la valeur monétaire probable par client pour une période donnée, en fonction de l'historique des transactions du client. Pour ce faire, procédez comme suit :

  • Importer des données sur les transactions et les clients dans BigQuery
  • Traiter les données à utiliser avec un modèle de machine learning (ML)
  • Créer le modèle de ML à l'aide de BigQuery ML
  • Obtenir des prédictions à partir du modèle pour identifier les meilleurs clients par CLV
  • Récupérer les adresses e-mail de ces clients à partir d'une table de données client
  • Se servir de ces données combinées pour créer une liste de remarketing à utiliser dans Google Ads
  • Se servir de cette liste de remarketing comme base pour générer une audience similaire à utiliser dans le ciblage des annonces

Ce tutoriel vous explique comment créer une instance AI Platform Notebook pour atteindre ces objectifs, avec des conseils normatifs et des procédures détaillées. Si vous souhaitez simplement utiliser un notebook terminé, vous pouvez utiliser bqml_automl_ltv_activate_lookalike.ipynb sur le serveur de notebooks de votre choix.

Ce tutoriel est destiné aux ingénieurs de données, aux data scientists et aux analystes de données qui créent des ensembles de données et des modèles de ML pour prendre des décisions commerciales. Il suppose que vous disposez des connaissances de base suivantes :

  • Connaissances de base sur les concepts du machine learning et sur Python
  • SQL standard

Ce tutoriel refactorise l'exemple utilisé sur la page Prédire la valeur du client avec AutoML Tables, qui constitue la quatrième et dernière partie d'une autre série de tutoriels sur la prédiction de la CLV. Envisagez de lire le premier tutoriel de cette série, Prédire la valeur du client avec AI Platform : Introduction, si vous souhaitez mieux comprendre les points clés spécifiques à l'extraction de caractéristiques et au développement de modèles dans le but de découvrir la CLV.

L'exemple de ce tutoriel diffère de celui de la section Prédire la valeur du client avec AutoML Tables de différentes manières :

  • Il crée plusieurs enregistrements par client à utiliser pour entraîner le modèle. Pour ce faire, il segmente les transactions des clients en fenêtres de temps superposées.
  • Il vous permet d'utiliser le modèle pour prédire la CLV à différentes périodes, par exemple un mois ou un trimestre, en modifiant simplement les paramètres d'entrée du modèle.
  • Il réduit le temps de développement en utilisant AutoML directement depuis BigQuery ML.
  • Il utilise des ensembles de données différents pour les données de ventes et les données clients.
  • Il montre comment utiliser les prédictions CLV pour créer des audiences similaires dans Google Ads.

Ensembles de données

Pour créer une liste de clients avec une CLV élevée à partir de laquelle vous pouvez créer une audience similaire, vous devez disposer de deux ensembles de données :

  • Transactions commerciales des clients que vous souhaitez évaluer. Vous utilisez des calculs basés sur ces données pour entraîner le modèle CLV. Dans un cas d'utilisation en production, vous devez extraire ces informations de votre système de traitement des commandes.
  • Adresses e-mail des clients Dans un cas d'utilisation en production, vous devez extraire ces informations de votre système de gestion de la relation client (CRM).

Ce tutoriel fournit des exemples de données dans deux fichiers CSV que vous chargez dans des tables BigQuery. Ces deux ensembles de données contiennent un numéro client, que vous utilisez pour joindre des tables afin d'associer l'adresse e-mail du client à ses informations CLV.

Model

Ce tutoriel vous explique comment créer un modèle de régression afin de prédire la valeur monétaire future de vos clients, car ce type de modèle permet de prédire une variable continue (également appelée valeur continue), telle que la CLV.

Plus précisément, ce tutoriel utilise BigQuery ML pour créer un modèle de régression AutoML. L'utilisation d'AutoML permet de minimiser les coûts de développement des manières suivantes :

  • Extraction de caractéristiques : AutoML gère automatiquement plusieurs tâches courantes d'extraction de caractéristiques.
  • Intégration de BigQuery ML : vous pouvez créer des modèles AutoML à l'aide des instructions SQL dans BigQuery ML, ce qui limite le besoin de passer d'un contexte de développement à un autre.
  • Division de l'ensemble de données d'entraînement : lors de l'entraînement d'un modèle, il est recommandé de répartir vos données en trois ensembles de données qui ne se chevauchent pas : entraînement, validation et test. AutoML gère cette configuration par défaut, mais vous pouvez également spécifier une répartition spécifique si vous le souhaitez.

Calcul des caractéristiques et des étiquettes

Dans ce tutoriel, vous utilisez des dates seuil pour segmenter les transactions des clients en fenêtres de temps superposées. Une date seuil sépare les transactions d'entrée des transactions cibles. Les transactions d'entrée se produisent avant la date seuil et permettent de calculer les caractéristiques que vous saisissez dans le modèle. Les transactions cibles se produisent après la date seuil et permettent de calculer la CLV pour cette période. Elle est utilisée comme étiquette que le modèle est entraîné à prédire.

Caractéristiques RFM

Trois caractéristiques importantes utilisées dans les modèles de CLV sont la récence, la fréquence et la valeurs monétaire (RFM), que vous calculez à partir des données d'historique des transactions client :

  • Récence : quand le client a-t-il passé sa dernière commande ?
  • Fréquence : à quelle fréquence effectue-t-il des achats ?
  • Montant : combien dépense-t-il ?

Le schéma suivant montre une succession de ventes passées pour un ensemble de quatre clients.

Historique des ventes pour quatre clients

Le schéma illustre les valeurs RFM pour les clients, en indiquant pour chacun d'entre eux les informations suivantes :

  • Récence : temps écoulé entre le dernier achat et la date actuelle, représenté par la distance entre le cercle le plus à droite et la ligne pointillée verticale portant l'étiquette Now (Maintenant).
  • Fréquence : temps écoulé entre les achats, représenté par la distance entre les cercles sur une seule ligne.
  • Montant : somme dépensée pour chaque achat, représentée par la taille du cercle.

Exigences concernant l'intégration à Google Ads

L'exemple de code présenté dans les sections de ce tutoriel sur l'intégration à Google Ads nécessite l'accès à un environnement Google Ads opérationnel. Pour pouvoir exécuter l'exemple de code avec votre propre environnement Google Ads, vous devez disposer des éléments suivants :

  • Un compte administrateur Google Ads et un accès à l'API Google Ads. Si vous ne les avez pas encore, suivez les instructions de la procédure d'inscription pour les obtenir.
  • Un jeton de développeur Google Ads, un ID client OAuth et un secret client, ainsi qu'un jeton d'actualisation OAuth pour la bibliothèque cliente Python Google Ads. Si vous ne possédez pas encore ces éléments, suivez les instructions de la section Configurer l'accès à l'API AdWords pour les obtenir. Pour l'étape 5 de cette procédure, vous pouvez utiliser googleads-python-lib/examples/adwords/authentication/generate_refresh_token.py pour savoir comment obtenir un jeton d'actualisation.
  • Les données de transaction qui vous permettent de calculer la CLV et les données client contenant l'adresse e-mail du client. Utilisez ceci à la place des exemples de données fournis dans la section Importer les données. Vous devez vous assurer que vos données utilisent les mêmes noms et schémas de table que les exemples de données. Les tableaux suivants décrivent les tables BigQuery attendues :

Table clv.sales

Colonne Type de données
customer_id INTEGER
order_id STRING
transaction_date DATE
product_sku STRING
qty INTEGER
unit_price FLOAT

Table clv.customers

Colonne Type de données
customer_id INTEGER
full_name STRING
age INTEGER
job_title STRING
email STRING

Objectifs

  1. Préparer et explorer les données d'entraînement à l'aide de BigQuery
  2. Créer, entraîner et déployer un modèle de ML à l'aide de BigQuery ML
  3. Obtenir des prédictions CLV à partir du modèle déployé
  4. Créer une liste de clients avec une CLV issu des 20 % de CLV les plus élevées.
  5. Créer une liste de remarketing Google Ads basée sur la liste des clients avec les CLV les plus élevées, que vous pouvez ensuite exploiter pour générer une audience similaire.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • AI Platform
  • BigQuery
  • BigQuery ML
  • Compute Engine

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder à la page de sélection du projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Compute Engine, BigQuery, and AI Platform Notebooks.

    Activer les API

Créer un notebook

  1. Ouvrir la console AI Platform Notebooks
  2. Cliquez sur Nouvelle instance.
  3. Sélectionnez Python 2 et 3.
  4. Dans le champ Instance name (Nom de l'instance), saisissez clv.
  5. Cliquez sur Créer. La création de l'instance de notebook prend quelques minutes.
  6. Lorsque l'instance est disponible, cliquez sur Ouvrir JupyterLab.
  7. Dans la section Notebook du lanceur d'applications de JupyterLab, cliquez sur Python 3.

Installer les bibliothèques

Installez googleads et les autres bibliothèques nécessaires pour ce tutoriel :

  1. Copiez le code suivant dans la première cellule du notebook:

    # Install libraries.
    %pip install -q googleads
    %pip install -q -U kfp matplotlib Faker --user
    
    # Restart kernel after installs
    import IPython
    app = IPython.Application.instance()
    app.kernel.do_shutdown(True)
    
  2. Cliquez sur Exécuter dans la barre de menu.

Importer des packages

Installez les packages nécessaires à ce tutoriel en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os, json, random
import hashlib, uuid
import time, calendar, math
import pandas as pd, numpy as np
import matplotlib.pyplot as plt, seaborn as sns
from datetime import datetime
from google.cloud import bigquery
from googleads import adwords

Créer un client BigQuery

Créez un client BigQuery pour la bibliothèque cliente Python pour BigQuery en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant. Remplacez myProject par l'ID du projet que vous utilisez pour suivre ce tutoriel. Vous pouvez trouver l'ID de projet dans la fiche Informations sur le projet du tableau de bord du projet Google Cloud.

bq_client = bigquery.Client(project="myProject")

Importer les données

Suivez les instructions des sections suivantes pour importer les exemples de données dans BigQuery, puis les traiter en vue de l'entraînement du modèle de ML.

Si vous possédez un environnement Google Ads fonctionnel, vous pouvez utiliser vos propres données au lieu d'importer l'exemple. Complétez la table clv.sales avec les données de transaction que vous pouvez utiliser pour calculer la CLV, puis remplissez la table clv.customers avec les données client qui incluent l'adresse e-mail du client.

Créer un ensemble de données

Pour pouvoir créer des tables BigQuery pour les exemples de données, vous devez créer un ensemble de données pour les contenir.

Créez l'ensemble de données clv en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant. Remplacez myProject par l'ID du projet que vous utilisez pour suivre ce tutoriel.

PROJECT_ID = "myProject"
! bq mk $PROJECT_ID:clv

Importer les données de ventes

Créez et remplissez la table clv.sales en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

! bq load \
--project_id $PROJECT_ID \
--skip_leading_rows 1 \
--max_bad_records 100000 \
--replace \
--field_delimiter "," \
--autodetect \
clv.sales \
gs://solutions-public-assets/analytics-componentized-patterns/ltv/sales_*

Importer les données client

Créez et remplissez la table clv.customers en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

! bq load \
--project_id $PROJECT_ID \
--skip_leading_rows 1 \
--max_bad_records 100000 \
--replace \
--field_delimiter "," \
--autodetect \
clv.customers \
gs://solutions-public-assets/analytics-componentized-patterns/ltv/crm.csv

Préparer les données

Pour préparer les données de transaction client afin de pouvoir les utiliser pour entraîner le modèle de ML, vous devez effectuer les tâches suivantes :

  • Définir les paramètres qui déterminent l'écart type autorisé pour la valeur monétaire de la commande et la quantité d'articles. Ils permettent d'identifier et de supprimer les enregistrements d'anomalies pour chaque client lors de l'agrégation initiale des données de transaction client.
  • Agréger les données de transaction client.
  • Vérifier la distribution des données agrégées sur différents critères, tels que les transactions par client et le nombre d'articles par commande, pour identifier les domaines où vous souhaitez affiner davantage les données.
  • Définir les caractéristiques à calculer à partir des données agrégées, telles que les valeurs RFM.
  • Définir les paramètres qui définissent les fenêtres de temps à utiliser pour le calcul des caractéristiques. Il peut s'agir du nombre de jours entre chaque date seuil, par exemple.
  • Calculer les caractéristiques nécessaires à l'entraînement du modèle.

Définir les paramètres d'agrégation

Utilisez les paramètres suivants dans la procédure d'agrégation pour définir les valeurs d'écart type maximales :

  • MAX_STDV_MONETARY : écart type de la valeur monétaire par client.
  • MAX_STDV_QTY : écart type de la quantité de produits par client.

Définissez les paramètres pour déterminer les valeurs d'écart type à utiliser en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

AGG_PARAMS = {
    'MAX_STDV_MONETARY': 500,
    'MAX_STDV_QTY': 100
}

Dans un cas d'utilisation en production, vous pouvez modifier ces paramètres pour déterminer les plages de valeurs acceptables pour la valeur de la commande et la quantité d'articles.

Agréger les données des transactions client

La requête suivante regroupe toutes les commandes par jour et par client. Étant donné que la tâche de ML consiste à prédire une valeur monétaire pour une période telle que des semaines ou des mois, les jours fonctionnent bien comme une unité de temps pour regrouper les transactions par client.

Cette requête supprime également les commandes qui constituent des anomalies pour chaque client. Les commandes dont la valeur ou la quantité de produits ne correspondent pas aux valeurs d'écart type acceptables spécifiées par MAX_STDV_MONETARY et MAX_STDV_QTY sont filtrées.

  1. Créez une table qui contient les données de transaction client agrégées en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery --params $AGG_PARAMS --project $PROJECT_ID
    
    DECLARE MAX_STDV_MONETARY INT64 DEFAULT @MAX_STDV_MONETARY;
    DECLARE MAX_STDV_QTY INT64 DEFAULT @MAX_STDV_QTY;
    
    CREATE OR REPLACE TABLE `clv.aggregation` AS
    SELECT
      customer_id,
      order_day,
      ROUND(day_value_after_returns, 2) AS value,
      day_qty_after_returns as qty_articles,
      day_num_returns AS num_returns,
      CEIL(avg_time_to_return) AS time_to_return
    FROM (
      SELECT
        customer_id,
        order_day,
        SUM(order_value_after_returns) AS day_value_after_returns,
        STDDEV(SUM(order_value_after_returns)) OVER(PARTITION BY customer_id ORDER BY SUM(order_value_after_returns)) AS stdv_value,
        SUM(order_qty_after_returns) AS day_qty_after_returns,
        STDDEV(SUM(order_qty_after_returns)) OVER(PARTITION BY customer_id ORDER BY SUM(order_qty_after_returns)) AS stdv_qty,
        CASE
          WHEN MIN(order_min_qty) < 0 THEN count(1)
          ELSE 0
        END AS day_num_returns,
        CASE
          WHEN MIN(order_min_qty) < 0 THEN AVG(time_to_return)
          ELSE NULL
        END AS avg_time_to_return
      FROM (
        SELECT
          customer_id,
          order_id,
          -- Gives the order date vs return(s) dates.
          MIN(transaction_date) AS order_day,
          MAX(transaction_date) AS return_final_day,
          DATE_DIFF(MAX(transaction_date), MIN(transaction_date), DAY) AS time_to_return,
          -- Aggregates all products in the order
          -- and all products returned later.
          SUM(qty * unit_price) AS order_value_after_returns,
          SUM(qty) AS order_qty_after_returns,
          -- If negative, order has qty return(s).
          MIN(qty) order_min_qty
        FROM
          `clv.sales`
        GROUP BY
          customer_id,
          order_id)
      GROUP BY
        customer_id,
        order_day)
    WHERE
      -- [Optional] Remove dates with outliers per a customer.
      (stdv_value < MAX_STDV_MONETARY
        OR stdv_value IS NULL) AND
      (stdv_qty < MAX_STDV_QTY
        OR stdv_qty IS NULL);
    
  2. Affichez un exemple des données de la table clv.aggregation résultante en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery
    
    SELECT * FROM clv.aggregation LIMIT 5;
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Cinq premières lignes de données agrégées.

Dans un cas d'utilisation en production, vous souhaiterez probablement affiner davantage les données en appliquant des critères de sélection supplémentaires, tels que les options suivantes :

  • Supprimer les enregistrements pour lesquels la quantité d'articles et le montant de l'achat ne sont pas des valeurs positives.
  • Supprimer les enregistrements sans numéro client.
  • Ne conserver que les clients actifs, selon votre propre définition. Par exemple, vous pouvez vous concentrer sur les clients ayant effectué un achat au cours des 90 derniers jours.

Vérifier la distribution des données

Ce tutoriel effectue un nettoyage minimal des données, au lieu de se concentrer sur une transformation de base des données de transaction afin d'assurer la compatibilité avec le modèle. Dans cette section, vous vérifiez la distribution des données afin de déterminer d'éventuelles anomalies et d'identifier les points à affiner.

Vérifier la distribution en fonction de la date

  1. Créez le DataFrame df_dist_dates et renseignez les données de date issues des transactions agrégées en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery df_dist_dates --project $PROJECT_ID
    
    SELECT count(1) c, SUBSTR(CAST(order_day AS STRING), 0, 7) as yyyy_mm
    FROM `clv.aggregation`
    WHERE qty_articles > 0
    GROUP BY yyyy_mm
    ORDER BY yyyy_mm
    
  2. Utilisez seaborn pour visualiser les données de date en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    plt.figure(figsize=(12,5))
    sns.barplot( x='yyyy_mm', y='c', data=df_dist_dates)
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Visualisation de la distribution des données de date.

    Les commandes sont bien réparties tout au long de l'année, bien que la répartition soit un peu plus faible au cours des premiers mois capturés dans cet ensemble de données. Dans un cas d'utilisation en production, vous pouvez utiliser la distribution des données en fonction de la date comme un facteur à prendre en compte lors de la définition des paramètres de fenêtre de temps pour la procédure de calcul de caractéristiques.

Vérifier la distribution en fonction des transactions par client

  1. Créez le DataFrame df_dist_customers et renseignez le nombre de transactions client à partir des transactions agrégées en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery df_dist_customers --project $PROJECT_ID
    
    SELECT customer_id, count(1) c
    FROM `clv.aggregation`
    GROUP BY customer_id
    
  2. Utilisez seaborn pour visualiser les données de transaction client en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    plt.figure(figsize=(12,4))
    sns.distplot(df_dist_customers['c'], hist_kws=dict(ec="k"), kde=False)
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Visualisation de la distribution des données client.

    Ces données sont bien réparties, avec un nombre de transactions par client distribué sur une plage étroite et sans anomalie évidente.

Vérifier la distribution en fonction de la quantité d'articles

  1. Créez le DataFrame df_dist_qty et renseignez les données de quantité d'articles à partir des transactions agrégées en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery df_dist_qty --project $PROJECT_ID
    
    SELECT qty_articles, count(1) c
    FROM `clv.aggregation`
    GROUP BY qty_articles
    
  2. Utilisez seaborn pour visualiser les données de quantité d'articles en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    plt.figure(figsize=(12,4))
    sns.distplot(df_dist_qty['qty_articles'], hist_kws=dict(ec="k"), kde=False)
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Visualisation de la distribution des données de quantité d&#39;articles.

    Quelques clients ont des commandes avec une très grande quantité d'articles, mais la distribution est généralement satisfaisante. Dans un cas d'utilisation en production, vous pouvez effectuer davantage d'opérations d'ingénierie de données dans ce domaine. Vous souhaitez supprimer les transactions correspondant à des anomalies pour des clients individuels. Par exemple, vous pouvez supprimer une transaction de 20 articles pour un client qui achète généralement un ou deux articles. Vous souhaitez conserver les clients considérés comme des anomalies, car ils achètent généralement plus d'articles que les autres.

Vérifier la distribution en fonction de la valeur monétaire

  1. Créez le DataFrame df_dist_values et renseignez les données de valeur monétaire à partir des transactions agrégées en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery df_dist_values --project $PROJECT_ID
    
    SELECT value
    FROM `clv.aggregation`
    
  2. Utilisez seaborn pour visualiser les données de valeur monétaire en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    axv = sns.violinplot(x=df_dist_values["value"])
    axv.set_xlim(-200, 3500)
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Visualisation de la distribution des données monétaires.

    La répartition indique quelques anomalies avec des dépenses beaucoup plus élevées que la moyenne. Dans un cas d'utilisation en production, vous pouvez effectuer davantage d'opérations d'ingénierie de données dans ce domaine. Vous souhaitez supprimer les transactions correspondant à des anomalies pour des clients individuels. Par exemple, vous pouvez supprimer une transaction de 1 000 $ pour un client qui dépense généralement 50 $ par transaction. Vous souhaitez conserver les clients considérés comme des anomalies, car ils dépensent généralement beaucoup plus que les autres.

Définir des caractéristiques

Le tableau suivant décrit les caractéristiques calculées pour entraîner le modèle :

Nom de la fonctionnalité Type Description
monetary FLOAT La somme des valeurs monétaires de toutes les transactions d'un client donné pour une période donnée.
fréquence INTEGER Le nombre de transactions effectuées par un client donné pour une période donnée.
recency INTEGER L'intervalle entre la première et la dernière transaction effectuée par un client pour une période donnée.
T INTEGER Le délai entre la première transaction de l'ensemble de données et la fin de la fenêtre des transactions d'entrée.
time_between FLOAT Le temps moyen entre les transactions d'un client donné pour une fenêtre de temps donnée.
avg_basket_value FLOAT La valeur monétaire moyenne du panier d'un client pour une période donnée.
avg_basket_size FLOAT Le nombre moyen d'articles qu'un client donné a dans son panier au cours d'une période donnée.
has_returns STRING Indique si un client donné a renvoyé des articles pour au moins une transaction pendant une période donnée.
avg_time_to_return FLOAT Le temps nécessaire à un client donné pour renvoyer le premier article d'une transaction.
num_returns INTEGER Le nombre d'articles renvoyés par le client et associés à des transactions dans une période donnée.

Définir les paramètres de calcul de la caractéristique

Les paramètres suivants définissent les périodes à utiliser pour les caractéristiques de calcul :

  • WINDOW_STEP : indique le nombre de jours entre les seuils. Cela détermine la fréquence à laquelle vous calculez les caractéristiques et les étiquettes.
  • WINDOW_STEP_INITIAL : spécifie le nombre de jours entre la date de la première commande dans vos données d'entraînement et le premier seuil.
  • WINDOW_LENGTH : indique le nombre de jours passés à utiliser pour les transactions d'entrée. La valeur par défaut consiste à utiliser une valeur de 0, qui prend en compte toutes les transactions avant le seuil spécifié.
  • LENGTH_FUTURE : indique le nombre de jours futurs pour prédire la valeur monetary servant d'étiquette de ML. À chaque seuil, BigQuery calcule la valeur de l'étiquette de toutes les commandes qui ont lieu LENGTH_FUTURE après la date seuil.

Par exemple, supposons que vous disposiez d'un ensemble de données dont la date de transaction la plus ancienne est le 1er janvier 2015, avec les valeurs de paramètres suivantes :

  • WINDOW_STEP : 30
  • WINDOW_STEP_INITIAL : 90
  • WINDOW_LENGTH : 0
  • LENGTH_FUTURE : 30

Les fenêtres temporelles pour les premières boucles de la procédure de création de caractéristiques se présenteraient comme suit :

Première boucle

Réglage Méthode de calcul Valeur
Date seuil La date de la transaction la plus ancienne + la valeur WINDOW_STEP_INITIAL, donc 01/01/2015 + 90 jours. 01/04/2015
Début de la période WINDOW_LENGTH équivalant à 0, toutes les transactions antérieures au seuil sont utilisées. La transaction la plus ancienne s'effectue le 1er janvier 2015. 01/01/2015
Période de transaction d'entrée De la date de début de la période jusqu'à la date seuil (incluse). 01/01/2015 - 01/04/2015
Période de transaction cible De la date seuil (non incluse) jusqu'à la date seuil + le nombre de jours spécifiés par LENGTH_FUTURE (01/04/2015 + 30 jours). 02/04/2015 - 01/05/2015

Deuxième boucle

Réglage Méthode de calcul Valeur
Date seuil La date seuil issue de la boucle précédente + la valeur WINDOW_STEP, soit le 01/04/2015 + 30 jours 01/05/2015
Début de la période WINDOW_LENGTH équivalant à 0, toutes les transactions antérieures au seuil sont utilisées. La transaction la plus ancienne s'effectue le 1er janvier 2015. 01/01/2015
Période de transaction d'entrée De la date de début de la période jusqu'à la date seuil (incluse). 01/01/2015 - 01/05/2015
Période de transaction cible De la date seuil (non incluse) jusqu'à la date seuil + le nombre de jours spécifiés par LENGTH_FUTURE (01/05/2015 + 30 jours). 02/05/2015 - 31/05/2015

Si vous deviez modifier WINDOW_LENGTH pour obtenir une valeur de 15, les intervalles seraient traités comme suit :

Première boucle

Réglage Méthode de calcul Valeur
Date seuil La date de la transaction la plus ancienne + la valeur WINDOW_STEP_INITIAL, donc 01/01/2015 + 90 jours. 01/04/2015
Début de la période Date seuil : valeur WINDOW_LENGTH, soit le 01/04/2015 - 15 jours. 17/03/2015
Période de transaction d'entrée De la date de début de la période jusqu'à la date seuil (incluse). 17/03/2015 - 01/04/2015
Période de transaction cible De la date seuil (non incluse) jusqu'à la date seuil + le nombre de jours spécifiés par LENGTH_FUTURE (01/04/2015 + 30 jours). 02/04/2015 - 01/05/2015

Deuxième boucle

Réglage Méthode de calcul Valeur
Date seuil La date seuil issue de la boucle précédente + la valeur WINDOW_STEP, soit le 01/04/2015 + 30 jours 01/05/2015
Début de la période Date seuil : valeur WINDOW_LENGTH, soit le 01/05/2015 - 15 jours 16/04/2015
Période de transaction d'entrée De la date de début de la période jusqu'à la date seuil (incluse). 16/04/2015 - 01/05/2015
Période de transaction cible De la date seuil (non incluse) jusqu'à la date seuil + le nombre de jours spécifiés par LENGTH_FUTURE (01/05/2015 + 30 jours). 02/05/2015 - 31/05/2015

Définissez les paramètres pour déterminer les périodes de calcul des caractéristiques en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

CLV_PARAMS = {
    'WINDOW_LENGTH': 0,
    'WINDOW_STEP': 30,
    'WINDOW_STEP_INITIAL': 90,
    'LENGTH_FUTURE': 30
}

Dans un cas d'utilisation en production, vous devez modifier ces paramètres pour obtenir des résultats qui conviennent le mieux aux données avec lesquelles vous travaillez. Par exemple, si vos clients achètent plusieurs fois la semaine, vous pouvez calculer des caractéristiques à l'aide de fenêtres hebdomadaires. Ou, si vous avez une grande quantité de données, vous pouvez créer davantage de fenêtres en diminuant leur taille et éventuellement en réduisant le nombre de jours entre les dates seuil. Tester ces paramètres, en plus du réglage des hyperparamètres, peut potentiellement améliorer les performances de votre modèle.

Créer des fonctionnalités

  1. Créez une table avec les caractéristiques calculées pour entraîner le modèle en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery --params $CLV_PARAMS --project $PROJECT_ID
    
    -- Length
    -- Date of the first order in the dataset.
    DECLARE MIN_DATE DATE;
    -- Date of the final order in the dataset.
    DECLARE MAX_DATE DATE;
    -- Date that separates inputs orders from target transactions.
    DECLARE THRESHOLD_DATE DATE;
    -- How many days back for inputs transactions. 0 means from the start.
    DECLARE WINDOW_LENGTH INT64 DEFAULT @WINDOW_LENGTH;
    -- Date at which an input transactions window starts.
    DECLARE WINDOW_START DATE;
    -- How many days between thresholds.
    DECLARE WINDOW_STEP INT64 DEFAULT @WINDOW_STEP;
    -- How many days for the first window.
    DECLARE WINDOW_STEP_INITIAL INT64 DEFAULT @WINDOW_STEP_INITIAL;
    -- Index of the window being run.
    DECLARE STEP INT64 DEFAULT 1;
    -- How many days to predict for.
    DECLARE LENGTH_FUTURE INT64 DEFAULT @LENGTH_FUTURE;
    
    SET (MIN_DATE, MAX_DATE) = (
      SELECT AS STRUCT
        MIN(order_day) AS min_days,
        MAX(order_day) AS max_days
      FROM
        `clv.aggregation`
    );
    
    SET THRESHOLD_DATE = MIN_DATE;
    
    -- For more information about the features of this table,
    -- see https://github.com/CamDavidsonPilon/lifetimes/blob/master/lifetimes/utils.py#L246
    -- and https://cloud.google.com/solutions/machine-learning/clv-prediction-with-offline-training-train#aggregating_data
    CREATE OR REPLACE TABLE clv.features
    (
      customer_id STRING,
      monetary FLOAT64,
      frequency INT64,
      recency INT64,
      T INT64,
      time_between FLOAT64,
      avg_basket_value FLOAT64,
      avg_basket_size FLOAT64,
      has_returns STRING,
      avg_time_to_return FLOAT64,
      num_returns INT64,
      -- threshold DATE,
      -- step INT64,
      target_monetary FLOAT64,
    );
    
    -- Using a BigQuery scripting loop
    -- (https://cloud.google.com/bigquery/docs/reference/standard-sql/scripting#loop)
    -- lets you enhance the logic of your query without the need of another
    -- programming language or client code.
    
    LOOP
      -- Can choose a longer original window in case
      -- there were not many orders in the early days.
      IF STEP = 1 THEN
        SET THRESHOLD_DATE = DATE_ADD(THRESHOLD_DATE, INTERVAL WINDOW_STEP_INITIAL DAY);
      ELSE
        SET THRESHOLD_DATE = DATE_ADD(THRESHOLD_DATE, INTERVAL WINDOW_STEP DAY);
      END IF;
      SET STEP = STEP + 1;
    
      IF THRESHOLD_DATE >= DATE_SUB(MAX_DATE, INTERVAL (WINDOW_STEP) DAY) THEN
        LEAVE;
      END IF;
    
      -- Takes all transactions before the threshold date unless you decide
      -- to use a different window length to test model performance.
      IF WINDOW_LENGTH != 0 THEN
        SET WINDOW_START = DATE_SUB(THRESHOLD_DATE, INTERVAL WINDOW_LENGTH DAY);
     ELSE
        SET WINDOW_START = MIN_DATE;
      END IF;
       INSERT clv.features
      SELECT
        CAST(tf.customer_id AS STRING),
        ROUND(tf.monetary_orders, 2) AS monetary,
        tf.cnt_orders AS frequency,
        tf.recency,
        tf.T,
        ROUND(tf.recency/cnt_orders, 2) AS time_between,
        ROUND(tf.avg_basket_value, 2) AS avg_basket_value,
        ROUND(tf.avg_basket_size, 2) AS avg_basket_size,
        has_returns,
        CEIL(avg_time_to_return) AS avg_time_to_return,
        num_returns,
        ROUND(tt.target_monetary, 2) AS target_monetary,
      FROM (
          -- This SELECT uses only data before THRESHOLD_DATE to make features.
          SELECT
            customer_id,
            SUM(value) AS monetary_orders,
            DATE_DIFF(MAX(order_day), MIN(order_day), DAY) AS recency,
            DATE_DIFF(THRESHOLD_DATE, MIN(order_day), DAY) AS T,
            COUNT(DISTINCT order_day) AS cnt_orders,
            AVG(qty_articles) avg_basket_size,
            AVG(value) avg_basket_value,
            CASE
              WHEN SUM(num_returns) > 0 THEN 'y'
              ELSE 'n'
            END AS has_returns,
            AVG(time_to_return) avg_time_to_return,
            THRESHOLD_DATE AS threshold,
            SUM(num_returns) num_returns,
          FROM
            `clv.aggregation`
          WHERE
            order_day <= THRESHOLD_DATE AND
            order_day >= WINDOW_START
          GROUP BY
            customer_id
        ) tf
          INNER JOIN (
        -- This SELECT uses all data after threshold as target.
        SELECT
          customer_id,
          SUM(value) target_monetary
        FROM
          `clv.aggregation`
        WHERE
          order_day <= DATE_ADD(THRESHOLD_DATE, INTERVAL LENGTH_FUTURE DAY)
          -- For the sample data, the overall value is similar to the value
          -- after threshold, and prediction performs better using the overall
          -- value. When using your own data, try uncommenting the following
          -- AND clause and see which version of the procedure gives you better
          -- results.
          -- AND order_day > THRESHOLD_DATE
        GROUP BY
          customer_id) tt
      ON
          tf.customer_id = tt.customer_id;
      END LOOP;
    
  2. Affichez un échantillon des données d'un client dans la table clv.features résultante en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery
    
    SELECT * FROM `clv.features` WHERE customer_id = "10"
    UNION ALL
    (SELECT * FROM `clv.features` LIMIT 5)
    ORDER BY customer_id, frequency, T LIMIT 5
    
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Cinq premières lignes de données de caractéristique.

Entraîner le modèle

Ce tutoriel utilise AUTOML_REGRESSOR dans BigQuery ML pour créer, entraîner et déployer un modèle de régression AutoML.

Dans ce tutoriel, nous utilisons les paramètres par défaut pour entraîner le modèle. Dans un cas d'utilisation en production, vous pouvez essayer d'autres techniques d'extraction de caractéristiques ainsi que des méthodes de répartition des données d'entraînement différentes afin d'améliorer le modèle.

Créez le modèle clv_model et remplissez-le en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

%%bigquery

CREATE OR REPLACE MODEL `clv.clv_model`
       OPTIONS(MODEL_TYPE="AUTOML_REGRESSOR",
               INPUT_LABEL_COLS=["target_monetary"],
               OPTIMIZATION_OBJECTIVE="MINIMIZE_MAE")
AS SELECT
  * EXCEPT(customer_id)
FROM
  `clv.features`

Vous devriez obtenir un bon modèle de base. Pour adapter le modèle à vos propres données et à votre propre cas d'utilisation, vous pouvez l'optimiser à l'aide des réglages d'hyperparamètres, de l'extraction de caractéristiques et d'autres techniques.

Prédire la CLV

La prochaine étape consiste à obtenir des prédictions sur la CLV à partir du modèle pour chaque client, puis à écrire ces données dans une table. Les enregistrements de prédiction contiennent les champs décrits dans le tableau suivant :

fieldName Type Description
customer_id STRING ID client
monetary_so_far FLOAT Montant total dépensé par le client avant la date de prédiction.
monetary_predicted FLOAT Estimation du montant total dépensé par le client, soit la somme des valeurs des champs monetary_so_far et monetary_future.
monetary_future FLOAT Estimation du futur montant que le client dépensera entre la date de prédiction et la fin de la période de prédiction.
  1. Créez la table clv.predictions et remplissez-la en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery --params $CLV_PARAMS --project $PROJECT_ID
    
    -- How many days back for inputs transactions. 0 means from the start.
    DECLARE WINDOW_LENGTH INT64 DEFAULT @WINDOW_LENGTH;
    -- Date at which an input transactions window starts.
    DECLARE WINDOW_START DATE;
    
    -- Date of the first transaction in the dataset.
    DECLARE MIN_DATE DATE;
    -- Date of the final transaction in the dataset.
    DECLARE MAX_DATE DATE;
    -- Date from which you want to predict.
    DECLARE PREDICT_FROM_DATE DATE;
    
    SET (MIN_DATE, MAX_DATE) = (
      SELECT AS STRUCT
        MIN(order_day) AS min_days,
        MAX(order_day) AS max_days
      FROM
        `clv.aggregation`
    );
    
    -- You can set any date here. In production, it is generally today.
    SET PREDICT_FROM_DATE = MAX_DATE;
    IF WINDOW_LENGTH != 0 THEN
      SET WINDOW_START = DATE_SUB(PREDICT_FROM_DATE, INTERVAL WINDOW_LENGTH DAY);
    ELSE
      SET WINDOW_START = MIN_DATE;
    END IF;
    
    CREATE OR REPLACE TABLE `clv.predictions`
    AS (
    SELECT
      customer_id,
      monetary AS monetary_so_far,
      ROUND(predicted_target_monetary, 2) AS monetary_predicted,
      ROUND(predicted_target_monetary - monetary, 2) AS monetary_future
    FROM
      ML.PREDICT(
        -- To use your own model, set the model name here.
        MODEL clv.clv_model,
        (
          SELECT
            customer_id,
            ROUND(monetary_orders, 2) AS monetary,
            cnt_orders AS frequency,
            recency,
            T,
            ROUND(recency/cnt_orders, 2) AS time_between,
            ROUND(avg_basket_value, 2) AS avg_basket_value,
            ROUND(avg_basket_size, 2) AS avg_basket_size,
            has_returns,
            CEIL(avg_time_to_return) AS avg_time_to_return,
            num_returns
          FROM (
            SELECT
              customer_id,
              SUM(value) AS monetary_orders,
              DATE_DIFF(MAX(order_day), MIN(order_day), DAY) AS recency,
              DATE_DIFF(PREDICT_FROM_DATE, MIN(order_day), DAY) AS T,
              COUNT(DISTINCT order_day) AS cnt_orders,
              AVG(qty_articles) avg_basket_size,
              AVG(value) avg_basket_value,
              CASE
                WHEN SUM(num_returns) > 0 THEN 'y'
                ELSE 'n'
              END AS has_returns,
              AVG(time_to_return) avg_time_to_return,
              SUM(num_returns) num_returns,
            FROM
              `clv.aggregation`
            WHERE
              order_day <= PREDICT_FROM_DATE AND
              order_day >= WINDOW_START
            GROUP BY
              customer_id
          )
        )
      )
    )
    
  2. Affichez un exemple des données de la table clv.features résultante en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery
    
    SELECT * FROM clv.predictions
    ORDER BY customer_id
    LIMIT 5;
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Cinq premières lignes de données de prédiction.

Évaluer les données de prédiction

Visualisez et générez des statistiques sur les données de prédiction afin de mieux comprendre la distribution des données et de voir s'il existe des tendances claires.

  1. Créez un DataFrame basé sur la table clv.predictions :

    %%bigquery df_predictions --project $PROJECT_ID
    
    clv.predictions
    
  2. Utilisez pandas.DataFrame.describe pour générer des statistiques descriptives sur les données de prédiction. Pour ce faire, copiez le code suivant dans la prochaine cellule vide du notebook, puis exécutez-le :

    df_predictions.describe()
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Statistiques concernant les données de prédiction.

  3. Utilisez matplotlib.gridspec pour visualiser les données de prédiction en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    from matplotlib.gridspec import GridSpec
    
    fig = plt.figure(constrained_layout=True, figsize=(15, 5))
    gs = GridSpec(2, 2, figure=fig)
    
    sns.set(font_scale = 1)
    plt.tick_params(axis='x', labelsize=14)
    
    ax0 = plt.subplot(gs.new_subplotspec((0, 0), colspan=1))
    ax1 = plt.subplot(gs.new_subplotspec((0, 1), colspan=1))
    ax2 = plt.subplot(gs.new_subplotspec((1, 0), colspan=2))
    
    sns.violinplot(df_predictions['monetary_so_far'], ax=ax0, label='monetary_so_far')
    sns.violinplot(df_predictions['monetary_predicted'], ax=ax1, label='monetary_predicted')
    sns.violinplot(df_predictions['monetary_future'], ax=ax2, label='monetary_future')
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Visualisation de la distribution des données de prédiction.

    L'analyse de la distribution monétaire indique de petites sommes monétaires pour le mois suivant par rapport à la valeur historique globale. Une raison à cela est que le modèle est entraîné à prédire la valeur du mois suivant, comme spécifié dans le paramètre LENGTH_FUTURE. Vous pouvez tester le changement de cette valeur afin d'effectuer l'entraînement et la prédiction pour le prochain trimestre (soit LENGTH_FUTURE = 90), et voir comment la distribution évolue.

Créer une audience similaire

Utilisez les procédures décrites dans cette section pour créer et exporter la liste des clients ayant une valeur de CLV élevé, puis utilisez cette liste pour créer une audience similaire dans Google Ads.

Les exemples de code présentés dans les sections après Identifier les principaux clients en fonction de la CLV ne sont exécutés que si vous avez accès à un environnement Google Ads opérationnel. Corrigez les Exigences applicables à l'intégration de Google Ads pour que cet exemple de code puisse être exécuté avec votre propre environnement Google Ads.

Identifier les principaux clients en fonction de la valeur vie client

Pour créer une audience similaire, la première étape consiste à identifier vos principaux clients en fonction de leur CLV prédite, puis à leur associer des adresses e-mail. Pour ce faire, utilisez le numéro client pour joindre la table des prédictions à une table de données client contenant ces informations.

Ce tutoriel utilise les 20% des meilleurs clients, en fonction de la CLV. Pour modifier le pourcentage de clients à sélectionner, modifiez le paramètre TOP_CLV_RATIO. L'instruction SQL permettant de sélectionner les clients utilise la fonction PERCENT_RANK pour identifier les clients se situant au pourcentage identifié par la valeur TOP_CLV_RATIO ou au-dessus en raison de leurs dépenses futures prévues.

  1. Définissez le paramètre TOP_CLV_RATIO en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    CLV_PARAMS = {
        'TOP_CLV_RATIO': 0.2
    }
    
  2. Créez le DataFrame df_top_ltv et remplissez-le en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    %%bigquery df_top_ltv --params $CLV_PARAMS --project $PROJECT_ID
    
    DECLARE TOP_CLV_RATIO FLOAT64 DEFAULT @TOP_CLV_RATIO;
    
    SELECT
      p.customer_id,
      monetary_future,
      c.email AS email
    FROM (
      SELECT
        customer_id,
        monetary_future,
        PERCENT_RANK() OVER (ORDER BY monetary_future DESC) AS percent_rank_monetary
      FROM
        `clv.predictions` ) p
    INNER JOIN (
      SELECT
        customer_id,
        email
      FROM
        `clv.customers` ) c
    ON
      p.customer_id = c.customer_id
    WHERE
      -- Decides the size of your list of emails. For similar-audience use cases
      -- where you need to find a minimum of matching emails, 20% should provide
      -- enough potential emails.
      percent_rank_monetary <= TOP_CLV_RATIO
    ORDER BY monetary_future DESC
    
  3. Affichez un exemple des données df_top_ltv en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    df_top_ltv.head(5)
    

    Un résultat semblable aux lignes suivantes doit s'afficher :

    Cinq premières lignes des principaux clients en fonction des données de CLV.

Créer le fichier de configuration Google Ads

Créez le fichier YAML de configuration pour le client Google Ads.

  1. Définissez les variables de fichier YAML contrôlant l'accès à l'API Google Ads en remplaçant les variables d'espace réservé ci-dessous par les valeurs appropriées pour votre environnement. Consultez la page Conditions requises pour l'intégration de Google Ads pour savoir comment obtenir les jetons et les identifiants OAuth requis si vous ne les possédez pas déjà.

    Copiez le code suivant dans la prochaine cellule vide du notebook, puis exécutez-le :

    DEVELOPER_TOKEN = "myDeveloperToken"
    OAUTH_2_CLIENT_ID = "myClientId"
    CLIENT_SECRET = "myClientSecret"
    REFRESH_TOKEN = "myRefreshToken"
    
  2. Créez le contenu du fichier YAML en copiant le code ci-dessous dans la prochaine cellule vide du notebook, puis en l'exécutant.

    ADWORDS_FILE = "/tmp/adwords.yaml"
    
    adwords_content = f"""
    # AdWordsClient configurations
    adwords:
      #############################################################################
      # Required Fields                                                           #
      #############################################################################
      developer_token: {DEVELOPER_TOKEN}
      #############################################################################
      # Optional Fields                                                           #
      #############################################################################
      # client_customer_id: INSERT_CLIENT_CUSTOMER_ID_HERE
      # user_agent: INSERT_USER_AGENT_HERE
      # partial_failure: True
      # validate_only: True
      #############################################################################
      # OAuth2 Configuration                                                      #
      # Below you may provide credentials for either the installed application or #
      # service account flows. Remove or comment the lines for the flow you're    #
      # not using.                                                                #
      #############################################################################
      # The following values configure the client for the installed application
      # flow.
      client_id: {OAUTH_2_CLIENT_ID}
      client_secret: {CLIENT_SECRET}
      refresh_token: {REFRESH_TOKEN}
      # The following values configure the client for the service account flow.
      # path_to_private_key_file: INSERT_PATH_TO_JSON_KEY_FILE_HERE
      # delegated_account: INSERT_DOMAIN_WIDE_DELEGATION_ACCOUNT
      #############################################################################
      # ReportDownloader Headers                                                  #
      # Below you may specify boolean values for optional headers that will be    #
      # applied to all requests made by the ReportDownloader utility by default.  #
      #############################################################################
        # report_downloader_headers:
        # skip_report_header: False
        # skip_column_header: False
        # skip_report_summary: False
        # use_raw_enum_values: False
    
    # AdManagerClient configurations
    ad_manager:
      #############################################################################
      # Required Fields                                                           #
      #############################################################################
      application_name: INSERT_APPLICATION_NAME_HERE
      #############################################################################
      # Optional Fields                                                           #
      #############################################################################
      # The network_code is required for all services except NetworkService:
      # network_code: INSERT_NETWORK_CODE_HERE
      # delegated_account: INSERT_DOMAIN_WIDE_DELEGATION_ACCOUNT
      #############################################################################
      # OAuth2 Configuration                                                      #
      # Below you may provide credentials for either the installed application or #
      # service account (recommended) flows. Remove or comment the lines for the  #
      # flow you're not using.                                                    #
      #############################################################################
      # The following values configure the client for the service account flow.
      path_to_private_key_file: INSERT_PATH_TO_JSON_KEY_FILE_HERE
      # delegated_account: INSERT_DOMAIN_WIDE_DELEGATION_ACCOUNT
      # The following values configure the client for the installed application
      # flow.
      # client_id: INSERT_OAUTH_2_CLIENT_ID_HERE
      # client_secret: INSERT_CLIENT_SECRET_HERE
      # refresh_token: INSERT_REFRESH_TOKEN_HERE
    
    # Common configurations:
    ###############################################################################
    # Compression (optional)                                                      #
    # Below you may specify whether to accept and automatically decompress gzip   #
    # encoded SOAP requests. By default, gzip compression is not enabled.         #
    ###############################################################################
    # enable_compression: False
    ###############################################################################
    # Logging configuration (optional)                                            #
    # Below you may specify the logging configuration. This will be provided as   #
    # an input to logging.config.dictConfig.                                      #
    ###############################################################################
    # logging:
      # version: 1
      # disable_existing_loggers: False
      # formatters:
        # default_fmt:
          # format: ext://googleads.util.LOGGER_FORMAT
      # handlers:
        # default_handler:
          # class: logging.StreamHandler
          # formatter: default_fmt
          # level: INFO
      # loggers:
        # Configure root logger
        # "":
          # handlers: [default_handler]
          # level: INFO
    ###############################################################################
    # Proxy configurations (optional)                                             #
    # Below you may specify an HTTP or HTTPS Proxy to be used when making API     #
    # requests. Note: You must specify the scheme used for the proxy endpoint.    #
    #                                                                             #
    # For additional information on configuring these values, see:                #
    # http://docs.python-requests.org/en/master/user/advanced/#proxies            #
    ###############################################################################
    # proxy_config:
      # http: INSERT_HTTP_PROXY_URI_HERE
      # https: INSERT_HTTPS_PROXY_URI_HERE
      # If specified, the given cafile will only be used if certificate validation
      # is not disabled.
      # cafile: INSERT_PATH_HERE
      # disable_certificate_validation: False
    ################################################################################
    # Utilities Included (optional)                                                #
    # Below you may specify whether the library will include utilities used in the #
    # user agent. By default, the library will include utilities used in the user  #
    # agent.                                                                       #
    ################################################################################
    # include_utilities_in_user_agent: True
    ################################################################################
    # Custom HTTP headers (optional)                                               #
    # Specify one or more custom headers to pass along with all requests to        #
    # the API.                                                                     #
    ################################################################################
    # custom_http_headers:
    #   X-My-Header: 'content'
    """
    
  3. Remplissez le fichier YAML en copiant le code ci-dessous dans la prochaine cellule vide du notebook, puis en l'exécutant.

    with open(ADWORDS_FILE, "w") as adwords_file:
        print(adwords_content, file=adwords_file)
    

Créer une liste de remarketing Google Ads

Créez une liste de remarketing Google Ads à l'aide des adresses e-mail des clients ayant la CLV la plus élevée.

  1. Créez une liste contenant les adresses e-mail des clients avec les CLV les plus élevée en copiant le code suivant dans la prochaine cellule vide, puis en l'exécutant :

    ltv_emails = list(set(df_top_ltv['email']))
    
  2. Créez la liste de remarketing en copiant le code suivant dans la prochaine cellule vide du notebook, puis en l'exécutant :

    """Adds a user list and populates it with hashed email addresses.
    
    Note: It may take several hours for the list to be populated with members. Email
    addresses must be associated with a Google account. For privacy purposes, the
    user list size will show as zero until the list has at least 1000 members. After
    that, the size will be rounded to the two most significant digits.
    """
    
    import hashlib
    import uuid
    
    # Import appropriate modules from the client library.
    from googleads import adwords
    
    def main(client):
      # Initialize appropriate services.
      user_list_service = client.GetService('AdwordsUserListService', 'v201809')
    
      user_list = {
          'xsi_type': 'CrmBasedUserList',
          'name': 'Customer relationship management list #%d' % uuid.uuid4(),
          'description': 'A list of customers that originated from email addresses',
          # CRM-based user lists can use a membershipLifeSpan of 10000 to indicate
          # unlimited; otherwise normal values apply.
          'membershipLifeSpan': 30,
          'uploadKeyType': 'CONTACT_INFO'
      }
    
      # Create an operation to add the user list.
      operations = [{
          'operator': 'ADD',
          'operand': user_list
      }]
    
      result = user_list_service.mutate(operations)
      user_list_id = result['value'][0]['id']
    
      emails = ['customer1@example.com', 'customer2@example.com',
                ' Customer3@example.com ']
      members = [{'hashedEmail': NormalizeAndSHA256(email)} for email in emails]
    
      # Add address info.
      members.append({
          'addressInfo': {
              # First and last name must be normalized and hashed.
              'hashedFirstName': NormalizeAndSHA256('John'),
              'hashedLastName': NormalizeAndSHA256('Doe'),
              # Country code and zip code are sent in plaintext.
              'countryCode': 'US',
              'zipCode': '10001'
          }
      })
    
      mutate_members_operation = {
          'operand': {
              'userListId': user_list_id,
              'membersList': members
          },
          'operator': 'ADD'
      }
    
      response = user_list_service.mutateMembers([mutate_members_operation])
    
      if 'userLists' in response:
        for user_list in response['userLists']:
          print('User list with name "%s" and ID "%d" was added.'
                % (user_list['name'], user_list['id']))
    
    def NormalizeAndSHA256(s):
      """Normalizes (lowercase, remove whitespace) and hashes a string with SHA-256.
    
      Args:
        s: The string to perform this operation on.
    
      Returns:
        A normalized and SHA-256 hashed string.
      """
      return hashlib.sha256(s.strip().lower()).hexdigest()
    
    if __name__ == '__main__':
      # Initialize the client object with the config
      # file you created in the previous section.
      adwords_client = adwords.AdWordsClient.LoadFromStorage(ADWORDS_FILE)
      main(adwords_client)
    

Ajouter une audience similaire

Une fois que vous disposez de la liste de remarketing, suivez ces instructions dans la documentation Google Ads pour ajouter des audiences similaires à votre ciblage.

Étapes suivantes facultatives

Utilisez les informations figurant dans les sections suivantes pour éventuellement améliorer les performances du modèle et automatiser le workflow de ML.

Améliorer le modèle

Ce tutoriel vous a montré l'une des approches possibles pour créer un modèle de base permettant de prédire la valeur monétaire future de vos clients. Si vous avez décidé d'approfondir cette démarche, voici quelques suggestions d'aspects à améliorer ou à tester :

  • Si vos données présentent de nombreuses anomalies, procédez à une ingénierie de données supplémentaire ou recherchez des données d'entraînement supplémentaires.
  • Testez différentes approches pour créer des caractéristiques en ajustant les limites des périodes ou en modifiant le ratio d'entrée par rapport aux transactions cibles.
  • Lorsque vous comparez des modèles, assurez-vous d'utiliser le même ensemble de données de test afin de comparer équitablement les performances des modèles. Par exemple, ce tutoriel prépare les données pour prédire au mieux les commandes des 30 prochains jours. Si vous souhaitez qu'un modèle effectue des prédictions pour le prochain trimestre, vous devez mettre à jour le paramètre LENGTH_FUTURE et recalculer les caractéristiques.
  • L'exemple d'ensemble de données utilise un nombre limité de champs. Si d'autres variables telles que des catégories de produits, des régions géographiques ou des données démographiques sont présentes dans vos propres données, essayez de créer des caractéristiques supplémentaires pour votre modèle.

Automatiser le workflow de ML

Au cours des étapes précédentes, vous avez appris à utiliser BigQuery et BigQuery ML pour préparer des données pour le machine learning, créer et entraîner un modèle, obtenir des prédictions et préparer des données pour l'intégration à Google Ads.

Dans un cas d'utilisation en production, toutes ces tâches sont récurrentes. Vous pouvez effectuer ces étapes manuellement à chaque fois, mais nous vous recommandons d'automatiser le processus. Ce tutoriel contient du code associé dans GitHub qui fournit un ensemble de procédures stockées dans BigQuery permettant d'automatiser ces étapes, ainsi qu'un script shell, run.sh, que vous pouvez utiliser pour les exécuter.

Vous pouvez utiliser les paramètres suivants lorsque vous appelez le script run.sh afin de le configurer pour qu'il fonctionne dans votre environnement :

Variable Description Par défaut
PROJECT_ID ID du projet Obligatoire
DATASET_ID ID de l'ensemble de données Obligatoire
TRAIN_MODEL_ID Nom du modèle entraîné. Définissez cette valeur sur *null* si vous ne souhaitez pas entraîner de modèle. Chaîne basée sur le temps.
USE_MODEL_ID Nom du modèle à utiliser pour les prédictions. Doit inclure un ensemble de données : [DATASET].[MODEL] Chaîne basée sur le temps.
WINDOW_LENGTH Temps (en jours) pour les transactions d'entrée. 0
WINDOW_STEP Temps (en jours) entre deux périodes. Équivaut au temps compris entre deux dates seuil. 30
WINDOW_STEP_INITIAL Temps initial (en jours) avant la première date seuil. 90
LENGTH_FUTURE Temps (en jours) à partir de quand vous souhaitez effectuer une prédiction. 30
MAX_STDV_MONETARY Écart type de la valeur monétaire par client au-dessus duquel le script supprime des transactions. 500
MAX_STDV_QTY Écart type de la valeur de quantité par client au-dessus duquel le script supprime des transactions. 100
TOP_LTV_RATIO Pourcentage des principaux clients à extraire. 0,20

Pour utiliser le script run.sh pour l'automatisation, procédez comme suit :

  1. Clonez le dépôt GitHub :

    git clone https://github.com/GoogleCloudPlatform/analytics-componentized-patterns.git
    
  2. Mettez à jour le script run.sh pour définir les valeurs des paramètres en fonction de votre environnement.

  3. Si vous utilisez vos propres données de transaction, mettez à jour 10_procedure_match.sql pour spécifier les colonnes appropriées dans votre table de transactions.

  4. Modifiez les autorisations sur le script run.sh pour pouvoir l'exécuter :

    chmod +x run.sh
    
  5. Pour savoir comment définir ces paramètres, consultez l'aide associée à la ligne de commande.

    ./run.sh --help
    
  6. Exécutez le script :

    ./run.sh --project-id [YOUR_PROJECT_ID] --dataset-id [YOUR_DATASET_ID]
    

Dans un cas d'utilisation en production, vous pouvez contacter vos ingénieurs de données et votre équipe DevOps pour leur demander d'intégrer les procédures stockées à leurs outils pour en faciliter l'utilisation.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, vous pouvez soit supprimer le projet contenant les ressources, soit le conserver, mais supprimer uniquement ces ressources.

Dans les deux cas, vous devez supprimer ces ressources afin d'éviter qu'elles ne vous soient facturées par la suite. Dans les sections suivantes, nous allons voir comment supprimer ces ressources.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les composants

Si vous ne souhaitez pas supprimer le projet, reportez-vous aux sections suivantes pour supprimer les composants facturables de ce tutoriel.

Supprimer l'ensemble de données et les tables BigQuery

  1. Ouvrez la console BigQuery
  2. Dans la section Ressources, développez le projet dans lequel vous avez terminé ce tutoriel, puis sélectionnez l'ensemble de données clv.
  3. Cliquez sur Supprimer l'ensemble de données dans l'en-tête du volet de l'ensemble de données.
  4. Dans la fenêtre qui apparaît en superposition, saisissez clv, puis cliquez sur Supprimer.

Supprimer le notebook AI Platform

  1. Ouvrir la page AI Platform Notebooks
  2. Cochez la case correspondant à l'instance de notebook clv.
  3. Cliquez sur Supprimer.
  4. Dans la fenêtre qui apparaît en superposition, cliquez sur Supprimer.

Étape suivante