Segmentazione RFM: Trovare i Clienti che Contano con Recency, Frequency e Monetary
Perché partire da tre colonne
Ogni volta che si parla di "conoscere i clienti" si finisce per costruire modelli complicati. Ma spesso le informazioni più utili sono già nei dati di transazione, e bastano tre dimensioni per ottenere qualcosa di concreto: quanto di recente un cliente ha comprato (Recency), quanto spesso compra (Frequency) e quanto spende in totale (Monetary). Da qui l'acronimo RFM.
Non è una tecnica nuova, anzi. Il motivo per cui sopravvive a mode e framework è che ha tre qualità rare:
- È economica: si calcola da una tabella di ordini, senza dati esterni.
- È spiegabile: un segmento si descrive in una frase, e chiunque lo capisce.
- È azionabile: i gruppi che emergono suggeriscono azioni diverse.
In questo articolo la costruiamo passo passo, dal dato grezzo al segmento, con SQL e un tocco di Python. I numeri che compaiono sono esempi illustrativi, non risultati di un caso reale.
Le tre dimensioni, spiegate bene
Recency
La Recency misura quanto tempo è passato dall'ultimo acquisto. Di solito si esprime in giorni: più è bassa, meglio è. Un cliente che ha comprato la settimana scorsa è probabilisticamente più propenso a ricomprare di uno che non si fa vivo da un anno.
Attenzione a una scelta che sembra banale ma cambia i risultati: la recency si misura rispetto a una data di riferimento. Che sia la data di oggi, l'ultima transazione registrata o la fine di un trimestre, quella scelta va fissata una volta e documentata. Se il calcolo gira ogni notte e prende sempre "adesso", i punteggi si muovono da soli anche quando i clienti non fanno nulla.
Frequency
La Frequency è il numero di acquisti in una finestra di tempo definita. Qui c'è una decisione importante: la finestra. Se prendi tutto lo storico, un cliente fedele da dieci anni avrà sempre un punteggio alto, anche se negli ultimi mesi è sparito. Se prendi solo l'ultimo mese, tagli fuori chi compra una volta a stagione. Una finestra mobile di 12 mesi è un compromesso comune nel retail, ma non è una regola sacra.
Monetary
Il Monetary è quanto il cliente ha speso nello stesso periodo. Può essere la somma degli importi, ma anche il valore medio per ordine: sono due letture diverse. Un cliente con dieci ordini da venti euro non è la stessa cosa di uno con due ordini da cento, eppure il totale può coincidere.
Una nota tecnica: la distribuzione della spesa è quasi sempre asimmetrica a destra, con tanti clienti piccoli e pochi grandi. Questo conta quando si passa al clustering, come vedremo.
Da dove arrivano i numeri
RFM si calcola a partire dalle transazioni. Uno schema minimo può essere questo:
create table ordini (
order_id bigint primary key,
customer_id bigint not null,
order_date date not null,
amount numeric(12,2) not null, -- valore netto, al netto dei resi
status text not null -- 'completed', 'refunded', ...
);
Due dettagli che fanno la differenza tra un'analisi seria e una che illude:
- Escludi i resi e gli ordini annullati, oppure gestiscili. Un cliente che compra e restituisce tutto non è un buon cliente.
- Decidi come trattare gli account aziendali, i regali e gli ordini duplicati. Se non li distingui, sporcano i segmenti.
Calcolare i punteggi con SQL
L'idea è semplice: aggreghi per cliente, poi trasformi ogni metrica in un punteggio da 1 a 5 con i quintili. In PostgreSQL basta la window function ntile.
with per_cliente as (
select
customer_id,
max(order_date) as ultimo_ordine,
count(*) as n_ordini,
sum(amount) as totale_speso
from ordini
where status = 'completed'
and order_date >= current_date - interval '365 days'
group by customer_id
),
con_punteggi as (
select
customer_id,
ultimo_ordine,
n_ordini,
totale_speso,
-- più recente = punteggio più alto
ntile(5) over (order by ultimo_ordine desc) as r_score,
ntile(5) over (order by n_ordini asc) as f_score,
ntile(5) over (order by totale_speso asc) as m_score
from per_cliente
)
select
customer_id,
r_score, f_score, m_score,
(r_score + f_score + m_score) as rfm_totale
from con_punteggi
order by rfm_totale desc;
Qualche accortezza sull'uso di ntile:
- I quintili non sono valori assoluti. Il punteggio 5 significa "tra il 20% dei migliori di questa base clienti", non "ha speso molto" in senso assoluto. Cambia la platea e cambia il significato.
- Attenzione ai pareggi. Con molti clienti che hanno la stessa spesa,
ntilespezza in modo arbitrario. Per certi casi conviene definire soglie fisse (per esempio: Recency < 30 giorni, 30–90, 90–180, ...) invece dei quantili. - I clienti nuovi hanno spesso una sola transazione: Frequency = 1 per tutti. Non è un difetto del metodo, è un'informazione.
Dai punteggi ai segmenti
Con tre punteggi in mano puoi leggere ogni cliente come una terna, per esempio (5, 5, 5) o (1, 2, 1). Da qui nascono i segmenti classici, una convenzione utile più che una verità matematica:
| Segmento | Profilo tipico | Lettura |
|---|---|---|
| Champions | R alto, F alto, M alto | Comprano spesso, di recente e spendono. Da coccolare. |
| Loyal | F alto, M medio-alto | Fedeli ma non recentissimi. Da riattivare. |
| Potenziali fedeli | R alto, F basso | Appena arrivati e attivi. Da coltivare. |
| A rischio | R basso, F e M alti | Un tempo ottimi, ora silenti. Priorità di recupero. |
| Occasionali | Tutto nella media | Il grosso della base. Difficili da muovere. |
| Ibernati | R, F, M bassi | Probabilmente persi. Costano più di quanto rendono. |
Questi nomi non sono obbligatori, ma la logica sì: Recency bassa su un cliente che era di valore è il segnale più allarmante, mentre Recency alta su un cliente nuovo è normale.
Non solo regole: anche clustering
Le soglie a quintili funzionano, ma sono arbitrarie. Un'alternativa è lasciare che i gruppi emergano dai dati con un clustering, tipicamente k-means su Recency, Frequency e Monetary (spesso log-trasformati).
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
# df ha colonne: recency_giorni, n_ordini, totale_speso
df = df.copy()
# la spesa è asimmetrica: la compressione log aiuta
X = pd.DataFrame({
"recency": np.log1p(df["recency_giorni"]),
"frequency": np.log1p(df["n_ordini"]),
"monetary": np.log1p(df["totale_speso"]),
})
X_scaled = StandardScaler().fit_transform(X)
km = KMeans(n_clusters=4, n_init=10, random_state=42)
df["cluster"] = km.fit_predict(X_scaled)
# profilo medio di ogni cluster, per capire chi c'è dentro
print(df.groupby("cluster")[["recency_giorni", "n_ordini", "totale_speso"]].mean())
Il clustering ha vantaggi e svantaggi speculari alle regole:
- Pro: i confini si adattano alla forma reale dei dati, senza soglie inventate.
- Contro: k-means devi essere scelto (il numero di cluster), non è stabile se i dati cambiano molto, e — soprattutto — i gruppi non hanno un'etichetta automatica. Sei tu a doverli interpretare.
In pratica molti usano i segmenti RFM come base e il clustering come controllo, per vedere se i gruppi che emergono assomigliano a quelli attesi.
Gli errori e i limiti
RFM è potente ma anche facile da fraintendere. I punti su cui inciampare sono sempre gli stessi.
Non è causalità
Un segmento descrive chi ha comprato, non perché. Dire "i Champions spendono di più, quindi diamo loro uno sconto" è un salto logico. La domanda vera — "dare uno sconto aumenta la spesa?" — la risponde solo un test controllato, non un segmento.
Non è una previsione
RFM fotografa il passato. Un cliente può essere nel migliore dei segmenti e sparire il mese dopo. Va trattato come un'euristica di priorità, non come un oracolo.
Le soglie cambiano tutto
Quintili o soglie fisse? Ultimi 6 o 12 mesi? Con resi o senza? Ognuna di queste scelte produce segmenti diversi. La cosa importante è documentare le scelte e non cambiarle a metà analisi senza motivo.
Il ciclo si chiude presto
Un piccolo negozio con pochi clienti abituali può vedere gli stessi nomi in tutti i segmenti. Con basse frequenze di acquisto, RFM dice poco: meglio guardare altro, per esempio la spesa media per ordine o la categoria di prodotto.
Distorce ciò che non misura
RFM ignora la marginalità. Un cliente che spende molto su prodotti a basso margine può valere meno di uno che spende la metà su prodotti redditizi. Se la marginalità è disponibile, va aggiunta come quarta dimensione, accettando che il modello diventa meno immediato.
Conclusione
La segmentazione RFM è uno strumento onesto: poche righe di SQL, tre metriche e un po' di buon senso per leggere i gruppi. Vale la pena usarla ogni volta che c'è una tabella di transazioni e la domanda è "da chi comincio?".
I punti chiave da portarsi a casa:
- RFM = Recency, Frequency, Monetary, tre dimensioni comportamentali già presenti nei dati di ordine.
- Le decisioni contano più della tecnica: finestra temporale, gestione dei resi, data di riferimento, quintili o soglie.
- I punteggi sono relativi alla base clienti, non valori assoluti: describono un rango, non un merito.
- I segmenti sono etichette interpretative, non verità statistiche. Vanno lette con il contesto del business.
- Non è causalità e non è previsione: serve a dare priorità, non a spiegare o anticipare da solo.
- Il clustering è un'alternativa, utile come controllo, ma richiede di scegliere quanti gruppi e di interpretarli.
Se domani vuoi qualcosa di più, i passi naturali sono due: aggiungere la marginalità e collegare i segmenti a un test controllato, così da misurare se l'azione che intraprendi su un segmento produce davvero l'effetto sperato.