ژرفا — خودآموز یادگیری عمیق و مهندسی هوش مصنوعی (متوسط)

فصل ۸ از ۱۰

پیشرفت ترم
۰٪

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

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

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

یک کنتور که مصرفِ یک لولهٔ باریک و یک لولهٔ پهن را کنارِ هم نشان می‌دهد

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

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

قبل از شروع#

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

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

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

📓 نوت‌بوک: نوت‌بوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

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

pip install -q tiktoken
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))
  فارسی  41 توکن /  50 نویسه   |   انگلیسی  14 توکن /  55 نویسه
  فارسی  38 توکن /  49 نویسه   |   انگلیسی  14 توکن /  49 نویسه

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

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

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

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

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}")
یک تماسِ کوچک  : 0.00009000
هزار تماسِ کوچک: 0.09000
هزار تماس با کلِ پیکره در پرامپت: 0.30540

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

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

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

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

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} توکن")
  دستورِ سامانه :   67 توکن
  متنِ بازیابی‌شده:  379 توکن
  خودِ پرسش     :   44 توکن
  جواب          :   38 توکن

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

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

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

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, "توکن در هر تماس")
  گامِ 1: پرامپت  490 توکن
  گامِ 2: پرامپت  665 توکن
  گامِ 3: پرامپت  800 توکن
  گامِ 4: پرامپت  941 توکن

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

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

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

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

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

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

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}")
۲۰۰ درخواست، پرسش‌های یکتا: 23
نرخِ اصابتِ cache: 88.5%
توکن بدونِ cache : 105923
توکن با cache    : 11800 (11.1%)
هزینهٔ صرفه‌جویی‌شده: 0.009412

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

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

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

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("؟", "")))
کلیدِ اول : جریمهٔ ساعت تأخیر امتیاز
کلیدِ دوم : جریمهٔ ساعت تأخیر امتیاز
یکسان‌اند؟ True
با cache_key یکسان‌اند؟ False
علامتِ سؤال هنوز مهم نیست؟ True

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

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

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

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

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

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} برای هزار پرسش")
  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 برای هزار پرسش

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

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

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

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

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")
  مدلِ large : 18/24
  مدلِ small :  5/24

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

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

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} پرسش به مدلِ بزرگ رفت")
  آستانهٔ اطمینان 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 پرسش به مدلِ بزرگ رفت

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

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

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

۸. تأخیر#

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

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

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

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

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

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

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

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

تمرین‌ها

اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.

در فصل بعد#

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

به آخر این فصل رسیدی!

اگر ساختی و جواب داد، این دکمه مال توست.