टेक्स्ट क्लासिफिकेशन का ओवरव्यू

PyTorch के साथ टेक्स्ट के लिए डीप लर्निंग

Shubham Jain

Instructor

टेक्स्ट क्लासिफिकेशन क्या है

टेक्स्ट को लेबल देना
शब्दों और वाक्यों का अर्थ निकालना

मशीन लर्निंग में क्लासिफिकेशन के प्रकार

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

बाइनरी क्लासिफिकेशन

दो श्रेणियों में छाँटना
उदाहरण: ईमेल स्पैम डिटेक्शन
ईमेल 'spam' या 'not spam' हो सकते हैं

बाइनरी क्लासिफिकेशन

¹ https://storage.googleapis.com/gweb-cloudblog-publish/images/image4_v2LFcq0.max-1200x1200.png

मल्टी-क्लास क्लासिफिकेशन

न्यूज़ क्लासिफिकेशन

कई श्रेणियों में छाँटना
उदाहरण: न्यूज़ आर्टिकल्स को इन कैटेगरी में बाँटा जा सकता है
1. Politics
2. Sports
3. Technology

मल्टी-लेबल क्लासिफिकेशन

हर टेक्स्ट को कई लेबल दिए जा सकते हैं
उदाहरण: Books कई जॉनर हो सकते हैं
- Action
- Adventure
- Fantasy

वर्ड एम्बेडिंग्स क्या हैं

वर्ड एम्बेडिंग पाइपलाइन

वर्ड एम्बेडिंग उदाहरण

पहले के एनकोडिंग तरीके शुरुआती कदम के लिए अच्छे हैं
- अक्सर बहुत ज़्यादा फीचर्स बनाते हैं और मिलते-जुलते शब्द नहीं पहचान पाते
वर्ड एम्बेडिंग्स शब्दों को न्यूमेरिकल वेक्टर्स में मैप करती हैं
सेमांटिक रिलेशन का उदाहरण:
- King और queen
- Man और woman

वर्ड-टू-इंडेक्स मैपिंग

उदाहरण:
- "King" -> 1
- "Queen" -> 2
कॉम्पैक्ट और कम्प्यूटेशनली एफिशिएंट
पाइपलाइन में टोकनाइज़ेशन के बाद आता है

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

torch.nn.Embedding:
- इंडेक्स से वर्ड वेक्टर्स बनाता है

इनपुट: Indexes for ['The', 'cat', 'sat', 'on', 'the', 'mat']

Embedding for 'the': tensor([-0.4689,  0.3164, -0.2971, -0.1291,  0.4064])
Embedding for 'cat': tensor([-0.0978, -0.4764,  0.0476,  0.1044, -0.3976])
Embedding for 'sat': tensor([ 0.2731,  0.4431,  0.1275,  0.1434, -0.4721])

torch.nn.Embedding का उपयोग

import torch
from torch import nn

words = ["The", "cat", "sat", "on", "the", "mat"]
word_to_idx = {word: i for i, word in enumerate(words)}

inputs = torch.LongTensor([word_to_idx[w] for w in words])

embedding = nn.Embedding(num_embeddings=len(words), embedding_dim=10)

output = embedding(inputs)

print(output)

tensor([[ 1.0624,  0.6792,  0.0459,  ... -1.0828, -0.4475,  0.4868],
         ...
         [1.5766,  0.0106,  0.1161,  ...,,  -0.0859, 1.3160,  1.3621])

पाइपलाइन में एम्बेडिंग्स का उपयोग

def preprocess_sentences(text):
  # Tokenization
  # Stemming
  ...

  # Word to index mapping

class TextDataset(Dataset):
    def __init__(self, encoded_sentences):
        self.data = encoded_sentences

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        return self.data[index]

def text_processing_pipeline(text):
    tokens = preprocess_sentences(text)
    dataset = TextDataset(tokens)
    dataloader = DataLoader(dataset, batch_size=2, 
                            shuffle=True)
    return dataloader, vectorizer


text = "Your sample text here."
dataloader, vectorizer = text_processing_pipeline(text)

embedding = nn.Embedding(num_embeddings=10,
                         embedding_dim=50) 

for batch in dataloader:
    output = embedding(batch)
    print(output)

अभ्यास करते हैं!

PyTorch के साथ टेक्स्ट के लिए डीप लर्निंग