En esta nota vamos a repasar el instructivo de Google para implementar el modelo de customer segmentation en BigQuery ML, pero introduciendo los conceptos básicos de machine learning (aprendizaje automático) necesarios para entender cómo opera el mismo.

Las técnicas de aprendizaje automático llegaron al mundo del marketing y la analítica digital hace ya mucho tiempo. Lo novedoso es el formato en el que Google nos presenta sus tres nuevos modelos de BigQuery ML para customer segmentationcustomer lifetime value prediction y conversion prediction. BigQuery ML es la propuesta de Google para acercar modelos de machine learning al lugar donde muchas empresas almacenan sus datos (de Google Analytics 360, CRM y demás), y en donde en muchos casos no están siendo explotados con fines descriptivos, predictivos o de personalización de la experiencia del usuario.

¿Qué tienen de  novedoso? Se trata de modelos prefabricados que cualquier usuario con conocimiento básico de SQL puede implementar y obtener un output – por lo menos – interesante.

¿Prefabricados? es una forma en que me gusta llamarlos porque se trata de modelos en los que viene predefinido de antemano tanto el algoritmo de aprendizaje automático que se utiliza, como así también las medidas de performancecon las cuales se evalúa al mismo, y  sin mucha posibilidad de customización.

¿Qué necesitás para poder implementar el modelo de Customer Segmentation?

1) Leer este artículo  -8 min de lectura- 😉
2) Tener un conocimiento básico de SQL

¿Qué es clusterizar?

Clusterizar es la tarea de agrupar en clusters o grupos aquellas instancias u observaciones con características similares, persiguiendo el objetivo de que las observaciones agrupadas en cada cluster sean -lo más posible- similares entre sí y diferentes a las de otros clusters.

Cuando tenemos un gran volumen de variables explicativas, no sabemos bien cuáles de ellas (ni de qué manera) son las que agrupan nuestros datos, cuáles tienen un poder discriminante o descriptivo mayor. Es simplemente información que no tenemos de antemano y por ende necesitamos la ayuda de un algoritmo de aprendizaje automático para poder encontrar patrones o estructuras que se encuentran latentes en los datos, es decir, que existen pero no se manifiestan o exteriorizan a priori.

 ¿Y esto para qué me sirve?

En el contexto del marketing digital y de analytics, clusterizar puede ser muy útil para la segmentación de usuarios o clientes (customer segmentation), con la finalidad de:

  • Comprender mejor el comportamiento de los usuarios en un sitio web o una app: ¿cómo se agrupan los usuarios según su comportamiento- páginas vistas, tiempo en página, cantidad de sesiones, transacciones, etc.-? Consideremos por ejemplo el caso de un Publisher que busca segmentar sus usuarios en “Casual Readers”, “Loyal Readers”, “Brand Lovers” y “Suscribers”, como punto de partida para elaborar una campaña que tenga el objetivo de migrar a los usuarios de las primeras categoría a las siguientes, siendo “Suscribers” ($$$) la meta final.
  • Crear audiencias que optimicen las campañas de marketing o remarketing: personalizar estrategias de marketing para usuarios de distintos clusters.  Por ejemplo, un Ecommerce que busca crear una audiencia de remarketing de “usuarios que llegaron al paso X del checkout, de la zona geográfica Y, y forman parte del cluster de interés Z”. O buscar que nuestras campañas adquieran nuevos usuarios con características similares a los individuos de mi cluster Z.

Dijimos que era necesario un algoritmo de aprendizaje automático para ayudarnos en esta tarea. Aquí es donde el modelo de customer segmentation de BigQuery ML echa mano al algoritmo k-means. Así que mejor empecemos por ahí.

El algoritmo k-means

K-means es un algoritmo de aprendizaje no supervisado que agrupa al conjunto de observaciones en ´k´ particionesdonde cada observación pertenece al grupo cuyo valor medio es más cercano. La agrupación se realiza minimizando la suma de distancias entre cada objeto y el centroide de su grupo o cluster.

Las instrucciones del algoritmo se pueden resumir así:

  1. Inicializa con los datos originales (puntos verdes)
  2. Asigna aleatoriamente k centroides (cruces de colores)
  3. Itera “n” veces hasta terminar:
  • asignación de clusters: asigna cada dato al centroide más cercano.
  • movida de centroides: a la distancia media de los puntos asignados al mismo.

Proyección en 2 dimensiones.

Ejemplo de las iteraciones de k-means con k=2.

Como se desprende de las instrucciones recién enumeradas y aplicadas a un  ´k=2´ como el del ejemplo, el algoritmo inicializa con dos centroides ubicados aleatoriamente. Luego, asigna cada observación al centroide más cercanocalculando algún tipo de distancia (euclídea o Manhattan, por ejemplo). Luego, los centroides se mueven hacia la distancia media de todas las observaciones que fueron asignadas a él, y el proceso se repite hasta que los centroides no se mueven más.

Pros y contras: Si bien k-means funciona muy bien cuando tenemos datos particionados y claramente diferenciados entre sí (como en el gráfico del ejemplo), ante conjuntos de datos donde esa partición no existe y los grupos no están bien definidos, sería conveniente recurrir a otro algoritmo de clusterización, cosa que el modelo de BigQuery ML lamentablemente no permite.

Por otro lado, al realizar el cálculo de distancias medias en sus iteraciones, el algoritmo se vuelve sensible a la presencia de outliers o ruido. Por lo cual es importante que en caso de contar con datos de este tipo, se realice un tratamiento de los mismos en la etapa previa a la implementación del modelo.

Customer segmentation en 6 pasos

Ahora sí, repasemos el instructivo de Google. Para mostrar el procedimiento del modelado vamos a utilizar los datos de libre acceso provistos en su repositorio git. Los mismos corresponden a una empresa de tipo “B2B office supplier”, pero esto no representa grandes diferencias respecto a los datos de un Ecommerce convencional o un portal de autogestión.

Los atributos o features con los cuales se entrena al modelo se resumen en la siguiente tabla:

Como se ve, se utilizan tanto datos de GA360 como del CRM de la empresa. A su vez y para enriquecer el modelo, se utilizan datos como el lifetime value de los usuarios que son una predicción obtenida anteriormente mediante otro modelo de BigQuery ML. Para lograr obtener estas 6 features en un mismo dataset de entrenamiento necesitamos realizar primero un trabajo de preprocesamiento a partir de los tres archivos ´.csv´ del repositorio git, los cuales importamos a BigQuery en forma de tabla.

Preprocesamiento

1- Realizamos una agregación sobre las métricas de GA360 “timeOnScreen” y “UniqueScreenViews” de GA360.

SELECT
User_ID,
SUM(timeOnScreen) AS timeOnScreen,
SUM(UniqueScreenViews) AS UniqueScreenViews
FROM
`bqmltest1234.BQML_Demo.GA360`
GROUP BY
User_ID

Tener en cuenta que en BigQuery siempre debemos estar trabajando en el marco de un proyecto, en el cual se crea un dataset o varios. En este caso el Project-ID o nombre del proyecto es “bqmltest1234”. Por otro lado, “BQML_Demo” es el nombre del dataset al cual fueron importados en formato de tabla los tres archivos ´.csv´ del repositorio git. Finalmente, “GA360” es el nombre de la tabla con los datos de Google Analytics 360 dentro del dataset. Por ende la sentencia FROM tiene la forma: FROM `yourprojectid.yourdataset.yourtable` .

Guardamos el resultado de la consulta en una nueva tabla llamada Aggregated_GA360.

: es el símbolo asignado a las tablas dentro del dataset.

2- Creamos nuestro dataset para entrenar el modelo uniendo varias tablas (join).

SELECT
`bqmltest1234.BQML_Demo.Users`.User_ID,
`bqmltest1234.BQML_Demo.Accounts`.Account_Number,
`bqmltest1234.BQML_Demo.Accounts`.Annual_Revenue,
`bqmltest1234.BQML_Demo.Aggregated_GA360`.timeOnScreen,
`bqmltest1234.BQML_Demo.Aggregated_GA360`.UniqueScreenViews,
`bqmltest1234.BQML_Demo.Users`.Loyalty_Program,
`bqmltest1234.BQML_Demo.Users`.Lifetime_Value,
`bqmltest1234.BQML_Demo.Users`.Age
FROM
`bqmltest1234.BQML_Demo.Aggregated_GA360`,
`bqmltest1234.BQML_Demo.Users`,
`bqmltest1234.BQML_Demo.Accounts`
WHERE
`bqmltest1234.BQML_Demo.Aggregated_GA360`.User_ID = `bqmltest1234.BQML_Demo.Users`.User_ID
AND 

`bqmltest1234.BQML_Demo.Accounts`.Account_Number = `bqmltest1234.BQML_Demo.Users`.Account_ID
ORDER BY
`bqmltest1234.BQML_Demo.Users`.User_ID ASC

Las cláusulas FROM tienen la misma estructura explicada anteriormente. “Users” y “Accounts” son los nombres con los que se definió anteriormente los otros dos archivos ´.csv´ del repositorio git. “Aggregated_GA360” es la tabla creada en el punto anterior. Volvemos a guardar la consulta en una nueva tabla llamada data, nuestro dataset de entrenamiento, que ya posee los atributos que necesitamos.

Entrenamiento del modelo

3- La siguiente query crea un modelo, le asigna un nombre (“my_model”) y lo entrena con el dataset de entrenamiento data:

CREATE MODEL
  `bqmltest1234.BQML_Demo.my_model`
OPTIONS
  (model_type='kmeans',
    num_clusters=9,
    distance_type='euclidean') AS
SELECT
  Annual_Revenue,
  timeOnScreen,
  UniqueScreenViews,
  Loyalty_Program,
  Lifetime_Value,
  Age
FROM
  `bqmltest1234.BQML_Demo.data`

Al correr esta query se guarda automáticamente dentro del dataset el modelo generado, en este caso con el nombre “my_model”. No es necesario guardarlo luego a correr la query.

:es el símbolo asignado a los modelos dentro del dataset.

En esta query también es donde se eligen los parámetros del algoritmo k-meansnum_clusters es el número de clústeres (en este caso k=9) y distance_type el tipo de distancia elegida para calcular las distancias al centroide (en este caso la distancia euclídea). Más adelante veremos cómo determinar el número de clusters. Antes necesitamos explicar cómo evaluar el modelo.

Evaluación del modelo

4- Para conocer qué tan buenos son los clusters obtenidos, evaluamos el modelo con dos medidas de performance distintas: Mean squared distances y Davies-Bouldin Index:

SELECT
  *
FROM
  ML.EVALUATE(MODEL `bqmltest1234.BQML_Demo.my_model`,
    TABLE `bqmltest1234.BQML_Demo.data`)

El output de esta query es el valor de las dos medidas de performance de “my_model”. Las medidas que utiliza BigQuery ML para evaluar tampoco pueden modificarse.

Mean-squared-distance es la media de todas las distancias cuadradas entre los puntos y sus respectivos centroides. Es lafunción costo que el algoritmo k-means busca reducir.

Davies-Bouldin Index, por su parte, es una medida que se obtiene de calcular el cociente entre la dispersión intra-cluster y la distancia entre clusters, es decir el nivel de dispersión al interior de cada cluster sobre la distancia entre los distintos clusters. Por ende, cuanto menor es su valor mejores son los clusters.

Selección del número de clusters

5- Para determinar el número de clusters adecuado, podemos correr la siguiente query que compara entre sí modelos creados anteriormente con distinto k:

SELECT
  '3' AS Size,
  *
FROM
  ML.EVALUATE(MODEL `bqmltest1234.BQML_Demo.my_model_2`)
UNION ALL
SELECT
  '9' AS Size,
  *
FROM
  ML.EVALUATE(MODEL `bqmltest1234.BQML_Demo.my_model`)
  UNION ALL
SELECT
  '6' AS Size,
  *
FROM
  ML.EVALUATE(MODEL `bqmltest1234.BQML_Demo.my_model_3`)
  UNION ALL
SELECT
  '12' AS Size,
  *
FROM
  ML.EVALUATE(MODEL `bqmltest1234.BQML_Demo.my_model_4`)

Los distintos modelos (my_model_2, 3 y 4) deben ser creados anteriormente. El output de la query arroja las medidas de performance para cada uno de los modelos con distinta cantidad de clusters. Si clickeamos en “Explore With Data Studio”muy sencillamente podemos crear el gráfico de abajo, conocido en aprendizaje automático como “Elbow method”, utilizado para tener una percepción del número de clusters adecuado. El gráfico tiene en el eje X la cantidad de clusters (k) en orden creciente y en Y la función costo (en este caso mean squared distance). Allí donde se empieza a sedimentar la función de costo, es decir donde ante el incremento de la cantidad de clusters la caída de la función de costo empieza a ser menos pronunciada, encontramos el k que estamos buscando.

Predicción de cluster y visualización en Data Studio

6- Con la siguiente query vamos a asignar a cada User-ID un cluster correspondiente (CENTROID_ID):

SELECT
  Data.*,
  Accounts.Total_Opportunity_Amount,
  Accounts.Country_Code,
  Accounts.Industry,
  Clusters.CENTROID_ID
FROM
  `bqmltest1234.BQML_Demo.Accounts` AS Accounts,
  `bqmltest1234.BQML_Demo.data` AS Data,
  ML.PREDICT(MODEL `bqmltest1234.BQML_Demo.my_model`,
    TABLE `bqmltest1234.BQML_Demo.data`) AS Clusters
WHERE
  Accounts.Account_Number = Data.Account_Number
  AND Clusters.User_ID = Data.User_ID
ORDER BY
  Data.User_ID

Nuevamente, como en el punto anterior, si linkeamos con Data Studio vamos a poder visualizar fácilmente -en 2D y eligiendo las variables que queramos- los clusters como en el gráfico de abajo (podés ver el dashboard aquí)

El output final del modelo asigna para cada user-ID un cluster determinado (del 1 al 9 en nuestro ejemplo). Esta información puede importarse a GA360 como una dimensión personalizada. Las audiencias ahora pueden incluir también a usuarios que forman parte de determinado cluster de interés. Finalmente, desde GA360 podemos conectar estas audiencias a Google Ads o DV360, como audiencias de remarketing o buscando adquirir nuevos usuarios similares a los identificados en algún cluster de interés.

Conclusión

Los nuevos modelos de BigQuery ML tienen como virtud la simpleza de su implementación. Por dos motivos:

  • No es necesario exportar la data: Muchas empresas tienen alojada en BigQuery su data histórica de GA360, Firebase, Ads, CRM, etc. Con BigQuery ML no es necesario exportar esa data -muchas veces muy pesada- hacia otro entorno en el cual luego será procesada.
  • Sólo SQL: No es necesario conocimiento en Python, R u otros lenguajes de programación, ni descargar paquetes o frameworks específicos para ciencia de datos.

Claro que esto tiene un costo: se trata de modelos armados o prefabricados, sin mucha posibilidad de customización y por ende inflexibles ante probables especificidades en los datos con los que estemos trabajando o propias del problema que estemos abordando. Claro que, Google ya tomó nota de esto y permite alternativas de customización en entornos de desarrollo como Colab, con código Python y los paquetes más utilizados para ciencia de datos. Todo en el marco de C4M (Cloud Four Marketing).

Resumiendo, los modelos de BigQuery ML muchas veces funcionan bien y son una solución simple y rápida, mientras que muchas otras veces deben ser mejorados o perfeccionados. Sea como sea, nunca está mal probar primero con la opción simple.

Santiago Gutierrez
Team Leader Analytics Consultant