سرنخ — خودآموز پایتون و برنامه‌نویسی برای هوش مصنوعی (مقدماتی)

فصل ۶ از ۸

پیشرفت ترم
۰٪

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

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

یک چراغِ جست‌وجو که از میانِ انبوهی از برگه‌ها سه برگهٔ مشخص را روشن کرده

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

  • یک index برداری بسازی و روی آن جست‌وجو کنی
  • جست‌وجوی معنایی و واژگانی را با عدد مقایسه کنی
  • متنِ بلند را برای بازیابی درست تکه کنی
  • الگوی RAG را بنویسی و بگویی کجا خاموش شکست می‌خورد

قبل از شروع#

از فصل ۵: embedding، شباهتِ کسینوسی، و اینکه بردار طول ثابت دارد.

از ترمِ ۲: numpy و کارِ برداری روی کلِ آرایه.

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

۱. index: یک بار حساب کن، هزار بار استفاده کن#

جست‌وجو یعنی سؤال را با همهٔ متن‌ها مقایسه کنی. اگر هر بار همهٔ متن‌ها را دوباره encode کنی، کارِ سنگین را بی‌جهت تکرار کرده‌ای.

پس یک بار همه را به بردار تبدیل کن و نگه‌دار. به این مجموعهٔ بردارها index می‌گویند.

pip install -q sentence-transformers
import numpy as np
import pandas as pd
from sentence_transformers import SentenceTransformer

docs = pd.read_csv("docs.csv")
encoder = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")

index = encoder.encode(docs["text"].tolist(), normalize_embeddings=True)

print("اندازه ایندکس:", index.shape)
print("طول هر بردار پس از نرمال‌سازی:", round(float(np.linalg.norm(index[0])), 3))
اندازه ایندکس: (20, 384)
طول هر بردار پس از نرمال‌سازی: 1.0

✅ چک کن: طولِ بردار باید دقیقاً 1.0 باشد. اگر عددِ دیگری دیدی، normalize_embeddings=True را جا انداخته‌ای — و آن‌وقت همهٔ شباهت‌های این فصل غلط درمی‌آیند، بدونِ اینکه هیچ خطایی بگیری، چون ضربِ داخلی بی‌اعتراض هر عددی را برمی‌گرداند.

normalize_embeddings=True یک ترفندِ مهم است. وقتی طولِ همهٔ بردارها ۱ باشد، مخرجِ فرمولِ کسینوسِ فصلِ ۵ برابرِ ۱ می‌شود و ضربِ داخلیِ ساده دقیقاً همان کسینوس است. یعنی به‌جای فراخوانیِ یک تابع برای هر متن، یک ضربِ ماتریسیِ numpy کلِ جست‌وجو را انجام می‌دهد.

۲. تابعِ جست‌وجو#

def search(question, k=3):
    """k متنِ مرتبط‌ترین با سؤال را برمی‌گرداند."""
    q = encoder.encode([question], normalize_embeddings=True)[0]
    scores = index @ q                       # یک ضرب، برای هر بیست متن
    top = np.argsort(-scores)[:k]            # منفی، چون argsort صعودی است
    return [(float(scores[i]), docs["text"][i]) for i in top]

for score, text in search("چطور غذا را خوشمزه کنم"):
    print(round(score, 2), "|", text)
0.53 | پیاز را با حرارت ملایم سرخ کن تا شیرینی‌اش دربیاید.
0.5 | گوشت را قبل از پختن از یخچال دربیاور تا به دمای اتاق برسد.
0.38 | خواب کافی از هر مکمل غذایی بیشتر روی تمرکز اثر دارد.

در سؤال هیچ کلمهٔ معناداری از دو جوابِ اول نیامده. تنها کلمهٔ مشترک «را» است؛ نه «پیاز»، نه «سرخ»، نه «گوشت». مدل فهمیده که «خوشمزه کردنِ غذا» و «سرخ کردنِ پیاز» یک قلمروند.

و به جوابِ سوم نگاه کن: جمله‌ای از سلامت با کلمهٔ «غذایی». نه کاملاً غلط، نه واقعاً جوابِ سؤال. بازیابی هیچ‌وقت بی‌نقص نیست و بخشِ ۷ می‌گوید با این واقعیت چه باید کرد.

np.argsort(-scores) را جدا نگه دار؛ همان یک خط است که «مرتب‌سازیِ نزولی» می‌دهد و در هر کدی که رتبه‌بندی دارد به‌کارت می‌آید.

و یک نکتهٔ حیاتی درباره‌اش: argsort خودِ مقدارها را برنمی‌گرداند، شمارهٔ جایگاهشان را برمی‌گرداند. برای همین خطِ بعدی با همان i هم امتیاز را از scores[i] برمی‌دارد و هم متن را از docs["text"][i] — آن i یک اندیس است، نه یک امتیاز. (علامتِ منفی هم برای این است که argsort همیشه صعودی مرتب می‌کند؛ منفی‌کردن ترتیب را برمی‌گرداند.)

نسخهٔ کوچک‌ترش np.argmax است که فقط شمارهٔ جایگاهِ بزرگ‌ترین عنصر را می‌دهد. هر جا فقط یک برنده می‌خواهی از آن استفاده کن؛ در بخش‌های ۴ و ۵ همین فصل می‌بینی‌اش. آن حرفِ arg در هر دو نام همین را می‌گوید: «جایگاهِ آن مقدار را بده، نه خودش را».

🌱 ریشه‌اش کجاست: کاری که این تابع می‌کند در واقع «نزدیک‌ترین همسایه» است: در فضایی که هر متن یک نقطه است، دنبالِ نزدیک‌ترین نقطه‌ها به نقطهٔ سؤال می‌گردیم. ایدهٔ فاصله بینِ دو نقطه — و اینکه چرا اصلاً یک عدد می‌تواند «نزدیکی» را بسنجد — در ریشه، ترم ۵ فصل ۴ — فاصله در صفحه از فیثاغورس ساخته می‌شود. همان ایده، فقط به‌جای دو بُعد، ۳۸۴ بُعد.

۳. همان سؤال، با روشِ واژگانی#

from sklearn.feature_extraction.text import TfidfVectorizer

lexical = TfidfVectorizer().fit(docs["text"])
L = lexical.transform(docs["text"]).toarray()

def search_lexical(question, k=3):
    v = lexical.transform([question]).toarray()[0]
    lengths = np.linalg.norm(L, axis=1) * np.linalg.norm(v)
    scores = np.divide(L @ v, lengths, out=np.zeros(len(L)), where=lengths > 0)
    return [(float(scores[i]), docs["topic"][i], docs["text"][i]) for i in np.argsort(-scores)[:k]]

for score, topic, text in search_lexical("چطور غذا را خوشمزه کنم"):
    print(round(score, 2), "|", topic, "|", text)
0.21 | برنامه‌نویسی | کد را برای خواننده بنویس، نه برای کامپیوتر.
0.2 | آشپزی | برای اینکه برنج شفته نشود، آب را دقیقاً اندازه بگیر.
0.18 | آشپزی | پیاز را با حرارت ملایم سرخ کن تا شیرینی‌اش دربیاید.

جوابِ اول برای یک سؤالِ آشپزی، یک جملهٔ برنامه‌نویسی است. چرا؟ چون از همهٔ کلمه‌های سؤال فقط «را» در واژگان هست، و این جمله کوتاه است و «را» در آن وزنِ بیشتری می‌گیرد. «را» یک کلمهٔ دستوریِ بی‌معناست که در بیشترِ جمله‌های فارسی هست.

آن np.divide با where=lengths > 0 هم عمدی است: اگر سؤالِ کاربر هیچ کلمه‌ای از واژگان نداشته باشد، طولِ بردارش صفر می‌شود و تقسیم بر صفر پیش می‌آید. همان ZeroDivisionErrorِ ترمِ ۱ فصلِ ۸، این بار در پوششِ numpy — که به‌جای خطا، nan می‌دهد و بی‌صدا کلِ رتبه‌بندی را خراب می‌کند.

۴. حالا اندازه بگیر#

یک نمونه چیزی ثابت نمی‌کند. یک مجموعهٔ کوچکِ ارزیابی بساز: سؤال‌های واقعی، به‌همراه جوابی که می‌دانی درست است.

💡 نکته: در خطِ چاپِ کدِ زیر شکلِ تازه‌ای از if می‌بینی: '✓' if ok_lexical else '✗'. این if به‌عنوان یک عبارت است، نه یک دستور — کلِ آن یک مقدار تولید می‌کند و برای همین می‌تواند داخلِ f-string بنشیند. از وسط بخوانش: «'✓' بده، اگر ok_lexical درست بود، وگرنه '✗'». همان if/else ترمِ ۱ فصلِ ۵ است، فشرده در یک خط.

QUESTIONS = [
    ("چطور غذا را خوشمزه کنم", "آشپزی"),
    ("بلیت ارزان‌تر بخرم", "سفر"),
    ("چطور بهتر بخوابم", "سلامت"),
    ("کدم را خواناتر بنویسم", "برنامه‌نویسی"),
    ("کجا اقامت کنم که کم‌هزینه باشد", "سفر"),
    ("برای تمرکز چه کنم", "سلامت"),
    ("برنج را چطور بپزم", "آشپزی"),
    ("چطور بفهمم کدام قسمت برنامه کند است", "برنامه‌نویسی"),
]

def topic_of_best(question, semantic=True):
    if semantic:
        q = encoder.encode([question], normalize_embeddings=True)[0]
        return docs["topic"][int(np.argmax(index @ q))]
    return search_lexical(question, 1)[0][1]

hit_lexical = hit_semantic = 0
for question, correct in QUESTIONS:
    ok_lexical = topic_of_best(question, semantic=False) == correct
    ok_semantic = topic_of_best(question) == correct
    hit_lexical += ok_lexical
    hit_semantic += ok_semantic
    print(f"{'✓' if ok_lexical else '✗'} واژگانی | {'✓' if ok_semantic else '✗'} معنایی | {question}")

print()
print(f"واژگانی: {hit_lexical}/{len(QUESTIONS)}  |  معنایی: {hit_semantic}/{len(QUESTIONS)}")
✗ واژگانی | ✓ معنایی | چطور غذا را خوشمزه کنم
✓ واژگانی | ✓ معنایی | بلیت ارزان‌تر بخرم
✗ واژگانی | ✓ معنایی | چطور بهتر بخوابم
✓ واژگانی | ✓ معنایی | کدم را خواناتر بنویسم
✗ واژگانی | ✓ معنایی | کجا اقامت کنم که کم‌هزینه باشد
✗ واژگانی | ✓ معنایی | برای تمرکز چه کنم
✓ واژگانی | ✓ معنایی | برنج را چطور بپزم
✓ واژگانی | ✓ معنایی | چطور بفهمم کدام قسمت برنامه کند است

واژگانی: 4/8  |  معنایی: 8/8

📏 اندازه بگیر: این هشت سطر، همان «خطِ پایه»ِ ترمِ ۳ است، فقط برای جست‌وجو. بدونِ آن فقط می‌توانستی بگویی «معنایی بهتر به‌نظر می‌رسد»؛ با آن می‌گویی «۸ در برابرِ ۴». و توجه کن که هشت‌تا خیلی کم است — با هشت سؤال، یکی خطا هم می‌شود ۱۲ درصد نوسان. برای هر کارِ واقعی حداقل چند ده سؤال بنویس، و سؤال‌ها را از کاربرانِ واقعی بگیر، نه از ذهنِ خودت — سؤالی که تو می‌سازی، ناخودآگاه با کلمه‌های متنِ خودت ساخته می‌شود و همین امتیازِ روشِ واژگانی را ناعادلانه بالا می‌برد.

۵. متنِ بلند: چرا باید تکه کنی#

فصلِ ۵ گفت متنِ بلند در یک بردارِ ۳۸۴تایی له می‌شود. حالا با عدد ببینیمش:

article = (
    "راهنمای سفر به شمال. مسیر تهران به رشت در روزهای تعطیل شلوغ است و بهتر است شب حرکت کنی. "
    "غذای محلی گیلان بیشتر با سیر و ترشی همراه است و میرزاقاسمی معروف‌ترینشان است. "
    "برای اقامت، اقامتگاه بومی در روستاها از هتل‌های ساحلی ارزان‌تر است و صبحانه‌اش هم محلی است. "
    "اگر با خودرو می‌روی، زنجیرچرخ را حتی در اواخر پاییز همراه داشته باش چون جاده‌های کوهستانی یخ می‌زنند. "
    "بهترین فصل اواخر بهار است؛ تابستان هم شرجی است هم گران."
)
question = "با ماشین بروم چه چیزی همراه ببرم؟"

q = encoder.encode([question], normalize_embeddings=True)[0]
whole = encoder.encode([article], normalize_embeddings=True)[0]
print("طول متن:", len(article), "نویسه")
print("شباهت سؤال با کل متن:", round(float(whole @ q), 2))
طول متن: 415 نویسه
شباهت سؤال با کل متن: 0.34

جوابِ سؤال داخلِ همین متن هست — جملهٔ زنجیرچرخ. ولی شباهتِ کل ۰٫۳۴ است، چون آن یک جمله در میانگینِ شش تکهٔ دیگر حل شده.

راهِ حل: متن را تکه کن. اولین ایده معمولاً تکه‌کردن بر اساسِ تعدادِ نویسه است:

def chunk_by_size(text, size=90, overlap=25):
    pieces, start = [], 0
    while start < len(text):
        pieces.append(text[start:start + size].strip())
        start += size - overlap
    return [p for p in pieces if p]

pieces = chunk_by_size(article)
print("تعداد تکه:", len(pieces))
print("تکهٔ چهارم:", pieces[3])
تعداد تکه: 7
تکهٔ چهارم: روستاها از هتل‌های ساحلی ارزان‌تر است و صبحانه‌اش هم محلی است. اگر با خودرو می‌روی، زنجیرچ

کار می‌کند، ولی عیبش را ببین: تکه از وسطِ جمله شروع می‌شود و از وسطِ جملهٔ بعدی قطع می‌شود. overlap (هم‌پوشانی) برای همین است — تا مطلبی که سرِ مرز افتاده، دستِ‌کم در یکی از دو تکه کامل باشد.

تکه‌کردنِ بهتر، مرزهای طبیعیِ متن را رعایت می‌کند — یعنی سرِ جمله ببُر، نه سرِ نویسه.

برای پیدا کردنِ مرزِ جمله به ابزارِ تازه‌ای نیاز داری: re، کتابخانهٔ عبارتِ باقاعده (regular expression). یک عبارتِ باقاعده یک الگوی جست‌وجو در متن است — به‌جای «دنبالِ این کلمهٔ دقیق بگرد»، می‌گویی «دنبالِ هر چیزی بگرد که این شکل را دارد». re.split(pattern, text) متن را هر جا که آن الگو دیده شود می‌شکند — همان کارِ split() ترمِ ۱، ولی به‌جای یک جداکنندهٔ ثابت، با یک الگو.

دو نشانه در کدِ زیر:

  • r"..." — حرفِ r قبل از گیومه یعنی «این متن را خام بخوان». بدونِ آن، پایتون \ را آغازِ یک نویسهٔ فراری حساب می‌کند: \s فقط یک SyntaxWarning می‌گیرد، ولی الگویی مثلِ \b بی‌صدا خراب می‌شود. برای هر عبارتِ باقاعده این r را بگذار؛ عادتِ ارزانی است.
  • \s+ — یعنی «یک یا چند فاصله».

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

import re

def chunk_by_sentence(text):
    parts = re.split(r"(?<=[.!?؟؛])\s+", text.strip())
    return [p.strip() for p in parts if p.strip()]

sentences = chunk_by_sentence(article)
V = encoder.encode(sentences, normalize_embeddings=True)
scores = V @ q
best = int(np.argmax(scores))

print("تعداد جمله:", len(sentences))
print("بهترین شباهت:", round(float(scores[best]), 2))
print("جملهٔ برنده:", sentences[best])
تعداد جمله: 7
بهترین شباهت: 0.46
جملهٔ برنده: اگر با خودرو می‌روی، زنجیرچرخ را حتی در اواخر پاییز همراه داشته باش چون جاده‌های کوهستانی یخ می‌زنند.

۰٫۳۴ برای کلِ متن، ۰٫۴۶ برای جملهٔ درست — و مهم‌تر از عدد، این است که حالا دقیقاً همان جمله را در دست داری، نه کلِ مقاله را.

آن (?<=[.!?؟؛]) یک lookbehind است: «جایی را ببر که بعد از یکی از این نشانه‌هاست»، تا خودِ نقطه به جملهٔ قبلی بچسبد. توجه کن که نقطهٔ فارسی و انگلیسی یکی است ولی علامتِ سؤال (؟) و نقطه‌ویرگول (؛) نویسه‌های جداگانه دارند — اگر جا بیفتند، متنِ فارسی درست تکه نمی‌شود.

اندازهٔ تکه مزیت عیب
خیلی کوچک (یک جمله) بازیابیِ دقیق زمینه گم می‌شود؛ ضمیرها بی‌مرجع می‌مانند
متوسط (چند جمله) تعادلِ معمولِ کارهای واقعی —
خیلی بزرگ (یک صفحه) زمینهٔ کامل معنا میانگین می‌گیرد و بازیابی ضعیف می‌شود

۶. RAG: بازیابی + تولید#

حالا دو تکهٔ ترم را به هم وصل کن. مدلِ زبانیِ فصلِ ۳ متن‌های تو را ندیده. ولی می‌توانی مرتبط‌ترین متن‌ها را پیدا کنی و داخلِ پرامپت بگذاری. اسمِ این الگو RAG است: Retrieval-Augmented Generation — تولیدِ تقویت‌شده با بازیابی.

def build_prompt(question, k=3):
    found = search(question, k)
    context = "\n".join(f"- {text}" for _, text in found)
    return (
        "فقط با تکیه بر متن‌های زیر جواب بده. "
        "اگر جواب در متن‌ها نبود، بنویس «نمی‌دانم».\n\n"
        f"متن‌ها:\n{context}\n\nسؤال: {question}"
    )

print(build_prompt("چطور غذا را خوشمزه کنم"))
فقط با تکیه بر متن‌های زیر جواب بده. اگر جواب در متن‌ها نبود، بنویس «نمی‌دانم».

متن‌ها:
- پیاز را با حرارت ملایم سرخ کن تا شیرینی‌اش دربیاید.
- گوشت را قبل از پختن از یخچال دربیاور تا به دمای اتاق برسد.
- خواب کافی از هر مکمل غذایی بیشتر روی تمرکز اثر دارد.

سؤال: چطور غذا را خوشمزه کنم

این رشته را به ask_model() فصلِ ۳ بده و کارت تمام است. کلِ RAG همین است — بقیهٔ چیزهایی که در این حوزه می‌شنوی، بهبودِ همین سه قدم‌اند: بازیابیِ بهتر، تکه‌کردنِ بهتر، پرامپتِ بهتر.

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

۷. جایی که خاموش شکست می‌خورد#

score, text = search("قیمت دلار امروز چند است", 1)[0]
print("بالاترین شباهت:", round(score, 2))
print("چیزی که برگرداند:", text)
بالاترین شباهت: 0.17
چیزی که برگرداند: برای اینکه برنج شفته نشود، آب را دقیقاً اندازه بگیر.

جوابِ این سؤال در پیکرهٔ ما نیست. ولی search بی‌هیچ اعتراضی یک جملهٔ آشپزی برگرداند، چون کارش این است که «شبیه‌ترین» را بدهد — و شبیه‌ترین، حتی وقتی هیچ ربطی ندارد، باز هم وجود دارد.

هیچ خطایی نگرفتی. هیچ هشداری ندیدی. جوابِ غلط دقیقاً شکلِ جوابِ درست را دارد. این خطرناک‌ترین حالت در کلِ این ترم است.

def search_with_floor(question, k=3, floor=0.30):
    found = [(s, t) for s, t in search(question, k) if s >= floor]
    return found or None

print("سؤال بی‌ربط:", search_with_floor("قیمت دلار امروز چند است"))
print("سؤال مرتبط:", len(search_with_floor("چطور غذا را خوشمزه کنم")), "متن")
سؤال بی‌ربط: None
سؤال مرتبط: 3 متن

⚠️ مواظب باش: عددِ ۰٫۳۰ را من از هوا نگرفتم و تو هم نباید بگیری. آن را از همان مجموعهٔ ارزیابیِ بخشِ ۴ درمی‌آورند: پایین‌ترین شباهتِ یک بازیابیِ درست را ببین، بالاترین شباهتِ یک بازیابیِ غلط را ببین، و آستانه را بینشان بگذار. اگر این دو با هم هم‌پوشانی داشتند، هیچ آستانه‌ای نجاتت نمی‌دهد و باید سراغِ مدلِ بهتر یا تکه‌کردنِ بهتر بروی. و آستانه با هر تغییرِ مدل یا پیکره باید دوباره سنجیده شود — عددی که برای یک مجموعه درست بود، برای مجموعهٔ بعدی معنا ندارد.

۸. ذخیرهٔ index#

ساختنِ index هزینه دارد. برای بیست جمله یک لحظه است، برای بیست هزار سند نه.

np.save("index.npy", index)
loaded = np.load("index.npy")

print("همان چیزی که ذخیره شد:", bool(np.array_equal(index, loaded)))
print("اندازه بازخوانی‌شده:", loaded.shape)
همان چیزی که ذخیره شد: True
اندازه بازخوانی‌شده: (20, 384)

🔧 اگر کار نکرد: سه قاعده که نقضشان همیشه دردسر می‌سازد. یک: ترتیبِ index باید دقیقاً ترتیبِ docs باشد — اگر جدولت را دوباره مرتب کنی و index را از نو نسازی، هر جوابی متنِ اشتباه را نشان می‌دهد و هیچ خطایی نمی‌گیری. دو: برداری که با یک مدل ساخته شده با بردارِ مدلِ دیگر قابلِ مقایسه نیست؛ نامِ مدل را کنارِ فایل بنویس. سه: روی Colab این فایل با پایانِ جلسه پاک می‌شود؛ اگر لازمش داری، در Google Drive ذخیره‌اش کن.

🤖 از دستیارت بپرس: «تفاوت np.save با np.savez و با pickle چیست و کدام برای ذخیرهٔ آرایهٔ عددی مناسب‌تر است؟» بعد جوابش را با آزمایش بسنج: هر سه را امتحان کن و اندازهٔ فایل و زمانِ بارگذاری را مقایسه کن. و اگر دربارهٔ pickle هشدارِ امنیتی نداد، خودت جست‌وجویش کن — یکی از مواردی است که دستیارها اغلب نمی‌گویند مگر بپرسی.

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

کلمه تلفظ به حروف فارسی یعنی چه
index ایندکس مجموعهٔ از پیش ساخته‌شدهٔ بردارهای متن‌ها
retrieval ری‌تریول پیدا کردنِ مرتبط‌ترین متن‌ها برای یک سؤال
chunking چانکینگ تکه‌کردنِ متنِ بلند قبل از ساختِ بردار
overlap اورلپ هم‌پوشانیِ تکه‌ها، تا مطلبِ سرِ مرز گم نشود
RAG رَگ بازیابی + دادنِ متن‌های یافته به مدل برای تولیدِ جواب
top-k تاپ-کِی k نتیجهٔ برتر

تمرین‌ها

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

در فصل بعد#

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

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

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