अपनी LLM का उपयोग करके सेंटिमेंट एनालिसिस टूल बनाना

परिचय

सेंटिमेंट एनालिसिस एक प्रक्रिया है जिसमें टेक्स्ट की भावनात्मक टोन का निर्धारण किया जाता है, जिसे मार्केटिंग, ग्राहक सेवा या जनमत सर्वेक्षण जैसे कई क्षेत्रों में लागू किया जा सकता है। इस लेख में, हम बड़े भाषा मॉडल (LLM) का उपयोग करके अपने स्वयं के सेंटिमेंट एनालिसिस टूल बनाने की प्रक्रिया का वर्णन करेंगे।

मॉडल का चयन

पहली कदम एक उपयुक्त भाषा मॉडल का चयन करना है। हम चुन सकते हैं:

• प्री-ट्रेन्ड मॉडल (जैसे BERT, RoBERTa, DistilBERT) – तैयार उपयोग के लिए, लेकिन अनुकूलन की आवश्यकता होती है।
• विशेषज्ञ मॉडल (जैसे VADER, TextBlob) – विशेष रूप से सेंटिमेंट एनालिसिस के लिए डिज़ाइन किए गए।
• स्वयं के मॉडल – अपने क्षेत्र के लिए विशिष्ट डेटा पर ट्रेन्ड किए गए।

हमारी उदाहरण के लिए, हम Hugging Face Transformers का उपयोग DistilBERT मॉडल के साथ करेंगे, जो BERT का हल्का संस्करण है और सेंटिमेंट एनालिसिस टास्क के लिए अच्छी तरह से उपयुक्त है।

आवश्यक लाइब्रेरीज का इंस्टॉलेशन

शुरू करने के लिए, हम आवश्यक लाइब्रेरीज को इंस्टॉल करें:

pip install transformers torch pandas

मॉडल और टोकनाइज़र को लोड करना

अगला, मॉडल और टोकनाइज़र को लोड करना:

from transformers import pipeline

# सेंटिमेंट एनालिसिस के लिए तैयार टूल लोड करना
sentiment_pipeline = pipeline("sentiment-analysis")

डेटा की तैयारी

हम टेस्ट करने के लिए एक डेटासेट तैयार करें। हम एक सरल उदाहरण का उपयोग कर सकते हैं:

texts = [
    "मुझे यह उत्पाद पसंद है, यह अद्भुत है!",
    "मैं सलाह नहीं दूंगा, बहुत निराश हुआ.",
    "मध्यम उत्पाद, कुछ विशेष नहीं.",
    "कार्यक्षमता संतोषजनक है, लेकिन कीमत बहुत अधिक है."
]

सेंटिमेंट एनालिसिस

अब हम अपने टेक्स्ट्स के लिए सेंटिमेंट एनालिसिस कर सकते हैं:

results = sentiment_pipeline(texts)

for text, result in zip(texts, results):
    print(f"टेक्स्ट: {text}")
    print(f"सेंटिमेंट: {result['label']} (निश्चितता: {result['score']:.2f})")
    print("---")

मॉडल को अनुकूलित करना

अगर हम अपने विशिष्ट डेटा के लिए मॉडल को अनुकूलित करना चाहते हैं, तो हम Hugging Face Transformers लाइब्रेरी का उपयोग करके अपने डेटासेट पर मॉडल को ट्रेन कर सकते हैं।

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import Trainer, TrainingArguments
import pandas as pd
from sklearn.model_selection import train_test_split

# उदाहरण डेटासेट
data = pd.DataFrame({
    "text": ["मुझे यह उत्पाद पसंद है", "मैं सलाह नहीं दूंगा", "मध्यम उत्पाद"],
    "label": [1, 0, 0]  # 1 - सकारात्मक, 0 - नकारात्मक
})

# डेटा को ट्रेनिंग और टेस्ट सेट में विभाजित करना
train_texts, test_texts, train_labels, test_labels = train_test_split(
    data["text"], data["label"], test_size=0.2
)

# टोकनाइज़र और मॉडल लोड करना
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# डेटा टोकनाइज़ करना
train_encodings = tokenizer(list(train_texts), truncation=True, padding=True)
test_encodings = tokenizer(list(test_texts), truncation=True, padding=True)

# डेटा हैंडलिंग के लिए क्लास
class SentimentDataset(torch.utils.data.Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item["labels"] = torch.tensor(self.labels[idx])
        return item

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

train_dataset = SentimentDataset(train_encodings, train_labels)
test_dataset = SentimentDataset(test_encodings, test_labels)

# ट्रेनिंग सेटिंग्स
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
)

# मॉडल ट्रेनिंग
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset
)

trainer.train()

मॉडल को डिप्लॉय करना

मॉडल को ट्रेन करने के बाद, हम इसे सेव कर सकते हैं और सेंटिमेंट एनालिसिस के लिए उपयोग कर सकते हैं:

model.save_pretrained("./custom_sentiment_model")
tokenizer.save_pretrained("./custom_sentiment_model")

# अनुकूलित मॉडल लोड करना
custom_model = AutoModelForSequenceClassification.from_pretrained("./custom_sentiment_model")
custom_tokenizer = AutoTokenizer.from_pretrained("./custom_sentiment_model")

# उदाहरण एनालिसिस
custom_pipeline = pipeline("sentiment-analysis", model=custom_model, tokenizer=custom_tokenizer)
print(custom_pipeline("यह उत्पाद शानदार है!"))

सारांश

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