🕊️ 🤳 💆🏻 सरल BERT आसवन गाइड 🖊️ 🎅 🆚

यदि आप मशीन सीखने में रुचि रखते हैं, तो आपने शायद BERT और ट्रांसफार्मर के बारे में सुना होगा।

BERT Google का एक भाषा मॉडल है, जो कई कार्यों पर एक व्यापक मार्जिन द्वारा अत्याधुनिक परिणाम दिखाता है। बीईआरटी, और आमतौर पर ट्रांसफार्मर, प्राकृतिक भाषा प्रसंस्करण एल्गोरिदम (एनएलपी) के विकास में एक पूरी तरह से नया कदम बन गए हैं। उनके बारे में लेख और विभिन्न बेंचमार्क के लिए "स्टैंडिंग" को Papers With Code वेबसाइट पर पाया जा सकता है।

बीईआरटी के साथ एक समस्या है: यह औद्योगिक प्रणालियों में उपयोग करने के लिए समस्याग्रस्त है। बीईआरटी-बेस में 110 एम पैरामीटर, बीईआरटी-बड़े - 340 एम शामिल हैं। इतनी बड़ी संख्या में मापदंडों के कारण, इस मॉडल को सीमित संसाधनों वाले उपकरणों जैसे मोबाइल फोन पर डाउनलोड करना मुश्किल है। इसके अलावा, लंबे समय तक प्रवेश इस मॉडल को अनुपयुक्त बनाता है जहां प्रतिक्रिया की गति महत्वपूर्ण होती है। इसलिए, BERT को तेज करने के तरीके खोजना एक बहुत ही गर्म विषय है।

हम Avito में अक्सर पाठ वर्गीकरण समस्याओं को हल करने के लिए है। यह एक सामान्य रूप से लागू मशीन लर्निंग कार्य है जिसका अच्छी तरह से अध्ययन किया गया है। लेकिन हमेशा कुछ नया करने की कोशिश करने का प्रलोभन होता है। यह लेख रोजमर्रा की मशीन सीखने के कार्यों में BERT को लागू करने के प्रयास से पैदा हुआ था। इसमें, मैं दिखाऊंगा कि कैसे आप नए डेटा को जोड़ने और मॉडल को जटिल किए बिना BERT का उपयोग करके मौजूदा मॉडल की गुणवत्ता में काफी सुधार कर सकते हैं।

तंत्रिका नेटवर्क को तेज करने की एक विधि के रूप में ज्ञान आसवन

तंत्रिका नेटवर्क को तेज / हल्का करने के कई तरीके हैं। सबसे विस्तृत समीक्षा जो मुझे मिली है वह मध्यम पर इंटेंटो ब्लॉग पर प्रकाशित हुई है।

तरीकों को मोटे तौर पर तीन समूहों में विभाजित किया जा सकता है:

नेटवर्क आर्किटेक्चर बदल जाता है।
मॉडल संपीड़न (मात्रा का ठहराव, छंटाई)।
ज्ञान आसवन।

यदि पहले दो तरीके अपेक्षाकृत प्रसिद्ध और समझने योग्य हैं, तो तीसरा कम आम है। पहली बार, आसवन का विचार रिच कारुआना द्वारा "मॉडल संपीड़न" लेख में प्रस्तावित किया गया था। इसका सार सरल है: आप एक हल्के मॉडल को प्रशिक्षित कर सकते हैं जो एक शिक्षक मॉडल के व्यवहार या यहां तक कि मॉडल की एक टुकड़ी की नकल करेगा। हमारे मामले में, शिक्षक बीईआरटी होगा, और छात्र कोई भी प्रकाश मॉडल होगा।

कार्य

आइए एक उदाहरण के रूप में द्विआधारी वर्गीकरण का उपयोग करके आसवन का विश्लेषण करें। एनएलपी के लिए मॉडल का परीक्षण करने वाले कार्यों के मानक सेट से ओपन एसएसटी -2 डेटासेट लें।

यह डेटासेट भावनात्मक रंग - सकारात्मक या नकारात्मक द्वारा टूटी हुई IMDb के साथ फिल्मों की समीक्षाओं का एक संग्रह है। इस डेटासेट पर मीट्रिक सटीकता है।

प्रशिक्षण BERT- आधारित मॉडल या "शिक्षक"

सबसे पहले, आपको "बड़े" BERT- आधारित मॉडल को प्रशिक्षित करने की आवश्यकता है, जो एक शिक्षक बन जाएगा। ऐसा करने का सबसे आसान तरीका है कि BERT से एम्बेडिंग लेना और उनके ऊपर क्लासिफायर को प्रशिक्षित करना, एक परत को नेटवर्क में जोड़ना।

ट्रांसफॉर्मर लाइब्रेरी के लिए धन्यवाद , यह करना बहुत आसान है, क्योंकि बर्टफॉरसेंसेंस क्लैसिफिकेशन मॉडल के लिए एक तैयार वर्ग है। मेरी राय में, इस मॉडल को पढ़ाने के लिए सबसे विस्तृत और समझने योग्य ट्यूटोरियल टुवर्ड्स डेटा साइंस द्वारा प्रकाशित किया गया था।

आइए कल्पना करें कि हमें एक प्रशिक्षित BertForSequenceClassification मॉडल मिला। हमारे मामले में, num_labels = 2, क्योंकि हमारे पास एक द्विआधारी वर्गीकरण है। हम इस मॉडल का उपयोग "शिक्षक" के रूप में करेंगे।

"छात्र" सीखना

आप एक छात्र के रूप में किसी भी वास्तुकला को ले सकते हैं: एक तंत्रिका नेटवर्क, एक रैखिक मॉडल, एक निर्णय वृक्ष। आइए बेहतर दृश्य के लिए BiLSTM को सिखाने का प्रयास करें। शुरू करने के लिए, हम बिना BERT के BiLSTM सिखाएंगे।

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

import torch from torchtext import data def get_vocab(X): X_split = [t.split() for t in X] text_field = data.Field() text_field.build_vocab(X_split, max_size=10000) return text_field def pad(seq, max_len): if len(seq) < max_len: seq = seq + ['<pad>'] * (max_len - len(seq)) return seq[0:max_len] def to_indexes(vocab, words): return [vocab.stoi[w] for w in words] def to_dataset(x, y, y_real): torch_x = torch.tensor(x, dtype=torch.long) torch_y = torch.tensor(y, dtype=torch.float) torch_real_y = torch.tensor(y_real, dtype=torch.long) return TensorDataset(torch_x, torch_y, torch_real_y)

मॉडल BiLSTM

मॉडल के लिए कोड इस तरह दिखेगा:

 import torch from torch import nn from torch.autograd import Variable class SimpleLSTM(nn.Module): def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout, batch_size, device=None): super(SimpleLSTM, self).__init__() self.batch_size = batch_size self.hidden_dim = hidden_dim self.n_layers = n_layers self.embedding = nn.Embedding(input_dim, embedding_dim) self.rnn = nn.LSTM(embedding_dim, hidden_dim, num_layers=n_layers, bidirectional=bidirectional, dropout=dropout) self.fc = nn.Linear(hidden_dim * 2, output_dim) self.dropout = nn.Dropout(dropout) self.device = self.init_device(device) self.hidden = self.init_hidden() @staticmethod def init_device(device): if device is None: return torch.device('cuda') return device def init_hidden(self): return (Variable(torch.zeros(2 * self.n_layers, self.batch_size, self.hidden_dim).to(self.device)), Variable(torch.zeros(2 * self.n_layers, self.batch_size, self.hidden_dim).to(self.device))) def forward(self, text, text_lengths=None): self.hidden = self.init_hidden() x = self.embedding(text) x, self.hidden = self.rnn(x, self.hidden) hidden, cell = self.hidden hidden = self.dropout(torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1)) x = self.fc(hidden) return x

ट्रेनिंग

इस मॉडल के लिए, आउटपुट वेक्टर का आयाम (batch_size, output_dim) होगा। प्रशिक्षण में, हम सामान्य लॉगलॉस का उपयोग करेंगे। PyTorch में BCEWithLogitsLoss क्लास है जो सिग्मॉइड और क्रॉस एन्ट्रॉपी को जोड़ती है। आपको क्या चाहिए

 def loss(self, output, bert_prob, real_label): criterion = torch.nn.BCEWithLogitsLoss() return criterion(output, real_label.float())

सीखने के एक युग के लिए कोड:

 def get_optimizer(model): optimizer = torch.optim.Adam(model.parameters()) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 2, gamma=0.9) return optimizer, scheduler def epoch_train_func(model, dataset, loss_func, batch_size): train_loss = 0 train_sampler = RandomSampler(dataset) data_loader = DataLoader(dataset, sampler=train_sampler, batch_size=batch_size, drop_last=True) model.train() optimizer, scheduler = get_optimizer(model) for i, (text, bert_prob, real_label) in enumerate(tqdm(data_loader, desc='Train')): text, bert_prob, real_label = to_device(text, bert_prob, real_label) model.zero_grad() output = model(text.t(), None).squeeze(1) loss = loss_func(output, bert_prob, real_label) loss.backward() optimizer.step() train_loss += loss.item() scheduler.step() return train_loss / len(data_loader)

युग के बाद सत्यापन के लिए कोड:

 def epoch_evaluate_func(model, eval_dataset, loss_func, batch_size): eval_sampler = SequentialSampler(eval_dataset) data_loader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=batch_size, drop_last=True) eval_loss = 0.0 model.eval() for i, (text, bert_prob, real_label) in enumerate(tqdm(data_loader, desc='Val')): text, bert_prob, real_label = to_device(text, bert_prob, real_label) output = model(text.t(), None).squeeze(1) loss = loss_func(output, bert_prob, real_label) eval_loss += loss.item() return eval_loss / len(data_loader)

यदि यह सब एक साथ रखा जाता है, तो हमें मॉडल के प्रशिक्षण के लिए निम्नलिखित कोड मिलते हैं:

 import os import torch from torch.utils.data import (TensorDataset, random_split, RandomSampler, DataLoader, SequentialSampler) from torchtext import data from tqdm import tqdm def device(): return torch.device("cuda" if torch.cuda.is_available() else "cpu") def to_device(text, bert_prob, real_label): text = text.to(device()) bert_prob = bert_prob.to(device()) real_label = real_label.to(device()) return text, bert_prob, real_label class LSTMBaseline(object): vocab_name = 'text_vocab.pt' weights_name = 'simple_lstm.pt' def __init__(self, settings): self.settings = settings self.criterion = torch.nn.BCEWithLogitsLoss().to(device()) def loss(self, output, bert_prob, real_label): return self.criterion(output, real_label.float()) def model(self, text_field): model = SimpleLSTM( input_dim=len(text_field.vocab), embedding_dim=64, hidden_dim=128, output_dim=1, n_layers=1, bidirectional=True, dropout=0.5, batch_size=self.settings['train_batch_size']) return model def train(self, X, y, y_real, output_dir): max_len = self.settings['max_seq_length'] text_field = get_vocab(X) X_split = [t.split() for t in X] X_pad = [pad(s, max_len) for s in tqdm(X_split, desc='pad')] X_index = [to_indexes(text_field.vocab, s) for s in tqdm(X_pad, desc='to index')] dataset = to_dataset(X_index, y, y_real) val_len = int(len(dataset) * 0.1) train_dataset, val_dataset = random_split(dataset, (len(dataset) - val_len, val_len)) model = self.model(text_field) model.to(device()) self.full_train(model, train_dataset, val_dataset, output_dir) torch.save(text_field, os.path.join(output_dir, self.vocab_name)) def full_train(self, model, train_dataset, val_dataset, output_dir): train_settings = self.settings num_train_epochs = train_settings['num_train_epochs'] best_eval_loss = 100000 for epoch in range(num_train_epochs): train_loss = epoch_train_func(model, train_dataset, self.loss, self.settings['train_batch_size']) eval_loss = epoch_evaluate_func(model, val_dataset, self.loss, self.settings['eval_batch_size']) if eval_loss < best_eval_loss: best_eval_loss = eval_loss torch.save(model.state_dict(), os.path.join(output_dir, self.weights_name))

आसवन

इस आसवन विधि का विचार वाटरलू विश्वविद्यालय के शोधकर्ताओं द्वारा एक लेख से लिया गया है । जैसा कि मैंने ऊपर कहा, "छात्र" को "शिक्षक" के व्यवहार की नकल करना सीखना चाहिए। वास्तव में व्यवहार क्या है? हमारे मामले में, ये प्रशिक्षण सेट पर शिक्षक मॉडल की भविष्यवाणियां हैं। और मुख्य विचार सक्रियण फ़ंक्शन को लागू करने से पहले नेटवर्क आउटपुट का उपयोग करना है। यह माना जाता है कि इस तरह से मॉडल अंतिम संभावनाओं के मामले में आंतरिक प्रतिनिधित्व को बेहतर ढंग से सीख सकेगा।

मूल लेख में हानि फ़ंक्शन के लिए एक शब्द जोड़ने का प्रस्ताव है, जो "लॉग" त्रुटि के लिए जिम्मेदार होगा - मॉडल लॉग के बीच एमएसई।

इन उद्देश्यों के लिए, हम दो छोटे बदलाव करते हैं: 1 से 2 तक नेटवर्क आउटपुट की संख्या को बदलें और नुकसान फ़ंक्शन को ठीक करें।

 def loss(self, output, bert_prob, real_label): a = 0.5 criterion_mse = torch.nn.MSELoss() criterion_ce = torch.nn.CrossEntropyLoss() return a*criterion_ce(output, real_label) + (1-a)*criterion_mse(output, bert_prob)

आप केवल मॉडल और हानि को फिर से परिभाषित करके लिखे गए सभी कोड का पुन: उपयोग कर सकते हैं:

 class LSTMDistilled(LSTMBaseline): vocab_name = 'distil_text_vocab.pt' weights_name = 'distil_lstm.pt' def __init__(self, settings): super(LSTMDistilled, self).__init__(settings) self.criterion_mse = torch.nn.MSELoss() self.criterion_ce = torch.nn.CrossEntropyLoss() self.a = 0.5 def loss(self, output, bert_prob, real_label): return self.a * self.criterion_ce(output, real_label) + (1 - self.a) * self.criterion_mse(output, bert_prob) def model(self, text_field): model = SimpleLSTM( input_dim=len(text_field.vocab), embedding_dim=64, hidden_dim=128, output_dim=2, n_layers=1, bidirectional=True, dropout=0.5, batch_size=self.settings['train_batch_size']) return model

बस इतना ही, अब हमारा मॉडल "नकल" करना सीख रहा है।

मॉडल तुलना

मूल लेख में, SST-2 के लिए सर्वश्रेष्ठ वर्गीकरण परिणाम = 0 पर प्राप्त किए जाते हैं, जब मॉडल केवल नकल करना सीखता है, वास्तविक लेबल को ध्यान में नहीं रखता है। सटीकता अभी भी BERT से कम है, लेकिन नियमित BiLSTM से काफी बेहतर है।

मैंने लेख से परिणाम दोहराने की कोशिश की, लेकिन मेरे प्रयोगों में सर्वोत्तम परिणाम = 0.5 पर प्राप्त हुआ।

सामान्य तरीके से LSTM सीखते समय यह हानि और सटीकता रेखांकन दिखता है। नुकसान के व्यवहार को देखते हुए, मॉडल ने तेजी से सीखा, और कहीं न कहीं छठे युग के बाद, फिर से देखना शुरू हुआ।

आसवन रेखांकन:

डिस्टिल्ड BiLSTM सामान्य से लगातार बेहतर है। यह महत्वपूर्ण है कि वे वास्तुकला में बिल्कुल समान हैं, एकमात्र अंतर शिक्षण के तरीके में है। मैंने GitHub पर पूर्ण प्रशिक्षण कोड पोस्ट किया ।

निष्कर्ष

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

सरल BERT आसवन गाइड