استراتيجيات توجيه النماذج

التوجيه الفعال للنماذج يحسّن التكلفة وزمن الاستجابة والجودة من خلال اختيار أفضل نموذج لكل طلب ديناميكياً. يغطي هذا الدرس أنماط التوجيه لنشر LLM الإنتاجي.

عوامل قرار التوجيه

┌─────────────────────────────────────────────────────────────┐
│                   مصفوفة قرار التوجيه                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  خصائص الطلب               معايير اختيار النموذج           │
│  ─────────────────          ─────────────────────────       │
│  • تعقيد المهمة            • التكلفة لكل رمز               │
│  • الجودة المطلوبة         • زمن الاستجابة (TTFT، التوليد) │
│  • طول السياق              • حجم نافذة السياق              │
│  • فئة المستخدم            • حدود المعدل المتاحة           │
│  • الميزانية المتبقية       • التوفر الحالي                 │
│                                                             │
│              ┌─────────────────────┐                        │
│              │   محرك قرار        │                        │
│              │    التوجيه         │                        │
│              └──────────┬──────────┘                        │
│                         │                                   │
│         ┌───────────────┼───────────────┐                   │
│         ▼               ▼               ▼                   │
│     GPT-4o         Claude Sonnet    Llama 70B               │
│   (متميز)          (متوازن)        (محسن التكلفة)           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

الاستراتيجية 1: التوجيه القائم على التعقيد

التوجيه بناءً على تحليل تعقيد المهمة:

from litellm import completion
import re

def analyze_complexity(prompt: str) -> str:
    """تقدير تعقيد المهمة من المطالبة."""
    indicators = {
        "high": ["analyze", "compare", "evaluate", "synthesize", "create"],
        "medium": ["explain", "describe", "summarize", "list"],
        "low": ["what is", "define", "translate", "format"]
    }

    prompt_lower = prompt.lower()

    for level, keywords in indicators.items():
        if any(kw in prompt_lower for kw in keywords):
            return level

    # الافتراضي بناءً على الطول
    if len(prompt) > 2000:
        return "high"
    elif len(prompt) > 500:
        return "medium"
    return "low"

def route_by_complexity(prompt: str, messages: list) -> str:
    """اختيار النموذج بناءً على التعقيد."""
    complexity = analyze_complexity(prompt)

    model_map = {
        "high": "gpt-4o",           # $5/1M رمز
        "medium": "claude-sonnet",   # $3/1M رمز
        "low": "gpt-4o-mini"         # $0.15/1M رمز
    }

    return model_map[complexity]

# الاستخدام
prompt = "قارن السياسات الاقتصادية لثلاث دول"
model = route_by_complexity(prompt, [])
response = completion(model=model, messages=[{"role": "user", "content": prompt}])

الاستراتيجية 2: التوجيه الدلالي

استخدام التضمينات لتصنيف الطلبات:

from litellm import embedding, completion
import numpy as np

# تضمينات المسار المحسوبة مسبقاً
ROUTES = {
    "code_generation": {
        "examples": ["اكتب وظيفة Python", "أنشئ REST API"],
        "model": "gpt-4o",  # الأفضل للكود
    },
    "creative_writing": {
        "examples": ["اكتب قصة", "ألّف قصيدة"],
        "model": "claude-sonnet",  # الأفضل للإبداع
    },
    "factual_qa": {
        "examples": ["ما عاصمة فرنسا؟", "متى ولد أينشتاين؟"],
        "model": "gpt-4o-mini",  # فعال التكلفة للأسئلة البسيطة
    }
}

def semantic_route(query: str, route_embeddings: dict) -> str:
    """التوجيه بناءً على التشابه الدلالي."""
    query_embedding = embedding(
        model="text-embedding-3-small",
        input=query
    ).data[0].embedding

    best_route = None
    best_similarity = -1

    for route, route_emb in route_embeddings.items():
        similarity = np.dot(query_embedding, route_emb)
        if similarity > best_similarity:
            best_similarity = similarity
            best_route = route

    return ROUTES[best_route]["model"]

الاستراتيجية 3: سلاسل الاحتياطي

التعامل مع الفشل بسلاسة مع الاحتياطيات:

from litellm import completion
from litellm.exceptions import RateLimitError, ServiceUnavailableError

FALLBACK_CHAIN = [
    {"model": "gpt-4o", "timeout": 30},
    {"model": "azure/gpt-4o", "timeout": 30},
    {"model": "claude-sonnet-4-20250514", "timeout": 30},
    {"model": "gpt-4o-mini", "timeout": 60},  # الملاذ الأخير
]

async def completion_with_fallback(messages: list) -> dict:
    """جرب النماذج بالتسلسل حتى النجاح."""
    last_error = None

    for config in FALLBACK_CHAIN:
        try:
            response = await acompletion(
                model=config["model"],
                messages=messages,
                timeout=config["timeout"]
            )
            return {
                "response": response,
                "model_used": config["model"],
                "fallback_count": FALLBACK_CHAIN.index(config)
            }
        except (RateLimitError, ServiceUnavailableError) as e:
            last_error = e
            continue

    raise last_error

الاستراتيجية 4: موجّه اختبار A/B

مقارنة أداء النموذج في الإنتاج:

import random
from dataclasses import dataclass
from typing import Optional

@dataclass
class ABConfig:
    control_model: str
    treatment_model: str
    treatment_percentage: float

class ABRouter:
    def __init__(self, config: ABConfig):
        self.config = config
        self.results = {"control": [], "treatment": []}

    def route(self, user_id: str) -> tuple[str, str]:
        """توجيه حتمي بناءً على user_id."""
        # تعيين ثابت لكل مستخدم
        bucket = hash(user_id) % 100

        if bucket < self.config.treatment_percentage * 100:
            return self.config.treatment_model, "treatment"
        return self.config.control_model, "control"

# الاستخدام
ab_router = ABRouter(ABConfig(
    control_model="gpt-4o",
    treatment_model="claude-sonnet-4-20250514",
    treatment_percentage=0.2  # 20% للعلاج
))

model, variant = ab_router.route(user_id="user-123")

الاستراتيجية 5: التوجيه المحسن للتكلفة

البقاء ضمن الميزانية مع الحفاظ على الجودة:

from dataclasses import dataclass

@dataclass
class ModelCost:
    model: str
    input_cost_per_1m: float
    output_cost_per_1m: float
    quality_score: float  # 0-1

MODELS = [
    ModelCost("gpt-4o", 5.0, 15.0, 0.95),
    ModelCost("claude-sonnet", 3.0, 15.0, 0.92),
    ModelCost("gpt-4o-mini", 0.15, 0.6, 0.80),
    ModelCost("llama-3.1-70b", 0.9, 0.9, 0.85),
]

class BudgetRouter:
    def __init__(self, daily_budget: float, min_quality: float = 0.8):
        self.daily_budget = daily_budget
        self.min_quality = min_quality
        self.spent_today = 0.0

    def route(self, estimated_tokens: int) -> str:
        """اختيار أرخص نموذج يلبي عتبة الجودة."""
        remaining = self.daily_budget - self.spent_today

        # التصفية بالجودة والفرز بالتكلفة
        candidates = [
            m for m in MODELS
            if m.quality_score >= self.min_quality
        ]
        candidates.sort(key=lambda m: m.input_cost_per_1m + m.output_cost_per_1m)

        for model in candidates:
            estimated_cost = (
                (estimated_tokens * model.input_cost_per_1m / 1_000_000) +
                (estimated_tokens * 0.5 * model.output_cost_per_1m / 1_000_000)
            )
            if estimated_cost <= remaining:
                return model.model

        # تجاوزت الميزانية، استخدم الأرخص
        return candidates[0].model

أفضل ممارسات التوجيه

┌─────────────────────────────────────────────────────────────┐
│              قائمة تحقق التوجيه الإنتاجي                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. دائماً لديك احتياطيات                                  │
│     └── لا تعتمد أبداً على مزود واحد                       │
│                                                             │
│  2. راقب قرارات التوجيه                                    │
│     └── سجّل اختيار النموذج مع بيانات الطلب الوصفية        │
│                                                             │
│  3. اختبر تغييرات النموذج A/B                              │
│     └── لا تفترض أن الأحدث = الأفضل لحالتك                 │
│                                                             │
│  4. فكر في زمن الاستجابة، ليس فقط التكلفة                  │
│     └── النماذج الأرخص قد يكون لها زمن استجابة أعلى        │
│                                                             │
│  5. نفّذ قواطع الدائرة                                     │
│     └── أوقف التوجيه للمزودين الفاشلين بسرعة               │
│                                                             │
│  6. خزّن قرارات التوجيه مؤقتاً                              │
│     └── تضمينات التوجيه الدلالي مكلفة                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

:::