3 وكلاء. 3 نماذج لغوية كبيرة. 1 معالج رسومات قديم: هندسة الاستدلال المتوازي على المعدن العاري

3 وكلاء. 3 نماذج لغوية كبيرة. بطاقة رسوميات واحدة قديمة: هندسة الاستدلال المتوازي على المعدن العاري

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

لماذا الاستدلال المتوازي مهم؟

تعتمد سير عمل الذكاء الاصطناعي الحديث بشكل متزايد على وكلاء متعددين يعملون بتناغم - واحد للاستدلال، وآخر للاسترجاع، وثالث للتوليد الإبداعي. تشغيلهم بالتسلسل على بطاقة رسوميات واحدة يهدر الوقت والذاكرة. الاستدلال المتوازي، حيث يقوم كل وكيل ببث الرموز بشكل متزامن، يمكن أن يقلل زمن الوصول ويحسن الإنتاجية. ولكن على بطاقة رسوميات قديمة (فكر في GTX 1080 Ti أو RTX 2060)، يجب عليك إدارة الذاكرة وأحجام النماذج والجدولة بعناية.

كما لوحظ في المناقشات الصناعية الأخيرة، بما في ذلك تغطية من OpenAI News ومدونة Microsoft AI Blog، فإن الاتجاه نحو نماذج أصغر ومتخصصة يجعل هذا ممكنًا. كما أبرزت Anthropic News أن الاستدلال الفعال هو مفتاح إضفاء الطابع الديمقراطي على الذكاء الاصطناعي. يضع هذا الدليل تلك الأفكار موضع التنفيذ.

المتطلبات

قبل أن نبدأ، دعنا نحدد الأساسيات من حيث الأجهزة والبرامج.

الأجهزة

• **بطاقة الرسوميات**: NVIDIA GTX 1080 Ti (11 جيجابايت VRAM) أو ما شابه ذلك. أي شيء بذاكرة VRAM 8+ جيجابايت يعمل.
• **المعالج**: أي معالج حديث بـ 4 أنوية أو أكثر.
• **الذاكرة العشوائية**: 32 جيجابايت ذاكرة نظام (16 جيجابايت كحد أدنى).
• **التخزين**: 50 جيجابايت مساحة خالية للنماذج والكود.

البرامج

• **نظام التشغيل**: Ubuntu 22.04 LTS (أو أي لينكس مع تعريفات NVIDIA).
• **تعريف NVIDIA**: الإصدار 525 أو أحدث.
• **CUDA Toolkit**: 12.1 (متوافق مع تعريفك).
• **Python**: 3.10 أو 3.11.

النماذج

سنستخدم ثلاثة نماذج لغوية كبيرة صغيرة ولكنها قادرة: 1. **الوكيل 1**: `microsoft/phi-3-mini-4k-instruct` (3.8 مليار معامل، ~2.2 جيجابايت بدقة 4 بت) 2. **الوكيل 2**: `TinyLlama/TinyLlama-1.1B-Chat-v1.0` (1.1 مليار معامل، ~0.7 جيجابايت) 3. **الوكيل 3**: `google/gemma-2-2b-it` (2 مليار معامل، ~1.2 جيجابايت بدقة 4 بت)

إجمالي استخدام VRAM: ~4 جيجابايت، مما يترك مساحة لذاكرة التخزين المؤقت KV والتنفيذ المتزامن.

التركيب خطوة بخطوة

سنقوم بإعداد بيئة معدنية عارية بأقل قدر من الحمل الإضافي. لا Docker، ولا سحابة - مجرد استدلال خام.

1. تثبيت تبعيات النظام

أولاً، قم بتحديث نظامك وتثبيت الأدوات الأساسية.

sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential git curl wget python3-pip python3-venv

2. تثبيت تعريفات NVIDIA و CUDA

إذا لم يكن لديك تعريف NVIDIA مثبتًا، فقم بذلك الآن.

# تحقق من بطاقة الرسوميات وإصدار التعريف
nvidia-smi
# إذا لم يكن مثبتًا، استخدم مثبت تعريف أوبونتو
sudo ubuntu-drivers autoinstall
sudo reboot

بعد إعادة التشغيل، قم بتثبيت CUDA 12.1 (قم بالتنزيل من NVIDIA). إليك تثبيت بسيط:

wget https://developer.download.nvidia.com/compute/cuda/12.1.0/local_installers/cuda_12.1.0_530.30.02_linux.run
sudo sh cuda_12.1.0_530.30.02_linux.run --silent --toolkit

أضف CUDA إلى PATH الخاص بك:

echo 'export PATH=/usr/local/cuda-12.1/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.1/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

3. إعداد بيئة Python

أنشئ بيئة افتراضية لعزل التبعيات.

python3 -m venv llm_agents_env
source llm_agents_env/bin/activate

4. تثبيت مكتبات الاستدلال

سنستخدم `transformers` مع `bitsandbytes` للقياس بدقة 4 بت، و `vllm` للجدولة المتوازية الفعالة.

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install transformers accelerate bitsandbytes
pip install vllm

`vllm` هو المفتاح: فهو يدعم التجميع المستمر، مما يعني أنه يمكن معالجة طلبات متعددة في وقت واحد على بطاقة رسوميات واحدة.

5. تنزيل النماذج

سنقوم بتخزين النماذج الثلاثة محليًا.

# إنشاء مجلد للنماذج
mkdir -p ~/models

# تنزيل كل نموذج باستخدام سطر Python واحد
python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('microsoft/phi-3-mini-4k-instruct', device_map='auto', load_in_4bit=True); \
tokenizer = AutoTokenizer.from_pretrained('microsoft/phi-3-mini-4k-instruct'); \
model.save_pretrained('~/models/phi-3-mini'); \
tokenizer.save_pretrained('~/models/phi-3-mini')"

python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0', device_map='auto', load_in_8bit=True); \
tokenizer = AutoTokenizer.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0'); \
model.save_pretrained('~/models/tinyllama'); \
tokenizer.save_pretrained('~/models/tinyllama')"

python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b-it', device_map='auto', load_in_4bit=True); \
tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b-it'); \
model.save_pretrained('~/models/gemma-2-2b'); \
tokenizer.save_pretrained('~/models/gemma-2-2b')"

قد يستغرق هذا من 10 إلى 20 دقيقة حسب سرعة اتصالك بالإنترنت.

هندسة الاستدلال المتوازي

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

البنية

نستخدم خادم API غير المتزامن من `vllm`. كل وكيل هو عميل منفصل يرسل المطالبات بشكل متزامن. يقوم الخادم بتجميعها بذكاء.

ملف التكوين

أنشئ `config.json` في جذر مشروعك:

{
  "models": [
    {
      "name": "phi-3-mini",
      "model_path": "~/models/phi-3-mini",
      "port": 8001,
      "max_num_seqs": 4,
      "gpu_memory_utilization": 0.3
    },
    {
      "name": "tinyllama",
      "model_path": "~/models/tinyllama",
      "port": 8002,
      "max_num_seqs": 6,
      "gpu_memory_utilization": 0.2
    },
    {
      "name": "gemma-2-2b",
      "model_path": "~/models/gemma-2-2b",
      "port": 8003,
      "max_num_seqs": 4,
      "gpu_memory_utilization": 0.3
    }
  ]
}

ملاحظة: مجموع كسور `gpu_memory_utilization` هو 0.8، مما يترك 0.2 للنفقات العامة.

تشغيل الخادم

أنشئ `start_agents.sh`:

#!/bin/bash
source llm_agents_env/bin/activate

# تشغيل خادم vllm لكل نموذج في الخلفية
python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/phi-3-mini \
    --port 8001 \
    --max-num-seqs 4 \
    --gpu-memory-utilization 0.3 \
    --trust-remote-code &

python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/tinyllama \
    --port 8002 \
    --max-num-seqs 6 \
    --gpu-memory-utilization 0.2 \
    --trust-remote-code &

python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/gemma-2-2b \
    --port 8003 \
    --max-num-seqs 4 \
    --gpu-memory-utilization 0.3 \
    --trust-remote-code &

# انتظار جميع عمليات الخلفية
wait

اجعله قابلاً للتنفيذ وقم بتشغيله:

chmod +x start_agents.sh
./start_agents.sh

يستمع كل خادم على منفذ مختلف. يتشاركون نفس بطاقة الرسوميات عبر إدارة الذاكرة من `vllm`.

كود العميل للطلبات المتوازية

الآن أنشئ `run_agents.py` لإرسال المطالبات إلى الوكلاء الثلاثة في وقت واحد:

import asyncio
import aiohttp
import time

async def query_agent(session, url, prompt, agent_name):
    payload = {
        "model": agent_name,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 200,
        "temperature": 0.7
    }
    start_time = time.time()
    async with session.post(url, json=payload) as resp:
        result = await resp.json()
        elapsed = time.time() - start_time
        content = result["choices"][0]["message"]["content"]
        print(f"[{agent_name}] الوقت: {elapsed:.2f}ث")
        print(f"[{agent_name}] الرد: {content[:100]}...")
        return content

async def main():
    prompts = {
        "phi-3-mini": "اشرح الحوسبة الكمومية بعبارات بسيطة.",
        "tinyllama": "اكتب هايكو عن قطة.",
        "gemma-2-2b": "ما هي عاصمة فرنسا؟ اشرح بإيجاز."
    }
    
    urls = {
        "phi-3-mini": "http://localhost:8001/v1/chat/completions",
        "tinyllama": "http://localhost:8002/v1/chat/completions",
        "gemma-2-2b": "http://localhost:8003/v1/chat/completions"
    }
    
    async with aiohttp.ClientSession() as session:
        tasks = []
        for agent_name, prompt in prompts.items():
            task = query_agent(session, urls[agent_name], prompt, agent_name)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks)
        print("\n=== جميع الوكلاء اكتملوا ===")
        return results

if __name__ == "__main__":
    asyncio.run(main())

قم بتشغيله:

python3 run_agents.py

يجب أن ترى جميع الردود الثلاثة مطبوعة، مع أوقات متداخلة - دليل على الاستدلال المتوازي.

أمثلة الاستخدام

مثال 1: الاستدلال متعدد الوكلاء

اجمع بين الوكلاء لمهمة سلسلة الأفكار. على سبيل المثال، الوكيل 1 يولد خطة، الوكيل 2 يسترجع الحقائق، الوكيل 3 يصنع الإجابة.

قم بتعديل `run_agents.py` لتمرير المخرجات بشكل تسلسلي ولكن مع تحميل النموذج بالتوازي:

# بعد الحصول على خطة phi-3-mini، مررها إلى tinyllama للحصول على الحقائق
plan = results[0]
fact_prompt = f"بناءً على هذه الخطة: {plan}، اذكر الحقائق الرئيسية."
# ... استمر في التوجيه

مثال 2: اختبار الحمل

أرسل 10 طلبات متزامنة لكل وكيل لاختبار ضغط بطاقة الرسوميات الخاصة بك:

async def stress_test(agent_name, url, num_requests=10):
    async with aiohttp.ClientSession() as session:
        tasks = [query_agent(session, url, "مرحبًا، من أنت؟", agent_name) 
                 for _ in range(num_requests)]
        await asyncio.gather(*tasks)

على GTX 1080 Ti، سترى إنتاجية تتراوح بين 5-10 رموز/ثانية لكل وكيل، حسب حجم النموذج.

مثال 3: مراقبة استخدام بطاقة الرسوميات

أثناء التشغيل، راقب VRAM في طرفية أخرى:

watch -n 1 nvidia-smi

سترى استخدام VRAM يتأرجح حول 8-9 جيجابايت، مع تحميل النماذج الثلاثة.

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

أخطاء نفاد الذاكرة

إذا كانت VRAM غير كافية، قلل `gpu_memory_utilization` في التكوين أو استخدم نماذج أصغر (على سبيل المثال، استبدل phi-3 بنموذج 1B).

أخطاء CUDA

تأكد من تطابق تعريفك مع CUDA 12.1. قم بتشغيل:

nvidia-smi | grep "CUDA Version"

استدلال بطيء

على بطاقة رسوميات قديمة، توقع 2-5 رموز/ثانية لكل وكيل. هذا طبيعي. قم بالتحسين عن طريق تقليل `max_tokens` أو استخدام القياس بدقة 4 بت.

الخاتمة

تشغيل ثلاثة وكلاء نموذج لغوي كبير على بطاقة رسوميات واحدة قديمة ليس ممكنًا فحسب - بل إنه عملي. مع اختيار دقيق للنموذج (نماذج صغيرة، قياس 4 بت)، وجدولة قادرة مثل `vllm`، وتكوين معدني عاري، يمكنك تحقيق استدلال متوازي دون موارد سحابية. هذا الإعداد مثالي للهواة والباحثين أو أي شخص يريد تجربة أنظمة متعددة الوكلاء بميزانية محدودة.

كما أكدت مصادر مثل مدونة Microsoft AI Blog و Anthropic News، فإن مستقبل الذكاء الاصطناعي يكمن في الاستدلال الفعال على الجهاز. من خلال الهندسة وفقًا للقيود، تطلق العنان لقوة وكلاء متعددين دون إنفاق الكثير. الآن اذهب وابنِ شيئًا باستخدام وكلائك الثلاثة وبطاقة الرسوميات المتعبة.