12  Ders 9B — Diffusion’ın Matematiği (Waseem + Tanishq)

Misafir ders: Waseem (fastai) ve Tanishq (Stability AI), DDPM makalesinin korkutucu görünen notasyonunu satır satır açar. q() bir olasılık yoğunluk fonksiyonudur; q(x⁰) veri dağılımı = Ders 9’un sihirli API’si; forward process her adımda βₜ kadar Gaussian gürültü ekleyen bir Markov zinciridir; reparameterization (x = μ + σ·ε) Gaussian’dan örneklemeyi kolaylaştırır. Forward kolay, reverse zor — Part 2’nin geri kalanı reverse’i öğrenen ağı sıfırdan kuracak.

NotBölüm bilgisi
  • Ders sayfası (video): course.fast.ai — Lesson 9B: Math of Diffusion (~51 dk, misafirler: Waseem + Tanishq)
  • Seri: Practical Deep Learning for Coders — Part 2, Ders 9B (Ders 9’un matematiksel eki)
  • Misafir hocalar: Waseem (fastai) + Tanishq (Stability AI)
  • Playlist: Part 2 — Foundations to Stable Diffusion (2022)
  • Notebook: Yok — bu ders, DDPM makalesinin matematiksel notasyonunun yorumudur.
  • Okuma süresi: ~28 dk
  • 🔢 İLK LaTeX dersi: İki block math formülü MathJax ile ($$). Prose içi semboller düz Unicode.

12.1 Bu Derste Ne Var?

Misafir ders. Waseem (fastai) ve Tanishq (Stability AI), DDPM makalesinin matematiğini ve ilk bakışta korkutan notasyonunu açar. Waseem matematik kökenli olmadığını açıkça söyler — ve tam da bu yüzden notasyonu “korkutmadan” yorumlamaya soyunur: her sembol aslında basit bir fikrin kompakt kısaltmasıdır. Ders 9 diffusion’ı sezgiyle, Ders 9A çalışan kodla verdi; bu ders altındaki matematiği gösterir.

Üç temel fikir bu dersin omurgasını kurar:

  1. q() bir olasılık yoğunluk fonksiyonudur — içine bir görüntü ver, sana “ne kadar olası olduğunu” söyleyen bir sayı dönsün. q(x⁰) veri dağılımıdır, q(xₜ | xₜ₋₁) ise koşullu geçiştir (q() yoğunluğu → q(x⁰)).
  2. Forward process = Gaussian geçişli Markov zinciri — her adımda görüntüye azıcık (βₜ kadar) gürültü ekle; ~1000 küçük adımda saf gürültüye var (forward formülü → Markov).
  3. Reparameterization — bir Gaussian’dan örneklemek basittir: birim gürültü al, varyansla ölçekle, ortalamayı ekle (x = μ + σ·ε). Forward kolaydır; asıl zor olan tersini (reverse) öğrenmektir (reparameterization → forward/reverse).

“I don’t have a math background, and so I want to help describe how I think about it and how you can interpret all of these notations.” — Waseem, 1:55

Şekil 28.1 bu yapıyı tek bir yol haritasında birleştirir: q() yoğunluk fonksiyonundan veri dağılımına (= Ders 9’un sihirli API’si), forward process’in Gaussian geçişli Markov zincirine, reparameterization’a ve forward-KOLAY ↔︎ reverse-ZOR karşıtlığına. Tüm zincirin altında Stat 110 yatar: PDF, normal dağılım, koşullu olasılık, Markov.

flowchart TD
    Q["q( ) = olasılık yoğunluk fonksiyonu"]
    Q0["q(x⁰) = veri dağılımı<br/>(= Ders 9 sihirli API)"]
    QT["q(xₜ | xₜ₋₁) = koşullu Gaussian geçiş"]
    FWD["forward process:<br/>N(√(1−βₜ)·xₜ₋₁, βₜ·I)"]
    MARKOV["Gaussian geçişli<br/>Markov zinciri"]
    REPARAM["reparameterization:<br/>x = μ + σ·ε"]
    EASY["forward KOLAY<br/>(bilinen Gaussian)"]
    HARD["reverse ZOR<br/>(öğrenilir)"]
    CONTRAST["forward ↔ reverse<br/>karşıtlığı"]
    STAT["Stat 110: PDF,<br/>normal dağılım, Markov"]

    Q --> Q0
    Q --> QT
    QT --> FWD
    FWD --> MARKOV
    Q0 --> MARKOV
    MARKOV --> REPARAM
    REPARAM --> EASY
    EASY --> CONTRAST
    HARD --> CONTRAST
    STAT --> Q
    STAT --> QT

    classDef cyan fill:#cffafe,stroke:#0e7490,stroke-width:2px,color:#1e293b;
    classDef rose fill:#ffe4e6,stroke:#e11d48,stroke-width:2px,color:#1e293b;

    class Q,Q0,QT,REPARAM,EASY,CONTRAST,STAT cyan;
    class FWD,MARKOV,HARD rose;
Şekil 12.1: Diffusion’ın matematiği kavram haritası: q() yoğunluk fonksiyonu → veri dağılımı (= Ders 9 sihirli API), forward process’in Gaussian geçişli Markov zinciri, reparameterization, ve forward-KOLAY ↔︎ reverse-ZOR karşıtlığı. Kaynak: Stat 110 (PDF, normal dağılım, Markov). (şematik)
İpucuBuilder Notu — Notasyondan Sezgiye: Korkutucu Değil, Kompakt
  • Geriye (Stat 110): Tüm ders Stat 110’un olasılık yoğunluk fonksiyonu, normal dağılım, koşullu olasılık ve Markov zinciri kavramları üstüne kuruludur — yeni bir şey yok, tanıdık parçaların kompakt notasyonu var.
  • İleriye (Part 2 / NYU §4.J): Bu matematik, DDPM (Ders 19) ve Karras (Ders 22) ile sıfırdan koda dökülür; reverse process, NYU’nun score/enerji-tabanlı modelleriyle (§4.J) akrabadır.
  • Tek cümle: Diffusion’ın “korkutucu” notasyonu, “her adımda biraz Gaussian gürültü ekle, sonra geri öğren” fikrinin matematiksel kısaltmasıdır.

12.2 Notasyondan Korkmamak

Waseem’in tezi nettir: makalelerdeki yoğun matematik notasyonu, basit fikirleri kompakt biçimde ifade eder. İlk bakışta korkutur ama her sembolü tek tek açınca arkasındaki sezgi yalındır. Ders, DDPM makalesinin notasyonunu satır satır yorumlar — amaç, builder’ı makale okuyabilir hâle getirmek.

“Simple compact notations implying a lot more than you might [expect].” — Waseem, 4:16

İpucuBuilder Notu — Makale Okuma Becerisi
  • İleriye: Makale okuyabilmek builder için kritik bir beceridir; notasyonu “fikre çevirmek” araştırmayı erişilebilir kılar. Korktuğun her sembol, çözünce bildiğin bir kavrama iner.
  • İleriye (Ders 19): DDPM makalesinin tüm forward/reverse denklemleri, bu dersin açtığı parçalardan (q(), Gaussian, Markov, reparameterization) inşa edilir.

12.3 q() Bir Olasılık Yoğunluk Fonksiyonudur

İlk sembol q. Waseem onu “bir kutu” (fonksiyon) gibi düşünmeyi önerir: içine bir görüntü verirsin, sana bir olasılık (yoğunluk) döner. Olasılık için genelde p kullanılır; bu makalede q tercih edilmiştir ama fikir birebir aynıdır. Yani q, bir görüntünün “ne kadar olası” olduğunu söyleyen bir ölçüdür.

“You can think of it as something that takes images… q is some function.” — Waseem, 2:25

İpucuBuilder Notu — PDF: Stat 110’un Temel Nesnesi
  • Geriye (Stat 110): Olasılık yoğunluk fonksiyonu (PDF), bir değerin ne kadar “olası” olduğunu veren fonksiyondur; Stat 110’un temel nesnesi.
  • Sezgi: q’yu bir API gibi düşün — girdi bir görüntü, çıktı bir olasılık. Bu “API” sezgisi ders boyunca q(x⁰) ve magic API bağlantısında tekrar tekrar dönecek.

12.4 Data Distribution: q(x⁰)

İlk somut tanım q(x⁰) — veri dağılımı. Burada x⁰ “orijinal görüntü”dür (örn. bir MNIST rakamı); üst-simge 0, “gürültü eklenmeden önceki, sıfırıncı adım” demektir. q(x⁰) bir şeyin “gerçek bir görüntü olma olasılığını” verir: gerçek bir rakam yüksek değer, rastgele gürültü düşük değer alır.

“Q of x superscript 0 — they call this the data distribution.” — Waseem, 2:25

İpucuBuilder Notu — q(x⁰) = Ders 9’un Sihirli API’si
  • Geriye (Ders 9): q(x⁰), Ders 9’daki “sihirli API”nin ta kendisidir — “bu geçerli bir görüntü mü?” sorusuna olasılık döndüren fonksiyon. Sezgi (Ders 9) ile matematik (bu ders) aynı nesneyi anlatır.
  • İleriye (sampling): “Veri dağılımından örneklemek” = q(x⁰)’ı yüksek yapan (yüksek olasılıklı) bir görüntü bulmaktır — üretmenin tanımı budur.

12.5 Koşullu Yoğunluk: q(xₜ | xₜ₋₁)

Sonraki tanım q(xₜ | xₜ₋₁). Dikey çizgi ( | ) koşullu olasılığı gösterir: “xₜ₋₁ verildiğinde xₜ’nin dağılımı”. Sezgisel olarak: bir adım önceki görüntüyü al, ona biraz gürültü ekleyerek bir sonrakini üret. Waseem bunu “başka bir sihirli API — görüntü alır, biraz daha gürültülü görüntü verir” diye tanımlar.

“This is a conditional probability density function… you can think of it as something that takes images and produces other images.” — Waseem, 9:06

İpucuBuilder Notu — Koşullu Olasılık: Bir Önceki Adıma Bağlı Geçiş
  • Geriye (Stat 110): Koşullu olasılık P(A | B); burada “bir önceki adıma bağlı” geçiş. q(xₜ | xₜ₋₁) = “xₜ₋₁’i biliyorsan, xₜ ne olur?”.
  • İleriye (forward formülü): Bu koşullu geçiş, az sonra somut bir Gaussian formülüne (N(√(1−βₜ)·xₜ₋₁, βₜI)) dönüşecek — şimdilik “girdi görüntü, çıktı biraz daha gürültülü görüntü” sezgisi yeter.

12.6 Normal (Gaussian) Dağılım

q(xₜ | xₜ₋₁) bir normal (Gaussian) dağılımdır — en bilinen olasılık dağılımı, çan eğrisi. İki parametresi vardır: ortalama (μ, mean) çanın merkezidir, varyans (σ², variance) ne kadar yayıldığını söyler. Standart sapma σ, varyansın kareköküdür; varyans bazen σ² yazılır. Bu iki sayı dağılımı tamamen belirler.

“A Gaussian distribution… the mean and the variance of the normal distribution.” — Tanishq, 8:21

Şekil 12.2 normal dağılımı gerçek hesaplamayla gösterir: üç farklı N(μ, σ²) eğrisi. Ortalama (μ) çanın merkezini kaydırır (dikey çizgi), varyans (σ²) çanın genişliğini belirler (yarı-yükseklikteki yatay ok). μ=0, σ=1 dar/yüksek; σ=2 geniş/alçak; μ=2.5 kaydırılmış. Kavramsal anahtar tek satırda: ortalama = merkez, varyans = yayılım.

Kod 
d = E.gaussian_curves_demo()
x = d["x"]
curves = d["curves"]

# Her eğri için renk + çizgi stili (μ, σ farkını görsel ayırır)
styles = [
    (COL_PRIMARY,    "-",  2.6),   # μ=0, σ=1  — dar/yüksek çan
    (COL_CYAN_400,   "--", 2.4),   # μ=0, σ=2  — geniş/alçak çan
    (COL_ACCENT,     "-.", 2.6),   # μ=2.5, σ=0.8 — kaydırılmış, en dar
]

fig, ax = plt.subplots(figsize=(8, 5))

for (mu, sig, pdf), (col, ls, lw) in zip(curves, styles):
    peak = pdf.max()
    ax.plot(x, pdf, color=col, linestyle=ls, linewidth=lw, zorder=3,
            label=f"N(μ={mu:g}, σ²={sig**2:g})  →  σ={sig:g}")
    # ortalama (μ) konumunda dikey çizgi — çanın merkezi
    ax.vlines(mu, 0, peak, color=col, linestyle=":", linewidth=1.4,
              alpha=0.75, zorder=2)
    # tepe (μ, merkez) etiketi
    ax.annotate(f"μ={mu:g}\n(merkez)", xy=(mu, peak),
                xytext=(mu, peak + 0.045), ha="center", va="bottom",
                fontsize=9, color=col, weight="bold", zorder=5)
    # yayılım (σ, genişlik) — yarı-yükseklikte yatay ok ile σ genişliğini göster
    half = peak / np.sqrt(np.e)          # μ±σ noktasının PDF yüksekliği
    ax.annotate("", xy=(mu + sig, half), xytext=(mu - sig, half),
                arrowprops=dict(arrowstyle="<->", color=col, lw=1.6,
                                shrinkA=0, shrinkB=0), zorder=4)
    ax.text(mu, half + 0.006, f"σ={sig:g}", ha="center", va="bottom",
            fontsize=8.5, color=col, style="italic", zorder=5)

# kavramsal anahtar: ortalama=merkez, varyans=yayılım
ax.text(0.015, 0.97,
        "ortalama (μ) = çanın merkezi\nvaryans (σ²) = çanın yayılımı",
        transform=ax.transAxes, ha="left", va="top", fontsize=9.5,
        color=COL_TEXT, weight="bold",
        bbox=dict(boxstyle="round,pad=0.4", fc=COL_BG_ROSE,
                  ec=COL_ACCENT, lw=1.4))

ax.set_xlabel("x")
ax.set_ylabel("yoğunluk  q(x)")
ax.set_title("Normal dağılım N(μ, σ²): ortalama merkezi, varyans yayılımı belirler",
             fontsize=12, weight="bold")
ax.set_ylim(0, None)
ax.legend(loc="upper right", fontsize=9, framealpha=0.95)
viz.apply_style(ax)
plt.tight_layout()
plt.show()
Şekil 12.2: (gerçek hesaplama: N(μ,σ²) PDF; ortalama merkezi, varyans yayılımı belirler)
İpucuBuilder Notu — N(μ, σ²): İki Sayı, Bütün Dağılım
  • Geriye (Stat 110): Normal dağılım N(μ, σ²); merkezî limit teoremi ve gürültü modellemesinin temeli. μ konumu, σ² yayılımı verir.
  • İleriye (reparameterization): “Sadece μ ve σ” olması, Gaussian’dan örneklemeyi kolaylaştıran tek sebeptir — x = μ + σ·ε formülü doğrudan bu iki parametreyi kullanır.

12.7 Isotropic Kovaryans: βₜ·I

Görüntü tek bir sayı değil, binlerce pikseldir; bu yüzden tek bir varyans yerine bir kovaryans matrisi gerekir. DDPM bunu βₜ·I olarak seçer: I birim matris olduğundan, her pikselin varyansı βₜ, pikseller arası kovaryans sıfırdır — yani her piksele bağımsız ve aynı miktarda gürültü eklenir (isotropic Gaussian).

“We’ve now got a covariance matrix where for each individual pixel it’s beta… and the covariances between the pixels is zero.” — Waseem, 18:38

Şekil 12.3 bunu gerçek hesaplamayla gösterir: sol panel temiz görüntü x₀, orta panel gürültülü √(1−β)·x₀ + √β·ε (β=0.5), sağ panel kovaryans matrisi βₜ·I (6×6) — köşegen β, dışı 0. Mesaj net: her piksele bağımsız, eşit β gürültü; pikseller arası kovaryans sıfır.

Kod 
d = E.isotropic_noise_demo()
clean, noisy, beta, cov = d["clean"], d["noisy"], d["beta"], d["cov"]

fig, (ax0, ax1, ax2) = plt.subplots(1, 3, figsize=(12, 4.5))

# SOL — temiz toy desen (x₀)
ax0.imshow(clean, cmap="cividis", interpolation="nearest")
ax0.set_title("temiz görüntü  x₀", color=COL_CYAN_700, fontsize=12, weight="bold")
ax0.set_xticks([]); ax0.set_yticks([])
for s in ax0.spines.values():
    s.set_edgecolor(COL_PRIMARY); s.set_linewidth(2.0)

# ORTA — gürültülü görüntü  √(1−β)·x₀ + √β·ε
ax1.imshow(noisy, cmap="cividis", interpolation="nearest")
ax1.set_title(f"gürültülü  √(1−β)·x₀ + √β·ε   (β={beta})",
              color=COL_ACCENT, fontsize=12, weight="bold")
ax1.set_xticks([]); ax1.set_yticks([])
for s in ax1.spines.values():
    s.set_edgecolor(COL_ACCENT); s.set_linewidth(2.0)

# SAĞ — kovaryans matrisi βI (6×6 köşegen)
im = ax2.imshow(cov, cmap="Blues", vmin=0.0, vmax=beta, interpolation="nearest")
ax2.set_title("kovaryans  βₜ·I  (6×6)", color=COL_CYAN_700, fontsize=12, weight="bold")
ax2.set_xticks(range(cov.shape[0])); ax2.set_yticks(range(cov.shape[0]))
ax2.tick_params(colors=COL_TEXT, length=0, labelsize=8)
for i in range(cov.shape[0]):
    for j in range(cov.shape[1]):
        v = cov[i, j]
        ax2.text(j, i, f"{v:.1f}", ha="center", va="center", fontsize=8.5,
                 color=(COL_WHITE if i == j else COL_SLATE_400), weight="bold")
ax2.text(0.5, -0.16, "βI: köşegen β, dışı 0", transform=ax2.transAxes,
         ha="center", va="top", fontsize=10, color=COL_TEXT, weight="bold")
for s in ax2.spines.values():
    s.set_edgecolor(COL_PRIMARY); s.set_linewidth(2.0)

# annotate — bağımsız eşit gürültü
fig.text(0.5, 0.015,
         "her piksele BAĞIMSIZ, eşit β gürültü  (pikseller arası kovaryans 0)",
         ha="center", va="bottom", fontsize=10.5, color=COL_ACCENT, weight="bold")

plt.tight_layout(rect=(0, 0.05, 1, 1))
Şekil 12.3: Isotropic gürültü βₜ·I: her piksele bağımsız, eşit β gürültü; kovaryans matrisi köşegen β, dışı 0 (gerçek hesaplama: βₜ·I kovaryans — her piksele bağımsız eşit gürültü; forward √(1−β)·x₀+√β·ε).
İpucuBuilder Notu — βₜ·I: Bağımsız ve Eşit Gürültü
  • Geriye (18.06 / Stat 110): Kovaryans matrisi (18.06); köşegen yapı = bağımsız değişkenler (Stat 110). βₜ·I, “her piksele bağımsız βₜ gürültü” demektir — pikseller birbirinden habersiz bozulur.
  • Builder ipucu: I (birim matris) seçimi rastgele değil; pratik bir basitleştirmedir — gürültüyü tek bir skaler βₜ ile kontrol etmeyi sağlar, noise schedule tam bu βₜ dizisidir.

12.8 Forward Process Formülü

Tüm parçalar birleşince DDPM’in forward (ileri) process formülü çıkar — her adımda biraz gürültü ekleyen Gaussian geçiş. İşte bu dersin ilk block math’i:

\[ q(x_t \mid x_{t-1}) = \mathcal{N}\!\left(x_t;\ \sqrt{1 - \beta_t}\, x_{t-1},\ \beta_t I\right) \]

Waseem uç durumlarla yorumlar: βₜ = 0 ise √(1−0)=1, varyans 0 → aynı görüntü (hiç gürültü yok). βₜ = 1 ise √(1−1)=0, kovaryans I → saf gürültü (ortalama 0, varyans 1). Arada bir yerde: görüntü + biraz gürültü karışımı. Ortalama √(1−βₜ)·xₜ₋₁ sinyali azıcık küçültür, βₜ·I gürültü ekler — her adım minik bir bozulmadır.

“If beta is one… this whole thing becomes zero and this becomes I, which implies a variance of one, so our image would just be pure noise.” — Waseem, 24:42

Şekil 12.4 bu tek adımı dört β değeri için gerçek hesaplamayla gösterir (β = 0, 0.3, 0.7, 1.0) — bu dersin flagship figürüdür. β=0 panelinde xₜ = x₀ (temiz sinyal aynen); β=1 panelinde saf gürültü (sinyal tamamen yok); arada sinyal küçülür (√(1−β)↓), gürültü artar (√β↑). Her panel √(1−β)·sinyal + √β·gürültü dengesini gözle gösterir.

Kod 
d = E.forward_formula_demo(betas=(0.0, 0.3, 0.7, 1.0))
xg = d["x_grid"]
x0 = d["x0"]
cases = d["cases"]

fig, axes = plt.subplots(2, 2, figsize=(11.5, 7), sharex=True, sharey=True)
axes = axes.ravel()

for ax, (b, mc, nc, xt) in zip(axes, cases):
    viz.apply_style(ax)
    # temiz sinyal x₀ (ince cyan referans)
    ax.plot(xg, x0, color=COL_PRIMARY, lw=1.4, alpha=0.85,
            label="x₀ (temiz sinyal)")
    # geçiş çıktısı xₜ (rose, kalın)
    ax.plot(xg, xt, color=COL_ACCENT, lw=2.2,
            label="xₜ (geçiş çıktısı)")
    ax.set_title(f"β={b:g}:  √(1−β)={mc:.2f}·sinyal + √β={nc:.2f}·gürültü",
                 fontsize=10.5, color=COL_CYAN_700, weight="bold")
    ax.axhline(0, color=COL_SLATE_400, lw=0.8, alpha=0.6)

# β=0 paneli: xₜ = x₀ (aynı)
axes[0].annotate("β=0 → xₜ = x₀ (hiç gürültü yok)",
                 xy=(0.5, 1.18), xytext=(0.5, 1.95),
                 ha="center", fontsize=9, color=COL_CYAN_700, weight="bold",
                 arrowprops=dict(arrowstyle="->", color=COL_CYAN_700, lw=1.3))

# β=1 paneli: saf gürültü
axes[3].annotate("β=1 → saf gürültü\n(sinyal tamamen yok)",
                 xy=(0.5, 0.0), xytext=(0.5, 2.0),
                 ha="center", fontsize=9, color=COL_ACCENT, weight="bold",
                 arrowprops=dict(arrowstyle="->", color=COL_ACCENT, lw=1.3))

# "sinyal küçülür / gürültü artar" yönü annotate (orta panelde)
axes[1].annotate("sinyal küçülür (√(1−β)↓)\ngürültü artar (√β↑)",
                 xy=(0.18, -1.6), xytext=(0.18, -2.55),
                 ha="center", fontsize=8.5, color=COL_TEXT, weight="bold",
                 arrowprops=dict(arrowstyle="->", color=COL_TEXT, lw=1.2))

axes[0].legend(loc="lower right", fontsize=8.5, framealpha=0.92)
for ax in (axes[2], axes[3]):
    ax.set_xlabel("konum", fontsize=9.5, color=COL_TEXT)
for ax in (axes[0], axes[2]):
    ax.set_ylabel("değer", fontsize=9.5, color=COL_TEXT)

fig.suptitle("Forward süreç: q(xₜ|xₜ₋₁) = N(√(1−β)·xₜ₋₁,  β·I)",
             fontsize=12.5, color=COL_TEXT, weight="bold", y=0.99)
plt.tight_layout()
plt.show()
Şekil 12.4: Forward sürecin tek adımı, β büyüdükçe sinyali söndürüp gürültüyü büyütür (gerçek hesaplama: q(xₜ|xₜ₋₁)=N(√(1−β)·xₜ₋₁, β·I); β=0 aynı, β=1 saf gürültü).
İpucuBuilder Notu — Her Adım Minik: Sinyal Azalır, Gürültü Artar
  • Geriye (Ders 5): √(1−βₜ)·xₜ₋₁ ortalamayı azıcık küçültür, βₜ·I gürültü ekler; “sinyal biraz azalır, gürültü biraz artar” — her adım minik bir bozulma, ~1000 adımda saf gürültü.
  • İleriye (Ders 9A σ çizelgesi): βₜ dizisi tam Ders 9A’da gördüğün noise schedule’dır; orada σ olarak, çıkarım-zamanı yeniden parametrize edilmiş hâliyle karşılaşırsın.

12.9 Markov Process with Gaussian Transitions

Tüm forward süreç, bu adımların bir zinciridir ve adı “Gaussian geçişli Markov süreci”dir. Waseem terimi üç parçaya ayırır: process = bir dizi (sequence); Markov = T anındaki şey yalnızca T−1 anına bağlıdır (daha öncesine değil); Gaussian = geçişin normal dağılım olması. Üçü birlikte: her biri Gaussian olan, yalnızca bir önceki adıma bağlı geçişlerden oluşan bir zincir.

“When we say Markov it means that the thing at time T depends only on the thing at T minus one; and Gaussian is that the transition is the normal distribution.” — Waseem, 28:26

Şekil 12.5 bu zinciri şematik gösterir: x⁰ (temiz görüntü, cyan) → x¹ → x² → … → x^T (saf gürültü, rose). Her ileri ok bir q(xₜ|xₜ₋₁) geçişi (+βₜ gürültü); geriye doğru kesik rose ok reverse’i (öğrenilir, zor) işaretler. Altta iki anahtar: Markov (xₜ yalnız xₜ₋₁’e bağlı) ve Gaussian (her geçiş N(√(1−βₜ)·xₜ₋₁, βₜ·I)).

Kod 
fig, ax = plt.subplots(figsize=(12, 4.5))

# --- yatay zincir kutuları: x⁰ → x¹ → x² → ... → x^T ---
labels = ["x⁰", "x¹", "x²", "x³", "…", "x^T"]
sub = ["temiz\ngörüntü", "", "", "", "", "saf\ngürültü"]

# x⁰ cyan (temiz), x^T rose (gürültü), aradakiler giderek grileşir
def _blend(c0, c1, t):
    return tuple(c0[i] + (c1[i] - c0[i]) * t for i in range(3))

import matplotlib.colors as mcolors
rgb_cyan = mcolors.to_rgb(COL_CYAN_400)
rgb_rose = mcolors.to_rgb(COL_ROSE_400)
rgb_gray = mcolors.to_rgb(COL_SLATE_300)

n = len(labels)
xs = np.linspace(0.8, 11.2, n)
y_chain = 2.7
bw, bh = 1.25, 1.05

for i, (lab, sb) in enumerate(zip(labels, sub)):
    t = i / (n - 1)
    if i == 0:
        fc, ec, tc = COL_BG, COL_CYAN_700, COL_TEXT          # temiz (cyan)
    elif i == n - 1:
        fc, ec, tc = COL_BG_ROSE, COL_ACCENT, COL_TEXT       # gürültü (rose)
    else:
        # ara kutular giderek grileşir (cyan→gri→rose karışımı)
        fc = mcolors.to_hex(_blend(rgb_cyan, rgb_gray, min(t * 1.4, 1.0)))
        ec = COL_SLATE_400
        tc = COL_TEXT
    txt = lab if not sb else f"{lab}\n{sb}"
    boxed_node(ax, xs[i], y_chain, bw, bh, txt, fc=fc, ec=ec, tc=tc,
               fontsize=11, lw=2.2)

# --- ileri oklar (forward, cyan) + üstünde geçiş etiketi ---
for i in range(n - 1):
    arrow_between(ax, (xs[i], y_chain), (xs[i + 1], y_chain),
                  color=COL_PRIMARY, lw=2.0, shrink=24)
    xm = (xs[i] + xs[i + 1]) / 2.0
    ax.text(xm, y_chain + 0.78, "q(xₜ|xₜ₋₁)", ha="center", va="bottom",
            fontsize=8.5, color=COL_CYAN_700, weight="bold")
    ax.text(xm, y_chain + 0.50, "+βₜ gürültü", ha="center", va="bottom",
            fontsize=8, color=COL_SLATE_400, style="italic")

# --- geriye doğru tek ok: reverse (öğrenilir, zor), kesik rose ---
arrow_between(ax, (xs[-1], y_chain - 0.62), (xs[-2], y_chain - 0.62),
              color=COL_ACCENT, lw=1.8, shrink=24,
              connectionstyle="arc3,rad=-0.35")
ax.text((xs[-1] + xs[-2]) / 2.0, y_chain - 1.55,
        "reverse (öğrenilir, zor)", ha="center", va="top",
        fontsize=8.5, color=COL_ACCENT, weight="bold", style="italic")
# kesikliği vurgulamak için kesik çizgi katmanı
ax.plot([xs[-1], xs[-2]], [y_chain - 0.62, y_chain - 0.62],
        color=COL_ACCENT, lw=1.4, ls=(0, (4, 3)), zorder=1)

# --- alt notlar ---
ax.text(6.0, 0.62,
        "Markov: xₜ yalnızca xₜ₋₁'e bağlı (geçmişe değil)",
        ha="center", va="center", fontsize=10, color=COL_CYAN_700,
        weight="bold")
ax.text(6.0, 0.18,
        "Gaussian: her geçiş normal dağılım  N(√(1−βₜ)·xₜ₋₁, βₜ·I)",
        ha="center", va="center", fontsize=9.5, color=COL_TEXT)

ax.set_xlim(0, 12)
ax.set_ylim(-0.1, 4.0)
ax.axis("off")
plt.tight_layout()
plt.show()
Şekil 12.5: (şematik: forward = Gaussian geçişli Markov zinciri; her adım βₜ gürültü, yalnız önceki adıma bağlı)
İpucuBuilder Notu — Markov: Gelecek Yalnız Şimdiye Bağlı
  • Geriye (Stat 110): Markov zinciri (Stat 110); “gelecek, geçmişe değil yalnızca şimdiye bağlı” özelliği. xₜ’yi hesaplamak için yalnızca xₜ₋₁ yeter, x⁰…xₜ₋₂’ye gerek yok.
  • Sezgi: Bu “hafızasızlık” forward’ı çok ucuzlatır; her adım yerel bir Gaussian gürültü ekleme işlemidir, geçmişin tamamını taşımak gerekmez.

12.10 Reparameterization: Gaussian’dan Örnekleme

Pratik bir nokta: bir Gaussian’dan örneklemek kolaydır. Birim gürültü (ortalama 0, varyans 1) al, istediğin standart sapmayla ölçekle, ortalamayı ekle. İşte bu dersin ikinci block math’i:

\[ x = \mu + \sigma\, \epsilon, \qquad \epsilon \sim \mathcal{N}(0, I) \]

Bu yüzden forward process’i kolayca örnekleyebiliriz — parametreleri (μ, σ) biliyoruz. Kod yazarken de tam böyle yapılır: kütüphaneden N(0,1) örnek al, σ ile ölçekle, μ ile kaydır. Rastgeleliği tek bir ε terimine ayırdığı için gradyan da μ ve σ’dan akabilir.

“Take some normal noise with a mean of zero and variance of one… multiply it by the variance and then add your mean.” — Tanishq, 30:30

Şekil 12.6 bunu gerçek hesaplamayla gösterir: sol panel birim gürültü ε ~ N(0,1) histogramı (ölçülen ort ≈ 0, std ≈ 1); sağ panel x = μ + σ·ε ~ N(μ, σ²) histogramı (ölçülen ort ≈ μ, std ≈ σ). Üstteki ok “ölçekle (×σ), kaydır (+μ)” dönüşümünü; alt not bunun VAE reparameterization trick’i (z = μ + σ·ε) olduğunu vurgular — gürültü dışarıda, gradyan μ ve σ’dan akar.

Kod 
d = E.reparam_demo()
eps, x = d["eps"], d["x"]
mu, sigma = d["mu"], d["sigma"]
x_mean, x_std = d["x_mean"], d["x_std"]

fig, (axL, axR) = plt.subplots(1, 2, figsize=(11.5, 4.8))

# --- SOL: birim gürültü ε ~ N(0,1) (cyan) ---
axL.hist(eps, bins=70, density=True, color=COL_PRIMARY, alpha=0.55,
         edgecolor=COL_CYAN_700, linewidth=0.4, zorder=3)
viz.apply_style(axL)
axL.axvline(0.0, color=COL_CYAN_700, lw=2.0, ls="--", zorder=4)
axL.set_title("ε ~ N(0, 1)  —  birim gürültü", color=COL_CYAN_700,
              fontsize=12, weight="bold")
axL.set_xlabel("ε", fontsize=11)
axL.set_ylabel("yoğunluk", fontsize=11)
axL.set_xlim(-7, 14)
axL.text(0.03, 0.95,
         f"ölçülen:\n  ort ≈ {eps.mean():.2f}\n  std ≈ {eps.std():.2f}",
         transform=axL.transAxes, va="top", ha="left", fontsize=10.5,
         color=COL_TEXT, weight="bold",
         bbox=dict(boxstyle="round,pad=0.4", fc=COL_BG, ec=COL_PRIMARY, lw=1.6))

# --- SAĞ: x = μ + σ·ε ~ N(μ, σ²) (rose) ---
axR.hist(x, bins=70, density=True, color=COL_ACCENT, alpha=0.50,
         edgecolor=COL_ROSE_400, linewidth=0.4, zorder=3)
viz.apply_style(axR)
axR.axvline(mu, color=COL_ACCENT, lw=2.0, ls="--", zorder=4)
axR.set_title("x = μ + σ·ε  ~  N(μ, σ²)", color=COL_ACCENT,
              fontsize=12, weight="bold")
axR.set_xlabel("x", fontsize=11)
axR.set_ylabel("yoğunluk", fontsize=11)
axR.set_xlim(-7, 14)
axR.text(0.97, 0.95,
         f"ölçülen:\n  ort ≈ {x_mean:.2f}  (μ={mu:.0f})\n  std ≈ {x_std:.2f}  (σ={sigma:.0f})",
         transform=axR.transAxes, va="top", ha="right", fontsize=10.5,
         color=COL_TEXT, weight="bold",
         bbox=dict(boxstyle="round,pad=0.4", fc=COL_BG_ROSE, ec=COL_ACCENT, lw=1.6))

# --- Ortada/üstte dönüşüm oku + VAE notu ---
fig.subplots_adjust(top=0.80, wspace=0.28)
con = FancyArrowPatch(
    (0.46, 0.93), (0.56, 0.93), transform=fig.transFigure,
    arrowstyle="-|>", mutation_scale=22, color=COL_CYAN_700, lw=2.4,
    zorder=10,
)
fig.add_artist(con)
fig.text(0.51, 0.965, f"ölçekle (×σ={sigma:.0f}), kaydır (+μ={mu:.0f})",
         ha="center", va="center", fontsize=11, weight="bold",
         color=COL_CYAN_700)
fig.text(0.51, 0.025,
         "= VAE reparameterization trick (z = μ + σ·ε):  gürültü dışarıda, gradyan μ ve σ'dan akar",
         ha="center", va="center", fontsize=10, color=COL_TEXT,
         bbox=dict(boxstyle="round,pad=0.4", fc=COL_BG, ec=COL_PRIMARY, lw=1.4))

plt.tight_layout(rect=[0, 0.05, 1, 0.88])
plt.show()
Şekil 12.6: Reparameterization x = μ + σ·ε: birim gürültü N(0,1)’i σ ile ölçekle, μ ile kaydır → N(μ,σ²). VAE’nin reparameterization trick’inin (z = μ + σ·ε) ta kendisi. (gerçek hesaplama: birim gürültüyü σ ile ölçekle + μ ile kaydır → N(μ,σ²); mean/std doğrulandı)
İpucuBuilder Notu — x = μ + σ·ε: VAE Trick’inin Ta Kendisi
  • Geriye (Ders 4 VAE / Stat 110): Bu, 6.S191 VAE’deki reparameterization trick’in ta kendisidir (z = μ + σ·ε); aynı zamanda Stat 110’daki konum-ölçek dönüşümü. Yeni bir numara değil, tanıdık bir araç.
  • Builder ipucu: Rastgeleliği ε’ya ayırmak, μ ve σ’yı türevlenebilir bırakır — bu yüzden hem VAE hem diffusion eğitiminde gradyan akar; “stochastic node”u dışarı çıkarmanın standart yolu budur.

12.11 Üretken Problem: Forward Kolay, Reverse Zor

Kritik içgörü: forward (gürültü ekleme) kolaydır çünkü Gaussian geçişlerinin parametrelerini (√(1−βₜ), βₜ) biliyoruz ve reparameterization ile anında örnekleriz. Ama biz reverse’i (gürültüden görüntü) istiyoruz — ve veri dağılımı q(x⁰)’dan doğrudan örnekleyemeyiz, çünkü onu bilmiyoruz (tam da öğrenmek istediğimiz şey o). Üretken modellemenin tüm problemi budur: karmaşık veri dağılımını, kolayca örneklenebilir bir biçimde temsil etmek.

“We can’t really sample from this thing — that’s exactly the problem that generative modeling is trying to solve.” — Waseem, 32:20

Çözüm: çok sayıda küçük adımla (örn. 1000) görüntüyü gürültüye çeviren forward süreci, öğrenilebilir biçimde tersine çevirmek.

Şekil 12.7 bu asimetriyi şematize eder: üst sıra FORWARD (kolay) — temiz görüntü x₀ → saf gürültü x_T, “+ Gaussian gürültü, √(1−β) ve β BİLİNİR, reparam ile anında”. Alt sıra REVERSE (zor) — saf gürültü → temiz görüntü, “? gürültü giderme, veri dağılımı BİLİNMEZ, ÖĞRENİLMELİ (bir sinir ağı)”. Ortada üretken modellemenin problemi: reverse’i öğren.

Kod 
fig, ax = plt.subplots(figsize=(11.5, 5.5))
ax.set_xlim(0, 11.5)
ax.set_ylim(0, 5.5)
ax.axis("off")
ax.set_facecolor(COL_WHITE)

# ----------------------------------------------------------------------------
# ÜST SIRA — FORWARD (kolay): temiz görüntü → saf gürültü  (cyan, kalın ok)
# ----------------------------------------------------------------------------
ax.text(5.75, 5.18, "FORWARD (kolay)", ha="center", va="center",
        fontsize=13, weight="bold", color=COL_CYAN_700)

viz.boxed_node(ax, 2.05, 4.25, 2.7, 1.0, "temiz görüntü\nx₀",
               fc=COL_BG, ec=COL_PRIMARY, tc=COL_TEXT, fontsize=11.5)
viz.boxed_node(ax, 9.45, 4.25, 2.7, 1.0, "saf gürültü\nx_T  ~ N(0, I)",
               fc=COL_BG, ec=COL_PRIMARY, tc=COL_TEXT, fontsize=11.5)

# kalın forward ok (soldan sağa)
viz.arrow_between(ax, (3.55, 4.25), (7.95, 4.25),
                  color=COL_PRIMARY, lw=3.4, mutation_scale=26, shrink=8)
ax.text(5.75, 4.66, "+ Gaussian gürültü  ·  √(1−β), β  BİLİNİR",
        ha="center", va="center", fontsize=10, weight="bold", color=COL_CYAN_700)
ax.text(5.75, 3.84, "kolay / reparam ile anında",
        ha="center", va="center", fontsize=9.5, style="italic", color=COL_CYAN_700)

# ----------------------------------------------------------------------------
# ALT SIRA — REVERSE (zor): saf gürültü → temiz görüntü  (rose, kesik ok)
# ----------------------------------------------------------------------------
ax.text(5.75, 2.32, "REVERSE (zor)", ha="center", va="center",
        fontsize=13, weight="bold", color=COL_ACCENT)

viz.boxed_node(ax, 2.05, 1.35, 2.7, 1.0, "saf gürültü\nx_T  ~ N(0, I)",
               fc=COL_BG_ROSE, ec=COL_ACCENT, tc=COL_TEXT, fontsize=11.5)
viz.boxed_node(ax, 9.45, 1.35, 2.7, 1.0, "temiz görüntü\nx₀",
               fc=COL_BG_ROSE, ec=COL_ACCENT, tc=COL_TEXT, fontsize=11.5)

# kesik reverse ok (soldan sağa, kesik çizgi)
rev = viz.arrow_between(ax, (3.55, 1.35), (7.95, 1.35),
                        color=COL_ACCENT, lw=2.6, mutation_scale=24, shrink=8)
rev.set_linestyle((0, (6, 4)))
ax.text(5.75, 1.78, "?  gürültü giderme  ·  veri dağılımı  BİLİNMEZ",
        ha="center", va="center", fontsize=10, weight="bold", color=COL_ACCENT)
ax.text(5.75, 0.92, "ÖĞRENİLMELİ (bir sinir ağı)",
        ha="center", va="center", fontsize=9.5, style="italic", weight="bold",
        color=COL_ACCENT)

# ----------------------------------------------------------------------------
# Ortadaki vurgu: üretken modellemenin problemi
# ----------------------------------------------------------------------------
ax.text(5.75, 3.06,
        "üretken modellemenin problemi:  reverse'i öğren",
        ha="center", va="center", fontsize=11, weight="bold", color=COL_TEXT,
        bbox=dict(boxstyle="round,pad=0.5", fc=COL_CYAN_50,
                  ec=COL_SLATE_400, lw=1.2))

plt.tight_layout()
plt.show()
Şekil 12.7: (şematik: forward kolay (bilinen Gaussian), reverse zor (öğrenilir) — diffusion bu asimetriyi çözer)
İpucuBuilder Notu — Reverse’i Öğrenmek: Eklenen Gürültüyü Tahmin Et
  • İleriye (Ders 19): Reverse process’i öğrenmek = bir sinir ağına “eklenen gürültüyü tahmin et” dedirtmek; DDPM (Ders 19) tam bunu kurar. Kayıp neden MSE olur? Çünkü hedef bilinen ε, tahmin ağın çıktısı.
  • Geriye (Ders 9A): Ders 9A’nın sampling loop’u bu reverse’in çalışan koduydu — her adımda gürültüyü tahmin et, kısmen çıkar. Şimdi neden öyle yaptığının matematiğini görüyorsun.

12.12 Lesson 9’un “Magic API”si ile Bağlantı

Waseem ve Tanishq sürekli Ders 9’a bağlanır: q(x⁰) “veri dağılımı” = Ders 9’daki sihirli API (bir şeyin geçerli görüntü olma olasılığı). Forward process bu dağılımı bozar; reverse onu geri kurar. Sampling = “yüksek olasılıklı (yüksek q değerli) bir görüntü bulmak”. Üç ders (9, 9A, 9B) aynı şeyi üç dilde anlatır: sezgi, kod, matematik.

“When we say we’re sampling from the data distribution… we’re trying to get data points that have a high value from that API.” — Tanishq, 29:25

İpucuBuilder Notu — Üç Dil, Tek Fikir
  • Geriye (Ders 9/9A): Ders 9’un sezgisi (gradyanla geçerli görüntüye it) + 9A’nın kodu (CFG’li sampling) + 9B’nin matematiği = aynı şeyin üç dili. q(x⁰) hepsinde ortak nesnedir.
  • Sezgi: “Sampling = yüksek q değerli nokta bulmak” cümlesi, Ders 9’un pixel gradyanı sezgisiyle birebir örtüşür — geçerliliği artan yöne adım at.

12.13 Kapanış

Ders 9B, diffusion’ın “korkutucu” matematiğini sezgiye çevirdi: q() bir olasılık fonksiyonu, q(x⁰) veri dağılımı (= magic API), forward process Gaussian geçişli bir Markov zinciri (her adımda βₜ gürültü), reparameterization ile kolayca örneklenir. Forward kolay, reverse zor — ve Part 2’nin geri kalanı reverse’i öğrenen ağı sıfırdan kuracak.

Şekil 12.8 dersin sentezidir: solda 9B’nin kavramları (rose), sağda her birinin nereden geldiği (cyan). q() + q(x⁰) ↔︎ Stat 110 PDF + Ders 9 sihirli API; N(μ,σ²) + Markov ↔︎ Stat 110; βₜ·I ↔︎ 18.06 kovaryans; reparameterization ↔︎ 6.S191 VAE + Stat 110 konum-ölçek; forward/reverse ↔︎ DDPM (Ders 19) + NYU §4.J score/EBM. Korkutucu notasyon, tanıdık fikirler.

Kod 
fig, ax = plt.subplots(figsize=(12, 6.5))
ax.set_xlim(0, 12)
ax.set_ylim(0, 10)
ax.axis("off")

# Başlık şeridi
ax.text(6.0, 9.55, "9B matematiği = tanıdık parçalar",
        ha="center", va="center", fontsize=15, weight="bold", color=COL_CYAN_700)
ax.text(3.0, 8.95, "9B kavramı", ha="center", va="center",
        fontsize=11.5, weight="bold", color=COL_ACCENT)
ax.text(9.0, 8.95, "nereden geliyor", ha="center", va="center",
        fontsize=11.5, weight="bold", color=COL_PRIMARY)

# 5 satır: (sol 9B-parça = rose, sağ kaynak = cyan)
rows = [
    ("q() yoğunluk +\nq(x⁰) veri dağılımı",
     "Stat 110: PDF +\nDers 9 sihirli API\n(geçerlilik olasılığı)"),
    ("normal dağılım\nN(μ,σ²) + Markov zinciri",
     "Stat 110: Gaussian + Markov\n(gelecek yalnız şimdiye bağlı)"),
    ("βₜ·I kovaryans",
     "18.06: kovaryans matrisi,\nköşegen = bağımsız"),
    ("reparameterization\nμ + σ·ε",
     "6.S191 VAE trick'i +\nStat 110 konum-ölçek"),
    ("forward / reverse",
     "DDPM (Ders 19) reverse'i sıfırdan kurar;\nNYU §4.J score / EBM"),
]

y_top, y_bot = 8.1, 0.9
n = len(rows)
ys = [y_top - i * (y_top - y_bot) / (n - 1) for i in range(n)]

xL, xR = 3.0, 9.0
wL, wR = 4.0, 4.6
h = 1.18

for y, (left, right) in zip(ys, rows):
    # SOL: 9B kavramı (rose)
    viz.boxed_node(ax, xL, y, wL, h, left,
                   fc=COL_BG_ROSE, ec=COL_ACCENT, tc=COL_TEXT,
                   fontsize=9.3, lw=2.0)
    # SAĞ: kaynak (cyan)
    viz.boxed_node(ax, xR, y, wR, h, right,
                   fc=COL_BG, ec=COL_PRIMARY, tc=COL_TEXT,
                   fontsize=8.9, lw=2.0)
    # ok: 9B parçası → kaynağı
    viz.arrow_between(ax, (xL + wL / 2, y), (xR - wR / 2, y),
                      color=COL_CYAN_700, lw=2.0, shrink=6)

plt.tight_layout()
plt.show()
Şekil 12.8: (sentez: diffusion matematiği = Stat 110 + Ders 9 + VAE parçaları; korkutucu notasyon, tanıdık fikirler)
İpucuBuilder Notu — 9B → 10: Matematikten Temellere
  • İleriye (Ders 10+): Ders 10 “from the foundations”a (matmul) başlar; bu matematik Ders 19-22’de DDPM/DDIM/Karras olarak koda dökülür. Sezgi (9) → kod (9A) → matematik (9B) → temeller (10) zinciri kapanır.
  • Tek cümle: Diffusion’ın matematiği = Stat 110 + Ders 9 + VAE parçaları; tek yeni şey, bunların kompakt notasyonda birleşmesidir.

12.14 Bu Dersin Özeti

  1. Makale notasyonu korkutucu görünür ama basit fikirlerin kompakt ifadesidir; her sembol tek tek yorumlanabilir (notasyon).
  2. q() bir olasılık yoğunluk fonksiyonudur; q(x⁰) veri dağılımı (= Ders 9’un sihirli API’si).
  3. q(xₜ | xₜ₋₁) koşullu geçiştir: bir önceki görüntüye biraz gürültü ekleyen Gaussian (koşullu yoğunluk).
  4. Gaussian iki parametrelidir (μ, σ²); görüntüde kovaryans βₜ·I (her piksele bağımsız, eşit gürültü) (Gaussian, isotropic).
  5. Forward process: q(xₜ | xₜ₋₁) = N(xₜ; √(1−βₜ)·xₜ₋₁, βₜI); βₜ=0 aynı görüntü, βₜ=1 saf gürültü (forward formülü).
  6. Tüm süreç Gaussian geçişli bir Markov zinciridir (process=dizi, Markov=yalnız önceki adıma bağlı, Gaussian=geçiş normal) (Markov).
  7. Reparameterization: x = μ + σ·ε (ε ~ N(0,I)); Gaussian’dan örneklemeyi kolaylaştırır (VAE trick’iyle aynı) (reparameterization).
  8. Forward kolay, reverse zor; üretken modellemenin problemi, kolay örneklenebilir bir temsil kurmaktır — Part 2 reverse’i öğrenir (forward/reverse).
ÖnemliTek Bir Cümle

Diffusion’ın matematiği özünde şudur: bir görüntüye, her biri Gaussian olan binlerce küçük adımda (βₜ kadar) gürültü ekleyerek onu saf gürültüye çeviren bir Markov zinciri (forward) kurarız; asıl iş, bu kolay yönü tersine çevirip gürültüden görüntü üreten reverse’i öğrenmektir.

12.15 Kontrol Soruları

Cevap:

Formül, bir önceki adımın görüntüsüne (xₜ₋₁) biraz gürültü ekleyerek bir sonrakini (xₜ) üreten bir Gaussian geçiştir: ortalaması √(1−βₜ)·xₜ₋₁ (önceki görüntü hafifçe küçültülmüş), kovaryansı βₜ·I (her piksele bağımsız βₜ gürültü). βₜ=0: √1=1, varyans 0 → görüntü aynen kalır (hiç gürültü). βₜ=1: √0=0, kovaryans I → ortalama 0, varyans 1, yani saf gürültü (önceki görüntüden iz kalmaz). 0 ile 1 arasında: sinyal biraz azalır, gürültü biraz artar — her adım minik bir bozulmadır. (Şekil 12.4 bu dört durumu gerçek hesaplamayla gösterir.)

Cevap:

Process (süreç): bir dizi/sekans söz konusudur (x⁰ → x₁ → x₂ → … → xₜ). Markov: T anındaki durum yalnızca T−1 anına bağlıdır, daha öncesine değil (“gelecek geçmişe değil yalnızca şimdiye bağlı”). Gaussian transitions (geçişler): bir adımdan diğerine geçiş bir normal (Gaussian) dağılımdır — yani q(xₜ | xₜ₋₁) bir Gaussian’dır. Üçü birlikte: her biri Gaussian olan, yalnızca bir önceki adıma bağlı geçişlerden oluşan bir zincir. (Şekil 12.5 bu zinciri şematik gösterir.)

Cevap:

Bir Gaussian’dan doğrudan örneklemek yerine, birim gürültü (ε ~ N(0, I), ortalama 0 varyans 1) alıp standart sapmayla (σ) ölçekleyip ortalamayı (μ) ekleyerek istediğin Gaussian’dan örnek üretiriz: x = μ + σ·ε. Bu kullanışlıdır çünkü her kütüphane N(0,1) örneği üretebilir; gerisi basit aritmetik. Ayrıca rastgeleliği tek bir ε terimine ayırdığı için gradyan akışına izin verir. Bu, 6.S191 Ders 4’teki VAE reparameterization trick’in (z = μ + σ·ε) ta kendisidir ve Stat 110’daki konum-ölçek dönüşümüdür. (Şekil 12.6 mean/std doğrulamasını gerçek histogramla gösterir.)

Cevap:

Forward (görüntüye gürültü ekleme) kolaydır çünkü Gaussian geçişlerinin parametrelerini (√(1−βₜ), βₜ) tam biliyoruz; reparameterization ile anında örnekleriz. Ama biz reverse’i isteriz: gürültüden gerçek bir görüntü üretmek. Veri dağılımı q(x⁰)’dan doğrudan örnekleyemeyiz çünkü onu bilmiyoruz (tam da öğrenmek istediğimiz şey o). Üretken modellemenin problemi budur: karmaşık veri dağılımını, kolayca örneklenebilir bir biçimde temsil etmek. Diffusion’ın çözümü: forward’ı çok sayıda küçük adıma böl, her adımın tersini (eklenen gürültüyü tahmin etmeyi) bir sinir ağına öğret. Builder açısından: kolay yönü (gürültüleme) veri üretmek için kullan, zor yönü (gürültü giderme) modele öğret — DDPM’in özü. (Şekil 12.7 bu asimetriyi gösterir.)

12.16 Egzersizler

Egzersiz 1 (Kavramsal). Forward process formülünü βₜ = 0, 0.5, 1 için elle değerlendir; her durumda ortalama (√(1−βₜ)·xₜ₋₁) ve varyansın (βₜ) ne olduğunu ve görüntünün nasıl göründüğünü açıkla.

Egzersiz 2 (İki-aşamalı). N(0,1)’den 100 örnek çek, sonra x = μ + σ·ε ile μ=5, σ=2 bir Gaussian’a dönüştür; histogramının ortalama ve varyansını doğrula (reparameterization — Şekil 12.6’ı kendi sayınla yeniden üret).

Egzersiz 3 (Edge case). Bir MNIST görüntüsüne forward process’i 10, 100, 1000 adım uygula (her adımda βₜ kadar gürültü); kaç adımda “tanınmaz” hale geldiğini gözle.

Egzersiz 4 (Notasyon). q(x⁰), q(xₜ | xₜ₋₁) ve N(μ, σ²) sembollerini kendi cümlelerinle açıkla; “magic API” sezgisiyle eşleştir.

Egzersiz 5 (Sonraki bölümün habercisi — Ders 19). Reverse process’i bir sinir ağının “eklenen gürültüyü tahmin etmesi” olarak nasıl kurabileceğini düşün; kayıp neden MSE olur?

12.17 Sonraki: Ders 10 İçin Hazırlık

Ders 10: Daha Derine (Diving Deeper)

Ders 9/9A/9B Stable Diffusion’ı sezgi, kod ve matematikle verdi. Ders 10 hem Stable Diffusion’a biraz daha iner hem de Part 2’nin asıl omurgasını başlatır: “from the foundations” — her şeyi (matris çarpımından itibaren) sıfırdan yeniden kurmak.

Ana konular (Ders 10):

  • Stable Diffusion’da daha ileri (DiffEdit vb.)
  • “From the foundations” felsefesi
  • Matris çarpımını sıfırdan (Ders 11 hazırlık)
  • İzin verilen tek temel: Python + tensör oluşturma
UyarıDers 10 Öncesi Yapılacak
  • Bu dersin egzersizlerini çöz (özellikle 1 ve 3 — forward process’i elle uygula).
  • Forward process formülünü ve reparameterization’ı kâğıt üstünde türet.
  • Ana cümleyi tekrar oku: “Forward kolay (Gaussian gürültü), reverse zor (öğrenilir).”

12.18 Anahtar Kavramlar (Cheat Sheet)

Kavram Tanım 9B’de
q() / yoğunluk fonksiyonu Bir görüntünün olasılığını veren fonksiyon 2:25
q(x⁰) / data distribution Gerçek görüntü olma olasılığı (= magic API) 2:25
q(xₜ | xₜ₋₁) Koşullu geçiş: önceki görüntüye gürültü ekle 9:06
Gaussian (normal) Çan eğrisi; mean (μ) + variance (σ²) ile tanımlı 8:21
βₜ·I (isotropic kovaryans) Her piksele bağımsız, eşit gürültü 18:38
Forward process N(xₜ; √(1−βₜ)·xₜ₋₁, βₜI); adım adım gürültüleme 27:05
Markov süreci T anı yalnızca T−1 anına bağlı 28:26
Gaussian transition Geçişin normal dağılım olması 28:26
Reparameterization x = μ + σ·ε; Gaussian’dan kolay örnekleme 30:30
Forward vs reverse Gürültüleme kolay, gürültü giderme öğrenilir 32:20
Sampling Yüksek olasılıklı (geçerli) görüntü bulma 29:25
βₜ (beta / noise schedule) Her adımda eklenen gürültü miktarı 18:38

12.19 ML Bağlantıları Özeti

İpucuBuilder Notu — 6 ML Köprüsü: 9B Matematiğinin Tanıdık Kökleri

Bu ders, diffusion’ın korkutucu notasyonunu tanıdık kavramlara indirger; köprülerin özeti:

  1. Olasılık yoğunluğu / normal dağılım / Markov → tamamı Stat 110; diffusion matematiğinin temeli (Gaussian, Markov).
  2. Forward process → Gaussian geçişli zincir; DDPM (Ders 19) bunu koda döker (forward formülü).
  3. Reparameterization (μ + σ·ε) → 6.S191 VAE trick’i; gradyan akışına izin verir (reparameterization).
  4. Forward kolay / reverse zor → üretken modellemenin merkez problemi; reverse bir ağla öğrenilir (forward/reverse).
  5. q(x⁰) = magic API → Ders 9’un sezgisi; reverse, “geçerlilik” yönünde adım atmak (magic API).
  6. NYU (§4.J) → reverse/score, enerji-tabanlı modeller ve score matching ile akraba (forward/reverse).
ÖnemliBu dersten tek bir şey alıp gideceksen

Diffusion’ın korkutucu matematiği aslında tek bir basit fikrin kısaltmasıdır — bir görüntüye her biri Gaussian olan binlerce minik adımda gürültü ekle (forward, kolay), sonra bu süreci tersine çeviren ağı öğret (reverse, zor). q(x⁰) Ders 9’un sihirli API’si, βₜ·I her piksele bağımsız gürültü, reparameterization ise VAE’den tanıdığın μ + σ·ε. Notasyon değişir; fikir basit kalır.