Crea un modelo de agrupamiento en clústeres de k-means para la segmentación de mercado mediante BigQuery ML

Aprende a segmentar los datos del público de Google Analytics 360 para fines de marketing mediante la creación de clústeres de k‑means con BigQuery ML.

Descripción general

Uno de los desafíos comunes de estadísticas de marketing con el que podrías encontrarte es determinar cuáles son los temas respecto al comportamiento de los consumidores, que luego puedes usar para desarrollar personas o perfiles de clientes. Estos perfiles pueden ayudarte a incorporar más conocimientos sobre los clientes a tus campañas de marketing.

Para crear con rapidez segmentos de clientes a partir de tus datos, puedes usar una técnica llamada agrupamiento en clústeres. Esta técnica te permite agrupar a los clientes con comportamientos similares para crear públicos diferentes a fin de usarlos en el marketing. Puedes personalizar tu comunicación con los clientes adaptando los anuncios y otras comunicaciones con ellos, en función de las preferencias y los comportamientos que indica el clúster al que pertenece cada cliente.

En este instructivo, aprenderás a crear clústeres de clientes con un modelo k-means en BigQuery ML. Debes entrenar el modelo con los datos de muestra del cliente que contienen información demográfica y de transacciones, y el modelo mostrará la información sobre los clústeres del cliente que identifique en esos datos. Luego, obtendrás predicciones del modelo que te permitirán asignar a cada cliente a su clúster adecuado según sus datos demográficos y su historial de transacciones. Después de asignar a cada cliente a un clúster, podrás enviar los datos actualizados de los clientes a Google Analytics 360 para usarlos en la activación de marketing.

En este instructivo, se explica cómo crear una instancia de notebook administrada por el usuario de Vertex AI para completar estos pasos y proporcionar orientación prescriptiva y procedimientos paso a paso. En cambio, si deseas comenzar con un notebook completado, puedes usar el notebook Cómo compilar modelos de agrupamiento de k-means para la segmentación de mercado mediante BigQuery ML en el servidor de notebook que elijas.

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:

  • Conceptos de aprendizaje automático
  • Python
  • SQL estándar

¿Cómo funcionan los algoritmos de agrupamiento en clústeres?

El agrupamiento en clústeres es un tipo de aprendizaje automático no supervisado. En este caso, ejecutarás un algoritmo de k-means para identificar cómo los datos se agrupan de manera lógica. El algoritmo evalúa los datos de entrenamiento para detectar similitudes y los agrupa en función de eso en lugar de depender de una etiqueta manual para agrupar los datos. Por ejemplo, supongamos que deseas agrupar a tus clientes por ingresos estimados y edad. Puedes usar el agrupamiento en clústeres para ayudarte a determinar cuántos clústeres existen en tus según estos atributos. Si bien el agrupamiento en clústeres puede parecer simple cuando se consideran solo uno o dos atributos de cliente, mientras más atributos deban considerarse, más difícil es hacerlo de forma manual.

Uno de los desafíos que presenta el uso del agrupamiento en clústeres es determinar si tienes la cantidad “adecuada” de clústeres. En este instructivo, se muestra cómo mejorar el modelo después de compilar una versión inicial a fin de que obtengas un modelo que cree una cantidad apropiada de clústeres para tu caso de uso.

Conjunto de datos

En este instructivo, se usa el conjunto de datos de muestra de Google Analytics, que se aloja a nivel público en BigQuery. Este conjunto de datos proporciona 12 meses (de agosto de 2016 a agosto de 2017) de datos ofuscados de Analytics 360 de Google Merchandising Store, una tienda de comercio electrónico real que vende productos de la marca Google.

Si tienes tus propios datos de Analytics 360, puedes usarlos en lugar del otro conjunto. En el instructivo, hay información sobre qué hacer en ese caso.

Objetivos

  • Procesar los datos del cliente en el formato correcto para crear un modelo de agrupamiento en clústeres de k-means
  • Crear, entrenar y, luego, implementar el modelo de k-means con BigQuery ML
  • Iterar en el modelo para desarrollar una versión que cree la cantidad óptima de clústeres
  • Analizar los clústeres que produjo el modelo para comprender qué te dicen sobre tus segmentos de clientes
  • Obtener predicciones del modelo implementado para asignar clientes a sus clústeres correspondientes.
  • Exportar datos de clientes actualizados desde BigQuery para que puedas usarlos en la activación de marketing en Analytics 360

Costos

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

  • AI Platform
  • BigQuery
  • BigQuery ML

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen 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 Notebooks and Compute Engine.

    Habilita las API

  5. 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

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

    Descubre cómo puedes habilitar la facturación

  7. Habilita las API de Notebooks and Compute Engine.

    Habilita las API

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta Cómo realizar una limpieza.

Crea un notebook

  1. En Google Cloud Console, ve a la página Notebooks.

    Ir a Notebooks

  2. En la pestaña Notebooks administrados por el usuario, haz clic en  Nuevo notebook .

  3. Elige Python 3.

  4. En Nombre de la instancia, escribe kmeans.

  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 las bibliotecas necesarias para este instructivo.

  1. Copia el siguiente código en la primera celda del notebook:

    # Install libraries.
    !pip install pandas-gbq
    !pip install google-cloud-bigquery
    !pip install google-cloud-bigquery-storage
    # Needed to setup flex slots for flat-rate pricing
    !pip install google-cloud-bigquery-reservation
    
    # Automatically 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 google.cloud import bigquery
import numpy as np
import pandas as pd
import pandas_gbq
import matplotlib.pyplot as plt

# used to display float format
pd.set_option('display.float_format', lambda x: '%.3f' % x)

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 estás usando para completar este instructivo.

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

Procese los datos

En esta sección, prepararás los datos que necesitas para entrenar el modelo de k-means. La preparación de datos incluye agregar datos de transacciones de clientes a partir de Analytics 360, generar datos demográficos de clientes de muestra y, luego, unir estos dos conjuntos para crear el conjunto de datos de entrenamiento.

En este instructivo, usarás los datos de muestra de Google Analytics, pero en un caso de uso de producción, debes usar tus propios datos de Analytics 360.

Cree un conjunto de datos de BigQuery

Crea un conjunto de datos de BigQuery que contenga los datos de los clientes y el modelo de k-means. Para ello, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

! bq mk myProject:kmeans

Datos agregados de transacciones

En esta sección, agregarás datos de transacciones de clientes del conjunto de datos de muestra de Analytics 360. Los datos agregados te brindan una idea más clara de la frecuencia con la que los clientes compran artículos, qué tipos de artículos compran y cuánto invierten.

En este instructivo, suponemos que una compra se produce cuando pagetype = "EVENT". En un caso de uso de producción, es posible que quieras identificar las compras de otra manera, según tu configuración de Analytics 360.

En este instructivo también se usa fullVisitorID como la clave para los datos del cliente. En un caso de uso de producción, debes reemplazar las instancias de fullVisitorID con clientId en estas consultas y en las posteriores. Esto se debe a que debes usar clientId como el campo de clave cuando se importen datos de públicos a Analytics 360. clientId suele ser una versión con hash de fullVisitorId, pero esta columna no se propaga en el conjunto de datos de muestra de Google Analytics. Para usar clientId en tus propios datos de Analytics 360, debes crear una dimensión personalizada y propagarla.

  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:

    ga360_only_view = 'GA360_View'
    shared_dataset_ref = client.dataset('kmeans')
    ga360_view_ref = shared_dataset_ref.table(ga360_only_view)
    ga360_view = bigquery.Table(ga360_view_ref)
    
    ga360_query = '''
    SELECT
      fullVisitorID,
      # This will be used to generate random data.
      ABS(farm_fingerprint(fullVisitorID)) AS Hashed_fullVisitorID,
      # You can aggregate this because an
      # operating system is tied to a fullVisitorID.
      MAX(device.operatingSystem) AS OS,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Apparel' THEN 1 ELSE 0 END) AS Apparel,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Office' THEN 1 ELSE 0 END) AS Office,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Electronics' THEN 1 ELSE 0 END) AS Electronics,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Limited Supply' THEN 1 ELSE 0 END) AS LimitedSupply,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Accessories' THEN 1 ELSE 0 END) AS Accessories,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Shop by Brand' THEN 1 ELSE 0 END) AS ShopByBrand,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Bags' THEN 1 ELSE 0 END) AS Bags,
      ROUND (SUM (productPrice/1000000),2) AS totalSpent_USD
      FROM
      `bigquery-public-data.google_analytics_sample.ga_sessions_*`,
      UNNEST(hits) AS hits,
      UNNEST(hits.product) AS hits_product
    WHERE
      _TABLE_SUFFIX BETWEEN '20160801'
      AND '20160831'
      AND geoNetwork.country = 'United States'
      AND type = 'EVENT'
    GROUP BY
      1,
      2
    '''
    
    ga360_view.view_query = ga360_query.format('myProject')
    ga360_view = client.create_table(ga360_view)
    
    
  2. Para ver una muestra de los datos agregados de transacciones de los clientes, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    # Show a sample of GA360 data
    
    ga360_query_df = f'''
    SELECT * FROM {ga360_view.full_table_id.replace(":", ".")}
    ORDER BY fullVisitorID
    LIMIT 5
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(ga360_query_df, job_config=job_config) #API Request
    df_ga360 = query_job.result()
    df_ga360 = df_ga360.to_dataframe()
    
    df_ga360
    

    Deberías ver resultados similares a los siguientes:

    Primeras 5 filas de datos agregados.

Genera datos demográficos

Usa el siguiente procedimiento para generar datos demográficos sintéticos de clientes.

En un caso de uso de producción, te recomendamos usar tus propios datos de un sistema de administración de relaciones con clientes (CRM). Debes omitir este paso y continar con el siguiente, que consiste en unir los datos de CRM con los datos agregados de transacciones de clientes.

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

    CRM_only_view = 'CRM_View'
    shared_dataset_ref = client.dataset('kmeans')
    CRM_view_ref = shared_dataset_ref.table(CRM_only_view)
    CRM_view = bigquery.Table(CRM_view_ref)
    
    # The query below works by hashing the fullVisitorID, which creates a
    # random distribution. It uses modulo to artificially split gender and
    # household income distribution.
    CRM_query = '''
    SELECT
      fullVisitorID,
    IF
      (MOD(Hashed_fullVisitorID,2) = 0,
        "M",
        "F") AS gender,
      # Generate household income
      CASE
        WHEN MOD(Hashed_fullVisitorID,10) = 0 THEN 55000
        WHEN MOD(Hashed_fullVisitorID,10) < 3 THEN 65000
        WHEN MOD(Hashed_fullVisitorID,10) < 7 THEN 75000
        WHEN MOD(Hashed_fullVisitorID,10) < 9 THEN 85000
        WHEN MOD(Hashed_fullVisitorID,10) = 9 THEN 95000
      ELSE
      Hashed_fullVisitorID
    END
      AS hhi
    FROM (
      SELECT
        fullVisitorID,
        ABS(farm_fingerprint(fullVisitorID)) AS Hashed_fullVisitorID,
      FROM
        `bigquery-public-data.google_analytics_sample.ga_sessions_*`,
        UNNEST(hits) AS hits,
        UNNEST(hits.product) AS hits_product
          WHERE
        _TABLE_SUFFIX BETWEEN '20160801'
        AND '20160831'
        AND geoNetwork.country = 'United States'
        AND type = 'EVENT'
      GROUP BY
        1,
        2)
    '''
    
    CRM_view.view_query = CRM_query.format('myProject')
    CRM_view = client.create_table(CRM_view)
    
  2. Para ver una muestra de los datos de cliente, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    # See an output of the synthetic CRM data
    
    CRM_query_df = f'''
    SELECT * FROM {CRM_view.full_table_id.replace(":", ".")}
    ORDER BY fullVisitorID
    LIMIT 5
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(CRM_query_df, job_config=job_config)
    df_CRM = query_job.result()
    df_CRM = df_CRM.to_dataframe()
    
    df_CRM
    

    Deberías ver resultados similares a los siguientes:

    Primeras 5 filas de datos generados de clientes.

Crea el conjunto de datos de entrenamiento

Usa el siguiente procedimiento para crear el conjunto de datos de entrenamiento mediante la unión de los datos agregados de transacciones de clientes y los datos demográficos generados de clientes.

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

    # Build a final view, which joins GA360 data with CRM data
    
    final_data_view = 'Final_View'
    shared_dataset_ref = client.dataset('kmeans')
    final_view_ref = shared_dataset_ref.table(final_data_view)
    final_view = bigquery.Table(final_view_ref)
    
    final_data_query = f'''
    SELECT
        g.*,
        c.* EXCEPT(fullVisitorId)
    FROM {ga360_view.full_table_id.replace(":", ".")} g
    JOIN {CRM_view.full_table_id.replace(":", ".")} c
    ON g.fullVisitorId = c.fullVisitorId
    '''
    
    final_view.view_query = final_data_query.format('myProject')
    final_view = client.create_table(final_view)
    
    print(f"Successfully created view at {final_view.full_table_id}")
    
  2. Para ver una muestra de los datos de , copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    # Show final data used before modeling
    
    sql_demo = f'''
    SELECT * FROM {final_view.full_table_id.replace(":", ".")}
    ORDER BY fullVisitorID
    LIMIT 5
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_demo, job_config=job_config)
    df_demo = query_job.result()
    df_demo = df_demo.to_dataframe()
    
    df_demo
    

    Deberías ver resultados similares a los siguientes:

    Las primeras 5 filas de datos asociados de clientes y de transacciones.

Crea, entrena y, luego, implementa un modelo inicial

En esta sección, crearás una función de Python que compilará el modelo de k-means. Crear una función en lugar de simplemente usar SQL te permite definir varios modelos para que BigQuery los compile en paralelo. Usarás esta función de nuevo en la sección Mejora el modelo para crear varias versiones del modelo con el fin de comparar los datos.

Ten en cuenta que no usarás fullVisitorId como entrada para el modelo, ya que no necesitas esos datos para crear un atributo para el agrupamiento en clústeres. En general, los datos únicos o poco comunes no son útiles para tal fin.

Por lo general, también necesitas normalizar atributos numéricos, pero puedes omitir ese paso aquí, ya que BigQuery ML se encarga de ello de forma automática.

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

    PROJECT_ID = "myProject"
    
    def makeModel (n_Clusters, Model_Name):
        sql =f'''
        CREATE OR REPLACE MODEL `{PROJECT_ID}.kmeans.{Model_Name}`
        OPTIONS(model_type='kmeans',
        kmeans_init_method = 'KMEANS++',
        num_clusters={n_Clusters}) AS
        SELECT * except(fullVisitorID, Hashed_fullVisitorID) FROM `{final_view.full_table_id.replace(":", ".")}`
        '''
        job_config = bigquery.QueryJobConfig()
        client.query(sql, job_config=job_config)
    
  2. Prueba la función mediante la creación del modelo test que segmenta los datos en tres clústeres. Ten en cuenta que el modelo tarda alrededor de 5 minutos en compilarse.

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

    model_test_name = "test"
    makeModel(3, model_test_name)
    
  3. Para confirmar que el modelo se creó, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    for model in client.list_models('kmeans'):
      print(model)
    

    Deberías ver resultados similares a los siguientes:

    Model(reference=ModelReference(project_id='myProject', dataset_id='kmeans', model_id='test'))
    
  4. Para establecer el parámetro test, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    model_id = "kmeans."+model_test_name
    client.delete_model(model_id)
    print(f"Deleted model '{model_id}'")
    

Mejora el modelo

En esta sección, se muestra cómo mejorar el modelo mediante su ajuste a fin de proporcionar la cantidad óptima de clústeres para tu caso de uso.

Determina la cantidad correcta de clústeres (representada por la “k” de “k-means”) depende de tu caso de uso. A veces, es fácil determinar cuántos clústeres necesitas. Por ejemplo, si procesas imágenes de dígitos individuales escritos a mano, necesitas 10 clústeres, uno para uno de los dígitos del 0 al 9. Para los casos de uso que son menos evidentes, puedes experimentar con varias versiones del modelo que usen diferentes cantidades de clústeres. Comparar las distintas versiones del modelo te permite ver cuál tiene el mejor rendimiento en términos de agrupamiento de datos y minimizar los errores en cada clúster.

Puedes determinar qué versión del modelo proporciona las mejores agrupaciones mediante el método del codo, que es una forma de graficar la pérdida según la cantidad de clústeres del modelo, junto con la puntuación de Davies–Bouldin del modelo. Esta puntuación indica qué tan diferentes son los datos de un clúster. Se define como la proporción entre la dispersión de los datos dentro de un clúster determinado y la dispersión de los propios clústeres. Un valor bajo implica un mejor agrupamiento en clústeres.

Crea varios modelos para compararlos

Generar varias versiones del modelo de k-means, desde una que cree tres clústeres hasta una que cree quince clústeres.

  1. Genera varias versiones del modelo de k-means. Ten en cuenta que los modelos tardan alrededor de 7 minutos en compilarse.

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

    low_k = 3
    high_k = 15
    model_prefix_name = 'kmeans_clusters_'
    
    lst = list(range (low_k, high_k+1)) #build list to iterate through k values
    
    for k in lst:
        model_name = model_prefix_name + str(k)
        makeModel(k, model_name)
    
  2. Para obtener una lista de los modelos generados, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    models = client.list_models('kmeans')
    print("Listing current models:")
    for model in models:
        full_model_id = f"{model.dataset_id}.{model.model_id}"
        print(full_model_id)
    

    Deberías ver resultados similares a los siguientes:

    Lista de las diferentes versiones del modelo.

Cómo comparar el rendimiento del modelo

Usa el siguiente procedimiento para comparar el rendimiento de los diferentes modelos mediante la revisión de la distancia cuadrada media, que identifica la pérdida del modelo, y la puntuación de Davies-Bouldin.

  1. Usa la instrucción de SQL ML.EVALUATE a fin de generar la distancia cuadrada media y la puntuación de Davies–Bouldin para cada modelo. Este proceso puede demorar aproximadamente un minuto en completarse.

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

    # This creates a dataframe with each model name, the Davies Bouldin Index, and Loss.
    
    df = pd.DataFrame(columns=['davies_bouldin_index', 'mean_squared_distance'])
    models = client.list_models('kmeans')
    for model in models:
        full_model_id = f"{model.dataset_id}.{model.model_id}"
        sql =f'''
            SELECT
                davies_bouldin_index,
                mean_squared_distance
            FROM ML.EVALUATE(MODEL `{full_model_id}`)
        '''
    
        job_config = bigquery.QueryJobConfig()
    
        # Start the query, passing in the extra configuration.
        query_job = client.query(sql, job_config=job_config)
        df_temp = query_job.to_dataframe()  # Wait for the job to complete.
        df_temp['model_name'] = model.model_id
        df =  pd.concat([df, df_temp], axis=0)
    
  2. Actualiza el marco de datos mediante la adición de una columna que identifique la cantidad de clústeres que usa el modelo y también clasifica los datos para los gráficos. Para ello, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    df['n_clusters'] = df['model_name'].str.split('_').map(lambda x: x[2])
    df['n_clusters'] = df['n_clusters'].apply(pd.to_numeric)
    df = df.sort_values(by='n_clusters', ascending=True)
    df
    

    Deberías ver resultados similares a los siguientes:

    Distancia cuadrada media y información de puntuación de Davies-Bouldin para cada modelo

  3. Para ver una muestra de los datos de , copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    df.plot.line(x='n_clusters', y=['davies_bouldin_index', 'mean_squared_distance'])
    

    Deberías ver resultados similares a los siguientes:

    Gráfico que representa la distancia cuadrada media y la puntuación de Davies-Bouldin, según la cantidad de clústeres de cada modelo.

    No existe un enfoque perfecto para determinar la cantidad óptima de clústeres para un caso de uso. Recomendamos adoptar el siguiente enfoque cuando tomes esta decisión:

    1. Aplica el método del codo y observa si te muestra un lugar claro donde la pérdida se iguala.
    2. Considera las puntuaciones de Davies-Bouldin de los modelos.
    3. Considera las reglas comerciales o los requisitos que podrían afectar tu decisión sobre la cantidad de clústeres con la que deseas trabajar.
    4. Elige el modelo que cumpla con los requisitos de tu empresa y que tenga la mejor combinación de baja pérdida y puntuación de Davies-Bouldin baja.

    En el gráfico anterior, la línea naranja representa la pérdida de cada modelo, representada por la distancia cuadrada media, que se ilustra en función de la cantidad de clústeres en el modelo. La tendencia de esta línea muestra que aumentar la cantidad de clústeres disminuye la pérdida, lo que es esperable. La línea también disminuye de forma constante, en lugar de llegar a un punto en el que la pérdida se iguale, y crea la figura de un codo. Esto indica que, en el caso de este conjunto de datos, el uso exclusivo del método del codo no es suficiente para determinar la cantidad óptima de clústeres.

    La línea azul representa la puntuación de Davies-Bouldin de cada modelo, que se grafica en función de la cantidad de clústeres del modelo. Dado que el método del codo no identificó claramente el modelo de mejor rendimiento, puedes identificarlo de forma alternativa; para ello, elige uno con una puntuación de Davies-Bouldin baja.

    El modelo con 11 clústeres tiene una pérdida bastante baja y la mejor puntuación Davies-Bouldin, por lo que si tus reglas empresariales no te dan un motivo para trabajar con menos clústeres, esta es tu mejor opción. Si tus reglas empresariales te dan una razón para trabajar con menos clústeres, el modelo con 4 clústeres tiene el segundo mejor puntaje de Davies-Bouldin. Para simplificar, en este instructivo se usa el modelo con 4 clústeres.

Analiza los clústeres de datos del modelo seleccionado

Desarrolla una comprensión sobre cómo se agruparon los datos en este modelo observando los centroides del modelo y, luego, analiza los datos en cada clúster para comprender cuántos usuarios y lo que indica el agrupamiento en clústeres sobre el comportamiento del cliente.

  1. Usa la instrucción de SQL ML.CENTROIDS para obtener información sobre los centroides del atributo gender de cada clúster. Para ello, copia el siguiente código en la siguiente celda vacía del notebook y, luego, ejecútalo:

    model_to_use = 'kmeans_clusters_4' # Edit this to use a different model
    final_model = 'kmeans.'+model_to_use
    
    pd.set_option('max_colwidth', 400)
    
    sql_get_attributes = f'''
    SELECT
      centroid_id,
      feature,
      categorical_value
    FROM
      ML.CENTROIDS(MODEL {final_model})
    WHERE
      feature IN ('gender')
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_get_attributes, job_config=job_config)
    df_attributes = query_job.result()
    df_attributes = df_attributes.to_dataframe()
    df_attributes
    

    Deberías ver resultados similares a los siguientes:

    Centros comerciales del atributo gemelo del modelo del kmeans.

  2. Calcula las estadísticas de resumen de los datos del clúster con la información de ML.PREDICT y ML.CENTROIDS copiando el siguiente código en la siguiente celda vacía del notebook y, luego, ejecutándolo:

    sql_get_numerical_attributes = f'''
    WITH T AS (
    SELECT
      centroid_id,
      ARRAY_AGG(STRUCT(feature AS name,
                       ROUND(numerical_value,1) AS value)
                       ORDER BY centroid_id)
                       AS cluster
    FROM ML.CENTROIDS(MODEL {final_model})
    GROUP BY centroid_id
    ),
    
    Users AS(
    SELECT
      centroid_id,
      COUNT(*) AS Total_Users
    FROM(
    SELECT
      * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT(MODEL {final_model},
        (
        SELECT
          *
        FROM
          {final_view.full_table_id.replace(":", ".")}
          )))
    GROUP BY centroid_id
    )
    
    SELECT
      centroid_id,
      Total_Users,
      (SELECT value from unnest(cluster) WHERE name = 'Apparel') AS Apparel,
      (SELECT value from unnest(cluster) WHERE name = 'Office') AS Office,
      (SELECT value from unnest(cluster) WHERE name = 'Electronics') AS Electronics,
      (SELECT value from unnest(cluster) WHERE name = 'LimitedSupply') AS LimitedSupply,
      (SELECT value from unnest(cluster) WHERE name = 'Accessories') AS Accessories,
      (SELECT value from unnest(cluster) WHERE name = 'Bags') AS Bags,
      (SELECT value from unnest(cluster) WHERE name = 'ShopByBrand') AS ShopByBrand,
      (SELECT value from unnest(cluster) WHERE name = 'totalSpent_USD') AS totalSpent_USD,
      (SELECT value from unnest(cluster) WHERE name = 'hhi') AS HouseholdIncome
    
    FROM T LEFT JOIN Users USING(centroid_id)
    ORDER BY centroid_id ASC
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_get_numerical_attributes, job_config=job_config)
    df_numerical_attributes = query_job.result()
    df_numerical_attributes = df_numerical_attributes.to_dataframe()
    df_numerical_attributes.head()
    

    Deberías ver resultados similares a los siguientes:

    Estadísticas de resumen de los datos del clúster.

Si se consideran tanto los datos de centroides como los del resumen de estadísticas, podrás determinar las siguientes características de los clústeres del modelo:

  • Clúster 1: Los clientes de este grupo compran mucho en la categoría ropa. Compran la mayoría de los elementos y tienen la segunda inversión más alta por elemento. No están muy motivados con la marca. El clúster se inclina ligeramente hacia el género femenino.
  • Clúster 2: Los clientes de este clúster compran en todas las categorías, pero compran más en ropa. Compran menos artículos que los clientes del clúster 1, pero invierten mucho más por artículo. Es muy probable que compren según la marca. Este clúster se inclina de forma significativa hacia el género femenino.
  • Clúster 3: Este clúster es un valor atípico y contiene solo una persona.
  • Clúster 4: Este es el clúster más poblado. En este clúster, los clientes realizan pocas compras y gastan menos en promedio. Por lo general, solo compran una vez y no son clientes leales a una marca. El sesgo de género es mínimo.

Obtén predicciones

Usa el modelo seleccionado para asignar a los usuarios a clústeres que puedas usar para la segmentación de marketing.

  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:

    sql_score = f'''
    SELECT * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT(MODEL {final_model},
        (
        SELECT
          *
        FROM
          {final_view.full_table_id.replace(":", ".")}
          LIMIT 10))
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_score, job_config=job_config)
    df_score = query_job.result()
    df_score = df_score.to_dataframe()
    
    df_score
    

    Deberías ver resultados similares a los siguientes:

    Primeras 10 filas de datos de entrenamiento procesados

Cómo exportar datos a Analytics 360

Después de tener la información del clúster para tus clientes a partir del modelo de k-means, puedes exportarla a Analytics 360 para usarla en campañas de marketing.

Para hacerlo, usa la consola de BigQuery a fin de ejecutar una consulta que muestre los datos que deseas exportar, como se muestra en el siguiente pseudocódigo de SQL:

CREATE OR REPLACE TABLE myDataset.myCustomerDataTable AS (
    SELECT * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT(MODEL myDataset.myModel,
        (
        SELECT
          *
        FROM
          myDataset.myTable)))

Guarda los resultados de la consulta como un archivo CSV y, luego, usa Importación de datos para importar los datos a Analytics 360. Ten en cuenta que los nombres de las columnas en los datos de recomendaciones exportados deben mapearse al esquema de importación de datos de Analytics 360. Por ejemplo, si el esquema de importación de datos es ga:clientId, ga:dimension1, ga:dimension2, los nombres de columna en tus datos deben ser ga:clientId, ga:dimension1, ga:dimension2. BigQuery no permite el uso de dos puntos en los nombres de las columnas, por lo que debes actualizar los nombres de las columnas en el archivo CSV exportado antes de importarlo.

Si lo deseas, puedes usar la implementación de referencia MoDeM (Model Deployment for Marketing) [MoDeM (Implementación de modelos para marketing)] para BigQuery ML models (modelos de BigQuery ML) a fin de facilitar la carga de datos en Analytics 360. Usa las instrucciones interactivas que aparecen en BQML Deployment Template notebook (notebook de plantillas de implementación de BQML) para comenzar.

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 la consola de Google Cloud, 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 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 kmeans.
  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 kmeans y, a continuación, haz clic en Borrar.

Borra la instancia de notebooks administrados por el usuario

  1. Abre la pestaña Notebooks administrados por el usuario
  2. Selecciona la casilla de verificación para la instancia de notebook kmeans.
  3. Haz clic en Borrar.
  4. En la ventana de superposición que aparece, haz clic en Borrar.

¿Qué sigue?