Perplexité des modèles de langage

La perplexité est une métrique d'évaluation qui mesure la qualité des modèles de langage. Dans cet article, nous expliquerons ce qu'est la perplexité et comment elle est calculée pour le modèle populaire GPT2 .

Qu'est-ce qu'un modèle de langage ?

Vous avez peut-être déjà entendu parler de grands modèles de langage (LLM) tels que BERT, GPT2, etc., qui ont changé le visage du traitement du langage naturel. Il existe différents types de modèles de langage tels que les modèles de langage statistiques et les modèles de langage neuronal. Les SLM sont basés sur des statistiques dans le texte donné alors que les modèles de langage neuronal sont formés à l'aide d'architectures de réseau neuronal.

À la base, un modèle de langage (ML) n'est rien d'autre qu'une distribution de probabilité sur un ensemble de mots qui est connu sous le nom de vocabulaire du modèle. Il indique la probabilité qu'un certain mot du vocabulaire se produise compte tenu de tous ses mots précédents. Habituellement, le mot qui a la probabilité maximale est sélectionné comme mot prédit suivant dans la séquence.

Cette probabilité peut être calculée en multipliant une suite de probabilités conditionnelles pour chaque mot étant donné ses mots précédents ce qui donne la vraisemblance de cette suite.

Par exemple, la vraisemblance conjointe de la phrase d'exemple "C'est une belle journée" s'écrit comme indiqué ci-dessous. Le calcul de cette probabilité nous aide à prédire les mots suivants ou manquants dans une séquence et ainsi le modèle apprend les nuances de la langue - d'où le terme modèle de langue.

P(It,is,a,beautiful,day) = P(day|beautiful, a, is, it) * 
                           P(beautiful|a, is, it) * P(a|is, it) * P(is|it)

Dans les sections suivantes, nous discuterons de certains termes importants utilisés pour calculer la perplexité.

Entropie

L'entropie est une mesure qui quantifie l'incertitude et est obtenue comme l'inverse de la probabilité qu'un événement se produise. Plus la probabilité est élevée, moins l'incertitude est grande. Par conséquent, l'objectif du modèle de langage est de minimiser l'entropie de la génération d'une séquence de mots similaires aux séquences d'apprentissage. La formule de calcul de l'entropie est donnée ci-dessous où P(x) est la probabilité du mot x.

Voici une excellente vidéo pour comprendre l'entropie plus en détail :https://youtube.com/watch?v=YtebGVx-Fxw

Entropie croisée

L'entropie croisée compare deux distributions de probabilité P(x) et Q(x). Dans le contexte des modèles linguistiques, nous comparons la distribution de probabilité prédite sur les mots avec la distribution de probabilité réelle. Ici, P(x) est la distribution de probabilité réelle et Q(x) est la distribution prédite par le modèle. L'entropie croisée est ensuite calculée comme indiqué ci-dessous et peut être utilisée comme fonction de perte pour former des modèles de langage.

Disons que nous avons un modèle de langage qui a été formé avec un vocabulaire de seulement 5 mots "ensoleillé", "jour", "beau", "paysage", "nuages". Maintenant, nous voulons calculer la perplexité du modèle lorsqu'il voit l'expression "beau paysage".

Calculons l'entropie croisée à l'aide d'un exemple simple dans PyTorch.

# Get the needed libraries
import torch
from torch.nn import functional as F

Ces logits sont ensuite transmis à une fonction softmax qui normalise les valeurs et les convertit en une distribution de probabilité. Il s'agit de la distribution de probabilité prédite.

tensor([[-0.7891,  1.3421,  0.4929,  0.0715, -0.0910],
        [ 0.9024, -0.8675,  0.8498, -1.0331,  0.5531]])

F.softmax(input, dim = -1)

Predicted:

tensor([[0.0575, 0.4841, 0.2071, 0.1359, 0.1155],
        [0.3369, 0.0574, 0.3196, 0.0486, 0.2375]])

Target/Actual: tensor([2, 3])

tensor([[0, 0, 1, 0, 0],
        [0, 0, 0, 1, 0]])

Loss for First Word:
(((- 0 * log(0.0575)) + (- 0 * log(0.4841)) + (- 1 * log(0.2071)) + 
  (- 0 * log(0.1359)) + (- 0 * log(0.1155))) = 1.5745535105805986

Loss for Second Word:
(((- 0 * log(0.3369)) + (- 0 * log(0.0574)) + (- 0* log(0.3196)) + 
  (- 1* log(0.0486)) + (- 0 * log(0.2375))) = 3.024131748075689

Loss = (1.5745535105805986 + 3.024131748075689)/2 = 2.299

loss = torch.nn.CrossEntropyLoss()

output = loss(input, target)
output

Loss: tensor(2.299)

Intuitivement, la perplexité signifie être surpris. On mesure à quel point le modèle est surpris en voyant de nouvelles données. Plus la perplexité est faible, meilleure est la formation.

La perplexité est calculée comme exposant de la perte obtenue à partir du modèle. Dans l'exemple ci-dessus, nous pouvons voir que la perplexité de notre exemple de modèle en ce qui concerne l'expression "beau paysage" est de 9,97. La formule de perplexité est l'exposant de la moyenne du log de vraisemblance de tous les mots d'une séquence d'entrée.

Maintenant, comparons la perplexité de deux phrases avec GPT2 et voyons à quel point c'est perplexe. Nous chargeons d'abord un tokenizer et une tête causale pour le modèle GPT2 de HuggingFace :

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")
inputs = tokenizer("ABC is a startup based in New York City and Paris", return_tensors = "pt")
loss = model(input_ids = inputs["input_ids"], labels = inputs["input_ids"]).loss
ppl = torch.exp(loss)
print(ppl)

Output: 29.48

inputs_wiki_text = tokenizer("Generative Pretrained Transformer is an opensource artificial intelligence created by OpenAI in February 2019", return_tensors = "pt")
loss = model(input_ids = inputs_wiki_text["input_ids"], labels = inputs_wiki_text["input_ids"]).loss
ppl = torch.exp(loss)
print(ppl)

Output: 211.81

La perplexité est généralement utilisée uniquement pour déterminer dans quelle mesure un modèle a appris l'ensemble d'apprentissage. D'autres métriques telles que BLEU , ROUGE etc., sont utilisées sur l'ensemble de test pour mesurer les performances du test.

Dans cet article, nous avons discuté et calculé l'entropie croisée, la perplexité d'un modèle de langage. Dans le prochain article, nous parlerons du benchmark GLUE qui mesure la capacité de compréhension générale du langage des modèles de langage populaires.

Les références