# فصل ۰۴ — تولیدِ تصویر: `diffusion`

<div dir="rtl">

# فصل ۰۴ — تولیدِ تصویر: `diffusion`

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

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

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

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

![تصویری که از میانِ نویز کم‌کم بیرون می‌آید](/lesson-assets/t6-s04-diffusion/prompt/01-image-out-of-noise.png)

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

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

## قبل از شروع

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

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

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

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/zharfa/term-6-going-further/session-04-diffusion.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

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

</div>

```python
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)])
```

<div dir="rtl">

</div>

```text
داده: (1797, 64) · بازهٔ مقدارها: -1.0 تا 1.0
ᾱ در گام‌های ۰، ۵۰، ۱۰۰، ۱۹۹: [0.9999, 0.8756, 0.5964, 0.1322]
```

<div dir="rtl">

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

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

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

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
  T= 200: ᾱ پایانی 0.13218 · سهمِ تصویرِ اصلی 0.3636
  T= 500: ᾱ پایانی 0.00635 · سهمِ تصویرِ اصلی 0.0797
  T=1000: ᾱ پایانی 0.00004 · سهمِ تصویرِ اصلی 0.0064
```

<div dir="rtl">

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

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

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
  t=  0: سهمِ تصویرِ اصلی 1.000 · انحرافِ معیارِ نتیجه 0.655
  t= 50: سهمِ تصویرِ اصلی 0.936 · انحرافِ معیارِ نتیجه 0.681
  t=100: سهمِ تصویرِ اصلی 0.772 · انحرافِ معیارِ نتیجه 0.667
  t=199: سهمِ تصویرِ اصلی 0.364 · انحرافِ معیارِ نتیجه 0.856
```

<div dir="rtl">

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

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

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

> 🌱 **ریشه‌اش کجاست:** اینکه جمعِ چند متغیرِ تصادفیِ مستقلِ گاوسی باز هم گاوسی است، از خانوادهٔ همان چیزی است که در [ریشه ترمِ ۶ فصل ۷](/courses/risheh/lessons/term-6-probability-statistics/session-07-distributions) دربارهٔ شکلِ توزیع‌ها دیدی. **و ضریبِ `sqrt` هم بی‌دلیل نیست: واریانس‌ها جمع می‌شوند، نه انحرافِ معیارها** — پس برای اینکه واریانسِ کل ثابت بماند، ضریب‌ها باید ریشه‌ای باشند.

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

</div>

```python
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()))
```

<div dir="rtl">

</div>

```text
پارامترها: 218432
```

<div dir="rtl">

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

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

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

## ۴. آموزش

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
  دورهٔ 100: زیان 0.4204
  دورهٔ 200: زیان 0.3376
  دورهٔ 300: زیان 0.3114
```

<div dir="rtl">

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

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

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

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
  گام‌ها       MSE حدسِ نویز
    0 تا 20   0.9447
   20 تا 50   0.6377
   50 تا 100  0.3055
  100 تا 150  0.1635
  150 تا 200  0.1315
```

<div dir="rtl">

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

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

</div>

```python
@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()
```

<div dir="rtl">

</div>

```text
هشت تصویرِ ساخته‌شده از نویزِ محض:
   ··▒███··
   ··████··
   ▒▒·▒█···
   ···██···
   ··▒█▒···
   ··███▒··
   ··█·█▒··
   ··███···

   ··████··
   ··█▒·▒··
   ·▒·▒▒···
   ···█▒···
   ···█·██·
   ·····██·
   ··▒·██▒·
   ··██▒█▒·
```

<div dir="rtl">

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

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

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

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

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

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

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
دقتِ داورِ ما روی دادهٔ واقعی: 0.9961
  میانگینِ اطمینانِ داور — واقعی 0.9573 · ساخته‌شده 0.6143 · نویزِ محض 0.6592
```

<div dir="rtl">

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

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

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

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

## ۷. `guidance`، با عدد

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

</div>

```python
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}")
```

<div dir="rtl">

</div>

```text
   guidance دقت روی کلاسِ خواسته‌شده
        0.0                   0.7850
        1.0                   0.7850
        2.0                   0.9900
        4.0                   1.0000
```

<div dir="rtl">

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

**فرمولِ `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` یک ابرپارامترِ دیگر است با بده‌بستانِ آشنا: وفاداری به شرط در برابرِ تنوع.**

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

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

</div>

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

<div dir="rtl">

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

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

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

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

</div>

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

<div dir="rtl">

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

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

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا مدل به‌جای تصویرِ تمیز، **نویز** را پیش‌بینی می‌کند؟

**تمرینِ اجباری:** `T` را ۵۰ و ۲۰۰ و ۵۰۰ بگذار (با همان تعدادِ دورهٔ آموزش) و برای هر کدام **دو عدد** بده: دقتِ کلاسِ خواسته‌شده با `guidance=2`، و زمانِ یک بار نمونه‌گیریِ ۲۰تایی. **از کدام `T` به بعد کیفیت دیگر بهتر نمی‌شود؟** آن نقطه، انتخابِ عملیِ توست.

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

## در فصل بعد

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

</div>

---
Source: https://yaadestan.com/courses/zharfa/lessons/t6/s04-diffusion (یادستان, Yaadestan)
