Automatizzare la Segmentazione dei Clienti con l'Analisi RFM Utilizzando Python

Un metodo efficace per ottenere una segmentazione dettagliata dei clienti è l’analisi RFM (Recency, Frequency, Monetary). Automatizzare questo processo utilizzando Python non solo migliora l’efficienza operativa, ma assicura anche coerenza e precisione nella gestione dei dati. In questo articolo, esploreremo come automatizzare l’intero processo di segmentazione RFM e integrare i risultati con piattaforme di automazione del marketing come Brevo.

Tabella dei Contenuti

Esportazione ed Elaborazione dei Dati

Il primo passo del processo consiste nell’esportare i dati dei clienti dal sistema di gestione dei contenuti (CMS) e-commerce, come Prestashop. Utilizzando l’API del CMS, estraiamo i dati rilevanti dei clienti, come l’ID cliente, la data dell’ultimo acquisto, la frequenza degli acquisti e la spesa totale. Questi dati vengono poi elaborati e organizzati in un DataFrame di Pandas, che fornisce una base strutturata per l’analisi successiva.

Query estrazione da Prestashop:

SELECT 
    c.email AS user_id,
    SUM(o.total_paid_real) AS total_spent,
    COUNT(o.id_order) AS purchase_count,
    DATE_FORMAT(MIN(o.date_add), '%Y%m%d') AS first_purchase_date,
    DATE_FORMAT(MAX(o.date_add), '%Y%m%d') AS last_purchase_date,
    DATEDIFF(MAX(o.date_add), MIN(o.date_add)) + 1 AS customer_lifetime_days,
    DATEDIFF(CURRENT_DATE(), MIN(o.date_add)) AS days_since_first_purchase,
    SUM(o.total_paid_real) / (DATEDIFF(MAX(o.date_add), MIN(o.date_add)) + 1) AS cltv
FROM 
    ps_customer AS c
JOIN 
    ps_orders AS o ON c.id_customer = o.id_customer
WHERE 
    o.valid = 1
GROUP BY 
    c.email

E’ possibile estrarre i dati anche da GA4 tramite BigQuery utilizzando questa query. Per una maggiore precisione consiglio di estrarre i dati direttamente da Prestashop.

WITH customer_purchases AS (
  SELECT
    user_pseudo_id AS user_id,
    ROUND(SUM((SELECT value.double_value FROM UNNEST(event_params) WHERE key = 'value')), 2) AS total_spent,
    COUNT(*) AS purchase_count,
    MIN(event_date) AS first_purchase_date,
    MAX(event_date) AS last_purchase_date
  FROM
   `table.events_*`
  WHERE
    event_name = 'purchase'
    AND _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL 12 MONTH)) AND FORMAT_DATE('%Y%m%d', CURRENT_DATE())
  GROUP BY
    user_id
),

customer_lifetime AS (
  SELECT
    user_id,
    total_spent,
    purchase_count,
    first_purchase_date,  
    last_purchase_date,   
    DATE_DIFF(PARSE_DATE('%Y%m%d', last_purchase_date), PARSE_DATE('%Y%m%d', first_purchase_date), DAY) + 1 AS customer_lifetime_days,
    DATE_DIFF(CURRENT_DATE(), PARSE_DATE('%Y%m%d', first_purchase_date), DAY) AS days_since_first_purchase
  FROM
    customer_purchases
)

SELECT
  user_id,
  total_spent,
  purchase_count,
  first_purchase_date,
  last_purchase_date,   -- Aggiunto nella selezione finale
  customer_lifetime_days,
  days_since_first_purchase,
  ROUND(total_spent / customer_lifetime_days, 2) AS cltv
FROM
  customer_lifetime
ORDER BY
  cltv DESC;

Clustering con K-Means++

Una volta che i dati sono stati preparati, applichiamo l’algoritmo di clustering K-Means++. Questo algoritmo ci permette di segmentare i clienti in gruppi omogenei basati sui valori di Recency, Frequency e Monetary. Utilizziamo il metodo Elbow per determinare il numero ottimale di cluster, garantendo che la segmentazione sia significativa e utile.

# Pulisci i dati NaN e sostituisci con la media
imputer = SimpleImputer(strategy='mean')
df[['total_spent', 'purchase_count', 'cltv']] = imputer.fit_transform(df[['total_spent', 'purchase_count', 'cltv']])
df = df.dropna()

# Pulizia e Preparazione dei Dati
df['last_purchase_date'] = pd.to_datetime(df['last_purchase_date'])
df['Recency'] = (df['last_purchase_date'].max() - df['last_purchase_date']).dt.days
df.drop(['last_purchase_date'], axis=1, inplace=True)  # Rimuovi la colonna originale delle date

# Standardizzazione delle metriche RFM per KMeans
scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(df[['Recency', 'purchase_count', 'total_spent']])

# Clustering con KMeans
k = 5
# kmeans = KMeans(n_clusters=k, init='random', random_state=42)  # k-means classico 
kmeans = KMeans(n_clusters=k, init='k-means++', random_state=42)  # k-means++
df['Cluster'] = kmeans.fit_predict(rfm_scaled)

# Calcola i centri dei cluster e li trasforma indietro nella scala originale
cluster_centers = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=['Recency', 'Frequency', 'Monetary'])

# Calcola la dimensione di ciascun cluster
cluster_sizes = df['Cluster'].value_counts().sort_index()

# Calcola i valori minimo e massimo per le metriche, per una migliore visualizzazione
vmin_val = cluster_centers.min().min()  # il valore minimo tra tutte le metriche
vmax_val = cluster_centers.max().max()  # il valore massimo tra tutte le metriche
# Pulisci i dati NaN e sostituisci con la media
imputer = SimpleImputer(strategy='mean')
df[['total_spent', 'purchase_count', 'cltv']] = imputer.fit_transform(df[['total_spent', 'purchase_count', 'cltv']])
df = df.dropna()

# Pulizia e Preparazione dei Dati
df['last_purchase_date'] = pd.to_datetime(df['last_purchase_date'])
df['Recency'] = (df['last_purchase_date'].max() - df['last_purchase_date']).dt.days
df.drop(['last_purchase_date'], axis=1, inplace=True)  # Rimuovi la colonna originale delle date

# Standardizzazione delle metriche RFM per KMeans
scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(df[['Recency', 'purchase_count', 'total_spent']])

# Clustering con KMeans
k = 5
# kmeans = KMeans(n_clusters=k, init='random', random_state=42)  # k-means classico 
kmeans = KMeans(n_clusters=k, init='k-means++', random_state=42)  # k-means++
df['Cluster'] = kmeans.fit_predict(rfm_scaled)

# Calcola i centri dei cluster e li trasforma indietro nella scala originale
cluster_centers = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=['Recency', 'Frequency', 'Monetary'])

# Calcola la dimensione di ciascun cluster
cluster_sizes = df['Cluster'].value_counts().sort_index()

# Calcola i valori minimo e massimo per le metriche, per una migliore visualizzazione
vmin_val = cluster_centers.min().min()  # il valore minimo tra tutte le metriche
vmax_val = cluster_centers.max().max()  # il valore massimo tra tutte le metriche

Per visualizzare e analizzare la distribuzione dei valori R, F e M all’interno di ciascun cluster, creiamo mappe termiche e box plot. Questi strumenti di visualizzazione ci aiutano a comprendere meglio le caratteristiche distintive di ogni segmento di clienti.

Creazione di File Excel

Dopo aver identificato i cluster, generiamo file Excel per ciascun gruppo di clienti. Ogni file contiene l’elenco dei clienti che appartengono a un cluster specifico, facilitando l’organizzazione e l’analisi dei dati. Questi file Excel sono essenziali per il passaggio successivo, in cui i dati dei clienti vengono caricati su una piattaforma di automazione del marketing (come Brevo).

Caricamento tramite API su Brevo

l caricamento dei dati sui clienti segmentati viene effettuato tramite l’API della piattaforma di automazione del marketing. Questo passaggio assicura che i segmenti di clientela siano aggiornati e pronti per essere utilizzati nelle campagne di marketing automatizzate. Il caricamento tramite API permette di mantenere i dati sincronizzati in modo continuo, senza la necessità di interventi manuali.

Scenari di Automazione del Marketing

L’ultimo passo del processo consiste nella creazione di scenari di automazione del marketing associati a ciascun cluster. Utilizzando la piattaforma di automazione del marketing, configuriamo scenari specifici per inviare comunicazioni mirate e personalizzate ai clienti in base al cluster di appartenenza. Questo approccio migliora l’efficacia delle campagne di marketing, aumentando l’engagement e la soddisfazione del cliente.

Importanza della Persistenza dei Parametri del Cluster

Per garantire che la segmentazione rimanga coerente nel tempo, è fondamentale mantenere la persistenza dei parametri del cluster. I nomi dei cluster e i loro centri devono essere archiviati in un file per assicurare che ogni esecuzione successiva dello script utilizzi gli stessi parametri. In questo modo, evitiamo disallineamenti che potrebbero compromettere l’efficacia delle campagne di marketing automatizzate. Gli aggiornamenti delle liste sulla piattaforma di marketing sono incrementali, attivando automaticamente gli scenari di automazione per ogni nuovo ingresso nella lista.

Cosa ne pensi di questo processo di automazione?

Giuseppe Cristofaro

Data Scientist
Sono un Data Scientist con esperienza nell’applicazione di tecniche avanzate di Machine Learning per l’analisi di complessi set di dati nel campo del marketing digitale. Specializzato nell’uso di Python, sviluppo modelli predittivi e di analisi dei dati che permettono di identificare e risolvere criticità nei progetti.

Data Genius

Automatizzare la Segmentazione dei Clienti con l’Analisi RFM Utilizzando Python