PyTorch के साथ NLP: एक व्यापक गाइड

NLP और PyTorch का परिचय

नैचुरल लैंग्वेज प्रोसेसिंग (NLP) आधुनिक AI का एक महत्वपूर्ण घटक है, जो मशीनों को मानवीय भाषा समझने और उस पर प्रतिक्रिया देने में सक्षम बनाता है। जैसे-जैसे डिजिटल इंटरैक्शन बढ़ते हैं, NLP का महत्व भी बढ़ता जाता है। PyTorch, एक लोकप्रिय ओपन-सोर्स मशीन लर्निंग लाइब्रेरी, अपनी लचीली संरचना और कुशल टेन्सर गणनाओं के कारण NLP कार्यों के लिए मजबूत उपकरण प्रदान करती है। इसका डायनेमिक कम्प्यूटेशनल ग्राफ जटिल मॉडलों को संशोधित और निर्मित करना आसान बनाता है, जो इसे हमारे ट्यूटोरियल के लिए आदर्श बनाता है।

यदि आप NLP के बारे में और सीखना चाहते हैं, तो हमारा Natural Language Processing in Python स्किल ट्रैक देखें, या यदि आप R में NLP सीखना पसंद करते हैं, तो DataCamp पर Introduction to Natural Language Processing in R कोर्स देखें।

पर्यावरण सेटअप

PyTorch वातावरण सेट करना कभी-कभी चुनौतीपूर्ण हो सकता है क्योंकि यह ऑपरेटिंग सिस्टम, पैकेज मैनेजर की पसंद, प्रोग्रामिंग भाषा और कम्प्यूटिंग प्लेटफ़ॉर्म जैसे कारकों पर निर्भर करता है। इन कारकों के आधार पर इंस्टॉलेशन प्रक्रिया में थोड़ा बदलाव हो सकता है, जिसके लिए आपको विशिष्ट कमांड चलाने की आवश्यकता होती है।

उपयुक्त इंस्टॉल कमांड प्राप्त करने के लिए, आप PyTorch के आधिकारिक get started पेज पर जा सकते हैं, जहाँ आप अपनी प्राथमिकताएँ चुनकर आवश्यक निर्देश प्राप्त कर सकते हैं।

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

टेन्सर का परिचय

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

PyTorch के संदर्भ में, टेन्सर प्राथमिक बिल्डिंग ब्लॉक्स और डेटा रिप्रेजेंटेशन ऑब्जेक्ट हैं। PyTorch में टेन्सर NumPy एरे के समान होते हैं, लेकिन इनमें डीप लर्निंग गणनाओं के लिए विशेष रूप से डिज़ाइन की गई अतिरिक्त क्षमताएँ और ऑप्टिमाइज़ेशन होते हैं। PyTorch के टेन्सर ऑपरेशन हार्डवेयर एक्सेलेरेशन, जैसे कि GPU, का लाभ उठाते हैं, जिससे जटिल न्यूरल नेटवर्क का कुशलतापूर्वक गणना करना संभव होता है।

भाषा डेटा की क्रमिक और पदानुक्रमित प्रकृति के कारण NLP कार्यों में टेन्सर महत्वपूर्ण भूमिका निभाते हैं।

NLP में पाठ्य जानकारी को संसाधित और समझना शामिल है। टेन्सर शब्दों, वाक्यों या दस्तावेज़ों को संख्यात्मक वेक्टर के रूप में एन्कोड करके पाठ डेटा का निरूपण और हेरफेर संभव बनाते हैं।

यह संख्यात्मक निरूपण डीप लर्निंग मॉडलों को पाठ्य डेटा को प्रभावी ढंग से संसाधित करने और उससे सीखने में सक्षम बनाता है। टेन्सर बड़े पैमाने के भाषा डेटासेट को कुशलतापूर्वक संभालने, न्यूरल नेटवर्क को प्रशिक्षित करने और अधिक सटीक NLP मॉडलों के लिए अटेंशन जैसे उन्नत तरीकों को सक्षम करते हैं।

वर्ड एम्बेडिंग्स

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

सरल शब्दों में, एम्बेडिंग्स शब्दों को संख्याओं के रूप में प्रस्तुत करने का एक चतुर तरीका हैं। ये संख्याएँ विशेष अर्थ रखती हैं जो बताती हैं कि शब्द आपस में कैसे संबंधित हैं। यह एक तरह का गुप्त कोड है जो कंप्यूटर को शब्दों को अधिक आसानी से समझने और उनके साथ काम करने में मदद करता है।

Word2Vec और GloVe वर्ड एम्बेडिंग्स बनाने के दो लोकप्रिय तरीके हैं। Word2Vec एक न्यूरल नेटवर्क-आधारित मॉडल है जो लक्षित शब्द के दिए गए परिवेश शब्दों की भविष्यवाणी करके (continuous bag of words - CBOW) या संदर्भ के आधार पर लक्षित शब्द की भविष्यवाणी करके (skip-gram) शब्दों के निरूपण सीखता है।

GloVe (Global Vectors for Word Representation) एक काउंट-आधारित तरीका है जो बड़े कॉर्पस में शब्दों की सह-अस्तित्व सांख्यिकी के आधार पर वर्ड वेक्टर बनाता है। यह वैश्विक शब्द संबंधों को पकड़ता है और अक्सर वर्ड एनालॉजी कार्यों में बेहतर प्रदर्शन देता है।

NLP मॉडल आर्किटेक्चर

सेंटिमेंट एनालिसिस कार्य के लिए मॉडल आर्किटेक्चर का उदाहरण।

सेंटिमेंट एनालिसिस NLP का एक सामान्य कार्य है जिसमें उद्देश्य किसी पाठ में व्यक्त भाव को समझना होता है, जिसे प्रायः सकारात्मक, नकारात्मक या न्यूट्रल के रूप में वर्गीकृत किया जाता है। इस कार्य के लिए एक सरल रिकरेंट न्यूरल नेटवर्क (RNN) या उसका उन्नत संस्करण लॉन्ग शॉर्ट-टर्म मेमोरी (LSTM) उपयोग किया जा सकता है।

RNNs

RNN आर्किटेक्चर पाठ को क्रमवार तरीके से संसाधित करता है, जहाँ प्रत्येक शब्द को एक के बाद एक इनपुट दिया जाता है। नेटवर्क एक हिडन स्टेट बनाए रखता है जो प्रत्येक शब्द इनपुट के साथ बदलता है और अब तक संसाधित अनुक्रम की जानकारी को कैप्चर करता है।

यह हिडन स्टेट नेटवर्क की मेमोरी के रूप में कार्य करता है। हालाँकि, मानक RNN लंबे अनुक्रमों में वैनिशिंग ग्रेडिएंट समस्या के कारण संघर्ष करते हैं, जहाँ जानकारी का योगदान समय के साथ ज्यामितीय रूप से क्षीण होता जाता है, जिससे नेटवर्क पहले के इनपुट भूल जाता है। आप हमारे RNN ट्यूटोरियल में रिकरेंट न्यूरल नेटवर्क के बारे में और जान सकते हैं। 

LSTMs

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

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

RNN या LSTM मॉडल इनपुट के रूप में किसी वाक्य या दस्तावेज़ में शब्दों का अनुक्रम लेता है। प्रत्येक शब्द आमतौर पर एक घने वेक्टर, या एम्बेडिंग, के रूप में प्रस्तुत किया जाता है, जो शब्द के सैमांटिक अर्थ को कैप्चर करता है।

नेटवर्क अनुक्रम को शब्द दर शब्द संसाधित करता है, वर्तमान शब्द और पिछले स्टेट के आधार पर अपने आंतरिक स्टेट को अपडेट करता है।

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

सबसे अधिक प्रायिकता वाली क्लास को मॉडल की भविष्यवाणी के रूप में चुना जाता है।

यह एक बुनियादी सेटअप है और इसे बिडायरेक्शनल LSTM (जो अनुक्रम को दोनों दिशाओं में संसाधित करते हैं) और अटेंशन मैकेनिज़्म (जो मॉडल को अनुक्रम के महत्वपूर्ण भागों पर ध्यान केंद्रित करने देते हैं) जैसे तरीकों से और बेहतर बनाया जा सकता है।

PyTorch में सेंटिमेंट एनालिसिस के लिए LSTM मॉडल का प्रशिक्षण

PyTorch का उपयोग करके सेंटिमेंट एनालिसिस मॉडल बनाने के लिए एंड-टू-एंड Python कोड उदाहरण

1. डेटासेट लोड करें

इस उदाहरण में, हम IMDB का 50K मूवी रिव्यू वाला डेटासेट उपयोग करेंगे। लक्ष्य LSTM मॉडल को सेंटिमेंट की भविष्यवाणी के लिए प्रशिक्षित करना है। दो संभावित मान हैं: 'positive' और 'negative'। अतः यह एक बाइनरी क्लासिफिकेशन टास्क है।

file_name = 'IMDB Dataset.csv'
df = pd.read_csv(file_name)
df.head()

2. एक्सप्लोरेटरी डेटा एनालिसिस

X,y = df['review'].values,df['sentiment'].values
x_train,x_test,y_train,y_test = train_test_split(X,y,stratify=y)
print(f'train data shape: {x_train.shape}')
print(f'test data shape: {x_test.shape}')


dd = pd.Series(y_train).value_counts()
sns.barplot(x=np.array(['negative','positive']),y=dd.values)
plt.show()

आउटपुट:

>>> train data shape: (37500,)

>>> test data shape: (12500,)

3. टेक्स्ट प्रीप्रोसेसिंग

टेक्स्ट प्रीप्रोसेसिंग और टोकनाइज़ेशन एक अत्यंत महत्वपूर्ण पहला चरण है। सबसे पहले, हम विराम चिह्न, अतिरिक्त स्पेस और संख्याएँ हटाकर टेक्स्ट डेटा को साफ करते हैं।

फिर हम वाक्यों को अलग-अलग शब्दों में बदलते हैं, सामान्य शब्दों (जिन्हें "स्टॉप वर्ड्स" कहा जाता है) को हटाते हैं, और डेटासेट में सबसे अधिक बार उपयोग होने वाले 1000 शब्दों का रिकॉर्ड रखते हैं। इन शब्दों को एक अद्वितीय पहचानकर्ता सौंपा जाता है, जो वन-हॉट एन्कोडिंग के लिए एक शब्दकोश बनाता है।

यह कोड मूल टेक्स्ट वाक्यों को इन अद्वितीय पहचानकर्ताओं के अनुक्रम में बदल रहा है, यानी मानवीय भाषा को ऐसे प्रारूप में अनुवादित कर रहा है जिसे मशीन लर्निंग मॉडल समझ सके।

def preprocess_string(s):
    # Remove all non-word characters (everything except numbers and letters)
    s = re.sub(r"[^\w\s]", '', s)
    # Replace all runs of whitespaces with no space
    s = re.sub(r"\s+", '', s)
    # replace digits with no space
    s = re.sub(r"\d", '', s)
    return s


def tokenize(x_train,y_train,x_val,y_val):
    word_list = []


    stop_words = set(stopwords.words('english'))
    for sent in x_train:
        for word in sent.lower().split():
            word = preprocess_string(word)
            if word not in stop_words and word != '':
                word_list.append(word)
 
    corpus = Counter(word_list)
    # sorting on the basis of most common words
    corpus_ = sorted(corpus,key=corpus.get,reverse=True)[:1000]
    # creating a dict
    onehot_dict = {w:i+1 for i,w in enumerate(corpus_)}
   
    # tokenize
    final_list_train,final_list_test = [],[]
    for sent in x_train:
            final_list_train.append([onehot_dict[preprocess_string(word)] for word in sent.lower().split()
                                     if preprocess_string(word) in onehot_dict.keys()])
    for sent in x_val:
            final_list_test.append([onehot_dict[preprocess_string(word)] for word in sent.lower().split()
                                    if preprocess_string(word) in onehot_dict.keys()])
           
    encoded_train = [1 if label =='positive' else 0 for label in y_train]  
    encoded_test = [1 if label =='positive' else 0 for label in y_val]
    return np.array(final_list_train), np.array(encoded_train),np.array(final_list_test), np.array(encoded_test),onehot_dict


x_train,y_train,x_test,y_test,vocab = tokenize(x_train,y_train,x_test,y_test)

आइए x_train में टोकन की लंबाई का विश्लेषण करते हैं।

rev_len = [len(i) for i in x_train]
pd.Series(rev_len).hist()

4. मॉडल के लिए डेटा तैयार करना

प्रत्येक समीक्षा की टोकन लंबाई अलग-अलग होने के कारण, स्थिरता के लिए उन्हें मानकीकृत करना आवश्यक है। चूँकि अधिकांश समीक्षाओं में 500 से कम टोकन हैं, हम सभी समीक्षाओं के लिए 500 को फिक्स्ड लंबाई के रूप में निर्धारित करेंगे।

def padding_(sentences, seq_len):
    features = np.zeros((len(sentences), seq_len),dtype=int)
    for ii, review in enumerate(sentences):
        if len(review) != 0:
            features[ii, -len(review):] = np.array(review)[:seq_len]
    return features


x_train_pad = padding_(x_train,500)
x_test_pad = padding_(x_test,500)

अगले चरण में, हम मॉडल प्रशिक्षण के लिए अंतिम डेटासेट बनाने के लिए DataLoader क्लास का उपयोग करते हैं।

# create Tensor datasets
train_data = TensorDataset(torch.from_numpy(x_train_pad), torch.from_numpy(y_train))
valid_data = TensorDataset(torch.from_numpy(x_test_pad), torch.from_numpy(y_test))


# dataloaders
batch_size = 50


# make sure to SHUFFLE your data
train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size)
valid_loader = DataLoader(valid_data, shuffle=True, batch_size=batch_size)


# obtain one batch of training data
dataiter = iter(train_loader)
sample_x, sample_y = next(dataiter)


print('Sample input size: ', sample_x.size()) # batch_size, seq_length
print('Sample input: \n', sample_x)
print('Sample output: \n', sample_y)

आउटपुट:

5. LSTM मॉडल परिभाषित करें

कोड का यह भाग एक रिकरेंट न्यूरल नेटवर्क (RNN) आर्किटेक्चर, विशेष रूप से ऊपर वर्णित Long Short-Term Memory (LSTM), का उपयोग करके सेंटिमेंट एनालिसिस मॉडल परिभाषित करता है। SentimentRNN क्लास एक PyTorch मॉडल है जो एम्बेडिंग लेयर से शुरू होता है, जो शब्द इंडेक्स को घने निरूपण में बदलता है जो शब्दों के सैमांटिक अर्थ को कैद करता है। इसके बाद एक LSTM लेयर आती है जो शब्द एम्बेडिंग्स के अनुक्रम को प्रोसेस करती है।

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

class SentimentRNN(nn.Module):
    def __init__(self,no_layers,vocab_size,hidden_dim,embedding_dim,drop_prob=0.5):
        super(SentimentRNN,self).__init__()
 
        self.output_dim = output_dim
        self.hidden_dim = hidden_dim
 
        self.no_layers = no_layers
        self.vocab_size = vocab_size
   
        # embedding and LSTM layers
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
       
        #lstm
        self.lstm = nn.LSTM(input_size=embedding_dim,hidden_size=self.hidden_dim,
                           num_layers=no_layers, batch_first=True)
       
        # dropout layer
        self.dropout = nn.Dropout(0.3)
   
        # linear and sigmoid layer
        self.fc = nn.Linear(self.hidden_dim, output_dim)
        self.sig = nn.Sigmoid()
       
    def forward(self,x,hidden):
        batch_size = x.size(0)
        # embeddings and lstm_out
        embeds = self.embedding(x)  # shape: B x S x Feature   since batch = True
        #print(embeds.shape)  #[50, 500, 1000]
        lstm_out, hidden = self.lstm(embeds, hidden)
       
        lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)
       
        # dropout and fully connected layer
        out = self.dropout(lstm_out)
        out = self.fc(out)
       
        # sigmoid function
        sig_out = self.sig(out)
       
        # reshape to be batch_size first
        sig_out = sig_out.view(batch_size, -1)


        sig_out = sig_out[:, -1] # get last batch of labels
       
        # return last sigmoid output and hidden state
        return sig_out, hidden
       
    def init_hidden(self, batch_size):
        ''' Initializes hidden state '''
        # Create two new tensors with sizes n_layers x batch_size x hidden_dim,
        # initialized to zero, for hidden state and cell state of LSTM
        h0 = torch.zeros((self.no_layers,batch_size,self.hidden_dim)).to(device)
        c0 = torch.zeros((self.no_layers,batch_size,self.hidden_dim)).to(device)
        hidden = (h0,c0)
        return hidden 

अब हम ऊपर परिभाषित SentimentRNN क्लास को आवश्यक पैरामीटर के साथ इनिशियलाइज़ करेंगे।

no_layers = 2
vocab_size = len(vocab) + 1 #extra 1 for padding
embedding_dim = 64
output_dim = 1
hidden_dim = 256


model = SentimentRNN(no_layers,vocab_size,hidden_dim,embedding_dim,drop_prob=0.5)


#moving to gpu
model.to(device)
print(model)

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

यहाँ प्रयुक्त लॉस फंक्शन Binary Cross-Entropy Loss (nn.BCELoss) है, जो ऐसे बाइनरी क्लासिफिकेशन कार्यों के लिए सामान्यतः इस्तेमाल होता है। ऑप्टिमाइज़ेशन विधि Adam (torch.optim.Adam) है, जो अपनी दक्षता और कम मेमोरी आवश्यकताओं के कारण लोकप्रिय है। Adam के लिए लर्निंग रेट 0.001 सेट किया गया है।

acc फंक्शन हमारे मॉडल की भविष्यवाणियों की सटीकता की गणना करने के लिए डिज़ाइन किया गया एक सहायक फंक्शन है। यह भविष्यवाणी की गई प्रायिकताओं को निकटतम पूर्णांक (0 या 1) पर राउंड करता है, इन भविष्यवाणियों की वास्तविक लेबल से तुलना करता है, और फिर सही भविष्यवाणियों का प्रतिशत निकालता है।

# loss and optimization functions


lr=0.001


criterion = nn.BCELoss()


optimizer = torch.optim.Adam(model.parameters(), lr=lr)


# function to predict accuracy
def acc(pred,label):
    pred = torch.round(pred.squeeze())
    return torch.sum(pred == label.squeeze()).item()

6. प्रशिक्षण शुरू करें

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

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

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

ग्रेडिएंट्स को एक अधिकतम मान तक क्लिप किया जाता है ताकि वे बहुत बड़े न हो जाएँ—यह RNNs और LSTMs के प्रशिक्षण में आम समस्या है।

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

यदि वैलिडेशन लॉस में सुधार होता है, तो मौजूदा मॉडल के पैरामीटर सहेजे जाते हैं, जिससे प्रशिक्षण के दौरान मिले सर्वश्रेष्ठ मॉडल को कैप्चर किया जा सके।

अंत में, प्रत्येक epoch के बाद, उस epoch का औसत लॉस और एक्यूरेसी प्रिंट की जाती है, जो मॉडल की लर्निंग प्रगति में अंतर्दृष्टि देती है।

clip = 5
epochs = 5
valid_loss_min = np.Inf
# train for some number of epochs
epoch_tr_loss,epoch_vl_loss = [],[]
epoch_tr_acc,epoch_vl_acc = [],[]


for epoch in range(epochs):
    train_losses = []
    train_acc = 0.0
    model.train()
    # initialize hidden state
    h = model.init_hidden(batch_size)
    for inputs, labels in train_loader:
       
        inputs, labels = inputs.to(device), labels.to(device)  
        # Creating new variables for the hidden state, otherwise
        # we'd backprop through the entire training history
        h = tuple([each.data for each in h])
       
        model.zero_grad()
        output,h = model(inputs,h)
       
        # calculate the loss and perform backprop
        loss = criterion(output.squeeze(), labels.float())
        loss.backward()
        train_losses.append(loss.item())
        # calculating accuracy
        accuracy = acc(output,labels)
        train_acc += accuracy
        #`clip_grad_norm` helps prevent the exploding gradient problem in RNNs / LSTMs.
        nn.utils.clip_grad_norm_(model.parameters(), clip)
        optimizer.step()
       
    val_h = model.init_hidden(batch_size)
    val_losses = []
    val_acc = 0.0
    model.eval()
    for inputs, labels in valid_loader:
            val_h = tuple([each.data for each in val_h])


            inputs, labels = inputs.to(device), labels.to(device)


            output, val_h = model(inputs, val_h)
            val_loss = criterion(output.squeeze(), labels.float())


            val_losses.append(val_loss.item())
           
            accuracy = acc(output,labels)
            val_acc += accuracy
           
    epoch_train_loss = np.mean(train_losses)
    epoch_val_loss = np.mean(val_losses)
    epoch_train_acc = train_acc/len(train_loader.dataset)
    epoch_val_acc = val_acc/len(valid_loader.dataset)
    epoch_tr_loss.append(epoch_train_loss)
    epoch_vl_loss.append(epoch_val_loss)
    epoch_tr_acc.append(epoch_train_acc)
    epoch_vl_acc.append(epoch_val_acc)
    print(f'Epoch {epoch+1}')
    print(f'train_loss : {epoch_train_loss} val_loss : {epoch_val_loss}')
    print(f'train_accuracy : {epoch_train_acc*100} val_accuracy : {epoch_val_acc*100}')
    if epoch_val_loss <= valid_loss_min:
        torch.save(model.state_dict(), 'state_dict.pt')
        print('Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...'.format(valid_loss_min,epoch_val_loss))
        valid_loss_min = epoch_val_loss
    print(25*'==')

आउटपुट:

7. मॉडल मूल्यांकन

यह भाग प्रशिक्षण के दौरान प्रशिक्षण और वैलिडेशन एक्यूरेसी तथा लॉस को दृश्य रूप में दिखाने के लिए दो प्लॉट बनाता है। पहला सबप्लॉट प्रत्येक epoch के बाद प्रशिक्षण और वैलिडेशन एक्यूरेसी का लाइन ग्राफ दिखाता है। यह ग्राफ यह देखने में सहायक है कि समय के साथ मॉडल कितना अच्छा सीख रहा है और जनरलाइज़ कर रहा है।

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

fig = plt.figure(figsize = (20, 6))
plt.subplot(1, 2, 1)
plt.plot(epoch_tr_acc, label='Train Acc')
plt.plot(epoch_vl_acc, label='Validation Acc')
plt.title("Accuracy")
plt.legend()
plt.grid()
   
plt.subplot(1, 2, 2)
plt.plot(epoch_tr_loss, label='Train loss')
plt.plot(epoch_vl_loss, label='Validation loss')
plt.title("Loss")
plt.legend()
plt.grid()


plt.show()

आउटपुट:

8. इन्फरेंस / प्रेडिक्शन

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

def predict_text(text):
        word_seq = np.array([vocab[preprocess_string(word)] for word in text.split()
                         if preprocess_string(word) in vocab.keys()])
        word_seq = np.expand_dims(word_seq,axis=0)
        pad =  torch.from_numpy(padding_(word_seq,500))
        inputs = pad.to(device)
        batch_size = 1
        h = model.init_hidden(batch_size)
        h = tuple([each.data for each in h])
        output, h = model(inputs, h)
        return(output.item())


index = 30
print(df['review'][index])
print('='*70)
print(f'Actual sentiment is  : {df["sentiment"][index]}')
print('='*70)
pro = predict_text(df['review'][index])
status = "positive" if pro > 0.5 else "negative"
pro = (1 - pro) if status == "negative" else pro
print(f'Predicted sentiment is {status} with a probability of {pro}')

आउटपुट:

यह पूरा नोटबुक DataLab का उपयोग करके विकसित किया गया है और इस वर्कबुक पर उपलब्ध है। ध्यान रखें कि यदि आप CPU का उपयोग कर रहे हैं, तो कोड चलाने में काफी समय लग सकता है। हालाँकि, GPU का उपयोग प्रशिक्षण समय को काफ़ी कम कर सकता है।

अगले चरण / मॉडल में सुधार

किसी NLP मॉडल में सुधार आम तौर पर कार्य की आवश्यकताओं और बाधाओं के अनुसार कई रणनीतियाँ शामिल करता है। हाइपरपैरामीटर ट्यूनिंग एक सामान्य तरीका है, जिसमें लर्निंग रेट, बैच साइज या न्यूरल नेटवर्क की लेयरों की संख्या जैसे पैरामीटरों को समायोजित करना शामिल है।

ये हाइपरपैरामीटर मॉडल के प्रदर्शन को काफी प्रभावित कर सकते हैं और आमतौर पर ग्रिड सर्च या रैंडम सर्च जैसी तकनीकों के माध्यम से ऑप्टिमाइज़ किए जाते हैं।

ट्रांसफर लर्निंग, विशेष रूप से BERT या GPT जैसे मॉडलों के साथ, NLP कार्यों में सुधार करने में अत्यधिक संभावनाएँ दिखा चुका है। ये मॉडल बड़े पाठ कॉर्पस पर प्री-ट्रेंड होते हैं और फिर किसी विशिष्ट कार्य पर फाइन-ट्यून किए जाते हैं, जिससे वे प्री-ट्रेनिंग के दौरान प्राप्त सामान्य भाषा समझ का लाभ उठा सकें। इस दृष्टिकोण ने सेंटिमेंट एनालिसिस सहित व्यापक NLP कार्यों में लगातार अत्याधुनिक परिणाम दिए हैं।

PyTorch के साथ NLP के वास्तविक-जीवन अनुप्रयोग

नैचुरल लैंग्वेज प्रोसेसिंग (NLP) मॉडलों का उपयोग, विशेष रूप से PyTorch जैसे फ़्रेमवर्क के माध्यम से लागू किए गए, वास्तविक-जीवन अनुप्रयोगों में व्यापक रूप से अपनाया गया है, जिसने हमारे डिजिटल जीवन के कई पहलुओं में क्रांति ला दी है।

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

रिकमेंडेशन सिस्टम के क्षेत्र में, NLP मॉडल उपयोगकर्ता समीक्षाओं और टिप्पणियों का विश्लेषण कर प्राथमिकताएँ समझने में मदद करते हैं, जिससे सिफारिशों के निजीकरण में सुधार होता है।

सेंटिमेंट एनालिसिस टूल भी NLP पर काफी हद तक निर्भर करते हैं। ये टूल सोशल मीडिया पोस्ट, ग्राहक समीक्षाओं या किसी भी पाठ डेटा की जाँच कर उनके पीछे के भाव का अनुमान लगा सकते हैं। व्यवसाय अक्सर अपने उत्पादों या सेवाओं के बारे में जनता के मनोभाव को परखने या मार्केट रिसर्च के लिए इन अंतर्दृष्टियों का उपयोग करते हैं, जिससे वे डेटा-आधारित निर्णय ले सकें।

Google BERT के उपयोग के और वास्तविक-जीवन उदाहरण इस Natural Language Processing Tutorial में खोजें।

निष्कर्ष

PyTorch NLP मॉडल बनाने के लिए एक शक्तिशाली और लचीला प्लेटफ़ॉर्म प्रदान करता है। इस ट्यूटोरियल में, हमने LSTM आर्किटेक्चर का उपयोग करके सेंटिमेंट एनालिसिस मॉडल विकसित करने की प्रक्रिया को कवर किया, जिसमें टेक्स्ट डेटा का प्रीप्रोसेसिंग, मॉडल बनाना, उसे प्रशिक्षित और वैलिडेट करना, और अंततः अनदेखे डेटा पर भविष्यवाणी करना जैसे प्रमुख चरण शामिल थे।

यह NLP और PyTorch से संभव चीज़ों की केवल एक झलक है। NLP के अनुप्रयोग व्यापक हैं—चैटबॉट्स और रिकमेंडेशन सिस्टम से लेकर सेंटिमेंट एनालिसिस टूल्स और उससे आगे तक।

इस क्षेत्र में निरंतर प्रगति, विशेष रूप से BERT और GPT जैसे ट्रांसफर लर्निंग मॉडलों के आगमन के साथ, भविष्य की खोजों के लिए और भी रोमांचक संभावनाएँ खोलती है। PyTorch के साथ NLP में महारत हासिल करना चुनौतीपूर्ण लेकिन फलदायी है, क्योंकि यह हमारे आसपास की दुनिया को समझने और उससे इंटरैक्ट करने का एक नया आयाम खोलता है।

यदि आप PyTorch में गहराई से सीखने में रुचि रखते हैं, तो हमारा Deep Learning with PyTorch कोर्स देखें। यहाँ आप PyTorch का परिचय, PyTorch लाइब्रेरी और उसके न्यूरल नेटवर्क व डीप लर्निंग में उपयोगों का अन्वेषण करना शुरू करेंगे। अगला, आप कृत्रिम न्यूरल नेटवर्क कवर करेंगे और सीखेंगे कि उन्हें वास्तविक डेटा का उपयोग करके कैसे प्रशिक्षित किया जाता है।