# فصل ۰۸ — هزینه، تأخیر، `cache`

<div dir="rtl">

# فصل ۰۸ — هزینه، تأخیر، `cache`

## در این فصل چه یاد می‌گیری

هفت فصل است داریم تماس می‌زنیم و هیچ‌وقت نشمردیم چقدر خرج شد. **این فصل می‌شمارد** — با توکنایزرِ واقعی، نه با تخمین.

و چهار عدد بیرون می‌آید که هر کدام یک تصمیمِ مهندسی‌اند: **جملهٔ فارسی سه برابرِ معادلِ انگلیسی‌اش توکن دارد**، **پرامپتِ عامل در چهار گام دو برابر می‌شود**، **یک `cache` چندخطی ۸۹ درصدِ توکن‌ها را حذف می‌کند**، و **فرستادنِ کارِ ساده به مدلِ ضعیف‌تر — که همه توصیه‌اش می‌کنند — اینجا ضرر می‌دهد.**

![یک کنتور که مصرفِ یک لولهٔ باریک و یک لولهٔ پهن را کنارِ هم نشان می‌دهد](/lesson-assets/t5-s08-cost-latency/prompt/01-image-meter-two-pipes.png)

آخر این فصل می‌توانی:

- توکن را با توکنایزرِ همان مدل بشماری، نه با حدس
- تابعِ هزینهٔ خودت را بنویسی و روی حجمِ واقعی حساب کنی
- یک `cache` بسازی و نرخِ اصابت و صرفه‌جویی‌اش را اندازه بگیری
- مرزِ «دقتِ بیشتر در برابرِ هزینهٔ بیشتر» را برای سامانه‌ات پیدا کنی

## قبل از شروع

**از ترمِ ۴ فصل ۶:** `BPE`، و اینکه فارسی توکنِ بیشتری می‌گیرد. **آنجا دلیلش را دیدی؛ اینجا صورت‌حسابش را می‌بینی.**

**از فصل ۴ و ۷:** `build`/`retrieve` و حلقهٔ عامل.

> 💡 **نکته:** **زمانِ تخمینی روی CPU: دو تا سه دقیقه.** سلولِ اول `tiktoken` را نصب می‌کند؛ در Colab لازم است.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/zharfa/term-5-llm-engineering/session-08-cost-latency.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

## ۱. توکن را بشمار، حدس نزن

</div>

```bash
pip install -q tiktoken
```

```python
import tiktoken

enc = tiktoken.get_encoding("cl100k_base")


def count(text):
    return len(enc.encode(text))


pairs = [
    ("کتابخانه شنبه تا چهارشنبه از ساعت ۸ تا ۲۰ باز است.",
     "The library is open Saturday to Wednesday from 8 to 20."),
    ("عضو دانشجویی هم‌زمان تا ۵ جلد کتاب امانت می‌گیرد.",
     "A student member borrows up to 5 books at a time."),
]
for fa, en in pairs:
    print(f"  فارسی {count(fa):>3} توکن / {len(fa):>3} نویسه   |   انگلیسی {count(en):>3} توکن / {len(en):>3} نویسه")

corpus = "\n\n".join(d["text"] for d in DOCS)
print()
print("کلِ پیکره:", count(corpus), "توکن در", len(corpus), "نویسه")
print("نسبتِ توکن به نویسه:", round(count(corpus) / len(corpus), 2))
```

<div dir="rtl">

</div>

```text
  فارسی  41 توکن /  50 نویسه   |   انگلیسی  14 توکن /  55 نویسه
  فارسی  38 توکن /  49 نویسه   |   انگلیسی  14 توکن /  49 نویسه

کلِ پیکره: 2594 توکن در 3519 نویسه
نسبتِ توکن به نویسه: 0.74
```

<div dir="rtl">

> 📏 **اندازه بگیر:** **دو جملهٔ هم‌معنا با طولِ تقریباً یکسان: ۴۱ توکن در برابرِ ۱۴.** یعنی **نزدیک به سه برابر**. این همان «مالیاتِ فارسی» است که در ترمِ ۴ فصلِ ۶ علتش را دیدی — توکنایزر عمدتاً روی متنِ انگلیسی آموزش دیده، پس فارسی را ریزتر می‌شکند. **و حالا معنای مهندسی‌اش را هم داری: برای همان کار، سه برابر پول می‌دهی و سه برابر زودتر به سقفِ طولِ متن می‌خوری.**

**و نسبت `۰٫۷۴` توکن به نویسه را جایی بنویس** — برای زدنِ تخمینِ سرانگشتی روی هر متنِ فارسی به دردت می‌خورد. **ولی برای عددِ واقعی، همیشه با توکنایزرِ همان مدلی بشمار که استفاده می‌کنی.** توکنایزرها یکی نیستند و اختلافشان بی‌اهمیت نیست.

## ۲. تابعِ هزینه را خودت بنویس

</div>

```python
PRICE_IN = 0.10        # واحدِ پول به‌ازای هر یک میلیون توکنِ ورودی — از صفحهٔ قیمتِ سرویس بردار
PRICE_OUT = 0.40       # واحدِ پول به‌ازای هر یک میلیون توکنِ خروجی


def cost(prompt_tokens, output_tokens):
    return (prompt_tokens * PRICE_IN + output_tokens * PRICE_OUT) / 1_000_000


print("یک تماسِ کوچک  :", f"{cost(500, 100):.8f}")
print("هزار تماسِ کوچک:", f"{cost(500, 100) * 1000:.5f}")
print("هزار تماس با کلِ پیکره در پرامپت:", f"{cost(count(corpus) + 60, 100) * 1000:.5f}")
```

<div dir="rtl">

</div>

```text
یک تماسِ کوچک  : 0.00009000
هزار تماسِ کوچک: 0.09000
هزار تماس با کلِ پیکره در پرامپت: 0.30540
```

<div dir="rtl">

**این عددها را باور نکن — `PRICE_IN` و `PRICE_OUT` را من دلبخواهی گذاشته‌ام.** قیمت‌ها هر چند ماه عوض می‌شوند و هر سرویس مالِ خودش را دارد؛ **نوشتنشان داخلِ یک کتاب یعنی نوشتنِ چیزی که فردا غلط است.** **دو خطِ بالا را از صفحهٔ قیمتِ سرویسِ خودت پر کن.**

**آنچه عوض نمی‌شود، شکلِ تابع است، و دو چیزِ مهم را می‌گوید:**

- **خروجی معمولاً چند برابرِ ورودی قیمت دارد.** پس «کوتاه جواب بده» فقط ادب نیست، صرفه‌جویی است.
- **یک تماس تقریباً مجانی است؛ صد هزار تماس نه.** **همیشه در مقیاسِ ماهانه حساب کن**، وگرنه هیچ‌وقت متوجهٔ خرجت نمی‌شوی.

## ۳. توکن‌ها کجا می‌روند

</div>

```python
import torch
from transformers import AutoModel, AutoTokenizer

NAME = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
tokenizer = AutoTokenizer.from_pretrained(NAME)
encoder = AutoModel.from_pretrained(NAME)
encoder.eval()


@torch.no_grad()
def embed(texts, batch=32):
    out = []
    for i in range(0, len(texts), batch):
        b = tokenizer(texts[i:i + batch], padding=True, truncation=True,
                      max_length=128, return_tensors="pt")
        hidden = encoder(**b).last_hidden_state
        mask = b["attention_mask"].unsqueeze(-1).float()
        out.append((hidden * mask).sum(1) / mask.sum(1))
    return torch.nn.functional.normalize(torch.cat(out), dim=1)


def chunk_doc(doc, size=3, overlap=1):
    parts = sentences(doc["text"])
    out, start = [], 0
    while start < len(parts):
        out.append({"doc": doc["id"], "title": doc["title"],
                    "text": " ".join(parts[start:start + size])})
        if start + size >= len(parts):
            break
        start += size - overlap
    return out


CHUNKS = [c for d in DOCS for c in chunk_doc(d)]
INDEX = embed([c["text"] for c in CHUNKS])
SYSTEM = ("تو دستیارِ کتابخانهٔ نوردانه‌ای. فقط از متنِ زیر جواب بده. "
          "اگر جواب در متن نیست بنویس: در سند نیست")


def build(question, k=3):
    scores = embed([question])[0] @ INDEX.T
    picked = [CHUNKS[i] for i in scores.topk(k).indices.tolist()]
    context = "\n\n".join(f"[{c['title']}]\n{c['text']}" for c in picked)
    return [{"role": "system", "content": SYSTEM},
            {"role": "user", "content": context + "\n\n" + question}]


def ask(question, k=3, tier="large"):
    return chat(build(question, k), tier=tier)["text"]


reset_calls()
sample = GOLD[0]["q"]
messages = build(sample)
print(f"  دستورِ سامانه : {count(SYSTEM):>4} توکن")
print(f"  متنِ بازیابی‌شده: {count(messages[1]['content']) - count(sample):>4} توکن")
print(f"  خودِ پرسش     : {count(sample):>4} توکن")
print(f"  جواب          : {count(ask(sample)):>4} توکن")
```

<div dir="rtl">

</div>

```text
  دستورِ سامانه :   67 توکن
  متنِ بازیابی‌شده:  379 توکن
  خودِ پرسش     :   44 توکن
  جواب          :   38 توکن
```

<div dir="rtl">

**جمعِ این چهار عدد ۵۲۸ است و ۳۷۹ تایش متنِ بازیابی‌شده — یعنی حدودِ سه‌چهارم.** هر بهینه‌سازی‌ای که سراغِ دستورِ سامانه یا پرسش برود، **دارد وقتش را تلف می‌کند.**

**و به دستورِ سامانه دقت کن: ۶۷ توکن، و در هر تماس تکرار می‌شود.** برای صد هزار تماس در ماه این می‌شود ۶٫۷ میلیون توکن **فقط برای یک جمله‌ای که هیچ‌وقت عوض نمی‌شود**. بعضی سرویس‌ها برای همین حالت **`cache` سمتِ خودشان** دارند (پیشوندِ ثابتِ پرامپت را نگه می‌دارند و ارزان‌تر حساب می‌کنند). **ارزشِ خواندنِ مستنداتش را دارد.**

## ۴. چرا عامل گران است

</div>

```python
def prompt_tokens(messages):
    return sum(count(m["content"]) for m in messages)


history = build(sample)
for step in range(1, 5):
    print(f"  گامِ {step}: پرامپت {prompt_tokens(history):>4} توکن")
    history.append({"role": "assistant", "content": "نتیجه را دیدم و ابزارِ بعدی را می‌خواهم."})
    history.append({"role": "tool", "name": "search_docs", "content": CHUNKS[step]["text"]})
total = sum(prompt_tokens(build(sample)[:2]) for _ in range(4))
print()
print("چهار گام پشتِ‌سرِ‌هم:", prompt_tokens(history), "توکن در آخرین تماس")
print("چهار تماسِ مستقل  :", total // 4, "توکن در هر تماس")
```

<div dir="rtl">

</div>

```text
  گامِ 1: پرامپت  490 توکن
  گامِ 2: پرامپت  665 توکن
  گامِ 3: پرامپت  800 توکن
  گامِ 4: پرامپت  941 توکن

چهار گام پشتِ‌سرِ‌هم: 1066 توکن در آخرین تماس
چهار تماسِ مستقل  : 490 توکن در هر تماس
```

<div dir="rtl">

**۴۹۰ در گامِ چهارم شد ۹۴۱. عددِ ۱۰۶۶ که کد با برچسبِ «آخرین تماس» چاپ کرد، تاریخچه بعد از گامِ چهارم است، یعنی پرامپتِ تماسِ پنجم.** این رشد از اینجا می‌آید که **مدل حافظه ندارد** (فصلِ ۱) و تو هر گام **کلِ تاریخچه** را دوباره می‌فرستی.

**پس هزینهٔ یک عاملِ `n` گامی خطی نیست.** گامِ اول یک پرامپت می‌فرستد، گامِ دوم حدودِ ۱٫۴ برابر، گامِ چهارم حدودِ ۱٫۹ برابر. **جمعِ کل تقریباً با مربعِ تعدادِ گام‌ها رشد می‌کند** — و همین‌جا دلیلِ دوم برای سقفِ گامِ فصلِ ۷ پیدا می‌شود: **اولی جلوی حلقهٔ بی‌پایان را می‌گرفت، دومی جلوی صورت‌حساب را.**

**سه راهِ عملیِ کوتاه نگه داشتنِ تاریخچه:**

- **مشاهده‌ها را خلاصه کن، نه اینکه خام نگه داری.** «متنِ سه‌هزارکلمه‌ای» را جایگزین کن با «یافتم: مدتِ امانتِ دانشجویی ۲۱ روز».
- **گام‌های قدیمی را بینداز** — معمولاً فقط دو سه مشاهدهٔ آخر به کار می‌آیند.
- **نتیجه‌های ابزار را در متغیرِ پایتونی نگه دار، نه در پرامپت.** اگر گامِ بعد فقط به یک عدد نیاز دارد، همان عدد را بفرست.

## ۵. `cache`: ارزان‌ترین بهینه‌سازیِ ممکن

</div>

```python
import random

WORKLOAD = [GOLD[i]["q"] for i in random.Random(0).choices(range(24), k=200,
                                                          weights=[6] * 6 + [1] * 18)]
print("۲۰۰ درخواست، پرسش‌های یکتا:", len(set(WORKLOAD)))

CACHE = {}


def ask_cached(question, k=3):
    key = " ".join(words(question))
    if key in CACHE:
        return CACHE[key], True
    answer = ask(question, k)
    CACHE[key] = answer
    return answer, False


reset_calls()
hits = 0
spent = 0
for question in WORKLOAD:
    answer, was_hit = ask_cached(question)
    hits += was_hit
    if not was_hit:
        spent += prompt_tokens(build(question)) + count(answer)

plain = sum(prompt_tokens(build(q)) + count(CACHE[" ".join(words(q))]) for q in WORKLOAD)

print("نرخِ اصابتِ cache:", f"{hits / len(WORKLOAD):.1%}")
print("توکن بدونِ cache :", plain)
print("توکن با cache    :", spent, f"({spent / plain:.1%})")
print("هزینهٔ صرفه‌جویی‌شده:", f"{cost(plain - spent, 0):.6f}")
```

<div dir="rtl">

</div>

```text
۲۰۰ درخواست، پرسش‌های یکتا: 23
نرخِ اصابتِ cache: 88.5%
توکن بدونِ cache : 105923
توکن با cache    : 11800 (11.1%)
هزینهٔ صرفه‌جویی‌شده: 0.009412
```

<div dir="rtl">

**۸۹ درصدِ توکن‌ها حذف شد، با یک `dict`.**

**و کلیدِ `cache` مهم‌ترین تصمیمش است.** ما `" ".join(words(question))` را کلید گذاشتیم — یعنی **متنِ نرمال‌شدهٔ فصلِ ۶**. پس «کارتم را گم کردم» و «کارتم را گم کردم؟» و «کارتم را گم کردم!» **یک کلید می‌شوند** و یک بار پول می‌دهی. **کلیدِ خام‌تر یعنی اصابتِ کمتر؛ کلیدِ خیلی سخاوتمندتر یعنی جوابِ غلط برای پرسشِ متفاوت.**

**و کلیدِ ما خودش همین عیب را دارد.** `words` توکنِ یک‌نویسه‌ای را دور می‌ریزد، پس دو پرسشی که فقط در یک رقم فرق دارند یک کلید می‌شوند و دومی جوابِ اولی را می‌گیرد:

</div>

```python
one = "جریمهٔ ۵ ساعت تأخیر چند امتیاز است؟"
two = "جریمهٔ ۷ ساعت تأخیر چند امتیاز است؟"
print("کلیدِ اول :", " ".join(words(one)))
print("کلیدِ دوم :", " ".join(words(two)))
print("یکسان‌اند؟", " ".join(words(one)) == " ".join(words(two)))


def cache_key(question):
    return " ".join(re.sub(r"[،؛,.!?؟:()«»]", " ", to_ascii_digits(question)).split())


print("با cache_key یکسان‌اند؟", cache_key(one) == cache_key(two))
print("علامتِ سؤال هنوز مهم نیست؟", cache_key(one) == cache_key(one.replace("؟", "")))
```

<div dir="rtl">

</div>

```text
کلیدِ اول : جریمهٔ ساعت تأخیر امتیاز
کلیدِ دوم : جریمهٔ ساعت تأخیر امتیاز
یکسان‌اند؟ True
با cache_key یکسان‌اند؟ False
علامتِ سؤال هنوز مهم نیست؟ True
```

<div dir="rtl">

این باگ در عددهای بالا اثری ندارد، چون در ۲۴ پرسشِ ما چنین جفتی نیست؛ ۲۳ پرسشِ یکتا ۲۳ بار تماس خوردند. **ولی در سامانهٔ واقعی این یک جوابِ غلطِ بی‌صداست، پس کلید را با `cache_key` بساز.**

> ✅ **چک کن:** نرخِ اصابتِ تو به **توزیعِ درخواست‌ها** بستگی دارد نه به کدت. ما عمداً شش پرسش را شش برابرِ بقیه پرتکرار کردیم چون **ترافیکِ واقعی همیشه همین شکل است** — چند پرسشِ خیلی پرتکرار و یک دنبالهٔ بلندِ نادر. روی حجمِ کم، ترافیکِ یکنواخت نرخِ اصابتِ کمتری می‌دهد، ولی این فرق با ۲۰۰ درخواست روی ۲۴ پرسش تقریباً از بین می‌رود.

**چهار چیزی که قبل از `cache` گذاشتن باید تصمیم بگیری:**

- **کِی باطل می‌شود؟** اگر سندی عوض شد، جوابِ ذخیره‌شده کهنه است. **ساده‌ترین راه: کلید را با نسخهٔ پیکره ترکیب کن.**
- **چقدر بماند؟** یک `dict` بی‌نهایت رشد می‌کند.
- **برای هر کاربر جدا یا مشترک؟** اگر جواب به هویتِ کاربر بستگی دارد، **`cache` مشترک یک نشتِ اطلاعات است** — و فصلِ بعد دربارهٔ همین جور چیزهاست.
- **`temperature` صفر است؟** اگر خروجی عمداً متنوع است، `cache` تنوع را می‌کشد.

## ۶. مرزِ دقت و هزینه

</div>

```python
def score(item, text):
    return (REFUSAL in text) if item["a"] is None else (item["a"] in text)


reset_calls()
for k in (1, 2, 3, 5, 8):
    right = sum(score(g, ask(g["q"], k)) for g in GOLD)
    tokens = sum(prompt_tokens(build(g["q"], k)) for g in GOLD) // len(GOLD)
    print(f"  k={k}: {right:>2}/24 درست · {tokens:>4} توکن در هر پرسش · "
          f"{cost(tokens, 30) * 1000:.5f} برای هزار پرسش")
```

<div dir="rtl">

</div>

```text
  k=1: 16/24 درست ·  236 توکن در هر پرسش · 0.03560 برای هزار پرسش
  k=2: 17/24 درست ·  359 توکن در هر پرسش · 0.04790 برای هزار پرسش
  k=3: 18/24 درست ·  482 توکن در هر پرسش · 0.06020 برای هزار پرسش
  k=5: 17/24 درست ·  730 توکن در هر پرسش · 0.08500 برای هزار پرسش
  k=8: 16/24 درست · 1099 توکن در هر پرسش · 0.12190 برای هزار پرسش
```

<div dir="rtl">

**همان جدولِ فصلِ ۴، این بار با ستونِ پول.**

**و حالا شکلش را کامل می‌بینی: `k=8` سه برابرِ `k=1` هزینه دارد و دقتش دقیقاً همان است.** بدترین انتخابِ ممکن، و کسی که فقط دقت را نگاه می‌کرد شاید انتخابش می‌کرد چون «متنِ بیشتر ضرر ندارد».

> 📏 **اندازه بگیر:** **`k=3` نه گران‌ترین است نه ارزان‌ترین، و بهترین دقت را دارد.** این حالتِ خوش‌شانسی است. **معمولاً واقعاً باید انتخاب کنی** — و آن‌وقت سؤال این است: «یک واحد دقتِ بیشتر چقدر می‌ارزد؟» جوابش به کاربردت بستگی دارد، نه به مدل. **برای دستیارِ کتابخانه ارزان؛ برای مشاورهٔ پزشکی، هر چقدر.**

## ۷. مدلِ کوچک‌تر برای کارِ ساده‌تر؟

</div>

```python
reset_calls()
for tier in ("large", "small"):
    right = sum(score(g, ask(g["q"], tier=tier)) for g in GOLD)
    print(f"  مدلِ {tier:<6}: {right:>2}/24")
```

<div dir="rtl">

</div>

```text
  مدلِ large : 18/24
  مدلِ small :  5/24
```

<div dir="rtl">

**۵ از ۲۴ — یعنی دقیقاً همان کفی که در فصلِ ۴ دیدیم: سامانه‌ای که فقط می‌گوید «در سند نیست».** مدلِ کوچکِ بدلِ ما فقط سه جملهٔ اولِ پرامپت را می‌بیند و این سه جمله خودِ دستورِ سامانه‌اند. پس از سند هیچ نمی‌خواند و همیشه می‌گوید «در سند نیست». این یک مدلِ کوچک نیست، یک مدلِ کور است.

**توصیهٔ متعارف این است که کارِ ساده را به مدلِ کوچک بدهی و فقط کارِ سخت را به بزرگ.** امتحانش کنیم:

</div>

```python
def confidence(question, k=3):
    return float((embed([question])[0] @ INDEX.T).topk(k).values[0])


reset_calls()
for cut in (0.0, 0.55, 0.65, 0.75, 1.0):
    right = 0
    big = 0
    for g in GOLD:
        easy = confidence(g["q"]) >= cut
        big += not easy
        right += score(g, ask(g["q"], tier="small" if easy else "large"))
    print(f"  آستانهٔ اطمینان {cut}: {right:>2}/24 درست · {big:>2} پرسش به مدلِ بزرگ رفت")
```

<div dir="rtl">

</div>

```text
  آستانهٔ اطمینان 0.0:  5/24 درست ·  0 پرسش به مدلِ بزرگ رفت
  آستانهٔ اطمینان 0.55:  7/24 درست ·  6 پرسش به مدلِ بزرگ رفت
  آستانهٔ اطمینان 0.65:  7/24 درست ·  9 پرسش به مدلِ بزرگ رفت
  آستانهٔ اطمینان 0.75: 14/24 درست · 19 پرسش به مدلِ بزرگ رفت
  آستانهٔ اطمینان 1.0: 18/24 درست · 24 پرسش به مدلِ بزرگ رفت
```

<div dir="rtl">

**منحنی یکنواخت است: هر پرسشی که به مدلِ کوچک می‌رود، خسارت می‌زند.** بهترین «مسیریابی» این است که اصلاً مسیریابی نکنی.

> 📏 **اندازه بگیر:** **مسیریابی وقتی می‌ارزد که مدلِ کوچک روی بخشِ آسان تقریباً به‌اندازهٔ بزرگ خوب باشد.** اینجا نیست — پس **هر تماسی که صرفه‌جویی می‌کنی، با یک جوابِ غلط می‌دهی.** و این یک نتیجهٔ عمومی نیست، **یک نتیجهٔ دربارهٔ همین دو مدل و همین کار** است. **همان آزمایش را با دو مدلِ واقعیِ خودت بکن؛ ممکن است کاملاً برعکس دربیاید.** آنچه عمومی است، **روشِ تصمیم‌گیری** است، نه جوابش.

**و اگر بخواهی مسیریابی را جدی امتحان کنی، سه سیگنالِ بهتر از اطمینانِ بازیابی هست:** طولِ پرسش، وجودِ کلماتِ حسابی («چند»، «جمع»، «اگر»)، و **تاریخچه: پرسش‌هایی که قبلاً مدلِ کوچک رویشان شکست خورده.**

## ۸. تأخیر

**تأخیر با هزینه یکی نیست و اغلب با هم در تضادند.**

</div>

| کار | اثر روی هزینه | اثر روی تأخیر |
|---|---|---|
| کوتاه کردنِ `context` | **کمتر** | **کمتر** |
| `cache` | **کمتر** | **خیلی کمتر** برای اصابت‌ها |
| `streaming` | بدونِ تغییر | **زمانِ تا اولین نویسه خیلی کمتر** |
| `retry` (فصل ۱) | **بیشتر** | **بیشتر** |
| حلقهٔ عامل (فصل ۷) | **خیلی بیشتر** | **خیلی بیشتر** |
| اجرای موازیِ چند تماسِ مستقل | بدونِ تغییر | **کمتر** |

<div dir="rtl">

**آن ردیفِ آخر مهم‌ترینشان است و اغلب فراموش می‌شود:** اگر پنج پرسشِ **مستقل** داری، پنج تماسِ هم‌زمان بزن نه پشتِ‌سرِ‌هم. **زمانِ کل می‌شود کندترینشان، نه جمعشان** — و هزینه یک ریال هم فرق نمی‌کند.

**و برای اندازه‌گیریِ تأخیر یک هشدار:** با بدلِ محلی عددِ معناداری درنمی‌آید، چون تماسِ شبکه‌ای در کار نیست. **روی سرویسِ واقعی، `time.perf_counter()` دورِ تماس بگذار، پنجاه بار بزن، و به‌جای میانگین، `p95` را گزارش کن** — چون کاربری که بدترین پنج درصد را تجربه می‌کند همان کسی است که شکایت می‌کند.

## واژه‌های تازهٔ این فصل

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| tiktoken | تیک‌توکن | کتابخانهٔ شمارشِ توکن برای توکنایزرهای رایج |
| prompt cache | پرامپت کش | نگه داشتنِ جوابِ پرامپتِ تکراری به‌جای تماسِ دوباره |
| cache hit rate | کش هیت ریت | کسری از درخواست‌ها که از `cache` جواب گرفتند |
| invalidation | این‌ولیدیشن | بی‌اعتبار کردنِ ورودیِ کهنهٔ `cache` |
| routing | روتینگ | فرستادنِ هر درخواست به مدلِ مناسبِ خودش |
| p95 latency | پی‌۹۵ لیتنسی | تأخیری که ۹۵ درصدِ درخواست‌ها از آن بهترند |

<div dir="rtl">

> 🔧 **اگر کار نکرد:** اگر `ModuleNotFoundError: tiktoken` گرفتی، سلولِ `pip` را اجرا نکرده‌ای. اگر شمارشت با صورت‌حسابِ سرویس نمی‌خواند، **توکنایزرت با توکنایزرِ آن مدل یکی نیست** — و اختلافش برای فارسی می‌تواند ده‌ها درصد باشد. **عددِ معتبر همان است که خودِ سرویس در `usage` برمی‌گرداند؛ شمارشِ محلی برای تخمینِ قبل از تماس است.**

> 🤖 **از دستیارت بپرس:** «`batching` در سرویس‌های LLM دقیقاً چه چیزی را بهتر می‌کند؟» (پاسخِ درست: **گذردهی**، نه تأخیرِ یک درخواست.) بعد این را بپرس: **«اگر ۱۰۰۰ سند دارم که باید خلاصه شوند و عجله ندارم، چه انتخابی درست است؟»** — و آنجا `batch`های بزرگ و صف‌های غیرهم‌زمان معنا پیدا می‌کنند.

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا هزینهٔ یک عاملِ چهارگامی بیشتر از چهار برابرِ یک تماسِ ساده است؟

**تمرینِ اجباری:** `WORKLOAD` را با توزیعِ **یکنواخت** بساز (`weights` را بردار) و هر سه عددِ بخشِ ۵ را دوباره حساب کن. **نرخِ اصابت چقدر افت می‌کند؟** بعد جوابِ این را بنویس: **اگر روی ترافیکِ یکنواخت آزمایش می‌کردی و بر اساسش تصمیم می‌گرفتی، چه اشتباهی می‌کردی؟**

**تمرینِ ستاره‌دار ⭐:** یک `cache` معنایی بساز: به‌جای کلیدِ رشته‌ای، **بردارِ پرسش را ذخیره کن و اگر شباهتِ پرسشِ تازه با یکی از ذخیره‌شده‌ها از آستانه بیشتر بود، همان جواب را برگردان.** برای آستانه‌های ۰٫۸ و ۰٫۹ و ۰٫۹۵ **دو عدد** بده: نرخِ اصابت، و **تعدادِ جواب‌هایی که غلط برگشتند** (با `GOLD` بسنج). **این دقیقاً همان بده‌بستانِ فصلِ ۶ است:** آستانهٔ سخاوتمندتر یعنی صرفه‌جوییِ بیشتر و **غلطِ بیشتر** — و تو حالا بلدی هر دو طرفش را عدد کنی.

## در فصل بعد

هشت فصل است داریم متنِ بازیابی‌شده را داخلِ پرامپت می‌گذاریم و **فرض کرده‌ایم آن متن بی‌آزار است**. فصلِ بعد یک جمله در یکی از اسناد می‌گذارد و **کلِ سامانه را می‌رباید** — بدونِ اینکه هیچ‌کس به سرویس دسترسی داشته باشد. بعد چهار دفاع می‌سازیم و **اندازه می‌گیریم کدام واقعاً کار می‌کند.**

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t5/s08-cost-latency (یادستان, Yaadestan)
