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

فصل ۴ از ۷

پیشرفت ترم
۰٪

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

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

و کلِ ایده سه سطر ریاضی است. یک شبکهٔ ۲۱۸ هزار پارامتری آموزش می‌دهیم که فقط بلد است نویز را حدس بزند، و از دلِ نویزِ محض رقم بیرون می‌کشیم. بعد سراغِ guidance می‌رویم و می‌بینیم که دقتِ تولیدِ کلاسِ خواسته‌شده از ۷۸ درصد به ۱۰۰ درصد می‌رود.

و در راه، یک متریکِ به‌ظاهر معقول را می‌سازیم که شکست می‌خورد — نویزِ محض از تصویرهای ساخته‌شدهٔ ما نمرهٔ بهتری می‌گیرد. آن شکست، آموزنده‌ترین بخشِ فصل است.

تصویری که از میانِ نویز کم‌کم بیرون می‌آید

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

  • فرآیندِ نویز و حذفِ نویز را پیاده کنی
  • بگویی مدل دقیقاً چه چیزی را پیش‌بینی می‌کند و چرا
  • guidance را بسازی و اثرش را اندازه بگیری
  • کیفیتِ تولید را با یک متریک بسنجی — و بفهمی کِی آن متریک دروغ می‌گوید

قبل از شروع#

از ترمِ ۲ فصل ۲: همان رقم‌های ⁦۸×۸⁩.

از ترمِ ۱ فصل ۶: MSELoss. از ترمِ ۴ فصل ۱: nn.Embedding برای شرط دادن.

💡 نکته: زمانِ تخمینی روی CPU: دو تا چهار دقیقه. بخشِ آخر چهار بار نمونه‌گیریِ کامل انجام می‌دهد و کندترین قسمت است.

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

۱. برنامهٔ نویز#

import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression

digits = load_digits()
X = torch.tensor(digits.images.reshape(-1, 64), dtype=torch.float32) / 8.0 - 1.0
y = torch.tensor(digits.target)
print("داده:", tuple(X.shape), "· بازهٔ مقدارها:", f"{float(X.min()):.1f}", "تا", f"{float(X.max()):.1f}")

T = 200
betas = torch.linspace(1e-4, 0.02, T)
alphas = 1.0 - betas
abar = torch.cumprod(alphas, dim=0)
print("ᾱ در گام‌های ۰، ۵۰، ۱۰۰، ۱۹۹:",
      [round(float(abar[i]), 4) for i in (0, 50, 100, 199)])
داده: (1797, 64) · بازهٔ مقدارها: -1.0 تا 1.0
ᾱ در گام‌های ۰، ۵۰، ۱۰۰، ۱۹۹: [0.9999, 0.8756, 0.5964, 0.1322]

داده را به بازهٔ ‎−۱ تا ۱ بردیم، چون نویزی که اضافه می‌کنیم میانگینِ صفر دارد. اگر داده در بازهٔ ۰ تا ۱ می‌ماند، مرکزش با مرکزِ نویز نمی‌خواند و مدل باید این جابه‌جایی را هم یاد بگیرد — کارِ اضافه، بی‌دلیل.

و abar (که ᾱ می‌نویسندش) قلبِ ماجراست: ریشهٔ دومش می‌گوید در هر گام چه کسری از تصویرِ اصلی باقی مانده. از ۰٫۹۹۹۹ شروع می‌شود و به ۰٫۱۳ می‌رسد، پس سهمِ تصویر در پایان حدودِ ۰٫۳۶ است؛ همان عددی که جدولِ بخشِ ۲ نشان می‌دهد.

و آن دو عددِ 1e-4 و 0.02 را از خودمان درنیاورده‌ایم: برنامهٔ خطیِ استانداردِ همان مقالهٔ اولِ diffusion است. آنجا با T=1000 به کار می‌روند و ᾱ پایانی واقعاً نزدیکِ صفر می‌شود، تا نمونه‌گیری از نویزِ محض کارِ درستی باشد. ما با T=200 به آن نقطه نمی‌رسیم: در گامِ آخر هنوز بخشی از تصویر مانده، و با این حال نمونه‌گیری را از نویزِ محض شروع می‌کنیم. روی این دادهٔ کوچک کار می‌کند، ولی یک میان‌بُر است.

for steps_T in (200, 500, 1000):
    end = float(torch.cumprod(1 - torch.linspace(1e-4, 0.02, steps_T), dim=0)[-1])
    print(f"  T={steps_T:>4}: ᾱ پایانی {end:.5f} · سهمِ تصویرِ اصلی {end ** 0.5:.4f}")
  T= 200: ᾱ پایانی 0.13218 · سهمِ تصویرِ اصلی 0.3636
  T= 500: ᾱ پایانی 0.00635 · سهمِ تصویرِ اصلی 0.0797
  T=1000: ᾱ پایانی 0.00004 · سهمِ تصویرِ اصلی 0.0064

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

۲. نویزی کردن، در یک قدم#

def add_noise(x0, t, noise):
    """x_t را در یک قدم می‌سازد — بدونِ حلقه."""
    a = abar[t].unsqueeze(1)
    return a.sqrt() * x0 + (1 - a).sqrt() * noise


torch.manual_seed(0)
sample = X[:1]
for step in (0, 50, 100, 199):
    t = torch.tensor([step])
    noisy = add_noise(sample, t, torch.randn_like(sample))
    keep = float(abar[step].sqrt())
    print(f"  t={step:>3}: سهمِ تصویرِ اصلی {keep:.3f} · انحرافِ معیارِ نتیجه {float(noisy.std()):.3f}")
  t=  0: سهمِ تصویرِ اصلی 1.000 · انحرافِ معیارِ نتیجه 0.655
  t= 50: سهمِ تصویرِ اصلی 0.936 · انحرافِ معیارِ نتیجه 0.681
  t=100: سهمِ تصویرِ اصلی 0.772 · انحرافِ معیارِ نتیجه 0.667
  t=199: سهمِ تصویرِ اصلی 0.364 · انحرافِ معیارِ نتیجه 0.856

این تابع مهم‌ترین ترفندِ کلِ diffusion است، و ارزشِ ایستادن دارد.

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

بدونِ این ترفند، آموزش دویست برابر کندتر می‌شد. با آن، برای هر نمونه یک t تصادفی می‌گیریم و در یک ضرب به همان‌جا می‌رویم.

🌱 ریشه‌اش کجاست: اینکه جمعِ چند متغیرِ تصادفیِ مستقلِ گاوسی باز هم گاوسی است، از خانوادهٔ همان چیزی است که در ریشه ترمِ ۶ فصل ۷ دربارهٔ شکلِ توزیع‌ها دیدی. و ضریبِ sqrt هم بی‌دلیل نیست: واریانس‌ها جمع می‌شوند، نه انحرافِ معیارها — پس برای اینکه واریانسِ کل ثابت بماند، ضریب‌ها باید ریشه‌ای باشند.

۳. مدلی که فقط نویز را حدس می‌زند#

class Denoiser(nn.Module):
    def __init__(self, dim=256, classes=10):
        super().__init__()
        self.time = nn.Embedding(T, dim)
        self.label = nn.Embedding(classes + 1, dim)   # کلاسِ آخر یعنی «بدونِ شرط»
        self.net = nn.Sequential(
            nn.Linear(64 + dim, dim), nn.SiLU(),
            nn.Linear(dim, dim), nn.SiLU(),
            nn.Linear(dim, 64))

    def forward(self, x, t, c):
        h = self.time(t) + self.label(c)
        return self.net(torch.cat([x, h], dim=1))


torch.manual_seed(0)
model = Denoiser()
print("پارامترها:", sum(p.numel() for p in model.parameters()))
پارامترها: 218432

سه ورودی دارد و هر سه لازم‌اند:

  • x — تصویرِ نویزی.
  • t — در کدام گامِ نویز هستیم. بدونِ این، مدل نمی‌داند باید کمی نویز بردارد یا خیلی زیاد. جا انداختنِ t رایج‌ترین اشتباهِ اولین پیاده‌سازیِ آدم است.
  • c — کلاسِ خواسته‌شده، به‌علاوهٔ یک شناسهٔ اضافی برای «بدونِ شرط». آن یکی در بخشِ ۷ کارِ اصلی را می‌کند.

و خروجی‌اش تصویر نیست — نویز است. مدل نمی‌گوید «تصویرِ تمیز این است»؛ می‌گوید «نویزی که به این تصویر اضافه شده این بود». این انتخاب عمدی است و در عمل بهتر جواب می‌دهد، چون هدفش همیشه یک توزیعِ ثابت و ساده است، نه تصویرهایی با آماری متفاوت در هر گام.

۴. آموزش#

torch.manual_seed(0)
opt = torch.optim.Adam(model.parameters(), lr=2e-3)
NO_LABEL = 10

for epoch in range(1, 301):
    idx = torch.randint(0, len(X), (128,))
    x0, labels = X[idx], y[idx]
    labels = torch.where(torch.rand(len(idx)) < 0.15, NO_LABEL, labels)
    t = torch.randint(0, T, (len(idx),))
    noise = torch.randn_like(x0)
    loss = F.mse_loss(model(add_noise(x0, t, noise), t, labels), noise)
    opt.zero_grad()
    loss.backward()
    opt.step()
    if epoch % 100 == 0:
        print(f"  دورهٔ {epoch:>3}: زیان {float(loss):.4f}")
  دورهٔ 100: زیان 0.4204
  دورهٔ 200: زیان 0.3376
  دورهٔ 300: زیان 0.3114

کلِ حلقهٔ آموزش شش سطر است و هیچ چیزِ عجیبی در آن نیست: یک MSE معمولی بینِ نویزِ واقعی و نویزِ حدس‌زده‌شده.

آن سطرِ torch.where مهم‌ترین سطرِ فصل است: با احتمالِ ۱۵ درصد، برچسب را دور می‌ریزیم و به‌جایش «بدونِ شرط» می‌گذاریم. پس یک مدل داریم که هم بلد است با شرط کار کند هم بدونِ شرط — و بخشِ ۷ از تفاوتِ همین دو حالت guidance می‌سازد.

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

torch.manual_seed(1)
print("  گام‌ها       MSE حدسِ نویز")
with torch.no_grad():
    for low, high in [(0, 20), (20, 50), (50, 100), (100, 150), (150, 200)]:
        total = 0.0
        for _ in range(30):
            idx = torch.randint(0, len(X), (256,))
            t = torch.randint(low, high, (256,))
            noise = torch.randn_like(X[idx])
            total += float(F.mse_loss(model(add_noise(X[idx], t, noise), t, y[idx]), noise))
        print(f"  {low:>3} تا {high:<3}  {total / 30:.4f}")
  گام‌ها       MSE حدسِ نویز
    0 تا 20   0.9447
   20 تا 50   0.6377
   50 تا 100  0.3055
  100 تا 150  0.1635
  150 تا 200  0.1315

خطا از ۰٫۹۴ در گام‌های اول به ۰٫۱۳ در گام‌های آخر می‌آید. عددِ گزارش‌شدهٔ آموزش میانگینِ همهٔ این‌هاست، و زیانِ حدودِ ۰٫۳ برای این اندازه مدل نتیجهٔ سالمی است.

۵. حالا از نویز، تصویر بساز#

@torch.no_grad()
def sample_images(n, label=None, guidance=0.0, seed=0):
    torch.manual_seed(seed)
    x = torch.randn(n, 64)
    want = torch.full((n,), NO_LABEL if label is None else label)
    blank = torch.full((n,), NO_LABEL)
    for step in reversed(range(T)):
        t = torch.full((n,), step)
        eps = model(x, t, want)
        if guidance > 0:
            eps = model(x, t, blank) + guidance * (eps - model(x, t, blank))
        mean = (x - (1 - alphas[step]) / (1 - abar[step]).sqrt() * eps) / alphas[step].sqrt()
        x = mean if step == 0 else mean + betas[step].sqrt() * torch.randn_like(x)
    return x.clamp(-1, 1)


made = sample_images(8)
print("هشت تصویرِ ساخته‌شده از نویزِ محض:")
for row in made[:2]:
    grid = row.reshape(8, 8)
    for line in grid:
        print("   " + "".join("█" if v > 0.2 else ("▒" if v > -0.4 else "·") for v in line))
    print()
هشت تصویرِ ساخته‌شده از نویزِ محض:
   ··▒███··
   ··████··
   ▒▒·▒█···
   ···██···
   ··▒█▒···
   ··███▒··
   ··█·█▒··
   ··███···

   ··████··
   ··█▒·▒··
   ·▒·▒▒···
   ···█▒···
   ···█·██·
   ·····██·
   ··▒·██▒·
   ··██▒█▒·

از ۶۴ عددِ کاملاً تصادفی شروع کردیم و چیزی بیرون آمد که شکلِ رقم دارد.

حلقهٔ نمونه‌گیری از آخر به اول می‌رود و در هر گام دو کار می‌کند: نویز را حدس بزن و کمی از آن را بردار (mean)، بعد کمی نویزِ تازه اضافه کن (+ betas.sqrt() * randn).

و صادق باشم دربارهٔ آن خطِ mean: ضریب‌هایش را اینجا اثبات نمی‌کنیم. این فرمولِ استانداردِ DDPM است و اثباتش چند صفحه احتمالِ شرطی می‌خواهد که بیرون از این دوره است. آنچه باید بفهمی شکلش است، نه ضریب‌هایش: «نویزِ حدس‌زده را به‌اندازهٔ همان کسری که در این گام اضافه شده بود کم کن، بعد دوباره به مقیاسِ گامِ قبل برگرد». تقسیم بر alphas[step].sqrt() دقیقاً همین برگرداندنِ مقیاس است، قرینهٔ همان a.sqrt() * x0 که در add_noise نوشتیم.

آن اضافه کردنِ نویزِ تازه عجیب به‌نظر می‌رسد ولی حیاتی است: بدونش هر بار از یک نقطهٔ شروع، همیشه همان تصویر درمی‌آید و مدل تنوعش را از دست می‌دهد. در گامِ آخر (step == 0) اضافه نمی‌کنیم، چون خروجیِ نهایی باید تمیز باشد.

۶. متریکی که دروغ گفت#

چطور بسنجیم که این‌ها «رقمِ خوبی» هستند؟ ایدهٔ ساده: یک طبقه‌بند روی رقم‌های واقعی آموزش بده و ببین چقدر با اطمینان تصویرهای ما را دسته‌بندی می‌کند.

judge = LogisticRegression(max_iter=3000).fit(X.numpy(), y.numpy())
print("دقتِ داورِ ما روی دادهٔ واقعی:", f"{judge.score(X.numpy(), y.numpy()):.4f}")

real_conf = judge.predict_proba(X[:200].numpy()).max(axis=1).mean()
fake_conf = judge.predict_proba(sample_images(200).numpy()).max(axis=1).mean()
noise_conf = judge.predict_proba(torch.randn(200, 64).clamp(-1, 1).numpy()).max(axis=1).mean()
print(f"  میانگینِ اطمینانِ داور — واقعی {real_conf:.4f} · ساخته‌شده {fake_conf:.4f} · نویزِ محض {noise_conf:.4f}")
دقتِ داورِ ما روی دادهٔ واقعی: 0.9961
  میانگینِ اطمینانِ داور — واقعی 0.9573 · ساخته‌شده 0.6143 · نویزِ محض 0.6592

📏 اندازه بگیر: نویزِ محض نمرهٔ بالاتری گرفت از تصویرهای ساخته‌شدهٔ ما (۰٫۶۶ در برابرِ ۰٫۶۱). این متریک بی‌ارزش است.

و دلیلش دقیقاً همان چیزی است که در سرنخ ترمِ ۳ دربارهٔ اطمینانِ مدل خواندی: طبقه‌بندِ خطی روی ورودی‌هایی که هیچ شباهتی به دادهٔ آموزشش ندارند هم با اطمینان نظر می‌دهد. اطمینانِ بالا یعنی «از مرزِ تصمیم دور است»، نه «معتبر است». نویزِ تصادفی به‌راحتی خیلی دور از مرز می‌افتد.

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

پس متریکِ بهتری لازم داریم — و بخشِ بعد یکی دارد که واقعاً کار می‌کند.

۷. guidance، با عدد#

متریکِ درست: از مدل بخواه رقمِ مشخصی بسازد، و ببین داور همان را می‌خواند یا نه. این دیگر دربارهٔ «اطمینان» نیست، دربارهٔ درست بودن است.

print(f"  {'guidance':>9} {'دقت روی کلاسِ خواسته‌شده':>24}")
for guidance in (0.0, 1.0, 2.0, 4.0):
    hits = 0
    for label in range(10):
        images = sample_images(20, label=label, guidance=guidance, seed=label)
        hits += int((judge.predict(images.numpy()) == label).sum())
    print(f"  {guidance:>9} {hits / 200:>24.4f}")
   guidance دقت روی کلاسِ خواسته‌شده
        0.0                   0.7850
        1.0                   0.7850
        2.0                   0.9900
        4.0                   1.0000

۷۸ درصد شد ۱۰۰ درصد.

فرمولِ guidance را دوباره نگاه کن: eps_blank + w × (eps_cond − eps_blank). آن تفریق، جهتی است که «با شرط» را از «بدونِ شرط» جدا می‌کند — و w می‌گوید چند برابرِ آن جهت را برداریم. w=۱ یعنی دقیقاً همان eps_cond، w=۴ یعنی چهار برابر در آن جهت اغراق کن.

✅ چک کن: guidance=0 و guidance=1 باید عددِ کاملاً یکسان بدهند — و در جدولِ بالا هم می‌دهند (۰٫۷۸۵۰). این تصادفی نیست: با w=۱ فرمول به eps_cond ساده می‌شود. اگر پیشِ تو این دو ردیف فرق داشتند، جایی در پیاده‌سازی‌ات اشتباه است — احتمالاً blank را درست نساخته‌ای.

و بهایش را هم بدان، چون رایگان نیست:

  • w بالا تنوع را می‌کشد. همهٔ «سه»هایت شبیهِ هم می‌شوند — نمونهٔ «معمولی‌ترِ» آن کلاس. دقتِ ۱٫۰ یعنی هیچ نمونهٔ غیرمعمولی باقی نمانده.
  • w خیلی بالا تصویر را خراب می‌کند (اشباع، لبه‌های تیزِ غیرطبیعی).
  • و هزینهٔ محاسبه بیشتر است، چون در هر گام مدل را برای هر دو حالت صدا می‌زنی. کدِ ما حتی سه بار صدا می‌زند، چون model(x, t, blank) را در سطرِ guidance دو بار نوشته‌ایم؛ اگر نتیجه‌اش را در یک متغیر نگه داری، دو بار می‌شود و جواب هم عوض نمی‌شود.

پس guidance یک ابرپارامترِ دیگر است با بده‌بستانِ آشنا: وفاداری به شرط در برابرِ تنوع.

۸. از این اسباب‌بازی تا مدل‌های واقعی#

آنچه ساختی از نظرِ مفهومی همان چیزی است که مدل‌های تولیدِ تصویرِ امروزی می‌کنند. تفاوت‌ها در مقیاس و مهندسی‌اند:

چیزی که ما کردیم چیزی که آن‌ها می‌کنند
MLP روی ۶۴ پیکسل U-Net یا transformer روی میلیون‌ها پیکسل
شرط = یکی از ده کلاس شرط = بردارِ متنِ آزاد، از یک مدلِ زبانی
نویز روی خودِ پیکسل نویز در یک فضای فشرده (latent)، ده‌ها برابر ارزان‌تر
۲۰۰ گامِ نمونه‌گیری نمونه‌گیرهای هوشمند، ۲۰ تا ۵۰ گام
۱۷۹۷ تصویر صدها میلیون تصویر از اینترنت

و آن سطرِ آخر، بحثِ حقِ مؤلف را می‌آورد که نمی‌شود از کنارش رد شد:

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

دادهٔ ما مشکلی ندارد — رقم‌های دست‌نویسی که برای پژوهش منتشر شده‌اند. این را عمداً انتخاب کردیم.

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

کلمه تلفظ به حروف فارسی یعنی چه
diffusion دیفیوژن ساختنِ تصویر با حذفِ تدریجیِ نویز
forward process فوروارد پراسس نویزی کردنِ تصویر طبقِ یک برنامهٔ معلوم
noise schedule نویز اسکجول اینکه در هر گام چقدر نویز اضافه شود
denoiser دی‌نویزر شبکه‌ای که نویزِ اضافه‌شده را حدس می‌زند
classifier-free guidance گایدنس بدونِ طبقه‌بند اغراق در تفاوتِ «با شرط» و «بدونِ شرط»
latent diffusion لیتنت دیفیوژن اجرای همین فرآیند در فضای فشرده به‌جای پیکسل

🔧 اگر کار نکرد: اگر خروجی نویزِ محض ماند، احتمالاً t را به مدل نداده‌ای یا در حلقهٔ نمونه‌گیری از اول به آخر رفته‌ای به‌جای برعکس — reversed را چک کن. اگر همهٔ تصویرها یکسان درآمدند، نویزِ گامِ میانی را اضافه نکرده‌ای. و اگر IndexError گرفتی، t را برابرِ T فرستاده‌ای؛ بازهٔ درست 0 تا T-1 است.

🤖 از دستیارت بپرس: «چرا مدل‌های امروزی نویز را در فضای latent اضافه می‌کنند و نه روی پیکسل؟» بعد این را بپرس: «این کار چه چیزی را از دست می‌دهد؟» — و آنجا با بده‌بستانِ همیشگی روبه‌رو می‌شوی: سرعت در برابرِ جزئیاتِ ریز، همان چیزی که در quantization فصلِ ۲ هم دیدی.

تمرین‌ها

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

در فصل بعد#

شش ترم مدل ساختیم و هیچ‌کدام از نوت‌بوک بیرون نیامد. فصلِ بعد یک مدل را سرو می‌کنیم: یک سرورِ واقعیِ HTTP که خودت می‌نویسی، با اندازه‌گیریِ تأخیر و گذردهی — و می‌بینی که دسته‌ای کردنِ درخواست‌ها گذردهی را چند برابر می‌کند بدونِ اینکه یک خط از مدل عوض شود.

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

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