एलएलएम सिंथेटिक डेटा जेनरेशन पर पूर्ण गाइड

from transformers import AutoTokenizer, AutoModelForCausalLM

<p># एक प्री-ट्रेन्ड एलएलएम लोड करें
model_name = "gpt2-large"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)</p>

<p># सिंथेटिक डेटा जेनरेशन के लिए एक प्रॉम्प्ट परिभाषित करें
prompt = "एक स्मार्टफोन के लिए एक ग्राहक समीक्षा जेनरेट करें:"</p>

<p># सिंथेटिक डेटा जेनरेट करें
input_ids = tokenizer.encode(prompt, return_tensors="pt")
output = model.generate(input_ids, max_length=100, num_return_sequences=1)</p>

<p># जेनरेटेड टेक्स्ट को डिकोड और प्रिंट करें
synthetic_review = tokenizer.decode(output[0], skip_special_tokens=True)
print(synthetic_review)

prompt = """
एक विस्तृत ग्राहक समीक्षा जेनरेट करें जो एक स्मार्टफोन के लिए निम्नलिखित विशेषताओं के साथ है:
- ब्रांड: {ब्रांड}
- मॉडल: {मॉडल}
- मुख्य विशेषताएं: {विशेषताएं}
- रेटिंग: {रेटिंग}/5 स्टार

<p>समीक्षा 50-100 शब्दों के बीच होनी चाहिए और इसमें दोनों सकारात्मक और नकारात्मक पहलुओं को शामिल किया जाना चाहिए।</p>

समीक्षा:
"""
</p>

<p>brands = ["एप्पल", "सैमसंग", "गूगल", "वनप्लस"]
models = ["आईफोन 13 प्रो", "गैलेक्सी एस21", "पिक्सल 6", "9 प्रो"]
features = ["5जी, ओएलईडी डिस्प्ले, ट्रिपल कैमरा", "120Hz रिफ्रेश रेट, 8K वीडियो", "एआई-पावर्ड कैमरा, 5जी", "फास्ट चार्जिंग, 120Hz डिस्प्ले"]
ratings = [4, 3, 5, 4]</p>

<p># कई समीक्षाएं जेनरेट करें
for brand, model, feature, rating in zip(brands, models, features, ratings):
filled_prompt = prompt.format(brand=brand, model=model, features=feature, rating=rating)
input_ids = tokenizer.encode(filled_prompt, return_tensors="pt")
output = model.generate(input_ids, max_length=200, num_return_sequences=1)
synthetic_review = tokenizer.decode(output[0], skip_special_tokens=True)
print(f"समीक्षा {brand} {model} के लिए:\n{synthetic_review}\n")

few_shot_prompt = """
ग्राहक सहायता के बारे में एक एजेंट (ए) और एक ग्राहक (सी) के बीच एक बातचीत जेनरेट करें जो एक उत्पाद समस्या के बारे में है। इस प्रारूप का पालन करें:

<p>स: हैलो, मैं अपने नए हेडफ़ोन के साथ समस्या का सामना कर रहा हूं। दायां ईयरबड़ काम नहीं कर रहा है।
ए: मुझे यह सुनकर खेद है। क्या आप मुझे बता सकते हैं कि आपके पास कौन सा हेडफ़ोन मॉडल है?
स: यह साउंडमैक्स प्रो 3000 है।
ए: धन्यवाद। क्या आपने हेडफ़ोन को रीसेट करने की कोशिश की है जिससे उन्हें 10 सेकंड के लिए चार्जिंग केस में रखा जा सके?
स: हां, मैंने यह कोशिश की, लेकिन इससे मदद नहीं मिली।
ए: मुझे दिखाई दे रहा है। आइए एक फ़र्मवेयर अपडेट का प्रयास करें। क्या आप कृपया हमारी वेबसाइट पर जाकर नवीनतम फ़र्मवेयर डाउनलोड कर सकते हैं?</p>

<p>अब एक अलग उत्पाद समस्या के बारे में एक नई बातचीत जेनरेट करें:</p>

<p>स: हाय, मैंने अभी अपनी नई स्मार्टवॉच प्राप्त की है, लेकिन यह चालू नहीं हो रही है।
"""
</p>

<p># बातचीत जेनरेट करें
input_ids = tokenizer.encode(few_shot_prompt, return_tensors="pt")
output = model.generate(input_ids, max_length=500, num_return_sequences=1)
synthetic_conversation = tokenizer.decode(output[0], skip_special_tokens=True)
print(synthetic_conversation)

यह दृष्टिकोण एलएलएम को वांछित बातचीत संरचना और शैली को समझने में मदद करता है, जिससे अधिक वास्तविक सिंथेटिक ग्राहक सहायता बातचीत होती है।

from transformers import GPT2LMHeadModel, GPT2Tokenizer
import torch

<p>model = GPT2LMHeadModel.from_pretrained("gpt2-medium")
tokenizer = GPT2Tokenizer.from_pretrained("gpt2-medium")</p>

<p>def generate_conditional_text(prompt, condition, max_length=100):
input_ids = tokenizer.encode(prompt, return_tensors="pt")
attention_mask = torch.ones(input_ids.shape, dtype=torch.long, device=input_ids.device)</p>

<p># स्थिति को एनकोड करें
condition_ids = tokenizer.encode(condition, add_special_tokens=False, return_tensors="pt")</p>

<p># इनपुट आईडी के साथ स्थिति को संयोजित करें
input_ids = torch.cat([condition_ids, input_ids], dim=-1)
attention_mask = torch.cat([torch.ones(condition_ids.shape, dtype=torch.long, device=condition_ids.device), attention_mask], dim=-1)</p>

<p>output = model.generate(input_ids, attention_mask=attention_mask, max_length=max_length, num_return_sequences=1, no_repeat_ngram_size=2, do_sample=True, top_k=50, top_p=0.95, temperature=0.7)</p>

<p>return tokenizer.decode(output[0], skip_special_tokens=True)</p>

<p># विभिन्न स्थितियों के साथ उत्पाद विवरण जेनरेट करें
conditions = ["विलासिता", "बजट-अनुकूल", "पर्यावरण-अनुकूल", "उच्च-प्रौद्योगिकी"]
prompt = "एक बैकपैक का विवरण दें:"</p>

<p>for condition in conditions:
description = generate_conditional_text(prompt, condition)
print(f"{condition} बैकपैक विवरण:\n{description}\n")</p>

import pandas as pd
from sklearn.model_selection import train_test_split
from transformers import pipeline

<p># एक छोटा वास्तविक दुनिया का डेटासेट लोड करें
real_data = pd.read_csv("small_product_reviews.csv")</p>

<p># डेटा को विभाजित करें
train_data, test_data = train_test_split(real_data, test_size=0.2, random_state=42)</p>

<p># टेक्स्ट जेनरेशन पाइपलाइन को आरंभ करें
generator = pipeline("text-generation", model="gpt2-medium")</p>

<p>def augment_dataset(data, num_synthetic_samples):
synthetic_data = []
for _, row in data.iterrows():
prompt = f"Generate a product review similar to: {row['review']}\nNew review:"
synthetic_review = generator(prompt, max_length=100, num_return_sequences=1)[0]['generated_text']
synthetic_data.append({'review': synthetic_review, 'sentiment': row['sentiment'] # Assuming the sentiment is preserved})
if len(synthetic_data) &gt;= num_synthetic_samples:
break
return pd.DataFrame(synthetic_data)</p>

<p># सिंथेटिक डेटा जेनरेट करें
synthetic_train_data = augment_dataset(train_data, num_synthetic_samples=len(train_data))</p>

<p># वास्तविक और सिंथेटिक डेटा को मिलाएं
augmented_train_data = pd.concat([train_data, synthetic_train_data], ignore_index=True)</p>

<p>print(f"मूल प्रशिक्षण डेटा आकार: {len(train_data)}")
print(f"वृद्ध प्रशिक्षण डेटा आकार: {len(augmented_train_data)}")</p>