Análisis RFM | Valor de vida útil de Cutomer mediante análisis RFM

Contenidos

Introducción

El ochenta por ciento de nuestro negocio proviene del 20% de nuestros clientes.

Cuesta 10 veces menos vender a un cliente existente que encontrar un nuevo cliente

T

98834capture-8983678

En nuestro índice de acciones, NIFTY 50 define cómo nuestro mercado de valores se está desempeñando de manera similar, en los negocios, es importante comprender quiénes son sus principales clientes que brindan flujos de ingresos consistentes y crecientes para su negocio.

Una de las metodologías simples y efectivas que se utilizan generalmente para calcular el valor del cliente durante un período de tiempo es RFM, que es,

Recency (R): qué tan recientemente un cliente ha realizado una compra
Frecuencia (F): la frecuencia con la que un cliente realiza una compra
Valor monetario (M): valor en dólares de las compras

Profundizaremos un poco más en el análisis de RFM en la siguiente sección:

Tomemos un pequeño ejemplo en el que un banco desea identificar clientes clave para retención / desarrollo / adquisición.

Entonces, en el escenario anterior, necesitamos calificar a cada cliente que tuvo transacciones recientes con el banco en tres métricas importantes mencionadas anteriormente R, F y M. Luego, cree una metodología de calificación para segmentar la base de clientes y postularse para diferentes programas de marketing.

Proceso de análisis RFM

Calculemos la puntuación de RFM para 5 clientes de muestra,

Paso 1: Derivar R, F & M de las transacciones del banco del último año.

Preferiblemente, RFM se realiza para datos recientes y se actualizará trimestralmente / semestralmente según el negocio

7527712-1610308

Encontrar R, F y M es bastante simple. Digamos que un cliente depositó 10 K de dinero el 1 de mayo y depositó otros 5 K el 10 de junio y si está haciendo un análisis de RFM el 1 de julio. Ahora para este cliente, la antigüedad será de 1 mes porque la última transacción fue en junio y la frecuencia será 2 porque realizó dos depósitos en mayo y junio y M será de 15 K

Paso 2: Obtenga la puntuación de cada cliente en función de cada parámetro según el rango dentro del parámetro

Para Recency, cuanto más pequeño, mejor, debido al cliente, estamos en su mente y para Frequency & Monitory los valores más grandes son mejores

5314323-6636622

Tomemos la tabla anterior como ejemplo, cuando se compara con todos los clientes, la antigüedad es mejor para el cliente 3, ya que está clasificado como el número 1, mientras que para la frecuencia está en la 4ª posición y, en términos del valor, en la 2ª posición.

Paso 3: Estandarizar la puntuación de cada cliente en función de cada parámetro (0-100)

24346123-9468920

Estandarizar = valor actual / Max (Valor) * 100

Paso 4: Derivar puntuación ponderada a través de cada parámetro para cada cliente

Puntaje consolidado = 0.15 * R + 0.28 * F + 0.57 * M

Las ponderaciones se pueden aplicar por igual o podemos proporcionar ponderaciones específicas para cada parámetro según el conocimiento del dominio o las aportaciones comerciales. Aquí, en el caso anterior, le estamos dando más importancia a la Frecuencia y al Monitoreo.

20825234-7012388

Simplemente aplicamos esos pesos a cada cliente.

Por ejemplo,

Valor del cliente 4 = 0,15 * 40 + 0,28 * 60 + 0,57 * 60 = 57

Luego, segregamos la puntuación en tres segmentos,

  • 0 – 50 – Cliente de bajo valor
  • 50 – 75 – Cliente de valor medio
  • 76-100 – Cliente de alto valor

Ahora, según los puntajes anteriores, una empresa puede aplicar la estrategia de diferenciación como retención / desarrollo / adquisición de diferentes segmentos de clientes

Además, la mayoría de nosotros podemos perfilar estos segmentos con características adicionales como datos demográficos, patrón de gasto y varios productos, etc. entiéndelos un poco más profundo.

Ahora intentemos implementar este análisis RFM en Python.

Análisis RMF en Python

Este es un estudio de caso, en el que estamos utilizando un conjunto de datos de la cadena minorista europea.

Los datos de muestra son los siguientes:

74730sampledata-2170489

Para nuestro análisis de RFM, las características clave importantes que usaremos son InvoicDate, CustomerID y para las ventas, usamos Cantidad y Precio unitario

# Import Packages
import numpy as np
import pandas as pd
import time, warnings
import datetime as dt
warnings.filterwarnings("ignore")
# Get the Data
# Read the data
df=pd.read_csv("retail_data.csv")
df.head()
# RFM Analysis
**RFM** (Recency, Frequency, Monetary) analysis first we need to create three features R , F & M from the data 
lets create those features
## Recency
# To calculate recency, we need to find out  **when was the customer's most recent purchase.**.
# Create a new column called date which contains the date of invoice only
df['date'] = pd.DatetimeIndex(df['InvoiceDate']).date
# Group by customers and check last date of purchase
recency_df = df.groupby(by='CustomerID', as_index=False)['date'].max()
recency_df.columns = ['CustomerID','LastPurshaceDate']
# Calculate recent date to find recency wrt to this date
recent_date=recency_df.LastPurshaceDate.max()
print(recent_date)
# Calculate recency
recency_df['Recency'] = recency_df['LastPurshaceDate'].apply(lambda x: (recent_date - x).days)
recency_df.head()
120072-3756079

Ahora de la misma forma calcularemos tanto la frecuencia como los valores monetarios.

# ## Frequency
# To calculate Frequency we need to check **How often a customer makes a purchase**.
# Drop duplicates
df1= df
df1.drop_duplicates(subset=['InvoiceNo', 'CustomerID'], keep="first", inplace=True)
# Calculate the frequency of purchases
frequency_df = df1.groupby(by=['CustomerID'], as_index=False)['InvoiceNo'].count()
frequency_df.columns = ['CustomerID','Frequency']
frequency_df.head()
# ## Monetary
# To calculate Monetary value  **How much money did the customer spent during the timeframe?**
# Create column total cost
df['TotalCost'] = df['Quantity'] * df['UnitPrice']
monetary_df = df.groupby(by='CustomerID',as_index=False).agg({'TotalCost': 'sum'})
monetary_df.columns = ['CustomerID','Monetary']
monetary_df.head()
# ## Create RFM Table
# Merge recency dataframe with frequency dataframe
temp_df = recency_df.merge(frequency_df,on='CustomerID')
temp_df.head()
# Merge with monetary dataframe to get a table with the 3 columns
rfm_df = temp_df.merge(monetary_df,on='CustomerID')
# Use CustomerID as index
rfm_df.set_index('CustomerID',inplace=True)
# Check the head
rfm_df.head()
980453-6627241
# Rank each metric R , F & M
rfm_df['R_rank'] = rfm_df['Recency'].rank( ascending=False)
rfm_df['F_rank'] = rfm_df['Frequency'].rank(ascending=True)
rfm_df['M_rank'] = rfm_df['Monetary'].rank(ascending=True)
rfm_df.head()
# normalize each rank with Max rank
rfm_df['R_rank_norm']=(rfm_df['R_rank']/rfm_df['R_rank'].max())*100
rfm_df['F_rank_norm']=(rfm_df['F_rank']/rfm_df['F_rank'].max())*100
rfm_df['M_rank_norm']=(rfm_df['F_rank']/rfm_df['M_rank'].max())*100
rfm_df.head()
# Now apply our equation and create final score **Consolidated Score = 0.15*R_rank_norm + 0.28*F_rank_norm + 0.57M_rank_norm**
rfm_df['RFM_Score']=0.15*rfm_df['R_rank_norm']+0.28*rfm_df['F_rank_norm']+0.57*rfm_df['M_rank_norm']
rfm_df=rfm_df.round(0)
rfm_df.head()
856894-3465923
# ## Customer segments with RFM Model
# # Segment customers based on RFM score
# 0 - 50 - Low valued customer
# 50 - 75 - Medium valued customer
# 76 - 100 - High valued customer
rfm_df["Customer_segment"]=np.where(rfm_df['RFM_Score'] > 75 ,"High Value Customer",(np.where(rfm_df['RFM_Score'] < 50 , "Low value Customer" ,"Medium Value Customer")))
rfm_df.head()
861505-1670907

Ahora que conocemos nuestros segmentos de clientes, podemos elegir cómo orientarnos o tratar con cada segmento.

Por ejemplo:

Cliente de alto valor: Ellos son sus clientes leales, así que bríndeles un apoyo constante a través del servicio de atención al cliente.

Cliente de valor medio: Envíeles correos electrónicos personalizados con ofertas y anímelos a comprar más

Cliente de bajo valor: Estos clientes están a punto de abandonar o entrar en una etapa inactiva, aplique estrategias de reactivación para ellos.

En Python y R tenemos varios paquetes que admiten el análisis RFM y también hay varias formas de derivar una puntuación RFM.

Espero que les guste este artículo. Feliz aprendizaje 🙂

Los medios que se muestran en este artículo no son propiedad de DataPeaker y se utilizan a discreción del autor.

Suscribite a nuestro Newsletter

No te enviaremos correo SPAM. Lo odiamos tanto como tú.