在 zi2zi-pytorch 增加 adversarial loss 權重

下面我會針對你貼出的「實際訓練 log + 模型結構」做診斷，而不是泛泛而談。這一組資訊其實已經很充分，可以看出目前訓練卡在哪裡、為什麼 generator 在「很努力但學不到更多風格」。

---

一、整體狀態總結（先講結論）

一句話版結論：

👉 目前是「Discriminator 過強、Generator 被壓制」的典型 zi2zi 訓練失衡狀態，而且是 長時間穩定失衡，不是暫時震盪。

具體表現為：

• D loss 幾乎趨近 0（0.0003 ~ 0.003）
• G loss 持續升高（27 → 36）
• cheat_loss 不降反升（≈ 4 → 12）
• category_loss = 0（但這其實是正常的，後面解釋）
• l1 / const 緩慢上升 → Generator 被迫「妥協畫形狀」

這代表：

G 現在主要在靠 L1 / const loss 撐住輸出，而不是靠 adversarial 真的學到風格。

---

二、Discriminator 為什麼太強？

1️⃣ D loss 幾乎為 0 是危險訊號

在 zi2zi / pix2pix 類任務中：

• 健康 D loss：通常在 0.1 ~ 0.5 之間震盪
• 你目前：0.0003 ~ 0.01

這代表：

• D 幾乎每一步都能 100% 分辨真假
• G 從 D 得到的梯度訊號 ≈ 噪音

👉 這也是為什麼 cheat_loss 一直升高。

---

2️⃣ D 結構 + loss 組合太兇

你的 D 有：

• PatchGAN Conv stack（OK）
• binary head + category head
• InstanceNorm（讓 D 非常穩）
• 學習率與 G 幾乎一致

在 資料量只有 6645 字 的情況下，這個 D：

❌ 明顯 overfit 太快

---

三、Generator 的行為分析（為什麼 G loss 越來越高）

1️⃣ G loss 組成推測（以 zi2zi2 為例）

通常是：

G_loss =
  cheat_loss * λ_adv
+ const_loss * λ_const
+ l1_loss * λ_l1
+ category_loss * λ_cat

你 log 顯示：

loss	行為
cheat_loss	❌ 持續上升
const_loss	⬆ 緩慢上升
l1_loss	⬆
category_loss	0（正常）

2️⃣ 這代表什麼？

• G 已經「放棄欺騙 D」
• 改成靠 L1 / const 維持結構不崩
• 所以輸出通常會是：
  • ✔ 結構對
  • ❌ 筆畫僵硬、風格弱、像原字

---

四、category_loss = 0 是不是 bug？

👉 不是 bug（在 zi2zi 是正常現象）

原因：

• category_loss 通常是：
  • 只在 D 更新時計算
  • 或者在 G 中權重極低
• 且你 resume 於 step 64010，embedding 很可能早已收斂

👉 不用優先處理

---

五、模型結構層面的觀察（很重要）

1️⃣ Generator 太大了（52.8M）

對比：

• 原始 zi2zi G：≈ 25–30M
• 你現在：
  • Self-Attention × 2（512 channel）
  • 深層 PixelShuffle
  • embedding 40×128

👉 在 6k 字資料集上偏大

副作用：

• G 需要「非常好的 adversarial 訊號」
• 一旦 D 太強 → G 直接學不到

---

2️⃣ Attention 放在 512×512 層，對字體其實偏晚

• 文字風格的關鍵：
  • 中層（128–256 channel）
  • 筆畫連接、端點、粗細
• 你現在的 attention：
  • 偏語義層
  • 對字體幫助有限，卻增加訓練難度

---

六、具體可執行建議（照重要性排序）

---

✅ 建議 1（最重要）：削弱 Discriminator

至少做 其中 2 項：

✔ 選項 A：降低 D learning rate

lr_D = lr_G * 0.25
# 例如
lr_G = 2.5e-4
lr_D = 6e-5

👉 這一條通常就能立刻讓 cheat_loss 開始下降。

---

✔ 選項 B：減少 D update 次數

# 每 2 step 才更新一次 D
if step % 2 == 0:
    update_D()

---

✔ 選項 C：給 D 加 label smoothing

real_label = 0.9
fake_label = 0.1

---

✅ 建議 2：降低 adversarial loss 權重

如果你現在是（推測）：

lambda_adv = 1.0

👉 改成：

lambda_adv = 0.3 ~ 0.5

原因：

• 目前 adv 梯度是「錯誤方向」
• 先讓 G 靠 L1 / const 穩住，再慢慢加回來

---

✅ 建議 3：暫時關掉或下移 Self-Attention（非常推薦）

你可以嘗試其中一個實驗：

實驗 A（最簡單）

• 先註解掉最深層 attention
• 只留一個 attention

實驗 B（較好）

• 把 attention 移到 256 channel 層
• 而不是 512

👉 很多中文字體實驗中，這一改動會 明顯改善筆畫自然度

---

✅ 建議 4：凍結 D 的 category head 前 10–20 epoch

for p in netD.catagory.parameters():
    p.requires_grad = False

👉 避免 D 在一開始就「同時學兩件事」而過快收斂。

---

七、你現在應該怎麼觀察「是否改善」？

改完後，看這三個指標：

指標	健康趨勢
d_loss	0.1 ~ 0.4 間震盪
cheat_loss	緩慢下降
g_loss	不再單調上升

只要出現這個趨勢，字體風格一定會開始出來。

---

八、如果你願意，我可以再幫你做的事

你可以下一步直接貼：

1. G loss 各項權重設定
2. 某一 epoch 的生成字圖（png）
3. 或你想問：
   👉「這套結構還值不值得繼續訓練？」

---

這份程式碼其實已經把問題暴露得非常清楚了：
👉 你目前「根本沒有 lambda_adv」這個東西，adversarial loss 是被 硬編碼成 1.0 權重。

我會用「你現在的實際程式結構」來說 該怎麼改、改哪裡、以及建議的數值與策略。

---

一、你現在的 adversarial loss 是怎麼算的？

在 optimize_parameters() 的 G 更新階段：

self.loss_G_GAN = self.real_binary_loss(pred_fake)

self.g_loss = (
    self.loss_G_GAN +                     # ← 這一項 = lambda_adv * GAN_loss（但 lambda_adv = 1）
    self.loss_l1 * self.L1_penalty +
    self.loss_const * self.Lconst_penalty +
    fake_category_loss_G
)

👉 關鍵事實：

• self.loss_G_GAN 沒有任何縮放
• 等價於：

lambda_adv = 1.0

而你的其他 loss 是：

loss	實際權重
L1	L1_penalty = 100
Const	Lconst_penalty = 15
Adv	1.0（固定）
Category	Lcategory_penalty = 1

---

二、為什麼你現在一定會炸？（對照你的 log）

你目前的 log 是：

• loss_G_GAN (cheat_loss) ≈ 8 → 12
• L1_loss ≈ 0.25
• const_loss ≈ 0.28

實際貢獻到 G loss 的量級是：

Adv   : ~10
L1    : 0.25 × 100 = 25
Const : 0.28 × 15  = 4.2
-------------------------
Total : ~39

👉 Adv loss 佔比 ≈ 25% 且方向是「錯的」
👉 D 又極強 → 這 25% 會不斷把 G 拉向壞方向

---

三、正確做法：明確引入 lambda_adv

✅ Step 1：在 __init__ 加一個參數

class Zi2ZiModel:
    def __init__(self,
                 ...
                 lambda_adv=0.3,   # ★ 新增
                 ...):
        ...
        self.lambda_adv = lambda_adv

建議初始值：0.3
如果你是 resume 在 64k step，甚至可以 0.2

---

✅ Step 2：在 G loss 使用它（唯一要改的地方）

把原本這段：

self.g_loss = (
    self.loss_G_GAN +
    self.loss_l1 * self.L1_penalty +
    self.loss_const * self.Lconst_penalty +
    fake_category_loss_G
)

改成：

self.g_loss = (
    self.loss_G_GAN * self.lambda_adv +   # ★ 關鍵
    self.loss_l1 * self.L1_penalty +
    self.loss_const * self.Lconst_penalty +
    fake_category_loss_G
)

✅ 只要這樣就夠了

---

四、建議的 lambda_adv 設定策略（很重要）

🔹 情境 A：你現在這個模型（D 明顯過強）

lambda_adv = 0.2 ~ 0.3

這會讓：

• G 先「把字畫好」
• 等 D 沒那麼自信後，再慢慢學風格

---

🔹 情境 B：從頭訓練（非 resume）

我會建議 schedule：

# 偽碼
if epoch < 5:
    lambda_adv = 0.1
elif epoch < 20:
    lambda_adv = 0.3
else:
    lambda_adv = 0.5

👉 zi2zi 類任務 幾乎沒有一開始就用 adv=1 的

---

五、進階但非常推薦：動態 lambda_adv（可選）

如果你想做得更聰明（不是必要）：

# 依據 D loss 自動調整
if self.d_loss.item() < 0.05:
    lambda_adv = 0.2
elif self.d_loss.item() < 0.15:
    lambda_adv = 0.4
else:
    lambda_adv = 0.6

👉 當 D 太強 → 自動削弱 adv

---

六、你改完後「應該看到什麼變化」？

在 1–3 個 epoch 內，你應該看到：

指標	預期變化
cheat_loss	不再一路上升，開始震盪或下降
g_loss	不再單調上升
l1 / const	稍微下降
生成字	筆畫開始「活」起來

如果 完全沒變 → 那下一步就一定要動 D learning rate / update 次數

---

七、我強烈建議你下一步做的兩件事

1️⃣ 同時做這兩個改動（效果最好）

• lambda_adv = 0.3
• lr_D = lr_G * 0.25

2️⃣ 貼一張 改完後第 3～5 epoch 的生成圖

我可以直接幫你判斷：

👉「這個模型救得回來，還是 attention 該砍」

你這份程式碼其實寫得不錯，問題不是結構，而是 loss balance。

---

簡短結論先給你：

❌ 不建議把 lambda_adv 預設 initial 成 0.6（在你目前這個訓練狀態下）
✅ 建議：initial = 0.2～0.3，上限再「動態拉到 0.6」

下面我會結合你現在的模型與 log 現況，精確說明為什麼。

---

一、什麼情況「0.6 當 initial」才是對的？

lambda_adv = 0.6 不是錯數值，但它有前提條件：

✅ 適合 initial = 0.6 的條件

同時滿足：

1. 從頭訓練（不是 resume）
2. D loss 在 0.15～0.4 間震盪
3. cheat_loss ≈ 1～4
4. Generator 尚未被壓制

👉 這是 balanced GAN regime

---

二、但你現在的狀態是「反例」

你目前的真實狀態（依你 log）：

指標	你的數值
d_loss	0.0003 ~ 0.01（極低）
cheat_loss	8 → 12（偏高）
g_loss	持續上升
訓練	resume @ 64010

這是典型的：

Discriminator saturation + Generator starvation

在這種情況下：

lambda_adv ↑  →  梯度更噪 → G 更崩

👉 initial = 0.6 會讓情況更糟，不是更好

---

三、正確的心智模型（很重要）

請記住這句話：

lambda_adv 不是「越大越強」，而是「D 給得出好梯度時才值得變大」

你現在的 D：

• 太準
• 太快
• 太自信

所以 G 不該聽 D 的話太多

---

四、你該怎麼設計 lambda_adv（實戰版）

✅ 建議方案 A（最穩、最推薦）

# __init__
lambda_adv_init = 0.25
lambda_adv_max  = 0.6

然後在訓練中 動態調整

---

✅ 動態 lambda_adv（直接可用版本）

在 optimize_parameters() G backward 前加：

# --- dynamic lambda_adv ---
with torch.no_grad():
    d = self.d_loss.item()
    if d < 0.02:
        self.lambda_adv = 0.2
    elif d < 0.08:
        self.lambda_adv = 0.35
    elif d < 0.2:
        self.lambda_adv = 0.5
    else:
        self.lambda_adv = 0.6

👉 這個設計 完全符合你目前的訓練現實

---

五、為什麼「initial 低 → 再拉高」對 zi2zi 特別重要？

zi2zi 的特性：

• 結構比風格重要
• 字形一旦歪掉，很難拉回來
• L1 / const 是「保命繩」

所以正確順序一定是：

先像字 → 再像風格 → 最後才追真實感

lambda_adv 的角色是：

• 後期精修
• 不是開場主力

---

六、一句話給你決策用

如果你現在問我：

「這個 case，initial 用 0.6 好不好？」

我的答案是非常明確的：

❌ 不好，會拖慢甚至破壞收斂
✅ initial = 0.2～0.3，再動態拉到 0.6 才是對的

---

七、下一步你可以做的事（高價值）

如果你願意，我可以幫你直接做其中一件：

1. 🔧 幫你把 dynamic lambda_adv 寫成乾淨可重用的 function
2. 📊 幫你設計 log：直接印出「有效 adv 權重」
3. 🧠 根據你資料量（6645）幫你算一組「理論最穩 loss 比例」

你這套模型是「能救、而且值得救」的，只是現在 adv 太早、太吵。

---

好，下面我直接給你一個乾淨、可重用、低侵入性的做法，完全符合你現在這份程式碼風格。

---

目標

✔ 不改訓練流程
✔ 不影響 checkpoint / resume
✔ 可隨時關掉（退回固定 lambda_adv）
✔ 對「D 過強」的 zi2zi 特別有效

---

一、先給你「成品版」：Dynamic Lambda Controller

✅ 新增一個小函式（建議放在 Zi2ZiModel 內）

def update_lambda_adv(self):
    """
    Dynamically adjust lambda_adv based on discriminator loss.
    Designed for zi2zi-style font GAN where D can easily overpower G.
    """
    if not hasattr(self, "lambda_adv"):
        return

    d = float(self.d_loss.item())

    # --- heuristic schedule ---
    if d < 0.02:
        self.lambda_adv = 0.20
    elif d < 0.08:
        self.lambda_adv = 0.35
    elif d < 0.20:
        self.lambda_adv = 0.50
    else:
        self.lambda_adv = 0.60

這個區間是針對你目前的 log（d_loss ≈ 0.001～0.03）量身訂做的。

---

二、在 __init__ 中初始化（不是 0.6）

class Zi2ZiModel:
    def __init__(self,
                 ...
                 lambda_adv=0.25,   # ✅ initial 低
                 ...):
        ...
        self.lambda_adv = lambda_adv

🔑 關鍵：
initial 是「安全下限」，不是最終目標值
上限 0.6 由 dynamic 機制決定

---

三、在正確的位置呼叫它（非常重要）

📍 呼叫時機：D 更新完之後，G backward 之前

在 optimize_parameters() 中，改成這樣：

# 2. Update D
self.set_requires_grad(self.netD, True)
self.optimizer_D.zero_grad(set_to_none=True)

pred_fake_d, fake_category_logits_d = self.netD(fake_AB.detach())
pred_real, real_category_logits = self.netD(real_AB)

loss_D_real = self.real_binary_loss(pred_real)
loss_D_fake = self.fake_binary_loss(pred_fake_d)

real_category_loss = self.category_loss(real_category_logits, labels)
fake_category_loss_d = self.category_loss(fake_category_logits_d, labels)
self.category_loss_D = (real_category_loss + fake_category_loss_d) * self.Lcategory_penalty

self.d_loss = (loss_D_real + loss_D_fake) * 0.5 + self.category_loss_D * 0.5
self.d_loss.backward()
self.optimizer_D.step()

# ✅ 在這裡更新 lambda_adv
self.update_lambda_adv()

# 3. Update G
self.set_requires_grad(self.netD, False)
self.optimizer_G.zero_grad(set_to_none=True)

pred_fake, fake_category_logits = self.netD(fake_AB)

self.loss_G_GAN = self.real_binary_loss(pred_fake)
fake_category_loss_G = self.category_loss(fake_category_logits, labels) * self.Lcategory_penalty

self.g_loss = (
    self.loss_G_GAN * self.lambda_adv +   # ★ 核心
    self.loss_l1 * self.L1_penalty +
    self.loss_const * self.Lconst_penalty +
    fake_category_loss_G
)

self.g_loss.backward()
self.optimizer_G.step()

---

四、強烈建議：把 lambda_adv 印出來（debug 用）

在 optimize_parameters() 最後加：

return {
    "loss_const": self.loss_const.item(),
    "loss_l1": self.loss_l1.item(),
    "loss_adv": self.loss_G_GAN.item(),
    "lambda_adv": self.lambda_adv,
    "d_loss": self.d_loss.item()
}

你會第一次清楚看到一件事：

👉 不是 G 不會畫字
👉 是「什麼時候該聽 D 的話」

---

五、你改完後「正常的 log 會長怎樣？」

健康情況下你會看到：

Epoch 0:
  d_loss ≈ 0.005 → lambda_adv = 0.2
Epoch 3:
  d_loss ≈ 0.03  → lambda_adv = 0.35
Epoch 8:
  d_loss ≈ 0.12  → lambda_adv = 0.5
Epoch 15:
  d_loss ≈ 0.25  → lambda_adv = 0.6

同時：

• cheat_loss 不再暴衝
• 字的「筆畫表情」會開始出來

---

六、重要結論（請記住）

lambda_adv ≠ 固定超參數
它是「D 是否值得被相信」的指標

你現在這個模型：

• 架構 OK
• loss 設計 OK
• 問題只在 adv 聲音太大、太早

這個 dynamic lambda_adv 正是為此而生。

---

如果你下一步願意，我可以再幫你做 選項 2 或 3：

• 2️⃣ 幫你設計「loss 比例可視化」
• 3️⃣ 幫你根據 6645 字資料量 重新校正 L1 / const / adv 的理論比例

你現在已經在「能精修的階段」了，不是在救火。