Segmentación de Clientes con Pyspark
En este artículo hablaré un poco de segmentación de cliente usando un método clásico RFM y la creación de una, usando Spark desde un set de datos de kaggle
¿Qué es la segmentación de RFM?
La segmentación de RFM permite a los especialistas en marketing enfocarse en grupos específicos de clientes con comunicaciones que son mucho más relevantes para su comportamiento particular y, por lo tanto, generan tasas de respuesta mucho más altas, además de una mayor lealtad y valor de vida del cliente . Al igual que otros métodos de segmentación, la segmentación RFM es una forma poderosa de identificar grupos de clientes para un tratamiento especial.
RFM significa recencia, frecuencia y dinero: más sobre cada uno de estos en breve.
Los especialistas en marketing suelen tener datos exhaustivos sobre sus clientes actuales, como historial de compras, historial de navegación, patrones de respuesta de campañas anteriores y datos demográficos, que pueden utilizarse para identificar grupos específicos de clientes que pueden abordarse con ofertas muy relevantes para cada uno.
Si bien existen innumerables formas de realizar la segmentación, el análisis de RFM es popular por tres razones:
- Utiliza escalas numéricas objetivas que producen una descripción concisa e informativa de alto nivel de los clientes.
- Es simple: los profesionales de marketing pueden usarlo de manera efectiva sin la necesidad de científicos de datos o software sofisticado.
- Es intuitivo: el resultado de este método de segmentación es fácil de entender e interpretar.
¿Qué son la actualidad, la frecuencia y el dinero?
- Recencia : ¿Cuánto tiempo ha transcurrido desde la última actividad o transacción del cliente con la marca? La actividad suele ser una compra, aunque a veces se usan variaciones, por ejemplo, la última visita a un sitio web o el uso de una aplicación móvil. En la mayoría de los casos, cuanto más recientemente un cliente ha inter-actuado o ha realizado transacciones con una marca, es más probable que el cliente responda a las comunicaciones de la marca.
- Frecuencia : ¿con qué frecuencia un cliente ha negociado o interactuado con la marca durante un período de tiempo particular? Claramente, los clientes con actividades frecuentes están más comprometidos, y probablemente más leales, que los clientes que rara vez lo hacen. Y los clientes que solo son únicos son una clase propia.
- Monetario : también conocido como “valor monetario”, este factor refleja cuánto ha gastado un cliente con la marca durante un período de tiempo determinado. Grandes derrochadores generalmente deben ser tratados de manera diferente que los clientes que gastan poco. Si se analiza el valor monetario dividido por frecuencia, se indica el monto promedio de la compra, un factor secundario importante a tener en cuenta al segmentar a los clientes.
¿Qué grupos encontramos?
- Mejores clientes
- Nuevos clientes de alto gasto
- Clientes leales activos de menor gasto
- Los mejores clientes batidos
¿Advertencia sobre RFM?
La segmentación de RFM es un método directo y poderoso para la segmentación de clientes.
Sin embargo, el hecho de que el modelo de RFM solo considere tres factores específicos (aunque importantes) significa que el método puede estar excluyendo otras variables que son igual o más importantes (por ejemplo, productos comprados, respuestas de campaña anteriores, detalles demográficos).
Además, el marketing de RFM es, por su propia naturaleza, un método histórico, analiza el comportamiento del cliente anterior que puede o no indicar con exactitud actividades, preferencias y respuestas futuras .
¿Mejores Técnicas?
Las técnicas de segmentación de clientes más avanzadas se basan en tecnologías de análisis predictivo que tienden a ser mucho más precisas para predecir el comportamiento futuro de los clientes.
Demostración con Spark jugando en kaggle
ruta del desafió
Lo puede ver aquí
importar librerias
from pyspark import SparkConf, SparkContext
from pyspark.sql import SparkSession
from pyspark.sql import Row
from pyspark.sql import functions as F
from pyspark.sql.types import *
import datetime
import pandas as pd
import numpy as npCreando una sesion en spark
spark = SparkSession.builder.appName(‘APP_RFM’).getOrCreate()Leyendo csv o desde una base de datos
df = spark.read.csv(“data.csv”, header=True)Validación de los esquemas
df = df.select(
df.InvoiceNo.cast(“String”),
df.StockCode.cast(“Double”),
df.Description.cast(“String”),
df.Quantity.cast(“Double”),
df.InvoiceDate.cast(“String”),
df.UnitPrice.cast(“Double”),
df.CustomerID.cast(“String”),
df.Country.cast(“String”)
)importar librerias
df2 = df.filter(F.col(“Country”) == “United Kingdom”)Remover orden que tengo un monto cero
df3 = df2.filter(F.col(“Quantity”) > 0)Remover no tiene un cliente asociado
df4 = df3.filter(F.col(“CustomerID”).isNotNull())Filtro mayores o iguales a fecha de inicio
df5 = df4.filter(F.col(“InvoiceDate”) >= “2010–12–09”)Máxima Fecha
max_date = df5.select(F.from_unixtime(F.unix_timestamp(F.max(‘InvoiceDate’), ‘MM/dd/yyy’))).rdd.map(lambda x:(str(x[0]))).collect()
max_date = max_date[0][:10]
print(max_date)Fecha según kaggle a tomar por el rango
now = datetime.date(2011,12,9)Monto total y convertimos la variable InvoiceDate en fecha
df6 = df5.withColumn(‘date’, F.to_date(F.from_unixtime(F.unix_timestamp(‘InvoiceDate’, ‘MM/dd/yyyy’)))).sort(“InvoiceNo”, ascending=False)
df6 = df6.withColumn(“amount_total”, F.col(“Quantity”) * F.col(“UnitPrice”))Calculamos la recencia
recency_df = df6.groupBy(‘CustomerID’).agg(F.max(“date”).alias(“LastPurshaceDate”))
recency_df = recency_df.withColumn(“date”, F.lit(now))
recency_df = recency_df.withColumn(“recency”, F.datediff(F.to_date(recency_df[“date”]),F.to_date(recency_df[“LastPurshaceDate”]))).sort(“recency”)
recency_df = recency_df.select(“CustomerID”, “Recency”)Eliminamos duplicados y Calculamos la frecuencia
frequency_df = df6.dropDuplicates([“InvoiceNo”, “CustomerID”])
frequency_df = frequency_df.groupBy(‘CustomerID’).agg(F.count(“*”).alias(“Frequency”))Calculamos el monto
monetary_df = df6.dropDuplicates([“InvoiceNo”, “CustomerID”])
monetary_df = monetary_df.groupBy(‘CustomerID’).agg(F.sum(“amount_total”).alias(“Monetary”))Union de dataframe
rfm_table = recency_df.join(frequency_df, “CustomerID”).sort(“CustomerID”)
rfm_table = rfm_table.join(monetary_df, “CustomerID”).sort(“CustomerID”)
Metodo de Quantiles en Spark
quantile = rfm_table.approxQuantile([“Recency”, “Frequency”, “Monetary”], [0.25, 0.5, 0.75], 0)
Porcentaje quartil recencia
rfm_table2 = rfm_table.withColumn(‘r_quantile’, F.when((F.col(“Recency”) >= 0) & (F.col(“Recency”) <= quantile[0][0]), “4”)\
.when((F.col(“Recency”) > quantile[0][0]) & (F.col(“Recency”) <= quantile[0][1]), “3”)\
.when((F.col(“Recency”) > quantile[0][1]) & (F.col(“Recency”) <= quantile[0][2]), “2”).otherwise(“1”))Porcentaje quartil frecuencia
rfm_table2 = rfm_table2.withColumn(‘f_quantile’, F.when((F.col(“Frequency”) >= 0) & (F.col(“Frequency”) <= quantile[1][0]), “1”)\
.when((F.col(“Frequency”) > quantile[1][0]) & (F.col(“Frequency”) <= quantile[1][1]), “2”)\
.when((F.col(“Frequency”) > quantile[1][1]) & (F.col(“Frequency”) <= quantile[1][2]), “3”).otherwise(“4”))Porcentaje quartil monto
rfm_table3 = rfm_table2.withColumn(‘m_quantile’, F.when((F.col(“Monetary”) >= 0) & (F.col(“Monetary”) <= quantile[2][0]), “1”)\
.when((F.col(“Monetary”) > quantile[2][0]) & (F.col(“Monetary”) <= quantile[2][1]), “2”)\
.when((F.col(“Monetary”) > quantile[2][1]) & (F.col(“Monetary”) <= quantile[2][2]), “3”).otherwise(“4”))Funcionn UDF para RFMscore
def rfm_score(r,f,m):
value = “{0}{1}{2}”.format(r,f,m)
return value
return_rfm_score_udf = F.udf(rfm_score)rfm_table3.withColumn(“RFMScore”, return_rfm_score_udf(F.col(“r_quantile”),F.col(“f_quantile”),F.col(“m_quantile”)))
Dataset terminado
rfm_table4.sort(“RFMScore”, ascending=False).toPandas()
Otro método, se pudo usar Kmeans y probar algoritmos supervisados
en vez que hacer quantiles con kmeans podemos buscar grupos asociados pero resultaría casi lo mismo , pero igual ya queda a gusto de cada persona como desea presentar la informacion , este ejemplo fácil les puede ayudar a segmentar aunque no es tanto una buena forma para nuevo clientes, pero ayuda en cierta manera.
Libro para estudio
Espero le hayas gustado esta publicación sobre segmentación de clientes con Spark ya comenzare con unas aplicaciones usando Tensorflow.
linkedin:
