1. **Tier 1: Fondamenti del Customer Journey e Cohorting Temporale**
a) Comprensione del Customer Journey in Italia:
Il percorso del cliente italiano si articola in fasi ben distinte: consapevolezza, considerazione, acquisto, post-acquisto e fidelizzazione. La fase post-acquisto rappresenta il momento critico per il recupero e la conversione residua, dove il timing dei trigger comunicativi influenza direttamente il tasso di retention e il Lifetime Value (LTV). A differenza di altri mercati, in Italia la sensibilità temporale è accentuata da forti ritmi stagionali (es. festività, Black Friday, Natale) e da una cultura commerciale fortemente legata alla relazione personale, che rende essenziale una segmentazione temporale precisa.

2. **Tier 2: Metodologia del Cohorting Temporale Avanzato**
a) Definizione dei Micro-Cohort Temporali:
Abbiamo abbandonato il cohorting statico basato solo su date di acquisto per adottare un approccio dinamico: i micro-cohort sono segmenti temporali di 7, 14 e 30 giorni, definiti come intervalli di osservazione con finestre di intervento ottimizzate. Ad esempio, un cohort “Giorni 1-7” permette di monitorare l’immediata reazione post-acquisto, mentre “Giorni 8-14” è critico per il primo tentativo di upselling o relazionamento.
b) Metodo A vs Metodo B:
Il metodo A applica una segmentazione puramente cronologica, mentre il metodo B integra variabili comportamentali (es. numero di touchpoint, valore medio ordine, canale di acquisizione) con pesatura temporale. Ad esempio, un evento di engagement 3 giorni post-acquisto in un cohort A ha peso maggiore che lo stesso evento in un cohort B, poiché corrisponde a una finestra critica di brand recall.
c) Calcolo Dinamico dei Tempi di Intervento:
Utilizziamo una funzione di decay temporale esponenziale per il scoring:
$$ Score = e^{-\lambda \cdot (T – T_0)} \cdot W(t) $$
dove $T$ è il tempo passato dall’evento, $T_0$ il tempo critico (es. 3 giorni), $W(t)$ è una funzione peso che raggiunge il picco a $t=3$ e decade fino a 0 a 30 giorni, con peso maggiore per i primi 7 giorni.
d) Integrazione multicanale:
I dati di touchpoint (email, SMS, app, social) vengono ordinati cronologicamente e aggregati per cohort, con attenzione alla sequenza e al gap temporale tra eventi. Strumenti come SQL con window functions o Python con Pandas permettono di ricostruire il percorso temporale preciso per ogni cliente.
e) Strumenti software: Python con librerie come `causalml` per cohort analysis, `pandas` per manipolazione temporale, e `matplotlib`/`seaborn` per visualizzare curve di engagement e decay score.
*Esempio pratico:*

import pandas as pd
import numpy as np

# Dati di esempio: cohort per giorni post-acquisto, eventi timestamp
df = pd.DataFrame({
‘customer_id’: [‘C001′,’C002′,’C003’],
‘batch_day’: [1,2,3], # giorni post-acquisto
‘event_type’: [‘email_open’,’sms_click’,’website_visit’],
‘timestamp_utc’: pd.to_datetime(
[‘2024-06-01 10:00:00’, ‘2024-06-05 11:20:00’, ‘2024-06-10 09:30:00’]
),
‘engagement_score’: [0.8, 0.5, 0.9]
})

# Converti in CET (UTC+2)
df[‘timestamp_cet’] = df[‘timestamp_utc’].dt.tz_convert(‘CET’)

# Calcola tempo dall’evento critico (3° giorno)
df[‘days_since_event_3’] = (df[‘timestamp_cet’] – df.groupby(‘customer_id’)[‘timestamp_cet’].transform(lambda x: x[2]))
df[‘days_since_event_3’] = df[‘days_since_event_3’].fillna(30) # per cohort 1-7

# Vettorizzazione eventi giornalieri
event_matrix = df.groupby([‘customer_id’, pd.Grouper(key=’timestamp_cet’, freq=’7D’)])[‘event_type’].count().unstack(fill_value=0)
event_matrix.columns = [‘email_open’, ‘sms_click’, ‘website_visit’]
df = df.merge(event_matrix, on=[‘customer_id’, ‘timestamp_cet’], how=’left’)

# Funzione di decay peso per early engagement
def decay_score(days, base=1.0, decay_rate=0.15):
return base * np.exp(-decay_rate * days) if days <= 30 else 0.1
df[‘decay_score’] = df.apply(lambda r: decay_score(r[‘days_since_event_3’]) if pd.notna(r[‘days_since_event_3’]) else 0, axis=1)

*Fase 1: Pre-trattamento dei dati temporali è cruciale—rimuovere outlier temporali con IQR: valori > Q3 + 1.5*IQR vengono corretti o esclusi solo se non ripetuti.*

3. **Tier 3: Implementazione Tecnica e Ottimizzazione Granulare**
a) Fase 1: Pulizia, Normalizzazione e Time-Stamping
Applicare il time-stamping UTC→CET con gestione daylight saving automatica tramite `pytz` o `zoneinfo` (Python 3.9+):

from zoneinfo import ZoneInfo
df[‘timestamp_cet’] = df[‘timestamp_utc’].dt.tz_localize(‘UTC’).dt.tz_convert(ZoneInfo(‘CET’))

Identificare duplicati tramite evento e cliente:

df_dup = df.duplicated(subset=[‘customer_id’, ‘batch_day’, ‘timestamp_utc’], keep=’first’)
df = df[~df_dup]

Compensare lacune con interpolazione lineare, ad esempio per engagement score:

df[‘engagement_score_interp’] = df.groupby(‘customer_id’)[‘engagement_score’].apply(lambda x: x.interpolate(method=’linear’))

Creare variabili derivati:
– `TimeSinceLastInteraction`: differenza temporale tra eventi consecutivi
– `PeakEngagementWindow`: finestra di 7 giorni attorno al 3° giorno post-acquisto
– `Retention_7d`: proporzione di clienti ancora attivi dopo 7 giorni

b) Fase 2: Creazione dei Micro-Cohort con K-Means Temporale (TK-Means)
Definiamo finestre temporali rigide:
– Finestra 1: giorni 1-7
– Finestra 2: giorni 8-14
– Finestra 3: giorni 15-30

Trasformiamo i dati in vettori temporali:

from sklearn.preprocessing import StandardScaler
import numpy as np

def create_temporal_vector(row, window_start, window_end):
days = (row[‘timestamp_cet’] – row[‘timestamp_cet’].min()).days
mask = (days >= window_start) & (days <= window_end)
vec = np.zeros(7)
vec[days – window_start] = row[row[‘event_type’] == ‘email_open’].sum()
vec[days – window_start] += row[row[‘event_type’] == ‘sms_click’].sum()
vec[days – window_start] += row[row[‘event_type’] == ‘website_visit’].sum()
return vec

# Applica a tutte le righe per cohort
windows = [1,7,14,30]
cohort_vecs = []

for w_start in [1,8,15]:
for w_end in [7,14,30]:
cohort_data = df[df[‘batch_day’] >= w_start – 1].copy()
cohort_data = cohort_data[cohort_data[‘timestamp_cet’].dt.dayofweek < 5] # focus su giorni lavorativi
vec = create_temporal_vector(cohort_data.iloc[0], w_start, w_end)
cohort_vecs.extend(vec)

# Normalizzazione e clustering
scaler = StandardScaler()
X_scaled = scaler.fit_transform(cohort_vecs.reshape(-1,1))
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3, random_state=42)
cohort_labels = kmeans.fit_predict(X_scaled)

# Assegnazione dinamica con regole temporali
cohort_assign = pd.DataFrame({‘customer_id’: df[‘customer_id’], ‘cohort_label’: cohort_labels})
cohort_assign[‘socket_timezone’] = df[‘timestamp_cet’].dt.strftime(‘%Z’).values

# Determinare numero ottimale cohort: metodo gomito temporale + silhouette score
from sklearn.metrics import silhouette_score
scores = []
for k in range(2,5):
km = KMeans(n_clusters=k, random_state=42).fit(cohort_vecs