ليه AI engineer لازم يفهم الـ serving؟
حتى لو بتستخدم API، كل حاجة بتدفع فيها أو بتشتكي منها جاية من طريقة الـ serving: سعر الـ output tokens أعلى من الـ input، الـ rate limits بالـ tokens/minute، الـ latency بتتغير مع طول الإجابة، و prompt caching بيوفر. ولو هتستضيف موديل مفتوح (خصوصية، تكلفة على حجم كبير، offline، fine-tune خاص)، القرارات دي بقت بتاعتك: أي GPU، أي quantization، كام طلب متزامن، وإزاي تحقق SLO.
| المقياس | معناه | بيتأثر بإيه |
|---|---|---|
| TTFT (time to first token) | المستخدم شاف أول حرف إمتى | طول الـ prompt (prefill)، الطابور، cold start |
| TPOT / ITL (time per output token) | سرعة الـ streaming | حجم الموديل، الـ batch، الـ memory bandwidth |
| End-to-end latency | ≈ TTFT + TPOT × عدد الـ output tokens | طول الإجابة أكتر من أي حاجة |
| Throughput | tokens/s للنظام كله | batching، الذاكرة المتاحة للـ KV cache |
GPU basics: ليه الـ decode «memory-bound»
الآلية: عشان الموديل يولّد token واحد، لازم يقرأ كل الأوزان من ذاكرة الـ GPU (HBM) ويعمل بيها حسابات قليلة نسبيًا لكل byte. الـ GPU عنده قدرة حسابية ضخمة لكن عرض نطاق الذاكرة هو اللي بيخلص الأول. النتيجة: في الـ decode، توليد token لطلب واحد وتوليد token لـ 16 طلب في نفس الخطوة بياخدوا وقت قريب من بعض — لأن قراءة الأوزان (التكلفة الأساسية) بتحصل مرة واحدة للـ batch كله.
ده أهم استنتاج في الـ serving: الـ batching بيرفع الـ throughput تقريبًا ببلاش لحد ما الذاكرة أو الحسابات تخلص. والـ prefill عكسه: معالجة آلاف tokens الـ prompt بالتوازي = compute-bound.
حساب الذاكرة: الأوزان + الـ KV cache
- الأوزان: عدد الـ parameters × bytes لكل parameter. موديل 8B بـ fp16/bf16 (2 bytes) ≈ 16 GB؛ بـ int8 ≈ 8 GB؛ بـ 4-bit ≈ 4 GB (+ overhead بسيط).
- الـ KV cache لكل token:
2 × layers × kv_heads × head_dim × bytes. النماذج الحديثة بتستخدم grouped-query attention (kv_heads أقل من query heads) عشان تقلّل الرقم ده بشكل كبير. - اللي فاضل بعد الأوزان والـ overhead = عدد الـ tokens اللي تقدر تخزنها لكل الطلبات المتزامنة مجتمعة. ده اللي بيحدد الـ concurrency الحقيقي.
المعمل تحت بيحسب ده لموديل افتراضي من فئة 8B على GPU بـ 24 GB، وبيوضح إن الـ quantization للأوزان مش بس بيصغّر الموديل — بيحرر ذاكرة للـ KV cache = طلبات متزامنة أكتر.
Batching: static vs continuous، و PagedAttention
- Static batching: اجمع N طلب، شغّلهم مع بعض لحد ما آخر واحد يخلص. المشكلة: الطلبات مختلفة جدًا في طول الإجابة؛ طلب بـ 30 token بيخلص بدري والـ slot بتاعه بيفضل فاضي لحد ما طلب الـ 600 token يخلص. والطلبات الجديدة مستنية في الطابور.
- Continuous (in-flight) batching: القرار بيتاخد كل خطوة decode: طلب خلص ← يطلع، وطلب جديد يدخل مكانه فورًا (لو فيه ذاكرة KV). الـ GPU دايمًا شغال بأقصى batch ممكن.
- PagedAttention (فكرة vLLM): الـ KV cache بيتخزن في «صفحات» صغيرة ثابتة الحجم بدل مساحة متصلة محجوزة لأقصى طول. ده بيقلل الهدر جدًا (مش لازم تحجز 8K token لطلب هيستخدم 500)، وبيسمح بمشاركة الصفحات بين طلبات ليها نفس الـ prefix (prefix caching).
معمل: ذاكرة الـ GPU، batching، و speculative decoding بالأرقام
المعمل ده محاكاة مبسطة مقصودة (خطوة الـ decode ليها زمن ثابت للـ batch، والـ prefill متجاهَل) عشان تشوف الآليات، مش benchmark لمنتج معين. الأرقام الحقيقية بتتقاس على الهاردوير بتاعك.
import random
random.seed(1)
# ---------------- 1) memory arithmetic (illustrative model shape, not a specific product) ----------------
LAYERS, KV_HEADS, HEAD_DIM, PARAMS_B = 32, 8, 128, 8.0 # an "8B-class" decoder with grouped-query attention
GPU_GB = 24
def weights_gb(bytes_per_param): return PARAMS_B * 1e9 * bytes_per_param / 1e9
def kv_bytes_per_token(bytes_per_value=2): return 2 * LAYERS * KV_HEADS * HEAD_DIM * bytes_per_value
print("weights: fp16 %.1f GB | int8 %.1f GB | 4-bit %.1f GB" % (weights_gb(2), weights_gb(1), weights_gb(0.5)))
print("KV cache per token (fp16): %.0f KB" % (kv_bytes_per_token() / 1024))
for wb, name in ((2, "fp16 weights"), (0.5, "4-bit weights")):
free = (GPU_GB - weights_gb(wb) - 1.5) * 1e9 # 1.5 GB runtime overhead (assumption)
print(f"{name:14s}: free for KV = {free/1e9:5.1f} GB -> {int(free // kv_bytes_per_token()):7d} cached tokens on a {GPU_GB} GB GPU")
# ---------------- 2) static vs continuous batching (token-step simulation) ----------------
KV_BUDGET_TOKENS = 49_000 # fp16 case from the calculation above
def workload(n=300):
t, reqs = 0.0, []
for i in range(n):
t += random.expovariate(1 / 0.2) # ~5 requests / second arrival
reqs.append(dict(id=i, arrive=t, prompt=random.randint(200, 1500),
out=random.choice([30, 60, 120, 250, 600]))) # short and long answers mixed
return reqs
STEP_S = 0.025 # one decode step for the whole batch (memory-bound; roughly flat in batch size)
def simulate(policy, max_batch=32):
reqs = workload(); pending = list(reqs); running = []; now = 0.0; done = []
while pending or running:
arrived = [r for r in pending if r["arrive"] <= now]
if policy == "static":
if not running and arrived: # start a batch only when the previous one fully ends
batch = arrived[:max_batch]
for r in batch: pending.remove(r); r["start"] = now; r["left"] = r["out"]
running = batch
else: # continuous: admit whenever a slot and KV memory are free
used = sum(r["prompt"] + r["out"] for r in running) # reserve worst-case KV for each running request
for r in arrived:
need = r["prompt"] + r["out"]
if len(running) < max_batch and used + need <= KV_BUDGET_TOKENS:
pending.remove(r); r["start"] = now; r["left"] = r["out"]; running.append(r); used += need
if not running:
now = min(r["arrive"] for r in pending); continue
now += STEP_S
for r in running: r["left"] -= 1
for r in [r for r in running if r["left"] <= 0]:
r["end"] = now; done.append(r); running.remove(r)
lat = sorted(r["end"] - r["arrive"] for r in done)
wait = sorted(r["start"] - r["arrive"] for r in done)
total_tokens = sum(r["out"] for r in done); span = max(r["end"] for r in done) - min(r["arrive"] for r in done)
return dict(p50=lat[len(lat)//2], p95=lat[int(len(lat)*.95)], wait_p95=wait[int(len(wait)*.95)], tok_s=total_tokens / span)
print("\npolicy p50 latency p95 latency p95 queue wait output tokens/s")
for pol in ("static", "continuous"):
random.seed(1); r = simulate(pol)
print(f"{pol:12s} {r['p50']:10.1f}s {r['p95']:11.1f}s {r['wait_p95']:14.1f}s {r['tok_s']:15.0f}")
# ---------------- 3) speculative decoding: expected tokens per target-model step ----------------
print("\nspeculative decoding (draft k tokens, each accepted with prob a):")
for a in (0.5, 0.7, 0.9):
row = []
for k in (2, 4, 8):
expected = (1 - a ** (k + 1)) / (1 - a) # accepted drafts + 1 token from the target model
row.append(f"k={k}: {expected:4.2f}")
print(f" acceptance a={a}: " + " ".join(row) + " tokens per target pass (vs 1.00 without)")weights: fp16 16.0 GB | int8 8.0 GB | 4-bit 4.0 GB
KV cache per token (fp16): 128 KB
fp16 weights : free for KV = 6.5 GB -> 49591 cached tokens on a 24 GB GPU
4-bit weights : free for KV = 18.5 GB -> 141143 cached tokens on a 24 GB GPU
policy p50 latency p95 latency p95 queue wait output tokens/s
static 52.4s 87.3s 82.3s 436
continuous 3.0s 15.2s 0.8s 915
speculative decoding (draft k tokens, each accepted with prob a):
acceptance a=0.5: k=2: 1.75 k=4: 1.94 k=8: 2.00 tokens per target pass (vs 1.00 without)
acceptance a=0.7: k=2: 2.19 k=4: 2.77 k=8: 3.20 tokens per target pass (vs 1.00 without)
acceptance a=0.9: k=2: 2.71 k=4: 4.10 k=8: 6.13 tokens per target pass (vs 1.00 without)- الذاكرة: بالأوزان fp16 فاضل مساحة KV لحوالي 50 ألف token متزامن؛ بالـ 4-bit تقريبًا 3 أضعاف. لو متوسط الطلب 2,000 token، ده الفرق بين ~25 و~70 طلب متزامن على نفس الكارت (بشرط إن الجودة بعد الـ quantization مقبولة — قِسها).
- Continuous batching: نفس الـ GPU ونفس الحمل: الـ throughput تقريبًا اتضاعف والـ p95 نزل جدًا، لأن الـ slots ما بتستناش أطول طلب في الـ batch. ده سبب إن محركات الـ serving الحديثة كلها بتعمله.
- Speculative decoding: موديل draft صغير يقترح k tokens، والموديل الكبير يتحقق منهم في pass واحد ويقبل اللي يتفق معاه. المكسب بيعتمد بالكامل على acceptance rate: نص متوقع (كود، JSON، ترجمة حرفية) acceptance عالي ومكسب كبير؛ نص إبداعي acceptance أقل. والناتج مطابق لتوزيع الموديل الكبير (مش تقريب) مع خوارزمية التحقق الصحيحة.
Quantization: أصغر وأسرع… بتمن
| الصيغة/الطريقة | فين بتقابلها | ملاحظات |
|---|---|---|
| FP16 / BF16 | الافتراضي للـ GPUs | المرجع للجودة |
| FP8 | GPUs الحديثة اللي بتدعمه | غالبًا فقد جودة صغير وسرعة أعلى — حسب الهاردوير |
| INT8 / INT4 weight-only (مثلًا GPTQ، AWQ) | vLLM وغيره | بيقلل الذاكرة والـ bandwidth (والـ decode memory-bound فبيسرّع) |
| GGUF (k-quants) | llama.cpp / Ollama على CPU و Apple Silicon و GPUs | مناسب للتشغيل المحلي والـ edge |
ليه بيشتغل؟ الأوزان المدرّبة فيها تكرار ودقة زيادة عن الحاجة؛ تمثيلها بـ bits أقل مع scale لكل مجموعة أوزان بيحافظ على معظم السلوك. ليه ممكن يضر؟ الفقد مش موزّع بالتساوي: المهام الحساسة (حساب، كود، لغات أقل تمثيلًا في التدريب زي العربي، المحادثات الطويلة) ممكن تتأثر أكتر من benchmarks الإنجليزي العامة.
فريق اختار 4-bit لأن الـ benchmark العام نزل نقطة واحدة. في الإنتاج، دقة استخراج التواريخ والأرقام من المستندات العربي نزلت بشكل ملحوظ. الدرس: قيّم الـ quantized model على الـ golden set بتاعك (بالشرائح) قبل القرار — نفس الـ eval gate بتاع أي تغيير موديل.
محركات الـ serving: vLLM و Ollama وأخواتهم
| المحرك | مناسب لـ | نقاط قوة | انتبه لـ |
|---|---|---|---|
| vLLM | serving إنتاجي على GPUs | continuous batching، PagedAttention، prefix caching، OpenAI-compatible server، دعم quantization | تشغيل GPUs وتحديث النسخ؛ ضبط الذاكرة والـ max length |
| Ollama | تطوير محلي، أدوات داخلية صغيرة، offline | تركيب سهل جدًا، GGUF، OpenAI-compatible endpoint | مش مصمم كـ multi-tenant serving عالي الـ throughput |
| llama.cpp server | CPU/edge/أجهزة محدودة | خفيف، portable | throughput أقل على الحمل الكبير |
| محركات تانية (SGLang، TensorRT-LLM، Triton…) | احتياجات متقدمة | أداء عالي في سيناريوهات معينة | تعقيد أكبر؛ قيّم مقابل احتياجك |
الـ ecosystem ده بيتغير بسرعة — راجع التوثيق الحالي قبل أي قرار، واعمل الـ benchmark بنفسك على الـ workload بتاعك.
services:
vllm:
image: vllm/vllm-openai:latest # pin an exact tag in production
command: >
--model ${MODEL_ID}
--max-model-len 16384
--gpu-memory-utilization 0.90
--enable-prefix-caching
environment:
HF_TOKEN: ${HF_TOKEN} # only if the model is gated
ports: ["8000:8000"]
volumes: ["hf-cache:/root/.cache/huggingface"] # avoid re-downloading weights on every restart
deploy:
resources:
reservations:
devices: [{ driver: nvidia, count: 1, capabilities: [gpu] }]
ollama: # local development alternative (CPU or GPU)
image: ollama/ollama:latest
ports: ["11434:11434"]
volumes: ["ollama:/root/.ollama"]
volumes: { hf-cache: {}, ollama: {} }ollama pull <model-name> # pick a model whose licence fits your use
ollama run <model-name> "اكتب جملة ترحيب قصيرة"
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"<model-name>","messages":[{"role":"user","content":"hello"}]}'من .NET: نفس الكود لـ API تجاري أو موديل مستضاف
الفكرة: vLLM و Ollama بيعرضوا endpoint متوافق مع OpenAI Chat Completions. فبـ IChatClient (Microsoft.Extensions.AI) تقدر تبدّل بين provider تجاري وموديل مستضاف بالـ config بس، ونفس الـ middleware (telemetry، caching، function invocation) بيشتغل على الاتنين.
// Packages: Microsoft.Extensions.AI, Microsoft.Extensions.AI.OpenAI, OpenAI (check current versions;
// the adapter method was renamed across previews — e.g. AsIChatClient()).
builder.Services.AddChatClient(sp =>
{
var cfg = sp.GetRequiredService<IConfiguration>().GetSection("Llm");
var options = new OpenAIClientOptions();
if (cfg["Endpoint"] is { Length: > 0 } endpoint)
options.Endpoint = new Uri(endpoint); // e.g. http://vllm:8000/v1 or http://localhost:11434/v1
var client = new OpenAIClient(new ApiKeyCredential(cfg["ApiKey"] ?? "unused-for-local"), options);
return client.GetChatClient(cfg["Model"]!).AsIChatClient();
})
.UseOpenTelemetry() // same tracing for hosted and commercial models
.UseLogging();{
"Llm": { "Endpoint": "http://localhost:11434/v1", "Model": "<local-model-name>", "ApiKey": "" }
}تحذير: «OpenAI-compatible» مش معناها متطابق 100%: tool calling، structured outputs، وبعض الـ parameters دعمهم بيختلف حسب المحرك والموديل. اكتب contract tests للـ features اللي بتعتمد عليها على كل backend.
Self-host ولا API؟ نموذج تكلفة
المعادلة المبسطة: تكلفة الـ API = (input tokens × سعر) + (output tokens × سعر). تكلفة الـ self-host = (عدد الـ GPUs × سعر الساعة × ساعات التشغيل) + هندسة وتشغيل (on-call، تحديثات، مراقبة) — بغض النظر عن الاستخدام. الـ self-host بيكسب لما الاستخدام عالي وثابت بحيث الـ GPUs مشغولة معظم الوقت.
def monthly_api_cost(req_per_day, in_tok, out_tok, price_in_per_m, price_out_per_m):
return req_per_day * 30 * (in_tok * price_in_per_m + out_tok * price_out_per_m) / 1e6
def monthly_selfhost_cost(gpus, gpu_hour_price, eng_hours_per_month, eng_hour_cost, always_on=True):
hours = 730 if always_on else 730 * 0.5
return gpus * gpu_hour_price * hours + eng_hours_per_month * eng_hour_cost
def max_requests_per_day(tokens_per_s_per_gpu, gpus, out_tok, utilisation=0.5):
# decode throughput bounds capacity; utilisation < 1 because traffic is not flat
return tokens_per_s_per_gpu * gpus * 86_400 * utilisation / out_tok
# Plug in YOUR prices and YOUR measured throughput — do not trust anyone's blog numbers (including these defaults).| عامل | بيميل لـ API | بيميل لـ self-host |
|---|---|---|
| الحجم | قليل/متقلب | عالي وثابت |
| الجودة المطلوبة | أحسن موديلات متاحة | موديل مفتوح كفاية (بعد eval) |
| البيانات | العقود (no-training، residency) كافية | لازم ما تخرجش من البنية التحتية |
| الفريق | مفيش خبرة GPUs/on-call | فيه منصة وخبرة |
| Latency | مقبول عبر الشبكة | محتاج قرب/offline/edge |
Checklist تحسين الـ latency والتكلفة (بالترتيب)
- قلّل الـ output tokens: «أجب في 3 جمل»،
max_tokensمناسب، structured output مختصر. أكبر مكسب عادة. - Streaming: مش بيقلل الوقت الكلي لكن بيقلل الوقت المُدرَك (TTFT هو اللي المستخدم بيحسه).
- Prompt/prefix caching: ثبّت الـ system prompt والـ tools في أول الـ prompt عشان الـ prefix يتعاد استخدامه.
- Context أقصر: retrieval أدق + reranking = chunks أقل = prefill أسرع وتكلفة أقل.
- Routing لنموذج أصغر للمهام البسيطة (درس LLMOps).
- Batch APIs للشغل غير الفوري (تقارير ليلية، backfill embeddings).
- Self-host: quantization، continuous batching، speculative decoding، prefix caching — كله بعد قياس.
Failure modes في الـ serving
- OOM مع الـ contexts الطويلة: طلب واحد بـ 100K token بيستهلك الـ KV كله. حط
max-model-lenوحد للـ input في الـ API gateway. - Preemption تحت الضغط: المحرك بيوقف طلبات ويعيد حسابها لما الذاكرة تخلص ← latency spikes. راقب metrics المحرك (queue length، preemptions، KV usage).
- Cold start: تحميل موديل 16 GB بياخد وقت؛ autoscaling من صفر = أول المستخدمين يستنوا جدًا. min replicas ≥ 1 و cache للأوزان على volume.
- Chat template mismatch: كل موديل ليه template لتنسيق الرسائل؛ template غلط = جودة سيئة بشكل غامض.
- الترخيص: «مفتوح» مش دايمًا «مسموح تجاريًا بأي شكل». اقرأ license الموديل.
اختبر فهمك
ليه الـ batching بيرفع الـ throughput في الـ decode تقريبًا ببلاش؟
إيه اللي بيحدد عدد الطلبات المتزامنة على GPU بعد تحميل الموديل؟
Speculative decoding مكسبه أكبر في أنهي حالة؟
تمارين محلولة
1: موديل 70B بـ fp16. كام GPU بـ 80 GB تحتاج للأوزان بس؟
الحل: 70×10⁹ × 2 bytes = 140 GB ← على الأقل 2 كروت للأوزان بس (tensor parallelism)، ومن غير مساحة كفاية للـ KV cache عمليًا ← غالبًا 4، أو quantization لـ 8/4-bit. الحساب ده أول خطوة قبل أي «هنستضيف 70B».
2: في المعمل، غيّر max_batch لـ 8. توقّع.
الحل: الـ continuous batching هيبقى محدود بالـ slots مش بالذاكرة: throughput أقل وطابور أطول (p95 queue wait يزيد). ده بيوضح إن ضبط الـ max concurrency لازم يتوازن مع الذاكرة والـ latency المطلوبة.
3: TTFT عالي جدًا لكن TPOT كويس. أسباب محتملة؟
الحل: prompts طويلة (prefill تقيل) ← قلل الـ context أو فعّل prefix caching؛ طابور انتظار (الـ server مشبّع) ← scale أو rate limit؛ cold start ← min replicas؛ أو retrieval بطيء قبل الـ LLM call أصلًا ← افحص الـ trace.
Mini project: Local model و benchmark
شغّل موديل صغير مفتوح بـ Ollama (أو vLLM لو عندك GPU)، ووصّله بالـ capstone عن طريق IChatClient بالـ config. اكتب script بيقيس TTFT و TPOT و throughput بـ 1 و4 و16 طلب متزامن، وشغّل الـ golden set بتاعك على الموديل المحلي مقابل API تجاري. المخرج: جدول (جودة لكل شريحة، latency، تكلفة تقديرية) + ADR: «أنهي features ينفع تشتغل على الموديل المحلي».
أسئلة إنترفيو: Junior → Senior → Staff
(Junior) إيه الفرق بين TTFT و TPOT؟
(Senior) اشرح continuous batching و PagedAttention.
(Senior) إزاي تقرر quantization لموديل هتستضيفه؟
(Staff) الإدارة عايزة تنقل كل الـ AI من API لـ self-hosted لتوفير الفلوس. خطتك؟
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.