zi2zi-pytorch 用 final_channels=1 訓練，再逐步增加 final_channels, 對於程式碼的調整有那些?

2025-02-232025-02-23

如果要 先用 final_channels=1 訓練，再逐步增加 final_channels，可以採取 階段性遷移學習 (Progressive Training)。這樣可以讓模型從較簡單的判別器開始學習，然後逐步增加複雜度，提升字型細節質量。

📌 主要的程式碼調整

你需要逐步改變 Discriminator 的 final_channels，以及調整學習率與訓練方式，主要修改以下部分：

1️⃣ 設定 `Discriminator` 的 `final_channels`

在 model.py (或 networks.py)，找到 Discriminator 類別 (class Discriminator(nn.Module))，修改最終輸出層 (final_conv)：

第一階段 (初始訓練，使用 `final_channels=1`)

class Discriminator(nn.Module):
    def __init__(self, input_nc, ndf=64, n_layers=3, final_channels=1):  # 新增 final_channels 參數
        super(Discriminator, self).__init__()
        kw = 4  # Kernel size
        padw = kw // 2

        # 第一層
        self.model = nn.Sequential(
            nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw),
            nn.LeakyReLU(0.2, True)
        )

        # 隱藏層
        nf_mult = 1
        for n in range(1, n_layers):
            nf_mult_prev = nf_mult
            nf_mult = min(2 ** n, 8)
            self.model.add_module(
                f"conv_{n}",
                nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=3, stride=2, padding=1, bias=False)
            )
            self.model.add_module(f"bn_{n}", nn.BatchNorm2d(ndf * nf_mult))
            self.model.add_module(f"lrelu_{n}", nn.LeakyReLU(0.2, True))

        # **最終輸出層 (先用 final_channels=1)**
        self.model.add_module(
            "final_conv",
            nn.Conv2d(ndf * nf_mult, final_channels, kernel_size=3, stride=1, padding=1, bias=False)
        )

    def forward(self, input):
        return self.model(input)

這時候 Discriminator 只輸出 1 個通道 (真/假分數)，讓 G 更容易學習。

2️⃣ 訓練過程中，逐步增加 `final_channels`

當 G 訓練穩定後 (例如 G_loss 下降到一定程度)，可以逐步 將 final_channels 增加到 ndf * nf_mult，以提升判別器的能力。

**第二階段 (加強 `D`，讓 `final_channels=ndf * nf_mult`)**

修改 train.py 的 模型初始化部分：

# 第一階段訓練
discriminator = Discriminator(input_nc=3, ndf=64, n_layers=3, final_channels=1)

# 訓練 `X` 個 Epochs (例如 30 個)
for epoch in range(30):
    train_one_epoch(generator, discriminator, optimizer_G, optimizer_D, dataloader)

# **第二階段**：增加 `D` 的 `final_channels`
discriminator = Discriminator(input_nc=3, ndf=64, n_layers=3, final_channels=64*8)  # 變成 512 通道
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.00005, betas=(0.5, 0.999))  # 降低學習率
print("✅ Discriminator final_channels 增加到 512，開始第二階段訓練")

# **繼續訓練**
for epoch in range(30, 60):  # 繼續訓練
    train_one_epoch(generator, discriminator, optimizer_G, optimizer_D, dataloader)

這樣就能先讓 G 學習基本風格，再逐步加強 D，提升最終結果的細節。

📌 其他最佳化調整

✅ 1. 降低 `D` 的學習率，避免 `D` 過強

當 final_channels 增加時，D 變強，可能導致 G 訓練困難。可以降低 D 的學習率：

d_learning_rate = 0.00005  # 原本 0.0002，降低 D 學習率
optimizer_D = optim.Adam(D.parameters(), lr=d_learning_rate, betas=(0.5, 0.999))

✅ 2. 先凍結 `D` 的前幾層，讓 `G` 適應後再解凍

在 D 更新後，先凍結前幾層的權重：

for param in discriminator.model[:3].parameters():  # 冻结前 3 层
    param.requires_grad = False

然後過幾個 Epoch 後，再解凍：

for param in discriminator.parameters():
    param.requires_grad = True

這樣可以讓 G 逐步適應 D 的變化，避免訓練不穩定。

📌 結論

🚀 最佳訓練策略： 1️⃣ 第一階段 (final_channels=1)：

D 只輸出單一真/假分數，讓 G 容易學習基本字型風格。
訓練 30~50 個 Epochs (具體視 G_loss 和 D_loss 變化而定)。

2️⃣ 第二階段 (final_channels=ndf * nf_mult)：

D 輸出更多特徵，讓 G 學習更多細節，提高字型質量。
降低 D 學習率 (lr=0.00005)，避免 D 過強。
先凍結 D 的前幾層，讓 G 適應後再解凍。

這樣可以穩定 G 的學習，避免 D 過強導致 G 訓練困難，最終能生成更精細的字體！ 🚀🔥

Max的程式語言筆記