مهندس معالجة اللغات الطبيعية

|
ما هو مهندس NLP؟ خارطة التعلم

فيديوهات تعليمية

مشاهدة قائمة التشغيل على YouTube

ما هو مهندس معالجة اللغات الطبيعية؟

مهندس معالجة اللغات الطبيعية (NLP Engineer)

مهندس معالجة اللغات الطبيعية هو متخصص يصمم ويبني أنظمة ذكاء اصطناعي قادرة على فهم ومعالجة اللغة البشرية، مثل الترجمة الآلية، تحليل المشاعر، والرد على الأسئلة.

معالجة النصوص

فهم وتجهيز اللغة البشرية

نماذج الذكاء الاصطناعي

بناء نماذج التعلم العميق للغة

تحليل المشاعر

تحليل المشاعر في النصوص

التعلم العميق

تقنيات Transformers والتعلم العميق

اللغات والأدوات المستخدمة

Python

اللغة الأساسية للتعامل مع البيانات وتحليل النماذج

JSON/YAML

لتكوين ملفات الإعدادات

NLTK

مكتبة أساسية لمعالجة النصوص

SpaCy

مكتبة قوية وسريعة لمعالجة النصوص المتقدمة

Hugging Face

إطار عمل للنماذج القائمة على Transformers

TextBlob/VADER

أدوات لتحليل المشاعر في النصوص

مهارات مهندس معالجة اللغات الطبيعية

1

Python Programming

إتقان Python للتعامل مع البيانات والنماذج

2

NLTK & SpaCy

مهارات معالجة النصوص والتحليل اللغوي

3

Hugging Face

بناء واستخدام نماذج Transformers

4

تعلم الآلة

خوارزميات التعلم الآلي للغة

5

تحليل المشاعر

تقنيات تحليل المشاعر في النصوص

6

النشر والتكامل

نشر نماذج NLP في بيئات الإنتاج

خارطة التعلم خطوة بخطوة

1

الخطوة 1: تعلم Python

Python هي اللغة الأساسية للتعامل مع البيانات وتحليل النماذج باستخدام مكتبات مثل TensorFlow Privacy و Fairlearn

الأهمية:

الأساس لجميع عمليات معالجة اللغات الطبيعية والتعلم العميق

الأدوات:

Python 3.x، Jupyter Notebook، VS Code

مثال Python أساسي لـ NLP:

# مقدمة في Python لمعالجة اللغات الطبيعية
print("مرحبا، معالجة اللغات الطبيعية!")

def greet(name):
    return f"مرحبا، {name}!"

print(greet("مهندس NLP"))

# أنواع البيانات الأساسية للنصوص
text = "أنا أتعلم معالجة اللغات الطبيعية"
text_length = len(text)
words = text.split()
word_count = len(words)

print(f"النص: {text}")
print(f"طول النص: {text_length} حرف")
print(f"الكلمات: {words}")
print(f"عدد الكلمات: {word_count}")

# معالجة النصوص الأساسية
def clean_text(text):
    """تنظيف النص الأساسي"""
    # تحويل إلى أحرف صغيرة
    text = text.lower()
    # إزالة علامات الترقيم
    import string
    text = text.translate(str.maketrans('', '', string.punctuation))
    # إزالة المسافات الزائدة
    text = ' '.join(text.split())
    return text

# مثال على التنظيف
sample_text = "مرحباً! أتعلم معالجة اللغات الطبيعية (NLP)."
cleaned = clean_text(sample_text)
print(f"النص الأصلي: {sample_text}")
print(f"بعد التنظيف: {cleaned}")

# العمل مع القواميس للنصوص
arabic_stopwords = ['و', 'في', 'على', 'من', 'إلى', 'عن', 'أن', 'هذا', 'هذه']
text_to_analyze = "أنا أتعلم الذكاء الاصطناعي و معالجة اللغات الطبيعية في جامعة الملك سعود"

def remove_stopwords(text, stopwords):
    """إزالة الكلمات الشائعة"""
    words = text.split()
    filtered_words = [word for word in words if word not in stopwords]
    return ' '.join(filtered_words)

filtered_text = remove_stopwords(text_to_analyze, arabic_stopwords)
print(f"النص الأصلي: {text_to_analyze}")
print(f"بعد إزالة الكلمات الشائعة: {filtered_text}")

# تحليل تكرار الكلمات
def word_frequency(text):
    """تحليل تكرار الكلمات في النص"""
    words = text.split()
    frequency = {}
    
    for word in words:
        frequency[word] = frequency.get(word, 0) + 1
    
    return frequency

# تطبيق تحليل التكرار
frequency_result = word_frequency(text_to_analyze)
print("\nتحليل تكرار الكلمات:")
for word, count in frequency_result.items():
    print(f"{word}: {count}")

# العمل مع ملفات النصوص
def read_text_file(filename):
    """قراءة ملف نصي"""
    try:
        with open(filename, 'r', encoding='utf-8') as file:
            content = file.read()
        return content
    except FileNotFoundError:
        return "الملف غير موجود"

def write_text_file(filename, content):
    """كتابة محتوى إلى ملف نصي"""
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(content)
    print(f"تم حفظ الملف: {filename}")

# مكتبات Python الأساسية لـ NLP
import nltk
import spacy
import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer

print("\nمكتبات Python لمعالجة اللغات الطبيعية:")
print(f"nltk version: {nltk.__version__ if hasattr(nltk, '__version__') else 'مثبتة'}")
print("spacy: مكتبة متقدمة لمعالجة النصوص")
print("pandas: لتحليل البيانات النصية")
print("scikit-learn: لخوارزميات التعلم الآلي")

# تجهيز البيانات النصية للتعلم الآلي
documents = [
    "أحب التعلم الآلي",
    "معالجة اللغات الطبيعية ممتعة",
    "الذكاء الاصطناعي هو المستقبل",
    "أتعلم Python للذكاء الاصطناعي"
]

# تحويل النصوص إلى متجهات رقمية
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(documents)
print(f"\nمصفوفة الكلمات:")
print(f"الأبعاد: {X.shape}")
print(f"الكلمات: {vectorizer.get_feature_names_out()}")

# تحليل TF-IDF
tfidf_vectorizer = TfidfVectorizer()
X_tfidf = tfidf_vectorizer.fit_transform(documents)
print(f"\nتحليل TF-IDF:")
print(f"الأبعاد: {X_tfidf.shape}")

# معالجة النصوص العربية المتقدمة
def arabic_text_processing(text):
    """معالجة متقدمة للنصوص العربية"""
    import re
    
    # إزالة التشكيل
    text = re.sub(r'[\u064B-\u065F]', '', text)
    
    # إزالة التكرار
    text = re.sub(r'(.)\1+', r'\1', text)
    
    # تحويل الأرقام العربية إلى إنجليزية
    arabic_numbers = '٠١٢٣٤٥٦٧٨٩'
    english_numbers = '0123456789'
    translation = str.maketrans(arabic_numbers, english_numbers)
    text = text.translate(translation)
    
    return text

# مثال على معالجة النصوص العربية
arabic_sample = "مرحباً يا أصدقاء! أتعلمُ معالجةَ اللغاتِ الطبيعية. التَّجربةُ رائعةٌ."
processed = arabic_text_processing(arabic_sample)
print(f"\nمعالجة النصوص العربية:")
print(f"قبل: {arabic_sample}")
print(f"بعد: {processed}")

# بناء نموذج تصنيف نصي بسيط
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, classification_report

# بيانات تدريبية (بسيطة)
train_texts = [
    "هذا المنتج رائع",
    "الخدمة سيئة",
    "التجربة ممتازة",
    "لا أنصح بهذا المنتج",
    "جودة عالية",
    "سعر مرتفع"
]

train_labels = [
    "positive", "negative", "positive", 
    "negative", "positive", "negative"
]

# تحويل النصوص إلى متجهات
vectorizer = CountVectorizer()
X_train = vectorizer.fit_transform(train_texts)

# تدريب النموذج
model = MultinomialNB()
model.fit(X_train, train_labels)

# اختبار النموذج
test_texts = ["منتج جيد", "غير مفيد"]
X_test = vectorizer.transform(test_texts)
predictions = model.predict(X_test)

print(f"\nنتائج نموذج التصنيف البسيط:")
for text, prediction in zip(test_texts, predictions):
    print(f"'{text}' → {prediction}")

# التعامل مع بيانات JSON للنصوص
import json

# مثال على بيانات نصية في JSON
nlp_data = {
    "texts": [
        {
            "id": 1,
            "content": "مرحبا بالعالم",
            "language": "arabic",
            "category": "greeting"
        },
        {
            "id": 2,
            "content": "Hello world",
            "language": "english", 
            "category": "greeting"
        }
    ],
    "metadata": {
        "source": "example",
        "processed": True
    }
}

# حفظ البيانات في ملف JSON
with open('nlp_data.json', 'w', encoding='utf-8') as f:
    json.dump(nlp_data, f, ensure_ascii=False, indent=2)

print(f"\nتم حفظ بيانات JSON في: nlp_data.json")

# تحليل المشاعر الأساسي
def basic_sentiment_analysis(text):
    """تحليل مشاعر بسيط"""
    positive_words = ['جيد', 'رائع', 'ممتاز', 'عظيم', 'مذهل']
    negative_words = ['سيء', 'رديء', 'مزعج', 'غير', 'سئ']
    
    words = text.split()
    positive_count = sum(1 for word in words if word in positive_words)
    negative_count = sum(1 for word in words if word in negative_words)
    
    if positive_count > negative_count:
        return "positive"
    elif negative_count > positive_count:
        return "negative"
    else:
        return "neutral"

# اختبار تحليل المشاعر
test_sentences = [
    "هذا المنتج جيد ورائع",
    "الخدمة سيئة ومزعجة",
    "لا أعرف ماذا أقول"
]

print(f"\nتحليل المشاعر الأساسي:")
for sentence in test_sentences:
    sentiment = basic_sentiment_analysis(sentence)
    print(f"'{sentence}' → {sentiment}")

# أدوات متقدمة لـ NLP
print("\n" + "="*50)
print("أدوات Python المتقدمة لمعالجة اللغات الطبيعية:")
print("="*50)

tools = [
    ("NLTK", "Natural Language Toolkit - مكتبة شاملة لمعالجة النصوص"),
    ("SpaCy", "مكتبة صناعية لمعالجة النصوص المتقدمة"),
    ("Transformers", "Hugging Face - مكتبة لنماذج التعلم العميق"),
    ("Gensim", "لنمذجة المواضيع و Word2Vec"),
    ("TextBlob", "لتحليل النصوص والمشاعر"),
    ("Stanza", "للمعالجة متعددة اللغات"),
    ("FastText", "لتمثيل الكلمات والتعرف على النصوص"),
    ("AllenNLP", "لمهام البحث في معالجة اللغات")
]

for tool, description in tools:
    print(f"✓ {tool}: {description}")
2

الخطوة 2: تعلم NLTK

مكتبة أساسية لمعالجة النصوص، مثل تقسيم الجمل، إزالة الكلمات الشائعة، والتقطيع

الأهمية:

الأساس لفهم كيفية معالجة النصوص قبل بناء النماذج

الأدوات:

Jupyter Notebook، Google Colab

مثال شامل لـ NLTK:

import nltk
import string
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer, WordNetLemmatizer
from nltk import pos_tag
from nltk.probability import FreqDist
from nltk.util import ngrams
import matplotlib.pyplot as plt

# تحميل بيانات NLTK المطلوبة
print("جاري تحميل بيانات NLTK...")
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('wordnet')
nltk.download('averaged_perceptron_tagger')
nltk.download('maxent_ne_chunker')
nltk.download('words')

print("مرحباً في عالم NLTK!")

# مثال 1: التقطيع (Tokenization)
sample_text = "أنا أتعلم معالجة اللغات الطبيعية. NLTK هي مكتبة رائعة!"

print("="*50)
print("1. التقطيع (Tokenization):")
print("="*50)

# تقطيع إلى جمل
sentences = sent_tokenize(sample_text)
print(f"الجمل: {sentences}")
print(f"عدد الجمل: {len(sentences)}")

# تقطيع إلى كلمات
words = word_tokenize(sample_text)
print(f"\nالكلمات: {words}")
print(f"عدد الكلمات: {len(words)}")

# مثال 2: إزالة علامات الترقيم
print("\n" + "="*50)
print("2. إزالة علامات الترقيم:")
print("="*50)

def remove_punctuation(text):
    """إزالة علامات الترقيم من النص"""
    # علامات الترقيم الإنجليزية والعربية
    arabic_punctuation = '،؛؟.!"٪\'()[]{}<>:;،؛؟'
    english_punctuation = string.punctuation
    all_punctuation = arabic_punctuation + english_punctuation
    
    translator = str.maketrans('', '', all_punctuation)
    return text.translate(translator)

clean_text = remove_punctuation(sample_text)
print(f"النص الأصلي: {sample_text}")
print(f"بعد إزالة الترقيم: {clean_text}")

# مثال 3: إزالة الكلمات الشائعة (Stopwords)
print("\n" + "="*50)
print("3. إزالة الكلمات الشائعة (Stopwords):")
print("="*50)

# إنشاء قائمة كلمات شائعة عربية
arabic_stopwords = [
    'و', 'في', 'على', 'من', 'إلى', 'عن', 'أن', 'هذا', 'هذه',
    'هؤلاء', 'كان', 'يكون', 'هو', 'هي', 'هم', 'الذي', 'التي',
    'الذين', 'ما', 'ماذا', 'لا', 'لم', 'لن', 'ليس', 'إن'
]

# إضافة الكلمات الإنجليزية
english_stopwords = stopwords.words('english')
all_stopwords = arabic_stopwords + english_stopwords

def remove_stopwords(tokens, stopwords_list):
    """إزالة الكلمات الشائعة من القائمة"""
    return [word for word in tokens if word.lower() not in stopwords_list]

filtered_words = remove_stopwords(words, all_stopwords)
print(f"الكلمات الأصلية ({len(words)}): {words}")
print(f"الكلمات المصفاة ({len(filtered_words)}): {filtered_words}")

# مثال 4: التصريف (Stemming)
print("\n" + "="*50)
print("4. التصريف (Stemming):")
print("="*50)

stemmer = PorterStemmer()

# كلمات عربية للتصريف
arabic_words = ['يذهب', 'يذهبان', 'يذهبون', 'ذهب', 'ذاهب']
print("الكلمات الأصلية:", arabic_words)

# لاحظ: NLTK يدعم الإنجليزية بشكل أفضل، لكن يمكننا تطبيق القواعد البسيطة
def arabic_stem(word):
    """تصريف بسيط للكلمات العربية"""
    prefixes = ['ي', 'ت', 'ن', 'أ']
    suffixes = ['ون', 'ان', 'ين', 'ة', 'ات']
    
    # إزالة البادئات
    for prefix in prefixes:
        if word.startswith(prefix):
            word = word[len(prefix):]
            break
    
    # إزالة اللواحق
    for suffix in suffixes:
        if word.endswith(suffix):
            word = word[:-len(suffix)]
            break
    
    return word

stemmed_arabic = [arabic_stem(word) for word in arabic_words]
print("الكلمات المصرفة:", stemmed_arabic)

# مثال 5: التطبيع (Lemmatization)
print("\n" + "="*50)
print("5. التطبيع (Lemmatization):")
print("="*50)

lemmatizer = WordNetLemmatizer()

# كلمات إنجليزية للتطبيع
english_words = ['running', 'ran', 'runs', 'better', 'best']
lemmatized_words = [lemmatizer.lemmatize(word, pos='v') for word in english_words]

for original, lemma in zip(english_words, lemmatized_words):
    print(f"{original} → {lemma}")

# مثال 6: تحديد جزء الكلام (POS Tagging)
print("\n" + "="*50)
print("6. تحديد جزء الكلام (POS Tagging):")
print("="*50)

# نص إنجليزي للتحليل
english_text = "I am learning Natural Language Processing with NLTK"
english_tokens = word_tokenize(english_text)
pos_tags = pos_tag(english_tokens)

print("النص:", english_text)
print("\nتحليل أجزاء الكلام:")
for word, tag in pos_tags:
    print(f"{word:15} → {tag}")

# شرح الرموز
tag_explanations = {
    'NN': 'اسم',
    'VB': 'فعل', 
    'JJ': 'صفة',
    'RB': 'ظرف',
    'PRP': 'ضمير',
    'IN': 'حرف جر'
}

print("\nشرح الرموز:")
for tag, explanation in tag_explanations.items():
    print(f"{tag}: {explanation}")

# مثال 7: تحليل التكرار (Frequency Distribution)
print("\n" + "="*50)
print("7. تحليل التكرار (Frequency Distribution):")
print("="*50)

long_text = """
معالجة اللغات الطبيعية هي مجال من مجالات الذكاء الاصطناعي.
NLTK تساعد في معالجة النصوص واللغات.
تعلم معالجة اللغات الطبيعية مفيد للغاية.
الذكاء الاصطناعي والتعلم الآلي هما المستقبل.
"""

# تقطيع النص
tokens = word_tokenize(long_text)
# إزالة الكلمات الشائعة
filtered_tokens = remove_stopwords(tokens, all_stopwords)
# إزالة علامات الترقيم
filtered_tokens = [remove_punctuation(token) for token in filtered_tokens]
# إزالة القيم الفارغة
filtered_tokens = [token for token in filtered_tokens if token.strip()]

# تحليل التكرار
fdist = FreqDist(filtered_tokens)

print("أكثر 10 كلمات تكراراً:")
for word, frequency in fdist.most_common(10):
    print(f"{word:15} → {frequency} مرة")

# رسم مخطط التكرار
plt.figure(figsize=(12, 6))
fdist.plot(10, title='أكثر 10 كلمات تكراراً')
plt.show()

# مثال 8: تحليل n-grams
print("\n" + "="*50)
print("8. تحليل n-grams:")
print("="*50)

def extract_ngrams(tokens, n):
    """استخراج n-grams من القائمة"""
    n_grams = ngrams(tokens, n)
    return [' '.join(gram) for gram in n_grams]

# استخراج bigrams (2-grams)
bigrams = extract_ngrams(filtered_tokens, 2)
print(f"أول 10 bigrams: {bigrams[:10]}")

# استخراج trigrams (3-grams)
trigrams = extract_ngrams(filtered_tokens, 3)
print(f"أول 10 trigrams: {trigrams[:10]}")

# مثال 9: التطبيع النصي المتقدم
print("\n" + "="*50)
print("9. التطبيع النصي المتقدم:")
print("="*50)

def advanced_text_normalization(text):
    """تطبيع نصي متقدم"""
    # 1. تحويل إلى أحرف صغيرة
    text = text.lower()
    
    # 2. إزالة الأرقام
    import re
    text = re.sub(r'\d+', '', text)
    
    # 3. إزالة المسافات الزائدة
    text = re.sub(r'\s+', ' ', text).strip()
    
    # 4. إزالة الحروف المنفردة
    text = ' '.join([word for word in text.split() if len(word) > 1])
    
    return text

# نص عربي للمعالجة
arabic_sample = """
مرحـــبا!     أتعلم معالجة اللغات الطبيعية.
NLTK 2024 مكتبة رائعة 100%.
أ. ب. ت هي أحرف عربية.
"""

normalized = advanced_text_normalization(arabic_sample)
print("النص الأصلي:")
print(arabic_sample)
print("\nبعد التطبيع:")
print(normalized)

# مثال 10: بناء قاموس الكلمات (Vocabulary)
print("\n" + "="*50)
print("10. بناء قاموس الكلمات (Vocabulary):")
print("="*50)

def build_vocabulary(texts, min_freq=1):
    """بناء قاموس الكلمات من مجموعة نصوص"""
    all_tokens = []
    
    for text in texts:
        tokens = word_tokenize(text)
        tokens = [remove_punctuation(token.lower()) for token in tokens]
        tokens = [token for token in tokens if token.strip()]
        all_tokens.extend(tokens)
    
    # تحليل التكرار
    fdist = FreqDist(all_tokens)
    
    # فلترة الكلمات بناء على الحد الأدنى للتكرار
    vocabulary = {word for word, freq in fdist.items() if freq >= min_freq}
    
    # إضافة فهارس للكلمات
    word_to_idx = {word: idx for idx, word in enumerate(sorted(vocabulary))}
    idx_to_word = {idx: word for word, idx in word_to_idx.items()}
    
    return vocabulary, word_to_idx, idx_to_word

# بيانات تدريبية
training_texts = [
    "أحب معالجة اللغات الطبيعية",
    "NLTK مكتبة مفيدة للغاية",
    "الذكاء الاصطناعي هو المستقبل",
    "أتعلم Python و NLTK معاً"
]

vocab, word2idx, idx2word = build_vocabulary(training_texts, min_freq=1)

print(f"حجم القاموس: {len(vocab)} كلمة")
print("\nالقاموس (الكلمة → الفهرس):")
for word, idx in sorted(word2idx.items(), key=lambda x: x[1]):
    print(f"{word:20} → {idx:3}")

# مثال 11: تمثيل الكلمات One-Hot Encoding
print("\n" + "="*50)
print("11. تمثيل الكلمات One-Hot Encoding:")
print("="*50)

def one_hot_encode(text, word2idx):
    """تمثيل النص باستخدام One-Hot Encoding"""
    tokens = word_tokenize(text)
    tokens = [remove_punctuation(token.lower()) for token in tokens]
    
    # إنشاء متجه بصفر
    vector = [0] * len(word2idx)
    
    # تعيين 1 للكلمات الموجودة
    for token in tokens:
        if token in word2idx:
            vector[word2idx[token]] = 1
    
    return vector

# اختبار الترميز
test_text = "أحب NLTK والذكاء الاصطناعي"
encoded = one_hot_encode(test_text, word2idx)

print(f"النص: {test_text}")
print(f"المتجه المشفر ({len(encoded)} بُعد):")
print(encoded)

# مثال 12: معالجة نصوص متعددة اللغات
print("\n" + "="*50)
print("12. معالجة نصوص متعددة اللغات:")
print("="*50)

def detect_language(text):
    """كشف لغة النص (بسيط)"""
    import re
    
    # أنماط اللغات
    arabic_pattern = re.compile(r'[\u0600-\u06FF]')
    english_pattern = re.compile(r'[A-Za-z]')
    
    arabic_chars = len(arabic_pattern.findall(text))
    english_chars = len(english_pattern.findall(text))
    
    if arabic_chars > english_chars:
        return "Arabic"
    elif english_chars > arabic_chars:
        return "English"
    else:
        return "Mixed/Unknown"

# اختبار كشف اللغة
multilingual_texts = [
    "مرحبا كيف حالك؟",
    "Hello, how are you?",
    "أهلاً Hello مرحباً",
    "1234567890"
]

print("كشف لغة النصوص:")
for text in multilingual_texts:
    lang = detect_language(text)
    print(f"'{text}' → {lang}")

# مثال 13: تحليل النصوص الطويلة
print("\n" + "="*50)
print("13. تحليل النصوص الطويلة:")
print("="*50)

def analyze_long_text(text, stopwords_list):
    """تحليل شامل للنصوص الطويلة"""
    
    # 1. إحصائيات أساسية
    sentences = sent_tokenize(text)
    words = word_tokenize(text)
    
    # 2. إزالة الكلمات الشائعة
    filtered_words = [word.lower() for word in words if word.lower() not in stopwords_list]
    
    # 3. تحليل التكرار
    fdist = FreqDist(filtered_words)
    
    # 4. الكلمات الفريدة
    unique_words = set(filtered_words)
    
    # 5. متوسط طول الكلمات
    avg_word_length = sum(len(word) for word in filtered_words) / len(filtered_words) if filtered_words else 0
    
    # نتائج التحليل
    analysis = {
        'num_sentences': len(sentences),
        'num_words': len(words),
        'num_unique_words': len(unique_words),
        'avg_sentence_length': len(words) / len(sentences) if sentences else 0,
        'avg_word_length': avg_word_length,
        'top_words': fdist.most_common(5)
    }
    
    return analysis

# نص طويل للتحليل
long_arabic_text = """
معالجة اللغات الطبيعية هي مجال من مجالات الذكاء الاصطناعي الذي يهدف إلى فهم اللغة البشرية.
NLTK هي مكتبة Python شائعة لمعالجة اللغات الطبيعية.
تتضمن معالجة اللغات الطبيعية العديد من المهام مثل التقطيع وتحليل المشاعر والترجمة الآلية.
الذكاء الاصطناعي يتطور بسرعة كبيرة في الوقت الحالي.
التعلم العميق يستخدم على نطاق واسع في معالجة اللغات الطبيعية.
"""

analysis_result = analyze_long_text(long_arabic_text, all_stopwords)

print("تحليل النص الطويل:")
for key, value in analysis_result.items():
    if key == 'top_words':
        print(f"{key}:")
        for word, freq in value:
            print(f"  {word}: {freq}")
    else:
        print(f"{key}: {value:.2f}" if isinstance(value, float) else f"{key}: {value}")

# ملخص خصائص NLTK
print("\n" + "="*50)
print("ملخص خصائص NLTK:")
print("="*50)

nltk_features = [
    ("التقطيع", "تقسيم النص إلى جمل وكلمات"),
    ("إزالة الكلمات الشائعة", "تصفية الكلمات غير المهمة"),
    ("التصريف والتطبيع", "تقليل الكلمات إلى جذورها"),
    ("تحديد أجزاء الكلام", "تصنيف الكلمات نحويًا"),
    ("تحليل التكرار", "دراسة تكرار الكلمات والعبارات"),
    ("تحليل n-grams", "دراسة تسلسلات الكلمات"),
    ("تمثيل النصوص", "تحويل النصوص إلى متجهات رقمية"),
    ("كشف اللغة", "التعرف على لغة النص"),
    ("التطبيع النصي", "تنظيف وتوحيد النصوص"),
    ("بناء القواميس", "إنشاء قواعد بيانات الكلمات")
]

for i, (feature, description) in enumerate(nltk_features, 1):
    print(f"{i:2}. {feature:20} - {description}")
3

الخطوة 3: تعلم SpaCy

مكتبة قوية وسريعة لمعالجة النصوص بشكل متقدم مثل التحليل النحوي والكيانات المسماة

الأهمية:

ضرورية لمعالجة النصوص بشكل فعال ومتطور

الأدوات:

Jupyter Notebook، Google Colab

مثال شامل لـ SpaCy:

import spacy
import pandas as pd
import matplotlib.pyplot as plt
from spacy import displacy
from collections import Counter
import warnings
warnings.filterwarnings('ignore')

print("جاري تحميل نماذج SpaCy...")

# تحميل نموذج اللغة الإنجليزية
try:
    nlp_en = spacy.load("en_core_web_sm")
    print("✓ تم تحميل النموذج الإنجليزي بنجاح")
except:
    print("جارٍ تثبيت النموذج الإنجليزي...")
    import subprocess
    subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"])
    nlp_en = spacy.load("en_core_web_sm")

# تحميل نموذج اللغة متعددة اللغات للنصوص العربية
try:
    nlp_xx = spacy.load("xx_ent_wiki_sm")  # النموذج متعدد اللغات
    print("✓ تم تحميل النموذج متعدد اللغات بنجاح")
except:
    print("جارٍ تثبيت النموذج متعدد اللغات...")
    import subprocess
    subprocess.run(["python", "-m", "spacy", "download", "xx_ent_wiki_sm"])
    nlp_xx = spacy.load("xx_ent_wiki_sm")

print("\n" + "="*60)
print("مرحباً في عالم SpaCy!")
print("="*60)

# مثال 1: المعالجة الأساسية
print("\n1. المعالجة الأساسية للنصوص:")

text_en = "Apple is looking at buying U.K. startup for $1 billion"
text_ar = "تفكر شركة أبل في شراء شركة ناشئة بريطانية مقابل مليار دولار"

# معالجة النص الإنجليزي
doc_en = nlp_en(text_en)
print(f"\nالنص الإنجليزي: {text_en}")
print(f"عدد الكلمات: {len(doc_en)}")

# معالجة النص العربي (باستخدام النموذج متعدد اللغات)
doc_ar = nlp_xx(text_ar)
print(f"\nالنص العربي: {text_ar}")
print(f"عدد الكلمات: {len(doc_ar)}")

# مثال 2: التقطيع والكلمات
print("\n" + "="*60)
print("2. التقطيع والتحليل اللغوي:")

print("\nتحليل النص الإنجليزي:")
for i, token in enumerate(doc_en):
    print(f"{i:2}. {token.text:15} | Lemma: {token.lemma_:15} | POS: {token.pos_:10} | Tag: {token.tag_:10}")

# مثال 3: استخراج الكيانات المسماة (NER)
print("\n" + "="*60)
print("3. استخراج الكيانات المسماة (Named Entity Recognition):")

print("\nالكيانات في النص الإنجليزي:")
for ent in doc_en.ents:
    print(f"  {ent.text:25} → {ent.label_:15} (ثقة: {ent.label:.2f})")

print("\nالكيانات في النص العربي:")
for ent in doc_ar.ents:
    print(f"  {ent.text:25} → {ent.label_:15}")

# شرح تسميات الكيانات
print("\nشرح تسميات الكيانات:")
labels = {
    "ORG": "منظمة/شركة",
    "PERSON": "شخص",
    "GPE": "دولة/مدينة",
    "LOC": "موقع",
    "DATE": "تاريخ",
    "TIME": "وقت",
    "MONEY": "مال",
    "PRODUCT": "منتج",
    "EVENT": "حدث",
    "WORK_OF_ART": "عمل فني"
}

for label, desc in labels.items():
    print(f"  {label:10} - {desc}")

# مثال 4: التحليل النحوي (Dependency Parsing)
print("\n" + "="*60)
print("4. التحليل النحوي (Dependency Parsing):")

print("\nتحليل النص: 'The quick brown fox jumps over the lazy dog'")
sample_sentence = "The quick brown fox jumps over the lazy dog"
doc_sample = nlp_en(sample_sentence)

print("\nالعلاقات النحوية:")
for token in doc_sample:
    print(f"{token.text:10} ← {token.dep_:15} ← {token.head.text:10}")

# عرض بصري للتحليل النحوي
print("\nعرض بصري للتحليل النحوي:")
html = displacy.render(doc_sample, style="dep", options={"compact": True})
# Note: In Jupyter Notebook, you would display the HTML directly

# مثال 5: التشابه الدلالي
print("\n" + "="*60)
print("5. التشابه الدلالي بين الكلمات:")

# تحميل نموذج كبير للكلمات المتجهة
try:
    nlp_lg = spacy.load("en_core_web_lg")
    print("✓ تم تحميل النموذج الكبير للكلمات المتجهة")
except:
    print("جارٍ تحميل النموذج المتوسط...")
    nlp_lg = spacy.load("en_core_web_md")

words = ["king", "queen", "man", "woman", "computer", "programming"]
tokens = nlp_lg(" ".join(words))

print("\nالتشابه بين الكلمات:")
for i in range(len(tokens)):
    for j in range(i + 1, len(tokens)):
        similarity = tokens[i].similarity(tokens[j])
        print(f"{tokens[i].text:15} ↔ {tokens[j].text:15} : {similarity:.3f}")

# مثال 6: تصنيف النصوص
print("\n" + "="*60)
print("6. ميزات تصنيف النصوص:")

def extract_text_features(text, nlp_model):
    """استخراج ميزات من النص"""
    doc = nlp_model(text)
    
    features = {
        'num_tokens': len(doc),
        'num_sentences': len(list(doc.sents)),
        'num_entities': len(doc.ents),
        'num_nouns': sum(1 for token in doc if token.pos_ == 'NOUN'),
        'num_verbs': sum(1 for token in doc if token.pos_ == 'VERB'),
        'num_adjectives': sum(1 for token in doc if token.pos_ == 'ADJ'),
        'avg_word_length': sum(len(token.text) for token in doc) / len(doc) if doc else 0,
        'contains_money': any(ent.label_ == 'MONEY' for ent in doc.ents),
        'contains_org': any(ent.label_ == 'ORG' for ent in doc.ents)
    }
    
    return features

# اختبار استخراج الميزات
test_texts = [
    "Apple reported $1 billion in revenue last quarter.",
    "The weather is beautiful today in New York.",
    "Microsoft announced a new partnership with OpenAI."
]

print("\nميزات النصوص:")
for text in test_texts:
    features = extract_text_features(text, nlp_en)
    print(f"\nالنص: {text[:50]}...")
    for key, value in features.items():
        print(f"  {key}: {value}")

# مثال 7: معالجة النصوص العربية المتقدمة
print("\n" + "="*60)
print("7. معالجة النصوص العربية:")

# نص عربي للتحليل
arabic_texts = [
    "تأسست شركة أبل في عام 1976 على يد ستيف جوبز.",
    "الذكاء الاصطناعي يغير العالم بشكل كبير.",
    "جامعة الملك سعود تقع في مدينة الرياض بالمملكة العربية السعودية."
]

print("\nتحليل النصوص العربية:")
for text in arabic_texts:
    doc = nlp_xx(text)
    print(f"\nالنص: {text}")
    print("الكيانات المسماة:")
    for ent in doc.ents:
        print(f"  {ent.text:20} → {ent.label_:10}")

# مثال 8: استخراج العبارات الاسمية
print("\n" + "="*60)
print("8. استخراج العبارات الاسمية (Noun Chunks):")

def extract_noun_chunks(text, nlp_model):
    """استخراج العبارات الاسمية من النص"""
    doc = nlp_model(text)
    chunks = list(doc.noun_chunks)
    return chunks

english_text = "The quick brown fox jumps over the lazy dog"
chunks = extract_noun_chunks(english_text, nlp_en)

print(f"\nالنص: {english_text}")
print("العبارات الاسمية:")
for i, chunk in enumerate(chunks, 1):
    print(f"{i:2}. {chunk.text}")

# مثال 9: تحليل المشاعر باستخدام SpaCy
print("\n" + "="*60)
print("9. تحليل المشاعر (نهج معتمد على القواعد):")

def sentiment_analysis_spacy(text, nlp_model):
    """تحليل المشاعر باستخدام قواعد SpaCy"""
    doc = nlp_model(text)
    
    # قوائم الكلمات الإيجابية والسلبية
    positive_words = ['good', 'great', 'excellent', 'amazing', 'wonderful', 'happy', 'love']
    negative_words = ['bad', 'terrible', 'awful', 'horrible', 'sad', 'hate', 'angry']
    
    # إحصاءات المشاعر
    sentiment_score = 0
    positive_count = 0
    negative_count = 0
    
    for token in doc:
        if token.lemma_.lower() in positive_words:
            sentiment_score += 1
            positive_count += 1
        elif token.lemma_.lower() in negative_words:
            sentiment_score -= 1
            negative_count += 1
    
    # تحديد المشاعر
    if sentiment_score > 0:
        sentiment = "إيجابي"
    elif sentiment_score < 0:
        sentiment = "سلبي"
    else:
        sentiment = "محايد"
    
    return {
        'sentiment': sentiment,
        'score': sentiment_score,
        'positive_words': positive_count,
        'negative_words': negative_count,
        'total_words': len(doc)
    }

# اختبار تحليل المشاعر
sentiment_texts = [
    "I love this product! It's amazing and works perfectly.",
    "This is terrible. I hate it so much.",
    "The service was okay, nothing special."
]

print("\nتحليل المشاعر:")
for text in sentiment_texts:
    result = sentiment_analysis_spacy(text, nlp_en)
    print(f"\nالنص: {text[:50]}...")
    print(f"المشاعر: {result['sentiment']} (نتيجة: {result['score']})")
    print(f"كلمات إيجابية: {result['positive_words']}")
    print(f"كلمات سلبية: {result['negative_words']}")

# مثال 10: بناء خط أنابيب مخصص
print("\n" + "="*60)
print("10. بناء خط أنابيب معالجة مخصص:")

from spacy.language import Language
from spacy.tokens import Doc

# إنشاء مكون مخصص
@Language.component("arabic_processor")
def arabic_processor(doc):
    """معالج مخصص للنصوص العربية"""
    # يمكن إضافة معالجة مخصصة هنا
    return doc

# إنشاء خط أنابيب مخصص
if "arabic_processor" not in nlp_xx.pipe_names:
    nlp_xx.add_pipe("arabic_processor", last=True)
    print("✓ تم إضافة المعالج العربي المخصص")

# مثال 11: استخراج المعلومات المنظمة
print("\n" + "="*60)
print("11. استخراج المعلومات المنظمة:")

def extract_structured_info(text, nlp_model):
    """استخراج معلومات منظمة من النص"""
    doc = nlp_model(text)
    
    structured_data = {
        'organizations': [],
        'persons': [],
        'locations': [],
        'dates': [],
        'money': [],
        'products': []
    }
    
    for ent in doc.ents:
        if ent.label_ == 'ORG':
            structured_data['organizations'].append(ent.text)
        elif ent.label_ == 'PERSON':
            structured_data['persons'].append(ent.text)
        elif ent.label_ in ['GPE', 'LOC']:
            structured_data['locations'].append(ent.text)
        elif ent.label_ == 'DATE':
            structured_data['dates'].append(ent.text)
        elif ent.label_ == 'MONEY':
            structured_data['money'].append(ent.text)
        elif ent.label_ == 'PRODUCT':
            structured_data['products'].append(ent.text)
    
    return structured_data

# اختبار استخراج المعلومات
info_text = "Apple CEO Tim Cook announced the new iPhone 15 in California on September 12, 2023 for $999."
info = extract_structured_info(info_text, nlp_en)

print(f"\nالنص: {info_text}")
print("\nالمعلومات المستخرجة:")
for category, items in info.items():
    if items:
        print(f"{category}: {', '.join(items)}")

# مثال 12: التصور البصري للكيانات
print("\n" + "="*60)
print("12. التصور البصري للكيانات:")

# نص للتصور
visualization_text = "Apple is looking at buying U.K. startup for $1 billion in January 2024."
doc_viz = nlp_en(visualization_text)

# إنشاء HTML للتصور (للعرض في Jupyter)
html = displacy.render(doc_viz, style="ent")
print("✓ تم إنشاء تصور بصري للكيانات")

# مثال 13: تحليل النصوص الطويلة
print("\n" + "="*60)
print("13. تحليل النصوص الطويلة بكفاءة:")

def analyze_long_document(text, nlp_model, chunk_size=1000):
    """تحليل النصوص الطويلة عن طريق التقسيم"""
    # تقسيم النص إلى أجزاء
    chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]
    
    all_entities = []
    all_nouns = []
    all_verbs = []
    
    for chunk in chunks:
        doc = nlp_model(chunk)
        
        # جمع الكيانات
        all_entities.extend([(ent.text, ent.label_) for ent in doc.ents])
        
        # جمع الأسماء
        all_nouns.extend([token.text for token in doc if token.pos_ == 'NOUN'])
        
        # جمع الأفعال
        all_verbs.extend([token.text for token in doc if token.pos_ == 'VERB'])
    
    # تحليل التكرار
    entity_counts = Counter([label for _, label in all_entities])
    noun_counts = Counter(all_nouns)
    verb_counts = Counter(all_verbs)
    
    return {
        'total_chunks': len(chunks),
        'unique_entities': len(set(all_entities)),
        'top_entity_types': entity_counts.most_common(5),
        'top_nouns': noun_counts.most_common(10),
        'top_verbs': verb_counts.most_common(10)
    }

# مثال 14: تكامل SpaCy مع مكتبات أخرى
print("\n" + "="*60)
print("14. تكامل SpaCy مع مكتبات أخرى:")

def spacy_to_dataframe(text, nlp_model):
    """تحويل تحليل SpaCy إلى DataFrame"""
    doc = nlp_model(text)
    
    data = []
    for token in doc:
        data.append({
            'text': token.text,
            'lemma': token.lemma_,
            'pos': token.pos_,
            'tag': token.tag_,
            'dep': token.dep_,
            'shape': token.shape_,
            'is_alpha': token.is_alpha,
            'is_stop': token.is_stop,
            'has_vector': token.has_vector,
            'vector_norm': token.vector_norm if token.has_vector else None
        })
    
    return pd.DataFrame(data)

# اختبار التحويل إلى DataFrame
df = spacy_to_dataframe("SpaCy is an amazing NLP library!", nlp_en)
print("\nتحليل SpaCy في DataFrame:")
print(df.head())

# مثال 15: أداء وتوقيت المعالجة
print("\n" + "="*60)
print("15. أداء وتوقيت المعالجة:")

import time

def benchmark_spacy(text, nlp_model, n_iterations=10):
    """قياس أداء معالجة SpaCy"""
    times = []
    
    for _ in range(n_iterations):
        start_time = time.time()
        doc = nlp_model(text)
        end_time = time.time()
        times.append(end_time - start_time)
    
    avg_time = sum(times) / len(times)
    tokens_per_second = len(doc) / avg_time
    
    return {
        'avg_processing_time': avg_time,
        'tokens_per_second': tokens_per_second,
        'num_tokens': len(doc),
        'times': times
    }

# قياس الأداء
benchmark_text = "SpaCy is known for its speed and efficiency in natural language processing tasks."
results = benchmark_spacy(benchmark_text, nlp_en)

print(f"\nنتائج الأداء:")
print(f"متوسط وقت المعالجة: {results['avg_processing_time']:.4f} ثانية")
print(f"عدد الكلمات في الثانية: {results['tokens_per_second']:.1f}")
print(f"عدد الكلمات: {results['num_tokens']}")

# ملخص خصائص SpaCy
print("\n" + "="*60)
print("ملخص خصائص SpaCy المتقدمة:")
print("="*60)

spacy_features = [
    ("المعالجة السريعة", "مصممة للأداء العالي في الإنتاج"),
    ("الكيانات المسماة", "استخراج الكيانات بدقة عالية"),
    ("التحليل النحوي", "تحليل دقيق للعلاقات النحوية"),
    ("الكلمات المتجهة", "نماذج مسبقة للكلمات المتجهة"),
    ("التشابه الدلالي", "قياس التشابه بين النصوص"),
    ("العبارات الاسمية", "استخراج المجموعات الاسمية"),
    ("خطوط الأنابيب المخصصة", "إضافة مكونات معالجة مخصصة"),
    ("التكامل مع المكتبات", "عمل سلس مع pandas و scikit-learn"),
    ("معالجة النصوص الطويلة", "تحليل النصوص الكبيرة بكفاءة"),
    ("التصور البصري", "عرض النتائج بشكل مرئي")
]

for i, (feature, description) in enumerate(spacy_features, 1):
    print(f"{i:2}. {feature:25} - {description}")

print("\n" + "="*60)
print("مقارنة بين NLTK و SpaCy:")
print("="*60)

comparison = [
    ("السرعة", "SpaCy أسرع بكثير من NLTK"),
    ("السهولة", "SpaCy أكثر سهولة في الاستخدام"),
    ("الدقة", "SpaCy أكثر دقة في المهام المعقدة"),
    ("حجم النماذج", "SpaCy يحتاج مساحة أكبر"),
    ("المرونة", "NLTK أكثر مرونة للأبحاث"),
    ("التعلم", "NLTK أفضل للتعلم والمبتدئين")
]

for item, desc in comparison:
    print(f"• {item:15}: {desc}")
4

الخطوة 4: تعلم Hugging Face Transformers

إطار عمل لإنشاء نماذج مبنية على Transformers والتعلم العميق مثل BERT و GPT

الأهمية:

ضروري لإنشاء نماذج NLP قوية مثل الترجمة الآلية، الإكمال التلقائي للنصوص، والإجابة على الأسئلة

الأدوات:

Hugging Face Transformers، PyTorch، TensorFlow

مثال شامل لـ Hugging Face:

from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification, AutoModelForTokenClassification
from transformers import BertTokenizer, BertModel, GPT2Tokenizer, GPT2LMHeadModel
from transformers import Trainer, TrainingArguments
import torch
import numpy as np
import pandas as pd
from datasets import Dataset
import warnings
warnings.filterwarnings('ignore')

print("مرحباً في عالم Hugging Face Transformers!")

# مثال 1: استخدام خطوط الأنابيب الجاهزة (Pipelines)
print("\n" + "="*60)
print("1. خطوط الأنابيب الجاهزة (Pipelines):")

# 1.1 تحليل المشاعر
print("\nأ) تحليل المشاعر:")
sentiment_analyzer = pipeline("sentiment-analysis")

texts = [
    "I love using Hugging Face Transformers!",
    "This is terrible and I hate it.",
    "The weather is okay today."
]

for text in texts:
    result = sentiment_analyzer(text)[0]
    print(f"'{text[:30]}...' → {result['label']} (ثقة: {result['score']:.3f})")

# 1.2 الترجمة الآلية
print("\nب) الترجمة الآلية:")
translator = pipeline("translation_en_to_fr", model="t5-small")

english_text = "Hello, how are you today?"
translation = translator(english_text)[0]['translation_text']
print(f"الإنجليزية: {english_text}")
print(f"الفرنسية: {translation}")

# 1.3 توليد النصوص
print("\nج) توليد النصوص:")
generator = pipeline("text-generation", model="gpt2")

prompt = "Once upon a time"
generated = generator(prompt, max_length=50, num_return_sequences=1)[0]['generated_text']
print(f"المطالبة: {prompt}")
print(f"النص المولد: {generated}")

# 1.4 الإجابة على الأسئلة
print("\nد) الإجابة على الأسئلة:")
qa_pipeline = pipeline("question-answering")

context = """
Hugging Face is a company that develops tools for building applications 
using machine learning. It is most notable for its Transformers library, 
built for natural language processing applications.
"""

question = "What does Hugging Face develop?"
answer = qa_pipeline(question=question, context=context)
print(f"السؤال: {question}")
print(f"الإجابة: {answer['answer']} (ثقة: {answer['score']:.3f})")

# 1.5 التعرف على الكيانات المسماة
print("\nهـ) التعرف على الكيانات المسماة:")
ner_pipeline = pipeline("ner", aggregation_strategy="simple")

ner_text = "Apple was founded by Steve Jobs in Cupertino, California."
entities = ner_pipeline(ner_text)

print(f"\nالنص: {ner_text}")
print("الكيانات المسماة:")
for entity in entities:
    print(f"  {entity['word']:15} → {entity['entity_group']:10} (ثقة: {entity['score']:.3f})")

# مثال 2: استخدام النماذج والمرمزات مباشرة
print("\n" + "="*60)
print("2. استخدام النماذج والمرمزات مباشرة:")

# 2.1 تحميل نموذج ومرمز BERT
print("\nأ) استخدام نموذج BERT:")
model_name = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertModel.from_pretrained(model_name)

# ترميز النص
text = "Hugging Face Transformers are amazing!"
inputs = tokenizer(text, return_tensors="pt")

# الحصول على التضمينات
with torch.no_grad():
    outputs = model(**inputs)

print(f"النص: {text}")
print(f"معرفات الكلمات: {inputs['input_ids'].tolist()[0]}")
print(f"انتباه: {outputs.last_hidden_state.shape}")

# 2.2 استخدام GPT-2 لتوليد النصوص
print("\nب) استخدام GPT-2 لتوليد النصوص:")
gpt2_tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
gpt2_model = GPT2LMHeadModel.from_pretrained("gpt2")

# توليد النص
input_text = "Artificial intelligence is"
input_ids = gpt2_tokenizer.encode(input_text, return_tensors="pt")

# توليد النص
output = gpt2_model.generate(
    input_ids,
    max_length=100,
    num_return_sequences=1,
    temperature=0.7,
    do_sample=True
)

generated_text = gpt2_tokenizer.decode(output[0], skip_special_tokens=True)
print(f"المدخل: {input_text}")
print(f"النص المولد: {generated_text}")

# مثال 3: ضبط النماذج على مهام مخصصة
print("\n" + "="*60)
print("3. ضبط النماذج على مهام مخصصة:")

# 3.1 تحضير بيانات التدريب
print("\nأ) تحضير بيانات التدريب:")

# بيانات تدريبية بسيطة (تصنيف المشاعر)
train_data = [
    {"text": "I love this product!", "label": 1},
    {"text": "This is terrible.", "label": 0},
    {"text": "Amazing experience!", "label": 1},
    {"text": "Very disappointed.", "label": 0},
    {"text": "Great quality.", "label": 1},
    {"text": "Waste of money.", "label": 0}
]

# تحويل إلى DataFrame
df = pd.DataFrame(train_data)

# تحويل إلى Dataset (متوافق مع Hugging Face)
dataset = Dataset.from_pandas(df)

# 3.2 تحميل النموذج والمرمز
print("\nب) تحميل النموذج والمرمز:")
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 3.3 دالة ترميز البيانات
def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

# تطبيق الترميز
tokenized_dataset = dataset.map(tokenize_function, batched=True)

# تقسيم البيانات
tokenized_dataset = tokenized_dataset.train_test_split(test_size=0.2)
train_dataset = tokenized_dataset["train"]
test_dataset = tokenized_dataset["test"]

print(f"بيانات التدريب: {len(train_dataset)} عينة")
print(f"بيانات الاختبار: {len(test_dataset)} عينة")

# 3.4 إعدادات التدريب
print("\nج) إعدادات التدريب:")
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
)

# 3.5 إنشاء المدرب
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset,
)

# ملاحظة: في الواقع العملي، سنقوم بالتدريب، لكن هنا سنكتفي بالعرض
print("✓ تم إعداد المدرب بنجاح")

# مثال 4: استخدام النماذج متعددة اللغات
print("\n" + "="*60)
print("4. استخدام النماذج متعددة اللغات:")

# 4.1 نموذج mBERT (متعدد اللغات)
print("\nأ) نموذج mBERT متعدد اللغات:")
from transformers import AutoModel, AutoTokenizer

# تحميل نموذج متعدد اللغات
multilingual_model_name = "bert-base-multilingual-cased"
multilingual_tokenizer = AutoTokenizer.from_pretrained(multilingual_model_name)
multilingual_model = AutoModel.from_pretrained(multilingual_model_name)

# نصوص بلغات مختلفة
multilingual_texts = [
    "Hello world",  # الإنجليزية
    "مرحبا بالعالم",  # العربية
    "Bonjour le monde",  # الفرنسية
    "Hola mundo",  # الإسبانية
]

print("\nتضمينات النصوص المتعددة اللغات:")
for text in multilingual_texts:
    inputs = multilingual_tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    with torch.no_grad():
        outputs = multilingual_model(**inputs)
    embedding = outputs.last_hidden_state.mean(dim=1)
    print(f"'{text}' → بُعد التضمين: {embedding.shape}")

# 4.2 نموذج AraBERT للغة العربية
print("\nب) نموذج AraBERT للغة العربية:")
try:
    arabert_tokenizer = AutoTokenizer.from_pretrained("aubmindlab/bert-base-arabertv02")
    arabert_model = AutoModel.from_pretrained("aubmindlab/bert-base-arabertv02")
    
    arabic_text = "أنا أتعلم معالجة اللغات الطبيعية"
    inputs = arabert_tokenizer(arabic_text, return_tensors="pt")
    
    with torch.no_grad():
        outputs = arabert_model(**inputs)
    
    print(f"النص العربي: {arabic_text}")
    print(f"بُعد التضمين: {outputs.last_hidden_state.shape}")
except:
    print("جارٍ تحميل نموذج بديل للغة العربية...")
    # استخدام نموذج متعدد اللغات بدلاً من ذلك
    inputs = multilingual_tokenizer(arabic_text, return_tensors="pt")
    with torch.no_grad():
        outputs = multilingual_model(**inputs)
    print(f"النص العربي: {arabic_text}")
    print(f"بُعد التضمين: {outputs.last_hidden_state.shape}")

# مثال 5: نماذج توليد المحادثة
print("\n" + "="*60)
print("5. نماذج توليد المحادثة:")

# 5.1 نموذج DialoGPT للمحادثات
print("\nأ) نموذج DialoGPT للمحادثات:")
try:
    from transformers import AutoModelForCausalLM
    
    chatbot_tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-small")
    chatbot_model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-small")
    
    # محادثة بسيطة
    chat_history_ids = None
    
    # الجولة الأولى
    user_input = "Hello, how are you?"
    new_input_ids = chatbot_tokenizer.encode(user_input + chatbot_tokenizer.eos_token, return_tensors='pt')
    
    # توليد الرد
    chat_history_ids = chatbot_model.generate(
        new_input_ids,
        max_length=1000,
        pad_token_id=chatbot_tokenizer.eos_token_id,
        temperature=0.7
    )
    
    response = chatbot_tokenizer.decode(chat_history_ids[:, new_input_ids.shape[-1]:][0], skip_special_tokens=True)
    print(f"المستخدم: {user_input}")
    print(f"الروبوت: {response}")
except Exception as e:
    print(f"حدث خطأ في تحميل نموذج المحادثة: {e}")

# مثال 6: نماذج الترجمة المتقدمة
print("\n" + "="*60)
print("6. نماذج الترجمة المتقدمة:")

# 6.1 نموذج MarianMT للترجمة
print("\nأ) نموذج MarianMT للترجمة:")
try:
    # ترجمة من الإنجليزية إلى العربية
    translator_en_ar = pipeline("translation_en_to_ar", model="Helsinki-NLP/opus-mt-en-ar")
    
    english_sentences = [
        "Hello, how are you?",
        "I love machine learning",
        "Natural language processing is amazing"
    ]
    
    print("\nالترجمة من الإنجليزية إلى العربية:")
    for sentence in english_sentences:
        translation = translator_en_ar(sentence)[0]['translation_text']
        print(f"الإنجليزية: {sentence}")
        print(f"العربية: {translation}")
        print("-" * 40)
except:
    print("جارٍ استخدام نموذج ترجمة بديل...")

# مثال 7: تحميل واستخدام نماذج مخصصة
print("\n" + "="*60)
print("7. تحميل واستخدام نماذج مخصصة:")

# 7.1 البحث عن النماذج في Hugging Face Hub
print("\nأ) البحث عن النماذج المتاحة:")

# قائمة بالنماذج الشائعة
popular_models = [
    "bert-base-uncased",
    "roberta-base",
    "gpt2",
    "t5-small",
    "distilbert-base-uncased",
    "albert-base-v2",
    "xlnet-base-cased",
    "bart-base",
    "electra-base-discriminator",
    "deberta-base"
]

print("\nأشهر نماذج Transformers:")
for i, model_name in enumerate(popular_models, 1):
    print(f"{i:2}. {model_name}")

# مثال 8: العمل مع الرؤوس المختلفة للنماذج
print("\n" + "="*60)
print("8. العمل مع الرؤوس المختلفة للنماذج:")

# 8.1 نموذج لتصنيف التسلسل
print("\nأ) نموذج لتصنيف التسلسل:")
from transformers import AutoModelForSequenceClassification

# تحميل نموذج لتصنيف المشاعر
sentiment_model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
sentiment_model = AutoModelForSequenceClassification.from_pretrained(sentiment_model_name)
sentiment_tokenizer = AutoTokenizer.from_pretrained(sentiment_model_name)

# اختبار النموذج
test_text = "I really enjoyed this movie!"
inputs = sentiment_tokenizer(test_text, return_tensors="pt", truncation=True)

with torch.no_grad():
    outputs = sentiment_model(**inputs)
    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

print(f"النص: {test_text}")
print(f"التنبؤات: {predictions.tolist()[0]}")

# 8.2 نموذج لتصنيف الرموز
print("\nب) نموذج لتصنيف الرموز:")
from transformers import AutoModelForTokenClassification

# نموذج للتعرف على الكيانات المسماة
ner_model_name = "dslim/bert-base-NER"
ner_model = AutoModelForTokenClassification.from_pretrained(ner_model_name)
ner_tokenizer = AutoTokenizer.from_pretrained(ner_model_name)

ner_text = "John Smith works at Google in California."
inputs = ner_tokenizer(ner_text, return_tensors="pt", truncation=True)

with torch.no_grad():
    outputs = ner_model(**inputs)
    predictions = torch.argmax(outputs.logits, dim=2)

# تحويل التوقعات إلى تسميات
tokens = ner_tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
labels = [ner_model.config.id2label[pred] for pred in predictions[0].tolist()]

print(f"\nالنص: {ner_text}")
print("\nتحليل الرموز:")
for token, label in zip(tokens, labels):
    if token not in ["[CLS]", "[SEP]", "[PAD]"]:
        print(f"{token:15} → {label}")

# مثال 9: حفظ وتحميل النماذج المخصصة
print("\n" + "="*60)
print("9. حفظ وتحميل النماذج المخصصة:")

# 9.1 حفظ النموذج
print("\nأ) حفظ النموذج:")
model_save_path = "./my_custom_model"

# حفظ النموذج والمرمز
model.save_pretrained(model_save_path)
tokenizer.save_pretrained(model_save_path)
print(f"✓ تم حفظ النموذج في: {model_save_path}")

# 9.2 تحميل النموذج المحفوظ
print("\nب) تحميل النموذج المحفوظ:")
loaded_model = AutoModelForSequenceClassification.from_pretrained(model_save_path)
loaded_tokenizer = AutoTokenizer.from_pretrained(model_save_path)
print("✓ تم تحميل النموذج بنجاح")

# مثال 10: الاستدلال بالدفعات (Batch Inference)
print("\n" + "="*60)
print("10. الاستدلال بالدفعات (Batch Inference):")

# 10.1 معالجة دفعات من النصوص
print("\nأ) معالجة دفعات من النصوص:")
batch_texts = [
    "This is amazing!",
    "I don't like this at all.",
    "It's okay, nothing special.",
    "Absolutely wonderful experience!",
    "Very disappointing."
]

# ترميز الدفعة
batch_inputs = sentiment_tokenizer(
    batch_texts,
    padding=True,
    truncation=True,
    max_length=128,
    return_tensors="pt"
)

# الاستدلال بالدفعة
with torch.no_grad():
    batch_outputs = sentiment_model(**batch_inputs)
    batch_predictions = torch.nn.functional.softmax(batch_outputs.logits, dim=-1)

print("\nنتائج تحليل المشاعر للدفعة:")
for text, prediction in zip(batch_texts, batch_predictions):
    sentiment_score = torch.argmax(prediction).item()
    sentiment = ["سلبي", "إيجابي"][sentiment_score]
    confidence = torch.max(prediction).item()
    print(f"'{text[:30]}...' → {sentiment} (ثقة: {confidence:.3f})")

# مثال 11: نماذج التلخيص التلقائي
print("\n" + "="*60)
print("11. نماذج التلخيص التلقائي:")

# 11.1 نموذج BART للتلخيص
print("\nأ) نموذج BART للتلخيص:")
try:
    summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
    
    long_text = """
    Natural language processing (NLP) is a subfield of linguistics, computer science, 
    and artificial intelligence concerned with the interactions between computers and human language. 
    It focuses on how to program computers to process and analyze large amounts of natural language data. 
    The goal is to enable computers to understand, interpret, and generate human language in a valuable way.
    """
    
    summary = summarizer(long_text, max_length=100, min_length=30, do_sample=False)[0]['summary_text']
    print(f"النص الأصلي: {long_text[:100]}...")
    print(f"\nالتلخيص: {summary}")
except:
    print("جارٍ استخدام نموذج تلخيص مبسط...")

# مثال 12: نماذج الإكمال التلقائي
print("\n" + "="*60)
print("12. نماذج الإكمال التلقائي:")

# 12.1 نموذج GPT-2 للإكمال
print("\nأ) نموذج GPT-2 للإكمال التلقائي:")
completion_pipeline = pipeline("text-generation", model="gpt2")

prompts = [
    "In the future, artificial intelligence will",
    "The best way to learn programming is",
    "Machine learning algorithms can"
]

print("\nإكمال الجمل:")
for prompt in prompts:
    completions = completion_pipeline(
        prompt,
        max_length=50,
        num_return_sequences=1,
        temperature=0.8
    )
    completion = completions[0]['generated_text']
    print(f"المطالبة: {prompt}")
    print(f"الإكمال: {completion}")
    print("-" * 60)

# مثال 13: نماذج التضمين (Embedding Models)
print("\n" + "="*60)
print("13. نماذج التضمين (Embedding Models):")

# 13.1 نموذج Sentence Transformers
print("\nأ) نموذج Sentence Transformers:")
try:
    from sentence_transformers import SentenceTransformer
    
    # تحميل نموذج التضمين
    embedder = SentenceTransformer('all-MiniLM-L6-v2')
    
    # جمل للتضمين
    sentences = [
        "The weather is beautiful today",
        "It's raining outside",
        "I love natural language processing",
        "Machine learning is fascinating"
    ]
    
    # توليد التضمينات
    embeddings = embedder.encode(sentences)
    
    print(f"عدد الجمل: {len(sentences)}")
    print(f"بُعد التضمين: {embeddings.shape}")
    
    # حساب التشابه
    from sklearn.metrics.pairwise import cosine_similarity
    
    similarity_matrix = cosine_similarity(embeddings)
    
    print("\nمصفوفة التشابه بين الجمل:")
    for i in range(len(sentences)):
        for j in range(i+1, len(sentences)):
            sim = similarity_matrix[i][j]
            print(f"'{sentences[i][:20]}...' ↔ '{sentences[j][:20]}...': {sim:.3f}")
except:
    print("تأكد من تثبيت sentence-transformers: pip install sentence-transformers")

# مثال 14: نماذج الرؤية-لغة (Vision-Language Models)
print("\n" + "="*60)
print("14. نماذج الرؤية-لغة (Vision-Language Models):")

# 14.1 نموذج CLIP
print("\nأ) نموذج CLIP (الرؤية واللغة):")
try:
    from transformers import CLIPProcessor, CLIPModel
    from PIL import Image
    import requests
    
    # تحميل النموذج
    clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
    clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
    
    print("✓ تم تحميل نموذج CLIP بنجاح")
    print("يمكن استخدامه لمطابقة الصور مع النصوص")
except:
    print("نموذج CLIP يحتاج إلى مكتبات إضافية")

# مثال 15: إنشاء تطبيقات واقعية
print("\n" + "="*60)
print("15. إنشاء تطبيقات واقعية باستخدام Transformers:")

# 15.1 تطبيق تحليل المشاعر للتعليقات
print("\nأ) تطبيق تحليل المشاعر للتعليقات:")

class SentimentAnalysisApp:
    """تطبيق تحليل المشاعر"""
    
    def __init__(self, model_name="nlptown/bert-base-multilingual-uncased-sentiment"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        
    def analyze_sentiment(self, text):
        """تحليل مشاعر النص"""
        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True)
        
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        
        sentiment_score = torch.argmax(probabilities).item()
        confidence = torch.max(probabilities).item()
        
        # تحويل النتيجة إلى نص
        sentiments = ["سلبي للغاية", "سلبي", "محايد", "إيجابي", "إيجابي للغاية"]
        
        return {
            'text': text,
            'sentiment': sentiments[sentiment_score],
            'score': sentiment_score,
            'confidence': confidence,
            'probabilities': probabilities.tolist()[0]
        }

# اختبار التطبيق
app = SentimentAnalysisApp()

test_comments = [
    "This product is absolutely amazing! Best purchase ever.",
    "Not worth the money. Very disappointed.",
    "It's okay, does what it's supposed to do.",
    "Excellent quality and fast delivery. Highly recommended!",
    "Terrible experience. Would not buy again."
]

print("\nتحليل مشاعر التعليقات:")
for comment in test_comments:
    result = app.analyze_sentiment(comment)
    print(f"\nالتعليق: {comment[:50]}...")
    print(f"المشاعر: {result['sentiment']} (ثقة: {result['confidence']:.3f})")

# ملخص Hugging Face Transformers
print("\n" + "="*60)
print("ملخص Hugging Face Transformers:")
print("="*60)

transformers_features = [
    ("خطوط الأنابيب الجاهزة", "استخدام مسبق لأدوات NLP"),
    ("مجموعة نماذج ضخمة", "آلاف النماذج المدربة مسبقاً"),
    ("التدريب والضبط", "إمكانية تدريب النماذج على بيانات مخصصة"),
    ("التكامل السلس", "عمل مع PyTorch و TensorFlow"),
    ("النماذج متعددة اللغات", "دعم عشرات اللغات"),
    ("نماذج التوليد", "GPT و BART و T5"),
    ("نماذج الترجمة", "ترجمة بين مئات اللغات"),
    ("نماذج التضمين", "تمثيل النصوص كمتجهات"),
    ("نماذج المحادثة", "روبوتات محادثة ذكية"),
    ("نماذج الرؤية-لغة", "معالجة الصور والنصوص معاً")
]

for i, (feature, description) in enumerate(transformers_features, 1):
    print(f"{i:2}. {feature:25} - {description}")

print("\n" + "="*60)
print("نصائح للاستخدام الفعال:")
print("="*60)

tips = [
    "ابدأ بالخطوط الأنابيب الجاهزة قبل بناء نماذج مخصصة",
    "استخدم النماذج المسبقة المدربة وضبطها على بياناتك",
    "اختر النموذج المناسب للمهمة (BERT للفهم، GPT للتوليد)",
    "انتبه لحجم النموذج ومتطلبات الذاكرة",
    "استخدم التقنيات المختلطة للنصوص متعددة اللغات",
    "اختبر النموذج على بيانات حقيقية قبل النشر",
    "استخدم التخزين المؤقت لتسريع الاستدلال",
    "تابع مستودع Hugging Face للحصول على أحدث النماذج"
]

for i, tip in enumerate(tips, 1):
    print(f"{i}. {tip}")
5

الخطوة 5: تعلم تحليل المشاعر

تقنية لتحليل المشاعر في النصوص، يمكن أن تكون إيجابية أو سلبية أو محايدة

الأهمية:

ضروري لفهم مشاعر المستخدمين في التعليقات، المراجعات، أو الرسائل

الأدوات:

TextBlob، VADER، NLTK، Transformers

مثال شامل لتحليل المشاعر:

import nltk
from nltk.sentiment import SentimentIntensityAnalyzer
from textblob import TextBlob
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from transformers import pipeline
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns

print("جاري تحميل أدوات تحليل المشاعر...")

# تحميل البيانات المطلوبة لـ NLTK
nltk.download('vader_lexicon')
nltk.download('punkt')

print("\n" + "="*60)
print("مرحباً في عالم تحليل المشاعر!")
print("="*60)

# مثال 1: تحليل المشاعر باستخدام TextBlob
print("\n1. تحليل المشاعر باستخدام TextBlob:")

def analyze_with_textblob(text):
    """تحليل المشاعر باستخدام TextBlob"""
    blob = TextBlob(text)
    
    # تحليل المشاعر (قطبية وذاتية)
    polarity = blob.sentiment.polarity  # -1 (سلبي) إلى +1 (إيجابي)
    subjectivity = blob.sentiment.subjectivity  # 0 (موضوعي) إلى 1 (ذاتي)
    
    # تحويل القطبية إلى فئة
    if polarity > 0.1:
        sentiment = "إيجابي"
    elif polarity < -0.1:
        sentiment = "سلبي"
    else:
        sentiment = "محايد"
    
    return {
        'text': text,
        'polarity': polarity,
        'subjectivity': subjectivity,
        'sentiment': sentiment,
        'translated': str(blob.translate(to='ar')) if blob.detect_language() != 'ar' else "بالعربية"
    }

# اختبار TextBlob
texts_tb = [
    "I love this product! It's amazing!",
    "This is terrible. I hate it.",
    "The weather is okay today.",
    "Absolutely wonderful experience!",
    "Very disappointing service."
]

print("\nتحليل TextBlob:")
for text in texts_tb:
    result = analyze_with_textblob(text)
    print(f"\nالنص: {text}")
    print(f"القطبية: {result['polarity']:.3f}")
    print(f"الذاتية: {result['subjectivity']:.3f}")
    print(f"المشاعر: {result['sentiment']}")

# مثال 2: تحليل المشاعر باستخدام VADER
print("\n" + "="*60)
print("2. تحليل المشاعر باستخدام VADER:")

def analyze_with_vader(text):
    """تحليل المشاعر باستخدام VADER"""
    sia = SentimentIntensityAnalyzer()
    
    # الحصول على درجات المشاعر
    scores = sia.polarity_scores(text)
    
    # تحديد الفئة بناء على المركب
    compound = scores['compound']
    
    if compound >= 0.05:
        sentiment = "إيجابي"
    elif compound <= -0.05:
        sentiment = "سلبي"
    else:
        sentiment = "محايد"
    
    return {
        'text': text,
        'neg': scores['neg'],      # النسبة السلبية
        'neu': scores['neu'],      # النسبة المحايدة
        'pos': scores['pos'],      # النسبة الإيجابية
        'compound': compound,      # الدرجة المركبة
        'sentiment': sentiment
    }

# اختبار VADER
texts_vader = [
    "This is GREAT! I'm so happy!",
    "I'm really sad and disappointed.",
    "It's normal, nothing special.",
    "WOW! AMAZING! FANTASTIC!",
    "Horrible, awful, terrible."
]

print("\nتحليل VADER:")
for text in texts_vader:
    result = analyze_with_vader(text)
    print(f"\nالنص: {text}")
    print(f"سلبي: {result['neg']:.3f}")
    print(f"محايد: {result['neu']:.3f}")
    print(f"إيجابي: {result['pos']:.3f}")
    print(f"مركب: {result['compound']:.3f}")
    print(f"المشاعر: {result['sentiment']}")

# مثال 3: تحليل المشاعر باستخدام Transformers
print("\n" + "="*60)
print("3. تحليل المشاعر باستخدام Transformers:")

# تحميل نموذج تحليل المشاعر من Hugging Face
print("\nجاري تحميل نموذج Transformers...")
try:
    sentiment_pipeline = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
    
    def analyze_with_transformers(text):
        """تحليل المشاعر باستخدام Transformers"""
        result = sentiment_pipeline(text)[0]
        
        # تحويل التسميات إلى العربية
        label_map = {
            "POSITIVE": "إيجابي",
            "NEGATIVE": "سلبي",
            "LABEL_0": "سلبي",
            "LABEL_1": "إيجابي"
        }
        
        sentiment = label_map.get(result['label'], result['label'])
        
        return {
            'text': text,
            'label': result['label'],
            'score': result['score'],
            'sentiment': sentiment
        }
    
    # اختبار Transformers
    texts_trans = [
        "The movie was fantastic and I enjoyed every minute of it.",
        "This restaurant has the worst service I've ever experienced.",
        "The product arrived on time and works as described."
    ]
    
    print("\nتحليل Transformers:")
    for text in texts_trans:
        result = analyze_with_transformers(text)
        print(f"\nالنص: {text[:50]}...")
        print(f"التصنيف: {result['label']}")
        print(f"الثقة: {result['score']:.3f}")
        print(f"المشاعر: {result['sentiment']}")
        
except Exception as e:
    print(f"حدث خطأ في تحميل نموذج Transformers: {e}")
    print("جارٍ استخدام نموذج بديل...")

# مثال 4: تحليل المشاعر للغة العربية
print("\n" + "="*60)
print("4. تحليل المشاعر للغة العربية:")

def arabic_sentiment_analysis(text):
    """تحليل المشاعر للنصوص العربية"""
    # قاموس المشاعر العربية
    arabic_positive_words = {
        'جيد', 'رائع', 'ممتاز', 'عظيم', 'جميل', 'حسن', 'طيب', 'مذهل',
        'رائع', 'جميل', 'سعيد', 'مفرح', 'مبهر', 'خلاب', 'فريد'
    }
    
    arabic_negative_words = {
        'سيء', 'رديء', 'مزعج', 'مؤسف', 'مخيب', 'مخز', 'قبيح', 'فظيع',
        'مقزز', 'ممل', 'مخيف', 'مؤلم', 'محزن', 'كارثي', 'مخرب'
    }
    
    # تقسيم النص إلى كلمات
    words = text.split()
    
    # حساب التكرار
    positive_count = sum(1 for word in words if word in arabic_positive_words)
    negative_count = sum(1 for word in words if word in arabic_negative_words)
    
    # حساب النتيجة
    total_words = len(words)
    if total_words > 0:
        positive_score = positive_count / total_words
        negative_score = negative_count / total_words
    else:
        positive_score = negative_score = 0
    
    # تحديد المشاعر
    if positive_score > negative_score:
        sentiment = "إيجابي"
        score = positive_score
    elif negative_score > positive_score:
        sentiment = "سلبي"
        score = negative_score
    else:
        sentiment = "محايد"
        score = 0
    
    return {
        'text': text,
        'positive_words': positive_count,
        'negative_words': negative_count,
        'total_words': total_words,
        'positive_score': positive_score,
        'negative_score': negative_score,
        'sentiment': sentiment,
        'score': score
    }

# نصوص عربية للتحليل
arabic_texts = [
    "المنتج جيد والخدمة رائعة",
    "التجربة كانت سيئة للغاية",
    "لا بأس، مقبول",
    "مذهل! أحببت كل شيء",
    "فظيع ومزعج"
]

print("\nتحليل المشاعر العربية:")
for text in arabic_texts:
    result = arabic_sentiment_analysis(text)
    print(f"\nالنص: {text}")
    print(f"كلمات إيجابية: {result['positive_words']}")
    print(f"كلمات سلبية: {result['negative_words']}")
    print(f"المشاعر: {result['sentiment']}")
    print(f"النتيجة: {result['score']:.3f}")

# مثال 5: مقارنة بين أدوات تحليل المشاعر
print("\n" + "="*60)
print("5. مقارنة بين أدوات تحليل المشاعر:")

def compare_sentiment_analyzers(text):
    """مقارنة نتائج أدوات تحليل المشاعر المختلفة"""
    
    results = {}
    
    # TextBlob
    try:
        blob_result = analyze_with_textblob(text)
        results['TextBlob'] = {
            'sentiment': blob_result['sentiment'],
            'score': blob_result['polarity']
        }
    except:
        results['TextBlob'] = {'sentiment': 'N/A', 'score': 0}
    
    # VADER
    try:
        vader_result = analyze_with_vader(text)
        results['VADER'] = {
            'sentiment': vader_result['sentiment'],
            'score': vader_result['compound']
        }
    except:
        results['VADER'] = {'sentiment': 'N/A', 'score': 0}
    
    # Transformers
    try:
        trans_result = analyze_with_transformers(text)
        score = trans_result['score']
        # تحويل الإيجابي/السلبي إلى درجة
        if trans_result['sentiment'] == 'سلبي':
            score = -score
        results['Transformers'] = {
            'sentiment': trans_result['sentiment'],
            'score': score
        }
    except:
        results['Transformers'] = {'sentiment': 'N/A', 'score': 0}
    
    return results

# مقارنة الأدوات
test_comparison = [
    "I absolutely love this! It's perfect!",
    "This is the worst thing I've ever bought.",
    "It's okay, nothing special."
]

print("\nمقارنة الأدوات:")
for text in test_comparison:
    print(f"\nالنص: {text}")
    comparisons = compare_sentiment_analyzers(text)
    
    for tool, result in comparisons.items():
        print(f"{tool:15} → {result['sentiment']:10} (نتيجة: {result['score']:.3f})")

# مثال 6: تحليل المشاعر للتعليقات الجماعية
print("\n" + "="*60)
print("6. تحليل المشاعر للتعليقات الجماعية:")

# بيانات تعليقات افتراضية
comments_data = {
    'comment': [
        "Great product! Highly recommended.",
        "Waste of money. Don't buy it.",
        "Average quality for the price.",
        "Excellent customer service!",
        "Terrible experience. Never again.",
        "Good value for money.",
        "Disappointed with the quality.",
        "Best purchase I've made this year!",
        "Not as described. Very misleading.",
        "Fast shipping and good packaging."
    ],
    'rating': [5, 1, 3, 5, 1, 4, 2, 5, 2, 4]
}

# إنشاء DataFrame
df_comments = pd.DataFrame(comments_data)

# إضافة تحليل المشاعر
def get_sentiment_vader(text):
    """الحصول على المشاعر باستخدام VADER"""
    sia = SentimentIntensityAnalyzer()
    compound = sia.polarity_scores(text)['compound']
    
    if compound >= 0.05:
        return "إيجابي"
    elif compound <= -0.05:
        return "سلبي"
    else:
        return "محايد"

# تطبيق تحليل المشاعر
df_comments['sentiment'] = df_comments['comment'].apply(get_sentiment_vader)

print("\nتحليل تعليقات المستخدمين:")
print(df_comments[['comment', 'rating', 'sentiment']].to_string(index=False))

# تحليل الإحصائيات
print(f"\nالإحصائيات:")
print(f"إجمالي التعليقات: {len(df_comments)}")
print(f"التعليقات الإيجابية: {(df_comments['sentiment'] == 'إيجابي').sum()}")
print(f"التعليقات السلبية: {(df_comments['sentiment'] == 'سلبي').sum()}")
print(f"التعليقات المحايدة: {(df_comments['sentiment'] == 'محايد').sum()}")

# مثال 7: التصور البصري لنتائج تحليل المشاعر
print("\n" + "="*60)
print("7. التصور البصري لنتائج تحليل المشاعر:")

# إعداد البيانات للرسم
sentiment_counts = df_comments['sentiment'].value_counts()

# إنشاء مخطط دائري
plt.figure(figsize=(10, 6))
plt.subplot(1, 2, 1)
colors = ['#4CAF50', '#FF9800', '#F44336']  # أخضر، برتقالي، أحمر
wedges, texts, autotexts = plt.pie(
    sentiment_counts.values,
    labels=sentiment_counts.index,
    autopct='%1.1f%%',
    colors=colors,
    startangle=90
)

# تخصيص النصوص
for autotext in autotexts:
    autotext.set_color('white')
    autotext.set_fontweight('bold')

plt.title('توزيع المشاعر في التعليقات')

# إنشاء مخطط أعمدة للمقارنة مع التقييمات
plt.subplot(1, 2, 2)
rating_by_sentiment = df_comments.groupby('sentiment')['rating'].mean()
bars = plt.bar(rating_by_sentiment.index, rating_by_sentiment.values, color=colors)
plt.title('متوسط التقييم حسب المشاعر')
plt.xlabel('المشاعر')
plt.ylabel('متوسط التقييم')
plt.ylim(0, 5)

# إضافة القيم على الأعمدة
for bar in bars:
    height = bar.get_height()
    plt.text(bar.get_x() + bar.get_width()/2., height + 0.1,
            f'{height:.2f}', ha='center', va='bottom')

plt.tight_layout()
plt.show()

# مثال 8: تحليل المشاعر الزمني
print("\n" + "="*60)
print("8. تحليل المشاعر الزمني:")

# بيانات زمنية افتراضية
time_series_data = {
    'date': pd.date_range('2024-01-01', periods=30, freq='D'),
    'comment': [
        "Great day!", "Okay", "Bad experience", "Excellent", "Average",
        "Wonderful", "Terrible", "Good", "Not bad", "Amazing",
        "Disappointing", "Fantastic", "Poor quality", "Very good", "Mediocre",
        "Outstanding", "Awful", "Satisfactory", "Brilliant", "Unacceptable",
        "Superb", "Below average", "Exceptional", "Unsatisfactory", "Perfect",
        "Inferior", "Marvelous", "Subpar", "Remarkable", "Lousy"
    ]
}

df_time = pd.DataFrame(time_series_data)

# تحليل المشاعر
df_time['sentiment'] = df_time['comment'].apply(get_sentiment_vader)

# تحويل المشاعر إلى أرقام للتحليل
sentiment_map = {'سلبي': -1, 'محايد': 0, 'إيجابي': 1}
df_time['sentiment_score'] = df_time['sentiment'].map(sentiment_map)

# حساب المتوسط المتحرك (7 أيام)
df_time['moving_avg'] = df_time['sentiment_score'].rolling(window=7, min_periods=1).mean()

print("\nتحليل المشاعر الزمني:")
print(df_time[['date', 'comment', 'sentiment', 'sentiment_score', 'moving_avg']].head(10))

# رسم الاتجاه الزمني
plt.figure(figsize=(12, 6))
plt.plot(df_time['date'], df_time['sentiment_score'], 'o-', label='المشاعر اليومية', alpha=0.6)
plt.plot(df_time['date'], df_time['moving_avg'], 'r-', linewidth=3, label='المتوسط المتحرك (7 أيام)')
plt.axhline(y=0, color='gray', linestyle='--', alpha=0.5)
plt.title('اتجاه المشاعر مع الوقت')
plt.xlabel('التاريخ')
plt.ylabel('نتيجة المشاعر')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# مثال 9: تحليل المشاعر باستخدام تعلم الآلة
print("\n" + "="*60)
print("9. تحليل المشاعر باستخدام تعلم الآلة:")

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import MultinomialNB
from sklearn.svm import SVC

# بيانات تدريبية أكبر
train_texts = [
    "I love this movie", "Great film", "Excellent acting",
    "Terrible plot", "Waste of time", "Boring and slow",
    "Amazing cinematography", "Best movie ever", "Highly recommended",
    "Disappointing ending", "Worst movie I've seen", "Not worth watching",
    "Fantastic story", "Brilliant performance", "Masterpiece",
    "Awful dialogue", "Painful to watch", "Complete failure"
]

train_labels = [
    1, 1, 1,  # إيجابي
    0, 0, 0,  # سلبي
    1, 1, 1,  # إيجابي
    0, 0, 0,  # سلبي
    1, 1, 1,  # إيجابي
    0, 0, 0   # سلبي
]

# تحويل النصوص إلى ميزات
vectorizer = TfidfVectorizer(max_features=100)
X = vectorizer.fit_transform(train_texts)
y = np.array(train_labels)

# تقسيم البيانات
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# تدريب النماذج
models = {
    'Logistic Regression': LogisticRegression(),
    'Naive Bayes': MultinomialNB(),
    'SVM': SVC(kernel='linear')
}

results = {}
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = np.mean(y_pred == y_test)
    results[name] = accuracy
    print(f"{name:25} → دقة: {accuracy:.3f}")

# اختبار النموذج الأفضل على نصوص جديدة
best_model_name = max(results, key=results.get)
best_model = models[best_model_name]

test_new_texts = [
    "This is absolutely fantastic!",
    "I really didn't like it at all.",
    "It was okay, nothing special."
]

print(f"\nاختبار النموذج الأفضل ({best_model_name}):")
for text in test_new_texts:
    # تحويل النص إلى ميزات
    features = vectorizer.transform([text])
    prediction = best_model.predict(features)[0]
    sentiment = "إيجابي" if prediction == 1 else "سلبي"
    print(f"'{text}' → {sentiment}")

# مثال 10: تطبيق متكامل لتحليل المشاعر
print("\n" + "="*60)
print("10. تطبيق متكامل لتحليل المشاعر:")

class AdvancedSentimentAnalyzer:
    """محلل مشاعر متقدم يستخدم طرق متعددة"""
    
    def __init__(self):
        self.vader_analyzer = SentimentIntensityAnalyzer()
        
    def analyze(self, text, method='ensemble'):
        """تحليل المشاعر باستخدام طريقة محددة"""
        
        if method == 'vader':
            return self._analyze_vader(text)
        elif method == 'ensemble':
            return self._analyze_ensemble(text)
        else:
            return self._analyze_simple(text)
    
    def _analyze_vader(self, text):
        """تحليل باستخدام VADER"""
        scores = self.vader_analyzer.polarity_scores(text)
        compound = scores['compound']
        
        if compound >= 0.05:
            sentiment = "إيجابي"
        elif compound <= -0.05:
            sentiment = "سلبي"
        else:
            sentiment = "محايد"
        
        return {
            'method': 'VADER',
            'text': text,
            'sentiment': sentiment,
            'score': compound,
            'details': scores
        }
    
    def _analyze_simple(self, text):
        """تحليل بسيط باستخدام القواميس"""
        positive_words = {'good', 'great', 'excellent', 'amazing', 'wonderful'}
        negative_words = {'bad', 'terrible', 'awful', 'horrible', 'poor'}
        
        words = text.lower().split()
        positive_count = sum(1 for word in words if word in positive_words)
        negative_count = sum(1 for word in words if word in negative_words)
        
        if positive_count > negative_count:
            sentiment = "إيجابي"
            score = positive_count / len(words) if words else 0
        elif negative_count > positive_count:
            sentiment = "سلبي"
            score = -negative_count / len(words) if words else 0
        else:
            sentiment = "محايد"
            score = 0
        
        return {
            'method': 'Simple',
            'text': text,
            'sentiment': sentiment,
            'score': score,
            'details': {
                'positive_count': positive_count,
                'negative_count': negative_count
            }
        }
    
    def _analyze_ensemble(self, text):
        """تحليل باستخدام المجموعة (متوسط الطرق)"""
        vader_result = self._analyze_vader(text)
        simple_result = self._analyze_simple(text)
        
        # تحويل النتائج إلى درجات موحدة (-1 إلى +1)
        vader_score = vader_result['score']
        simple_score = simple_result['score']
        
        # متوسط الدرجات
        ensemble_score = (vader_score + simple_score) / 2
        
        if ensemble_score >= 0.1:
            sentiment = "إيجابي"
        elif ensemble_score <= -0.1:
            sentiment = "سلبي"
        else:
            sentiment = "محايد"
        
        return {
            'method': 'Ensemble',
            'text': text,
            'sentiment': sentiment,
            'score': ensemble_score,
            'details': {
                'vader_score': vader_score,
                'simple_score': simple_score,
                'vader_sentiment': vader_result['sentiment'],
                'simple_sentiment': simple_result['sentiment']
            }
        }

# اختبار المحلل المتقدم
analyzer = AdvancedSentimentAnalyzer()

test_texts = [
    "This product is absolutely fantastic and works perfectly!",
    "I'm very disappointed with the quality and service.",
    "It's average, does the job but nothing special."
]

print("\nتحليل المشاعر المتقدم:")
for text in test_texts:
    print(f"\nالنص: {text[:50]}...")
    
    # تحليل بطرق مختلفة
    for method in ['vader', 'simple', 'ensemble']:
        result = analyzer.analyze(text, method=method)
        print(f"{method:10} → {result['sentiment']:10} (نتيجة: {result['score']:.3f})")

# ملخص أدوات تحليل المشاعر
print("\n" + "="*60)
print("ملخص أدوات تحليل المشاعر:")
print("="*60)

tools_summary = [
    ("TextBlob", "بسيط وسهل، جيد للنصوص الإنجليزية العامة"),
    ("VADER", "مصمم خصيصًا لوسائل التواصل الاجتماعي"),
    ("Transformers", "أكثر دقة، يحتاج موارد حسابية"),
    ("القواميس المخصصة", "مرن، يحتاج بناء قاموس"),
    ("تعلم الآلة", "دقيق مع بيانات تدريب كافية"),
    ("المجموعة (Ensemble)", "أفضل دقة بجمع طرق متعددة")
]

for tool, description in tools_summary:
    print(f"• {tool:20}: {description}")

print("\n" + "="*60)
print("نصائح لتحليل المشاعر الفعال:")
print("="*60)

advice = [
    "اختر الأداة المناسبة لنوع النصوص (وسائل التواصل، مراجعات، مقالات)",
    "ضبط العتبات بناءً على المجال (ما يعتبر إيجابيًا في مجال قد يختلف)",
    "استخدام تقنيات ما قبل المعالجة لتحسين النتائج",
    "دمج طرق متعددة للحصول على نتائج أكثر دقة",
    "تقييم الأداء على بيانات اختبار حقيقية",
    "أخذ السياق والنفي في الاعتبار (مثل 'ليس جيدًا')",
    "التعامل مع النصوص متعددة اللغات بشكل مناسب",
    "مراقبة وتحديث النماذج بانتظام"
]

for i, tip in enumerate(advice, 1):
    print(f"{i}. {tip}")

هندسة معالجة اللغات الطبيعية

طبقة المعالجة الأولية

التقطيع، إزالة الكلمات الشائعة، التصريف، التطبيع

طبقة الميزات

تمثيل الكلمات، التضمينات، استخراج الميزات

طبقة النماذج

Transformers، التعلم العميق، النماذج اللغوية

طبقة التطبيق

تحليل المشاعر، الترجمة، التلخيص، الإجابة على الأسئلة

أدوات معالجة اللغات الطبيعية

Python

اللغة الأساسية لمعالجة النصوص والذكاء الاصطناعي

NLP تعلم آلي تحليل

NLTK

مكتبة شاملة للمعالجة اللغوية والتعليم

تقطيع تحليل تصريف

SpaCy

مكتبة صناعية سريعة للمعالجة المتقدمة

NER تحليل نحوي كفاءة

المزايا والتحديات

المزايا

  • طلب عالي: هناك طلب كبير على مهندسي NLP خاصة في الشركات التي تعتمد على الذكاء الاصطناعي لتحليل النصوص
  • أدوات مجانية: معظم الأدوات المستخدمة مثل NLTK و SpaCy و Transformers مجانية ومفتوحة المصدر
  • مجتمع كبير: Python و Hugging Face لديهما مجتمعات نشطة توفر الدعم والموارد
  • تأثير كبير: تطبيقات NLP تغير كيفية تفاعلنا مع التكنولوجيا
  • مجالات متنوعة: تطبيقات في الرعاية الصحية، المالية، التعليم، وغيرها

التحديات

  • تعقيد اللغة: اللغات البشرية معقدة وتحتوي على العديد من الاستثناءات
  • اللغات المختلفة: دعم اللغات غير الإنجليزية يتطلب مجهودًا إضافيًا
  • البيانات المطلوبة: النماذج المتقدمة تحتاج كميات هائلة من البيانات
  • التحيز في البيانات: النماذج قد تتعلم تحيزات موجودة في بيانات التدريب

أنواع مشاريع معالجة اللغات الطبيعية

تحليل المشاعر

تحليل مشاعر التعليقات والمراجعات ووسائل التواصل

مشاعر تحليل تقييم

الترجمة الآلية

ترجمة النصوص بين اللغات المختلفة

ترجمة لغات نصوص

المساعدات الذكية

بناء مساعدات ذكية تجيب على الأسئلة

أسئلة إجابات ذكاء

الخلاصة

معالجة اللغات الطبيعية أصبحت أحد أهم مجالات الذكاء الاصطناعي. من خلال إتقان Python، NLTK، SpaCy، Hugging Face Transformers، وتقنيات تحليل المشاعر، يمكنك بناء أنظمة ذكية تفهم وتعالج اللغة البشرية.

نصائح للبدء:

  • ابدأ بتعلم Python جيداً فهو الأساس لجميع مكتبات NLP
  • تعلم NLTK لفهم أساسيات معالجة النصوص
  • انتقل إلى SpaCy للمعالجة المتقدمة والصناعية
  • استخدم Hugging Face للوصول إلى أحدث نماذج الذكاء الاصطناعي
  • تمرن على مشاريع حقيقية وشاركها في محفظة أعمالك

موارد تعليمية:

Hugging Face SpaCy Documentation NLTK Documentation Kaggle NLP Competitions