LLM اختصار لـ:
Large Language Model — نموذج لغوي كبير
وهو نموذج ذكاء اصطناعي يتعلم الأنماط الموجودة في كمية هائلة من النصوص.
بشكل مبسط، المهمة الأساسية للنموذج هي:
إعطاء نص سابق
↓
محاولة توقع الـ Token التالي
↓
إضافة الـ Token إلى النص
↓
تكرار العملية
مثال:
النص:
"عاصمة الجزائر هي"
النموذج يتوقع:
الجزائرية 5%
الجزائر 90%
باريس 1%
...
↓ اختيار
"الجزائر"
ثم يصبح السياق:
عاصمة الجزائر هي الجزائر
وهكذا تستمر العملية Token بعد Token.
يمكن تصور النظام كاملاً بالشكل التالي:
┌─────────────────────┐
│ مصادر البيانات │
│ Web / Books / Code │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Data Collection │
│ جمع البيانات │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Data Cleaning │
│ تنظيف البيانات │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Deduplication │
│ إزالة التكرار │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Tokenization │
│ تقسيم النص Tokens │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Embedding │
│ تحويل إلى Vectors │
└──────────┬──────────┘
│
▼
┌──────────────────────────┐
│ PRE-TRAINING │
│ Transformer + Attention │
└────────────┬─────────────┘
│
▼
┌──────────────────────────┐
│ Fine-Tuning / Alignment │
│ SFT + RLHF / DPO │
└────────────┬─────────────┘
│
▼
┌──────────────────────────┐
│ Model Optimization │
│ Quantization / Pruning │
│ Distillation │
└────────────┬─────────────┘
│
▼
┌──────────────────────────┐
│ INFERENCE │
│ Prompt → Response │
└──────────────────────────┘
سنشرح الآن كل مرحلة.
الـ LLM لا يبدأ بمعرفة اللغة.
في البداية يكون لدينا نموذج يحتوي على أوزان عشوائية تقريباً.
لكي يتعلم، نحتاج إلى كمية ضخمة من النصوص.
مثال:
المقالات
الكتب
المواقع
الأبحاث
الشيفرات البرمجية
الوثائق التقنية
المحادثات
يمكن تصور البيانات هكذا:
Database / Files / Web
│
├── Article 1
├── Article 2
├── Book
├── Source Code
└── Documentation
│
▼
Dataset
لدينا البيانات التالية:
الجزائر دولة في شمال إفريقيا.
لغة البرمجة C# تستخدم لتطوير التطبيقات.
PostgreSQL هو نظام لإدارة قواعد البيانات.
هذه النصوص تصبح جزءاً من Dataset التدريب.
لكن لا يمكن إرسالها مباشرة إلى النموذج.
أولاً يجب تنظيفها.
الإنترنت يحتوي على كمية ضخمة من البيانات غير المفيدة.
مثال:
<div class="ads">
BUY NOW!!!
CLICK HERE!!!
</div>أو:
xxxxxxxxxxxx
SPAM SPAM SPAM
أو محتوى مكرر:
Hello world
Hello world
Hello world
Hello world
يتم تطبيق Pipeline مثل:
Raw Data
│
▼
Remove HTML
│
▼
Remove Spam
│
▼
Remove Duplicates
│
▼
Normalize Text
│
▼
Clean Dataset
لنفترض أن لدينا:
Article A:
.NET is a modern development platform.
Article B:
.NET is a modern development platform.
Article C:
.NET is a modern development platform.
إذا تم تدريب النموذج عليها بشكل مفرط، فقد تتكرر بعض المعلومات أكثر من اللازم.
لذلك:
Before:
A ──┐
B ──┼── نفس المحتوى
C ──┘
After Deduplication:
A فقط
النموذج لا يرى النص كما نراه نحن.
مثلاً:
أنا أتعلم البرمجة
قد يتم تقسيمه إلى وحدات تسمى:
Tokens
تصور مبسط:
أنا
أتعلم
البرمجة
فتصبح:
[أنا] [أتعلم] [البرمجة]
وفي بعض الحالات يمكن تقسيم الكلمة إلى أجزاء أصغر.
مثلاً:
programming
قد تصبح تقريباً:
program
ming
أو حسب الـ Tokenizer المستخدم.
Input:
"أنا أستخدم C#"
│
▼
Tokenizer
│
▼
Tokens:
[أنا]
[أستخدم]
[C]
[#]
ثم يتم تحويل كل Token إلى رقم:
أنا → 1023
أستخدم → 8542
C → 500
# → 101
فتصبح:
[1023, 8542, 500, 101]
الأرقام السابقة ليست كافية لتمثيل المعنى.
لذلك يتم تحويل كل Token إلى Vector.
مثلاً:
Token:
"قط"
قد يتم تمثيله بشكل مبسط:
[0.12, -0.55, 0.91, 0.23, ...]
في الواقع، يحتوي الـ Vector عادة على عدد كبير من الأبعاد.
تصور:
Token
│
▼
Embedding Layer
│
▼
Vector
[0.12, -0.55, 0.91, 0.23, ...]
لأن النموذج يعمل رياضياً.
النموذج لا يفهم كلمة:
Database
كما يفهمها الإنسان.
بل يتعامل مع:
Vector
والعلاقات الرياضية بين المتجهات.
فكرة الـ Embeddings تسمح بوجود كلمات متقاربة في فضاء رياضي.
تصور مبسط:
حيوان
│
┌──────┴──────┐
│ │
قط كلب
مركبة
│
┌──────┴──────┐
│ │
سيارة شاحنة
في الفضاء المتجهي:
cat قريب من dog
car قريب من truck
لكن:
cat بعيد عن database
وهذه الفكرة تساعد النموذج على تمثيل العلاقات والمعاني.
Transformer هو نوع من الشبكات العصبية المستخدمة لمعالجة تسلسلات النص.
لدينا:
أنا أتعلم البرمجة باستخدام C#
النموذج يجب أن يفهم العلاقة بين الكلمات.
مثلاً:
أنا
↓
أتعلم
↓
البرمجة
↓
باستخدام
↓
C#
لكن اللغة ليست دائماً بسيطة بهذا الشكل.
انظر إلى:
ذهب خالد إلى المكتبة لأنه يريد قراءة كتاب.
كلمة:
يريد
ترتبط بـ:
خالد
وليس بالضرورة بالكلمة السابقة مباشرة.
هنا تأتي أهمية:
لنفترض الجملة:
خالد يبرمج تطبيقاً لأنه يحب البرمجة
عند معالجة كلمة:
يحب
قد يحتاج النموذج إلى النظر إلى:
خالد
وليس فقط إلى الكلمة السابقة.
يمكن تصور Attention هكذا:
┌──────── خالد
│
│ أهمية عالية
▼
[خالد] [يبرمج] [تطبيقاً] [لأنه] [يحب] [البرمجة]
│
├──── ينظر إلى كلمات أخرى
│
▼
حساب العلاقات
رياضياً، تعتمد Self-Attention على ثلاثة عناصر:
Query (Q)
Key (K)
Value (V)
المعادلة الشهيرة:
Attention(Q, K, V)
=
softmax(QKᵀ / √d) × V
بشكل مبسط:
Query
│
├──── مقارنة مع Keys
│
▼
Attention Scores
│
▼
Softmax
│
▼
Weights
│
▼
Values
│
▼
Context Representation
النموذج يسأل:
ما الكلمات المهمة لفهم هذه الكلمة؟
ثم يعطي كل كلمة وزناً.
مثلاً:
خالد 0.60
يبرمج 0.15
تطبيقاً 0.05
لأنه 0.05
البرمجة 0.15
هذه مجرد فكرة توضيحية، وليست أرقاماً حقيقية لنموذج محدد.
بدلاً من وجود Attention واحد، يحتوي الـ Transformer عادة على عدة رؤوس Attention.
تصور:
Input
│
├──── Head 1 → علاقة نحوية
│
├──── Head 2 → علاقة دلالية
│
├──── Head 3 → علاقة زمنية
│
└──── Head N → علاقات أخرى
│
▼
Combine
│
▼
Output
كل Head يمكن أن يتعلم نوعاً مختلفاً من العلاقات.
المهمة الأساسية هي:
توقع الـ Token التالي.
مثال:
Input:
"أنا أتعلم"
Expected:
"البرمجة"
النموذج يحاول توقع:
أنا أتعلم → ؟
في البداية قد تكون الإجابة عشوائية:
السيارة 0.20
البرمجة 0.10
البحر 0.30
الطعام 0.40
الإجابة الصحيحة:
البرمجة
يتم حساب الخطأ:
Loss
ثم:
Prediction
│
▼
Calculate Loss
│
▼
Backpropagation
│
▼
Update Weights
│
▼
Try Again
ويتكرر هذا مليارات المرات.
الأوزان هي الأرقام الداخلية التي تشكل "معرفة" النموذج.
بشكل مبسط:
Model
W1 = 0.23
W2 = -1.52
W3 = 0.78
W4 = 2.10
...
أثناء التدريب:
Input
│
▼
Prediction
│
▼
Wrong?
│
├── Yes → Update Weights
│
└── No → Continue
بعد ملايين ومليارات عمليات التعديل، تصبح الأوزان قادرة على إنتاج تنبؤات أفضل.
لنفترض الجملة:
أنا أتعلم C#
يتم تحويلها إلى مهمة تدريب:
Input:
أنا
Target:
أتعلم
ثم:
Input:
أنا أتعلم
Target:
C#
يمكن تصورها:
[أنا] ───────────────► أتعلم
[أنا أتعلم] ─────────► C#
هذا يحدث على كمية ضخمة من البيانات.
بعد Pre-training، النموذج يعرف كيفية إكمال النص.
لكن ربما لا يعرف أنه يجب أن يتصرف كمساعد.
مثلاً:
User:
ما هي عاصمة الجزائر؟
النموذج الأساسي قد يكمل النص بطريقة غير مناسبة.
لذلك نستخدم بيانات منظمة:
Instruction:
ما هي عاصمة الجزائر؟
Response:
عاصمة الجزائر هي الجزائر العاصمة.
ثم يتعلم النموذج النمط:
Question
↓
Understand Instruction
↓
Generate Helpful Answer
شكل بيانات SFT:
{
"instruction": "اشرح ما هو PostgreSQL",
"response": "PostgreSQL هو نظام ..."
}ثم:
High Quality Examples
│
▼
Supervised Fine-Tuning
│
▼
Assistant Model
يمكن للنموذج أن يكون ذكياً لغوياً، لكن نريد أن تكون إجاباته:
مفيدة
آمنة
واضحة
مرتبطة بالسؤال
هنا تأتي مرحلة:
Alignment
RLHF تعني:
Reinforcement Learning from Human Feedback
بشكل مبسط:
Prompt
│
▼
Model generates answers
│
▼
Humans compare answers
│
▼
Preferred Answer
│
▼
Model learns preferences
مثال:
Question:
اشرح REST API
النموذج يولد:
Answer A:
شرح طويل وغير واضح
Answer B:
شرح منظم مع مثال
يقوم الإنسان بتحديد:
B أفضل
ويتدرب النموذج على تفضيل خصائص الإجابة الأفضل.
DPO تعني:
Direct Preference Optimization
الفكرة أيضاً تعتمد على المقارنة بين:
Chosen Response
و:
Rejected Response
مثال:
Prompt
│
├──── Answer A ✓
│
└──── Answer B ✗
ثم يتعلم النموذج إعطاء احتمال أعلى لنمط الإجابات المفضلة.
لنفترض أن لدينا نموذجاً:
100 GB RAM
تشغيله سيكون مكلفاً.
لذلك نستخدم تقنيات مثل:
Quantization
Pruning
Distillation
الأوزان قد تكون:
Float32
أي:
32 bits
يمكن تحويلها إلى:
Float16
Int8
Int4
تصور:
Original Model
Weight:
0.123456789
Float32
│
▼
Quantization
│
▼
Int8 / Int4 Representation
الفائدة:
Memory ↓
Cost ↓
Inference Speed ↑
لكن هناك احتمال:
Accuracy ↓ قليلاً
لنفترض شبكة:
A ────── B
│ \ │
│ \ │
│ \ │
C ────── D
بعض الاتصالات قد يكون تأثيرها ضعيفاً.
يتم حذفها:
A ────── B
│ │
│ │
C ────── D
الهدف:
Smaller Model
لدينا:
Large Teacher Model
│
│ Knowledge
▼
Small Student Model
المعلم:
Large
Slow
Expensive
الطالب:
Smaller
Faster
Cheaper
الفكرة هي محاولة نقل أكبر قدر ممكن من سلوك النموذج الكبير إلى النموذج الأصغر.
الآن النموذج جاهز للاستخدام.
المستخدم يرسل:
اشرح لي PostgreSQL
ماذا يحدث؟
User
"اشرح لي PostgreSQL"
↓
LLM Server
اشرح لي PostgreSQL
↓
[اشرح]
[لي]
[Post]
[gre]
[SQL]
هذا مثال توضيحي فقط؛ التقسيم الفعلي يعتمد على الـ Tokenizer.
Tokens
[Token1]
[Token2]
[Token3]
│
▼
Embedding Layer
│
▼
Vectors
مثلاً:
Token 1
[0.21, -0.44, 0.81, ...]
Token 2
[0.12, 0.92, -0.10, ...]
Embeddings
│
▼
┌─────────────────┐
│ Transformer 1 │
└────────┬────────┘
▼
┌─────────────────┐
│ Transformer 2 │
└────────┬────────┘
▼
┌─────────────────┐
│ Transformer 3 │
└────────┬────────┘
▼
...
▼
┌─────────────────┐
│ Transformer N │
└────────┬────────┘
│
▼
Token Probabilities
النموذج ينتج احتمالات:
PostgreSQL 0.20
هو 0.30
نظام 0.25
قاعدة 0.15
...
ثم يجب اختيار Token واحد.
طرق الاختيار مختلفة.
اختيار أعلى احتمال:
A = 0.60 ✓
B = 0.30
C = 0.10
النتيجة:
A
Temperature تؤثر على توزيع الاحتمالات.
بشكل مفاهيمي:
Low Temperature
أكثر استقراراً
أقل عشوائية
High Temperature
أكثر تنوعاً
أكثر عشوائية
لنفترض:
A = 40%
B = 30%
C = 15%
D = 10%
E = 5%
إذا:
Top-K = 3
يتم الاختيار فقط من:
A
B
C
بدلاً من اختيار عدد ثابت من الكلمات، يتم اختيار مجموعة Tokens تصل إلى نسبة احتمالية معينة.
مثلاً:
Top-P = 0.90
يتم الاحتفاظ بالـ Tokens الأكثر احتمالاً حتى يصل مجموع احتمالاتها تقريباً إلى 90%.
لنفترض أن المستخدم كتب:
ما هو PostgreSQL؟
النموذج يولد:
Step 1:
"PostgreSQL"
ثم:
ما هو PostgreSQL؟
PostgreSQL
↓
Step 2:
"هو"
↓
ما هو PostgreSQL؟
PostgreSQL هو
↓
Step 3:
"نظام"
↓
PostgreSQL هو نظام
وتستمر العملية:
Prompt
│
▼
Predict Token
│
▼
Append Token
│
▼
Predict Next Token
│
▼
Append Token
│
▼
...
حتى تصل إلى:
End Of Sequence
أو إلى حد معين من الـ Tokens.
لنأخذ السؤال:
ما هي عاصمة الجزائر؟
Prompt
↓
ما هي عاصمة الجزائر؟
Tokenization
↓
[ما]
[هي]
[عاصمة]
[الجزائر]
[؟]
Embedding
↓
Vectors
Transformer
↓
Self-Attention
يقوم النموذج بتحليل العلاقات بين:
عاصمة ← الجزائر
Probability Distribution
↓
الجزائر العاصمة 0.92
وهران 0.03
قسنطينة 0.02
...
Sampling
↓
الجزائر العاصمة
تتكرر العملية لتكوين الجملة:
عاصمة الجزائر هي الجزائر العاصمة.
يمكن اختصار كل ما يحدث داخل الـ LLM في هذا المخطط:
TRAINING
Raw Text
│
▼
Data Cleaning
│
▼
Deduplication
│
▼
Tokenization
│
▼
Embeddings
│
▼
Transformer
│
▼
Self-Attention
│
▼
Next Token Prediction
│
▼
Calculate Loss
│
▼
Backpropagation
│
▼
Update Weights
│
▼
Repeat Billions of Times
ALIGNMENT
Pretrained Model
│
▼
Fine-Tuning
│
▼
SFT
│
▼
RLHF / DPO
│
▼
Safety
│
▼
Production Model
INFERENCE
User Prompt
│
▼
Tokenizer
│
▼
Embeddings
│
▼
Transformer
│
▼
Attention
│
▼
Token Probabilities
│
▼
Sampling
│
▼
Next Token
│
└───────────────┐
│
▼
Repeat
│
▼
Final Response
الفكرة الأساسية التي يجب تذكرها هي:
الـ LLM هو في جوهره نظام يتعلم من كميات ضخمة من البيانات كيفية توقع الـ Token التالي، باستخدام شبكة Transformer وآلية Self-Attention، ثم يتم تحسينه ومحاذاته، وبعد ذلك يولّد الإجابات Token بعد Token.
إذا أردت، أستطيع في الخطوة التالية إعداد الجزء الثاني من الدرس بعنوان: "بناء Mini LLM عملياً خطوة بخطوة باستخدام Python وPyTorch"، حيث نطبق عملياً: Tokenizer → Embedding → Self-Attention → Transformer → Training على مثال صغير.