Compila nuevos públicos en función del valor del ciclo de vida del cliente existente

Aprende a predecir el valor del ciclo de vida del cliente (CLV) y, luego, usar estos datos para identificar a potenciales nuevos clientes mediante la compilación de públicos similares en Google Ads.

Descripción general

En este instructivo, se muestra cómo predecir el posible valor monetario por cliente para un plazo específico según el historial de transacciones del cliente. Para ello, sigue estos pasos:

  • Importa datos de transacciones y clientes a BigQuery
  • Procesa los datos para usarlos con un modelo de aprendizaje automático (AA).
  • Compila el modelo del AA mediante BigQuery ML.
  • Obtén predicciones del modelo para identificar a los clientes principales por CLV.
  • Recupera direcciones de correo electrónico de estos clientes desde una tabla de datos de clientes.
  • Usa estos datos combinados a fin de crear una lista de remarketing para usar en Google Ads.
  • Usa esta lista de remarketing como base para generar un público similar que se pueda usar en la segmentación de anuncios.

En este instructivo, se explica cómo crear un AI Platform Notebooks para satisfacer estos objetivos, con orientación prescriptiva y procedimientos paso a paso. En cambio, si deseas comenzar a usar un notebook completo, puedes usar bqml_automl_ltv_activate_lookalike.ipynb en el servidor de notebook que prefieras.

Este instructivo está dirigido a ingenieros de datos, científicos de datos y analistas de datos que compilan modelos y conjuntos de datos del AA para respaldar las decisiones empresariales. Suponemos que tienes conocimientos básicos sobre lo siguiente:

  • Conocimientos básicos de los conceptos del aprendizaje automático y Python
  • SQL estándar

Este instructivo refactoriza el ejemplo usado en Predice el valor del ciclo de vida del cliente con AutoML Tables, que es la cuarta y última parte de otra serie de instructivos sobre cómo predecir el CLV. Considera leer el primer instructivo de esa serie, Predice el valor del ciclo de vida del cliente con AI Platform: Introducción, si deseas comprender mejor los puntos de decisión clave específicos para hacer ingeniería de atributos y desarrollo del modelo del descubrimiento de CLV.

El ejemplo en este instructivo se diferencia de la que se encuentra en Predice el valor del ciclo de vida del cliente con AutoML Tables de las siguientes maneras:

  • Se crean varios registros por cliente para usar en el entrenamiento del modelo. Para ello, segmenta las transacciones de los clientes en períodos superpuestos.
  • Te permite usar el modelo para predecir el CLV en diferentes períodos, por ejemplo, un mes o un trimestre, con solo cambiar los parámetros de entrada del modelo.
  • Minimiza el tiempo de desarrollo con AutoML directamente desde BigQuery ML.
  • Usa conjuntos de datos diferentes para los datos de ventas y clientes.
  • Muestra cómo usar las predicciones de CLV para crear públicos similares en Google Ads.

Conjuntos de datos

Para crear una lista de clientes con CLV a partir de los que puedes compilar un público similar, necesitas dos conjuntos de datos:

  • Transacciones de ventas para los clientes que deseas evaluar. Usa cálculos basados en estos datos para entrenar del modelo de CLV. En un caso de uso de producción, extraerías esta información de tu sistema de procesamiento de pedidos.
  • Direcciones de correo electrónico de clientes. En un caso de uso de producción, puedes extraer esta información de tu sistema de administración de relaciones con clientes (CRM).

En este instructivo, se proporcionan datos de muestra en dos archivos CSV que cargas en tablas de BigQuery. Ambos conjuntos de datos contienen un ID de cliente que se usa para unir tablas con el fin de asociar la dirección de correo electrónico del cliente con la información del CLV.

Modelo

En este instructivo, se muestra cómo crear un modelo de regresión a fin de usarlo a fin de predecir el valor monetario futuro de tus clientes, ya que este tipo de modelo es adecuado para predecir una variable continua (también llamada valor continuo), como el importe de CLV.

En este instructivo, se usa BigQuery ML para crear un modelo de regresión de AutoML. Usar AutoML ayuda a minimizar la sobrecarga de desarrollo de las siguientes maneras:

  • Ingeniería de atributos: AutoML controla de forma automática varias tareas comunes de ingeniería de atributos.
  • Integración de BigQuery ML: puedes crear modelos de AutoML mediante instrucciones de SQL de BigQuery ML, lo que limita la necesidad de alternar entre distintos contextos de desarrollo.
  • Dividir el conjunto de datos de entrenamiento: cuando se entrena un modelo, se recomienda dividir los datos en tres conjuntos de datos que no se superponen: entrenamiento, validación y prueba. AutoML controla esto de forma predeterminada, aunque también puedes especificar una división en particular si lo deseas.

Calcula los atributos y las etiquetas

En este instructivo, usarás fechas de umbrales para segmentar las transacciones de los clientes a lo largo del tiempo en varias ventanas que se superponen. Una fecha límite separa las transacciones de entrada de las transacciones de destino. Las transacciones de entrada se realizan antes de la fecha límite y se usan para calcular los atributos que ingresas en el modelo. Las transacciones de destino se producen después de la fecha límite y se usan para calcular el CLV durante ese período, que se usa como la etiqueta en la que se entrena el modelo predecir.

Atributos de RFM

Tres atributos importantes que se usan en los modelos de CLV son los valores de compras recientes, frecuencia y monetario (RFM), que se calculan a partir de datos históricos de transacciones del cliente:

  • Compras recientes: ¿Cuándo fue el último pedido del cliente?
  • Frecuencia: ¿Con qué frecuencia compra?
  • Valor monetario: ¿Qué cantidad de dinero gasta?

En el siguiente diagrama, se muestra una sucesión de ventas pasadas para un conjunto de cuatro clientes.

Historial de ventas de 4 clientes

En el diagrama, se ilustran los valores de RFM y se muestra lo siguiente para cada cliente:

  • Compras recientes: el período entre la última compra y hoy, representado por la distancia entre el círculo del extremo derecho y la línea de puntos vertical etiquetada como Ahora.
  • Frecuencia: El período entre las compras, representado por la distancia entre los círculos en una sola línea.
  • Valor monetario: La cantidad de dinero gastado en cada compra, representada por el tamaño del círculo.

Requisitos para la integración de Google Ads

El código de ejemplo en las secciones de este instructivo en la integración de Google Ads requiere acceso a un entorno de Google Ads en funcionamiento para ejecutarse. Para que el código de ejemplo se pueda ejecutar con tu propio entorno de Google Ads, debes contar con los siguientes elementos:

  • Una cuenta de administrador de Google Ads y acceso a la API de Google Ads. Si aún no las tienes, sigue las instrucciones del procedimiento de Registro para obtenerlas.
  • Un token de desarrollador de Google Ads, un ID de cliente de OAuth y un secreto del cliente, y un token de actualización de OAuth para la biblioteca cliente de Google Ads para Python. Si aún no tienes estos artículos, sigue las instrucciones en Configura el acceso a la API de AdWords para obtenerlos. Para el paso 5 en ese procedimiento, puedes usar googleads-python-lib/examples/adwords/authentication/generate_refresh_token.py para ver cómo obtener un token de actualización.
  • Datos de transacción que puedes usar para calcular el CLV y datos de clientes que incluyen la dirección de correo electrónico del cliente. Usa esto en lugar de los datos de muestra proporcionados en la sección Importar los datos. Deberás asegurarte de que tus datos usen los mismos nombres y esquemas de tabla que los datos de muestra. En las siguientes tablas, se describen las tablas esperadas de BigQuery:

Tabla clv.sales

Column Tipo de datos
customer_id INTEGER
order_id STRING
transaction_date DATE
product_sku STRING
qty INTEGER
unit_price FLOAT

Tabla clv.customers

Column Tipo de datos
customer_id INTEGER
full_name STRING
age INTEGER
job_title STRING
email STRING

Objetivos

  1. Preparar y explorar datos de entrenamiento con BigQuery.
  2. Compilar, implementar y entrenar un modelo del AA con BigQuery ML.
  3. Obtener predicciones de CLV a partir del modelo implementado
  4. Crear una lista de los clientes que representen el 20% de CLV superior.
  5. Crear una lista de remarketing de Google Ads basada en la lista de clientes de CLV principales, que luego puedes usar para generar un público similar a esos clientes.

Costos

En este instructivo, se usan componentes facturables de Google Cloud, que incluyen los siguientes:

  • AI Platform
  • BigQuery
  • BigQuery ML
  • Compute Engine

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de Google Cloud pueden ser elegibles para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. Habilita las API de Compute Engine, BigQuery, and Notebooks.

    Habilita las API

Crea un notebook

  1. Abre la consola de Notebooks
  2. Haz clic en Instancia nueva (New instance).
  3. Elige Python 2 y 3.
  4. En Nombre de la instancia, escribe clv.
  5. Haz clic en Crear. La instancia de notebook toma unos minutos en crearse.
  6. Cuando la instancia esté disponible, haz clic en Abrir JupyterLab.
  7. En la sección Notebook del iniciador de JupyterLab, haz clic en Python 3.

Instala bibliotecas

Instala googleads y otras bibliotecas necesarias para este instructivo:

  1. Copia el siguiente código en la primera celda del 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. Haz clic en Ejecutar  en la barra de menú.

Importa paquetes

Para instalar los paquetes necesarios de este instructivo, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

Crea un cliente de BigQuery

Crea un cliente de BigQuery para la Biblioteca cliente de Python para BigQuery y copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo. Reemplaza myProject por el ID del proyecto que usarás para completar este instructivo. Puedes encontrar el ID del proyecto en la tarjeta de Información del proyecto en el panel del proyecto de Google Cloud.

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

Importa los datos

Usa las instrucciones de las siguientes secciones a fin de importar los datos de muestra a BigQuery y, luego, procésalo para entrenar el modelo del AA.

Si tienes un entorno de Google Ads en funcionamiento, puedes usar tus propios datos en lugar de importar la muestra. Propaga la tabla clv.sales con datos de transacciones que puedes usar para calcular el CLV y propaga la tabla clv.customers con los datos del cliente que incluyen la dirección de correo electrónico del cliente.

Cree un conjunto de datos

Antes de crear tablas de BigQuery para los datos de ejemplo, debes crear un conjunto de datos que las contenga.

Para crear el conjunto de datos clv, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo. Reemplaza myProject por el ID del proyecto que usarás para completar este instructivo.

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

Importa los datos de ventas

Para crear y propagar la tabla clv.sales, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

! 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_*

Importa los datos de clientes

Para crear y propagar la tabla clv.customers, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

! 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

Prepara los datos

Si deseas preparar los datos de transacciones del cliente a fin de que puedas usarlos para entrenar el modelo del AA, debes completar las siguientes tareas:

  • Establece parámetros que determinen la desviación estándar permitida para el valor monetario y la cantidad de artículos. Se usan para identificar y quitar registros de valores atípicos de cada cliente cuando realizas la agregación inicial de los datos de transacciones de los clientes.
  • Agregar los datos de las transacciones de los clientes
  • Verifica la distribución de los datos agregados entre criterios, como las transacciones por cliente y la cantidad de artículos por pedido, a fin de identificar las áreas en las que quizás quieras definir mejor los datos.
  • Define las características que se procesarán a partir de los datos agregados, como los valores de RFM.
  • Configura los parámetros que definen los períodos que se usarán para el cálculo de atributos. Por ejemplo, la cantidad de días que debe haber entre dos fechas límite.
  • Calcula los atributos necesarios para entrenar el modelo.

Establece parámetros de agregación

Usa los siguientes parámetros en el procedimiento de agregación para definir los valores de desviación estándar máximos:

  • MAX_STDV_MONETARY: Es la desviación estándar del valor monetario por cliente.
  • MAX_STDV_QTY: Es la desviación estándar de la cantidad de productos por cliente.

Para configurar los parámetros a fin de determinar los valores de variación estándar que se usarán, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

En un caso de uso de producción, puedes modificar estos parámetros a fin de determinar qué rangos de valores son aceptables para el valor del pedido y la cantidad de artículos.

Agrega datos de transacciones de clientes

La siguiente consulta agrega todos los pedidos por día por cliente. Dado que la tarea del AA es predecir un valor monetario por un período, como semanas o meses, los días funcionan bien como una unidad de tiempo para agrupar las transacciones por cliente.

Esta consulta también quita los pedidos que son valores atípicos para cada cliente. Se filtran los pedidos en los que el valor de pedido o la cantidad de productos quedan fuera de los valores de desviación estándar que admiten MAX_STDV_MONETARY y MAX_STDV_QTY.

  1. Para crear una tabla con datos agregados de transacciones del cliente, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    %%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. Para ver una muestra de los datos en la tabla clv.aggregation resultante, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

    Deberías ver resultados similares a los siguientes:

    Primeras 5 filas de datos agregados.

En un caso de uso de producción, es probable que quieras definir mejor los datos mediante la aplicación de criterios de selección adicionales, como las siguientes opciones:

  • Quita los registros que no tengan cantidades positivas de artículos e importe de la compra.
  • Quita los registros que no tienen un ID de cliente.
  • Mantén solo a los clientes activos, aunque tú defines eso. Por ejemplo, es posible que desees enfocarte en los clientes que compraron algo en los últimos 90 días.

Verifica la distribución de datos

Este instructivo realiza una limpieza mínima de los datos, en su lugar, se enfoca en realizar una transformación básica de los datos de la transacción para que funcione con el modelo. En esta sección, verificarás la distribución de datos para determinar dónde hay valores atípicos y, además, identificar las áreas que te permitirán definir mejor los datos.

Verifica la distribución por fecha

  1. Para crear y propagar el marco de datos df_dist_dates con datos de fecha de las transacciones agregadas, copia el siguiente código en la siguiente celda vacía del notebook y, luego, completa los datos. ejecución:

    %%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. Usa Seaborn para visualizar los datos de fecha con la copia del siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

    Deberías ver resultados similares a los siguientes:

    Visualización de la distribución de datos de fecha

    Los pedidos están bien distribuidos durante el año, aunque se observa un poco menos en los primeros meses capturados en este conjunto de datos. En un caso de uso de producción, puedes usar la distribución de datos por fecha como un factor a fin de tener en cuenta cuando configures los parámetros de período de tiempo para el procedimiento de cálculo de atributos.

Verifica la distribución por transacciones por cliente

  1. Para crear y propagar el marco de datos df_dist_customers con los recuentos de transacciones de los clientes, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    %%bigquery df_dist_customers --project $PROJECT_ID
    
    SELECT customer_id, count(1) c
    FROM `clv.aggregation`
    GROUP BY customer_id
    
  2. Para usar Seaborn a fin de visualizar los datos de la transacción del cliente, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

    Deberías ver resultados similares a los siguientes:

    Visualización de la distribución de datos de clientes

    Estos datos tienen una buena distribución, con la cantidad de transacciones por cliente distribuidas en un rango reducido y sin valores atípicos claros.

Verifica la distribución por cantidad de artículos

  1. Para crear y propagar el marco de datos df_dist_qty con datos de cantidad de artículos de las transacciones agregadas, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    %%bigquery df_dist_qty --project $PROJECT_ID
    
    SELECT qty_articles, count(1) c
    FROM `clv.aggregation`
    GROUP BY qty_articles
    
  2. Para usar Seaborn a fin de visualizar los datos de cantidad de elementos, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

    Deberías ver resultados similares a los siguientes:

    Visualización de la distribución de datos por cantidad de artículos.

    Algunos clientes tienen grandes cantidades en sus pedidos, pero la distribución suele ser buena. En un caso de uso de producción, puedes realizar más ingeniería de datos en esta área. Deseas quitar las transacciones que sean atípicas de clientes individuales. Por ejemplo, si quitas una transacción de 20 artículos para un cliente que suele comprar 1 o 2 artículos. Deseas mantener a los clientes con valores atípicos en que suelen comprar muchos más artículos que otros.

Verifica la distribución por valor monetario

  1. Para crear y propagar el marco de datos df_dist_values con datos de valor monetario de las transacciones agregadas, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    %%bigquery df_dist_values --project $PROJECT_ID
    
    SELECT value
    FROM `clv.aggregation`
    
  2. Para usar Seaborn a fin de visualizar los datos del valor monetario, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

    Deberías ver resultados similares a los siguientes:

    Visualización de la distribución de datos monetarios

    La distribución muestra algunos valores atípicos que invierten mucho más que el promedio. En un caso de uso de producción, puedes realizar más ingeniería de datos en esta área. Deseas quitar las transacciones con valores atípicos de clientes individuales. Por ejemplo, quitar una transacción de $1,000 para un cliente que, generalmente, gasta alrededor de $50 por transacción. Deseas mantener a los clientes que están a valores atípicos porque suelen gastar mucho más que otros.

Define atributos

En la siguiente tabla, se describen los atributos que se calculan para entrenar el modelo:

Nombre del atributo. Tipo Descripción
monetary FLOAT La suma de los valores monetarios de todas las transacciones de un cliente determinado durante un período determinado.
frequency INTEGER La cantidad de transacciones que un cliente determinado realizó para un período determinado.
recency INTEGER El tiempo transcurrido entre la primera y la última transacción que realizó un cliente determinado durante un período determinado.
T INTEGER El tiempo que transcurre entre la primera transacción en el conjunto de datos y el final de la ventana de transacciones de entrada.
time_between FLOAT El tiempo promedio que transcurre entre las transacciones de un cliente determinado durante un período determinado.
avg_basket_value FLOAT El valor monetario promedio de la cesta de compra del cliente para un período determinado.
avg_basket_size FLOAT La cantidad promedio de artículos que tiene un cliente determinado en su cesta durante un período determinado.
has_returns STRING Si un cliente determinado devolvió artículos en, al menos, una transacción durante un período determinado.
avg_time_to_return FLOAT El tiempo que tarda un cliente en particular mostrar su primer elemento para una transacción.
num_returns INTEGER La cantidad de elementos que el cliente devolvió y que están asociados con transacciones que se encuentran en un período determinado.

Configura parámetros de procesamiento de atributos

Los siguientes parámetros definen los períodos que se deben usar para el cálculo de atributos:

  • WINDOW_STEP: Especifica la cantidad de días entre umbrales. Esto determina la frecuencia con la que procesas atributos y etiquetas.
  • WINDOW_STEP_INITIAL: Especifica la cantidad de días entre la primera fecha del pedido en tus datos de entrenamiento y el primer umbral.
  • WINDOW_LENGTH: Especifica la cantidad de días que se usan en las transacciones de entrada. El valor predeterminado es un valor de 0, que toma todas las transacciones antes del límite especificado.
  • LENGTH_FUTURE: Especifica la cantidad de días en el futuro para predecir el valor monetary que sirve como etiqueta del AA. En cada límite, BigQuery calcula el valor de la etiqueta para todos los pedidos que ocurren LENGTH_FUTURE después de la fecha límite.

Por ejemplo, supongamos que tienes un conjunto de datos con una fecha de transacción anterior al 1/1/2015 y los siguientes valores del parámetro:

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

Los períodos de tiempo para los primeros bucles del procedimiento de creación de atributos funcionarán de la siguiente manera:

Primer bucle

Parámetro Cómo se calcula Valor
Fecha de umbral La fecha de la primera transacción más el valor del WINDOW_STEP_INITIAL, así que 1/1/2015 + 90 días. 1/4/2015
Inicio de ventana WINDOW_LENGTH es 0, por lo que se usan todas las transacciones anteriores al umbral. La primera transacción se realiza el 1/1/2015. 1/1/2015
Ventana de la entrada de la transacción Desde la fecha de inicio de la ventana hasta la fecha límite, inclusive 1/1/2015 - 1/4/2015
Ventana de transacción de destino Desde la fecha límite (exclusivo) hasta la fecha límite y la cantidad de días especificada por LENGTH_FUTURE (1/4/2015 + 30 días). 2/4/2015 - 1/5/2015

Segundo bucle

Parámetro Cómo se calcula Valor
Fecha de umbral La fecha límite del bucle anterior más el valor WINDOW_STEP, así que 1/4/2015 + 30 días 1/5/2015
Inicio de ventana WINDOW_LENGTH es 0, por lo que se usan todas las transacciones anteriores al umbral. La primera transacción se realiza el 1/1/2015. 1/1/2015
Ventana de la entrada de la transacción Desde la fecha de inicio de la ventana hasta la fecha límite, inclusive 1/1/2015 - 1/5/2015
Ventana de transacción de destino Desde la fecha límite (exclusivo) hasta la fecha límite y la cantidad de días especificada por LENGTH_FUTURE (1/5/2015 + 30 días). 2/5/2015 - 31/5/2015

Si modificaras WINDOW_LENGTH para que tiene un valor de 15, los períodos de tiempo en ese caso funcionarían de la siguiente manera:

Primer bucle

Parámetro Cómo se calcula Valor
Fecha de umbral La fecha de la primera transacción más el valor del WINDOW_STEP_INITIAL, así que 1/1/2015 + 90 días. 1/4/2015
Inicio de ventana Fecha del límite: valor WINDOW_LENGTH, así que 4/1/2015 - 15 días. 17/3/2015
Ventana de la entrada de la transacción Desde la fecha de inicio de la ventana hasta la fecha límite, inclusive 17/3/2015 - 1/4/2015
Ventana de transacción de destino Desde la fecha límite (exclusivo) hasta la fecha límite y la cantidad de días especificada por LENGTH_FUTURE (1/4/2015 + 30 días). 2/4/2015 - 1/5/2015

Segundo bucle

Parámetro Cómo se calcula Valor
Fecha de umbral Fecha límite del bucle anterior + valor WINDOW_STEP, así que 1/4/2015 + 30 días 1/5/2015
Inicio de ventana Fecha del límite: valor WINDOW_LENGTH, así que 1/5/2015 - 15 días 16/4/2015
Ventana de la entrada de la transacción Desde la fecha de inicio de la ventana hasta la fecha límite, inclusive 16/4/2015 - 1/5/2015
Ventana de transacción de destino Desde la fecha límite (exclusivo) hasta la fecha límite y la cantidad de días especificada por LENGTH_FUTURE (1/5/2015 + 30 días). 2/5/2015 - 31/5/2015

Para configurar los parámetros a fin de determinar las ventanas de cómputo de características, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

En un caso de uso de producción, deberás modificar estos parámetros para obtener resultados que se adapten mejor a los datos con los que trabajas. Por ejemplo, si tus clientes compran varias veces a la semana, podrías calcular los atributos con ventanas semanales. O, si tienes muchos datos, puedes crear más ventanas mediante la disminución de sus tamaños y, posiblemente, reducir la cantidad de días entre las fechas límite. Experimentar con estos parámetros, además del ajuste de hiperparámetros puede mejorar potencialmente el rendimiento de tu modelo.

Crear funciones

  1. Para crear una tabla con atributos calculados a fin de entrenar el modelo, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    %%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. Para ver una muestra de los datos de un cliente en la tabla clv.features resultante, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

    Deberías ver resultados similares a los siguientes:

    Primeras 5 filas de datos de atributos.

Entrena el modelo

En este instructivo, se usa el AUTOML_REGRESSOR en BigQuery ML para crear, entrenar y, luego, implementar un modelo de regresión de AutoML.

En este instructivo, se usa la configuración predeterminada a fin de entrenar el modelo. en un caso de uso de producción, puedes probar técnicas de ingeniería de atributos adicionales y diferentes divisiones de datos de entrenamiento para mejorar el modelo.

Para crea y propagar el modelo clv_model, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

%%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`

Esto debería brindarte un buen modelo base para trabajar. Para adaptar el modelo a tus propios datos y casos de uso, puedes optimizarlo con el ajuste de hiperparámetros, la ingeniería de atributos y otras técnicas.

Predice el CLV

En el siguiente paso, se obtendrán predicciones del CLV del modelo para cada cliente y, luego, se escribirán estos datos en una tabla. Los registros de predicción contienen los campos descritos en la siguiente tabla:

Nombre del campo Tipo Descripción
customer_id STRING ID de cliente
monetary_so_far FLOAT Cantidad total de dinero que el cliente invirtió antes de la fecha de predicción.
monetary_predicted FLOAT Cantidad total de dinero prevista por el cliente, que es la suma de los valores de los campos monetary_so_far y monetary_future.
monetary_future FLOAT Cantidad futura de dinero prevista que el cliente gastará entre la fecha de predicción y el final del período de predicción.
  1. Para crear y propagar la tabla clv.predictions, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    %%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. Para ver una muestra de los datos en la tabla clv.features resultante, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

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

    Deberías ver resultados similares a los siguientes:

    Primeras 5 filas de datos de predicción.

Evalúa los datos de la predicción

Visualiza y genera estadísticas sobre los datos de predicción para comprender mejor la distribución de datos y ver si hay tendencias claras.

  1. Crea un marco de datos basado en la tabla clv.predictions:

    %%bigquery df_predictions --project $PROJECT_ID
    
    clv.predictions
    
  2. Para usar pandas.DataFrame.describe a fin de generar estadísticas descriptivas sobre los datos de predicción, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    df_predictions.describe()
    

    Deberías ver resultados similares a los siguientes:

    Estadísticas para los datos de predicción

  3. Para usar matplotlib.gridspec a fin de visualizar los datos de predicción, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    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')
    

    Deberías ver resultados similares a los siguientes:

    Visualización de la distribución de datos de predicción

    El análisis de distribución monetaria muestra los importes monetarios pequeños para el mes siguiente en comparación con el valor histórico general. Un motivo es que el modelo esté entrenado para predecir el valor del mes siguiente, como se especifica en el parámetro LENGTH_FUTURE. Puedes experimentar con cambiar ese valor a fin de entrenar y predecir para el próximo trimestre (que sería LENGTH_FUTURE = 90) y ver cómo cambia la distribución.

Crea un público similar

Usa los procedimientos de esta sección a fin de crear y exportar una lista de clientes con CLV alto y, luego, usar esa lista para crear un público similar en Google Ads.

Los ejemplos de código en las secciones que siguen Identifica los clientes principales por CLV solo se pueden ejecutar si tienes acceso a un entorno de Google Ads en funcionamiento. Dirígete a la página Requisitos para la integración de Google Ads a fin de que este código de ejemplo se pueda ejecutar con tu propio entorno de Google Ads.

Identifica a los clientes principales por CLV

Como primer paso para crear un público similar, debes identificar a tus clientes principales según su CLV previsto y, luego, asociar las direcciones de correo electrónico a ellos. Para ello, usa el ID de cliente a fin de unir la tabla de predicciones con una tabla de datos de clientes que contenga esta información.

En este instructivo, se usa el 20% de los clientes más importantes según el CLV. Puedes cambiar el porcentaje de clientes que se seleccionan para modificar el parámetro TOP_CLV_RATIO. La instrucción de SQL para seleccionar los clientes usa la función PERCENT_RANK a fin de identificar a los clientes cuyos gastos futuros los coloca al mismo nivel del valor TOP_CLV_RATIO o sobre él.

  1. Para establecer el parámetro TOP_CLV_RATIO, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    CLV_PARAMS = {
        'TOP_CLV_RATIO': 0.2
    }
    
  2. Para crear y propagar el marco de datos df_top_ltv, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    %%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. Para ver una muestra de los datos de df_top_ltv, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    df_top_ltv.head(5)
    

    Deberías ver resultados similares a los siguientes:

    Primeras 5 filas de los clientes principales según los datos del CLV

Crea el archivo de configuración de Google Ads

Crea el archivo YAML de configuración para el cliente de Google Ads.

  1. Reemplaza las variables de marcador de posición por los valores apropiados para tu entorno a fin de configurar las variables de archivo YAML que controlan el acceso a la API de Google Ads. Consulta Requisitos para la integración de Google Ads a fin de obtener información a fin de obtener los tokens necesarios y las credenciales de OAuth si aún no los tienes.

    Copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    DEVELOPER_TOKEN = "myDeveloperToken"
    OAUTH_2_CLIENT_ID = "myClientId"
    CLIENT_SECRET = "myClientSecret"
    REFRESH_TOKEN = "myRefreshToken"
    
  2. Para crear el contenido del archivo YAML, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo.

    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. Para propagar el archivo YAML, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo.

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

Crea una lista de remarketing de Google Ads

Usa los correos electrónicos de los principales clientes de CLV para crear una lista de remarketing de Google Ads.

  1. Crea una lista que contenga los correos electrónicos de los principales clientes de CLV mediante la copia del siguiente código en la siguiente celda vacía del notebook y, luego, ejecútala:

    ltv_emails = list(set(df_top_ltv['email']))
    
  2. Para crear la lista de remarketing, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútela:

    """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)
    

Agrega un público similar

Una vez que tengas la lista de remarketing, sigue estas instrucciones en la documentación de Google Ads para agregar Públicos similares a tu orientación.

Próximos pasos (opcionales)

Usa la información de las siguientes secciones para mejorar el rendimiento del modelo y automatizar el flujo de trabajo del AA.

Mejora el modelo

En este instructivo, se muestra un enfoque posible para crear un modelo básico con el fin de predecir el valor monetario futuro de tus clientes. Si decidiste adoptar aún más este enfoque, las siguientes son sugerencias de lugares para mejorar o experimentar:

  • Si tienes muchos valores atípicos en tus datos, realiza ingeniería de datos adicional o busca datos de entrenamiento adicionales.
  • Puedes probar diferentes enfoques para crear características mediante el ajuste de los límites del período, o cambiar la proporción de entrada a las transacciones de destino.
  • Cuando compares modelos, asegúrate de usar el mismo conjunto de datos de prueba para comparar de forma detallada el rendimiento de los modelos. Por ejemplo, en este instructivo se preparan los datos para predecir mejor los pedidos de los próximos 30 días. Si deseas que un modelo prediga el próximo trimestre, debes actualizar el parámetro LENGTH_FUTURE y volver a calcular los atributos.
  • El conjunto de datos de ejemplo usa una cantidad limitada de campos. Si tienes otras dimensiones, como categorías de productos, regiones geográficas o información demográfica en tus propios datos, intenta crear atributos adicionales para tu modelo.

Automatiza el flujo de trabajo del AA

En los pasos anteriores, aprendiste cómo usar BigQuery y BigQuery ML a fin de preparar datos para el aprendizaje automático, crear y entrenar un modelo, obtener predicciones y preparar datos para la integración de Google Ads.

En un caso de uso de producción, todas serían tareas recurrentes. Puedes ejecutar estos pasos de forma manual cada vez, pero recomendamos automatizar el proceso. Este instructivo tiene código complementario en GitHub que proporciona un conjunto de procedimientos almacenados de BigQuery a fin de automatizar estos pasos, y también una secuencia de comandos de shell, run.sh, que puedes usar para ejecutarlas.

Puedes usar los siguientes parámetros cuando llamas a la secuencia de comandos run.sh a fin de configurarla para que funcione en tu entorno:

Variable Descripción Predeterminada
PROJECT_ID ID del proyecto Obligatorio
DATASET_ID ID de conjunto de datos Obligatorio
TRAIN_MODEL_ID Nombre del modelo entrenado. Configúralo en *null* si no deseas entrenar un modelo. String según la hora.
USE_MODEL_ID Nombre del modelo que se usará para las predicciones. Debe incluir el conjunto de datos: [DATASET].[MODEL] String según la hora.
WINDOW_LENGTH Intervalo de tiempo en días para las transacciones de entrada. 0
WINDOW_STEP Tiempo en días entre dos ventanas. Equivalente al tiempo entre dos fechas límite. 30
WINDOW_STEP_INITIAL Hora inicial en días antes de configurar la primera fecha límite. 90
LENGTH_FUTURE Tiempo en días para hacer una predicción. 30
MAX_STDV_MONETARY Desviación estándar del valor monetario por cliente por encima del que la secuencia de comandos quita las transacciones. 500
MAX_STDV_QTY Desviación estándar del valor de cantidad por cliente por encima del que la secuencia de comandos quita las transacciones. 100
TOP_LTV_RATIO Porcentaje de los principales clientes que se extraerán. 0.2

Sigue estos pasos a fin de usar la secuencia de comandos run.sh para la automatización:

  1. Clona el repositorio de GitHub:

    git clone https://github.com/GoogleCloudPlatform/analytics-componentized-patterns.git
    
  2. Actualiza la secuencia de comandos run.sh a fin de establecer los valores de los parámetros para que coincidan con tu entorno.

  3. Si usas tus propios datos de transacción, actualiza 10_procedure_match.sql para especificar las columnas adecuadas de tu tabla de transacciones.

  4. Ajusta los permisos en la secuencia de comandos run.sh para que puedas ejecutarla:

    chmod +x run.sh
    
  5. Revisa la ayuda de la línea de comandos para obtener información para configurar los parámetros:

    ./run.sh --help
    
  6. Ejecuta la secuencia de comandos:

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

En un caso de uso de producción, puedes consultar con tus ingenieros de datos y el equipo de DevOps para ver si pueden integrar los procedimientos almacenados en sus herramientas con facilidad a fin de facilitar su uso.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto, pero borra solo esos recursos.

De cualquier manera, debes quitar esos recursos para que no se te cobre por ellos en el futuro. En las siguientes secciones, se describe cómo borrar estos recursos.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra los componentes

Si no deseas borrar el proyecto, usa las siguientes secciones para borrar los componentes facturables de este instructivo.

Borra las tablas y el conjunto de datos de BigQuery

  1. Abre la consola de BigQuery
  2. En la sección Recursos, expande el proyecto en el que estás completando este instructivo y selecciona el conjunto de datos CLV.
  3. Haz clic en Borrar conjunto de datos en el encabezado del panel de conjunto de datos.
  4. En la ventana de superposición que aparece, escribe clv y, luego, haz clic en Borrar.

Borra el notebook de AI Platform

  1. Abre la página AI Platform Notebooks.
  2. Selecciona la casilla de verificación para la instancia de notebook CLV.
  3. Haz clic en Borrar.
  4. En la ventana de superposición que aparece, haz clic en Borrar.

¿Qué sigue?