StackedGAN详解与实现

0. 前言

生成对抗网络 (Generative Adversarial Network, GAN) 能够通过学习数据分布生成具有意义的输出，但无法控制生成结果的具体特征。像条件生成对抗网络 (CGAN) 和辅助分类器生成对抗网络 (ACGAN) 这样的 GAN 变体，能够训练出特定条件下合成指定输出的生成器。例如，CGAN 和 ACGAN 都可以引导生成器生成特定的 MNIST 手写数字——这是通过同时使用 100 维噪声编码与对应的独热标签作为输入来实现的。但除了独热标签之外，我们仍缺乏控制生成结果其他属性的方法。
本节将介绍能实现对生成器输出进行调控的 GAN 变体，StackedGAN。StackedGAN 采用预训练的编码器或分类器来辅助解耦潜编码。该模型可视为由多个子模块堆叠而成，每个子模块均由编码器与生成对抗网络组成。各层 GAN 通过对应编码器的输入输出数据，以对抗训练方式进行学习。

1. StackedGAN 原理

与 InfoGAN 的理念相似，StackedGAN 提出了一种解耦潜表征的方法，用于条件化生成器的输出。然而，StackedGAN 采用了不同的解决思路：该模型不是学习如何通过调节噪声来产生目标输出，而是将单一 GAN 拆解为多层 GAN 的堆叠结构。每个 GAN 都使用独立的潜编码，按照判别器-生成器对抗的标准方式分别进行训练。下图展示了 StackedGAN 的工作流程，其中编码器网络已通过分类任务完成训练：

编码器网络由一系列简单编码器 ($E_i,i=0,..,n-1$) 堆叠而成，分别对应 $n$ 种特征维度。每个编码器负责提取特定特征，例如在人脸图像生成中，$E_0$ 可专门提取发型特征 $h_1$。所有简单编码器协同工作，确保整体编码器能实现准确预测。
StackedGAN 的核心思路在于：若要构建能生成逼真图像的 GAN，只需对编码器进行逆向操作。该模型由多个简单 GAN ($G_i,i=0,…,n-1) 堆叠构成，分别对应 $n$ 种特征。每个 $G_i$ 学习逆转其对应编码器 $E_i$ 的处理流程，例如 $G_0$ 即通过伪造发型特征来生成伪造人脸图像，这与 $E_0$ 的提取过程形成逆向关系。
每个 $G_i$ 通过潜编码 $z_i$ 来条件化其生成器输出。以人脸图像生成为例，潜编码 $z_0$ 可实现从卷发到波浪发的发型变换。整个 GAN 堆栈可协同运作，合成完整的人脸图像，从而完成对整个编码器的逆向重构。各 $G_i$ 的潜编码 $z_i$ 可独立调控生成面容的特定属性。
在了解 StackedGAN 核心原理后，我们将使用 tf.keras 实现 StackedGAN。

2. 使用 Keras 实现 StackedGAN

2.1 编码器

为简洁起见，本节使用两个 编码器-GAN 组合单元，只要掌握单个单元的训练方法，其余部分均可沿用相同原理。StackedGAN 的起点是一个编码器。该编码器可以是经过训练能够准确预测标签的分类器。其中间特征向量 $f_1$ 将用于 GAN 的训练。对于 MNIST 数据集，我们可以采用基于 CNN 的分类器，使用全连接层来提取 256 维特征。编码器具有两个输出 $E_0$ 和 $E_1$，这两个模型都将用于训练 StackedGAN。

def build_encoder(inputs,num_labels=10,feature1_dim=256):kernel_size = 3filters = 64x,feature1 = inputs# Encoder0 or enc0y = keras.layers.Conv2D(filters=filters,kernel_size=kernel_size,padding='same',activation='relu')(x)y = keras.layers.MaxPool2D()(y)y = keras.layers.Conv2D(filters=filters,kernel_size=kernel_size,padding='same',activation='relu')(y)y = keras.layers.MaxPooling2D()(y)y = keras.layers.Flatten()(y)feature1_output = keras.layers.Dense(feature1_dim,activation='relu')(y)#Encoder0 or enc0: image (x or feature0) to feature1enc0 = keras.Model(inputs=x,outputs=feature1_output,name='encoder0')#Encoder1 or enc1y = keras.layers.Dense(num_labels)(feature1)labels = keras.layers.Activation('softmax')(y)#Encoder1 or enc1: feature1 to class labels (feature2)enc1 = keras.Model(inputs=feature1,outputs=labels,name='encoder1')#return both enc0,enc1return enc0,enc1

$E_0$ 的输出 $h_1$ 是一个256维特征向量，这正是我们希望 $G_1$ 学习生成的目标。该特征向量作为编码器 $E_0$ 的辅助输出而存在。整体编码器通过训练可实现对 MNIST 数字 $x$ 的分类任务，其标签 $y$ 由编码器 $E_1$ 进行预测。在此过程中，中间特征集 $h_1$ 被学习提取，并作为 $G_0$ 的训练数据。

2.2 损失函数

在编码器接收输入 ($x$)、中间特征 ($h_1$) 和标签 ($y$)的前提下，每个 GAN 均采用判别器-生成器对抗的标准训练方式。其损失函数如下所示，StackedGAN 额外引入了条件损失和熵损失两个函数。

网络结构	损失函数
GAN	$$\begin{gathered} {\mathcal{L}}^{(D)}=-{\mathbb{E}}_{x\sim p_{data}}logD(x)-{\mathbb{E}}_{z}log(1-D(G(z))) \\ {\mathcal{L}}^{(G)}=-{\mathbb{E}}_{z}logD(G(z)) \end{gathered}$$
StackedGAN	$$\begin{gathered} {\mathcal{L}}_i^{(D)}=-{\mathbb{E}}_{h_i\sim p_{data}}logD(h_i)-{\mathbb{E}}_{h_{i+1}\sim p_{data},z_i}log(1-D(G(h_{i+1},z_i))) \\ {\mathcal{L}}_i^{(G)adv}=-{\mathbb{E}}_{h_{i+1}\sim p_{data},z_i}logD(G(h_{i+1},z_i)) \\ {\mathcal{L}}_i^{(G)cond}=||E_i(G(h_{i+1},z_i)),f_i|{|}_2 \\ {\mathcal{L}}_i^{(G)ent}=||Q_i(G(h_{i+1},z_i)),z_i|{|}_2 \\ {\mathcal{L}}_i^{(G)}={\lambda }_1{\mathcal{L}}_i^{(G)adv}+{\lambda }_2{\mathcal{L}}_i^{(G)cond}+{\lambda }_3{\mathcal{L}}_i^{(G)ent} \end{gathered}$$

其中 ${\lambda }_1$，${\lambda }_2$，${\lambda }_3$ 为权重系数，$i$ 代表编码器和 GAN 的标识符。条件损失函数 ${\mathcal{L}}_i^{(G)cond}$ 用于确保生成器在根据输入噪声代码 $z_i$ 生成输出 $h_i$ 时不会忽略输入 $f_{i+1}$。编码器 $E_i$ 必须能够通过逆转生成器 $G_i$ 的流程来恢复生成器的输入。生成器输入与通过编码器恢复的输入之间的差异通过 L2 范数(欧几里得距离)或均方误差 (mean squared error, MSE)来衡量。
然而，条件损失函数引入了一个新问题：生成器会忽略输入噪声编码 $z_i$，仅依赖 $f_{i+1}$。熵损失函数 ${\mathcal{L}}_i^{(G)ent}$ 则确保生成器不会忽略噪声编码 $z_i$——Q网络从生成器输出中重建噪声编码，重建噪声与输入噪声之间的差异同样通过 L2 范数(均方误差)衡量。
最终损失函数与常规 GAN 损失函数类似，包含判别器损失 ${\mathcal{L}}_i^{(D)}$ 和生成器对抗损失 ${\mathcal{L}}_i^{(G)adv}$。三个生成器损失函数的加权和构成了最终生成器损失。原始论文中，网络先进行独立训练再进行联合训练：独立训练阶段首先训练编码器，联合训练阶段则同时使用真实数据和生成数据。

2.3 生成器

构建两个生成器 gen0 和 gen1，分别对应 $G_0$ 和 $G_1$。gen0 生成器可以使用 gan.py 中的生成器构建器来实例化，以特征 $h_1$ 和噪声编码 $z_0$ 作为输入，其输出是生成的伪造图像 $\hat{x}$。gen1 生成器由三个全连接层构成，以标签和噪声编 ${\hat{z}}_1$ 作为输入，第三层生成伪造特征 ${\hat{h}}_1$。

def build_generator(latent_codes,image_size,feature1_dim=256):#latent codes and network parameterslabels,z0,z1,feature1 = latent_codes#image_resize = image_size // 4#kernel_size = 5#layer_filters = [128,64,32,1]#gen1 inputsinputs = [labels,z1] #10+50=60-dimx = keras.layers.concatenate(inputs,axis=1)x = keras.layers.Dense(512,activation='relu')(x)x = keras.layers.BatchNormalization()(x)x = keras.layers.Dense(512,activation='relu')(x)x = keras.layers.BatchNormalization()(x)fake_feature1 = keras.layers.Dense(feature1_dim,activation='relu')(x)#gen1: classes and noise (feature2 + z1) to feature1gen1 = keras.Model(inputs,fake_feature1,name='gen1')#gen0: feature1 + z0 to feature0 (image)gen0 = gan.generator(feature1,image_size,codes=z0)return gen0,gen1

判别器 $D_0$ 和 $D_1$ (分别对应 dis0 与 dis1 )，其中 dis0 的结构与常规 GAN 判别器类似，但其特殊性在于：既接收特征向量作为输入，又包含用于重建 $z_0$ 的辅助网络 $Q_0$；dis1 判别器则采用三层 MLP 结构，其最后一层负责区分真实与伪造的 $h_1$ 特征。$Q_1$ 网络与 dis1 共享前两层网络权重，并通过第三层网络实现 $z_1$ 的重建。

def build_disciminator(inputs,z_dim=50):#input is 256-dim feature1x = keras.layers.Dense(256,activation='relu')(inputs)x = keras.layers.Dense(256,activation='relu')(x)# first output is probality that feature1 is realf1_source = keras.layers.Dense(1)(x)f1_source = keras.layers.Activation('sigmoid',name='feature1_source')(f1_source)#z1 reonstruction (Q1 network)z1_recon = keras.layers.Dense(z_dim)(x)z1_recon = keras.layers.Activation('tanh',name='z1')(z1_recon)discriminator_outputs = [f1_source,z1_recon]dis1 = keras.Model(inputs,discriminator_outputs,name='dis1')return dis1

在训练 StackedGAN 之前，编码器已进行预训练。需要注意的是，我们已将三种生成器损失函数(对抗损失、条件损失和熵损失)整合到对抗模型的训练中。由于 Q 网络与判别器模型共享部分公共层，因此其损失函数也一并纳入判别器模型的训练流程。

def build_and_train_models():#build StackedGAN#数据加载(x_train,y_train),(x_test,y_test) = keras.datasets.mnist.load_data()image_size = x_train.shape[1]x_train = np.reshape(x_train,[-1,image_size,image_size,1])x_train = x_train.astype('float32') / 255.x_test = np.reshape(x_test,[-1,image_size,image_size,1])x_test = x_test.astype('float32') / 255.num_labels = len(np.unique(y_train))y_train = keras.utils.to_categorical(y_train)y_test = keras.utils.to_categorical(y_test)#超参数model_name = 'stackedGAN_mnist'batch_size = 64train_steps = 40000lr = 2e-4decay = 6e-8input_shape = (image_size,image_size,1)label_shape = (num_labels,)z_dim = 50z_shape = (z_dim,)feature1_dim = 256feature1_shape = (feature1_dim,)#discriminator 0 and Q network 0 modelsinputs = keras.layers.Input(shape=input_shape,name='discriminator0_input')dis0 = gan.discriminator(inputs,num_codes=z_dim)optimizer = keras.optimizers.RMSprop(lr=lr,decay=decay)# 损失函数：1）图像是真实的概率# 2）MSE z0重建损失loss = ['binary_crossentropy','mse']loss_weights = [1.0,10.0]dis0.compile(loss=loss,loss_weights=loss_weights,optimizer=optimizer,metrics=['accuracy'])dis0.summary()#discriminator 1 and Q network 1 modelsinput_shape = (feature1_dim,)inputs = keras.layers.Input(shape=input_shape,name='discriminator1_input')dis1 = build_disciminator(inputs,z_dim=z_dim)# 损失函数: 1) feature1是真实的概率 (adversarial1 loss)# 2) MSE z1 重建损失 (Q1 network loss or entropy1 loss)loss = ['binary_crossentropy','mse']loss_weights = [1.0,1.0]dis1.compile(loss=loss,loss_weights=loss_weights,optimizer=optimizer,metrics=['acc'])dis1.summary()keras.utils.plot_model(dis0,to_file='dis0.png',show_shapes=True)keras.utils.plot_model(dis1,to_file='dis1.png',show_shapes=True)#generator modelsfeature1 = keras.layers.Input(shape=feature1_shape,name='featue1_input')labels = keras.layers.Input(shape=label_shape,name='labels')z1 = keras.layers.Input(shape=z_shape,name='z1_input')z0 = keras.layers.Input(shape=z_shape,name='z0_input')latent_codes = (labels,z0,z1,feature1)gen0,gen1 = build_generator(latent_codes,image_size)gen0.summary()gen1.summary()keras.utils.plot_model(gen0,to_file='gen0.png',show_shapes=True)keras.utils.plot_model(gen1,to_file='gen1.png',show_shapes=True)#encoder modelsinput_shape = (image_size,image_size,1)inputs = keras.layers.Input(shape=input_shape,name='encoder_input')enc0,enc1 = build_encoder((inputs,feature1),num_labels)enc0.summary()enc1.summary()encoder = keras.Model(inputs,enc1(enc0(inputs)))encoder.summary()keras.utils.plot_model(enc0,to_file='enc0.png',show_shapes=True)keras.utils.plot_model(enc1,to_file='enc1.png',show_shapes=True)keras.utils.plot_model(encoder,to_file='encoder.png',show_shapes=True)data = (x_train,y_train),(x_test,y_test)train_encoder(encoder,data,model_name=model_name)#adversarial0 model = generator0 + discrimnator0 + encoder0optimizer = keras.optimizers.RMSprop(lr=lr*0.5,decay=decay*0.5)enc0.trainable = Falsedis0.trainable = Falsegen0_inputs = [feature1,z0]gen0_outputs = gen0(gen0_inputs)adv0_outputs = dis0(gen0_outputs) + [enc0(gen0_outputs)]adv0 = keras.Model(gen0_inputs,adv0_outputs,name='adv0')# 损失函数：1）feature1是真实的概率# 2）Q network 0 损失# 3）condition0 损失loss = ['binary_crossentropy','mse','mse']loss_weights = [1.0,10.0,1.0]adv0.compile(loss=loss,loss_weights=loss_weights,optimizer=optimizer,metrics=['acc'])adv0.summary()#adversarial1 model = generator1 + discrimnator1 + encoder1enc1.trainable = Falsedis1.trainable = Falsegen1_inputs = [labels,z1]gen1_outputs = gen1(gen1_inputs)adv1_outputs = dis1(gen1_outputs) + [enc1(gen1_outputs)]adv1 = keras.Model(gen1_inputs,adv1_outputs,name='adv1')#损失函数：1）标签是真实的概率#2）Q network 1 损失#3）conditional1 损失loss_weights = [1.0,1.0,1.0]loss = ['binary_crossentropy','mse','categorical_crossentropy']adv1.compile(loss=loss,loss_weights=loss_weights,optimizer=optimizer,metrics=['acc'])adv1.summary()keras.utils.plot_model(adv0,to_file='adv0.png',show_shapes=True)keras.utils.plot_model(adv1,to_file='adv1.png',show_shapes=True)models = (enc0,enc1,gen0,gen1,dis0,dis1,adv0,adv1)params = (batch_size,train_steps,num_labels,z_dim,model_name)train(models,data,params)

训练函数与经典 GAN 训练流程类似，不同之处在于我们每次仅训练一个 GAN (即先训练 $G_1$，再训练 $G_0$)：

1. 训练判别器1 (dis1) 和 $Q_1$ 网络：通过最小化判别器损失和熵损失
2. 训练判别器0 (dis0）和 $Q_0$ 网络：通过最小化判别器损失和熵损失
3. 训练对抗网络1 (adv1)：通过最小化对抗损失、熵损失和条件损失
4. 训练对抗网络0 (adv0)：通过最小化对抗损失、熵损失和条件损失

def train_encoder(model,data,model_name='stackedgan_mnist',batch_size=64):(x_train,y_train),(x_test,y_test) = datamodel.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['acc'])model.fit(x_train,y_train,validation_data=(x_test,y_test),epochs=20,batch_size=batch_size)model.save(model_name + '-encoder.h5')score = model.evaluate(x_test,y_test,batch_size=batch_size,verbose=0)print("\nTest accuracy: %.1f%%" % (100.0 * score[1]))def train(models,data,params):enc0,enc1,gen0,gen1,dis0,dis1,adv0,adv1 = modelsbatch_size,train_steps,num_labels,z_dim,model_name = params(x_train,y_train),_ = datasave_interval = 500z0 = np.random.normal(scale=0.5,size=[16,z_dim])z1 = np.random.normal(scale=0.5,size=[16,z_dim])noise_class = np.eye(num_labels)[np.arange(0,16) % num_labels]noise_params = [noise_class,z0,z1]train_size = x_train.shape[0]print(model_name,'labels for generated images: ',np.argmax(noise_class,axis=1))for i in range(train_steps):rand_indexes = np.random.randint(0,train_size,size=batch_size)real_images = x_train[rand_indexes]# real feature1 from encoder0 outputreal_feature1 = enc0.predict(real_images)# generate random 50-dim z1 latent codereal_z1 = np.random.normal(scale=0.5,size=[batch_size,z_dim])#real labelsreal_labels = y_train[rand_indexes]#generate fake feature1 using generator1 from real labels and 50-dim z1 latent codefake_z1 = np.random.normal(scale=0.5,size=[batch_size,z_dim])fake_feature1 = gen1.predict([real_labels,fake_z1])#real + fake datafeature1 = np.concatenate((real_feature1,fake_feature1))z1 = np.concatenate((real_z1,fake_z1))#label 1st half as real and 2nd half as fakey = np.ones([2*batch_size,1])y[batch_size:,:] = 0#train discriminator1 to classify feature1 as real/fake and recovermetrics = dis1.train_on_batch(feature1,[y,z1])log = "%d: [dis1_loss: %f]" % (i, metrics[0])#train the discriminator0 for 1 batch#1 batch of reanl and fake imagesreal_z0 = np.random.normal(scale=0.5,size=[batch_size,z_dim])fake_z0 = np.random.normal(scale=0.5,size=[batch_size,z_dim])fake_images = gen0.predict([real_feature1,fake_z0])#real + fake datax = np.concatenate((real_images,fake_images))z0 = np.concatenate((real_z0,fake_z0))#train discriminator0 to classify image as real/fake and recover latent code (z0)metrics = dis0.train_on_batch(x,[y,z0])log = "%s [dis0_loss: %f]" % (log, metrics[0])# 对抗训练# 生成fake z1，labelsfake_z1 = np.random.normal(scale=0.5,size=[batch_size,z_dim])#input to generator1 is sampling fr real labels and 50-dim z1 latent codegen1_inputs = [real_labels,fake_z1]y = np.ones([batch_size,1])#train generator1metrics = adv1.train_on_batch(gen1_inputs,[y,fake_z1,real_labels])fmt = "%s [adv1_loss: %f, enc1_acc: %f]"log = fmt % (log, metrics[0], metrics[6])# input to generator0 is real feature1 and 50-dim z0 latent codefake_z0 = np.random.normal(scale=0.5,size=[batch_size,z_dim])gen0_inputs = [real_feature1,fake_z0]#train generator0metrics = adv0.train_on_batch(gen0_inputs,[y,fake_z0,real_feature1])log = "%s [adv0_loss: %f]" % (log, metrics[0])print(log)if (i + 1) % save_interval == 0:genenators = (gen0,gen1)plot_images(genenators,noise_params=noise_params,show=False,step=(i+1),model_name=model_name)gen1.save(model_name + '-gen1.h5')gen0.save(model_name + '-gen0.h5')

3. 生成结果

模型训练完成后，将 $G0$ 和 $G_1$ 堆叠，整个系统能够根据标签及噪声代码 $z_0$ 和 $z_1$ 生成对应的伪造图像。
(1) 保持噪声代码 $z_0$ 和 $z_1$ 采样自均值为 0.5、标准差为 1.0 的正态分布，将离散标签从 0 到 9 依次调整。可以观察到 StackedGAN 的离散代码能够控制生成器输出的数字形态：

$ python3 stackedgan-mnist.py --generator0=stackedgan_mnist-gen0.h5 --generator1=stackedgan_mnist-gen1.h5 --digit=0

(2) 将第一个噪声编码 $z_0$ 作为从 -4.0 到 4.0 的恒定向量，第二个噪声代码 $z_1$ 设置为零向量。表明第一个噪声编码主要控制笔划粗细，以数字 2 为例：

python stackedgan-mnist.py --generator0=stackedgan_mnist-gen0.h5 --generator1=stackedgan_mnist-gen1.h5 --z0=0 --z1=0 --p0--digit=2

(3) 将第二个噪声代码 $z_1$ 作为从 -1.0 到 1.0 的恒定向量，此时第一个噪声代码 $z_0$ 设置为零向量。下图显示第二个噪声代码主要控制数字的旋转角度(倾斜度)，并在一定程度上影响笔划粗细，以数字 8 为例：

python stackedgan-mnist.py --generator0=stackedgan_mnist-gen0.h5 --generator1=stackedgan_mnist-gen1.h5 --z0=0 --z1=0 --p1 --digit=8