Python में Bag of Words मॉडल: एक संपूर्ण मार्गदर्शिका

Bag of Words (BoW) प्राकृतिक भाषा संसाधन (NLP) में प्रयुक्त एक तकनीक है। यह व्याकरण और शब्द क्रम पर विचार किए बिना, पाठ्य डेटा को मशीन-पठनीय स्वरूप—विशेष रूप से संख्यात्मक मानों—में बदलने के लिए व्यापक रूप से उपयोग की जाती है। BoW को समझना किसी भी व्यक्ति के लिए आवश्यक है जो टेक्स्ट डेटा के साथ काम करता है। Python, Bag of Words को प्रभावी रूप से लागू करने के लिए कई टूल्स और लाइब्रेरी प्रदान करता है।

इस ट्यूटोरियल में, हम BoW को गहराई से समझेंगे, इसके कॉन्सेप्ट्स से परिचय कराएंगे, इसके उपयोग कवर करेंगे, और Python में एक विस्तृत कार्यान्वयन देखेंगे। इस ट्यूटोरियल के अंत तक, आप वास्तविक समस्याओं पर Bag of Words मॉडल लागू करने में सक्षम होंगे। यदि आप NLP में नए हैं, तो और जानने के लिए हमारी Natural Language Processing in Python स्किल ट्रैक देखें। 

Bag of Words क्या है?

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

Bag of Words किसी दस्तावेज़ में शब्दों की आवृत्ति पर आधारित होता है। प्रक्रिया टेक्स्ट में शब्दावली खोजने और उनकी उपस्थिति को मापने से शुरू होती है। इसे "बैग" इसलिए कहा जाता है क्योंकि इसमें शब्दों के क्रम और संरचना को नहीं देखा जाता, केवल उनकी उपस्थिति देखी जाती है। 

Bag of Words मॉडल, Continuous Bag of Words (CBOW) मॉडल से अलग है, जो आस-पास के शब्दों का उपयोग करके लक्ष्य शब्द का अनुमान लगाते हुए, सघन वर्ड एम्बेडिंग्स सीखता है और शब्दों के बीच अर्थ-संबंधों को कैप्चर करता है। CBOW को बड़े कॉर्पस पर प्रशिक्षण की आवश्यकता होती है और यह कम-आयामी वेक्टर तैयार करता है जो उन जटिल NLP अनुप्रयोगों में मूल्यवान हैं जहाँ संदर्भ महत्वपूर्ण होता है।

Bag of Words का उपयोग क्यों करें?

Bag of Words कई NLP कार्यों में उपयोगी है; इसके उपयोग के कुछ कारण इस प्रकार हैं:

• फीचर एक्सट्रैक्शन: यह असंरचित टेक्स्ट डेटा को संरचित डेटा में बदलता है, जिसे विभिन्न मशीन लर्निंग एल्गोरिद्म के इनपुट के रूप में उपयोग किया जा सकता है।
• सरलता और दक्षता: BoW की गणनात्मक रूप से लागू करना सरल है, और यह छोटे से मध्यम आकार के टेक्स्ट कॉर्पस पर अच्छी तरह काम करता है।
• दस्तावेज़ समानता: यह कॉसाइन समानता जैसी तकनीकों का उपयोग करके टेक्स्ट दस्तावेज़ों के बीच समानता की गणना करने में काम आ सकता है।
• टेक्स्ट वर्गीकरण: Naive Bayes जैसी तकनीकों के साथ मिलाकर, BoW स्पैम वर्गीकरण और सेंटिमेंट विश्लेषण जैसे कार्यों के लिए प्रभावी है।

हालाँकि, इसकी कुछ कमियाँ भी हैं, जैसे अर्थ, शब्द संरचना, या शब्द क्रम पर विचार न करना।

Python में Bag of Words लागू करने के चरण

Bag-of-Words मॉडल बनाने के लिए, हम कॉर्पस के सभी शब्द लेते हैं और प्रत्येक शब्द के लिए एक कॉलम बनाते हैं। पंक्तियाँ वाक्यों का प्रतिनिधित्व करती हैं। यदि कोई शब्द वाक्य में मौजूद है, तो उसे 1 से दर्शाया जाता है, और यदि शब्द मौजूद नहीं है, तो 0 से। कॉलम में प्रत्येक शब्द एकल फीचर का प्रतिनिधित्व करता है।

अंत में, हमें एक विरल मैट्रिक्स प्राप्त होता है। विरल मैट्रिक्स वह होता है जिसमें बहुत सारे शून्य होते हैं। 

डेटा प्रीप्रोसेसिंग

Python में Bag of Words मॉडल बनाने के लिए, हमें कुछ प्रीप्रोसेसिंग चरण लेने होंगे। इनमें टोकनाइजेशन और स्टॉपवर्ड्स हटाना शामिल है।

टोकनाइजेशन वह प्रक्रिया है जिसमें टेक्स्ट के किसी हिस्से को छोटे यूनिट्स—आम तौर पर शब्दों—में तोड़ा जाता है। आप NLTK का उपयोग करके टोकनाइजेशन कर सकते हैं। 

स्टॉप वर्ड्स अंग्रेज़ी के सामान्य शब्द होते हैं, जैसे "the," "that," और "a," जो किसी वाक्य की ध्रुवता में योगदान नहीं देते।

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

# Download stopwords and tokenizer if you haven't already
nltk.download("punkt")
nltk.download("stopwords")

# Example sentence
sentence = "This is an example showing how to remove stop words from a sentence."

# Tokenize the sentence into words
words = word_tokenize(sentence)

# Get the list of stop words in English
stop_words = set(stopwords.words("english"))

# Remove stop words from the sentence
filtered_sentence = [word for word in words if word.lower() not in stop_words]

# Join the words back into a sentence
filtered_sentence = " ".join(filtered_sentence)
print(filtered_sentence)संचालित द्वारा

आउटपुट:

example showing remove stop words sentence.संचालित द्वारा

शब्दावली बनाना

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

नीचे दिया गया कोड कॉर्पस में शब्दों का एक सरल फ्रीक्वेंसी वितरण बनाता है, जो शब्दावली बनाने या टेक्स्ट सामग्री समझने जैसे बुनियादी NLP कार्यों के लिए उपयोगी है:

• corpus वेरिएबल में कुछ उदाहरण वाक्य हैं। वास्तविक अनुप्रयोगों में, इसमें बड़ा और अधिक विविध टेक्स्ट डेटा होगा।
• vocab = defaultdict(int) शब्द आवृत्ति गिनने को सरल करता है; कोई नया शब्द आने पर उसकी गिनती स्वतः 0 से आरंभ होती है, जिससे बिना जाँच के सीधे बढ़ाया जा सकता है।
• प्रत्येक वाक्य को लोअरकेस में बदलकर और रेगुलर एक्सप्रेशन से शब्द निकालकर टोकनाइज़ किया जाता है। पैटर्न \b\w+\b केवल अल्फ़ान्यूमेरिक अक्षरों वाले शब्द पहचानता है और विराम चिह्नों व अन्य प्रतीकों को नजरअंदाज करता है।
• हर शब्द की गिनती vocab डिक्शनरी में अद्यतन होती है।
• शब्दावली को आवृत्ति के अनुसार अवरोही क्रम में सॉर्ट किया जाता है, ताकि सबसे आम शब्द ऊपर दिखें, और संदर्भ के लिए प्रदर्शित किया जाता है।

import re  
# Import the regular expressions module to help with text processing
from collections import (
    defaultdict,
)  

# Import defaultdict to easily handle word frequency counting

# Sample corpus of text - a small dataset of sentences to analyze
corpus = [
    "Tokenization is the process of breaking text into words.",
    "Vocabulary is the collection of unique words.",
    "The process of tokenizing is essential in NLP.",
]

# Initialize a defaultdict with integer values to store word frequencies

# defaultdict(int) initializes each new key with a default integer value of 0
vocab = defaultdict(int)

# Loop through each sentence in the corpus to tokenize and normalize
for sentence in corpus:
    # Convert the sentence to lowercase to ensure consistency in counting (e.g., 'Tokenization' and 'tokenization' are treated as the same word)
    # Use regular expressions to find words composed of alphanumeric characters only
    words = re.findall(r"\b\w+\b", sentence.lower())
    # For each word found, increment its count in the vocab dictionary
    for word in words:
        vocab[word] += 1

# Convert the defaultdict vocab to a regular dictionary for easier handling and sorting

# Sort the dictionary by word frequency in descending order and convert it to a new dictionary
sorted_vocab = dict(sorted(vocab.items(), key=lambda x: x[1], reverse=True))

# Display the sorted vocabulary with each word and its frequency count
print("Vocabulary with Frequencies:", sorted_vocab)संचालित द्वारा

आउटपुट:

Vocabulary with Frequencies: {'is': 3, 'the': 3, 'of': 3, 'process': 2, 'words': 2, 'tokenization': 1, 'breaking': 1, 'text': 1, 'into': 1, 'vocabulary': 1, 'collection': 1, 'unique': 1, 'tokenizing': 1, 'essential': 1, 'in': 1, 'nlp': 1}संचालित द्वारा

मैन्युअल रूप से शब्दावली बनाना, खासकर बड़े कॉर्पस के लिए, समय लेने वाला हो सकता है। Scikit-learn का CountVectorizer इस प्रक्रिया को स्वचालित करता है और अधिक लचीला टेक्स्ट प्रोसेसिंग देता है, जैसा कि हम आगे देखेंगे। 

Python का उपयोग करते हुए Bag of Words का कार्यान्वयन (शुरू से)

आइए Python में शुरू से एक सरल Bag of Words कार्यान्वयन से शुरू करते हैं। यह आपको इसके निर्माण खंडों और अंदर की कार्यप्रणाली को समझने में मदद करेगा।

मैन्युअल कार्यान्वयन

चरण 1: टेक्स्ट डेटा का प्रीप्रोसेसिंग

हम एक सरल फ़ंक्शन परिभाषित करके शुरू करेंगे जो टोकनाइजेशन, लोअरकेसिंग और विराम चिह्न हटाने सहित टेक्स्ट प्रोसेस करेगा।

from collections import defaultdict
import string

# Sample text data: sentences
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]
# Function to preprocess text
def preprocess(text):
    # Convert to lowercase
    text = text.lower()
    # Remove punctuation
    text = text.translate(str.maketrans("", "", string.punctuation))
    # Tokenize: split the text into words
    tokens = text.split()
    return tokens

# Apply preprocessing to the sample corpus
processed_corpus = [preprocess(sentence) for sentence in corpus]
print(processed_corpus)संचालित द्वारा

आउटपुट:

[['python', 'is', 'amazing', 'and', 'fun'], ['python', 'is', 'not', 'just', 'fun', 'but', 'also', 'powerful'], ['learning', 'python', 'is', 'fun']]संचालित द्वारा

चरण 2: शब्दावली बनाना

अब, हमें सभी दस्तावेज़ स्कैन करने हैं और अद्वितीय शब्दों की पूरी सूची बनानी है, यही हमारी शब्दावली होगी।

# Initialize an empty set for the vocabulary
vocabulary = set()

# Build the vocabulary
for sentence in processed_corpus:
    vocabulary.update(sentence)

# Convert to a sorted list
vocabulary = sorted(list(vocabulary))
print("Vocabulary:", vocabulary)संचालित द्वारा

चरण 3: शब्द आवृत्ति की गणना और वेक्टराइज़ करना

अब हम प्रोसेस्ड कॉर्पस में प्रत्येक दस्तावेज़ के लिए शब्दावली के हर शब्द की आवृत्ति की गणना करेंगे।

def create_bow_vector(sentence, vocab):
    vector = [0] * len(vocab)  # Initialize a vector of zeros
    for word in sentence:
        if word in vocab:
            idx = vocab.index(word)  # Find the index of the word in the vocabulary
            vector[idx] += 1  # Increment the count at that index
    return vector
संचालित द्वारा

इस बिंदु तक, आपने अपने कॉर्पस के प्रत्येक दस्तावेज़ के लिए Bag of Words प्रतिनिधित्व बना लिया होगा।

# Create BoW vector for each sentence in the processed corpus
bow_vectors = [create_bow_vector(sentence, vocabulary) for sentence in processed_corpus]
print("Bag of Words Vectors:")
for vector in bow_vectors:
    print(vector)
संचालित द्वारा

आउटपुट:

Bag of Words Vectors:
[0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1]संचालित द्वारा

Scikit-learn के CountVectorizer का उपयोग

Bag of Words मॉडल को मैन्युअल रूप से बनाना सीखने के लिए अच्छा है, लेकिन प्रोडक्शन अनुप्रयोगों में आप Scikit-learn जैसी कुशल, अनुकूलित लाइब्रेरी का उपयोग करना चाहेंगे।

टोकनाइजेशन के लिए हम जिस Python फ़ंक्शन का उपयोग करते हैं वह है CountVectorizer, जिसे sklearn.feature_extraction.text से इम्पोर्ट किया जाता है। CountVectorizer की विशेषताओं में से एक max_features है, जो उस अधिकतम शब्दों की संख्या को दर्शाता है जिन्हें आप bag of words मॉडल में रखना चाहते हैं। यहाँ हमने None उपयोग किया है, यानी सभी फीचर्स उपयोग होंगे। 

CountVectorizer का इंस्टेंस बनाने के बाद, .fit_transform() मेथड का उपयोग करके bag of words मॉडल बनाएँ। इसके बाद, .toarray() का उपयोग करके bag of words मॉडल को उन numpy arrays में बदलें जिन्हें मशीन लर्निंग मॉडल में भेजा जा सके।

फिट हो जाने पर, CountVectorizer ने फीचर इंडिसेस की एक डिक्शनरी बना ली होती है। शब्दावली में किसी शब्द का इंडेक्स मान, पूरे प्रशिक्षण कॉर्पस में उसकी आवृत्ति से जुड़ा होता है।

from sklearn.feature_extraction.text import CountVectorizer
# Original corpus
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]
# Create a CountVectorizer Object
vectorizer = CountVectorizer()
# Fit and transform the corpus
X = vectorizer.fit_transform(corpus)
# Print the generated vocabulary
print("Vocabulary:", vectorizer.get_feature_names_out())
# Print the Bag-of-Words matrix
print("BoW Representation:")
print(X.toarray())संचालित द्वारा

आउटपुट:

markdownVocabulary: ['also' 'amazing' 'and' 'but' 'fun' 'is' 'just' 'learning' 'not'

 'powerful' 'python']

BoW Representation:

[[0 1 1 0 1 1 0 0 0 0 1]

 [1 0 0 1 1 1 1 0 1 1 1]

 [0 0 0 0 1 1 0 1 0 0 1]]संचालित द्वारा

उदाहरण: Bag of Words लागू करना

अब पूरे प्रोसेस को दर्शाने के लिए तीन मूवी रिव्यू वाले एक छोटे टेक्स्ट कॉर्पस पर BoW मॉडल लागू करते हैं। 

हम इस छोटे कॉर्पस पर BoW मॉडल लागू करने के लिए Scikit-learn के CountVectorizer का उपयोग करेंगे।

हम जिन चरणों का पालन करेंगे, वे हैं:

• CountVectorizer अपने-आप टेक्स्ट को टोकनाइज़ करता है, विराम चिह्न हटाता है और शब्दों को लोअरकेस करता है।
• .fit_transform(corpus) कॉर्पस को डॉक्युमेंट-टर्म मैट्रिक्स में बदलता है, जहाँ प्रत्येक पंक्ति एक दस्तावेज़ और प्रत्येक कॉलम शब्दावली का एक शब्द दर्शाता है।
• X_dense वह सघन मैट्रिक्स है जो प्रत्येक दस्तावेज़ में प्रत्येक शब्द की आवृत्ति को दर्शाता है।

from sklearn.feature_extraction.text import CountVectorizer
# Sample corpus of movie reviews
corpus = [
    "I loved the movie, it was fantastic!",
    "The movie was okay, but not great.",
    "I hated the movie, it was terrible.",
]

# Initialize the CountVectorizer
vectorizer = CountVectorizer()

# Fit and transform the corpus to a document-term matrix
X = vectorizer.fit_transform(corpus)

# Convert the document-term matrix into a dense format (optional for visualization)
X_dense = X.toarray()

# Get the vocabulary (mapping of words to index positions)
vocab = vectorizer.get_feature_names_out()

# Print the vocabulary and document-term matrix
print("Vocabulary:", vocab)
print("Document-Term Matrix:\n", X_dense)संचालित द्वारा

आउटपुट:

Vocabulary: ['but' 'fantastic' 'great' 'hated' 'it' 'loved' 'movie' 'not' 'okay' 'terrible' 'the' 'was']
Document-Term Matrix:
 [[0 1 0 0 1 1 1 0 0 0 1 1]  # First review: "I loved the movie, it was fantastic!"
  [1 0 1 0 1 0 1 1 1 0 1 1]  # Second review: "The movie was okay, but not great."
  [0 0 0 1 1 0 1 0 0 1 1 1]] # Third review: "I hated the movie, it was terrible."संचालित द्वारा

ऊपर दिए गए आउटपुट की व्याख्या इस प्रकार की जा सकती है:

• कॉर्पस के प्रत्येक अद्वितीय शब्द को एक इंडेक्स सौंपा जाता है, और शब्द वर्णानुक्रम में क्रमबद्ध होते हैं। उदाहरण के लिए, "but" इंडेक्स 0 पर है, "fantastic" इंडेक्स 1 पर, "movie" इंडेक्स 6 पर, आदि।
•  डॉक्युमेंट मैट्रिक्स की प्रत्येक पंक्ति एक मूवी रिव्यू का प्रतिनिधित्व करती है, और प्रत्येक कॉलम शब्दावली के किसी शब्द के अनुरूप होता है। मैट्रिक्स के मान उस दस्तावेज़ में प्रत्येक शब्द की आवृत्ति दर्शाते हैं।
• पहला रिव्यू: [0 1 0 0 1 1 1 0 0 0 1 1] यह दर्शाता है कि:
• शब्द "fantastic" एक बार आता है (इंडेक्स 1 पर 1),
• शब्द "loved" एक बार आता है (इंडेक्स 5 पर 1),
• शब्द "movie" एक बार आता है (इंडेक्स 6 पर 1),
• शब्द "it" एक बार आता है (इंडेक्स 4 पर 1),
• आदि।

BoW वेक्टर की व्याख्या इस प्रकार की जा सकती है:

• प्रत्येक दस्तावेज़ संख्याओं के एक वेक्टर के रूप में होता है जो शब्द गणनाओं का प्रतिनिधित्व करता है। वेक्टर के आयाम शब्दावली के आकार के बराबर होते हैं। इस मामले में, शब्दावली में 12 शब्द हैं, इसलिए प्रत्येक रिव्यू 12-आयामी वेक्टर में बदल जाता है।
• प्रत्येक पंक्ति में अधिकांश मान शून्य होते हैं क्योंकि हर दस्तावेज़ में शब्दावली के हर शब्द मौजूद नहीं होते। इसलिए, BoW मॉडल अक्सर विरल होते हैं, यानी इनमें बहुत सारे शून्य होते हैं।

Bag of Words के लाभ और सीमाएँ

अब हम Bag of Words मॉडल के कुछ लाभ और सीमाएँ कवर करते हैं।

लाभ

1. लागू करने और समझने में सरल: Bag of Words मॉडल सबसे सरल टेक्स्ट प्रतिनिधित्व तकनीकों में से एक है, जो इसे शुरुआती लोगों के लिए आदर्श बनाता है। इसकी सरलता, जटिल प्रीप्रोसेसिंग या विशेष मॉडल्स की आवश्यकता के बिना, तेज़ कार्यान्वयन की अनुमति देती है।
2. टेक्स्ट वर्गीकरण कार्यों में उपयोग में आसान: Bag of Words टेक्स्ट वर्गीकरण, सेंटिमेंट विश्लेषण, और स्पैम डिटेक्शन जैसे बुनियादी कार्यों के लिए उपयुक्त है। इन कार्यों में अक्सर परिष्कृत भाषा मॉडलों की आवश्यकता नहीं होती, इसलिए BOW प्रतिनिधित्व पर्याप्त और कुशल होता है।

सीमाएँ

1. शब्दावली का आकार विरलता को प्रभावित करता है: शब्दावली जितनी बड़ी होगी, प्रतिनिधित्व उतना ही अधिक विरल और उच्च-आयामी होगा। यह विरलता मॉडलों के लिए प्रभावी ढंग से सीखना कठिन बना सकती है और अत्यधिक गणनात्मक लागत से बचने के लिए शब्दावली आकार का सावधानीपूर्वक ट्यूनिंग आवश्यक बनाती है।
2. विरल मैट्रिक्स उत्पन्न करता है जो गणनात्मक रूप से महंगे होते हैं: चूँकि प्रत्येक दस्तावेज़ को संभावित रूप से बड़ी शब्दावली में प्रत्येक शब्द की आवृत्ति द्वारा दर्शाया जाता है, परिणामी मैट्रिक्स अक्सर अधिकांशतः शून्य होते हैं, जिन्हें मशीन लर्निंग पाइपलाइनों में स्टोर और प्रोसेस करना अल्प-प्रभावी हो सकता है। बड़े डेटासेट के साथ, विरल मैट्रिसेस को प्रभावी ढंग से स्टोर और कंप्यूट करने के लिए विशेष टूल्स और लाइब्रेरी की आवश्यकता पड़ती है।
3. अर्थ और संदर्भ खो देता है: BOW शब्द क्रम और वाक्य रचना को नजरअंदाज करता है, जिससे व्याकरणिक संबंध और अर्थ खो जाते हैं। यह सीमा उन कार्यों के लिए इसे कम उपयुक्त बनाती है जहाँ संदर्भ, बारीकियाँ, और शब्द क्रम मायने रखते हैं, जैसे अनुवाद या जटिल वाक्यों में सेंटिमेंट पहचान।

Bag of Words में शब्दावली के आकार को घटाने के लिए निम्नलिखित रणनीतियाँ उपयोग की जा सकती हैं:

• केस को नजरअंदाज करना। 
• विराम चिह्न हटाना।
• स्टॉपवर्ड्स हटाना, यानी the और a जैसे सामान्य शब्द। 
• सुनिश्चित करना कि सभी शब्द सही तरीके से वर्तनीगत हों। 
• शब्दों को मूल रूप में लाने के लिए स्टेमिंग तकनीकों का उपयोग करना।

अगले कदम: Bag of Words से आगे

Bag of Words मॉडल की एक सीमा यह है कि यह सभी शब्दों को समान मानता है। दुर्भाग्य से, इससे ऐसी समस्याएँ हो सकती हैं जहाँ कुछ शब्द केवल बार-बार आने के कारण अधिक महत्व पा लेते हैं। 

TF-IDF (Term Frequency-Inverse Document Frequency) इस समस्या का समाधान देता है, क्योंकि यह सभी दस्तावेज़ों में शब्दों की आवृत्ति के आधार पर उनके वज़न को समायोजित करता है।

TF-IDF: Bag of Words का विस्तार

Term Frequency (TF) किसी दस्तावेज़ में किसी शब्द की आवृत्ति को दर्शाता है। Inverse Document Frequency (IDF) कई दस्तावेज़ों में सामान्य रूप से आने वाले शब्दों के प्रभाव को घटाता है। TF-IDF स्कोर इन दोनों मानकों के गुणन से निकाला जाता है। 

मान लीजिए किसी दस्तावेज़ में 200 शब्द हैं, जहाँ love शब्द 5 बार आता है। तब love का TF (5 / 200) = 0.025 होगा। मानते हुए कि हमारे पास दस लाख दस्तावेज़ हैं और love उनमें से एक हज़ार में आता है, तो IDF = log(1000000 / 1000) = 3 होगा। TF-IDF वजन इन मानों का गुणन होगा: 0.025 * 3 = 0.075।

Scikit-learn में, इसे TfidfVectorizer क्लास का उपयोग करके काफ़ी आसानी से निकाला जा सकता है।

from sklearn.feature_extraction.text import TfidfVectorizer
# Sample corpus
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]

# Create the Tf-idf vectorizer
tfidf_vectorizer = TfidfVectorizer()

# Fit and transform the corpus
X_tfidf = tfidf_vectorizer.fit_transform(corpus)

# Show the Vocabulary
print("Vocabulary:", tfidf_vectorizer.get_feature_names_out())

# Show the TF-IDF Matrix
print("TF-IDF Representation:")
print(X_tfidf.toarray())संचालित द्वारा

आउटपुट:

Vocabulary: ['also' 'amazing' 'and' 'but' 'fun' 'is' 'just' 'learning' 'not'
 'powerful' 'python']
TF-IDF Representation:
[[0.         0.57292883 0.57292883 0.         0.338381   0.338381
  0.         0.         0.         0.         0.338381  ]
 [0.40667606 0.         0.         0.40667606 0.24018943 0.24018943
  0.40667606 0.         0.40667606 0.40667606 0.24018943]
 [0.         0.         0.         0.         0.41285857 0.41285857
  0.         0.69903033 0.         0.         0.41285857]]
संचालित द्वारा

ऊपर लागू TF-IDF मैट्रिक्स आपको कच्ची आवृत्तियों के बजाय वेटेड माप देता है।

हालाँकि Bag of Words मॉडल की सीमाएँ हैं, खासकर बड़े और अधिक जटिल डेटासेट्स के लिए, फिर भी यह कई NLP अनुप्रयोगों में एक बुनियादी निर्माण खंड है। इसे समझना आपको word embeddings और Transformers जैसे उन्नत मॉडलों का पता लगाने में सहायता करेगा।

यहाँ से, आप अपने प्रोजेक्ट्स में BoW के साथ प्रयोग कर सकते हैं, जैसे स्पैम डिटेक्शन, सेंटिमेंट विश्लेषण, डॉक्युमेंट क्लस्टरिंग, आदि।

यदि आप Bag of Words से आगे और सुधार चाहते हैं, तो आप Word2Vec, और GloVe जैसी विधियों या BERT जैसे डीप लर्निंग मॉडलों का अन्वेषण कर सकते हैं।

अंतिम विचार

Bag of Words तकनीक प्राकृतिक भाषा संसाधन में प्रयुक्त एक मौलिक तकनीक है। यह असंरचित टेक्स्ट को उन संख्यात्मक फीचर्स में बदलने का एक सरल, फिर भी प्रभावी तरीका है जिन्हें मशीन लर्निंग एल्गोरिद्म उपयोग कर सकते हैं। इस ट्यूटोरियल में, हमने कवर किया है:

• Bag of Words (BoW) मॉडल क्या है?
• मशीन लर्निंग मॉडल बनाने में Bag of Words मॉडल के फायदे।
• Python में Bag of Words मॉडल कैसे लागू करें।
•  Bag of Words के लाभ और सीमाएँ।
• Bag of Words मॉडल के पीछे का सिद्धांत और प्रेरणा।
• पारंपरिक Bag of Words दृष्टिकोण में सुधार के रूप में TF-IDF का परिचय।

प्राकृतिक भाषा संसाधन में गहराई से जाने के लिए हमारा Natural Language Processing in Python स्किल ट्रैक देखें।