Local AI on kenji.blog

كيفية ضبط TinyLLaMA بأسرع طريقة في بيئة محلية

Fri, 11 Sep 2026 16:00:00 +0900

1. مقدمة: لماذا TinyLLaMA والبيئة المحلية الآن؟

يتقدم تطور النماذج اللغوية الكبيرة (LLMs) بسرعة هائلة، ومع ذلك يستمر عدد معلمات النماذج (Parameters) في التضخم ليصل إلى مئات المليارات. في حين أن النماذج الضخمة مثل GPT-4 و Claude 3 تتمتع بأداء لا مثيل له، إلا أن التكلفة الحسابية اللازمة للاستنتاج (Inference) والتدريب، بالإضافة إلى المخاوف المتعلقة بالأمان وخصوصية البيانات عند استخدام واجهات برمجة التطبيقات (APIs) الخارجية، تشكل عقبات كبيرة للشركات. خاصة في الأعمال التي تتعامل مع بيانات داخلية سرية للغاية أو معلومات شخصية، فإن إرسال البيانات إلى واجهات برمجة تطبيقات LLM عامة على السحابة (Cloud) غالباً ما يكون غير مقبول من منظور الامتثال (مثل GDPR و APPI).

لذلك، تتجه الأنظار نحو النماذج اللغوية الصغيرة (SLM: Small Language Models) و التشغيل المحلي في بيئات محلية (On-premises). من بينها، يتميز “TinyLLaMA” بحجمه المدمج الذي يبلغ 1.1 مليار معلمة فقط (1.1B)، إلا أنه تم تدريبه مسبقًا على مجموعة بيانات ضخمة تبلغ حوالي 3 تريليون رمز (Tokens)، مما يجعله يظهر أداءً مذهلاً مقارنة بالنماذج من نفس الفئة.

في هذا المقال، سنقدم دليلاً كاملاً للضبط الدقيق (Fine-tuning) لـ TinyLLaMA في بيئة محلية (خادم محلي أو محطة عمل) للمهام الخاصة بشركتك، بـ “أسرع وأعلى كفاءة”. سنشرح كل شيء بشمولية، بدءًا من الخلفية الرياضية وتقنيات التحسين الحديثة، وصولاً إلى أكواد التنفيذ الفعلية باستخدام PyTorch.

2. بنية TinyLLaMA وخصائصه

يعتمد TinyLLaMA على بنية LLaMA (Large Language Model Meta AI) التي طورتها شركة Meta. على الرغم من إبقاء عدد المعلمات عند 1.1B، إلا أنه يستخدم نفس حزمة التقنيات المستخدمة في LLaMA 2، مما يتميز بتوافق عالٍ جداً مع النظام البيئي.

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

RMSNorm (Root Mean Square Normalization): تقنية تطبيع (Normalization) تعمل على تحسين الكفاءة الحسابية عن طريق حذف طرح المتوسط من حسابات LayerNorm التقليدية. إنها تزيد من الإنتاجية مع الحفاظ على استقرار التدريب.
دالة التنشيط SwiGLU: في شبكة التغذية الأمامية (Feed Forward Network - FFN)، يتم استخدام SwiGLU بدلاً من ReLU أو GELU التقليدية. يتم التعبير عن هذا رياضياً على النحو التالي: $$ \text{SwiGLU}(x, W, V) = \text{Swish}(xW) \otimes (xV) $$ هنا، يمثل $\otimes$ الضرب على مستوى العناصر (Hadamard product)، ودالة Swish هي $\text{Swish}(z) = z \cdot \sigma(\beta z)$. هذا يحسن من القدرة التعبيرية بشكل كبير.
RoPE (Rotary Position Embedding): طريقة تجمع بين مزايا التضمين الموضعي المطلق (Absolute position encoding) والنسبي (Relative position encoding). تتمتع بأداء تعميمي عالٍ حتى عند تمديد طول التسلسل.
Grouped Query Attention (GQA): نهج وسط بين Multi-Head Attention (MHA) و Multi-Query Attention (MQA)، ومن خلال تجميع رؤوس المفاتيح (Keys) والقيم (Values)، فإنه يوفر عرض النطاق الترددي للذاكرة ويزيد من سرعة الاستنتاج بشكل كبير.

يوضح مخطط Mermaid أدناه تدفق البيانات العام لـ TinyLLaMA وبنية كتلة المحول (Transformer block).

graph TD A["النص المدخل"] --> B["المرمز (BPE)"] B --> C["طبقة التضمين"] C --> D["كتل المحول (22 طبقة لـ TinyLLaMA)"] D --> E["RMSNorm (نهائي)"] E --> F["الإسقاط الخطي (حجم المفردات)"] F --> G["احتمالات المخرجات (Softmax)"] subgraph "تشريح كتلة المحول" D1["حالة الإخفاء المدخلة"] --> D2["RMSNorm"] D2 --> D3["انتباه الاستعلام المجمع (GQA)"] D3 --> D4["إضافة متبقية"] D4 --> D5["RMSNorm"] D5 --> D6["SwiGLU FFN"] D6 --> D7["إضافة متبقية"] D7 --> D8["المخرجات للطبقة التالية"] D1 -.-> D4 D4 -.-> D7 end

3. اختراق في الضبط الدقيق: LoRA و QLoRA

لإجراء ضبط دقيق كامل المعلمات (Full parameter fine-tuning) في بيئة محلية، حتى بالنسبة لنموذج 1.1B، فإنه يستهلك عشرات الجيجابايت من ذاكرة VRAM (ذاكرة الفيديو) للاحتفاظ بحالة المحسن (Optimizer) والتدرجات (Gradients). لتحقيق تدريب فعال بموارد محدودة، من الضروري استخدام طريقة PEFT (Parameter-Efficient Fine-Tuning) وهي “LoRA” وامتداد التكميم (Quantization) الخاص بها “QLoRA”.

3.1 الخلفية الرياضية لـ LoRA (Low-Rank Adaptation)

LoRA هي طريقة تقوم بتجميد (Freeze) مصفوفات الأوزان المدربة مسبقًا، وتقريب مقدار تحديث الوزن ($\Delta W$) كحاصل ضرب مصفوفتين صغيرتين منخفضتي الرتبة (Low-rank).

لنفترض أن الأوزان المدربة مسبقًا هي $W_0 \in \mathbb{R}^{d \times k}$. في الضبط الدقيق الكامل، يتم تحديث $W_0$ نفسها لتصبح $W_0 + \Delta W$، ولكن في LoRA يتم تحليل مصفوفة التحديث $\Delta W$ على النحو التالي:

$$ \Delta W = B \times A $$

هنا، $B \in \mathbb{R}^{d \times r}$، و $A \in \mathbb{R}^{r \times k}$، و $r$ هي معلمة فائقة (Hyperparameter) تسمى الرتبة (Rank)، وهي قيمة صغيرة جداً (عادة 8، 16، 32، وما إلى ذلك) تلبي $r \ll \min(d, k)$.

يكون حساب التمرير الأمامي (Forward pass) على النحو التالي:

$$ h = W_0 x + \Delta W x = W_0 x + B A x $$

في الحالة الأولية، تتم تهيئة المصفوفة $A$ بشكل عشوائي بتوزيع طبيعي (Gaussian distribution)، وتتم تهيئة المصفوفة $B$ كمصفوفة صفرية. وبسبب هذا، تكون $\Delta W$ في بداية التدريب صفراً، مما يسمح ببدء التدريب مع الاحتفاظ بمخرجات النموذج الأساسي (Base model) بالكامل.

graph LR X["متجه الإدخال x"] --> W0["الوزن المجمد المدرب مسبقًا (W_0)"] X --> A["مصفوفة LoRA القابلة للتدريب A (r x k)"] A --> B["مصفوفة LoRA القابلة للتدريب B (d x r)"] W0 --> Add["جمع المتجهات"] B --> Add Add --> Y["متجه الإخراج h"]

3.2 ابتكار QLoRA (Quantized LoRA)

تدفع QLoRA بنهج LoRA خطوة أبعد، وهي طريقة تقوم بتكميم (Quantize) النموذج الأساسي $W_0$ إلى دقة 4-bit (NormalFloat 4, NF4) وتحميله في الذاكرة. هذا يقلل بشكل كبير من استهلاك VRAM.

تتضمن QLoRA ثلاث تقنيات مهمة:

تكميم 4-bit NormalFloat (NF4): نوع بيانات مثالي نظرياً ومحسن للأوزان التي تتبع توزيعاً طبيعياً.
التكميم المزدوج (Double Quantization): يوفر المزيد من الذاكرة عن طريق تكميم ثوابت التكميم (معاملات المقياس - Scale factors) نفسها.
Paged Optimizers: آلية تستخدم ميزة الذاكرة الموحدة من NVIDIA لتفريغ (Evict) حالة المحسن مؤقتاً إلى ذاكرة الوصول العشوائي (RAM) الخاصة بوحدة المعالجة المركزية (CPU) عند نفاد VRAM.

نتيجة لذلك، فإن الضبط الذي يتطلب عادةً من 16 جيجابايت إلى 24 جيجابايت من VRAM يمكن إجراؤه بسهولة على وحدات معالجة رسومات استهلاكية (مثل RTX 3060 12GB أو RTX 4070).

4. متطلبات الأجهزة والإعداد في البيئة المحلية

تعتبر متطلبات الأجهزة لضبط TinyLLaMA (1.1B) باستخدام QLoRA منخفضة جداً.

مواصفات الأجهزة الموصى بها

وحدة معالجة الرسومات (GPU): NVIDIA RTX 3060 (12GB) أو RTX 3090/4090 (24GB) أو NVIDIA A10G/A100 وغيرها. تعمل إذا كان هناك 8 جيجابايت من VRAM على الأقل، ولكن يوصى بـ 12 جيجابايت أو أكثر لزيادة حجم الدفعة (Batch size).
وحدة المعالجة المركزية (CPU): وحدة معالجة مركزية حديثة بـ 8 نوى أو أكثر (Intel Core i7/i9، AMD Ryzen 7/9)
ذاكرة الوصول العشوائي (RAM): 32 جيجابايت أو أكثر (مهمة كوجهة إخلاء من VRAM عند استخدام Paged Optimizers)
مساحة التخزين: NVMe SSD (لتسريع قراءة مجموعة البيانات وحفظ النموذج)

إعداد بيئة البرامج

هذه إرشادات الإعداد بفرض استخدام بيئة Ubuntu 22.04 LTS. سنستخدم Python 3.10 أو أحدث.

1
2
3
4
5
6
7
8
9


# إنشاء بيئة افتراضية وتفعيلها
python3 -m venv tinyllama_env
source tinyllama_env/bin/activate

# تثبيت PyTorch (لـ CUDA 12.1)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# تثبيت المكتبات المتعلقة بالمحولات (Transformers)
pip install transformers datasets peft trl accelerate bitsandbytes

5. تقنيات التحسين للحصول على أسرع ضبط

لإكمال الضبط بـ “أسرع” طريقة، لا يكفي مجرد تشغيل النص البرمجي، بل يجب الجمع بين تقنيات التحسين التالية.

5.1 Flash Attention 2

في آلية الانتباه (Attention) القياسية، يكون التعقيد الزمني والمكاني $O(N^2)$ بالنسبة لطول التسلسل $N$. تعمل تقنية Flash Attention 2 على تحسين الوصول إلى الذاكرة بين SRAM و HBM (الذاكرة ذات النطاق الترددي العالي) في GPU، مما يزيل اختناقات الإدخال/الإخراج (IO bottlenecks) دون تقليل كمية الحسابات، ويرفع سرعة التدريب عدة مرات، ويقلل استهلاك الذاكرة بشكل كبير.

5.2 Gradient Checkpointing (نقاط فحص التدرج)

بدلاً من حفظ جميع التنشيطات الوسيطة (Intermediate activations) المحسوبة في التمرير الأمامي في VRAM، تقوم هذه الطريقة بحفظ جزء منها فقط، وإعادة حسابها عند الحاجة في التمرير الخلفي (Backward pass). يزداد وقت الحساب بنسبة 20٪ تقريبًا، ولكن يمكن تقليل استهلاك الذاكرة بشكل كبير، مما يسمح بتعيين حجم دفعة (Batch size) أكبر، وبالتالي تحسين الإنتاجية الإجمالية.

5.3 Mixed Precision Training (التدريب بالدقة المختلطة) و Bfloat16

لتحقيق أقصى استفادة من Tensor Cores في GPU، نستخدم bfloat16 (Brain Floating Point) للحسابات أثناء التدريب. بالمقارنة مع float16، فإن طول البت للأس هو نفسه في float32، لذلك يكون خطر تجاوز السعة (Overflow) وانخفاض السعة (Underflow) منخفضًا جدًا، مما يجعل التدريب مستقرًا.

6. عملي: كود الضبط الدقيق QLoRA لـ TinyLLaMA

الآن، سنشرح نص PyTorch المخصص لأسرع ضبط، والذي يتضمن جميع التحسينات المذكورة أعلاه. هنا نستخدم SFTTrainer من مكتبة trl (Transformer Reinforcement Learning) الخاصة بـ Hugging Face.

6.1 تجهيز مجموعة البيانات وتحميل النموذج

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import torch
from datasets import load_dataset
from transformers import (
 AutoModelForCausalLM,
 AutoTokenizer,
 BitsAndBytesConfig,
 TrainingArguments
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer

# 1. تحديد النموذج والمرمز (Tokenizer)
model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"

# 2. إعدادات تكميم 4-bit لـ QLoRA
bnb_config = BitsAndBytesConfig(
 load_in_4bit=True,
 bnb_4bit_use_double_quant=True,
 bnb_4bit_quant_type="nf4",
 bnb_4bit_compute_dtype=torch.bfloat16 # إجراء الحسابات باستخدام bfloat16
)

# 3. تحميل النموذج (تفعيل Flash Attention 2)
print("Loading model...")
model = AutoModelForCausalLM.from_pretrained(
 model_id,
 quantization_config=bnb_config,
 device_map="auto",
 use_flash_attention_2=True # مفتاح التسريع
)

# 4. تحميل المرمز (Tokenizer)
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right" # التعيين إلى right لتجنب الأخطاء أثناء التدريب باستخدام fp16/bf16

6.2 تطبيق محول LoRA وتنسيق مجموعة البيانات

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


# 5. التحضير لتدريب k-bit وتفعيل نقاط فحص التدرج
model.gradient_checkpointing_enable()
model = prepare_model_for_kbit_training(model)

# 6. إعدادات LoRA
peft_config = LoraConfig(
 r=16, # الرتبة
 lora_alpha=32, # معامل التحجيم
 lora_dropout=0.05,
 bias="none",
 task_type="CAUSAL_LM",
 target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] # استهداف جميع الطبقات الخطية يحسن الأداء
)

model = get_peft_model(model, peft_config)
model.print_trainable_parameters()
# مثال للمخرجات: trainable params: 14,286,848 || all params: 1,114,335,232 || trainable%: 1.282%

# 7. تحميل مجموعة البيانات (نستخدم هنا مجموعة بيانات Instruction باللغة اليابانية كمثال)
# في الواقع، ستقوم بتحميل ملف JSONL خاص بك من البيئة المحلية
dataset = load_dataset("kunishou/databricks-dolly-15k-ja", split="train")

def format_instruction(sample):
 """
 تنسيق السلسلة لتتناسب مع تنسيق ChatML أو قالب الموجه (Prompt template)
 """
 prompt = f"<|im_start|>user\n{sample['instruction']}"
 if sample.get("input", "") != "":
 prompt += f"\n{sample['input']}"
 prompt += f"<|im_end|>\n<|im_start|>assistant\n{sample['output']}<|im_end|>"
 return {"text": prompt}

dataset = dataset.map(format_instruction)

6.3 تنفيذ التدريب

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


# 8. إعداد وسائط التدريب
training_args = TrainingArguments(
 output_dir="./tinyllama-lora-output",
 per_device_train_batch_size=8, # يمكن زيادته إذا كانت هناك مساحة في VRAM
 gradient_accumulation_steps=2, # حجم الدفعة الفعلي = 8 * 2 = 16
 optim="paged_adamw_32bit", # توفير VRAM باستخدام Paged Optimizer
 save_steps=100,
 logging_steps=10,
 learning_rate=2e-4,
 fp16=False,
 bf16=True, # التدريب بالدقة المختلطة (bfloat16)
 max_grad_norm=0.3,
 max_steps=500, # 500 خطوة للاختبار. في الإنتاج، حدد عدد الحقبات (Epochs)
 warmup_ratio=0.03,
 group_by_length=True,
 lr_scheduler_type="cosine",
)

# 9. بدء التدريب باستخدام SFTTrainer
trainer = SFTTrainer(
 model=model,
 train_dataset=dataset,
 peft_config=peft_config,
 dataset_text_field="text",
 max_seq_length=1024, # تعديل ليناسب طول الإدخال المتوقع
 tokenizer=tokenizer,
 args=training_args,
)

print("Starting training...")
trainer.train()

# 10. حفظ محول LoRA
trainer.model.save_pretrained("./tinyllama-lora-final")
tokenizer.save_pretrained("./tinyllama-lora-final")
print("Training complete and model saved.")

7. تقييم الأداء واستكشاف الأخطاء وإصلاحها

إليك المشكلات الشائعة والحلول الخاصة بها عند تشغيل التدريب في بيئة محلية.

حدوث OOM (Out Of Memory):
- قلل per_device_train_batch_size إلى 1.
- قم بزيادة gradient_accumulation_steps للحفاظ على حجم الدفعة الفعلي.
- قم بتقصير max_seq_length من 2048 إلى 1024 أو 512.
الخسارة (Loss) لا تنخفض أو تتباعد:
- قد يكون معدل التعلم (learning_rate) مرتفعًا جدًا. حاول تقليله من 2e-4 إلى حوالي 5e-5.
- إذا كنت تستخدم Float16 بدلاً من Bfloat16، فقد يحدث انخفاض في سعة التدرجات (Underflow). تحقق من bf16=True.
توليد سلاسل نصية غامضة أثناء الاستنتاج:
- تأكد من تعيين padding_side="right" بشكل صحيح. بالإضافة إلى ذلك، تحقق مما إذا كان تنسيق مجموعة البيانات (مثل الرموز المميزة الخاصة <|im_start|>) متوافقًا مع التنسيق المستخدم أثناء التدريب المسبق للنموذج الأساسي.

8. نشر النموذج بعد الضبط (Deployment)

عند اكتمال الضبط، ما يتم حفظه ليس “النموذج الأساسي بأكمله”، بل فقط “محول LoRA (أوزان الفروق)” الذي يبلغ حجمه بضعة ميغابايت إلى عشرات الميغابايت. لإجراء الاستنتاج بسرعة، يجب دمج (Merge) أوزان LoRA هذه في النموذج الأساسي الأصلي وتصديرها كنموذج واحد.

نص دمج النموذج (Merge script)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


import torch
from peft import AutoPeftModelForCausalLM
from transformers import AutoTokenizer

output_dir = "./tinyllama-lora-final"

# تحميل النموذج والمحول باستخدام FP16/BF16
model = AutoPeftModelForCausalLM.from_pretrained(
 output_dir,
 device_map="auto",
 torch_dtype=torch.bfloat16
)
tokenizer = AutoTokenizer.from_pretrained(output_dir)

# دمج الأوزان وحفظها
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./tinyllama-merged", safe_serialization=True)
tokenizer.save_pretrained("./tinyllama-merged")
print("Model merged and saved successfully!")

تشغيل خادم استنتاج فائق السرعة باستخدام vLLM

عند النشر في بيئة محلية، ولتحقيق أقصى قدر من سرعة الاستنتاج (الرموز في الثانية - Tokens per second)، يوصى بشدة باستخدام vLLM أو TGI (Text Generation Inference) بدلاً من خط الأنابيب القياسي (pipeline) الخاص بـ Hugging Face. يستخدم vLLM تقنية PagedAttention لمنع تجزئة ذاكرة GPU، مما يحسن من قدرة معالجة الطلبات المتزامنة بشكل كبير.

يوضح مخطط Mermaid أدناه مسار العمل (Pipeline) من التدريب إلى نشر خادم الاستنتاج.

graph TD A["بيانات خاصة خام"] --> B["المعالجة المسبقة والتنسيق (JSONL)"] B --> C["الضبط الدقيق QLoRA (باستخدام SFTTrainer)"] C --> D["أوزان محول LoRA (.safetensors)"] D --> E["الدمج مع النموذج الأساسي TinyLLaMA 1.1B"] E --> F["النموذج المدمج"] F --> G["النشر عبر خادم vLLM"] G --> H["نقطة نهاية API / واجهة مستخدم (مثال: روبوت دردشة)"]

يمكن إكمال بدء تشغيل خادم API باستخدام vLLM بأمر واحد فقط:

1
2
3
4
5
6


python -m vllm.entrypoints.openai.api_server \
 --model ./tinyllama-merged \
 --host 0.0.0.0 \
 --port 8000 \
 --max-model-len 2048 \
 --dtype bfloat16

بهذا، يتم بناء نقطة نهاية متوافقة مع OpenAI API في البيئة المحلية، مما يسمح باستخدام الذكاء الاصطناعي المحلي بشكل آمن وسريع.

9. الخلاصة

في هذا المقال، شرحنا كيفية إجراء ضبط دقيق (Fine-tuning) لنموذج “TinyLLaMA”، الذي يتميز بأداء عالٍ على الرغم من خفة وزنه (1.1 مليار معلمة)، بأسرع طريقة وأكثرها كفاءة في استخدام الذاكرة في بيئة محلية (On-premises).

من خلال LoRA / QLoRA، أصبح من الممكن إجراء ضبط لـ LLM بشكل احترافي حتى على وحدات معالجة الرسومات المخصصة للمستهلكين.
من خلال الاستفادة من Flash Attention 2 و Gradient Checkpointing، قمنا بتحسين وقت التدريب واستهلاك VRAM إلى أقصى حد.
من خلال النشر باستخدام vLLM، حققنا إنتاجية عالية حتى في بيئة الإنتاج.

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

دليل تطوير نماذج الذكاء الاصطناعي الصغيرة (مثل TinyLLaMA) باستخدام C++

Fri, 11 Sep 2026 14:00:00 +0900

دليل تطوير نماذج الذكاء الاصطناعي الصغيرة (مثل TinyLLaMA) باستخدام C++

في الآونة الأخيرة، ازداد الاهتمام بشكل سريع بتشغيل النماذج اللغوية الكبيرة (LLM) في البيئات المحلية. على وجه الخصوص، يمكن للنماذج الصغيرة مثل TinyLLaMA (بحجم 1.1 مليار معلمة) إجراء الاستدلال بسرعة عملية حتى على الأجهزة الطرفية ذات الموارد المحدودة أو أجهزة الكمبيوتر المحمولة العادية (بما في ذلك بيئات Windows). بينما يعتبر التطوير باستخدام Python و PyTorch هو السائد، إلا أنه عند السعي لتحقيق الأداء الأمثل وكفاءة الذاكرة، يصبح الجمع بين C++ ومكتبة التنسور “ggml” المعتمدة على لغة C هو المعيار الفعلي.

في هذا المقال، سنشرح خطوات تطوير مفصلة للغاية لبناء محرك استدلال من الصفر (أو فهم البنية الداخلية لـ llama.cpp الحالية بعمق) لتحميل TinyLLaMA وتوليد النصوص باستخدام C++.

1. لماذا C++ و ggml؟

في مرحلة تدريب الذكاء الاصطناعي، تتفوق Python بفضل مرونتها ونظامها البيئي الغني. ومع ذلك، في مرحلة النشر أو “الاستدلال (Inference)"، تصبح C++ خياراً قوياً للأسباب التالية:

تقليل النفقات العامة (Overhead): يمكن القضاء تماماً على قفل المترجم العالمي (GIL) والنفقات العامة لوقت التشغيل في Python.
كفاءة الذاكرة وتخصيص الساحة (Arena Allocation): نظراً لإمكانية التحكم اليدوي في تخصيص وتحرير الذاكرة، يمكن منع الزيادات غير المتوقعة الناتجة عن جمع القمامة (Garbage Collection).
الوصول المباشر إلى الأجهزة: استدعاء الوظائف المضمنة لـ SIMD (Intrinsics) مباشرة مثل AVX-512 و AVX2 و ARM NEON، مما يتيح استغلال قدرات الحوسبة لوحدة المعالجة المركزية إلى أقصى حد.
التخلص من التبعيات: ggml هي مكتبة C/C++ خالية من التبعيات (Zero dependencies)، ويمكن بناؤها بسهولة حتى في بيئة MSVC على Windows بمجرد توفر مترجم.

2. النظرة العامة على البنية

يوضح مخطط Mermaid التالي سير العمل في خط أنابيب الاستدلال بالكامل. إنها سلسلة من العمليات تبدأ من النص المدخل من قبل المستخدم وصولاً إلى توليد الرمز (Token) التالي.

graph TD A["نص إدخال المستخدم"] --> B["BPE Tokenizer"] B --> C["مصفوفة معرفات الرموز (Token IDs)"] C --> D["البحث في طبقة التضمين (Embedding Layer Lookup)"] D --> E["كتل المحول (Transformer Blocks)"] E --> F["RMSNorm"] F --> G["طبقة رأس LM (LM Head Layer)"] G --> H["مصفوفة اللوغاريتمات (Logits)"] H --> I["وحدة أخذ العينات (Sampler)"] I --> J["معرف الرمز التالي (Next Token ID)"] J --> K["Detokenizer"] K --> L["قطعة النص المخرجة"] J -.-> |"إضافة إلى السياق"| C

نظراً لأنه نموذج انحدار ذاتي (Autoregressive)، تتم إضافة الرموز المخرجة مرة أخرى إلى السياق، وتدور كمدخلات لتوقع الرمز التالي (الجزء المتقطع في المخطط).

3. تنسيق النموذج وتخطيط الذاكرة (mmap)

تعد القراءة/الكتابة على القرص واستهلاك الذاكرة العائق الأكبر عند التعامل مع أوزان الشبكات العصبية الضخمة. في تطبيقات C++، يتم حل ذلك باستخدام تخطيط الذاكرة (Memory Mapping - mmap).

3.1 كيفية عمل تخطيط الذاكرة وتطبيقه في Windows

باستخدام mmap، يمكن تعيين محتويات الملف مباشرة إلى مساحة الذاكرة الافتراضية للعملية.

نسخ صفري (Zero-copy): يتم تحميل البيانات مباشرة من القرص إلى ذاكرة التخزين المؤقت للصفحات في النواة (Kernel)، ولا يحدث نسخ إضافي إلى مساحة المستخدم.
التحميل عند الطلب (Page Fault): في اللحظة التي تصل فيها وحدة المعالجة المركزية فعلياً إلى عنوان الذاكرة ذلك، يحدث خطأ في الصفحة (Page Fault)، ويتم تحميل الكتلة المطلوبة فقط (عادة 4 كيلوبايت) في الذاكرة الفعلية.

في بيئة Windows، بدلاً من mmap الخاصة بـ POSIX، يتم استخدام واجهات برمجة تطبيقات Win32 CreateFileMapping و MapViewOfFile.

sequenceDiagram participant OS["نظام التشغيل Windows"] participant RAM["الذاكرة الفعلية (Physical Memory)"] participant App["تطبيق C++"] App->>OS: "CreateFileMapping / MapViewOfFile" OS-->>App: "مؤشر عنوان الذاكرة الافتراضية" App->>App: "قراءة بيانات التنسور عند المؤشر" OS->>RAM: "Page Fault / تحميل الصفحة من القرص" RAM-->>App: "البيانات جاهزة لحسابات SIMD"

3.2 البنية الثنائية لتنسيق GGUF

يعد GGUF (GPT-Generated Unified Format)، المحول من تنسيقات مثل .safetensors الخاصة بـ Hugging Face، التنسيق النهائي للاستدلال. يحتوي على المخطط الثنائي الصارم التالي:

البتات السحرية (Magic Bytes): 0x46554747 (GGUF).
الإصدار (Version): رقم إصدار التنسيق.
عدد التنسورات وعدد البيانات الوصفية (Tensor & Metadata Count): عدد التنسورات وأزواج المفتاح-القيمة للبيانات الوصفية.
البيانات الوصفية (Metadata): مفاتيح ببادئات طول السلسلة وقيم محددة النوع.
معلومات التنسور (Tensor Info): اسم كل تنسور، عدد الأبعاد، نوع البيانات (FP16، Q4_K، إلخ)، وموقع الإزاحة داخل الملف.
الحشو (Padding): حشوات مدرجة لمحاذاة بيانات التنسور مع حدود معينة (عادة 32 بايت أو 64 بايت). هذا ضروري للوصول السريع للذاكرة في تعليمات SIMD (وخاصة AVX).
بيانات التنسور (Tensor Data): مصفوفة بيانات الأوزان الفعلية المحاذاة.

4. الأساس الرياضي لـ TinyLLaMA وخوارزميات C++

يعتمد TinyLLaMA بعض الابتكارات المعمارية المتقدمة لزيادة الكفاءة. سنشرح التمثيلات الرياضية لتنفيذها بشكل صحيح في C++.

4.1 التقييس الجذري لمتوسط المربعات (RMSNorm)

يقلل التكلفة الحسابية عن طريق حذف مركزة المتوسط من LayerNorm وتنفيذ قياس التباين فقط.

$$ \text{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d}\sum_{i=1}^{d} x_i^2 + \epsilon}} \odot \gamma $$

حيث $d$ هو عدد الأبعاد، و $\gamma$ هو تنسور المقياس المُدرَّب. عند التنفيذ بـ C++، نقوم أولاً بحساب مجموع مربعات المصفوفة بسرعة باستخدام _mm256_fmadd_ps في AVX2، وتحسينه عن طريق ضربه بالجذر التربيعي العكسي (مثل تعليمة _mm256_rsqrt_ps).

4.2 التضمين الموضعي الدوار (RoPE)

هي تقنية لتطبيق معلومات موقع الرمز كدوران (Rotate) في مساحة التنسور. يمكن اعتبارها دوراناً على مستوى الأعداد المركبة، ويتم تطبيق الدوران التالي على الأزواج البعدية المتجاورة $(x_1, x_2)$ للمتجه $x$:

$$ \text{RoPE}(x, m) = \begin{pmatrix} x_{1} \cos(m\theta) - x_{2} \sin(m\theta) \\ x_{1} \sin(m\theta) + x_{2} \cos(m\theta) \end{pmatrix} $$

حيث $m$ هو المؤشر الموضعي المطلق للرمز، و $\theta$ هو التردد الأساسي المحسوب مسبقاً. في ggml، يتم تنفيذه بالتوازي ببساطة عن طريق إضافة عامل ggml_rope أثناء بناء رسم الاستدلال البياني.

4.3 الانتباه المجمع للاستعلام (Grouped-Query Attention - GQA)

في الانتباه متعدد الرؤوس (MHA) العادي، يوجد نفس عدد الرؤوس لكل من Query و Key و Value. ومع ذلك، لتقليل استهلاك عرض النطاق الترددي للذاكرة وذاكرة التخزين المؤقت KV بشكل كبير، يعتمد TinyLLaMA Grouped-Query Attention (GQA).

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

في GQA، تشترك عدة رؤوس Query في رأس Key/Value واحد. في تطبيق C++، قبل إجراء ضرب المصفوفات ggml_mul_mat، من الضروري إجراء عملية بث (Broadcast) لتنسورات KV لتتناسب مع عدد Query.

4.4 دالة التنشيط SwiGLU

في طبقة الشبكة المغذية للأمام (FFN)، يتم استخدام SwiGLU بدلاً من GELU.

$$ \text{SwiGLU}(x) = \text{Swish}(x W_{\text{gate}}) \otimes (x W_{\text{up}}) $$ $$ \text{Swish}(z) = z \cdot \sigma(z) = z \cdot \frac{1}{1 + e^{-z}} $$

يتم تمثيله في الرسم البياني الحسابي بدمج عاملي ggml_silu و ggml_mul.

5. بناء الرسم البياني الحسابي وإدارة الذاكرة باستخدام ggml

تعتمد ggml نهج “التحديد والتنفيذ (Define-and-Run)"، حيث تقوم ببناء رسم بياني حسابي ثابت للاستدلال ثم تقييمه (evaluate) لاحقاً.

5.1 ggml_context ومخصص الساحة (Arena Allocator)

الميزة الأكثر تميزاً في ggml هي “تخصيص الساحة”، الذي لا ينفذ أي تخصيص ديناميكي للذاكرة (malloc أو new) داخل حلقة الاستدلال. يتم تخصيص منطقة ذاكرة متصلة ضخمة (الساحة) عند التهيئة، وفي كل مرة يتم فيها استدعاء ggml_new_tensor وغيره، يزداد مؤشر هذه المنطقة. عند اكتمال خطوة استدلال واحدة، يتم فقط إعادة تعيين مؤشر التخصيص إلى الموضع الأولي، وبذلك يكتمل تخصيص الذاكرة لخطوة الاستدلال التالية على الفور.

5.2 مثال عملي لبناء الرسم البياني

في كل خطوة استدلال، يتم تجميع الرسم البياني الحسابي التالي في الذاكرة.

graph TD A["معرف رمز الإدخال (Tokens Input ID)"] --> B["البحث عن التضمين (Embed Lookup)"] B --> C["ggml_rms_norm"] C --> D["إسقاطات Q / K / V"] D --> E["ggml_rope Positional"] E --> F["حفظ في KV Cache"] E --> G["تحميل من KV Cache"] G --> H["الانتباه الذاتي (Self Attention)"] H --> I["المقياس و Softmax"] I --> J["مخرجات الانتباه (Attention Output)"] J --> K["الإسقاط الخارجي (Out Projection)"] K --> L["إضافة المتبقي (Add Residual)"]

6. التكميم (Quantization) وتحسين Windows / SIMD

يتطلب التعامل مع TinyLLaMA (1.1B) بصيغة FP16 حوالي 2.2 جيجابايت من الذاكرة، ولكن باستخدام تكميم 4-بت (مثل Q4_K) يمكن ضغطه بشكل كبير إلى حوالي 600 ميجابايت.

6.1 بنية التكميم الكتلي (Block Quantization)

لا تقوم ggml بتكميم التنسور بأكمله بشكل موحد، بل يتم ذلك على أساس “الكتلة”. في تنسيق Q4_0، يتم تجميع 32 قيمة FP16 في كتلة واحدة.

عامل المقياس (Scale Factor): قيمة واحدة FP16 (2 بايت)
البيانات المكممة: 32 قيمة 4-بت (16 بايت) هذا يقلل من تأثير القيم المتطرفة المحلية.

6.2 تسريع الضرب النقطي باستخدام AVX2

عند البناء لأحدث وحدات المعالجة المركزية x86 في بيئة Windows، مع الاستفادة من علامات المترجم مثل /arch:AVX2، تتم معالجة SIMD عبر التدفق التالي:

التحميل (Load): تحميل بيانات التكميم 4-بت من الذاكرة إلى سجلات AVX بحجم 256 بت.
التوسيع وفك الحزم (Unpack): استخدام أقنعة البت (Bitmasks) وعمليات الإزاحة لتوسيع قيم 4-بت إلى Int8 أو Int16.
إلغاء التكميم (Dequantize): الضرب في عامل المقياس للتحويل إلى فاصلة عائمة.
عمليات FMA: تنفيذ عمليات الضرب والجمع بالتوازي على قيم التنشيط باستخدام _mm256_fmadd_ps (Fused Multiply-Add).

7. تفاصيل تنفيذ ذاكرة التخزين المؤقت KV (KV Cache)

في التوليد التلقائي الانحداري، تعد “ذاكرة التخزين المؤقت KV” لتجاوز حسابات Key و Value للرموز السابقة ميزة أساسية.

فيما يلي النقاط الرئيسية عند تنفيذ ذلك بـ C++:

التخصيص المسبق للتنسور: تهيئة تنسور ضخم لذاكرة التخزين المؤقت KV بحجم الحد الأقصى لطول السياق (مثال: 2048 رمزاً) (يُفضل FP16).
نسخ الإزاحة (Offset Copy): عند الحساب للموضع الرمزي $N$، يتم تخزين متجهات K و V الناتجة في تلك الخطوة في الصف $N$ من تنسور التخزين المؤقت KV باستخدام دوال مثل ggml_cpy.
إنشاء مشهد (View) أثناء الانتباه: عند حساب الانتباه، يتم تمرير “مشهد” يشير فقط إلى أجزاء الرموز من 0 إلى $N$ لضرب المصفوفات.

8. BPE Tokenizer وفك التشفير (Decoding)

تتم معالجة السلسلة المدخلة كتسلسل بايتات UTF-8 وتتم مطابقتها مع مفردات محددة مسبقاً. في C++، لتسريع البحث في المفردات، يتم تنفيذ خوارزميات مثل شجرة البادئة (Trie Tree) أو قوائم الانتظار ذات الأولوية.

من سجلات Logits الناتجة عن LM Head، يتم قياس الاحتمالات باستخدام معلمة درجة الحرارة (Temperature)، ويتم تضييق المرشحين باستخدام استخراج Top-K أو أساليب Top-P (Nucleus Sampling)، ويتم تحديد الرمز التالي النهائي باستخدام أرقام عشوائية.

9. إعداد مشروع C++ (بيئة Windows / PowerShell)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


cmake_minimum_required(VERSION 3.14)
project(TinyLLaMACpp)

set(CMAKE_CXX_STANDARD 17)

# إعدادات التحسين وعلامات AVX2 لـ Windows (MSVC)
if(MSVC)
 add_compile_options(/O2 /arch:AVX2 /fp:fast)
 add_link_options(/STACK:8388608)
else()
 add_compile_options(-O3 -march=native -ffast-math)
endif()

add_library(ggml OBJECT ggml/ggml.c ggml/ggml-alloc.c)
target_compile_definitions(ggml PRIVATE GGML_USE_AVX2 GGML_USE_F16C GGML_USE_FMA)

add_executable(main main.cpp)
target_link_libraries(main ggml)

مثال لأمر البناء في PowerShell:

1
2
3
4


mkdir build
cd build
cmake .. -G "Visual Studio 17 2022" -A x64
cmake --build . --config Release

10. الخلاصة

يعد تنفيذ محرك استدلال لنموذج ذكاء اصطناعي صغير مثل TinyLLaMA من الصفر باستخدام C++ و ggml فرصة رائعة لكشف الصندوق الأسود للتعلم العميق وتعلم جمال التحكم في الأجهزة منخفضة المستوى. باستخدام التحميل بنسخ صفري المعتمد على تخطيط الذاكرة، وتحسينات SIMD، وبناء ذاكرة التخزين المؤقت KV، دعونا نفتح آفاقاً جديدة لمستقبل الذكاء الاصطناعي الطرفي (Edge AI) بينما نستمتع بجوهر برمجة الأنظمة.

【مقدمة في تنفيذ RAG】كيفية جعل الذكاء الاصطناعي المحلي يقرأ مستنداتك

Fri, 11 Sep 2026 13:00:00 +0900

مقدمة

في السنوات الأخيرة، كان التطور في نماذج اللغة الكبيرة (LLM) ملحوظًا، حيث تغلغل العديد من أنظمة الذكاء الاصطناعي مثل ChatGPT و Claude في حياتنا وأعمالنا. ومع ذلك، هناك نقطة ضعف واضحة في نماذج LLM العامة. وهي أنها لا تعرف سوى “المعلومات العامة المتاحة وقت التدريب”. بالطبع، لا يمكنها الإجابة على الأسئلة المتعلقة بـ “المستندات الخاصة” مثل لوائح الشركة، والمذكرات الشخصية، ومواد المشاريع غير المنشورة. إذا حاولت إجبارها على الإجابة، فهناك خطر كبير من أنها ستولد أكاذيب تبدو معقولة ولكنها بعيدة عن الحقيقة (الهلوسة - Hallucination).

لذلك، فإن البنية المعمارية التقنية التي تنتشر حاليًا بشكل هائل في جميع أنحاء العالم هي RAG (Retrieval-Augmented Generation: التوليد المعزز بالاسترجاع). باستخدام RAG، يصبح من الممكن تزويد LLM بالمعرفة الخاصة ديناميكيًا من قاعدة بيانات خارجية، وجعلها تولد إجابات دقيقة وموثوقة بناءً على ذلك.

علاوة على ذلك، عند التعامل مع مجال الشركات أو المعلومات الشخصية السرية، غالبًا ما يكون إرسال البيانات إلى واجهات برمجة التطبيقات (APIs) المستندة إلى السحابة مثل OpenAI غير مسموح به بموجب سياسة الأمان. ما هو مطلوب هنا هو بناء “RAG محلي” مدمج مع الذكاء الاصطناعي المحلي (LLM يعمل بالكامل على جهاز الكمبيوتر الخاص بك أو الخادم المحلي - On-Premise).

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

1. البنية المعمارية العامة لـ RAG

RAG ليس نموذج ذكاء اصطناعي واحد، بل هو بنية نظام تتعاون فيها مكونات متعددة. يتكون بشكل رئيسي من مرحلتين: “مرحلة الاستيعاب (إدخال البيانات)” و “مرحلة الاسترجاع والتوليد (البحث والتوليد)”.

يوضح مخطط Mermaid التالي الصورة العامة لنظام RAG.

graph TD subgraph "مرحلة الاستيعاب (التحضير المسبق)" Doc["مستندات خاصة (PDF, TXT, إلخ.)"] --> Loader["محمل المستندات"] Loader --> Splitter["تقسيم النص (Chunking)"] Splitter --> EmbedModel1["نموذج التضمين (Embedding)"] EmbedModel1 --> VectorDB["قاعدة بيانات المتجهات"] end subgraph "مرحلة الاستدلال (عند استعلام المستخدم)" User["سؤال من المستخدم (استعلام)"] --> EmbedModel2["نموذج التضمين (Embedding)"] EmbedModel2 --> QueryVector["متجه الاستعلام"] QueryVector --> Search["بحث التشابه (بحث المتجهات)"] VectorDB --> Search Search --> Context["استخراج القطع ذات الصلة (السياق)"] User --> PromptBuilder["بناء الموجه (Prompt)"] Context --> PromptBuilder PromptBuilder --> LocalLLM["LLM محلي"] LocalLLM --> Answer["توليد الإجابة النهائية"] end

مرحلة الاستيعاب (التحضير المسبق)

تحميل المستندات: تحميل البيانات غير المهيكلة مثل ملفات PDF، Word، والملفات النصية.
التقسيم (Chunking): تقسيم النصوص الطويلة إلى كتل ذات معنى (Chunks) لتتناسب مع قيود الإدخال في LLM (نافذة السياق) ولتحسين دقة البحث.
التضمين (Embedding / تحويل إلى متجهات): إدخال الكتل المقسمة إلى نموذج التضمين (Embedding Model) وتحويلها إلى مصفوفات من الأرقام (متجهات) ذات مئات إلى آلاف الأبعاد.
الحفظ في قاعدة البيانات: حفظ المتجهات المحولة مرتبطة بالبيانات النصية الأصلية في قاعدة بيانات المتجهات (Vector DB).

مرحلة الاستدلال (أثناء التشغيل)

تحويل الاستعلام إلى متجهات: تحويل سؤال المستخدم إلى متجه باستخدام نفس نموذج التضمين المستخدم في التحضير المسبق.
بحث التشابه: حساب التشابه بين متجه الاستعلام ومتجهات المستندات في قاعدة البيانات، واسترداد أعلى الكتل النصية الأقرب دلاليًا (ذات الصلة العالية).
بناء الموجه (Prompt): دمج النصوص المستردة ذات الصلة كـ “سياق (معرفة خلفية)” مع سؤال المستخدم لإنشاء موجه الإدخال لـ LLM.
توليد الإجابة: يتلقى LLM الموجه الموسع ويولد إجابة بناءً على معلومات السياق المرفقة.

2. الفهم العميق للبحث في المتجهات والتضمين (Embeddings)

جوهر RAG هو “البحث في المتجهات (البحث الدلالي)”. بينما يعتمد بحث الكلمات الرئيسية التقليدي (مثل BM25) على المطابقة التامة للكلمات وتكرارها، يعتمد البحث في المتجهات على “التشابه الدلالي”. على سبيل المثال، حتى الكلمات المختلفة مثل “كلب” و “جرو”، أو “حاسوب” و “كمبيوتر”، ستظهر في نتائج البحث إذا كانت معانيها متقاربة.

ما هو نموذج التضمين (Embedding Model)؟

نموذج التضمين هو شبكة عصبية تأخذ النصوص باللغة الطبيعية كإدخال وتخرج متجهًا كثيفًا ثابت الطول (Dense Vector). النماذج الشائعة (مثل text-embedding-3-small أو النماذج مفتوحة المصدر مثل multilingual-e5-large) تقوم بتعيين النص إلى متجه حقيقي بأبعاد 384 أو 1024.

في هذا الفضاء متعدد الأبعاد (الفضاء الكامن - Latent Space)، يتم تدريب النموذج بحيث تكون المسافة في فضاء الإحداثيات أقرب كلما كانت الجمل متشابهة في المعنى.

الخلفية الرياضية لحساب التشابه: تشابه جيب التمام (Cosine Similarity)

عندما تبحث قاعدة بيانات المتجهات عن المستندات ذات الصلة، فإن مقياس المسافة الأكثر استخدامًا هو تشابه جيب التمام (Cosine Similarity). على عكس المسافة الإقليدية (المسافة المطلقة المكانية)، يركز تشابه جيب التمام على “الزاوية بين متجهين”. نظرًا لأنه أقل تأثرًا بطول الجملة (معيار المتجه)، فهو مناسب جدًا لحساب تشابه النصوص.

يتم التعبير عن تشابه جيب التمام للمتجهين $\mathbf{A}$ و $\mathbf{B}$ رياضياً كالتالي:

$$ \text{Cosine Similarity}(\mathbf{A}, \mathbf{B}) = \cos(\theta) = \frac{\mathbf{A} \cdot \mathbf{B}}{\|\mathbf{A}\| \|\mathbf{B}\|} = \frac{\sum_{i=1}^{n} A_i B_i}{\sqrt{\sum_{i=1}^{n} A_i^2} \sqrt{\sum_{i=1}^{n} B_i^2}} $$

$\mathbf{A} \cdot \mathbf{B}$ يمثل الجداء النقطي (Dot Product).
$\|\mathbf{A}\|$ يمثل معيار L2 (الطول) للمتجه $\mathbf{A}$.
$n$ هو عدد أبعاد المتجه.

يأخذ تشابه جيب التمام قيمًا من -1 إلى 1.

قريب من 1: اتجاه كلا المتجهين هو نفسه تقريبًا (المعنى متشابه جدًا)
قريب من 0: المتجهان متعامدان (غير مرتبطين)
قريب من -1: المتجهان في اتجاهين متعاكسين (المعنى معاكس)

تستخدم قواعد بيانات المتجهات الحديثة (مثل Chroma، FAISS، Qdrant) خوارزمية بحث أقرب جار تقريبي (ANN) تسمى HNSW (Hierarchical Navigable Small World)، والتي تم تحسينها للبحث عن المستندات ذات تشابه جيب التمام العالي من بين ملايين البيانات المتجهة في أجزاء من الثانية.

3. حزمة التقنيات لبناء RAG محلي

لبناء RAG محلي بالكامل لا يعتمد على السحابة، سنستفيد من نظام المصادر المفتوحة. نوصي بحزمة التقنيات التالية:

نموذج اللغة (LLM)
- الأداة: Ollama أو Llama.cpp
- النماذج: نماذج مفتوحة خفيفة وعالية الأداء مثل Llama-3-8B-Instruct، Gemma-2-9B-It، Qwen2-7B-Instruct. للمهام باللغة اليابانية، تعتبر النماذج المضبوطة لليابانية مثل Llama-3-ELYZA-JP-8B مناسبة (يمكن استخدام نماذج تدعم اللغة العربية للمهام العربية).
نموذج التضمين (Embedding)
- النماذج: intfloat/multilingual-e5-large أو BAAI/bge-m3. لتشغيله محليًا، من الشائع تنزيله من Hugging Face وتشغيله باستخدام Sentence-Transformers.
قاعدة بيانات المتجهات (Vector DB)
- ChromaDB: مبني على Python وسهل الإعداد للغاية. مثالي للتطوير المحلي.
- FAISS: مكتبة بحث متجهات سريعة طورتها Meta.
- Qdrant / Milvus: مخصص للبيئات الأكبر وبيئات الإنتاج.
إطار عمل التنسيق (Orchestration Framework)
- LangChain: المعيار الفعلي لربط المكونات (Chain).
- LlamaIndex: إطار عمل للاتصال بالبيانات متخصص بشكل خاص في RAG.

في هذه المرة، سنقوم بالتنفيذ باستخدام المزيج الأسهل في التقديم: LangChain + ChromaDB + Ollama + HuggingFaceEmbeddings.

4. دورة تعليمية للتنفيذ: بناء RAG محلي كامل باستخدام Python

من هنا، سنقوم ببناء RAG محلي من خلال كتابة كود Python فعليًا. مسبقًا، يرجى تثبيت Ollama على جهاز الكمبيوتر الخاص بك وتشغيله في الخلفية. أيضًا، قم بسحب (Pull) النموذج على Ollama (مثال: ollama run llama3).

الخطوة 1: تثبيت المكتبات المطلوبة

1
2


pip install langchain langchain-community langchain-huggingface
pip install chromadb sentence-transformers pypdf

الخطوة 2: الكود البرمجي الكامل للتنفيذ

فيما يلي برنامج نصي كامل بلغة Python لقراءة ملف PDF، وتحويله إلى متجهات، وجعل نموذج LLM المحلي يجيب على الأسئلة.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93


import os
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.llms import Ollama
from langchain_core.prompts import PromptTemplate
from langchain.chains import RetrievalQA

def main():
 # 1. تحميل المستندات
 print("جاري تحميل المستندات...")
 # حدد مسار ملف PDF الذي تريد قراءته
 file_path = "sample_company_policy.pdf"
 loader = PyPDFLoader(file_path)
 documents = loader.load()

 # 2. تقسيم النص (Text Splitting)
 # التقسيم إلى أحجام مناسبة دون تدمير معنى الجمل
 text_splitter = RecursiveCharacterTextSplitter(
 chunk_size=500, # أقصى عدد من الأحرف لكل كتلة
 chunk_overlap=50, # عدد الأحرف المتداخلة بين الكتل (لمنع انقطاع السياق)
 separators=["\n\n", "\n", "。", "、", " ", ""]
 )
 chunks = text_splitter.split_documents(documents)
 print(f"تم التقسيم إلى {len(chunks)} كتلة.")

 # 3. تهيئة نموذج التضمين (Local HuggingFace Model)
 # استخدام نموذج متعدد اللغات
 print("جاري تحميل نموذج التضمين...")
 embeddings = HuggingFaceEmbeddings(
 model_name="intfloat/multilingual-e5-large",
 model_kwargs={'device': 'cpu'} # 'cuda' أو 'mps' إذا كان لديك وحدة معالجة رسومات (GPU)
 )

 # 4. بناء قاعدة بيانات المتجهات (Chroma)
 print("جاري بناء قاعدة بيانات المتجهات...")
 persist_directory = "./chroma_db"
 vectorstore = Chroma.from_documents(
 documents=chunks,
 embedding=embeddings,
 persist_directory=persist_directory
 )
 # إنشاء المسترد (Retriever). إعداد لجلب أفضل 3 مستندات ذات صلة
 retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

 # 5. تهيئة LLM المحلي (Ollama)
 print("جاري الاتصال بـ LLM المحلي...")
 # تأكد من الحصول على النموذج مسبقًا باستخدام شيء مثل 'ollama pull llama3'
 llm = Ollama(model="llama3")

 # 6. تعريف قالب الموجه (Prompt Template)
 prompt_template = """أنت مساعد ممتاز على دراية بلوائح الشركة والمعلومات الداخلية.
يرجى الإجابة على سؤال المستخدم بالتفصيل باستخدام السياق (معلومات الخلفية) التالي فقط.
إذا لم تتمكن من العثور على الإجابة في السياق، فلا تخمن من نفسك وأجب بصدق "لا يمكن المعرفة من المعلومات المقدمة".

【السياق】
{context}

【السؤال】
{question}

【الإجابة】:
"""
 PROMPT = PromptTemplate(
 template=prompt_template,
 input_variables=["context", "question"]
 )

 # 7. بناء سلسلة RAG
 qa_chain = RetrievalQA.from_chain_type(
 llm=llm,
 chain_type="stuff",
 retriever=retriever,
 return_source_documents=True, # إعداد لإرجاع مصدر المعلومات
 chain_type_kwargs={"prompt": PROMPT}
 )

 # 8. تنفيذ السؤال
 query = "يرجى إخباري عن شروط دفع نفقات النقل المتعلقة بالعمل عن بعد."
 print(f"\nالسؤال: {query}\n")

 result = qa_chain.invoke({"query": query})

 print("【الإجابة】")
 print(result['result'])
 print("\n---")
 print("【مصادر المعلومات المرجعية】")
 for doc in result['source_documents']:
 print(f"- صفحة {doc.metadata.get('page', 'غير معروف')}: {doc.page_content[:50]}...")

if __name__ == "__main__":
 main()

شرح نقاط الكود

RecursiveCharacterTextSplitter: وهو المقسم الموصى به بشدة عند تقسيم اللغة الطبيعية. يحاول التقسيم بترتيب الفقرات (\n\n)، الأسطر (\n)، وعلامات الترقيم (。)، بحيث يتناسب مع chunk_size المحدد مع الحفاظ على وحدة المعنى قدر الإمكان. عن طريق تعيين chunk_overlap، فإنه يمنع فقدان المعلومات بسبب انقطاع الحدود السياقية.
HuggingFaceEmbeddings: intfloat/multilingual-e5-large هو نموذج تضمين مفتوح المصدر قوي جدًا يدعم لغات متعددة. يتيح لك تحويل النصوص إلى متجهات على الذاكرة المحلية دون اتصال بالإنترنت، دون استخدام واجهات برمجة التطبيقات السحابية (مثل text-embedding-ada-002 الخاص بـ OpenAI).
ChromaDB: نظرًا لأنه يعمل في الذاكرة (In-memory) أو في التخزين المحلي (مبني على SQLite)، فلا حاجة لإعداد خادم قاعدة بيانات معقد. بتحديد persist_directory، يمكنك تخطي عملية التحويل إلى متجهات عند إعادة التشغيل وقراءة قاعدة البيانات من القرص.

5. تقنيات RAG المتقدمة (Advanced RAG Techniques)

النظام الأساسي (Naive RAG) الذي بنيناه في الدورة التعليمية أعلاه يعمل، ولكن إذا كانت هناك حاجة إلى دقة إجابة عالية في بيئة الإنتاج، فمن الضروري تقديم تقنيات متقدمة مثل ما يلي.

5.1 البحث الهجين (Hybrid Search)

البحث في المتجهات ممتاز في التقاط “المعنى”، ولكنه قد يعاني مع عمليات البحث الدقيقة بالكلمات الرئيسية مثل “أسماء الأعلام الخاصة”، “أرقام طرازات المنتجات”، أو “معرفات الموظفين”. لذلك، من خلال إجراء البحث الدلالي عبر بحث المتجهات والبحث بالكلمات الرئيسية باستخدام خوارزميات مثل BM25 بشكل متوازٍ، ثم تسجيل ودمج نتائج كليهما (باستخدام طرق مثل دمج الترتيب المتبادل؛ Reciprocal Rank Fusion; RRF)، يمكن تقليل حالات الإخفاق في البحث بشكل كبير.

5.2 إعادة الترتيب (Re-ranking)

البحث في المتجهات سريع، ولكنه لا يقيّم بالضرورة الملاءمة السياقية الدقيقة للسياق. خط أنابيب المعالجة (Pipeline) الشائع لتحسين دقة البحث هو كالتالي:

البحث الأولي (First-stage Retrieval): استرجاع حوالي 20 إلى 30 كتلة نصية ذات صلة بشكل واسع وسطحي من قاعدة بيانات المتجهات.
إعادة التقييم (Re-ranking): استخدام نموذج تعلم آلي آخر أثقل يُعرف باسم Cross-Encoder (مثل bge-reranker)، وإدخال زوج من استعلام المستخدم والكتل المستردة لإعادة حساب درجة الملاءمة الدلالية.
الفرز: تمرير أفضل 3 إلى 5 كتل ذات أعلى الدرجات كـسياق نهائي إلى موجه LLM.

من خلال هذه الطريقة، يمكن منع تمرير معلومات الضوضاء غير ذات الصلة إلى LLM، مما يزيد بشكل كبير من دقة الإجابة (Precision).

graph LR Query["استعلام"] --> VSearch["بحث المتجهات (أفضل 20)"] VSearch --> Reranker["نموذج إعادة الترتيب (Cross-Encoder)"] Query --> Reranker Reranker --> TopK["أفضل 3 بدقة عالية"] TopK --> LLM["توليد LLM"]

5.3 التقسيم الدلالي (Semantic Chunking) والبحث في المستند الأصلي

بدلاً من تقسيم النص ميكانيكيًا بعدد ثابت من الأحرف، توجد طريقة تسمى “التقسيم الدلالي” (Semantic Chunking) تكتشف تغيرات المعنى في الجملة باستخدام الذكاء الاصطناعي لتقسيمها. أيضًا، في طريقة تُعرف باسم “البحث في المستند الأصل” (Parent Document Retriever)، يتم تحويل النص إلى متجهات بوحدات صغيرة جدًا (مثل الجمل) لأغراض البحث لتحقيق بحث عالي الدقة، وعند تمريره إلى LLM، يتم تمرير “الفقرة الكبيرة الأصلية (المستند الأصل)” التي تحتوي على تلك الجملة، مما يوفر سياقًا كافيًا لـ LLM.

6. تحديات وحلول عند تشغيل RAG محلي

عند بناء وتشغيل RAG في بيئة محلية، توجد عقبات محددة.

نفاد ذاكرة الفيديو (VRAM): لتشغيل LLM محلي بسرعة عملية (عشرات الرموز في الثانية)، يجب تحميل النموذج في ذاكرة الفيديو (VRAM) الخاصة بوحدة المعالجة الرسومية (GPU). لتشغيل نموذج من فئة 8B بصيغة fp16 (نقطة عائمة 16 بت)، يتطلب الأمر حوالي 16 غيغابايت من VRAM، ولكن باستخدام تقنيات التكميم (Quantization) (تقنيات الضغط إلى 4 بت أو 8 بت مثل صيغ GGUF و AWQ)، من الممكن تشغيلها بسرعة كافية حتى على 8 غيغابايت من VRAM (مثل أجهزة الكمبيوتر المخصصة للألعاب). يدعم كل من Llama.cpp و Ollama تنسيقات التكميم هذه افتراضيًا.
حدود نافذة السياق: إذا كان حجم السياق المسترد كبيرًا جدًا، فقد يتجاوز الحد الأقصى لإدخال LLM (حد الرموز)، أو قد ينسى النموذج الجزء الأوسط من المعلومات (ظاهرة الضياع في المنتصف - Lost in the middle). من الضروري تعديل عدد الكتل المستخرجة والاختيار الدقيق من خلال تقنية إعادة الترتيب المذكورة أعلاه.
إدارة حداثة البيانات: عند تحديث المستندات المصدرية، يجب أيضًا تحديث المتجهات أو حذفها (عمليات CRUD) للمستندات المقابلة في قاعدة بيانات المتجهات. نظرًا لأن ChromaDB يدعم التحديثات بناءً على معرف المستند (Document ID)، فمن العملي إدارة قيم التجزئة (Hash) للملفات وإعداد معالجة مجمعة (Batch Processing) لمزامنة التغييرات فقط.

الخاتمة

RAG (التوليد المعزز بالاسترجاع) هو نموذج قوي يطور الذكاء الاصطناعي من مساعد عام عادي إلى “خبيرك الشخصي” أو “خبير متخصص في الأعمال الداخلية”.

حتى في المتطلبات شديدة السرية حيث لا يمكن استخدام الخدمات السحابية، وجدنا أنه من السهل نسبيًا بناء بيئة “RAG محلي” كاملة من خلال الجمع بين أنظمة المصادر المفتوحة مثل Ollama، LangChain، و ChromaDB.

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

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

【أحدث إصدار لعام 2026】الدليل الشامل لتشغيل النماذج اللغوية الكبيرة (LLM) المحلية على بيئة ويندوز

Fri, 11 Sep 2026 10:00:00 +0900

1. مقدمة: لماذا نماذج LLM المحلية على ويندوز الآن؟

في عام 2026، يشهد تطور الذكاء الاصطناعي التوليدي والنماذج اللغوية الكبيرة (LLM) نقلة نوعية كبرى من خدمات واجهة برمجة التطبيقات (API) الضخمة على السحابة إلى “نماذج LLM المحلية” التي تعمل على أجهزة الكمبيوتر الشخصية والبيئات المحلية (On-Premises). على الرغم من أن نماذج الذكاء الاصطناعي السحابية مثل GPT-5 من OpenAI و Claude 3.5 من Anthropic قوية جدًا، إلا أنه لا يمكن للشركات والأفراد إرسال جميع بياناتهم إلى السحابة. من منظور الخصوصية، والأمان، وزمن الوصول (Latency)، والتكلفة المستدامة طويلة الأجل، فقد زاد الطلب على نماذج LLM المحلية بشكل غير مسبوق وبشكل هائل.

تطور النظام البيئي لنماذج LLM المحلية في بيئة ويندوز (Windows) بشكل خاص كان مذهلًا. حتى سنوات قليلة مضت، كان من المتعارف عليه أن “تطوير وتشغيل الذكاء الاصطناعي يعني Linux”، ولكن في عام 2026، تحول نظام ويندوز إلى منصة ذكاء اصطناعي قوية وسهلة الاستخدام للغاية.

في هذه المقالة، وبناءً على أحدث الاتجاهات التقنية لعام 2026، نقدم دليلاً شاملاً لبناء، وتشغيل، وتحسين نماذج LLM المحلية في بيئة ويندوز. سنقوم بشرح مفصل بحجم هائل يغطي كل شيء بدءًا من الإعداد البسيط للمبتدئين باستخدام Ollama، والتحسين الأقصى للمتقدمين باستخدام llama.cpp، وحتى الفهم العميق للبنية (Architecture) والنهج الرياضي لحساب ذاكرة الوصول العشوائي للفيديو (VRAM)، بالإضافة إلى الضبط الدقيق (Fine-tuning) محليًا.

1.1 الاتجاهات التقنية المحيطة بنماذج LLM المحلية في عام 2026

تتمثل الاتجاهات الرئيسية التي تشكل النظام البيئي الحالي لنماذج LLM المحلية فيما يلي:

الانتشار الكامل لتنسيق GGUF: أصبح تنسيق GGUF (GPT-Generated Unified Format)، الذي يدمج البيانات الوصفية (Metadata) والموترات (Tensors) في ملف واحد، معيارًا أساسيًا (De facto standard) بالكامل. وبفضل هذا، أصبح من الممكن تشغيل النماذج في أي بيئة بمجرد تنزيل ملف واحد من Hugging Face.
إضفاء الطابع الديمقراطي على بنية MoE (مزيج الخبراء): تم إطلاق العديد من نماذج MoE صغيرة الحجم ولكنها عالية الأداء. ومن خلال تنشيط بعض الخبراء فقط أثناء الاستدلال (Inference)، فإنها تحقق أداءً يضاهي النماذج الضخمة مع تقليل العبء الحسابي على أجهزة الكمبيوتر الشخصية الاستهلاكية.
التجريد العالي والتحسين لمحركات الاستدلال: تم تحسين أدوات مثل Ollama، LM Studio، و AnythingLLM، ولم يعد المستخدمون بحاجة إلى القلق بشأن التبعيات المعقدة مثل تثبيت برامج تشغيل CUDA. بالإضافة إلى ذلك، بفضل الدعم الأصلي (Native) لـ FlashAttention 3 على ويندوز، زادت سرعة الاستدلال بشكل كبير.
الاستفادة من وحدات المعالجة العصبية (NPU) وظهور أجهزة كمبيوتر Windows Copilot+: حتى بالنسبة لأجهزة الكمبيوتر المحمولة التي لا تحتوي على وحدة معالجة رسومات (GPU)، فقد دخلت تقنية تشغيل النماذج اللغوية الصغيرة (SLM) باستهلاك منخفض للطاقة باستخدام وحدة المعالجة العصبية (NPU) المدمجة مرحلة الاستخدام العملي.

2. متطلبات الأجهزة (Hardware) وإعداد نظام التشغيل

لكي تعمل نماذج LLM المحلية بسرعة عملية (أكثر من 15 إلى 30 رمزًا مميزًا “Token” في الثانية)، يعد اختيار الأجهزة (Hardware) هو الأمر الأكثر أهمية.

2.1 تكوين الأجهزة الموصى به

مع تطور أجهزة الكمبيوتر الخاصة بالذكاء الاصطناعي (AI PC)، تتغير أيضًا المواصفات المطلوبة.

نظام التشغيل (OS): Windows 11 Pro (إصدار 24H2 أو أحدث). يعد هذا ضروريًا للاستفادة الكاملة من ميزات WSL2، والإدارة المتقدمة للذاكرة، بالإضافة إلى استخدام أحدث واجهات برمجة التطبيقات (API) الخاصة بـ DirectML.
وحدة المعالجة المركزية (CPU): سلسلة Intel Core Ultra 200 أو أحدث، أو سلسلة AMD Ryzen 9000 أو أحدث. عند استخدام استدلال CPU معًا، فإن الاتصال بذاكرة ذات نطاق ترددي عالي يعد أمرًا لا غنى عنه.
ذاكرة الوصول العشوائي (RAM): الحد الأدنى 32 جيجابايت، ويُوصى بـ 64 جيجابايت أو أكثر. يصبح النطاق الترددي للذاكرة الرئيسية (بالجيجابايت/ثانية) هو عنق الزجاجة (Bottleneck) الحاسم أثناء استدلال CPU أو عند تفريغ التحميل (Offloading). يُفضل استخدام ذاكرة عالية السرعة DDR5-6000 أو أعلى.
وحدة معالجة الرسومات (GPU): سلسلة NVIDIA RTX 4000/5000. الأهم في نماذج LLM المحلية ليس أداء الحوسبة بل “سعة ذاكرة الوصول العشوائي للفيديو (VRAM)”.
- فئة البداية (Entry): RTX 4060 Ti (نسخة 16 جيجابايت) - الأفضل من حيث التكلفة والأداء. مثالية لنماذج بحجم 8B إلى 14B.
- الفئة المتوسطة (Mid-range): RTX 4070 Ti SUPER (16 جيجابايت) / RTX 4080 SUPER (16 جيجابايت).
- الفئة المتقدمة (High-end): RTX 4090 (24 جيجابايت) / RTX 5090 (32 جيجابايت) - مطلوبة لتشغيل النماذج المكممة (Quantized models) بحجم 30B إلى 70B.
التخزين (Storage): محرك أقراص PCIe Gen4 أو Gen5 NVMe SSD. يقلل من وقت تحميل النماذج التي تبلغ مساحتها عشرات الجيجابايت بشكل كبير.

2.2 إعداد WSL2 (نظام ويندوز الفرعي لنظام لينكس 2)

تعمل العديد من أدوات واجهة المستخدم الرسومية (GUI) بشكل أصلي (Native) على ويندوز، ولكن WSL2 مفيد جدًا للتطوير باستخدام بايثون (Python)، وتجميع أحدث الأدوات، وإجراء الضبط الدقيق (LoRA Fine-tuning) الذي سيتم شرحه لاحقًا. في أحدث بيئة لـ Windows 11، يمكنك استخدام GPU (CUDA) بشفافية من WSL2 بمجرد تثبيت برنامج تشغيل NVIDIA على النظام المضيف.

افتح PowerShell بصلاحيات المسؤول (Administrator) وقم بتشغيل ما يلي:

1
2
3
4
5


# تثبيت WSL2 وأحدث إصدار من Ubuntu
wsl --install -d Ubuntu-24.04

# تحديث النواة (Kernel)
wsl --update

بعد التثبيت، قم بتشغيل nvidia-smi داخل وحدة تحكم WSL2، وإذا تم التعرف على GPU بشكل صحيح، فقد نجحت العملية.

3. بنية نموذج LLM المحلي وآلية الاستدلال (Inference)

من المفيد جدًا في استكشاف الأخطاء وإصلاحها وتحسين الأداء فهم كيفية قيام النموذج بإنشاء النص في بيئة محلية، وهيكله الداخلي.

يوضح مخطط Mermaid التالي خط أنابيب (Pipeline) الاستدلال النموذجي لـ LLM المحلي.

graph TD User["إدخال المستخدم (الموجه/Prompt)"] --> Tokenizer["أداة الترميز (Tokenizer)"] Tokenizer --> Embedding["طبقة التضمين (Embedding)"] subgraph "كتلة المحول (Transformer Block) (x طبقات)" Embedding --> Attn["الانتباه الذاتي (Self-Attention)"] Attn --> KVCache["ذاكرة التخزين المؤقت KV (الاحتفاظ بالمفتاح/القيمة)"] Attn --> FFN["شبكة التغذية الأمامية (FFN)"] end FFN --> Logits["حساب اللوجيت (Logits)"] Logits --> Sampler["أداة أخذ العينات (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["الرمز المميز المخرج (Output Token)"] OutputToken --> |"التوليد التلقائي الانحداري"| Tokenizer OutputToken --> Decoder["أداة فك الترميز (Detokenizer)"] Decoder --> FinalOutput["النص النهائي المخرج"]

3.1 مرحلتان: التعبئة المسبقة (Prefill) وفك التشفير (Decode)

ينقسم إنشاء النص بواسطة LLM إلى مرحلتين تختلفان في الخصائص الحسابية:

مرحلة التعبئة المسبقة (معالجة الموجه - Prefill): هي المرحلة التي يتم فيها معالجة وفهم موجه الإدخال (Prompt) بأكمله مرة واحدة. نظرًا لإمكانية الحوسبة المتوازية، ترتبط قدرة حساب GPU (FLOPS) بشكل مباشر بالسرعة. إذا كان الموجه طويلاً، فقد تستغرق هذه المرحلة بضع ثوانٍ.
مرحلة فك التشفير (توليد الرموز المميزة - Decode): هي المرحلة التي يتم فيها التنبؤ برمز مميز واحد في كل مرة وتمريره إلى الإدخال التالي (التوليد التلقائي الانحداري - Autoregressive). نظرًا لأن الحوسبة المتوازية مقيدة في هذه المرحلة، فإن عرض النطاق الترددي لـ VRAM في GPU يصبح عنق الزجاجة الحاسم.

4. حساب استهلاك VRAM والفهم الرياضي لحجم النموذج

لتحكم بشكل صحيح على “ما هو النموذج الذي سيعمل على جهاز الكمبيوتر الخاص بي؟"، تحتاج إلى فهم معادلة حساب VRAM. في حالة حدوث تراجع (Fallback) إلى ذاكرة النظام (RAM) بسبب نقص VRAM، ستنخفض سرعة الاستدلال بمقدار 10 إلى 100 مرة.

4.1 VRAM الأساسي بناءً على حجم المعلمة (Parameter)

هو مقدار الذاكرة المطلوب لتحميل أوزان (Weights) النموذج في VRAM. يتم حسابه باستخدام حجم النموذج $P$ (عدد المعلمات، الوحدة: 1 مليار = 1B) وعدد البايتات لكل معلمة $B$.

$$ V_{base} = P \times B \quad \text{(GB)} $$

على سبيل المثال، عند تحميل نموذج بـ 8B (8 مليارات) معلمة بتنسيق FP16 (فاصلة عائمة نصف الدقة، 16 بت = 2 بايت):

$$ V_{base} = 8 \times 2 = 16 \text{ GB} $$

بمعنى آخر، حتى مع وحدة معالجة رسومات تحتوي على 16 جيجابايت من VRAM، ستصل إلى الحد الأقصى تقريبًا بمجرد تحميل النموذج.

4.2 سحر التكميم (Quantization)

وهنا يأتي دور “التكميم”. من خلال تقليل دقة المعلمات، يتم تصغير حجم النموذج بشكل كبير. في حالة التكميم الأكثر شيوعًا 4 بت (مثل: Q4_K_M)، يبلغ المتوسط حوالي 0.55 بايت لكل معلمة.

$$ V_{base\_4bit} = 8 \times 0.55 = 4.4 \text{ GB} $$

وبالتالي، إذا كان لديك 16 جيجابايت من VRAM، فيمكنك بسهولة تشغيل نموذج 8B بوجود مساحة إضافية كافية.

4.3 حساب ذاكرة التخزين المؤقت KV (إصدار يدعم GQA)

أثناء الاستدلال، تستهلك “ذاكرة التخزين المؤقت KV” التي تحتفظ بالسياق الماضي VRAM. في أحدث النماذج مثل Llama 3، يتم استخدام GQA (الانتباه الاستعلامي المجمع - Grouped Query Attention) لتوفير الذاكرة.

يمكن التعبير عن استهلاك ذاكرة التخزين المؤقت KV $V_{kv}$ (بالجيجابايت) بالصيغة الرياضية التالية:

$$ V_{kv} = 2 \times b \times s \times l \times \left( \frac{h_{kv}}{h_q} \right) \times h_q \times d \times B_{kv} \div 10^9 $$

عند التبسيط، يمكن حسابها ببساطة باستخدام عدد رؤوس المفاتيح والقيم $h_{kv}$:

$$ V_{kv} = 2 \times b \times s \times l \times h_{kv} \times d \times B_{kv} \div 10^9 $$

حيث أن:

$b$: حجم الدفعة (عادة 1 للاستخدام الشخصي المحلي)
$s$: طول التسلسل (طول السياق، مثال: 8192)
$l$: عدد الطبقات (مثال: 32)
$h_{kv}$: عدد رؤوس KV (مثال: 8)
$d$: عدد الأبعاد لكل رأس (مثال: 128)
$B_{kv}$: عدد البايتات لذاكرة التخزين المؤقت KV (2 إذا كان FP16)

مثال للحساب (Llama 3 8B، سياق 8192، ذاكرة تخزين مؤقت FP16): $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

يرجى ملاحظة أنه كلما زاد طول السياق $s$، زادت الحاجة إلى VRAM بشكل خطي.

5. الممارسة 1: إعداد أسرع وأقصر باستخدام Ollama

بمجرد فهم النظرية، دعنا نقم بتشغيل LLM فعليًا على بيئة ويندوز. اعتبارًا من عام 2026، فإن الأداة الأكثر سهولة في الاستخدام هي “Ollama”. فهي توفر واجهة سطر أوامر (CLI) بديهية تشبه Docker.

5.1 التثبيت والتشغيل

قم بتنزيل مثبت ويندوز من موقع Ollama الرسمي وقم بتشغيله.
افتح PowerShell وأدخل الأمر التالي. هنا، سنستخدم llama3:8b الذي يدعم اللغة اليابانية.

1

ollama run llama3:8b

في أول تشغيل، سيتم تنزيل النموذج. بمجرد الانتهاء، يمكنك التفاعل معه مباشرة في الجهاز الطرفي (Terminal).

5.2 إنشاء ذكاء اصطناعي مخصص باستخدام Modelfile

يمكنك بسهولة إنشاء ذكاء اصطناعي بشخصية (Persona) محددة. قم بإنشاء Modelfile في أي مكان تريده.

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
أنت مهندس برمجيات أول ممتاز جدًا.
يرجى الإجابة على أسئلة المستخدم بشكل منطقي وموجز، مع تقديم أمثلة التعليمات البرمجية دائمًا.
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

قم ببناء النموذج المخصص الخاص بك وتشغيله بالأوامر التالية:

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 الاستخدام من التطبيقات الخارجية (محرر الذكاء الاصطناعي)

تكشف Ollama عن نقطة نهاية API متوافقة مع OpenAI على http://localhost:11434. من خلال تحديد عنوان URL هذا في إعدادات الخلفية (Backend) لإضافات VS Code مثل Cursor و Continue.dev، وتحديد اسم النموذج كـ SeniorDev أو ما شابه، ستحصل على مساعد تشفير (Coding) محلي قوي ومجاني.

6. الممارسة 2: ضبط الأداء الأقصى باستخدام llama.cpp

إذا كنت ترغب في إجراء إدارة دقيقة للذاكرة أو تجربة أحدث التنسيقات (مثل EXL2 وتكميم IQ) بسرعة، فسوف تتفاعل مباشرة مع المحرك الأساسي llama.cpp.

6.1 خطوات بناء llama.cpp

في بيئة ويندوز، من الأفضل بناءه من المصدر باستخدام CUDA Toolkit و CMake.

1
2
3
4
5
6
7
8


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build

# التهيئة والتجميع ليكون متوافقًا مع CUDA
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 التشغيل المتقدم في وضع الخادم

استخدم llama-server.exe الذي تم بناؤه لاستضافة النموذج.

1
2
3
4
5
6
7


.\bin\Release\llama-server.exe `
 --model "C:\models\Llama-3-8B-Instruct.Q4_K_M.gguf" `
 --ctx-size 8192 `
 --n-gpu-layers 99 `
 --threads 8 `
 --flash-attn `
 --port 8080

--n-gpu-layers 99: نقل كل الطبقات الممكنة إلى VRAM الخاص بـ GPU.
--flash-attn: تمكين FlashAttention 3 لتحسين سرعة الاستدلال وتقليل استهلاك VRAM لذاكرة التخزين المؤقت KV.

7. واجهة المستخدم الرسومية (GUI): بناء LM Studio و RAG المحلي

إذا كنت لا تفضل استخدام سطر الأوامر، أو إذا كنت ترغب في إجراء التوليد المعزز بالاسترجاع (RAG) بشكل بديهي، فاستخدم واجهة مستخدم رسومية (GUI).

7.1 LM Studio

يعد LM Studio تطبيقًا رائعًا يجمع بين البحث عن النماذج، والتنزيل، والتحقق المسبق من متطلبات النظام، وواجهة مستخدم (UI) للدردشة في مكان واحد. بضغطة زر “Local Server” داخل التطبيق، سيتم تشغيل واجهة برمجة تطبيقات (API) متوافقة مع OpenAI.

7.2 بنية RAG باستخدام AnythingLLM

هذا هو المخطط المعماري لبيئة RAG التي تسمح بقراءة المستندات الداخلية للشركة والمذكرات الشخصية.

graph LR Document["المستند (PDF, MD)"] --> Chunking["تقسيم إلى كتل (Chunking)"] Chunking --> EmbedModel["نموذج التضمين (Embedding Model)"] EmbedModel --> VectorDB["قاعدة بيانات المتجهات (Vector Database)"] UserQuery["سؤال المستخدم"] --> EmbedQuery["تضمين السؤال"] EmbedQuery --> VectorDB VectorDB --> |"بحث عن التشابه"| RetrievedDocs["استخراج المستندات ذات الصلة"] UserQuery --> PromptBuilder["توليد الموجه (Prompt)"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["نموذج LLM محلي"] LocalLLM --> Answer["الإجابة النهائية"]

باستخدام إصدار سطح المكتب من AnythingLLM (لويندوز)، يمكنك تحديد Ollama (لـ LLM والتضمين) من شاشة الإعدادات، وإعداده لاستخدام VectorDB محلي (LanceDB)، وستكتمل هذه البنية في غضون بضع دقائق. هذه هي ولادة الذكاء الاصطناعي الخاص الذي لا يرسل البيانات إلى الخارج على الإطلاق.

8. الضبط الدقيق (LoRA) على Windows WSL2

لا يقتصر الأمر على التشغيل المحلي فحسب، بل إذا كنت ترغب في جعل النموذج أكثر ذكاءً باستخدام بياناتك الخاصة، فيمكنك إجراء الضبط الدقيق (Fine-tuning) باستخدام LoRA (التكيف منخفض الرتبة - Low-Rank Adaptation). اعتبارًا من عام 2026، وبفضل مكتبة تسمى “Unsloth”، يمكنك إكمال تدريب نموذج 8B في بضع ساعات حتى مع 16 جيجابايت من VRAM في بيئة Windows WSL2.

قم بتشغيل الأوامر التالية داخل Ubuntu في WSL2 لإعداد البيئة:

1
2
3
4


conda create --name unsloth_env python=3.11
conda activate unsloth_env
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

تعمل Unsloth على تحسين أنوية CUDA (CUDA kernels) إلى أقصى حد، وبالمقارنة مع مكتبة Hugging Face القياسية، فإن سرعة التدريب تزيد بحوالي الضعف، وينخفض استهلاك VRAM إلى النصف تقريبًا. بمجرد فتح Jupyter Notebook وتحميل مجموعة البيانات (بتنسيق JSONL)، يمكن إجراء التدريب لعدة عصور (Epochs) باستخدام أجهزة مثل RTX 4060 Ti مع 12 جيجابايت إلى 16 جيجابايت من VRAM.

9. استكشاف أخطاء الأداء وإصلاحها

فيما يلي المشكلات الشائعة والحلول الخاصة بها.

1. سرعة الاستدلال بطيئة للغاية (1 إلى 2 رمز / ثانية)

السبب: النموذج لا يتناسب مع VRAM وتم تحميله على ذاكرة النظام (RAM). الحل: تحقق من “ذاكرة GPU المخصصة” في إدارة المهام. إذا وصلت إلى الحد الأقصى، فقم بتقليل حجم السياق (-c)، أو استخدم نموذج تكميم بعدد بتات أقل (مثل Q4_K_M).

2. خطأ “CUDA out of memory”

السبب: تم استنفاد VRAM بالكامل. يحدث هذا بشكل خاص عندما تطول المحادثة وتتضخم ذاكرة التخزين المؤقت KV. الحل: قم بتقييد قيمة num_ctx بشكل مقصود في حالة Ollama، أو قيمة -c في حالة llama.cpp.

3. توليد اللغة (مثل اليابانية أو العربية) غريب

السبب: عدم تطابق قالب الموجه (Prompt template)، أو النموذج غير مدعوم. الحل: استخدم نموذجًا يحتوي اسمه على Instruct، وتأكد من تحديد القالب الصحيح (مثل تنسيق ChatML أو Llama3) الذي حدده منشئ النموذج في الأداة.

10. الخلاصة والآفاق المستقبلية

في عام 2026، لم يعد بناء نماذج LLM المحلية في بيئة ويندوز حكرًا على عدد قليل من المهندسين فقط. بفضل تحول تنسيق GGUF إلى معيار أساسي، وظهور أنظمة بيئية محسّنة مثل Ollama و LM Studio، والتحسينات على مستوى الأجهزة (Hardware) مثل FlashAttention، يمكن لأي شخص الآن بسهولة الحصول على بيئة ذكاء اصطناعي بمستوى الشركات (Enterprise-grade).

يرجى الاستفادة من النقاط التالية المشروحة في هذا المقال:

استخدم الحساب الرياضي لـ VRAM لاختيار حجم النموذج ومستوى التكميم المناسبين لمنطق مواصفات جهاز الكمبيوتر الخاص بك.
استخدم Ollama لإعداد بيئة بأسرع وقت، وربطها مع محرر الذكاء الاصطناعي لتحسين الإنتاجية بشكل كبير.
استخدم التحكم المتقدم في المعلمات من خلال llama.cpp لاستخراج أقصى أداء ممكن للأجهزة.
قم ببناء نظام RAG محلي آمن للتعامل مع البيانات السرية باستخدام AnythingLLM.
استفد من Unsloth (WSL2) لتطوير وتدريب ذكاء اصطناعي مخصص يمتلك معرفتك المتخصصة الخاصة.

لم يعد مصطلح “إضفاء الطابع الديمقراطي” على الذكاء الاصطناعي مجرد كلمة طنانة (Buzzword)، بل أصبح نظامًا واقعيًا يعمل على سطح مكتب ويندوز الخاص بك. تحرر من تكاليف استخدام واجهات برمجة التطبيقات السحابية وخطر تسرب المعلومات، وادخل الآن إلى عالم الذكاء الاصطناعي الخاص القوي والحر.