Kebingungan Model Bahasa

Perplexity adalah metrik evaluasi yang mengukur kualitas model bahasa. Pada postingan kali ini, kita akan membahas apa itu kebingungan dan bagaimana cara menghitungnya untuk model populer GPT2 .

Apa itu Model Bahasa?

Anda mungkin pernah mendengar model bahasa besar (LLM) seperti BERT, GPT2, dll., Yang telah mengubah wajah Pemrosesan Bahasa Alami. Ada berbagai jenis model bahasa seperti model bahasa statistik dan model bahasa saraf. SLM didasarkan pada statistik dalam teks yang diberikan di mana model bahasa Neural dilatih menggunakan arsitektur jaringan saraf.

Pada intinya, model bahasa (LM) tidak lain adalah distribusi probabilitas atas sekumpulan kata yang dikenal sebagai kosa kata model. Ini memberi tahu kemungkinan kata tertentu dalam kosakata yang muncul mengingat semua kata sebelumnya. Biasanya, kata mana pun yang memiliki probabilitas maksimum akan dipilih sebagai kata prediksi berikutnya dalam urutan.

Probabilitas ini dapat dihitung dengan mengalikan urutan probabilitas bersyarat untuk setiap kata yang diberikan kata sebelumnya yang memberikan kemungkinan urutan ini.

Misalnya, kemungkinan gabungan dari contoh kalimat “It is a beautiful day” ditulis seperti di bawah ini. Menghitung probabilitas ini membantu kita untuk memprediksi kata berikutnya atau kata yang hilang secara berurutan dan dengan demikian model mempelajari nuansa bahasa — maka istilah model bahasa.

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

Pada bagian selanjutnya, kita akan membahas beberapa istilah penting yang digunakan untuk menghitung Perplexity.

Entropi

Entropi adalah ukuran yang mengukur ketidakpastian dan diperoleh sebagai kebalikan dari probabilitas suatu peristiwa yang terjadi. Semakin tinggi probabilitasnya, semakin rendah ketidakpastiannya. Oleh karena itu, tujuan dari model bahasa adalah untuk meminimalkan entropi menghasilkan urutan kata yang mirip dengan urutan pelatihan. Rumus untuk menghitung Entropi adalah seperti yang diberikan di bawah ini dimana P(x) adalah probabilitas dari kata x.

Berikut adalah video yang bagus untuk memahami Entropi secara lebih detail:https://youtube.com/watch?v=YtebGVx-Fxw

Lintas Entropi

Cross Entropy membandingkan dua distribusi probabilitas P(x) dan Q(x). Dalam konteks model bahasa, kami membandingkan distribusi probabilitas yang diprediksi pada kata-kata dengan distribusi probabilitas yang sebenarnya. Di sini, P(x) adalah distribusi probabilitas aktual dan Q(x) adalah distribusi prediksi model. Entropi silang kemudian dihitung seperti yang ditunjukkan di bawah ini yang dapat digunakan sebagai fungsi kerugian untuk melatih model bahasa.

Katakanlah kita memiliki model bahasa yang telah dilatih dengan kosakata hanya 5 kata "cerah", "hari", "indah", "pemandangan", "awan". Sekarang, kami ingin menghitung kebingungan model ketika melihat frase "pemandangan indah".

Mari kita hitung cross entropy menggunakan contoh sederhana di PyTorch.

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

Logit ini kemudian diteruskan ke fungsi softmax yang menormalkan nilai dan mengubahnya menjadi distribusi probabilitas. Ini adalah distribusi probabilitas yang diprediksi.

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)

Secara intuitif, kebingungan berarti terkejut. Kami mengukur seberapa besar model terkejut dengan melihat data baru. Semakin rendah kebingungan, semakin baik pelatihannya.

Kebingungan dihitung sebagai eksponen dari kerugian yang diperoleh dari model. Pada contoh di atas, kita dapat melihat bahwa kebingungan model contoh kita terkait dengan frase “pemandangan indah” adalah 9,97. Rumus kebingungan adalah eksponen rata-rata kemungkinan log dari semua kata dalam urutan input.

Sekarang, mari kita bandingkan kebingungan dua kalimat dengan GPT2 dan lihat betapa bingungnya itu. Pertama-tama kita memuat tokenizer dan causal head untuk model GPT2 dari 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

Kebingungan biasanya digunakan hanya untuk menentukan seberapa baik model telah mempelajari set pelatihan. Metrik lain seperti BLEU , ROUGE dll., Digunakan pada set pengujian untuk mengukur performa pengujian.

Dalam posting ini, kami telah membahas dan menghitung Cross Entropy, Perplexity dari model bahasa. Pada postingan selanjutnya, kita akan membahas tentang benchmark GLUE yang mengukur kemampuan pemahaman bahasa secara umum dari model bahasa populer.

Referensi