भाषा मॉडल की उलझन

पेप्लेक्सिटी एक मूल्यांकन मीट्रिक है जो भाषा मॉडल की गुणवत्ता को मापता है। इस पोस्ट में, हम चर्चा करेंगे कि लोकप्रिय मॉडल GPT2 के लिए उलझन क्या है और इसकी गणना कैसे की जाती है ।

एक भाषा मॉडल क्या है?

आपने पहले से ही बड़े भाषा मॉडल (एलएलएम) जैसे बीईआरटी, जीपीटी2 आदि के बारे में सुना होगा, जिसने प्राकृतिक भाषा प्रसंस्करण का चेहरा बदल दिया है। विभिन्न प्रकार के भाषा मॉडल हैं जैसे सांख्यिकीय भाषा मॉडल और तंत्रिका भाषा मॉडल। SLM दिए गए पाठ में आँकड़ों पर आधारित होते हैं जहाँ तंत्रिका भाषा मॉडल को तंत्रिका नेटवर्क आर्किटेक्चर का उपयोग करके प्रशिक्षित किया जाता है।

इसके मूल में, एक भाषा मॉडल (एलएम) शब्दों के एक सेट पर संभाव्यता वितरण के अलावा और कुछ नहीं है, जिसे मॉडल की शब्दावली के रूप में जाना जाता है। यह शब्दावली में एक निश्चित शब्द की संभावना बताता है जो उसके पिछले सभी शब्दों को दिया गया है। आमतौर पर, जिस भी शब्द की अधिकतम संभावना होती है, उसे अनुक्रम में अगले अनुमानित शब्द के रूप में चुना जाता है।

इस संभावना की गणना प्रत्येक शब्द के लिए उसके पिछले शब्दों के लिए सशर्त संभावनाओं के अनुक्रम को गुणा करके की जा सकती है जो इस क्रम की संभावना देता है।

उदाहरण के लिए, उदाहरण वाक्य "यह एक सुंदर दिन है" की संयुक्त संभावना को नीचे दिखाए गए अनुसार लिखा गया है। इस संभाव्यता की गणना करने से हमें अनुक्रम में अगले या लापता शब्दों की भविष्यवाणी करने में मदद मिलती है और इस प्रकार मॉडल भाषा की बारीकियों को सीखता है - इसलिए शब्द भाषा मॉडल।

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

अगले भाग में, हम कुछ महत्वपूर्ण शब्दों पर चर्चा करेंगे जिनका उपयोग पेरप्लेक्सिटी की गणना के लिए किया जाता है।

एन्ट्रापी

एन्ट्रापी एक माप है जो अनिश्चितता की मात्रा निर्धारित करता है और किसी घटना के होने की संभावना के व्युत्क्रम के रूप में प्राप्त किया जाता है। संभावना जितनी अधिक होगी, अनिश्चितता उतनी ही कम होगी। इसलिए, भाषा मॉडल का लक्ष्य प्रशिक्षण अनुक्रमों के समान शब्दों के अनुक्रम उत्पन्न करने की एंट्रॉपी को कम करना है। एंट्रॉपी की गणना करने का सूत्र नीचे दिया गया है जहां P(x) शब्द x की प्रायिकता है।

एंट्रॉपी को और अधिक विस्तार से समझने के लिए यहां एक शानदार वीडियो है:https://youtube.com/watch?v=YtebGVx-Fxw

क्रॉस एंट्रॉपी

क्रॉस एन्ट्रॉपी दो प्रायिकता वितरणों P(x) और Q(x) की तुलना करता है। भाषा मॉडल के संदर्भ में, हम वास्तविक संभाव्यता वितरण के साथ शब्दों पर अनुमानित संभाव्यता वितरण की तुलना करते हैं। यहाँ, P(x) वास्तविक संभाव्यता वितरण है और Q(x) मॉडल अनुमानित वितरण है। क्रॉस एंट्रॉपी की गणना तब की जाती है जैसा कि नीचे दिखाया गया है जिसका उपयोग भाषा मॉडल को प्रशिक्षित करने के लिए हानि कार्य के रूप में किया जा सकता है।

मान लीजिए कि हमारे पास एक भाषा मॉडल है जिसे केवल 5 शब्दों "धूप", "दिन", "सुंदर", "दृश्य", "बादल" की शब्दावली के साथ प्रशिक्षित किया गया है। अब, जब मॉडल "सुंदर दृश्यों" वाक्यांश को देखता है, तो हम उसकी उलझन की गणना करना चाहते हैं।

आइए PyTorch में एक सरल उदाहरण का उपयोग करके क्रॉस एन्ट्रापी की गणना करें।

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

इन लॉग्स को फिर एक सॉफ्टमैक्स फ़ंक्शन में पास किया जाता है जो मूल्यों को सामान्य करता है और उन्हें प्रायिकता वितरण में परिवर्तित करता है। यह अनुमानित संभाव्यता वितरण है।

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)

सहज रूप से, व्याकुलता का अर्थ है चकित होना। हम मापते हैं कि नया डेटा देखकर मॉडल कितना हैरान है। उलझन जितनी कम होगी, प्रशिक्षण उतना ही अच्छा होगा।

भ्रम की गणना मॉडल से प्राप्त हानि के प्रतिपादक के रूप में की जाती है। उपरोक्त उदाहरण में, हम देख सकते हैं कि "सुंदर दृश्यों" वाक्यांश के संबंध में हमारे उदाहरण मॉडल की उलझन 9.97 है। एक इनपुट अनुक्रम में सभी शब्दों की लॉग संभावना के माध्य के प्रतिपादक के लिए जटिलता का सूत्र है।

अब, GPT2 के साथ दो वाक्यों की उलझन की तुलना करते हैं और देखते हैं कि यह कितना पेचीदा है। हम सबसे पहले हगिंगफेस से GPT2 मॉडल के लिए एक टोकननाइज़र और एक कॉज़ल हेड लोड करते हैं:

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

उलझन आमतौर पर केवल यह निर्धारित करने के लिए प्रयोग किया जाता है कि मॉडल ने प्रशिक्षण सेट को कितनी अच्छी तरह सीखा है। परीक्षण प्रदर्शन को मापने के लिए परीक्षण सेट पर BLEU , ROUGE आदि जैसे अन्य मेट्रिक्स का उपयोग किया जाता है।

इस पोस्ट में, हमने एक भाषा मॉडल के क्रॉस एंट्रॉपी, पेप्लेक्सिटी पर चर्चा और गणना की है। अगली पोस्ट में, हम GLUE बेंचमार्क के बारे में बात करेंगे जो लोकप्रिय भाषा मॉडलों की सामान्य भाषा समझने की क्षमता को मापता है।

संदर्भ