條件式生成對抗網路 cGAN 架構與訓練流程解析

– 12 分鐘閱讀

深度學習中的生成對抗網路（GAN）是一種能生成逼真資料的強大技術。而條件式生成對抗網路（cGAN）更進一步，允許我們控制生成資料的型別。本文將深入探討 cGAN 的架構、訓練流程及程式碼實作，並以影像生成為例，逐步講解如何使用 TensorFlow 建立和訓練 cGAN 模型。首先，我們會剖析 cGAN 中的判別器和生成器架構，接著說明如何定義 cGAN 模型、設定損失函式和最佳化器。最後，我們將探討資料集的建立和預處理，以及如何生成潛在點和虛擬資料，以完整展現 cGAN 的訓練流程。

生成對抗網路（GAN）中的判別器和生成器架構

判別器架構

判別器的主要功能是區分輸入的影像是否為真實或是由生成器生成的假影像。為了達到這個目的，判別器的架構中包含了多個卷積層，以提取影像的特徵。此外，判別器還需要根據額外的訊息（標籤）來進行區分。

以下是判別器架構的部分程式碼：

opt = tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5)
metrics=['accuracy'])

這段程式碼定義了判別器的最佳化器和評估指標。

判別器的特徵提取和標籤處理

判別器的特徵提取是透過卷積層完成的。另外，判別器還需要處理標籤訊息，以便根據標籤進行區分。以下是相關的程式碼：

inputs_label = tf.keras.Input(shape=(1,))
x = tf.keras.layers.CategoryEncoding(num_tokens=NUM_OF_CLASSES, output_mode="one_hot")(inputs_label)

這段程式碼首先定義了標籤的輸入形狀，然後使用 CategoryEncoding 層將標籤進行 one-hot 編碼。

生成器架構

生成器的主要功能是根據輸入的噪聲向量和標籤訊息生成特定類別的影像。以下是生成器架構的部分程式碼：

def create_generator():
    inputs_label = tf.keras.Input(shape=(1,))
    x = tf.keras.layers.CategoryEncoding(num_tokens=NUM_OF_CLASSES, output_mode="one_hot")(inputs_label)
    # ...

這段程式碼定義了生成器的標籤輸入和 one-hot 編碼。

內容解密：

在上面的程式碼中，CategoryEncoding 層是用來將標籤進行 one-hot 編碼的。這樣可以將標籤訊息轉換為一個稀疏的向量，方便之後的處理。

圖表翻譯：

以下是生成器架構的 Mermaid 圖表：

  graph LR
    A[輸入標籤] --> B[one-hot 編碼]
    B --> C[生成器]
    C --> D[輸出影像]

這個圖表展示了生成器的架構，從輸入標籤到輸出影像的過程。

人工智慧技術應用

人工智慧（AI）是一種模擬人類智慧的技術，讓機器可以執行通常需要人類智慧的任務。近年來，人工智慧技術在各個領域中得到廣泛的應用，包括自然語言處理、影像識別、語音識別等。

自然語言處理

自然語言處理（NLP）是一種讓機器可以理解和生成人類語言的技術。它可以用於文字分類別、情感分析、機器翻譯等任務。例如，聊天機器人可以使用NLP技術來理解使用者的輸入，並生成相應的回應。

內容解密：

import nltk
from nltk.tokenize import word_tokenize

# 定義一個文字分類別器
class TextClassifier:
    def __init__(self):
        self.classifier = nltk.NaiveBayesClassifier()

    def train(self, training_data):
        self.classifier.train(training_data)

    def classify(self, text):
        tokens = word_tokenize(text)
        return self.classifier.classify(dict([token, True] for token in tokens))

# 訓練模型
training_data = [
    ({'this': True, 'is': True, 'a': True, 'positive': True}, 'positive'),
    ({'this': True, 'is': True, 'a': True, 'negative': True}, 'negative')
]
classifier = TextClassifier()
classifier.train(training_data)

# 分類別新文字
new_text = "This is a positive review"
print(classifier.classify(new_text))

圖表翻譯：

  flowchart TD
    A[文字輸入] --> B[分詞]
    B --> C[特徵提取]
    C --> D[分類別器]
    D --> E[分類別結果]

圖表翻譯：這個流程圖展示了文字分類別的過程。首先，輸入的文字需要進行分詞，然後提取特徵，接著使用分類別器進行分類別，最後輸出分類別結果。

影像識別

影像識別是一種讓機器可以理解和識別影像的技術。它可以用於物體識別、人臉識別等任務。例如，自駕車可以使用影像識別技術來識別路標和行人。

內容解密：

import cv2
import numpy as np

# 載入影像
img = cv2.imread('image.jpg')

# 將影像轉換為灰度圖
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 使用SIFT演算法進行特徵提取
sift = cv2.SIFT_create()
kp, des = sift.detectAndCompute(gray, None)

# 將特徵點繪製在影像上
cv2.drawKeypoints(img, kp, img)

# 顯示影像
cv2.imshow('Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

圖表翻譯：

  flowchart TD
    A[影像輸入] --> B[灰度轉換]
    B --> C[特徵提取]
    C --> D[特徵點繪製]
    D --> E[影像顯示]

圖表翻譯：這個流程圖展示了影像識別的過程。首先，輸入的影像需要進行灰度轉換，然後使用SIFT演算法進行特徵提取，接著將特徵點繪製在影像上，最後顯示影像。

生成模型架構

在生成模型中，我們定義了一個具有兩個輸入層的模型：inputs_label 和 inputs_lat。inputs_label 是類別標籤的輸入層，期待一個代表類別標籤的整數。inputs_lat 是噪聲向量（潛在空間）的輸入層，其形狀與噪聲向量的維度相同。

units = 16 * 16
x = tf.keras.layers.Dense(units)(x)
labels = tf.keras.layers.Reshape((16, 16, 1))(x)

在這段程式碼中，我們首先定義了一個全連線層（Dense），其單位數為 16 * 16。然後，我們使用 Reshape 層將輸出重新塑形為 (16, 16, 1) 的形狀，以便輸出可以代表影像的類別標籤。

inputs_lat = tf.keras.layers.Input(shape=(LATENT_DIM,))
units = 128 * 16 * 16
x = tf.keras.layers.Dense(units)(inputs_lat)
x = tf.keras.layers.LeakyReLU(alpha=0.2)(x)
latent = tf.keras.layers.Reshape((16, 16, 128))(x)

在這段程式碼中，我們定義了一個輸入層 inputs_lat，其形狀為 (LATENT_DIM,)，代表噪聲向量的維度。然後，我們使用全連線層（Dense）將輸入重新對映到一個更高維度的空間。接著，我們使用 LeakyReLU 啟用函式對輸出進行啟用。最後，我們使用 Reshape 層將輸出重新塑形為 (16, 16, 128) 的形狀，以便輸出可以代表影像的潛在空間。

model = tf.keras.Model([inputs_lat, inputs_label], outputs)

在這段程式碼中，我們定義了一個 Keras 模型，其輸入為 inputs_lat 和 inputs_label，輸出為模型的輸出。這個模型可以用於生成影像的類別標籤和潛在空間。

內容解密：

在這個生成模型中，我們使用了兩個輸入層：inputs_label 和 inputs_lat。inputs_label 是類別標籤的輸入層，期待一個代表類別標籤的整數。inputs_lat 是噪聲向量（潛在空間）的輸入層，其形狀與噪聲向量的維度相同。然後，我們使用全連線層（Dense）和 Reshape 層將輸入重新對映到一個更高維度的空間。接著，我們使用 LeakyReLU 啟用函式對輸出進行啟用。最後，我們使用 Reshape 層將輸出重新塑形為 (16, 16, 128) 的形狀，以便輸出可以代表影像的潛在空間。

圖表翻譯：

  graph LR
    A[inputs_label] --> B[全連線層]
    B --> C[Reshape]
    C --> D[類別標籤]
    E[inputs_lat] --> F[全連線層]
    F --> G[LeakyReLU]
    G --> H[Reshape]
    H --> I[潛在空間]
    D --> J[模型輸出]
    I --> J

這個圖表展示了生成模型的架構。inputs_label 和 inputs_lat 是兩個輸入層，分別代表類別標籤和噪聲向量。然後，我們使用全連線層（Dense）和 Reshape 層將輸入重新對映到一個更高維度的空間。接著，我們使用 LeakyReLU 啟用函式對輸出進行啟用。最後，我們使用 Reshape 層將輸出重新塑形為 (16, 16, 128) 的形狀，以便輸出可以代表影像的潛在空間。

生成對抗網路（GAN）中的生成器架構

在生成對抗網路（GAN）中，生成器（Generator）是一個關鍵的元件，負責生成新的、合成的資料樣本。以下是生成器架構的詳細描述：

生成器架構

生成器架構的設計目的是將隨機噪聲向量和類別標籤對映到合成的影像。以下是生成器架構的步驟：

  1. 類別編碼：使用 CategoryEncoding 層將類別標籤編碼為 one-hot 向量。
  2. 密集層：使用密集層（fully connected layer）將 one-hot 向量對映到 16x16 網格，具有 1 個通道。
  3. 噪聲向量處理：將隨機噪聲向量透過密集層，將其對映到 16x16 網格，具有 128 個通道。
  4. 網格合併：將來自類別標籤和噪聲向量的 16x16 網格合併，沿著通道維度，形成 16x16 網格，具有 129 個通道。
  5. 轉置卷積：使用轉置卷積（transposed convolution）將合併的網格上取樣到更大的尺寸，同時學習生成真實影像所需的模式和結構。
  6. 卷積操作：使用卷積操作生成輸出，具有 3 個通道（對應影像的 RGB 通道）。

條件生成對抗網路（cGAN）架構

生成器和判別器（Discriminator）共同構成了條件生成對抗網路（cGAN）架構。生成器的目的是生成能夠欺騙判別器的合成影像，而判別器的目的是區分真實影像和合成影像。

cGAN 模型

現在，我們可以將生成器和判別器結合起來，建立整個 cGAN 模型。以下是相關程式碼：

def create_cgan(g_model, d_model):
    d_model.trainable = False
    # ...

這個 cGAN 模型將生成器和判別器結合起來，形成一個強大的生成模型，能夠生成高品質的合成影像。

圖表翻譯：

  graph LR
    A[類別標籤] -->|CategoryEncoding|> B[one-hot向量]
    B -->|密集層|> C[16x16網格]
    D[隨機噪聲向量] -->|密集層|> E[16x16網格]
    C -->|合併|> F[16x16網格]
    F -->|轉置卷積|> G[上取樣]
    G -->|卷積操作|> H[輸出]

這個圖表展示了生成器架構的流程，從類別標籤和隨機噪聲向量開始，到生成合成影像的輸出。

根據條件的生成對抗網路（cGAN）模型定義

在深度學習中，生成對抗網路（GAN）是一種強大的工具，能夠生成非常逼真的資料。然而，當我們想要控制生成資料的型別時，條件生成對抗網路（cGAN）就變得非常重要。下面是使用 TensorFlow 定義一個 cGAN 模型的過程。

定義 cGAN 模型

首先，我們需要定義生成器（Generator）和判別器（Discriminator）的輸入和輸出。假設我們的生成器接收雜訊（Noise）和標籤（Label）作為輸入，生成器的輸出將是一個合成的資料。

gen_noise, gen_label = g_model.input
gen_output = g_model.output

接下來，我們定義判別器的輸入和輸出。判別器接收生成器的輸出和標籤作為輸入，輸出是一個機率，表示輸入資料是真實的還是生成的。

gan_output = d_model([gen_output, gen_label])

然後，我們定義 cGAN 模型，該模型接收雜訊和標籤作為輸入，輸出是判別器的輸出。

model = tf.keras.Model([gen_noise, gen_label], gan_output)

最後，我們定義最佳化器，使用 Adam 最佳化器，學習率為 0.0002，beta_1 為 0.5。

opt = tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5)

訓練 cGAN 模型

在訓練 cGAN 模型時，我們需要先將判別器設為不可訓練。這是因為我們先預訓練判別器，以區分真實和生成的資料，然後才訓練生成器。

# 將判別器設為不可訓練
d_model.trainable = False

這樣，我們就定義了一個基本的 cGAN 模型，該模型可以根據給定的標籤生成特定型別的資料。

內容解密：

上述程式碼定義了一個 cGAN 模型，該模型由生成器和判別器組成。生成器接收雜訊和標籤作為輸入，生成一個合成的資料。判別器接收生成器的輸出和標籤作為輸入，輸出是一個機率，表示輸入資料是真實的還是生成的。最佳化器使用 Adam 最佳化器，學習率為 0.0002，beta_1 為 0.5。

圖表翻譯：

  graph LR
    A[雜訊] -->|輸入|> B[生成器]
    C[標籤] -->|輸入|> B
    B -->|輸出|> D[判別器]
    C -->|輸入|> D
    D -->|輸出|> E[機率]
    E -->|輸出|> F[最終結果]

上述 Mermaid 圖表展示了 cGAN 模型的流程，從雜訊和標籤的輸入，到生成器的輸出，然後到判別器的輸出，最終得到機率和最終結果。

載入資料集

在前面的步驟中，我們下載了WIKI面部資料集，提取了中繼資料，並在Pandas DataFrame中預處理了中繼資料。現在是定義TensorFlow資料集並載入影像資料的時候。我們將定義兩個函式，分別用於預處理和載入影像資料。請參考以下程式碼：

def preprocess_data(img_path, trainy):
    img = tf.image.resize(img, (IMAGE_SHAPE[0], IMAGE_SHAPE[1]))
    img = (img - 127.5) / 127.5
    return [img, trainy]

資料集建立

接下來，我們需要建立一個TensorFlow資料集，以便於後續的模型訓練。以下是建立資料集的步驟：

# 定義資料集路徑和標籤
dataset_path = 'path/to/dataset'
labels = 'path/to/labels'

# 載入資料集
dataset = tf.data.Dataset.from_tensor_slices((img_path, trainy))

# 對資料集進行預處理
dataset = dataset.map(preprocess_data)

# 對資料集進行批次處理
dataset = dataset.batch(BATCH_SIZE)

cGAN模型建立

現在，我們可以開始建立cGAN模型了。cGAN是一種特殊的GAN模型，能夠根據指定的類別分佈生成影像。以下是建立cGAN模型的步驟：

# 定義生成器模型
def generator_model():
    model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(7*7*256, input_shape=(100,)),
        tf.keras.layers.Reshape((7, 7, 256)),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.LeakyReLU(),
        tf.keras.layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding='same'),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.LeakyReLU(),
        tf.keras.layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same'),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.LeakyReLU(),
        tf.keras.layers.Conv2DTranspose(3, (5, 5), strides=(2, 2), padding='same', activation='tanh')
    ])
    return model

# 定義判別器模型
def discriminator_model():
    model = tf.keras.models.Sequential([
        tf.keras.layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[28, 28, 3]),
        tf.keras.layers.LeakyReLU(),
        tf.keras.layers.Dropout(0.3),
        tf.keras.layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'),
        tf.keras.layers.LeakyReLU(),
        tf.keras.layers.Dropout(0.3),
        tf.keras.layers.Flatten(),
        tf.keras.layers.Dense(1, activation='sigmoid')
    ])
    return model

# 建立cGAN模型
generator = generator_model()
discriminator = discriminator_model()

模型訓練

現在，我們可以開始訓練cGAN模型了。以下是訓練模型的步驟：

# 定義損失函式
def generator_loss(y_pred):
    return tf.keras.losses.BinaryCrossentropy(from_logits=True)(tf.ones_like(y_pred), y_pred)

def discriminator_loss(y_real, y_fake):
    real_loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)(tf.ones_like(y_real), y_real)
    fake_loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)(tf.zeros_like(y_fake), y_fake)
    return real_loss + fake_loss

# 定義最佳化器
generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)

# 訓練模型
for epoch in range(EPOCHS):
    for x, y in dataset:
        # 訓練生成器
        with tf.GradientTape() as gen_tape:
            gen_output = generator(x, training=True)
            gen_loss = generator_loss(gen_output)
        gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
        generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))

        # 訓練判別器
        with tf.GradientTape() as disc_tape:
            real_output = discriminator(x, training=True)
            fake_output = discriminator(gen_output, training=True)
            disc_loss = discriminator_loss(real_output, fake_output)
        gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

結果

經過訓練後，cGAN模型就可以根據指定的類別分佈生成影像了。以下是生成的影像：

圖表翻譯：

以下是生成影像的流程圖：

  flowchart TD
    A[輸入類別分佈] --> B[生成器模型]
    B --> C[判別器模型]
    C --> D[輸出影像]

這個流程圖描述了cGAN模型如何根據輸入的類別分佈生成影像。首先，輸入類別分佈被傳入生成器模型，生成器模型根據類別分佈生成影像。然後，生成的影像被傳入判別器模型，判別器模型根據影像的真實性評分。最後，輸出影像被生成。

建立資料集和生成潛在點

在深度學習中，資料集的建立和預處理是非常重要的步驟。下面，我們將介紹如何建立資料集和生成潛在點。

建立資料集

首先，我們需要建立一個資料集，該資料集包含了影像和對應的標籤。以下是建立資料集的程式碼：

def create_dataset(images, trainy):
    dataset = tf.data.Dataset.from_tensor_slices((images, trainy))
    dataset = dataset.map(preprocess_data, num_parallel_calls=tf.data.AUTOTUNE)
    dataset = dataset.shuffle(BATCH_SIZE*8).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
    return dataset

在這個程式碼中，create_dataset 函式接收影像和標籤作為輸入，然後建立一個 TensorFlow 資料集。接下來，該函式對資料集進行預處理，包括讀取影像、重塑影像大小和正規化畫素值。最後，資料集被打亂、批次化和預先載入。

內容解密：

  • tf.data.Dataset.from_tensor_slices：從張量中建立一個資料集。
  • dataset.map：對資料集進行預處理。
  • num_parallel_calls=tf.data.AUTOTUNE：自動調整平行呼叫的數量。
  • dataset.shuffle：打亂資料集。
  • dataset.batch：批次化資料集。
  • dataset.prefetch：預先載入資料集。

建立潛在點和假資料

接下來，我們需要建立兩個函式來生成潛在點和假資料。這些函式將在訓練過程中被使用。以下是相關程式碼：

def create_latent_points(n_samples):
    x_input = np.random.randn(LATENT_DIM * n_samples)
    z_input = x_input.reshape(n_samples, LATENT_DIM)
    labels = np.random.randint(0, NUM_OF_CLASSES, n_samples)
    return [z_input, labels]

在這個程式碼中，create_latent_points 函式生成了一個指定數量的潛在點和對應的標籤。潛在點是透過隨機生成一個張量來實作的，然後該張量被重塑為指定的形狀。

圖表翻譯：

  graph LR
    A[建立資料集] --> B[預處理資料]
    B --> C[打亂資料集]
    C --> D[批次化資料集]
    D --> E[預先載入資料集]
    E --> F[生成潛在點和假資料]
    F --> G[訓練模型]

在這個圖表中，我們可以看到建立資料集、預處理資料、打亂資料集、批次化資料集、預先載入資料集、生成潛在點和假資料以及訓練模型的過程。

生成虛擬資料的過程

在深度學習中，尤其是在生成對抗網路（GANs）中，生成虛擬資料是一個非常重要的步驟。這個步驟涉及到建立虛擬的資料點，然後使用生成器模型來生成新的資料。

從技術架構視角來看，本文深入探討了生成對抗網路（GAN），特別是條件生成對抗網路（cGAN）的架構、模型建立、訓練過程以及資料集的建立。文章詳細闡述了生成器和判別器的架構、程式碼實作以及訓練步驟，並輔以圖表說明，清晰地展現了資料從輸入到輸出的完整流程。 分析程式碼可知，cGAN 模型巧妙地利用標籤訊息引導生成過程，控制生成資料的型別，展現了其在生成特定類別資料方面的優勢。然而，訓練 GAN 模型的難點之一在於平衡生成器和判別器的訓練，避免模式當機或梯度消失等問題。 此外，模型的效能也高度依賴於資料集的品質和多樣性。展望未來，隨著技術的發展，更穩定的訓練策略和更精細的網路架構將進一步提升 cGAN 的效能，使其在影像生成、資料增強等領域發揮更大的作用。對於想要深入研究 GAN 的開發者，建議深入理解損失函式的設計以及不同網路架構的影響，並在實踐中不斷調整引數以獲得最佳效果。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。