Métriques automatisées pour évaluer la qualité de la génération de texte

Introduction

Génération automatique de texte est la tâche consistant à générer du texte en langage naturel en utilisant un système d'apprentissage automatique. La génération ici peut être ouverte ou guidée selon un certain cas d'utilisation. Un système de génération de texte bien entraîné peut rendre très difficile la distinction entre des textes écrits par des humains et par des machines. Certains des cas d'utilisation réels populaires où la génération de texte est observée en action sont la réponse intelligente de Gmail, l'auto-complétion sur un smartphone, etc.

Évaluer ces systèmes peut devenir compliqué. La plupart des systèmes disponibles de nos jours sont de nature probabilistique et on observe souvent qu'ils fabriquent des informations factuelles lorsqu'ils génèrent du texte. Ainsi, l'une des meilleures façons d'effectuer l'évaluation est de le faire avec l'aide des humains, mais cela n'est pas toujours faisable car c'est un processus coûteux et chronophage. Cela ne garantit pas non plus la reproductibilité en raison du biais d'échantillonnage. De plus, il n'est pas possible d'évaluer à grande échelle lorsqu'on le fait manuellement. Par conséquent, pour les raisons mentionnées ci-dessus, les métriques automatiques sont généralement préférées pour évaluer les systèmes de génération de texte. Les métriques automatiques peuvent être à la fois entraînées et non entraînées. Comme prévu, les métriques entraînées essaient de prendre en compte les spécificités de la tâche lors de l'évaluation mais au prix de l'apprentissage de cette fonction avec des données pertinentes, tandis que les métriques non entraînées sont génériques, ne nécessitent aucun entraînement, sont indépendantes de la langue et plus rapides à calculer. Les métriques non entraînées sont populaires et largement utilisées pour mesurer la qualité des textes générés, tant dans l'industrie que dans le milieu académique, dans de nombreux cas d'utilisation tels que la traduction automatique, le résumé de texte, la génération d'histoires, la description d'images, etc.

Dans ce blog, nous nous concentrerons sur certaines métriques non entraînées populaires (avec code) pour évaluer la qualité du texte généré par les systèmes existants de génération de langage naturel (NLG), allant des systèmes classiques comme la génération basée sur des modèles aux modèles avancés comme GPT, les modèles de séquence, etc.

Prérequis

Ces prérequis aideront à comprendre les métriques automatisées pour évaluer la qualité de la génération de texte :

• Compréhension de base du traitement du langage naturel (NLP) : Familiarité avec les concepts fondamentaux du NLP tels que la tokenisation, les embeddings de mots et la modélisation de séquences.

• Connaissance des techniques de génération de texte : Connaissance des différents modèles de génération de texte (par exemple, GPT, T5, BART) et de leurs cas d'utilisation dans des tâches telles que le résumé, la traduction et l'intelligence artificielle conversationnelle.

• Familiarité avec les métriques d'évaluation : Compréhension des métriques d'évaluation automatisées courantes pour le texte, telles que BLEU, ROUGE, METEOR et la perplexité, ainsi que leurs forces et leurs limites dans différents contextes.

• Compétences en programmation : Maîtrise de base de Python, y compris la connaissance de bibliothèques telles que NLTK, Hugging Face Transformers ou Transformers, pour implémenter et utiliser ces métriques.

• Compréhension de l'analyse statistique : Connaissance des concepts statistiques tels que la précision, le rappel et le score F1, qui sont fondamentaux pour de nombreuses mesures d'évaluation de texte.

ROUGE

ROUGE signifie Rappel-Orienté Understudy pour l'Evaluation de Gist. Il a été introduit dans cet article en 2004. C'est une métrique vraiment populaire que vous trouverez certainement dans la littérature sur le résumé de texte. La métrique est basée sur le calcul du chevauchement syntaxique entre les résumés candidats et de référence (ou tout autre texte). Rouge-1, Rouge-2, Rouge-L et Rouge-S sont quelques nombres couramment calculés. Ici, Rouge-1 calcule le chevauchement des unigrams _(mot individuel)_ entre les textes candidats et de référence. Rouge-2 calcule le chevauchement des bigrammes _(paires de mots)_ entre les textes candidats et de référence. Rouge-L calcule le chevauchement des n-grammes cooccurrents les plus longs en séquence entre les textes candidats et de référence. Rouge-S calcule le chevauchement du Skip-bigram (de toute paire de mots dans leur ordre dans la phrase) entre les textes candidats et de référence. La formulation mathématique de la précision et du rappel de Rouge-1 est montrée ci-dessous -

Précision et Rappel ROUGE-1

En littérature, vous trouverez souvent que le score F1 est mentionné pour chacun de R1, R2, RL, et ainsi de suite. L'implémentation de ROUGE est réalisée ci-dessous -

from rouge import Rouge 
rouge = Rouge()

def calculate_rouge(candidate, reference):
    '''
    candidate, reference: generated and ground-truth sentences
    '''
    scores = rouge.get_scores([candidate], reference)
    return scores

Calcul ROUGE en Python

N'hésitez pas à consulter le package python ici et aussi à jeter un œil à cette démonstration en ligne.

bleue

BLEU signifie Bilingue Evaluation Understudy. C'est un métrique très populaire que vous trouverez certainement dans la littérature sur la traduction automatique et qui a été proposé dans cet article en 2002. Le métrique est utilisé pour comparer une traduction candidate à une ou plusieurs traductions de référence. Et le résultat se situe dans la plage de 0 à 1, où un score proche de 1 indique des traductions de bonne qualité.

BLEU-1, BLEU-2, BLEU-3 et BLEU-4 sont quelques nombres couramment calculés que l’on trouve souvent mentionnés dans la littérature. Ici, chacun de 1, 2, 3 et 4 représente la précision de la séquence n-gramme qui est prise en compte lors du calcul du score BLEU. La formulation mathématique de BLEU est montrée ci-dessous-

Formulation BLEU | Image de la source

La métrique introduit également la notion de « Pénalité de brièveté »(le premier terme dans la formule ci-dessus). Dans ce cas, si la sortie est plus courte que la phrase de référence, nous pénalisons le score BLEU par ce facteur, traitant ainsi le problème de la génération de sous-ensembles.

L'implémentation de BLEU est faite ci-dessous

from nltk.translate.bleu_score import sentence_bleu
from nltk import word_tokenize

def calculate_bleu(candidate, reference):
    '''
    candidate, reference: generated and ground-truth sentences
    '''
    reference = word_tokenize(reference)
    candidate = word_tokenize(candidate)
    score = sentence_bleu(reference, candidate)
    return score

Calcul du BLEU en Python

N'hésitez pas à consulter le paquet Python ici et à suivre plus d'exemples à partir de là. Il est également bon de savoir quand ne pas utiliser une métrique, pour cela je vous recommanderais de lire Evaluating Text Output in NLP: BLEU à vos propres risques.

BERTScore

Comme son nom l'indique, BERTScore a quelque chose à voir avec BERT, n'est-ce pas ? Alors oui, BERTScore utilise BERT pour calculer la qualité du texte généré par les systèmes NLG. Il a été proposé assez récemment dans cet article en 2020. Contrairement à la plupart des méthodes qui utilisent principalement les chevauchements syntaxiques au niveau des tokens ou des phrases entre l'hypothèse et les morceaux de texte de référence, BERTScore, en revanche, capture l'aspect sémantique en utilisant les embeddings contextualisés générés par le modèle BERT.

Pipeline BERTScore | Image modifiée à partir de la source

Comme on peut le voir dans la figure ci-dessus, cela commence par obtenir d'abord des embeddings de mots contextualisés pour les textes de référence (vérité terrain) et les textes candidats (ceux générés par le système NLG). Il calcule ensuite la similarité cosinus entre chaque mot des références et des candidats, obtenant ainsi une idée des mots les plus similaires sémantiquement. Sur cette base, il calcule ensuite la précision, le rappel et le score F en utilisant les formules telles que décrites dans l'image ci-dessus.

Rappel du calcul du BERTScore avec des pondérations d'importance

Les auteurs de l'article parlent également du concept de “poids d'importance ”, qui donne plus de poids aux mots censés être plus importants et exclusifs au texte, contrairement aux mots courants. Ils utilisent les poids de fréquences inverses de documents (IDF) à cet effet. L'intuition est que plus un mot est commun dans les documents, moins il est important pour le document concerné. Par conséquent, l'importance des scores pour ces mots ne devrait pas avoir beaucoup d'importance. Dans de tels cas, nous aurons une faible valeur IDF. D'un autre côté, si le mot est unique au document concerné, il aura une valeur IDF élevée. Ici, le choix du poids peut être ajusté et reste ouvert à l'exploration.

Ce code peut être mis en œuvre facilement en utilisant le dépôt GitHub Tiiiger bert_score. Suivez les instructions pour installer la bibliothèque, puis vous pouvez exécuter BERTscore pour l'évaluation en langue anglaise via le terminal comme suit :

bert-score -r original_text.txt -c generated_text.txt --lang en

N'hésitez pas à suivre la bibliothèque Python à des fins d'implémentation. Il y a également une très bonne explication vidéo pour la même chose. Vous pouvez la consulter ici.

MÉTÉORE

METEOR signifie La Métrique pour Evaluation de la Traduction avec un Exact ORdre. Il a été présenté dans cet article. Il peut être utilisé pour évaluer les résultats dans divers domaines de tâches comme la traduction automatique, le résumé de texte, la légende d'image, etc. Mais vous le trouverez souvent utilisé dans la littérature sur la traduction automatique. Il prétend également avoir une forte corrélation avec le jugement humain.

Il présente certains avantages évidents par rapport à la métrique BLEU (une métrique populaire pour l'évaluation des sorties des systèmes de traduction automatique) qui se concentre principalement sur la capture de l'aspect précision de la génération par rapport à la vérité terrain. METEOR, en revanche, est basé sur l'idée de calculer la moyenne harmonique de la précision et du rappel en unigrammes, où le rappel reçoit un poids plus important que la précision. Accorder un poids plus important au rappel nous permet de mieux comprendre combien de la vérité terrain avons-nous produit en tant que sortie lors du processus de génération. La formulation mathématique exacte est présentée ci-dessous -

Calcul du score F de Meteor

METEOR a également une notion de “Pénalité de Bloc” qui considère le chevauchement non seulement des unigrammes mais aussi des blocs (mots consécutifs) pour imposer un certain niveau d'ordre. Elle est notée “p ” et est calculée comme indiqué ci-dessous -

Calcul de la pénalité par bloc

Ici, c et um sont respectivement le nombre de segments dans le candidat qui apparaissent également dans la référence et les unigrammes dans la phrase candidate. Enfin, le calcul du score METEOR (M) se fait en multipliant le facteur « p » par le score F, montré ci-dessous -

Calcul du score METEOR

La mise en œuvre de METEOR est réalisée ci-dessous

from nltk.translate import meteor

def calculate_meteor(candidate, reference):
  '''
  candidate, reference: tokenized list of words in the sentence
  '''
  reference = word_tokenize(reference)
  candidate = word_tokenize(candidate)
  meteor_score = round(meteor([candidate],reference), 4)
  return meteor_score

Implémentation de Meteor en Python

N'hésitez pas à consulter la documentation de nltk à ce sujet.

Auto-BLEU

Self-BLEU est une utilisation intelligente de la métrique BLEU traditionnelle pour capturer et quantifier la diversité dans le texte généré. Elle a été proposée par des chercheurs de l'Université Jiao Tong de Shanghai et du University College de Londres dans cet article en 2018.

Plus la valeur du score de self-bleu est faible, plus la diversité du texte généré est élevée. Les tâches de génération de texte long, comme la génération d'histoires, la génération de nouvelles, etc., pourraient être bien adaptées pour surveiller de tels métriques, aidant à évaluer la redondance et la monotonie du modèle. Cette métrique peut être complétée par d'autres métriques d'évaluation de génération de texte qui prennent en compte la qualité et la pertinence du texte généré. Un compromis optimal entre pertinence et diversité permettrait d'obtenir un texte parfaitement équilibré.

L'algorithme est assez simple et se présente comme suit :

1. Choisissez une phrase parmi un ensemble de phrases générées pour une entrée donnée. Calculez le score BLEU entre cette phrase et toutes les autres phrases restantes de l'ensemble.
2. Itérez sur toutes les phrases uniques, générez des scores BLEU pour toutes, et stockez-les dans une liste.
3. Enfin, prenez la moyenne de la liste calculée dans le cadre de l'étape 2.

import numpy as np
import copy

def get_bleu_score(sentence, remaining_sentences):
    lst = []
    for i in remaining_sentences:
        bleu = sentence_bleu(sentence, i)
        lst.append(bleu)
    return lst


def calculate_selfBleu(sentences):
    '''
    sentences - list of sentences generated by NLG system
    '''
    bleu_scores = []

    for i in sentences:
        sentences_copy = copy.deepcopy(sentences)
        remaining_sentences = sentences_copy.remove(i)
        print(sentences_copy)
        bleu = get_bleu_score(i,sentences_copy)
        bleu_scores.append(bleu)

    return np.mean(bleu_scores)

calculate_selfBleu(sentences)

Implémentation de Self-BLEU en Python

Distance de Déplacement de Mots (WMD)

Comme le nom l’indique, il s’agit de calculer la distance qu’un mot parcourt pour se déplacer vers un autre mot dans une certaine représentation hyperspatiale commune. Cette méthode peut être utilisée pour déterminer la proximité sémantique entre les textes générés et les textes de référence en calculant la distance minimale mot-mot nécessaire pour transformer une phrase en une autre phrase. Cependant, bien que WMD fonctionne assez bien pour les textes courts, le temps de calcul augmente considérablement, et l’essence sémantique globale est un peu perdue à mesure que la longueur des documents augmente. Des efforts ont été faits pour accélérer l’ensemble des calculs WMD avec certaines approximations, n’hésitez pas à consulter ceci et ceci.

L'image ci-dessous montre l'interprétation visuelle de cet algorithme

Visualisation d’ADM | Image de la source

Comme on peut le voir sur l'image ci-dessus, nous avons deux phrases propres d et d’ comme « Obama speaks media Illinois » et « President greets press Chicago » respectivement. La prochaine étape consiste à projeter chaque jeton de chaque phrase dans un espace hyperspatial commun de d dimensions. On peut utiliser soit des méthodes existantes clés en main à cet effet comme word2vec, gloVe, fasttext, BERT, etc., soit entraîner leurs versions sur leurs données. Plus la méthode de représentation est bonne, meilleur sera le calcul global de distance. Une fois cela réalisé, l'étape suivante consiste à calculer le WMD en additionnant la distance que chaque mot de d parcourt pour aller vers son mot le plus proche (au sens sémantique) depuis le document d’. Par exemple - « speaks » est le plus proche de « greets », « media » est le plus proche de « press », « Obama » est le plus proche de « President » et « Illinois » est le plus proche de « Chicago ». La méthode originale calcule la distance L2 (euclidienne) comme mesure de distance. Mais on peut utiliser d'autres distances comme le cosinus dans ce cas lorsqu'on traite des dimensions très élevées.

Prenons un autre exemple et regardons le calcul de distance - Comme on peut le voir dans l'image ci-dessous, chaque mot des documents D1 et D2 est aligné sur le mot le plus proche dans le document D0. La distance minimale globale parcourue par les tokens importants de D1 pour atteindre D0 est de 1,07, tandis que la distance minimale globale parcourue par les tokens importants de D2 pour atteindre D0 est de 1,63. Moins la distance est grande, plus la similarité est élevée.

Illustration d'ADM | Image modifiée à partir de la source

La mise en œuvre de celui-ci est vraiment pratique et peut être réalisée via la bibliothèque gensim comme montré ci-dessous -

import gensim.downloader as api
model = api.load('word2vec-google-news-300')

def calculate_wmd(model, hypothesis, reference):
    '''
    model - word vector model
    hypothesis - generated sentence
    reference - groud-truth sentence
    '''
    distance = model.wmdistance(
hypothesis, 
                            reference
                            )
return distance

Implémentation de WMD dans Python Gensim

N'hésitez pas à consulter la documentation de gensim à ce sujet.

Conclusion

Chacun des indicateurs que nous avons discutés aujourd'hui tente de capturer certains aspects du texte généré par rapport à la vérité terrain disponible. Il est donc pratique de mesurer et de rapporter plus d'un d'entre eux pour une tâche donnée. Il y a eu quelques extensions à ROUGE, BLEU et METEOR pour capturer également les synonymes, les rendant plus robustes au schéma de recouvrement. De plus, pour les indicateurs qui reposent sur des recouvrements syntaxiques, il est recommandé de normaliser_(sensibilité à la casse, racines des mots, variations morphologiques, etc.)_ les textes générés et de référence avant de faire les calculs. Il y a également beaucoup de recherches actives dans le domaine des « métriques apprises », contrairement à ce que nous avons discuté aujourd'hui qui est non paramétrique. Par exemple, vous pourriez vouloir consulter BLEURT (article, vidéo) et le Perception Score. Nous garderons cette discussion pour un autre blog.

J'espère que vous avez apprécié la lecture. Merci !

Références

1. Évaluation de la génération de texte : un sondage
2. BLEU, METEOR, BERTScore : Évaluation de la performance des métriques dans l'évaluation des erreurs de traduction critiques dans les textes orientés vers le sentiment