بنينا طبقة توجيه لخفض تكاليف الذكاء الاصطناعي، لكنها عطلت المنتج.

بناء طبقة توجيه لخفض تكاليف الذكاء الاصطناعي.. لكنها حطمت المنتج

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

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

المشكلة التي حاولنا حلها

اعتمد منتجنا المدعوم بالذكاء الاصطناعي على نماذج لغوية كبيرة متعددة من مزودين مثل OpenAI وGoogle. استخدمنا GPT-4 للاستدلال المعقد، وGPT-3.5 للمهام البسيطة، وPaLM 2 من Google للاستعلامات في مجالات محددة. كانت فاتورتنا الشهرية تتجه نحو ستة أرقام.

الحل الواضح: توجيه كل طلب إلى أرخص نموذج قادر على معالجته. أردنا نظاماً يحلل كل مطالبة، ويقدر تعقيدها، ويرسلها إلى النموذج الأكثر كفاءة من حيث التكلفة. إذا سأل مستخدم "كيف الطقس؟" نوجه إلى GPT-3.5-mini. إذا سأل "اكتب تحليلاً قانونياً مفصلاً" نوجه إلى GPT-4.

المتطلبات

قبل البناء، حددنا ما يجب أن تفعله طبقة التوجيه:

• **تحسين التكلفة**: تقليل متوسط تكلفة الطلب بنسبة 40% على الأقل.
• **التحكم في زمن الاستجابة**: الحفاظ على أوقات الاستجابة تحت 2 ثانية لـ 95% من الطلبات.
• **الحفاظ على الجودة**: الحفاظ على درجات رضا المستخدمين ضمن 5% من خط الأساس.
• **منطق الاحتياطي**: التصعيد تلقائياً إلى نماذج أكثر قدرة إذا فشل النموذج الرخيص.
• **المراقبة**: تسجيل كل قرار توجيه مع النموذج والتكلفة وزمن الاستجابة.

التثبيت خطوة بخطوة

بنينا طبقة التوجيه كخدمة وسيطة بلغة Python باستخدام FastAPI وRedis. إليك كيفية الإعداد.

1. تثبيت التبعيات

أولاً، أنشئ بيئة افتراضية وقم بتثبيت الحزم المطلوبة.

python -m venv routing-env
source routing-env/bin/activate
pip install fastapi uvicorn redis openai google-generativeai pydantic python-dotenv

2. تكوين البيئة

أنشئ ملف `.env` بمفاتيح API الخاصة بك وأسعار النماذج.

# .env
OPENAI_API_KEY=sk-your-key-here
GOOGLE_API_KEY=your-google-key
REDIS_URL=redis://localhost:6379

# أسعار النماذج لكل 1000 رمز (بالدولار)
GPT4_PRICE=0.03
GPT35_PRICE=0.0015
PALM2_PRICE=0.0005

3. منطق التوجيه الأساسي

قلب النظام هو مقدر تعقيد يسجل المطالبات على مقياس من 1-10.

# router.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import openai
import google.generativeai as palm
import redis
import os
from dotenv import load_dotenv

load_dotenv()

app = FastAPI()
r = redis.from_url(os.getenv("REDIS_URL"))

class Request(BaseModel):
    prompt: str
    user_id: str

class Response(BaseModel):
    model: str
    content: str
    cost: float
    latency_ms: int

def estimate_complexity(prompt: str) -> int:
    """تقدير تعقيد المطالبة من 1-10 بناءً على الطول والكلمات والبنية."""
    score = 1
    if len(prompt) > 200:
        score += 2
    if len(prompt) > 500:
        score += 2
    if any(word in prompt.lower() for word in ["قانوني", "طبي", "كود", "رياضيات"]):
        score += 3
    if "?" not in prompt:
        score += 1
    return min(score, 10)

def select_model(complexity: int) -> str:
    """التوجيه إلى أرخص نموذج يمكنه التعامل مع التعقيد."""
    if complexity <= 3:
        return "palm-2"  # $0.0005
    elif complexity <= 6:
        return "gpt-3.5-turbo"  # $0.0015
    else:
        return "gpt-4"  # $0.03

@app.post("/route")
async def route_request(request: Request):
    complexity = estimate_complexity(request.prompt)
    model = select_model(complexity)
    
    # تسجيل القرار في Redis للمراقبة
    r.rpush("routing_log", f"{model}:{complexity}:{request.user_id}")
    
    # استدعاء النموذج المحدد
    import time
    start = time.time()
    
    try:
        if model == "gpt-4" or model == "gpt-3.5-turbo":
            openai.api_key = os.getenv("OPENAI_API_KEY")
            response = openai.ChatCompletion.create(
                model=model,
                messages=[{"role": "user", "content": request.prompt}]
            )
            content = response.choices[0].message.content
        elif model == "palm-2":
            palm.configure(api_key=os.getenv("GOOGLE_API_KEY"))
            response = palm.generate_text(prompt=request.prompt)
            content = response.result
        
        latency = int((time.time() - start) * 1000)
        cost = calculate_cost(model, len(request.prompt), len(content))
        
        return Response(model=model, content=content, cost=cost, latency_ms=latency)
    
    except Exception as e:
        # الاحتياطي إلى GPT-4 عند الفشل
        return await fallback(request.prompt)

def calculate_cost(model: str, input_tokens: int, output_tokens: int) -> float:
    prices = {
        "gpt-4": 0.03,
        "gpt-3.5-turbo": 0.0015,
        "palm-2": 0.0005
    }
    return prices[model] * (input_tokens + output_tokens) / 1000

4. تشغيل الخدمة

شغّل طبقة التوجيه على المنفذ 8000.

uvicorn router:app --host 0.0.0.0 --port 8000 --reload

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

بمجرد تشغيل الخدمة، يمكنك اختبارها باستخدام curl.

استعلام بسيط (يُوجه إلى PaLM 2)

curl -X POST http://localhost:8000/route \
  -H "Content-Type: application/json" \
  -d '{"prompt": "ما عاصمة فرنسا؟", "user_id": "test1"}'

الاستجابة المتوقعة:

{
  "model": "palm-2",
  "content": "عاصمة فرنسا هي باريس.",
  "cost": 0.0005,
  "latency_ms": 340
}

استعلام معقد (يُوجه إلى GPT-4)

curl -X POST http://localhost:8000/route \
  -H "Content-Type: application/json" \
  -d '{"prompt": "اكتب تحليلاً قانونياً مفصلاً لآثار التعديل الرابع على تتبع الهواتف الخلوية بدون إذن قضائي من قبل وكالات إنفاذ القانون، بما في ذلك السوابق القضائية للمحكمة العليا والآراء المخالفة.", "user_id": "test2"}'

الاستجابة المتوقعة:

{
  "model": "gpt-4",
  "content": "...",
  "cost": 0.12,
  "latency_ms": 2100
}

ما الذي حطم المنتج

عملت طبقة التوجيه بشكل مثالي في العزلة. انخفضت تكلفة الطلب بنسبة 52% خلال الأسبوع الأول. لكن المستخدمين بدأوا يشكون من جودة غير متناسقة، وفشل عشوائي، وسلوك غريب.

هشاشة تقدير التعقيد

كانت دالة `estimate_complexity` لدينا مبسطة جداً. مستخدم يسأل "ما الفرق بين القطة والكلب؟" حصل على درجة 1 (بسيط) وتم توجيهه إلى PaLM 2. أعاد PaLM 2 إجابة قصيرة وصحيحة تقنياً. لكن المستخدم توقع رداً مفصلاً ومحادثياً مثل ما يقدمه GPT-4. قامت طبقة التوجيه بتحسين التكلفة، وليس تجربة المستخدم.

والأسوأ من ذلك، أن المطالبات الغامضة مثل "ساعدني في فهم هذا الكود" حصلت على درجة عالية بسبب كلمة "كود" وتم توجيهها إلى GPT-4 دون داعٍ. كنا نحرق المال على طلبات بسيطة.

كابوس الاحتياطي

عندما فشل PaLM 2 في طلب (وهو ما حدث بنسبة ~8% بسبب حدود المعدل)، عمل الاحتياطي إلى GPT-4 - لكنه ضاعف زمن الاستجابة. رأى المستخدمون مؤشرات تحميل دوارة لأكثر من 4 ثوانٍ. قفز زمن الاستجابة في المئين 95 من 1.2 ثانية إلى 4.8 ثانية.

اختلاف سلوك النماذج

لكل نموذج شخصية مختلفة. GPT-4 مطول وحذر. GPT-3.5 موجز ومباشر. PaLM 2 يميل إلى أن يكون أكثر إبداعاً. لاحظ المستخدمون أن نفس المطالبة تعيد نغمات مختلفة تماماً اعتماداً على قرار التوجيه. فقد منتجنا صوته المتناسق.

ما تعلمناه

1. تحسين التكلفة يجب أن يشمل تجربة المستخدم

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

2. التوجيه يحتاج إلى تخصيص لكل مستخدم

بعض المستخدمين يفضلون الإجابات القصيرة. آخرون يريدون تحليلاً عميقاً. كان يجب أن تتعلم طبقة التوجيه تفضيلات المستخدمين وتعدل العتبات وفقاً لذلك.

3. الاحتياطيات تحتاج إلى ميزانيات زمنية

بدلاً من الاحتياطي الأعمى إلى GPT-4، كان يجب أن نضع ميزانية زمنية قصوى لزمن الاستجابة. إذا استغرق النموذج الرخيص أكثر من 500 مللي ثانية، صعّد فوراً - لا تنتظر حتى يفشل.

4. راقب الجودة، وليس التكلفة فقط

تتبعنا تكلفة الطلب وزمن الاستجابة. كان يجب أن نتتبع:

• درجات رضا المستخدمين لكل نموذج
• معدلات إنجاز المهام لكل نموذج
• معدلات هجر الجلسات

طبقة التوجيه المُحسّنة

بعد الحادثة، أعدنا بناء طبقة التوجيه مع وضع هذه الدروس في الاعتبار. إليك النسخة المحسّنة.

# improved_router.py
import asyncio
from typing import Optional

class AdaptiveRouter:
    def __init__(self, user_preferences: dict = None):
        self.user_prefs = user_preferences or {}
        self.latency_budget = 2000  # حد أقصى 2 ثانية إجمالاً
    
    async def route_with_timeout(self, prompt: str, user_id: str):
        complexity = self.estimate_complexity(prompt)
        preferred_style = self.user_prefs.get(user_id, "متوازن")
        
        # ضبط العتبة بناءً على تفضيل المستخدم
        if preferred_style == "موجز":
            threshold = 4
        elif preferred_style == "مفصل":
            threshold = 6
        else:
            threshold = 5
        
        # جرب النموذج الأرخص أولاً، مع مهلة زمنية
        model = self.select_model(complexity, threshold)
        try:
            result = await asyncio.wait_for(
                self.call_model(model, prompt),
                timeout=self.latency_budget / 1000
            )
            return result
        except asyncio.TimeoutError:
            # صعّد فوراً إذا كان النموذج الرخيص بطيئاً
            result = await self.call_model("gpt-4", prompt)
            return result

الخلاصة

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

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

إذا كنت تبني نظاماً مشابهاً، ابدأ بقاعدة بسيطة: لا تدع المستخدم يرى أبداً أنك بدّلت النماذج. إذا لاحظوا، فقد حطّمت المنتج بالفعل.