Introduction
Au cours des 10 à 15 dernières années, avec les avancées des technologies numériques, les stratégies marketing ont profondément évolué. Grandes marques comme marchés de niche ont collecté d'immenses volumes de données sur les transactions, les achats, les préférences, le pouvoir d'achat, l'activité d'achat, la démographie, les avis, etc. Toutes ces données permettent aux marketeurs de comprendre le comportement client à chaque étape, de l'intention d'achat à l'acte d'achat, jusqu'à la fidélisation. C'est là que le potentiel de la data science entre en scène.
La data science transforme les big data marketing en informations actionnables, même si certaines découvertes sont peu intuitives au premier abord (par exemple des schémas de comportement et cooccurrences moins évidents). À la clé, une vision plus nette des audiences cibles, l'acquisition et la rétention de clients, l'optimisation des stratégies marketing, une meilleure visibilité, des campagnes publicitaires plus performantes, l'activation de nouveaux canaux, et in fine un fort impact sur le chiffre d'affaires.
Parmi les cas d'usage les plus courants de la data science en marketing figure la prédiction du taux de churn (attrition) client. Examinons ce sujet de plus près.
Cas d'usage data science en marketing : prédire le taux de churn client
Le churn client désigne la tendance des clients à résilier un service qu'ils utilisaient, cessant ainsi d'en être clients. Le taux de churn correspond au pourcentage de clients perdus sur un intervalle de temps défini. C'est l'inverse du taux de croissance client, qui suit les nouveaux clients.
Le taux de churn est un indicateur essentiel de la satisfaction client et de la santé globale de l'entreprise. Au-delà d'un churn « naturel » inhérent à tout business, ou saisonnier selon certains services, d'autres facteurs signalent qu'un dysfonctionnement interne doit être corrigé. Parmi eux :
- un support client absent ou de mauvaise qualité,
- des expériences négatives,
- un basculement vers un concurrent offrant de meilleures conditions ou une tarification plus attractive,
- une évolution des priorités des clients,
- des clients de longue date qui ne se sentent plus satisfaits,
- un service en deçà des attentes,
- des difficultés financières,
- des blocages liés à la protection contre la fraude sur les paiements des clients.
Un taux de churn élevé pose de sérieux problèmes à toute entreprise, pour les raisons suivantes :
- Il est corrélé à une baisse du chiffre d'affaires.
- Il coûte bien plus cher d'acquérir de nouveaux clients que de fidéliser les existants, surtout sur des marchés très concurrentiels.
- Si l'attrition est due à un service client défaillant, la réputation de l'entreprise peut être fortement dégradée par des avis négatifs publiés sur les réseaux sociaux ou les sites d'évaluation.
La rétention client est donc un pilier stratégique pour tous les services par abonnement. Pour prédire le churn et mettre en place des actions préventives, il faut collecter et analyser les données de comportement client (fréquence d'achat, ancienneté, résiliations, relances par appels et messages, activité en ligne) et identifier les attributs — et leurs combinaisons — caractéristiques des clients à risque. Savoir à l'avance quels clients risquent de partir, en particulier les comptes à fort revenu ou de longue date, permet de concentrer les efforts là où ils sont les plus utiles et de bâtir une stratégie efficace pour les convaincre de rester. Cela peut passer par un appel avec une offre dédiée : cadeau, remise, montée de gamme au même prix, ou toute autre expérience personnalisée.
Sur le plan technique, la prédiction du churn est un problème de classification en apprentissage automatique, où les clients sont étiquetés « oui » ou « non » selon leur risque d'attrition. Explorons ce cas d'usage en Python avec des données réelles.
Nous allons modéliser le churn dans un contexte télécom, où les clients peuvent regrouper plusieurs services sous un même contrat-cadre. Le jeu de données contient des variables décrivant l'activité client nettoyée et un label de churn indiquant si le client a résilié ou non.
Observons d'abord les données et la distribution du churn :
import pandas as pd
telcom = pd.read_csv('telco.csv')
print(f'Number of customers: {telcom.shape[0]:,}\n'
f'Churn values: {set(telcom['Churn'])}\n\n'
f'Churn distribution, %:\n{round(telcom.groupby(['Churn']).size()/telcom.shape[0]*100).convert_dtypes()}')Number of customers: 7,032
Churn values: {0, 1}
Churn distribution, %:
Churn
0 73
1 27
dtype: float6427 % des clients ont résilié, un taux plutôt élevé. Comparé au cas d'usage précédent en data science, ce jeu de données ne semble toutefois pas souffrir d'un fort déséquilibre de classes.
Préparons maintenant les données avant d'appliquer des techniques de machine learning pour prédire le churn. Il s'agit de séparer les jeux d'entraînement et de test, et d'extraire variables explicatives et cible :
from sklearn.model_selection import train_test_split
target = ['Churn']
custid = ['customerID']
cols = [col for col in telcom.columns if col not in custid + target]
X = telcom[cols]
y = telcom[target]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)Le premier algorithme que nous allons utiliser pour prédire les labels de churn et évaluer la précision est une régression logistique simple :
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
lr = LogisticRegression()
lr.fit(X_train, y_train)
predictions = lr.predict(X_test)
print(f'Test accuracy: {round(accuracy_score(y_test, predictions), 4)}')Test accuracy: 0.8009Ajoutons maintenant une fonctionnalité à notre modèle de régression logistique : l'exécuter sur des données mises à l'échelle avec une régularisation L1 afin d'effectuer une sélection de variables en parallèle de l'apprentissage. Différentes valeurs du paramètre C (inverse de l'intensité de régularisation) influencent la précision du modèle. Pour commencer, fixons C à 0,025 :
lr = LogisticRegression(penalty='l1', C=0.025, solver='liblinear')
lr.fit(X_train, y_train)
predictions = lr.predict(X_test)
print(f'Test accuracy: {round(accuracy_score(y_test, predictions), 4)}')Test accuracy: 0.7969Nous allons à présent ajuster C pour la régularisation L1 afin d'identifier la valeur optimale qui réduit la complexité du modèle tout en maintenant de bonnes performances. Pour cela, nous itérons sur différentes valeurs de C, entraînons un modèle de régression logistique à chaque fois et calculons les métriques de performance.
La liste C a été définie en amont avec les valeurs possibles du paramètre. Le tableau l1_metrics comporte 3 colonnes : la valeur de C, le nombre de coefficients non nuls et la précision du modèle. Voyons le résultat :
C Non-Zero Coeffs Accuracy
0 1.0000 23.0 0.801479
1 0.5000 22.0 0.799204
2 0.2500 21.0 0.802048
3 0.1000 20.0 0.802617
4 0.0500 18.0 0.802048
5 0.0250 13.0 0.796928
6 0.0100 5.0 0.790102
7 0.0050 3.0 0.783276
8 0.0025 2.0 0.745734On constate que des valeurs de C plus faibles réduisent le nombre de coefficients non nuls (donc les variables retenues), ce qui diminue la complexité du modèle, mais dégrade aussi la précision. Il semble que C = 0,05 soit un bon compromis : 18 variables conservées, avec une précision légèrement supérieure au modèle non régularisé.
Essayons maintenant un autre algorithme : l'arbre de décision.
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)
print(f'Test accuracy: {round(accuracy_score(y_test, predictions), 4)}')Test accuracy: 0.7275Pour sélectionner un modèle plus précis tout en évitant le surapprentissage, nous pouvons ajuster la profondeur de l'arbre (paramètre max_depth) et identifier sa valeur optimale. Techniquement, la démarche est similaire à la recherche de C pour la régression logistique : nous itérons sur plusieurs profondeurs, entraînons un arbre à chaque fois, puis calculons la précision.
La liste depth_list a été définie en amont avec les valeurs possibles. Le tableau depth_tuning comporte 2 colonnes : les profondeurs candidates et la précision correspondante. Appliquons cette approche pour trouver la profondeur optimale :
depth_list = list(range(2, 15))
depth_tuning = np.zeros((len(depth_list), 2))
depth_tuning[:, 0] = depth_list
for index in range(len(depth_list)):
clf = DecisionTreeClassifier(max_depth=depth_list[index])
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)
depth_tuning[index, 1] = accuracy_score(y_test, predictions)
col_names = ['Max_Depth', 'Accuracy']
print(pd.DataFrame(depth_tuning, columns=col_names)) Max_Depth Accuracy
0 2.0 0.756542
1 3.0 0.783276
2 4.0 0.782708
3 5.0 0.791809
4 6.0 0.778157
5 7.0 0.780432
6 8.0 0.757110
7 9.0 0.762230
8 10.0 0.763936
9 11.0 0.752560
10 12.0 0.745165
11 13.0 0.732651
12 14.0 0.727531La précision augmente d'abord avec la profondeur, puis décline. À max_depth = 5, l'arbre obtient la meilleure précision ; nous pouvons donc retenir cette valeur comme profondeur optimale.
Après avoir identifié les meilleurs paramètres pour la régression logistique et l'arbre de décision, reconstruisons ces modèles puis détectons et interprétons les principaux facteurs qui font varier le churn.
Pour la régression logistique, nous allons extraire et analyser les exposants des coefficients obtenus :
# Reconstruction du meilleur modèle
lr = LogisticRegression(penalty='l1', C=0.05, solver='liblinear')
lr.fit(X_train, y_train)
predictions = lr.predict(X_test)
# Association des noms de variables et coefficients
feature_names = pd.DataFrame(X_train.columns, columns=['Feature'])
log_coef = pd.DataFrame(np.transpose(lr.coef_), columns=['Coefficient'])
coefficients = pd.concat([feature_names, log_coef], axis=1)
# Calcul des exposants des coefficients
coefficients['Exp_Coefficient'] = np.exp(coefficients['Coefficient'])
# Suppression des coefficients nuls
coefficients = coefficients[coefficients['Coefficient']!=0]
print(coefficients.sort_values(by=['Exp_Coefficient'])) Feature Coefficient Exp_Coefficient
21 tenure -0.907750 0.403431
4 PhoneService_Yes -0.820517 0.440204
17 Contract_Two year -0.595271 0.551413
8 TechSupport_Yes -0.418254 0.658195
16 Contract_One year -0.414158 0.660896
5 OnlineSecurity_Yes -0.412228 0.662173
6 OnlineBackup_Yes -0.143100 0.866667
3 Dependents_Yes -0.039299 0.961463
7 DeviceProtection_Yes -0.017465 0.982687
11 PaperlessBilling_Yes 0.071389 1.073999
1 SeniorCitizen_Yes 0.097904 1.102857
19 PaymentMethod_Electronic check 0.188533 1.207477
22 MonthlyCharges 0.901454 2.463182On voit que la variable ayant l'effet le plus fort sur la probabilité de churn est l'ancienneté (tenure). De manière générale, des exposants inférieurs à 1 diminuent les chances d'attrition, tandis que des exposants supérieurs à 1 les augmentent.
Pour l'arbre de décision, nous allons extraire et tracer les règles if-else :
# Reconstruction du meilleur modèle
clf = DecisionTreeClassifier(max_depth=5)
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)
from sklearn import tree
import graphviz
# Export d'un objet graphviz à partir de l'arbre entraîné
exported = tree.export_graphviz(decision_tree=clf,
out_file=None,
feature_names=cols,
precision=1,
class_names=['Not churn', 'Churn'],
filled=True)
graph = graphviz.Source(exported)
display(graph)
Nous obtenons une visualisation claire de l'arbre de décision, interprétable comme un ensemble de règles if-else depuis la racine. Là encore, l'ancienneté client apparaît comme la variable la plus déterminante. L'arbre peut être approfondi avec davantage de niveaux pour explorer le rôle d'autres variables.
Pour aller plus loin, vous pouvez affiner encore les hyperparamètres, tester d'autres méthodes de séparation train/test, comparer d'autres algorithmes de machine learning et analyser différentes métriques pour évaluer les performances.
Si vous souhaitez approfondir la prédiction du churn et d'autres applications de la data science en marketing, ce cours Machine Learning for Marketing in Python est un excellent point de départ.