Perplexidade dos modelos de linguagem

A perplexidade é uma métrica de avaliação que mede a qualidade dos modelos de linguagem. Neste post, discutiremos o que é perplexidade e como ela é calculada para o popular modelo GPT2 .

O que é um modelo de linguagem?

Você já deve ter ouvido falar de modelos de linguagem grandes (LLM), como BERT, GPT2 etc., que mudaram a cara do processamento de linguagem natural. Existem diferentes tipos de modelos de linguagem, como modelos de linguagem estatísticos e modelos de linguagem neural. Os SLMs são baseados em estatísticas no texto fornecido, enquanto os modelos de linguagem neural são treinados usando arquiteturas de rede neural.

Em sua essência, um modelo de linguagem (LM) nada mais é do que uma distribuição de probabilidade sobre um conjunto de palavras conhecido como vocabulário do modelo. Ele informa a probabilidade de uma determinada palavra no vocabulário ocorrer, dadas todas as suas palavras anteriores. Normalmente, qualquer palavra que tenha a probabilidade máxima é selecionada como a próxima palavra prevista na sequência.

Essa probabilidade pode ser calculada multiplicando uma sequência de probabilidades condicionais para cada palavra dadas suas palavras anteriores, o que dá a probabilidade dessa sequência.

Por exemplo, a verossimilhança conjunta da sentença de exemplo “Está um lindo dia” é escrita como mostrado abaixo. Calcular essa probabilidade nos ajuda a prever as palavras seguintes ou ausentes em uma sequência e, assim, o modelo aprende as nuances do idioma — daí o termo modelo de idioma.

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

Nas próximas seções, discutiremos alguns termos importantes que são usados ​​para calcular a perplexidade.

Entropia

A entropia é uma medida que quantifica a incerteza e é obtida como o inverso da probabilidade de um evento ocorrer. Quanto maior a probabilidade, menor a incerteza. Assim, o objetivo do modelo de linguagem é minimizar a entropia de geração de uma sequência de palavras semelhantes às sequências de treinamento. A fórmula para calcular a entropia é dada abaixo onde P(x) é a probabilidade da palavra x.

Aqui está um ótimo vídeo para entender a Entropia com mais detalhes:https://youtube.com/watch?v=YtebGVx-Fxw

entropia cruzada

Cross Entropy compara duas distribuições de probabilidade P(x) e Q(x). No contexto dos modelos de linguagem, comparamos a distribuição de probabilidade prevista sobre as palavras com a distribuição de probabilidade real. Aqui, P(x) é a distribuição de probabilidade real e Q(x) é a distribuição predita do modelo. A entropia cruzada é então calculada conforme mostrado abaixo, que pode ser usada como uma função de perda para treinar modelos de linguagem.

Digamos que temos um modelo de linguagem que foi treinado com um vocabulário de apenas 5 palavras “ensolarado”, “dia”, “bonito”, “cenário”, “nuvens”. Agora, queremos calcular a perplexidade da modelo ao ver a frase “bela paisagem”.

Vamos calcular a entropia cruzada usando um exemplo simples no PyTorch.

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

Esses logits são então passados ​​para uma função softmax que normaliza os valores e os converte em uma distribuição de probabilidade. Esta é a distribuição de probabilidade prevista.

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)

Intuitivamente, perplexidade significa ser surpreendido. Medimos o quanto o modelo fica surpreso ao ver novos dados. Quanto menor a perplexidade, melhor é o treinamento.

A perplexidade é calculada como expoente da perda obtida do modelo. No exemplo acima, podemos ver que a perplexidade do nosso modelo de exemplo em relação à frase “bela paisagem” é 9,97. A fórmula para perplexidade é o expoente da média de probabilidade logarítmica de todas as palavras em uma sequência de entrada.

Agora, vamos comparar a perplexidade de duas sentenças com GPT2 e ver como ela é perplexa. Primeiro carregamos um tokenizer e um cabeçalho causal para o modelo GPT2 do 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

A perplexidade geralmente é usada apenas para determinar o quão bem um modelo aprendeu o conjunto de treinamento. Outras métricas como BLEU , ROUGE etc., são usadas no conjunto de teste para medir o desempenho do teste.

Neste post, discutimos e calculamos a entropia cruzada, a perplexidade de um modelo de linguagem. No próximo post, falaremos sobre o benchmark GLUE que mede a capacidade geral de compreensão de linguagem de modelos de linguagem populares.

Referências