اس نوٹ بک کو استعمال کرتے ہوئے متن کی درجہ بندی کے لیے GPT2 ماڈل کو ٹھیک کرنے کے لیے استعمال کیا جاتا ہے۔ گلے لگانے والا چہرہٹرانسفارمرز اپنی مرضی کے مطابق ڈیٹاسیٹ پر لائبریری۔
GPT2 کو درجہ بندی کے کاموں میں استعمال کرنے کے لیے درکار تمام فعالیتوں کو شامل کرنا ہمارے لیے گلے لگانے والا چہرہ بہت اچھا ہے۔ چہرے کو گلے لگانے کا شکریہ!
میں درجہ بندی کے لیے GPT2 کے استعمال کے بارے میں زیادہ معلومات حاصل کرنے کے قابل نہیں تھا لہذا میں نے دوسرے ٹرانسفارمرز ماڈلز کے ساتھ ملتے جلتے ڈھانچے کا استعمال کرتے ہوئے اس ٹیوٹوریل کو بنانے کا فیصلہ کیا۔
مرکزی خیال: چونکہ GPT2 ایک ڈیکوڈر ٹرانسفارمر ہے، اس لیے ان پٹ کی ترتیب کا آخری ٹوکن اگلے ٹوکن کے بارے میں پیشین گوئیاں کرنے کے لیے استعمال کیا جاتا ہے جو ان پٹ کی پیروی کرے۔ اس کا مطلب ہے کہ ان پٹ کی ترتیب کے آخری ٹوکن میں پیشین گوئی میں درکار تمام معلومات شامل ہیں۔ اس کو ذہن میں رکھتے ہوئے ہم اس معلومات کو جنریشن ٹاسک کے بجائے درجہ بندی کے کام میں پیشین گوئی کرنے کے لیے استعمال کر سکتے ہیں۔
دوسرے لفظوں میں، پیشین گوئی کرنے کے لیے پہلے ٹوکن ایمبیڈنگ کا استعمال کرنے کے بجائے جیسا کہ ہم Bert میں کرتے ہیں، ہم GPT2 کے ساتھ پیشین گوئی کرنے کے لیے آخری ٹوکن ایمبیڈنگ کا استعمال کریں گے۔
چونکہ ہم نے صرف برٹ میں پہلے ٹوکن کی پرواہ کی تھی، اس لیے ہم دائیں طرف پیڈنگ کر رہے تھے۔ اب GPT2 میں ہم پیشین گوئی کے لیے آخری ٹوکن استعمال کر رہے ہیں لہذا ہمیں بائیں جانب پیڈ کرنے کی ضرورت ہوگی۔ HuggingFace Transformers میں اچھے اپ گریڈ کی وجہ سے ہم GPT2 Tokenizer کو ایسا کرنے کے لیے کنفیگر کر سکتے ہیں۔
مجھے اس نوٹ بک کے لیے کیا معلوم ہونا چاہیے؟
چونکہ میں اپنے ٹرانسفارمرز کے ماڈلز کو ٹھیک کرنے کے لیے PyTorch کا استعمال کر رہا ہوں PyTorch پر کوئی بھی معلومات بہت مفید ہے۔
کے بارے میں تھوڑا سا جاننا ٹرانسفارمرز لائبریری بھی مدد کرتی ہے۔
اس نوٹ بک کو کیسے استعمال کیا جائے؟
ہر پروجیکٹ کی طرح، میں نے اس نوٹ بک کو دوبارہ قابل استعمال ذہن میں رکھ کر بنایا ہے۔
تمام تبدیلیاں ڈیٹا پروسیسنگ کے حصے میں ہوں گی جہاں آپ کو اپنے ڈیٹا کی ضروریات کو پورا کرنے کے لیے PyTorch Dataset، Data Collator اور DataLoader کو اپنی مرضی کے مطابق بنانا ہوگا۔
تمام پیرامیٹرز جو تبدیل کیے جاسکتے ہیں کے تحت ہیں۔ درآمدات سیکشن ہر پیرامیٹر کو اچھی طرح سے تبصرہ کیا گیا ہے اور ممکنہ حد تک بدیہی ہونے کے لئے تشکیل دیا گیا ہے۔
ڈیٹا بیس
یہ نوٹ بک ایک حسب ضرورت ڈیٹاسیٹ پر پہلے سے تربیت دینے والے ٹرانسفارمرز کا احاطہ کرے گی۔ میں معروف فلموں کے جائزے مثبت - منفی لیبل والے استعمال کروں گا۔ بڑی مووی ریویو ڈیٹا سیٹ.
سٹینفورڈ ویب سائٹ پر فراہم کردہ تفصیل:
یہ بائنری جذبات کی درجہ بندی کے لیے ایک ڈیٹا سیٹ ہے جس میں پچھلے بینچ مارک ڈیٹاسیٹس سے کافی زیادہ ڈیٹا ہوتا ہے۔ ہم تربیت کے لیے 25,000 انتہائی قطبی فلموں کے جائزوں کا ایک سیٹ فراہم کرتے ہیں، اور 25,000 جانچ کے لیے۔ استعمال کے لیے اضافی بغیر لیبل والا ڈیٹا بھی ہے۔ خام متن اور پہلے سے پروسیس شدہ الفاظ کی شکلیں فراہم کی جاتی ہیں۔ مزید تفصیلات کے لیے ریلیز میں موجود README فائل دیکھیں۔
یہ ڈیٹاسیٹ کیوں؟ میرا خیال ہے کہ درجہ بندی کے لیے ڈیٹا سیٹ کو سمجھنے اور استعمال کرنے میں آسان ہے۔ میرے خیال میں جذباتی اعداد و شمار کے ساتھ کام کرنے میں ہمیشہ مزہ آتا ہے۔
کوڈنگ
اب کچھ کوڈنگ کرتے ہیں! ہم نوٹ بک میں ہر کوڈنگ سیل کے ذریعے جائیں گے اور بیان کریں گے کہ یہ کیا کرتا ہے، کوڈ کیا ہے، اور کب متعلقہ ہے — آؤٹ پٹ دکھائیں گے۔
اگر آپ ہر کوڈ سیل کو اپنی ازگر کی نوٹ بک میں چلانے کا فیصلہ کرتے ہیں تو میں نے اس فارمیٹ کی پیروی کرنا آسان بنا دیا ہے۔
جب میں کسی ٹیوٹوریل سے سیکھتا ہوں تو میں ہمیشہ نتائج کو نقل کرنے کی کوشش کرتا ہوں۔ مجھے یقین ہے کہ اگر آپ کے پاس وضاحت کے ساتھ کوڈ ہے تو اس کی پیروی کرنا آسان ہے۔
ڈاؤن لوڈز
ڈاؤن لوڈ، اتارنا بڑی مووی ریویو ڈیٹا سیٹ اور اسے مقامی طور پر ان زپ کریں۔
Download the dataset.
!wget -q -nc http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
Unzip the dataset.
!tar -zxf /content/aclImdb_v1.tar.gz
انسٹال
ٹرانسفارمرز Hugging Face سے تمام زبردست کوڈ استعمال کرنے کے لیے لائبریری کو انسٹال کرنے کی ضرورت ہے۔ تازہ ترین ورژن حاصل کرنے کے لیے میں اسے سیدھا GitHub سے انسٹال کروں گا۔
ml_چیزیں لائبریری مشین لرننگ سے متعلق مختلف کاموں کے لیے استعمال ہوتی ہے۔ میں نے اس لائبریری کو ہر مشین لرننگ پروجیکٹ کے لیے لکھنے کے لیے کوڈ کی مقدار کو کم کرنے کے لیے بنایا ہے۔
Installing build dependencies ... done Getting requirements to build wheel ... done Preparing wheel metadata ... done |████████████████████████████████| 2.9MB 6.7MB/s |████████████████████████████████| 890kB 48.9MB/s |████████████████████████████████| 1.1MB 49.0MB/s Building wheelfor transformers (PEP 517) ... done Building wheel for sacremoses (setup.py) ... done |████████████████████████████████| 71kB 5.2MB/s Building wheel for ml-things (setup.py) ... done Building wheel for ftfy (setup.py) ... done
درآمدات
اس نوٹ بک کے لیے تمام ضروری لائبریریاں درآمد کریں۔ اس نوٹ بک کے لیے استعمال کیے گئے پیرامیٹرز کا اعلان کریں:
set_seed(123) - تولیدی صلاحیت کے لیے ایک مقررہ بیج لگانا ہمیشہ اچھا ہے۔
epochs - تربیتی دوروں کی تعداد (مصنفین 2 اور 4 کے درمیان تجویز کرتے ہیں)۔
batch_size - بیچوں کی تعداد - زیادہ سے زیادہ ترتیب کی لمبائی اور GPU میموری پر منحصر ہے۔ 512 ترتیب کی لمبائی کے لیے 10 کا ایک بیچ عام طور پر cuda میموری کے مسائل کے بغیر کام کرتا ہے۔ چھوٹے ترتیب کی لمبائی کے لیے 32 یا اس سے زیادہ کے بیچ کو آزما سکتے ہیں۔ max_length - پیڈ یا متن کی ترتیب کو ایک مخصوص لمبائی تک چھوٹا کریں۔ میں تربیت کو تیز کرنے کے لیے اسے 60 پر سیٹ کروں گا۔
device - استعمال کرنے کے لیے جی پی یو تلاش کریں۔ اگر کوئی جی پی یو نہیں ملا تو سی پی یو کو بطور ڈیفالٹ استعمال کریں گے۔
model_name_or_path - ٹرانسفارمرز ماڈل کا نام - پہلے سے تربیت یافتہ ماڈل استعمال کرے گا۔ ٹرانسفارمر ماڈل کا راستہ - مقامی ڈسک سے آپ کا اپنا ماڈل لوڈ کرے گا۔ اس ٹیوٹوریل میں میں استعمال کروں گا۔ gpt2 ماڈل.
labels_ids - لیبلز کی لغت اور ان کی شناخت - اس کا استعمال سٹرنگ لیبلز کو نمبروں میں تبدیل کرنے کے لیے کیا جائے گا۔
n_labels - ہم اس ڈیٹاسیٹ میں کتنے لیبل استعمال کر رہے ہیں۔ اس کا استعمال درجہ بندی کے سر کے سائز کا فیصلہ کرنے کے لیے کیا جاتا ہے۔
import io
import os
import torch
from tqdm.notebook import tqdm
from torch.utils.data import Dataset, DataLoader
from ml_things import plot_dict, plot_confusion_matrix, fix_text
from sklearn.metrics import classification_report, accuracy_score
from transformers import (set_seed, TrainingArguments, Trainer, GPT2Config, GPT2Tokenizer, AdamW, get_linear_schedule_with_warmup, GPT2ForSequenceClassification) # Set seed for reproducibility.
set_seed(123) # Number of training epochs (authors on fine-tuning Bert recommend between 2 and 4).
epochs = 4 # Number of batches - depending on the max sequence length and GPU memory.
# For 512 sequence length batch of 10 works without cuda memory issues.
# For small sequence length can try batch of 32 or higher.
batch_size = 32 # Pad or truncate text sequences to a specific length
# if `None` it will use maximum sequence of word piece tokens allowed by model.
max_length = 60 # Look for gpu to use. Will use `cpu` by default if no gpu found.
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Name of transformers model - will use already pretrained model.
# Path of transformer model - will load your own model from local disk.
model_name_or_path = 'gpt2' # Dictionary of labels and their id - this will be used to convert.
# String labels to number ids.
labels_ids = {'neg': 0, 'pos': 1} # How many labels are we using in training.
# This is used to decide size of classification head.
n_labels = len(labels_ids)
مددگار افعال
میں ان تمام کلاسز اور فنکشنز کو رکھنا چاہتا ہوں جو اس نوٹ بک میں اس سیکشن کے تحت استعمال کیے جائیں گے تاکہ نوٹ بک کی صاف شکل برقرار رکھنے میں مدد ملے:
MovieReviewsDataset(Dataset)
اگر آپ نے پہلے PyTorch کے ساتھ کام کیا ہے، تو یہ بہت معیاری ہے۔ ہمیں اپنے ڈیٹاسیٹ میں پڑھنے، اسے پارس کرنے اور متن کو ان کے متعلقہ لیبلز کے ساتھ واپس کرنے کے لیے اس کلاس کی ضرورت ہے۔
اس کلاس میں مجھے صرف ہر فائل کے مواد کو پڑھنے کی ضرورت ہے، کسی بھی یونی کوڈ کے مسائل کو حل کرنے کے لیے fix_text کا استعمال کریں اور مثبت اور منفی جذبات پر نظر رکھیں۔
میں فہرستوں میں تمام متن اور لیبل شامل کروں گا۔
اس PyTorch ڈیٹا سیٹ کلاس کے تین اہم حصے ہیں:
اس میں() جہاں ہم ڈیٹاسیٹ میں پڑھتے ہیں اور متن اور لیبلز کو نمبروں میں تبدیل کرتے ہیں۔
لین () جہاں ہمیں ان مثالوں کی تعداد واپس کرنے کی ضرورت ہے جو ہم پڑھتے ہیں۔ یہ len(MovieReviewsDataset()) کو کال کرتے وقت استعمال ہوتا ہے۔
getitem() ہمیشہ ایک ان پٹ کے طور پر ایک int ویلیو لیتا ہے جو اس بات کی نمائندگی کرتا ہے کہ ہماری مثالوں میں سے کون سی مثال ہمارے ڈیٹاسیٹ سے واپس آنی ہے۔ اگر 3 کی قدر گزر جاتی ہے، تو ہم اپنے ڈیٹاسیٹ کی مثال کو پوزیشن 3 پر واپس کریں گے۔
class MovieReviewsDataset(Dataset): r"""PyTorch Dataset class for loading data. This is where the data parsing happens. This class is built with reusability in mind: it can be used as is as. Arguments: path (:obj:`str`): Path to the data partition. """ def __init__(self, path, use_tokenizer): # Check if path exists. if not os.path.isdir(path): # Raise error if path is invalid. raise ValueError('Invalid `path` variable! Needs to be a directory') self.texts = [] self.labels = [] # Since the labels are defined by folders with data we loop # through each label. for label in ['pos', 'neg']: sentiment_path = os.path.join(path, label) # Get all files from path. files_names = os.listdir(sentiment_path)#[:10] # Sample for debugging. # Go through each file and read its content. for file_name in tqdm(files_names, desc=f'{label} files'): file_path = os.path.join(sentiment_path, file_name) # Read content. content = io.open(file_path, mode='r', encoding='utf-8').read() # Fix any unicode issues. content = fix_text(content) # Save content. self.texts.append(content) # Save encode labels. self.labels.append(label) # Number of exmaples. self.n_examples = len(self.labels) return def __len__(self): r"""When used `len` return the number of examples. """ return self.n_examples def __getitem__(self, item): r"""Given an index return an example from the position. Arguments: item (:obj:`int`): Index position to pick an example to return. Returns: :obj:`Dict[str, str]`: Dictionary of inputs that contain text and asociated labels. """ return {'text':self.texts[item], 'label':self.labels[item]}
Gpt2ClassificationCollator
میں اس کلاس کو ڈیٹا کولیٹر بنانے کے لیے استعمال کرتا ہوں۔ یہ ڈیٹا لوڈر میں ڈیٹا کے غسل بنانے کے لیے استعمال کیا جائے گا جو ماڈل کو کھلایا جاتا ہے۔ میں متن اور لیبل کو نمبر میں تبدیل کرنے کے لیے ہر ترتیب پر ٹوکنائزر اور لیبل انکوڈر کا استعمال کرتا ہوں۔
ہمارے لیے خوش قسمت ہے، Hugging Face نے ہر چیز کے بارے میں سوچا اور ٹوکنائزر کو تمام بھاری لفٹنگ (ٹیکسٹ کو ٹوکنز، پیڈنگ، تراشنا، نمبروں میں متن کو انکوڈ کرنا) کرنے پر مجبور کیا اور استعمال کرنا بہت آسان ہے!
اس ڈیٹا کولیٹر کلاس کے دو اہم حصے ہیں:
اس میں() جہاں ہم ٹوکنائزر کو شروع کرتے ہیں جسے ہم استعمال کرنے کا ارادہ رکھتے ہیں، اپنے لیبلز کو کیسے انکوڈ کریں اور اگر ہمیں ترتیب کی لمبائی کو مختلف قدر پر سیٹ کرنے کی ضرورت ہے۔
کال () فنکشن کولیٹر کے طور پر استعمال کیا جاتا ہے جو ڈیٹا کی مثالوں کے بیچ کو بطور ان پٹ لیتا ہے۔ اسے اس فارمیٹ کے ساتھ ایک آبجیکٹ واپس کرنے کی ضرورت ہے جسے ہمارے ماڈل میں فیڈ کیا جا سکتا ہے۔ خوش قسمتی سے ہمارا ٹوکنائزر ہمارے لیے ایسا کرتا ہے اور اس طرح ماڈل کو فیڈ کیے جانے کے لیے تیار متغیرات کی لغت واپس کرتا ہے: model(**inputs). چونکہ ہم ماڈل کو ٹھیک کر رہے ہیں میں نے لیبل بھی شامل کیے ہیں۔
class Gpt2ClassificationCollator(object): r""" Data Collator used for GPT2 in a classificaiton rask. It uses a given tokenizer and label encoder to convert any text and labels to numbers that can go straight into a GPT2 model. This class is built with reusability in mind: it can be used as is as long as the `dataloader` outputs a batch in dictionary format that can be passed straight into the model - `model(**batch)`. Arguments: use_tokenizer (:obj:`transformers.tokenization_?`): Transformer type tokenizer used to process raw text into numbers. labels_ids (:obj:`dict`): Dictionary to encode any labels names into numbers. Keys map to labels names and Values map to number associated to those labels. max_sequence_len (:obj:`int`, `optional`) Value to indicate the maximum desired sequence to truncate or pad text sequences. If no value is passed it will used maximum sequence size supported by the tokenizer and model. """ def __init__(self, use_tokenizer, labels_encoder, max_sequence_len=None): # Tokenizer to be used inside the class. self.use_tokenizer = use_tokenizer # Check max sequence length. self.max_sequence_len = use_tokenizer.model_max_length if max_sequence_len is None else max_sequence_len # Label encoder used inside the class. self.labels_encoder = labels_encoder return def __call__(self, sequences): r""" This function allowes the class objesct to be used as a function call. Sine the PyTorch DataLoader needs a collator function, I can use this class as a function. Arguments: item (:obj:`list`): List of texts and labels. Returns: :obj:`Dict[str, object]`: Dictionary of inputs that feed into the model. It holddes the statement `model(**Returned Dictionary)`. """ # Get all texts from sequences list. texts = [sequence['text'] for sequence in sequences] # Get all labels from sequences list. labels = [sequence['label'] for sequence in sequences] # Encode all labels using label encoder. labels = [self.labels_encoder[label] for label in labels] # Call tokenizer on all texts to convert into tensors of numbers with # appropriate padding. inputs = self.use_tokenizer(text=texts, return_tensors="pt", padding=True, truncation=True, max_length=self.max_sequence_len) # Update the inputs with the associated encoded labels as tensor. inputs.update({'labels':torch.tensor(labels)}) return inputs
ٹرین (ڈیٹا لوڈر، آپٹیمائزر_، شیڈولر_، ڈیوائس_)
میں نے یہ فنکشن ڈیٹا لوڈر آبجیکٹ کے ذریعے مکمل پاس کرنے کے لیے بنایا ہے (DataLoader آبجیکٹ **MovieReviewsDataset کلاس کا استعمال کرتے ہوئے ہمارے Dataset* ٹائپ آبجیکٹ سے بنایا گیا ہے)۔ یہ بنیادی طور پر پورے ڈیٹاسیٹ کے ذریعے ایک دور کی ٹرین ہے۔
ڈیٹا لوڈر PyTorch DataLoader سے بنایا گیا ہے جو MovieReviewsDataset کلاس سے تخلیق کردہ آبجیکٹ لیتا ہے اور ہر مثال کو بیچوں میں رکھتا ہے۔ اس طرح ہم ڈیٹا کے اپنے ماڈل بیچز کو فیڈ کر سکتے ہیں!
PyTorch میں آپٹمائزر_ اور شیڈولر_ بہت عام ہیں۔ انہیں تربیت کے دوران ہمارے ماڈل کے پیرامیٹرز کو اپ ڈیٹ کرنے اور ہماری سیکھنے کی شرح کو اپ ڈیٹ کرنے کی ضرورت ہے۔ اس کے علاوہ بھی بہت کچھ ہے لیکن میں تفصیل میں نہیں جاؤں گا۔ یہ درحقیقت ایک بہت بڑا خرگوش ہول ہو سکتا ہے کیونکہ ان افعال کے پیچھے بہت کچھ ہوتا ہے جس کی ہمیں فکر کرنے کی ضرورت نہیں ہے۔ آپ کا شکریہ PyTorch!
اس عمل میں ہم نقصان کے ساتھ اصل لیبلز اور پیشین گوئی شدہ لیبلز کا ٹریک رکھتے ہیں۔
def train(dataloader, optimizer_, scheduler_, device_): r""" Train pytorch model on a single pass through the data loader. It will use the global variable `model` which is the transformer model loaded on `_device` that we want to train on. This function is built with reusability in mind: it can be used as is as long as the `dataloader` outputs a batch in dictionary format that can be passed straight into the model - `model(**batch)`. Arguments: dataloader (:obj:`torch.utils.data.dataloader.DataLoader`): Parsed data into batches of tensors. optimizer_ (:obj:`transformers.optimization.AdamW`): Optimizer used for training. scheduler_ (:obj:`torch.optim.lr_scheduler.LambdaLR`): PyTorch scheduler. device_ (:obj:`torch.device`): Device used to load tensors before feeding to model. Returns: :obj:`List[List[int], List[int], float]`: List of [True Labels, Predicted Labels, Train Average Loss]. """ # Use global variable for model. global model # Tracking variables. predictions_labels = [] true_labels = [] # Total loss for this epoch. total_loss = 0 # Put the model into training mode. model.train() # For each batch of training data... for batch in tqdm(dataloader, total=len(dataloader)): # Add original labels - use later for evaluation. true_labels += batch['labels'].numpy().flatten().tolist() # move batch to device batch = {k:v.type(torch.long).to(device_) for k,v in batch.items()} # Always clear any previously calculated gradients before performing a # backward pass. model.zero_grad() # Perform a forward pass (evaluate the model on this training batch). # This will return the loss (rather than the model output) because we # have provided the `labels`. # The documentation for this a bert model function is here: # https://huggingface.co/transformers/v2.2.0/model_doc/bert.html#transformers.BertForSequenceClassification outputs = model(**batch) # The call to `model` always returns a tuple, so we need to pull the # loss value out of the tuple along with the logits. We will use logits # later to calculate training accuracy. loss, logits = outputs[:2] # Accumulate the training loss over all of the batches so that we can # calculate the average loss at the end. `loss` is a Tensor containing a # single value; the `.item()` function just returns the Python value # from the tensor. total_loss += loss.item() # Perform a backward pass to calculate the gradients. loss.backward() # Clip the norm of the gradients to 1.0. # This is to help prevent the "exploding gradients" problem. torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) # Update parameters and take a step using the computed gradient. # The optimizer dictates the "update rule"--how the parameters are # modified based on their gradients, the learning rate, etc. optimizer.step() # Update the learning rate. scheduler.step() # Move logits and labels to CPU logits = logits.detach().cpu().numpy() # Convert these logits to list of predicted labels values. predictions_labels += logits.argmax(axis=-1).flatten().tolist() # Calculate the average loss over the training data. avg_epoch_loss = total_loss / len(dataloader) # Return all true labels and prediction for future evaluations. return true_labels, predictions_labels, avg_epoch_loss
توثیق (ڈیٹا لوڈر، آلہ_)
میں نے اس فنکشن کو ٹرین کی طرح بالکل اسی طرح لاگو کیا لیکن پیرامیٹرز اپ ڈیٹ، پسماندہ پاس اور گریڈینٹ مہذب حصے کے بغیر۔ ہمیں ان تمام کاموں کو بہت زیادہ کمپیوٹیشنل کرنے کی ضرورت نہیں ہے کیونکہ ہم صرف اپنے ماڈل کی پیشین گوئیوں کی پرواہ کرتے ہیں۔
میں ڈیٹا لوڈر کو اسی طرح استعمال کرتا ہوں جیسے ٹرین میں اپنے ماڈل کو کھانا کھلانے کے لیے بیچ نکالنے کے لیے۔
اس عمل میں میں نقصان کے ساتھ ساتھ اصل لیبلز اور پیشین گوئی شدہ لیبلز کا ٹریک رکھتا ہوں۔
def validation(dataloader, device_): r"""Validation function to evaluate model performance on a separate set of data. This function will return the true and predicted labels so we can use later to evaluate the model's performance. This function is built with reusability in mind: it can be used as is as long as the `dataloader` outputs a batch in dictionary format that can be passed straight into the model - `model(**batch)`. Arguments: dataloader (:obj:`torch.utils.data.dataloader.DataLoader`): Parsed data into batches of tensors. device_ (:obj:`torch.device`): Device used to load tensors before feeding to model. Returns: :obj:`List[List[int], List[int], float]`: List of [True Labels, Predicted Labels, Train Average Loss] """ # Use global variable for model. global model # Tracking variables predictions_labels = [] true_labels = [] #total loss for this epoch. total_loss = 0 # Put the model in evaluation mode--the dropout layers behave differently # during evaluation. model.eval() # Evaluate data for one epoch for batch in tqdm(dataloader, total=len(dataloader)): # add original labels true_labels += batch['labels'].numpy().flatten().tolist() # move batch to device batch = {k:v.type(torch.long).to(device_) for k,v in batch.items()} # Telling the model not to compute or store gradients, saving memory and # speeding up validation with torch.no_grad(): # Forward pass, calculate logit predictions. # This will return the logits rather than the loss because we have # not provided labels. # token_type_ids is the same as the "segment ids", which # differentiates sentence 1 and 2 in 2-sentence tasks. # The documentation for this `model` function is here: # https://huggingface.co/transformers/v2.2.0/model_doc/bert.html#transformers.BertForSequenceClassification outputs = model(**batch) # The call to `model` always returns a tuple, so we need to pull the # loss value out of the tuple along with the logits. We will use logits # later to to calculate training accuracy. loss, logits = outputs[:2] # Move logits and labels to CPU logits = logits.detach().cpu().numpy() # Accumulate the training loss over all of the batches so that we can # calculate the average loss at the end. `loss` is a Tensor containing a # single value; the `.item()` function just returns the Python value # from the tensor. total_loss += loss.item() # get predicitons to list predict_content = logits.argmax(axis=-1).flatten().tolist() # update list predictions_labels += predict_content # Calculate the average loss over the training data. avg_epoch_loss = total_loss / len(dataloader) # Return all true labels and prediciton for future evaluations. return true_labels, predictions_labels, avg_epoch_loss
ماڈل اور ٹوکنائزر لوڈ کریں۔
پہلے سے تربیت یافتہ GPT2 ٹرانسفارمر کے تین ضروری حصوں کو لوڈ کرنا: کنفیگریشن، ٹوکنائزر اور ماڈل۔
اس مثال کے لیے میں استعمال کروں گا۔ gpt2 HuggingFace پہلے سے تربیت یافتہ ٹرانسفارمرز سے۔ آپ GP2 کی کوئی بھی مختلف حالتیں استعمال کر سکتے ہیں جو آپ چاہتے ہیں۔
پیدا کرنے میں model_config میں اپنے درجہ بندی کے کام کے لیے درکار لیبلز کی تعداد کا ذکر کروں گا۔ چونکہ میں صرف دو جذبات کی پیش گوئی کرتا ہوں: مثبت اور منفی مجھے صرف دو لیبلز کی ضرورت ہوگی۔ num_labels.
کی تشکیل tokenizer ٹرانسفارمرز لائبریری کا استعمال کرتے وقت بہت معیاری ہے۔ ٹوکنائزر بنانے کے بعد اس ٹیوٹوریل کے لیے پیڈنگ کو بائیں جانب سیٹ کرنا ضروری ہے۔ tokenizer.padding_side = "left" اور پیڈنگ ٹوکن کو شروع کریں۔ tokenizer.eos_token جو کہ GPT2 کی ترتیب ٹوکن کا اصل اختتام ہے۔ یہ اس ٹیوٹوریل کا سب سے ضروری حصہ ہے کیونکہ GPT2 پیشین گوئی کے لیے آخری ٹوکن استعمال کرتا ہے لہذا ہمیں بائیں طرف پیڈ کرنے کی ضرورت ہے۔
HuggingFace نے پہلے ہی ہمارے لئے زیادہ تر کام کیا ہے اور GPT2 ماڈل میں درجہ بندی کی پرت شامل کی ہے۔ ماڈل بنانے میں جو میں نے استعمال کیا۔ GPT2ForSequenceClassification. چونکہ ہمارے پاس ایک حسب ضرورت پیڈنگ ٹوکن ہے ہمیں اسے استعمال کرنے والے ماڈل کے لیے شروع کرنے کی ضرورت ہے۔ model.config.pad_token_id. آخر میں ہمیں ماڈل کو اس ڈیوائس میں منتقل کرنے کی ضرورت ہوگی جس کی ہم نے پہلے وضاحت کی تھی۔
# Get model configuration.
print('Loading configuraiton...')
model_config = GPT2Config.from_pretrained(pretrained_model_name_or_path=model_name_or_path, num_labels=n_labels) # Get model's tokenizer.
print('Loading tokenizer...')
tokenizer = GPT2Tokenizer.from_pretrained(pretrained_model_name_or_path=model_name_or_path)
# default to left padding
tokenizer.padding_side = "left"
# Define PAD Token = EOS Token = 50256
tokenizer.pad_token = tokenizer.eos_token # Get the actual model.
print('Loading model...')
model = GPT2ForSequenceClassification.from_pretrained(pretrained_model_name_or_path=model_name_or_path, config=model_config) # resize model embedding to match new tokenizer
model.resize_token_embeddings(len(tokenizer)) # fix model padding token id
model.config.pad_token_id = model.config.eos_token_id # Load model to defined device.
model.to(device)
print('Model loaded to `%s`'%device)
Loading configuraiton... Loading tokenizer... Loading model... Some weights of GPT2ForSequenceClassification were not initialized from the model checkpoint at gpt2 and are newly initialized: ['score.weight'] You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference. Model loaded to `cuda`
ڈیٹاسیٹ اور کولیٹر
یہ وہ جگہ ہے جہاں میں ڈیٹا کولیٹر آبجیکٹ کے ساتھ PyTorch ڈیٹا سیٹ اور ڈیٹا لوڈر بناتا ہوں جو ہمارے ماڈل میں ڈیٹا فیڈ کرنے کے لیے استعمال ہوں گے۔
یہ وہ جگہ ہے جہاں میں استعمال کرتا ہوں۔ مووی ریویو ڈیٹاسیٹ کلاس PyTorch ڈیٹاسیٹ بنانے کے لیے جو متن اور لیبل واپس کرے گا۔
چونکہ ہمیں اپنے ماڈل میں نمبر داخل کرنے کی ضرورت ہے ہمیں متن اور لیبل کو نمبروں میں تبدیل کرنے کی ضرورت ہے۔ یہ ایک کولیٹر کا مقصد ہے! یہ PyTorch ڈیٹاسیٹ کے ذریعہ آؤٹ پٹ ڈیٹا لیتا ہے اور ہمارے ماڈل کی ترتیب کو آؤٹ پٹ کرنے کے لئے ڈیٹا کولیٹر فنکشن سے گزرتا ہے۔
کوڈ کو صاف ستھرا اور بہتر ڈھانچہ بنانے کے لیے میں ٹوکنائزر کو PyTorch ڈیٹا سیٹ سے دور رکھ رہا ہوں۔ آپ واضح طور پر ٹوکنائزر کو PyTorch ڈیٹاسیٹ اور آؤٹ پٹ سیکونسز کے اندر استعمال کر سکتے ہیں جو ڈیٹا کولیٹر کا استعمال کیے بغیر سیدھے ماڈل میں استعمال کیا جا سکتا ہے۔
میں اس بات کا تعین کرنے کے لیے ایک توثیق ٹیکسٹ فائل استعمال کرنے کی پرزور سفارش کرتا ہوں کہ زیادہ فٹنگ سے بچنے کے لیے کتنی تربیت کی ضرورت ہے۔ یہ جاننے کے بعد کہ کون سے پیرامیٹرز بہترین نتائج دیتے ہیں، توثیق کی فائل کو ٹرین میں شامل کیا جا سکتا ہے اور پورے ڈیٹا سیٹ کے ساتھ ایک حتمی ٹرین چلائی جا سکتی ہے۔
ڈیٹا کولیٹر کا استعمال PyTorch ڈیٹا سیٹ آؤٹ پٹس کو فارمیٹ کرنے کے لیے کیا جاتا ہے تاکہ GPT2 کے لیے درکار ان پٹ سے مماثل ہو۔
# Create data collator to encode text and labels into numbers.
gpt2_classificaiton_collator = Gpt2ClassificationCollator(use_tokenizer=tokenizer, labels_encoder=labels_ids, max_sequence_len=max_length) print('Dealing with Train...')
# Create pytorch dataset.
train_dataset = MovieReviewsDataset(path='/content/aclImdb/train', use_tokenizer=tokenizer)
print('Created `train_dataset` with %d examples!'%len(train_dataset)) # Move pytorch dataset into dataloader.
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=gpt2_classificaiton_collator)
print('Created `train_dataloader` with %d batches!'%len(train_dataloader)) print() print('Dealing with Validation...')
# Create pytorch dataset.
valid_dataset = MovieReviewsDataset(path='/content/aclImdb/test', use_tokenizer=tokenizer)
print('Created `valid_dataset` with %d examples!'%len(valid_dataset)) # Move pytorch dataset into dataloader.
valid_dataloader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False, collate_fn=gpt2_classificaiton_collator)
print('Created `eval_dataloader` with %d batches!'%len(valid_dataloader))
Dealing with Train... pos files: 100%|████████████████████████████████|12500/12500 [01:17<00:00, 161.19it/s] neg files: 100%|████████████████████████████████|12500/12500 [01:05<00:00, 190.72it/s] Created `train_dataset` with 25000 examples! Created `train_dataloader` with 782 batches! Reading pos files... pos files: 100%|████████████████████████████████|12500/12500 [00:54<00:00, 230.93it/s] neg files: 100%|████████████████████████████████|12500/12500 [00:42<00:00, 291.07it/s] Created `valid_dataset` with 25000 examples! Created `eval_dataloader` with 782 batches!
ٹرین
میں نے تربیت میں PyTorch کے ذریعہ آپٹیمائزر اور شیڈیولر استعمال کیا۔ میں نے سب سے زیادہ عام پیرامیٹرز استعمال کیے ہیں جو ٹرانسفارمرز ماڈلز استعمال کرتے ہیں۔
میں نے متعین عہدوں کی تعداد کے ذریعے لوپ کیا اور کال کی۔ ٹرین اور توثیق کام کرتا ہے.
میں ہر دور کے بعد کیراس کی طرح اسی طرح کی معلومات کو آؤٹ پٹ کرنے کی کوشش کر رہا ہوں: train_loss: — val_loss: — train_acc: — valid_acc.
ٹریننگ کے بعد پلاٹ ٹرین اور توثیق کے نقصان اور درستگی کے منحنی خطوط کو چیک کریں کہ تربیت کیسے چلی۔
نوٹ:تربیتی پلاٹ کچھ عجیب لگ سکتے ہیں: توثیق کی درستگی تربیت کی درستگی سے زیادہ شروع ہوتی ہے اور توثیق کا نقصان تربیتی نقصان سے کم شروع ہوتا ہے۔ عام طور پر اس کے برعکس ہوگا۔ میں فرض کرتا ہوں کہ ڈیٹا کی تقسیم توثیق کے حصے کے لیے آسان یا تربیتی حصے یا دونوں کے لیے بہت مشکل ہے۔ چونکہ یہ ٹیوٹوریل درجہ بندی کے لیے GPT2 استعمال کرنے کے بارے میں ہے میں ماڈل کے نتائج کے بارے میں زیادہ فکر نہیں کروں گا۔
# Note: AdamW is a class from the huggingface library (as opposed to pytorch) # I believe the 'W' stands for 'Weight Decay fix"
optimizer = AdamW(model.parameters(), lr = 2e-5, # default is 5e-5, our notebook had 2e-5 eps = 1e-8 # default is 1e-8. ) # Total number of training steps is number of batches * number of epochs.
# `train_dataloader` contains batched data so `len(train_dataloader)` gives # us the number of batches.
total_steps = len(train_dataloader) * epochs # Create the learning rate scheduler.
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps = 0, # Default value in run_glue.py num_training_steps = total_steps) # Store the average loss after each epoch so we can plot them.
all_loss = {'train_loss':[], 'val_loss':[]}
all_acc = {'train_acc':[], 'val_acc':[]} # Loop through each epoch.
print('Epoch')
for epoch in tqdm(range(epochs)): print() print('Training on batches...') # Perform one full pass over the training set. train_labels, train_predict, train_loss = train(train_dataloader, optimizer, scheduler, device) train_acc = accuracy_score(train_labels, train_predict) # Get prediction form model on validation data. print('Validation on batches...') valid_labels, valid_predict, val_loss = validation(valid_dataloader, device) val_acc = accuracy_score(valid_labels, valid_predict) # Print loss and accuracy values to see how training evolves. print(" train_loss: %.5f - val_loss: %.5f - train_acc: %.5f - valid_acc: %.5f"%(train_loss, val_loss, train_acc, val_acc)) print() # Store the loss value for plotting the learning curve. all_loss['train_loss'].append(train_loss) all_loss['val_loss'].append(val_loss) all_acc['train_acc'].append(train_acc) all_acc['val_acc'].append(val_acc) # Plot loss curves.
plot_dict(all_loss, use_xlabel='Epochs', use_ylabel='Value', use_linestyles=['-', '--']) # Plot accuracy curves.
plot_dict(all_acc, use_xlabel='Epochs', use_ylabel='Value', use_linestyles=['-', '--'])
Epoch 100%|████████████████████████████████|4/4 [15:11<00:00, 227.96s/it] Training on batches... 100%|████████████████████████████████|782/782 [02:42<00:00, 4.82it/s] Validation on batches... 100%|████████████████████████████████|782/782 [02:07<00:00, 6.13it/s] train_loss: 0.54128 - val_loss: 0.38758 - train_acc: 0.75288 - valid_acc: 0.81904 Training on batches... 100%|████████████████████████████████|782/782 [02:36<00:00, 5.00it/s] Validation on batches... 100%|████████████████████████████████|782/782 [01:41<00:00, 7.68it/s] train_loss: 0.36716 - val_loss: 0.37620 - train_acc: 0.83288 -valid_acc: 0.82912 Training on batches... 100%|████████████████████████████████|782/782 [02:36<00:00, 5.00it/s] Validation on batches... 100%|████████████████████████████████|782/782 [01:24<00:00, 9.24it/s] train_loss: 0.31409 - val_loss: 0.39384 - train_acc: 0.86304 - valid_acc: 0.83044 Training on batches... 100%|████████████████████████████████|782/782 [02:36<00:00, 4.99it/s] Validation on batches... 100%|████████████████████████████████|782/782 [01:09<00:00, 11.29it/s] train_loss: 0.27358 - val_loss: 0.39798 - train_acc: 0.88432 - valid_acc: 0.83292
ٹرین اور توثیق کا نقصان۔
ٹرین اور توثیق کی درستگی.
اندازہ
درجہ بندی کے ساتھ کام کرتے وقت صحت سے متعلق یادداشت اور F1 سکور کو دیکھنا مفید ہے۔
کسی ماڈل کی جانچ کرتے وقت ایک اچھا گیج کنفیوژن میٹرکس ہے۔
# Get prediction form model on validation data. This is where you should use
# your test data.
true_labels, predictions_labels, avg_epoch_loss = validation(valid_dataloader, device) # Create the evaluation report.
evaluation_report = classification_report(true_labels, predictions_labels, labels=list(labels_ids.values()), target_names=list(labels_ids.keys()))
# Show the evaluation report.
print(evaluation_report) # Plot confusion matrix.
plot_confusion_matrix(y_true=true_labels, y_pred=predictions_labels, classes=list(labels_ids.keys()), normalize=True, magnify=0.1, );
اگر آپ نے اسے یہاں تک پہنچایا مبارک ہو! 🎊 اور آپ کا شکریہ! 🙏 میرے ٹیوٹوریل میں آپ کی دلچسپی کے لیے!
میں ابھی کچھ عرصے سے اس کوڈ کو استعمال کر رہا ہوں اور مجھے لگتا ہے کہ یہ اس مقام پر پہنچ گیا ہے جہاں اچھی طرح سے دستاویزی اور پیروی کرنا آسان ہے۔
یقیناً میرے لیے پیروی کرنا آسان ہے کیونکہ میں نے اسے بنایا ہے۔ اس لیے کسی بھی رائے کا خیرمقدم کیا جاتا ہے اور اس سے مجھے اپنے مستقبل کے سبق کو بہتر بنانے میں مدد ملتی ہے!
اگر آپ کو کچھ غلط نظر آتا ہے تو براہ کرم میرے پر ایک مسئلہ کھول کر مجھے بتائیں ml_things GitHub ذخیرہ!
وہاں موجود بہت سارے ٹیوٹوریلز زیادہ تر ایک وقتی چیز ہیں اور ان کو برقرار نہیں رکھا جا رہا ہے۔ میں اپنے ٹیوٹوریلز کو زیادہ سے زیادہ تازہ ترین رکھنے کا ارادہ رکھتا ہوں۔
یہ مضمون اصل میں شائع کیا گیا تھا جارج میہائلا کی ذاتی ویب سائٹ اور مصنف کی اجازت سے TOPBOTS پر دوبارہ شائع کیا گیا۔
اس مضمون کا لطف اٹھائیں؟ مزید AI اپ ڈیٹس کے لیے سائن اپ کریں۔
جب ہم مزید تکنیکی تعلیم جاری کریں گے تو ہم آپ کو بتائیں گے۔
