Data science pour les ventes : analyse du sentiment client

• Cas d’usage data science pour les ventes : analyser le sentiment client
• Préparer le jeu de données
• Appliquer la méthode BOW 
• Prédire le sentiment avec un modèle supervisé
• Conclusion 

Les cas d’usage de la data science concernent quasiment tous les secteurs où une grande quantité de données est ou peut être collectée.  Les magasins et sites e-commerce sont les lieux où se vit l’expérience client réelle des personnes attirées par les campagnes marketing, et où sont recueillies des données d’achat précieuses pour une marque ou une entreprise donnée. C’est là que les personnes décident finalement si elles veulent acheter un produit, si elles s’intéressent à un achat non prévu, combien elles sont prêtes à dépenser, si elles reviendront dans ce magasin et quel avis elles laisseront sur leur expérience. 

Les avis clients constituent en effet une source solide de données pour analyser et comprendre ce qu’il faut changer ou renforcer dans l’ensemble du parcours de vente. Cette analyse peut permettre de réduire les coûts, d’améliorer l’efficacité opérationnelle, d’optimiser l’expérience client, de révéler de nouvelles opportunités, de développer l’activité et, in fine, d’augmenter le chiffre d’affaires. Voyons de plus près comment ces informations précieuses peuvent être analysées et modélisées avec des algorithmes de data science pour dégager des insights cachés et capter le message global de chaque client.

Cas d’usage data science pour les ventes : analyser le sentiment client 

L’analyse du sentiment client est un processus automatisé visant à identifier les émotions des clients lorsqu’ils utilisent les services ou produits d’une entreprise. Il s’agit généralement de données textuelles non structurées, collectées via des enquêtes en ligne, les réseaux sociaux, les tickets de support, les formulaires de feedback, les avis produits, les forums, les appels téléphoniques, les emails et les chatbots. En apprentissage automatique, l’analyse du sentiment repose sur le traitement automatique du langage (NLP), qui applique des méthodes statistiques et linguistiques pour extraire les sentiments positifs, négatifs et neutres directement à partir des textes. Concrètement, elle produit deux paramètres :

• Polarité : indique si un sentiment est positif ou négatif.
• Intensité : indique la force de ce sentiment.

L’analyse du sentiment client est un outil clé pour toute entreprise moderne : elle aide à obtenir des insights actionnables, à repérer et corriger les problèmes récurrents critiques qui génèrent de l’insatisfaction, à renforcer les fonctionnalités des produits ou services qui suscitent des émotions positives et, plus globalement, à prendre des décisions plus efficaces basées sur les données. Plus finement, elle permet de :

• améliorer le service client et donc l’expérience globale,
• accroître la fidélité,
• réduire le taux d’attrition,
• faire évoluer produits et services au bon moment,
• optimiser les campagnes marketing,
• anticiper de nouvelles tendances et de nouveaux marchés,
• préserver la haute réputation de l’entreprise,
• augmenter les profits.

Comme pour toute analyse de texte, certains écueils peuvent survenir lors d’une analyse du sentiment. Par exemple, l’algorithme de NLP peut ne pas détecter le sarcasme dans certains avis et les classer à tort. Il peut aussi échouer à déchiffrer certaines abréviations très spécifiques ou un argot rarement utilisé.

Préparer le jeu de données

Explorons le fonctionnement de l’analyse du sentiment client en pratique à l’aide d’un jeu de données d’avis de films IMDB :

import pandas as pd

movies = pd.read_csv('movies.csv', index_col=0).reset_index(drop=True)
print(f'Number of reviews: {movies.shape[0]:,}\n')
print(movies.head())

Number of reviews: 7,501

                                              review  label
0  This short spoof can be found on Elite's Mille...      0
1  A singularly unfunny musical comedy that artif...      0
2  An excellent series, masterfully acted and dir...      1
3  The master of movie spectacle Cecil B. De Mill...      1
4  I was gifted with this movie as it had such a ...      0

Nous avons deux colonnes : l’une contient le texte de chaque avis, l’autre l’estimation du sentiment global : positif (1) ou négatif (0).

Calculons la part d’avis positifs et négatifs :

round(movies['label'].value_counts()*100/len(movies['label'])).convert_dtypes()

0    50
1    50
Name: label, dtype: Int64

Nous avons donc des proportions quasiment égales d’avis positifs et négatifs.

Appliquer la méthode BOW 

La prochaine étape consiste à transformer les textes en variables numériques, car un modèle d’apprentissage automatique ne traite que des caractéristiques numériques. En particulier, nous allons créer des variables qui comptent combien de fois chaque mot apparaît dans l’avis correspondant. L’approche la plus simple et directe s’appelle bag-of-words (BOW) : elle construit un vocabulaire de tous les mots présents dans le document et compte leur fréquence dans chaque avis. Nous obtiendrons ainsi de nouvelles variables, une par mot, avec leur fréquence associée.

Appliquons la méthode BOW à notre jeu de données :

from sklearn.feature_extraction.text import CountVectorizer

# Creating new features
vect = CountVectorizer(max_features=200)
vect.fit(movies.review)
X_review = vect.transform(movies.review)
X_df = pd.DataFrame(X_review.toarray(), columns=vect.get_feature_names())

# Combining the new features with the label
movies_bow = pd.concat([movies['label'], X_df], axis=1)
print(movies_bow.head())

  label  10  about  acting  action  actors  actually  after  again  all  ...  \
0      0   0      0       0       0       0         0      0      0    0  ...  
1      0   1      0       1       0       1         0      0      0    3  ...  
2      1   0      0       0       0       0         0      1      0    0  ...  
3      1   0      0       0       1       0         0      0      0    0  ...  
4      0   1      0       0       1       0         0      0      0     0  

  will  with  without  work  world  would  years  you  young  your 
0     0     1        0     0      0      1      0    0      0     0 
1     2     7        1     0      0      2      0    3      0     2 
2     0     2        0     0      0      0      0    0      1     0 
3     0     0        0     0      0      0      0    1      1     0 
4     0     2        0     1      0      0      0    0      0     0 

[5 rows x 201 columns]

Ci-dessus, nous avons utilisé le paramètre optionnel max_features pour ne considérer que les 200 mots les plus fréquents et éviter un surapprentissage potentiel.

Prédire le sentiment avec un modèle supervisé

Nous allons maintenant utiliser un modèle supervisé pour prédire le sentiment. Comme nous voulons estimer si le sentiment d’un nouvel avis est positif ou négatif à partir d’avis déjà étiquetés, nous sommes face à un problème de classification. Utilisons à nouveau une régression logistique et mesurons la précision du modèle :

Accuracy score: 0.754

Confusion matrix:
[[37.62772101 13.23856064]
[11.32829853 37.80541981]]

On observe que le modèle a classé 11 % des avis positifs comme négatifs, et 13 % comme positifs alors qu’ils étaient négatifs. Pour améliorer la précision, on peut envisager d’exclure les stop words (mots très fréquents et peu informatifs comme "about", "will", "you", etc.) et d’augmenter la taille du vocabulaire.

Avec la méthode BOW, on peut se retrouver avec des centaines voire des milliers de nouvelles variables. Le modèle peut alors devenir trop complexe : surappris, avec trop de caractéristiques et de paramètres inutiles. Une façon d’y remédier est d’utiliser la régularisation, qui contraint la fonction du modèle. Le paramètre à ajuster est C, qui représente l’intensité de la régularisation. Testons deux valeurs : 100 et 0,1, et voyons laquelle offre les meilleures performances sur les données de test :

lr_1 = LogisticRegression(C=100)
lr_1.fit(X_train, y_train)
predictions_1 = lr_1.predict(X_test)

lr_2 = LogisticRegression(C=0.1)
lr_2.fit(X_train, y_train)
predictions_2 = lr_2.predict(X_test)

print(f'Accuracy score, lr_1 model: {round(accuracy_score(y_test, predictions_1), 3)}\n'
      f'Accuracy score, lr_2 model: {round(accuracy_score(y_test, predictions_2), 3)}\n\n'
      f'Confusion matrix for lr_1 model, %:\n{confusion_matrix(y_test, predictions_1)/len(y_test)*100}\n\n'
      f'Confusion matrix for lr_2 model, %:\n{confusion_matrix(y_test, predictions_2)/len(y_test)*100}')

Accuracy score, lr_1 model: 0.753
Accuracy score, lr_2 model: 0.756

Confusion matrix for lr_1 model, %:
[[37.53887161 13.32741004]
[11.32829853 37.80541981]]

Confusion matrix for lr_2 model, %:
[[37.67214571 13.19413594]
[11.19502443 37.93869391]]

La différence de précision entre ces deux valeurs de C est négligeable. En testant davantage de valeurs, on pourrait sans doute améliorer les performances. Toutefois, nous n’avons ici que 200 nouvelles variables, le modèle reste donc peu complexe et la régularisation n’est pas indispensable.

Au lieu de prédire des étiquettes 0 ou 1 avec predict, on peut prédire une probabilité de sentiment avec predict_proba. Gardons à l’esprit qu’on ne peut pas appliquer directement l’accuracy score ou la matrice de confusion aux probabilités prédites, car ces métriques attendent des classes. Il faut donc les convertir en classes : par défaut, une probabilité supérieure ou égale à 0,5 est traduite en classe 1, sinon en classe 0.

lr = LogisticRegression()
lr.fit(X_train, y_train)

# Predicting the probability of the 0 class
predictions_prob_0 = lr.predict_proba(X_test)[:, 0]

# Predicting the probability of the 1 class
predictions_prob_1 = lr.predict_proba(X_test)[:, 1]

print(f'First 10 predicted probabilities of class 0: {predictions_prob_0[:10].round(3)}\n'
      f'First 10 predicted probabilities of class 1: {predictions_prob_1[:10].round(3)}')

First 10 predicted probabilities of class 0: [0.246 0.143 0.123 0.708 0.001 0.828 0.204 0.531 0.121 0.515]
First 10 predicted probabilities of class 1: [0.754 0.857 0.877 0.292 0.999 0.172 0.796 0.469 0.879 0.485]

Conclusion 

De nombreuses autres approches utiles peuvent être appliquées à notre jeu de données pour mener une analyse du sentiment plus fine :

• utiliser des n-grams (combinaisons de mots) plutôt que des mots isolés afin de préserver le contexte,
• exclure les stop words,
• limiter la taille du vocabulaire en fonction de seuils de fréquence hauts ou bas,
• créer des variables numériques supplémentaires décrivant la longueur de chaque avis ou le nombre de signes de ponctuation (ce dernier peut parfois corréler avec l’intensité du sentiment),
• exclure les chiffres, certains caractères, des mots d’une certaine longueur, ou considérer des motifs lexicaux plus complexes,
• appliquer le stemming et la lemmatisation, c’est-à-dire ramener les mots à leur racine,
• recourir à des méthodes plus sophistiquées que BOW pour créer le vocabulaire, par exemple TfIdf (term frequency–inverse document frequency), qui tient compte de la fréquence d’un mot dans un avis relativement aux autres avis,
• utiliser des bibliothèques spécialisées pour l’analyse du sentiment, comme TextBlob, SentiWordNet ou VADER (Valence Aware Dictionary and Sentiment Reasoner).

Si vous souhaitez approfondir ces techniques et d’autres méthodes pour réaliser une analyse du sentiment riche en insights, découvrez le cours Sentiment Analysis in Python.