J’ai récemment eu l’idée de coloriser les critiques trompeuses en fonction de leur fond sentimental. Le principe était assez clair : analyser le sentiment d’un avis et sur la base de sa distribution neutre/positif/négatif, coloriser le commentaire en conséquence (le bleu est neutre, le rouge est négatif et le vert est positif). J’ai supposé que les critiques trompeuses auraient l’air plus « voyantes » (je n’en étais pas sûr au début). J’ai travaillé sur ce projet constamment pendant cinq jours sur mon temps libre et j’ai publié des mises à jour quotidiennes sur ma page LinkedIn. Voici le résumé de mes publications et quelques résultats.
Jour 1 : Définir l’idée, préparer les données
L’idée de ce projet était assez simple. Supposons que nous ayons une critique véridique et une critique trompeuse. Les deux sont de la même polarité (positive ou négative). Cependant, comme l’appuient la plupart des recherches, les critiques trompeuses peuvent avoir des modèles sous-jacents qui sont visibles par une machine, mais pas par un œil humain.
Dans certains cas, les sentiments sont exagérés (par exemple, j’ai adoré le service, c’était juste BRILLANT, etc.). Dès lors, qu’en serait-il si on pouvait coloriser les propos et d’un coup d’œil évaluer le niveau d’exagération ?
Pour analyser les sentiments, j’ai utilisé l’API Azure Text Analytics qui nous permet d’obtenir différents aspects d’un sentiment, comme la neutralité ou la négativité, en plus d’analyser le simple sentiment global, qui peut ne pas toujours être uniforme, car certaines critiques sont composées de commentaires négatifs et aspects positifs.
Pour l’expérience, nous avons utilisé le Ott Deceptive Opinion Spam Corpus, qui est l’ensemble de données de référence, couramment utilisé pour comparer différents modèles d’apprentissage automatique, visant à détecter automatiquement la supercherie dans les avis des utilisateurs.
Pour plus de commodité, j’ai créé un ensemble de fonctions permettant d’obtenir rapidement un sous-ensemble nécessaire d’Ott Corpus.
Cela donne :
def read_ott():
try:
ott_path = ‘../local_datasets/deceptive-opinion.csv’
ott_deceptive = pd.read_csv(ott_path, encoding=’utf-8′, sep=’,’, engine=’python’)
except FileNotFoundError:
ott_path = ‘./local_datasets/deceptive-opinion.csv’
ott_deceptive = pd.read_csv(ott_path, encoding=’utf-8′, sep= », », engine=’python’)
return ott_deceptive
def get_ott_negative():
ott_dataframe = read_ott()
ott_dataframe_negative = ott_dataframe[ott_dataframe[‘polarity’] == ‘negative’]
Jour 2 : Premiers résultats
Voici donc le résultat de la toute première exécution du projet (j’étais très excité lors du lancement de l’expérience). Et voilà à quoi cela ressemblait ! L’image ci-dessous représente une collection de 400 (faux) critiques d’hôtels trompeuses de polarité négative.
Les utilisateurs devaient laisser des commentaires négatifs et ces avis ont été collectés via Amazon Mechanical Turk (Ott et al.). Pour obtenir le sentiment, j’ai créé une fonction :
def get_overall_sentiment(phrase):
documents = [phrase]
response = text_analytics_client.analyze_sentiment(documents, language=’en’)
result = [doc for doc in response if not doc.is_error]
output = result[0]
positive = output.confidence_scores.positive
neutral = output.confidence_scores.neutral
negative = output.confidence_scores.negative
return positive, neutral, negative
Chaque pixel est un avis, et selon le sentiment, il est colorisé au format BGR (bleu, vert, rouge et non RVB, car j’utilise OpenCV). Comme vous le voyez, voici à quoi ressemblent les trolls d’Internet pour un ordinateur ! L’étape suivante consiste à exécuter le même modèle de ML sur des avis négatifs véridiques.
P.S. Étonnamment, il y a des pixels verts.
Jour 3 : Critiques trompeuses vs critiques constructives
Après le test précédent, je ne savais toujours pas si le mensonge pouvait avoir une couleur. Le 3ème jour, cependant, j’étais plutôt positif à ce sujet car il y avait finalement quelque chose à comparer. J’avais donc lancé le même pipeline sur les avis négatifs véridiques et nous pouvons observer des différences évidentes.
Comme vous pouvez le remarquer sur les deux images ci-dessus, les critiques trompeuses sont plus brillantes, avec beaucoup moins de points verts. Cela a définitivement prouvé qu’il y avait une certaine exagération dans les faux commentaires, donc l’étape suivante consistait à vérifier si le même schéma peut être observé dans les critiques positives.
N.B. pour créer une image à partir d’un tableau de sentiments au format BGR, j’ai procédé comme suit : j’ai d’abord converti le sentiment au format BGR, puis généré une image à partir de ces valeurs
def sentiment_to_opencv(overall_sentiment):
positive, neutral, negative = overall_sentiment
blue = ceil(neutral*255)
green = ceil(positive*255)
red = ceil(negative * 255)
return blue, green, red
def generate_image(reviews_bgr, image_name):
if len(reviews_bgr) != 400:
return False
image = np.zeros((20, 20, 3), dtype=np.uint8)
counter = 0
for i in range(20):
for j in range(20):
image[i][j] = reviews_bgr[counter]
counter += 1
return cv2.imwrite(image_name, image)
Jour 4 : L’herbe est toujours plus verte ailleurs
Après des résultats aussi prometteurs que ceux de l’expérience précédente, il semblait judicieux de lancer le même pipeline sur les critiques positives (trompeuses et véridiques). Et qu’est-ce qu’on voit ici ?
Les couleurs sont beaucoup plus vives avec moins de taches rouges. Nous pouvons voir comment certains services sont faussement flattés. D’un autre côté, les critiques véridiques ont tendance à être plus réalistes, car rien n’est parfait dans notre monde. Il y avait certainement quelque chose d’intéressant là-dedans. L’étape suivante consistait à centraliser ces pixels et à donner une couleur uniforme qui représentait spécifiquement la supercherie.
Jour 5 : Lie to me
Au début de notre aventure nous avons dit que nous voulions une couleur, pas plusieurs. Ainsi, la généralisation/la moyenne de tous les pixels en une seule couleur uniforme a donné des résultats étonnamment intéressants.
Lorsque nous mettons tous les pixels sur un canevas, il devient évident que nous pouvons certainement trouver l’exagération dans les commentaires trompeurs à l’aide d’outils NLP, tels que Azure Sentiment Analysis par exemple. Et on peut littéralement le voir ! Comme vous l’avez peut-être remarqué, les avis négatifs véridiques ne sont pas aussi rouges que les avis trompeurs. Et même les fausses critiques positives sont plus vertes que les commentaires véridiques.
N.B. Faire la moyenne des pixels était assez simple, il suffit de diviser un pixel en trois canaux, puis de les fusionner après avoir trouvé la moyenne.
def mix_colors(reviews_bgr, image_name):
average_blue = 0
average_green = 0
average_red = 0
for blue, green, red in reviews_bgr:
average_blue += int(blue)
average_green += int(green)
average_red += int(red)
average_blue = ceil(average_blue/len(reviews_bgr))
average_green = ceil(average_green / len(reviews_bgr))
average_red = ceil(average_red / len(reviews_bgr))
image = np.zeros((150, 150, 3), dtype=np.uint8)
image[:] = (average_blue, average_green, average_red)
return cv2.imwrite(image_name, image)
Ce fut une expérience de 5 jours fascinante. J’ai beaucoup appris et il me semble maintenant que c’est le début de quelque chose d’encore plus intéressant. J’espère que c’était intéressant pour vous aussi. Si vous voulez expérimenter vous-même, vous pouvez trouver le code ici. Comme vous aurez besoin d’une API Text Analytics, la meilleure solution est de créer un compte Azure gratuit et de commencer à jouer avec les services cognitifs. Cependant, si vous trouvez cela compliqué ou si vous souhaitez simplement l’essayer sans l’acheter, n’hésitez pas à me contacter par email, je peux vous fournir une clé temporaire, afin que vous puissiez commencer à jouer avec le service.
Ecrit par Alibek Jakupov, Data scientist et Microsoft MVP Artifical Intelligence.