FLAN-T5 ट्यूटोरियल: मार्गदर्शिका और फाइन-ट्यूनिंग

FLAN-T5 क्या है?

FLAN-T5 एक ओपन-सोर्स, सीक्वेंस-टू-सीक्वेंस, बड़ा भाषा मॉडल है, जिसका वाणिज्यिक उपयोग भी किया जा सकता है। यह मॉडल 2022 के अंत में Google के शोधकर्ताओं द्वारा प्रकाशित किया गया था और इसे कई कार्यों पर फाइन-ट्यून किया गया है।

T5 मॉडल विभिन्न कार्यों को टेक्स्ट-टू-टेक्स्ट प्रारूप में पुनर्परिभाषित करता है, जैसे अनुवाद, भाषिक स्वीकृत्यता, वाक्य समानता, और दस्तावेज़ संक्षेपण, जैसा कि नीचे दिखाया गया है:

T5 कैसे अनेक कार्यों को टेक्स्ट-टू-टेक्स्ट ढांचे में पुनर्परिभाषित करता है (स्रोत)

इसी प्रकार, T5 मॉडल की संरचना मूल Transformer पेपर में प्रयुक्त एन्कोडर-डिकोडर ढांचे के बहुत करीब है। मुख्य अंतर प्रशिक्षण डेटा के आकार और प्रकृति में है; T5 को 750GB के विशाल टेक्स्ट कॉर्पस पर प्रशिक्षित किया गया था, जिसे Colossal Clean Crawled Corpus (C4) कहा जाता है।

इसके विपरीत, मूल Transformer विशेष रूप से भाषा अनुवाद के लिए बनाया गया था और इसलिए इसे 1.4 GB के अंग्रेज़ी-जर्मन वाक्य युग्मों के डेटासेट पर प्रशिक्षित किया गया था।

हमारा लेख Transformers और Hugging Face का उपयोग: एक परिचय पाठकों को ट्रांसफॉर्मर्स समझने और वास्तविक जीवन की समस्याओं को हल करने के लिए उनकी क्षमता का उपयोग करने में मार्गदर्शन करता है।

Transformer मॉडल की संरचना (स्रोत)

FLAN-T5 को फाइन-ट्यून करना कितना महत्वपूर्ण है?

इसमें कोई संदेह नहीं कि FLAN-T5 का उपयोग विभिन्न नैचुरल लैंग्वेज प्रोसेसिंग कार्यों के लिए किया जा सकता है।

हालांकि, इसकी पूरी क्षमता का लाभ उठाने और विशिष्ट अनुप्रयोगों के लिए इष्टतम प्रदर्शन सुनिश्चित करने हेतु फाइन-ट्यूनिंग एक महत्वपूर्ण कदम है। नीचे FLAN-T5 को फाइन-ट्यून करने के महत्व को रेखांकित करने वाले मुख्य बिंदु दिए गए हैं:

• FLAN-T5 को फाइन-ट्यून करना मॉडल को विशिष्ट कार्यों के अनुरूप ढालने और उन कार्यों पर उसके प्रदर्शन में सुधार के लिए महत्वपूर्ण है।
• फाइन-ट्यूनिंग उपयोगकर्ता की आवश्यकताओं और डेटा के अनुरूप मॉडल का अनुकूलन करने की अनुमति देती है।
• स्थानीय वर्कस्टेशन पर CPU के साथ FLAN-T5 को फाइन-ट्यून करने की क्षमता इसे अधिक व्यापक उपयोगकर्ताओं के लिए सुलभ बनाती है।
• यह सुलभता उन छोटे संगठनों या व्यक्तिगत शोधकर्ताओं के लिए लाभकारी है जिनके पास GPU संसाधनों तक पहुंच नहीं है।
• समग्र रूप से, FLAN-T5 को फाइन-ट्यून करना, मॉडल को विशिष्ट उपयोग मामलों के लिए अनुकूलित करने और उसके संभावित लाभों को अधिकतम करने का एक मूल्यवान कदम है।

इस ट्यूटोरियल का लक्ष्य प्रश्न-उत्तर परिदृश्य पर FLAN-T5 को फाइन-ट्यून करने के लिए एक संपूर्ण मार्गदर्शिका प्रदान करना है।

इस ट्यूटोरियल में, हम आपको FLAN-T5 के लिए फाइन-ट्यूनिंग को समझने और लागू करने में मदद करने के लिए कई विषयों को कवर करेंगे। हम आवश्यक लाइब्रेरी और टूल्स पर चर्चा से शुरू करेंगे, और फिर फाइन-ट्यूनिंग के लिए वातावरण कैसे सेट करें, यह देखेंगे।

इसके बाद, हम आपको FLAN-T5 मॉडल को लोड करने और अपने डेटा को फाइन-ट्यूनिंग के लिए तैयार करने की प्रक्रिया से लेकर चलेंगे। जैसे ही डेटा तैयार हो जाएगा, हम आपके विशिष्ट आवश्यकताओं के अनुरूप मॉडल को प्रशिक्षित करने और फाइन-ट्यून करने के चरणों पर मार्गदर्शन करेंगे।

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

फाइन-ट्यून किए गए FLAN-T5 के संभावित उपयोग

तकनीकी कार्यान्वयन में उतरने से पहले, आइए फाइन-ट्यून किए गए FLAN-T5 के कुछ संभावित उपयोग देखें—नीचे चैट और संवाद संक्षेपण, टेक्स्ट वर्गीकरण, और Fast Healthcare Interoperability Resources (FHIR) के उदाहरण दिए गए हैं।

फाइन-ट्यून किए गए FLAN-T5 के तीन संभावित उपयोग

• चैट और संवाद संक्षेपण: FLAN-T5 बातचीतों को संक्षिप्त कर सकता है, ग्राहक सेवा इंटरैक्शन या व्यावसायिक बैठकों का त्वरित सार प्रस्तुत करता है।
• टेक्स्ट वर्गीकरण: टेक्स्ट को पूर्व-निर्धारित वर्गों में स्वचालित रूप से वर्गीकृत करने में उपयोगी, जैसे सेंटिमेंट विश्लेषण, स्पैम पहचान, या टॉपिक मॉडलिंग।
• FHIR संसाधन जनरेशन: FLAN-T5 नैदानिक टेक्स्ट को संरचित FHIR (Fast Healthcare Interoperability Resources) में बदल सकता है, जिससे स्वास्थ्य-प्रणालियों में साझा करना और एकीकरण आसान हो जाता है।

लेख के मुख्य तकनीकी पहलुओं में जाने से पहले, हमारा ट्यूटोरियल LangChain के साथ LLM एप्लिकेशन कैसे बनाएं पाठकों को LangChain—उन्नत AI एप्लिकेशन बनाने के लिए एक ओपन-सोर्स Python फ्रेमवर्क—के साथ बड़े भाषा मॉडलों की अप्रयुक्त क्षमता खोजने में मार्गदर्शन करता है।

पूर्वापेक्षाएँ

अब जबकि हमें FLAN-T5 के बारे में बेहतर समझ है, आइए देखें कि इसे प्रश्न-उत्तर उपयोग मामले के लिए कैसे फाइन-ट्यून करें, और पूरा नोटबुक GitHub पर उपलब्ध है।

शुरू करने के लिए, निम्नलिखित लाइब्रेरी और टूल आवश्यक हैं:

• Hugging Face: एक प्लेटफ़ॉर्म जो FLAN-T5 मॉडल तक पहुंच प्रदान करता है, जिससे इसे डाउनलोड करना और फाइन-ट्यूनिंग के लिए उपयोग करना आसान होता है
• Transformers: प्री-ट्रेंड FLAN-T5 मॉडल को लोड करने की प्रक्रिया को सरल बनाता है और फाइन-ट्यूनिंग के लिए उपयोगी फ़ंक्शंस देता है
• Datasets: उपयोग के लिए तैयार डेटासेट का संग्रह, जो फाइन-ट्यूनिंग के लिए प्रासंगिक डेटा स्रोत करने में अहम है
• Sentencepiece: एक टोकनाइज़ेशन टूल, जो मुख्यतः बड़े और बहुभाषी टेक्स्ट डेटा के लिए उपयोग होता है
• Tokenizers: टेक्स्ट को उपयोग मामले के अनुरूप प्रारूप में बदलने के लिए टोकनाइज़ेशन लाइब्रेरी
• Evaluate: यह लाइब्रेरी मॉडल मूल्यांकन के लिए कई तरह के मेट्रिक्स प्रदान करती है, जिससे सुनिश्चित होता है कि फाइन-ट्यून किया गया मॉडल वांछित प्रदर्शन मानक पूरा करता है
• Rouge score: बड़े भाषा मॉडलों द्वारा जनित टेक्स्ट की गुणवत्ता का आकलन करने के लिए प्रयुक्त विशेष मेट्रिक
• NLTK: टोकनाइज़ेशन और स्टेमिंग जैसे डेटा पूर्वप्रसंस्करण चरणों के लिए उपयोगी

लाइब्रेरी की स्थापना

स्थापना निम्नानुसार Jupyter नोटबुक से Python पैकेज मैनेजर pip का उपयोग कर की जा सकती है।

%%bash
pip install nltk
pip install datasets
pip install transformers[torch]
pip install tokenizers
pip install evaluate
pip install rouge_score
pip install sentencepiece
pip install huggingface_hubसंचालित द्वारा

नोटबुक में %%bash कमांड का उपयोग संबंधित सेल को प्रत्येक कमांड अलग-अलग चलाने के बजाय एक bash स्क्रिप्ट के रूप में चलाने के लिए किया जाता है।

लाइब्रेरी इम्पोर्ट करें

सभी लाइब्रेरी इंस्टॉल करने के बाद, हम प्रत्येक को निम्नानुसार इम्पोर्ट कर सकते हैं:

import nltk
import evaluate
import numpy as np
from datasets import load_dataset
from transformers import T5Tokenizer, DataCollatorForSeq2Seq
from transformers import T5ForConditionalGeneration, Seq2SeqTrainingArguments, Seq2SeqTrainerसंचालित द्वारा

FLAN-T5 मॉडल लोड करना

Hugging Face पर FLAN-T5 के कई प्रारूप उपलब्ध हैं—छोटे से लेकर अत्यंत बड़े मॉडल तक—और जितना बड़ा मॉडल, उतने अधिक पैरामीटर।

नीचे Hugging Face मॉडल कार्ड पर उपलब्ध विभिन्न मॉडल आकार दिए गए हैं:

FLAN-T5 वेरिएंट उनके पैरामीटर और मेमोरी उपयोग के साथ

उचित मॉडल आकार चुनना

FLAN-T5 के वेरिएंट में से सही मॉडल आकार का चुनाव मुख्यतः निम्न मानदंडों पर निर्भर करता है:

• प्रोजेक्ट की विशिष्ट आवश्यकताएँ
• उपलब्ध गणनात्मक संसाधन
• अपेक्षित प्रदर्शन स्तर

इस प्रायोगिक कार्य के लिए NVIDIA A100 GPU का उपयोग किया जा रहा है, और google/flan-t5-base मॉडल गणनात्मक दक्षता और प्रदर्शन संगतता के बीच संतुलन प्रदान करेगा।

मॉडल और टोकनाइज़र इनिशियलाइज़ेशन

मॉडल बनाने के लिए निम्न तीन निर्देश आवश्यक हैं।

# Load the tokenizer, model, and data collator
MODEL_NAME = "google/flan-t5-base"

tokenizer = T5Tokenizer.from_pretrained(MODEL_NAME)
model = T5ForConditionalGeneration.from_pretrained(MODEL_NAME)
data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=model)संचालित द्वारा

• टोकनाइज़र को T5Tokenizer मॉड्यूल और मॉडल के नाम का उपयोग करते हुए उदाहरणित किया गया है
• T5ForConditionalGeneration की from_pretrained फ़ंक्शन का उपयोग कर मॉडल लोड किया जाता है
• DataCollectorForSeq2Seq के साथ, प्रश्न-उत्तर कार्य के लिए उपयोग हेतु एक डेटा कोलेटर बनाया जाता है

फाइन-ट्यूनिंग के लिए डेटा तैयार करना

मॉडल, टोकनाइज़र और डेटा कोलेटर उपलब्ध होने के साथ, अगला कदम फाइन-ट्यूनिंग के लिए प्रयोग का डेटा लोड करना है, और यहाँ प्रयुक्त डेटा Hugging Face पर उपलब्ध Yahoo चर्चा डेटा है।

डेटा लोड करने की प्रक्रिया सरल है और इसे load_dataset फ़ंक्शन का उपयोग कर किया जा सकता है, जो डेटासेट का नाम पैरामीटर के रूप में लेता है। इस विशेष मामले में, फोकस प्रशिक्षण डेटा पर है।

# Acquire the training data from Hugging Face
DATA_NAME = "yahoo_answers_qa"
yahoo_answers_qa = load_dataset(DATA_NAME)संचालित द्वारा

डेटा प्राप्त होने के बाद, इसे क्रमशः 70% और 30% के अनुपात में प्रशिक्षण और परीक्षण डेटासेट में विभाजित किया जाता है, और यह train_test_split फ़ंक्शन से प्राप्त होता है।

yahoo_answers_qa = yahoo_answers_qa["train"].train_test_split(test_size=0.3)संचालित द्वारा

निम्न कथन प्रशिक्षण और परीक्षण डेटा दोनों में कुल ऑब्ज़र्वेशंस की संख्या दर्शाता है।

# Check the length of the data and its structure
yahoo_answers_qaसंचालित द्वारा

प्रशिक्षण और मान्यकरण डेटासेट के लिए कुल ऑब्ज़र्वेशंस

डेटा फ़ॉर्मैटिंग और टोकनाइज़ेशन

फाइन-ट्यूनिंग प्रक्रिया के लिए हमारे पास प्रशिक्षण और परीक्षण दोनों में पर्याप्त डेटा है। लेकिन उससे पहले हमें डेटा को फाइन-ट्यूनिंग के प्रारूप में ढालना होगा।

अगले चरण में प्रयुक्त अधिकांश फ़ंक्शंस Toughdata लेख से प्रेरित हैं।

इन्फ़रेंस मोड के दौरान, मॉडल को कॉल करने की प्रक्रिया इस प्रारूप में होगी:

“कृपया इस प्रश्न का उत्तर दें: <USER_QUESTION>”

जहाँ <USER_QUESTION> वह प्रश्न है जिसके बारे में उपयोगकर्ता उत्तर चाहता है। इस कार्यक्षमता को प्राप्त करने के लिए, हमें प्रशिक्षण डेटा को इस स्ट्रिंग “कृपया इस प्रश्न का उत्तर दें,” को कार्य के प्रीफ़िक्स के रूप में जोड़कर फ़ॉर्मैट करना होगा, और यह नीचे दिए गए preprocess_function फ़ंक्शन से किया जाता है।

फ़ॉर्मैटिंग के अलावा, यह फ़ंक्शन इनपुट और आउटपुट का टोकनाइज़ेशन tokenizer फ़ंक्शन का उपयोग करके भी करता है।

# We prefix our tasks with "answer the question"
prefix = "Please answer this question: "

# Define the preprocessing function

def preprocess_function(examples):
   """Add prefix to the sentences, tokenize the text, and set the labels"""
   # The "inputs" are the tokenized answer:
   inputs = [prefix + doc for doc in examples["question"]]
   model_inputs = tokenizer(inputs, max_length=128, truncation=True)
  
   # The "labels" are the tokenized outputs:
   labels = tokenizer(text_target=examples["answer"], 
                      max_length=512,         
                      truncation=True)

   model_inputs["labels"] = labels["input_ids"]
   return model_inputsसंचालित द्वारा

अगला, यह फ़ंक्शन नीचे दिए गए map फ़ंक्शन का उपयोग करके पूरे डेटासेट पर लागू किया जाता है:

# Map the preprocessing function across our dataset
tokenized_dataset = yahoo_answers_qa.map(preprocess_function, batched=True)संचालित द्वारा

FLAN-T5 प्रशिक्षण और फाइन-ट्यूनिंग

प्रशिक्षण प्रक्रिया में जाने से पहले, फाइन-ट्यूनिंग के समग्र प्रदर्शन का आकलन करने के लिए मेट्रिक्स को पहचानना बेहतर होता है।

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

टेक्स्ट जनरेशन मॉडल के प्रदर्शन का आकलन करने के लिए दो सबसे सामान्य मेट्रिक्स BLEU और ROUGE हैं, और इस मामले में, उत्तर की गुणवत्ता का मूल्यांकन संदर्भ उत्तर से तुलना करके किया जाता है।

इस ट्यूटोरियल का फोकस ROUGE है, लेकिन यह विकिपीडिया लेख BLEU स्कोर के बारे में अधिक जानकारी देता है।

ROUGE स्कोर क्या है?

ROUGE का अर्थ है Recall-Oriented Understudy for Gisting Evaluation। प्रश्न-उत्तर के लिए ROUGE के कुछ प्रमुख घटक इस प्रकार हैं:

• ROUGE-L: प्रत्याशी और संदर्भ उत्तरों के बीच सबसे लंबी सामान्य अनुक्रम को मापता है। यह पूर्ण टेक्स्ट के रिकॉल पर केंद्रित होता है।
• ROUGE-1, ROUGE-2, ROUGE-SU4: प्रत्याशी और संदर्भ के बीच यूनिग्राम, बिग्राम, 4-ग्राम ओवरलैप की तुलना करते हैं। मुख्य भागों/खंडों के रिकॉल पर फोकस
• उच्च ROUGE स्कोर आम तौर पर प्रश्न-उत्तर के लिए बेहतर प्रदर्शन का संकेत देते हैं। 0.70+ के निकट या उससे ऊपर के स्कोर मजबूत माने जाते हैं
• इस मेट्रिक का उपयोग करते समय, स्टेमिंग और स्टॉपवर्ड्स हटाने जैसे प्रोसेसिंग समग्र प्रदर्शन में सुधार कर सकते हैं

इस समझ के साथ, निम्न सहायक फ़ंक्शन compute_metrics अंतर्निहित ROUGE स्कोर की गणना करने में मदद कर सकता है। फ़ंक्शन के कार्यान्वयन से पहले, ROUGE और NLTK सेटअप करना आवश्यक है।

nltk.download("punkt", quiet=True)
metric = evaluate.load("rouge")संचालित द्वारा

नीचे फ़ंक्शन का कार्यान्वयन दिया गया है।

def compute_metrics(eval_preds):
   preds, labels = eval_preds

   # decode preds and labels
   labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
   decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
   decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)

   # rougeLSum expects newline after each sentence
   decoded_preds = ["\n".join(nltk.sent_tokenize(pred.strip())) for pred in decoded_preds]
   decoded_labels = ["\n".join(nltk.sent_tokenize(label.strip())) for label in decoded_labels]

   result = metric.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True)
  
   return resultसंचालित द्वारा

प्रशिक्षण प्रक्रिया

फाइन-ट्यूनिंग शुरू करने के लिए, हमें कुछ हाइपरपैरामीटर सेट करने होंगे और मुख्य निम्न हैं:

• लर्निंग रेट: यह नियंत्रित करता है कि मॉडल डेटा से कितनी तेजी से सीखता है। सामान्य मान 1e-5 से 5e-5 होते हैं, और इस उपयोग मामले के लिए मान 3e-4 रखा गया है
• बैच आकार: मॉडल के वज़नों को अपडेट करने से पहले प्रोसेस किए गए नमूनों की कुल संख्या। बड़े बैच प्रक्रिया को तेज कर सकते हैं, लेकिन कमजोर प्रदर्शन का कारण भी बन सकते हैं। हम यहाँ 8 का उपयोग करते हैं
• प्रति डिवाइस ट्रेन बैच आकार: यह बैच आकार जैसा ही है, लेकिन प्रत्येक डिवाइस (GPU) पर निर्दिष्ट होता है
• वेट डिके: इसका उद्देश्य मॉडल को ओवरफिटिंग से बचाना है। 0.01 वेट डिके के लिए स्वीकार्य मान है
• सेव टोटल लिमिट: प्रशिक्षण के दौरान सहेजे जाने वाले कुल चेकपॉइंट्स की संख्या। जितनी अधिक सेव, उतने अधिक रोलबैक की संभावनाएँ, पर अधिक डिस्क उपयोग। इस मामले में हम 3 सेव कर रहे हैं
• एपोच की संख्या: प्रशिक्षण डेटासेट के पूर्ण पास की कुल संख्या। अधिक एपोच का अर्थ अधिक प्रशिक्षण समय है, पर मॉडल का प्रदर्शन भी बेहतर हो सकता है। आमतौर पर 3 से 10 के बीच मान चुना जाता है, और यहाँ 3 का उपयोग किया गया है।

ऊपर दिए गए पैरामीटर नीचे परिभाषित हैं और इन्हें मॉडल के प्रशिक्षण आर्ग्युमेंट्स सेटअप करने में उपयोग किया जाता है। समूचा प्रशिक्षण आर्टिफैक्ट्स results फ़ोल्डर में सहेजे जाते हैं:

# Global Parameters
L_RATE = 3e-4
BATCH_SIZE = 8
PER_DEVICE_EVAL_BATCH = 4
WEIGHT_DECAY = 0.01
SAVE_TOTAL_LIM = 3
NUM_EPOCHS = 3

# Set up training arguments
training_args = Seq2SeqTrainingArguments(
   output_dir="./results",
   evaluation_strategy="epoch",
   learning_rate=L_RATE,
   per_device_train_batch_size=BATCH_SIZE,
   per_device_eval_batch_size=PER_DEVICE_EVAL_BATCH,
   weight_decay=WEIGHT_DECAY,
   save_total_limit=SAVE_TOTAL_LIM,
   num_train_epochs=NUM_EPOCHS,
   predict_with_generate=True,
   push_to_hub=False
)संचालित द्वारा

इसके बाद, मॉडल के प्रशिक्षण प्रक्रिया को शुरू करने के लिए ट्रेनर सेट किया जाता है।

trainer = Seq2SeqTrainer(
   model=model,
   args=training_args,
   train_dataset=tokenized_dataset["train"],
   eval_dataset=tokenized_dataset["test"],
   tokenizer=tokenizer,
   data_collator=data_collator,
   compute_metrics=compute_metrics
)संचालित द्वारा

अंत में, train फ़ंक्शन का उपयोग कर मॉडल प्रशिक्षण निम्नानुसार शुरू किया जाता है:

trainer.train()संचालित द्वारा

लगभग चार घंटे के बाद, प्रत्येक एपोच के लिए प्रशिक्षण प्रक्रिया का समग्र प्रदर्शन नीचे दिया गया है।

प्रशिक्षण एपोच और उनके अनुरूप प्रदर्शन स्कोर

आइए ऊपर दिए गए प्रदर्शन मेट्रिक्स बोर्ड को समझते हैं।

• ट्रेनिंग लॉस और वैलिडेशन लॉस: इन मेट्रिक्स में कम मान बेहतर होते हैं क्योंकि ये डेटा पर मॉडल की बेहतर फिटिंग दर्शाते हैं। प्रशिक्षण और वैलिडेशन लॉस एपोच के साथ घटे हैं, और सबसे कम मान एपोच 3 में दर्ज हुए हैं।

• Rouge मेट्रिक्स (Rouge1, Rouge2, Rougel, और Rougelsum): इन मेट्रिक्स में उच्च मान बेहतर टेक्स्ट संक्षेपण प्रदर्शन का संकेत देते हैं। सभी चार Rouge मेट्रिक्स में मान एपोच के साथ बढ़े हैं, और सबसे अधिक मान एपोच 3 में दर्ज हुए हैं।


समग्र रूप से, मॉडल ने तीसरे एपोच में अच्छा प्रदर्शन किया, क्योंकि इसमें सबसे कम ट्रेनिंग और वैलिडेशन लॉस के साथ सभी ROUGE मेट्रिक्स में सबसे अधिक मान दिखे। नीचे सभी चेकपॉइंट्स के साथ results फ़ोल्डर की सामग्री दी गई है:

“results” फ़ोल्डर की सामग्री

मॉडल इन्फ़रेंस

अब जबकि मॉडल फाइन-ट्यून किया जा चुका है, क्या इसे किसी वास्तविक जीवन परिदृश्य पर लागू करना अच्छा नहीं होगा?

यही तो मॉडल इन्फ़रेंस है। किसी मौजूदा मॉडल का उपयोग वास्तविक दुनिया की समस्या को हल करने के लिए करना—और यहाँ फाइन-ट्यून किए गए मॉडल के साथ यही किया जा रहा है।

उससे पहले, हमें कुछ चरण पूरे करने होंगे:

• अंतिम चेकपॉइंट के लिए फाइन-ट्यून किया गया मॉडल लोड करें

last_checkpoint = "./results/checkpoint-22500"

finetuned_model = T5ForConditionalGeneration.from_pretrained(last_checkpoint)
tokenizer = T5Tokenizer.from_pretrained(last_checkpoint)संचालित द्वारा

• उत्तर देने के लिए एक विशिष्ट प्रश्न परिभाषित करें

my_question = "What do you think about the benefit of Artificial Intelligence?"
inputs = "Please answer to this question: " + my_questionसंचालित द्वारा

• प्रीडिक्शन चलाएँ

inputs = tokenizer(inputs, return_tensors="pt")
outputs = finetuned_model.generate(**inputs)
answer = tokenizer.decode(outputs[0])
from textwrap import fill

print(fill(res, width=80))संचालित द्वारा

नीचे फाइन-ट्यून किए गए मॉडल का परिणाम दिया गया है, और यह काफी अच्छा दिखता है। साथ ही textwrap की fill विधि का उपयोग प्रति पंक्ति अधिकतम 80 अक्षरों तक सीमित करने के लिए किया जाता है, ताकि पूरा स्ट्रिंग एक ही पंक्ति में न आए।

प्रश्न पर फाइन-ट्यून किए गए मॉडल की प्रतिक्रिया

निष्कर्ष और आगे के कदम

इस लेख ने FLAN-T5 मॉडल को फाइन-ट्यून करने के लिए एक संपूर्ण मार्गदर्शिका प्रदान की है। सबसे पहले, इसने पाठक को मॉडल और उसके संभावित उपयोग मामलों की बेहतर समझ दी, फिर समग्र तकनीकी कार्यान्वयन से गुज़रा—Hugging Face से प्रयोगात्मक डेटा और मॉडल लोड करने से लेकर GPU पर मॉडल को प्रशिक्षित करने तक। ROUGE स्कोर के आधार पर सर्वश्रेष्ठ मॉडल का वास्तविक-जीवन परिदृश्य पर परीक्षण किया गया।

अब आगे कहाँ जाएँ?

हमारे लेख 12 GPT-4 ओपन-सोर्स विकल्प, और PyTorch के साथ एक LLM को कैसे प्रशिक्षित करें अपस्किलिंग के लिए उत्कृष्ट अगले कदम हो सकते हैं। पहला लेख GPT-4 के ओपन-सोर्स विकल्पों को उजागर करता है जो समान प्रदर्शन दे सकते हैं और चलाने के लिए कम गणनात्मक संसाधन मांगते हैं। इन प्रोजेक्ट्स के साथ निर्देश, कोड स्रोत, मॉडल वज़न, डेटासेट और चैटबॉट UI आते हैं।

दूसरा लेख पाठक को PyTorch का उपयोग करके बड़े भाषा मॉडलों को प्रशिक्षित करने की प्रक्रिया—आरंभिक सेटअप से लेकर अंतिम कार्यान्वयन तक—में पारंगत होने में मदद करता है। आप AI पेशेवरों द्वारा उपयोग किए जाने वाले शक्तिशाली डीप लर्निंग फ्रेमवर्क के साथ अपनी कौशल भी बढ़ा सकते हैं। आज ही Deep Learning with PyTorch कोर्स से जुड़ें।