# Original Text
text = “آپ کا نام کیا ہے؟ میں آپ کی مدد کر سکتا ہوں۔”

# After Tokenization
tokens = [“آپ”, “کا”, “نام”, “کیا”, “ہے”, “میں”, “آپ”, “کی”, “مدد”, “کر”, “سکتا”, “ہوں”]

# After Stopword Removal (removing common Urdu words)
filtered = [“نام”, “کیا”, “مدد”, “کر”, “سکتا”]

# After Lemmatization (reducing to root forms)
lemmatized = [“نام”, “کیا”, “مدد”, “کرنا”, “سکنا”]

# Original Text
text = “I am learning NLP and it’s fascinating!”

# Tokenization
tokens = [“I”, “am”, “learning”, “NLP”, “and”, “it’s”, “fascinating”, “!”]

# Lowercasing & Punctuation Removal
cleaned = [“i”, “am”, “learning”, “nlp”, “and”, “its”, “fascinating”]

# Stopword Removal
filtered = [“learning”, “nlp”, “fascinating”]

# Lemmatization
lemmatized = [“learn”, “nlp”, “fascinating”]

# Create conda environment
conda create -n hf_env python=3.10 -y
conda activate hf_env

# Install core packages
pip install transformers datasets torch
pip install tensorflow # Optional, for TensorFlow models
pip install ipykernel # For Jupyter notebooks

# Verify installation
python -c “from transformers import pipeline; print(‘✅ Installation successful!’)”

from transformers import pipeline

# English to Urdu translation
translator = pipeline(
“translation”,
model=”Helsinki-NLP/opus-mt-en-ur”
)

english_texts = [
“Hello, how are you?”,
“Pakistan is a beautiful country.”,
“I am learning machine learning.”
]

for text in english_texts:
result = translator(text)
print(f”English: {text}”)
print(f”Urdu: {result[0][‘translation_text’]}”)
print(“-” * 50)

# Text summarization
summarizer = pipeline(“summarization”)

long_text = “””
Artificial Intelligence (AI) is rapidly transforming various industries around the world.
From healthcare to finance, from transportation to entertainment, AI is revolutionizing
how we work and live. Machine learning, a subset of AI, enables computers to learn
and improve from experience without being explicitly programmed. Natural Language
Processing (NLP) is another crucial component that allows machines to understand,
interpret, and generate human language. Deep learning, powered by neural networks,
has achieved remarkable breakthroughs in image recognition, speech processing, and
language understanding. As AI continues to evolve, it promises to solve complex
problems and create new opportunities across multiple sectors.
“””

summary = summarizer(long_text, max_length=50, min_length=25)
print(“Original text length:”, len(long_text.split()))
print(“Summary length:”, len(summary[0][‘summary_text’].split()))
print(“\nSummary:”)
print(summary[0][‘summary_text’])

# Question answering
qa_pipeline = pipeline(“question-answering”)

context = “””
Pakistan is a country in South Asia. It is the world’s sixth-most populous country
with a population exceeding 225 million. Islamabad is the capital city, while Karachi
is the largest city and financial center. The country was established in 1947 as a
homeland for Muslims. Pakistan has four provinces: Punjab, Sindh, Khyber Pakhtunkhwa,
and Balochistan.
“””

questions = [
“What is the capital of Pakistan?”,
“When was Pakistan established?”,
“How many provinces does Pakistan have?”,
“Which is the largest city of Pakistan?”
]

for question in questions:
answer = qa_pipeline(question=question, context=context)
print(f”Question: {question}”)
print(f”Answer: {answer[‘answer’]} (confidence: {answer[‘score’]:.3f})”)
print(“-” * 50)

# Named Entity Recognition
ner = pipeline(“ner”, aggregation_strategy=”simple”)

text = “Imran Khan was born in Lahore, Pakistan. He played cricket for Pakistan national team.”

entities = ner(text)
print(“Text:”, text)
print(“\nEntities found:”)
for entity in entities:
print(f”- {entity[‘word’]}: {entity[‘entity_group’]} (confidence: {entity[‘score’]:.3f})”)

# Expected output:
# – Imran Khan: PER (Person)
# – Lahore: LOC (Location)
# – Pakistan: LOC (Location)

# Urdu text generation
generator = pipeline(
“text-generation”,
model=”flax-community/gpt2-base-urdu”
)

urdu_prompts = [
“پاکستان میں”,
“اردو زبان”,
“تعلیم کی اہمیت”
]

for prompt in urdu_prompts:
result = generator(
prompt,
max_length=30,
num_return_sequences=1,
pad_token_id=50256
)
print(f”Prompt: {prompt}”)
print(f”Generated: {result[0][‘generated_text’]}”)
print(“-” * 50)

import pandas as pd
from transformers import pipeline
import matplotlib.pyplot as plt
from collections import Counter

class MultilingualSentimentAnalyzer:
def __init__(self):
# Initialize models for different languages
self.english_classifier = pipeline(“sentiment-analysis”)
self.urdu_classifier = pipeline(
“text-classification”,
model=”asafaya/bert-base-urdu”
)

def detect_language(self, text):
# Simple language detection based on character script
urdu_chars = sum(1 for char in text if ‘\u0600’ <= char <= '\u06FF') total_chars = len([c for c in text if c.isalpha()]) if total_chars == 0: return "unknown" urdu_ratio = urdu_chars / total_chars return "urdu" if urdu_ratio > 0.3 else “english”

def analyze_sentiment(self, text):
language = self.detect_language(text)

if language == “urdu”:
result = self.urdu_classifier(text)
else:
result = self.english_classifier(text)

return {
‘text’: text,
‘language’: language,
‘sentiment’: result[0][‘label’],
‘confidence’: result[0][‘score’]
}

def analyze_batch(self, texts):
results = []
for text in texts:
results.append(self.analyze_sentiment(text))
return results

def create_report(self, results):
# Create summary statistics
sentiments = [r[‘sentiment’] for r in results]
languages = [r[‘language’] for r in results]

sentiment_counts = Counter(sentiments)
language_counts = Counter(languages)

print(“📊 SENTIMENT ANALYSIS REPORT”)
print(“=” * 40)
print(f”Total texts analyzed: {len(results)}”)
print(f”\nLanguage distribution:”)
for lang, count in language_counts.items():
print(f” {lang.title()}: {count} ({count/len(results)*100:.1f}%)”)

print(f”\nSentiment distribution:”)
for sentiment, count in sentiment_counts.items():
print(f” {sentiment}: {count} ({count/len(results)*100:.1f}%)”)

return sentiment_counts, language_counts

# Usage example
analyzer = MultilingualSentimentAnalyzer()

# Test with mixed English and Urdu texts
sample_texts = [
“I love this product! It’s amazing!”,
“This is terrible quality.”,
“یہ بہت اچھا ہے”,
“برا کوالٹی ہے”,
“Pakistan is a beautiful country”,
“پاکستان میں بہترین کھانا ملتا ہے”,
“The service was okay, nothing special”,
“اوسط سروس تھی”
]

# Analyze all texts
results = analyzer.analyze_batch(sample_texts)

# Print detailed results
print(“🔍 DETAILED ANALYSIS”)
print(“=” * 50)
for result in results:
print(f”Text: {result[‘text’]}”)
print(f”Language: {result[‘language’]}”)
print(f”Sentiment: {result[‘sentiment’]} (confidence: {result[‘confidence’]:.3f})”)
print(“-” * 50)

# Generate report
sentiment_counts, language_counts = analyzer.create_report(results)

# Create visualizations
import matplotlib.pyplot as plt
plt.style.use(‘seaborn-v0_8’)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

# Sentiment distribution pie chart
sentiment_labels = list(sentiment_counts.keys())
sentiment_values = list(sentiment_counts.values())
colors = [‘#2E8B57’, ‘#DC143C’, ‘#FFD700′] # Green, Red, Gold

ax1.pie(sentiment_values, labels=sentiment_labels, autopct=’%1.1f%%’,
colors=colors, startangle=90)
ax1.set_title(‘Sentiment Distribution’, fontsize=14, fontweight=’bold’)

# Language distribution bar chart
language_labels = list(language_counts.keys())
language_values = list(language_counts.values())

bars = ax2.bar(language_labels, language_values, color=[‘#4A90E2’, ‘#7B68EE’])
ax2.set_title(‘Language Distribution’, fontsize=14, fontweight=’bold’)
ax2.set_ylabel(‘Number of Texts’)

# Add value labels on bars
for bar, value in zip(bars, language_values):
ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.1,
str(value), ha=’center’, va=’bottom’, fontweight=’bold’)

plt.tight_layout()
plt.show()

# Save results to CSV for further analysis
df = pd.DataFrame(results)
df.to_csv(‘sentiment_analysis_results.csv’, index=False)
print(“💾 Results saved to ‘sentiment_analysis_results.csv'”)

# Advanced feature: Real-time analysis from file
def analyze_file(file_path):
“””Analyze sentiment from a text file”””
analyzer = MultilingualSentimentAnalyzer()

with open(file_path, ‘r’, encoding=’utf-8′) as file:
texts = [line.strip() for line in file if line.strip()]

print(f”📄 Analyzing {len(texts)} texts from {file_path}”)
results = analyzer.analyze_batch(texts)

# Generate comprehensive report
sentiment_counts, language_counts = analyzer.create_report(results)

# Calculate average confidence
avg_confidence = sum(r[‘confidence’] for r in results) / len(results)
print(f”\n📊 Average confidence: {avg_confidence:.3f}”)

# Find most confident predictions
most_confident = max(results, key=lambda x: x[‘confidence’])
least_confident = min(results, key=lambda x: x[‘confidence’])

print(f”\n🎯 Most confident prediction:”)
print(f” Text: {most_confident[‘text’][:50]}…”)
print(f” Sentiment: {most_confident[‘sentiment’]} ({most_confident[‘confidence’]:.3f})”)

print(f”\n❓ Least confident prediction:”)
print(f” Text: {least_confident[‘text’][:50]}…”)
print(f” Sentiment: {least_confident[‘sentiment’]} ({least_confident[‘confidence’]:.3f})”)

return results

# Example usage (uncomment to use with your own file)
# results = analyze_file(‘reviews.txt’)