Software Engineer Encyclopedia
0%
Domain 11 · LLM Engineering & AI Integration · Pillar

Inference وServing للـ LLMs: من GPU لـ endpoint بـ SLO

LLM Inference & Serving

إزاي الـ LLM بيتشغّل فعلًا: prefill وdecode، الـ GPU memory وKV cache، batching (static وcontinuous)، quantization، speculative decoding، vLLM وOllama، وقرار self-host مقابل API بالأرقام.

  • Advanced
  • ~12 min read
  • 15 sections
  • 5 code examples
  • 1 diagrams
  • 7 questions
  • Priority L2 · Essential
  • vLLM / Ollama / llama.cpp (راجع التوثيق الحالي لكل واحد) · .NET 9 + Microsoft.Extensions.AI · المعمل Python stdlib (executed)

بعد الدرس ده هتقدر

  • تشرح prefill وdecode وليه الـ decode memory-bound، وتربطهم بـ TTFT وTPOT
  • تحسب ذاكرة الأوزان والـ KV cache لموديل وGPU معينين
  • تفرّق بين static وcontinuous batching وتفهم PagedAttention
  • تختار quantization مناسب وتقيّم أثره على الجودة (خصوصًا العربي)
  • تقدّر مكسب speculative decoding من acceptance rate
  • تشغّل موديل مفتوح بـ vLLM أو Ollama وتكلمه من .NET بـ OpenAI-compatible API، وتقرر self-host vs API بنموذج تكلفة
01

ليه AI engineer لازم يفهم الـ serving؟

Why serving knowledge matters even if you call an API
Basics

حتى لو بتستخدم 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طول الإجابة أكتر من أي حاجة
Throughputtokens/s للنظام كلهbatching، الذاكرة المتاحة للـ KV cache
02

GPU basics: ليه الـ decode «memory-bound»

Compute vs memory bandwidth
Deep dive

الآلية: عشان الموديل يولّد token واحد، لازم يقرأ كل الأوزان من ذاكرة الـ GPU (HBM) ويعمل بيها حسابات قليلة نسبيًا لكل byte. الـ GPU عنده قدرة حسابية ضخمة لكن عرض نطاق الذاكرة هو اللي بيخلص الأول. النتيجة: في الـ decode، توليد token لطلب واحد وتوليد token لـ 16 طلب في نفس الخطوة بياخدوا وقت قريب من بعض — لأن قراءة الأوزان (التكلفة الأساسية) بتحصل مرة واحدة للـ batch كله.

ده أهم استنتاج في الـ serving: الـ batching بيرفع الـ throughput تقريبًا ببلاش لحد ما الذاكرة أو الحسابات تخلص. والـ prefill عكسه: معالجة آلاف tokens الـ prompt بالتوازي = compute-bound.

Prefill: whole prompt at oncecompute-bound → sets TTFTtok 1tok 2tok 3…tok NDecode: one step per token, each step reads all weights + KV cachememory-bound → sets TPOT; batching many requests per step raises throughputKV cachegrows per token
Prefill is parallel and compute-heavy; decode is sequential and memory-bandwidth-heavy
03

حساب الذاكرة: الأوزان + الـ KV cache

Weights and KV-cache memory arithmetic
Deep dive
  • الأوزان: عدد الـ 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 = طلبات متزامنة أكتر.

04

Batching: static vs continuous، و PagedAttention

Why continuous batching changed LLM serving
Deep dive
  • 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).
05

معمل: ذاكرة الـ GPU، batching، و speculative decoding بالأرقام

Executed lab
Practical

المعمل ده محاكاة مبسطة مقصودة (خطوة الـ decode ليها زمن ثابت للـ batch، والـ prefill متجاهَل) عشان تشوف الآليات، مش benchmark لمنتج معين. الأرقام الحقيقية بتتقاس على الهاردوير بتاعك.

Pythonserving_lab.pyExecuted ✓
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)")
ConsoleOutput — captured from a real run
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)
  1. الذاكرة: بالأوزان fp16 فاضل مساحة KV لحوالي 50 ألف token متزامن؛ بالـ 4-bit تقريبًا 3 أضعاف. لو متوسط الطلب 2,000 token، ده الفرق بين ~25 و~70 طلب متزامن على نفس الكارت (بشرط إن الجودة بعد الـ quantization مقبولة — قِسها).
  2. Continuous batching: نفس الـ GPU ونفس الحمل: الـ throughput تقريبًا اتضاعف والـ p95 نزل جدًا، لأن الـ slots ما بتستناش أطول طلب في الـ batch. ده سبب إن محركات الـ serving الحديثة كلها بتعمله.
  3. Speculative decoding: موديل draft صغير يقترح k tokens، والموديل الكبير يتحقق منهم في pass واحد ويقبل اللي يتفق معاه. المكسب بيعتمد بالكامل على acceptance rate: نص متوقع (كود، JSON، ترجمة حرفية) acceptance عالي ومكسب كبير؛ نص إبداعي acceptance أقل. والناتج مطابق لتوزيع الموديل الكبير (مش تقريب) مع خوارزمية التحقق الصحيحة.
06

Quantization: أصغر وأسرع… بتمن

Weight quantization formats and how to evaluate them
Deep dive
الصيغة/الطريقةفين بتقابلهاملاحظات
FP16 / BF16الافتراضي للـ GPUsالمرجع للجودة
FP8GPUs الحديثة اللي بتدعمهغالبًا فقد جودة صغير وسرعة أعلى — حسب الهاردوير
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 الإنجليزي العامة.

Failure mode

فريق اختار 4-bit لأن الـ benchmark العام نزل نقطة واحدة. في الإنتاج، دقة استخراج التواريخ والأرقام من المستندات العربي نزلت بشكل ملحوظ. الدرس: قيّم الـ quantized model على الـ golden set بتاعك (بالشرائح) قبل القرار — نفس الـ eval gate بتاع أي تغيير موديل.

07

محركات الـ serving: vLLM و Ollama وأخواتهم

Choosing a serving engine
Deep dive
المحركمناسب لـنقاط قوةانتبه لـ
vLLMserving إنتاجي على GPUscontinuous batching، PagedAttention، prefix caching، OpenAI-compatible server، دعم quantizationتشغيل GPUs وتحديث النسخ؛ ضبط الذاكرة والـ max length
Ollamaتطوير محلي، أدوات داخلية صغيرة، offlineتركيب سهل جدًا، GGUF، OpenAI-compatible endpointمش مصمم كـ multi-tenant serving عالي الـ throughput
llama.cpp serverCPU/edge/أجهزة محدودةخفيف، portablethroughput أقل على الحمل الكبير
محركات تانية (SGLang، TensorRT-LLM، Triton…)احتياجات متقدمةأداء عالي في سيناريوهات معينةتعقيد أكبر؛ قيّم مقابل احتياجك

الـ ecosystem ده بيتغير بسرعة — راجع التوثيق الحالي قبل أي قرار، واعمل الـ benchmark بنفسك على الـ workload بتاعك.

YAMLdocker-compose.serving.yml
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: {} }
Bashlocal quick start (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"}]}'
08

من ‎.NET: نفس الكود لـ API تجاري أو موديل مستضاف

Provider-agnostic client via OpenAI-compatible endpoints
Practical

الفكرة: vLLM و Ollama بيعرضوا endpoint متوافق مع OpenAI Chat Completions. فبـ IChatClient (Microsoft.Extensions.AI) تقدر تبدّل بين provider تجاري وموديل مستضاف بالـ config بس، ونفس الـ middleware (telemetry، caching، function invocation) بيشتغل على الاتنين.

C#Program.cs
// 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();
JSONappsettings.Development.json
{
  "Llm": { "Endpoint": "http://localhost:11434/v1", "Model": "<local-model-name>", "ApiKey": "" }
}

تحذير: «OpenAI-compatible» مش معناها متطابق 100%: tool calling، structured outputs، وبعض الـ parameters دعمهم بيختلف حسب المحرك والموديل. اكتب contract tests للـ features اللي بتعتمد عليها على كل backend.

09

Self-host ولا API؟ نموذج تكلفة

A cost model for the build-vs-buy decision
Deep dive

المعادلة المبسطة: تكلفة الـ API = (input tokens × سعر) + (output tokens × سعر). تكلفة الـ self-host = (عدد الـ GPUs × سعر الساعة × ساعات التشغيل) + هندسة وتشغيل (on-call، تحديثات، مراقبة) — بغض النظر عن الاستخدام. الـ self-host بيكسب لما الاستخدام عالي وثابت بحيث الـ GPUs مشغولة معظم الوقت.

Pythonbreakeven.py
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
10

Checklist تحسين الـ latency والتكلفة (بالترتيب)

Latency and cost optimization, ordered by usual payoff
Practical
  1. قلّل الـ output tokens: «أجب في 3 جمل»، max_tokens مناسب، structured output مختصر. أكبر مكسب عادة.
  2. Streaming: مش بيقلل الوقت الكلي لكن بيقلل الوقت المُدرَك (TTFT هو اللي المستخدم بيحسه).
  3. Prompt/prefix caching: ثبّت الـ system prompt والـ tools في أول الـ prompt عشان الـ prefix يتعاد استخدامه.
  4. Context أقصر: retrieval أدق + reranking = chunks أقل = prefill أسرع وتكلفة أقل.
  5. Routing لنموذج أصغر للمهام البسيطة (درس LLMOps).
  6. Batch APIs للشغل غير الفوري (تقارير ليلية، backfill embeddings).
  7. Self-host: quantization، continuous batching، speculative decoding، prefix caching — كله بعد قياس.
11

Failure modes في الـ serving

What breaks in production
Pitfalls
  • 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 الموديل.
12

اختبر فهمك

Knowledge check
Basics

ليه الـ batching بيرفع الـ throughput في الـ decode تقريبًا ببلاش؟

إيه اللي بيحدد عدد الطلبات المتزامنة على GPU بعد تحميل الموديل؟

Speculative decoding مكسبه أكبر في أنهي حالة؟

13

تمارين محلولة

Solved exercises
Practical
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.

14

Mini project: Local model و benchmark

Mini project
Practical

شغّل موديل صغير مفتوح بـ Ollama (أو vLLM لو عندك GPU)، ووصّله بالـ capstone عن طريق IChatClient بالـ config. اكتب script بيقيس TTFT و TPOT و throughput بـ 1 و4 و16 طلب متزامن، وشغّل الـ golden set بتاعك على الموديل المحلي مقابل API تجاري. المخرج: جدول (جودة لكل شريحة، latency، تكلفة تقديرية) + ADR: «أنهي features ينفع تشتغل على الموديل المحلي».

15

أسئلة إنترفيو: Junior → Senior → Staff

Interview ladder
Basics
(Junior) إيه الفرق بين TTFT و TPOT؟
TTFT وقت ظهور أول token (بيتحدد بالـ prefill والطابور)، TPOT متوسط الوقت بين كل token والتاني أثناء الـ streaming (بيتحدد بالـ decode).
(Senior) اشرح continuous batching و PagedAttention.
Continuous: الـ batch بيتعاد تشكيله كل خطوة decode، الطلب اللي خلص يطلع والجديد يدخل. PagedAttention: الـ KV cache في صفحات صغيرة بدل مساحة متصلة محجوزة، فالهدر بيقل والـ prefixes ممكن تتشارك. النتيجة throughput أعلى بكتير على نفس الـ GPU.
(Senior) إزاي تقرر quantization لموديل هتستضيفه؟
احسب الذاكرة المطلوبة وأثرها على الـ concurrency، جرّب صيغ مدعومة على المحرك بتاعك، وقيّم على الـ golden set بالشرائح (خصوصًا العربي والأرقام)، وقِس الـ latency الفعلي. القرار = أقل دقة بتعدّي الـ gate.
(Staff) الإدارة عايزة تنقل كل الـ AI من API لـ self-hosted لتوفير الفلوس. خطتك؟
نموذج تكلفة بأرقام حقيقية (استخدام فعلي، throughput مقاس، GPUs، تشغيل و on-call)، eval للموديلات المفتوحة على كل feature، تقسيم الـ features (اللي الموديل المفتوح كفاية فيها vs اللي محتاجة الأقوى)، pilot لـ feature واحدة عالية الحجم، abstraction (IChatClient/gateway) يخلي الرجوع سهل، وقرار في ADR. غالبًا النتيجة hybrid مش all-or-nothing.
↗

المراجع والقراءة الإضافية

References & further reading

الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)

خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.

محتويات الدرس