GAN的学习 - 训练过程（冻结判别器）_gan训练过程

20200823 -

0. 引言

在前一篇文章《GAN的学习[1]》中简单介绍了构造GAN的过程，包括如何构造生成器和判别器，如何训练GAN等，但是其中存在一个问题，就是在训练过程中怎么保证判别器不更新权值。下面针对这部分进行具体的描述。
（20200910 - 增加）
经过了这段时间的学习，对这部分内容有了重新的认识。本篇文章记录的时候，我并不知道tensorflow是怎么实现这种冻结操作的， 但经过了这段时间的学习之后，对训练过程以及tensorflow和keras两种框架不同的处理方式加深了理解。

1. 整体的流程

在GAN进行工作的流程中，需要生成器和判别器的共同工作。判别器的模型使用生成器生成的数据示例和真实的样本进行二分类（可能也会是多分类，这种情况需要特殊考虑），在二分类时，一般是判定数据是真的还是假的；而生成器的训练需要利用判别器所反馈回来的信息（就是损失函数）来实现权值的更新。
（20200901 增加）

上图是GAN的原始过程，当k=1的时候（按照图中所说），也就是每训练一次判别器，就训练一次生成器。所以GAN进行训练的过程中，就是生成器和判别器相互博弈，共同提升相应性能的过程。（个人感觉如果陷入了某个最优点是不是会产生震荡呢？）
整体的训练代码如下（同样使用文章[1]引用的文章[2]来进行说明）

# train the generator and discriminator
def train(g_model, d_model, gan_model, dataset, latent_dim, n_epochs=100, n_batch=256):
	bat_per_epo = int(dataset.shape[0] / n_batch)
	half_batch = int(n_batch / 2)
	# manually enumerate epochs
	for i in range(n_epochs):
		# enumerate batches over the training set
		for j in range(bat_per_epo):
			# get randomly selected 'real' samples
			X_real, y_real = generate_real_samples(dataset, half_batch)
			# generate 'fake' examples
			X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
			# create training set for the discriminator
			X, y = vstack((X_real, X_fake)), vstack((y_real, y_fake))
			# update discriminator model weights
			d_loss, _ = d_model.train_on_batch(X, y)
			# prepare points in latent space as input for the generator
			X_gan = generate_latent_points(latent_dim, n_batch)
			# create inverted labels for the fake samples
			y_gan = ones((n_batch, 1))
			# update the generator via the discriminator's error
			g_loss = gan_model.train_on_batch(X_gan, y_gan)
			# summarize loss on this batch
			print('>%d, %d/%d, d=%.3f, g=%.3f' % (i+1, j+1, bat_per_epo, d_loss, g_loss))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

来具体描述一下上述代码的具体含义，关于batch,epochs就不再赘述，直接看最里层训练的东西。步骤如下：
1）生成真实和虚假图片，并放置于新的数据集
2）利用步骤1）中生成的完整数据集训练判别器，此时判别器肯定是能更新的
3）利用生成器来生成假图片，同时将其的标签全部定义为真实的
4）利用生成的假图片（同时标签也进行了反转）来训练GAN模型，注意此时判别器是不能更新权值的，那么这个步骤也就是完全是为了更新生成器来实现的。

注意几个细节：

1. 先进行了判别器的权值更新~~，从实际上代码反馈出来的意思可以知道，这种单独的更新方式也会导致GAN中的判别器的权值被更新（不然肯定就没有意义了）~~
2. 在训练GAN的过程中，只利用了假数据来进行训练。

同时这里需要注意的是，虽然代码前面显示训练了判别器，但是需要注意的是，这两个部分的判别器，一个会更新权值，另一个部分不会更新权值。
那么，好了， GAN大致的训练训练过程也就是知道了：就是同时训练判别器和生成器，让两者来促进整体的性能提升。下一小节来具体看各个模型之前的区别，有哪些特殊的设置，来理解为什么这样能工作。

2. 各个部分模型的构建

关于生成器和判别器的模型内部内容，这里不进行关注，本质上使用什么样的模型（什么层这种内容）应该跟具体的任务相关，与GAN的整体训练是没有关系的。
判别器模型：

# define the standalone discriminator model
def define_discriminator(in_shape=(28,28,1)):
	model = Sequential()
	model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same', input_shape=in_shape))
	model.add(LeakyReLU(alpha=0.2))
	model.add(Dropout(0.4))
	model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same'))
	model.add(LeakyReLU(alpha=0.2))
	model.add(Dropout(0.4))
	model.add(Flatten())
	model.add(Dense(1, activation='sigmoid'))
	# compile model
	opt = Adam(lr=0.0002, beta_1=0.5)
	model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
	return model
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

生成器模型：

# define the standalone generator model
def define_generator(latent_dim):
	model = Sequential()
	# foundation for 7x7 image
	n_nodes = 128 * 7 * 7
	model.add(Dense(n_nodes, input_dim=latent_dim))
	model.add(LeakyReLU(alpha=0.2))
	model.add(Reshape((7, 7, 128)))
	# upsample to 14x14
	model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
	model.add(LeakyReLU(alpha=0.2))
	# upsample to 28x28
	model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
	model.add(LeakyReLU(alpha=0.2))
	model.add(Conv2D(1, (7,7), activation='sigmoid', padding='same'))
	return model
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

GAN模型

# define the combined generator and discriminator model, for updating the generator
def define_gan(g_model, d_model):
	# make weights in the discriminator not trainable
	d_model.trainable = False
	# connect them
	model = Sequential()
	# add generator
	model.add(g_model)
	# add the discriminator
	model.add(d_model)
	# compile model
	opt = Adam(lr=0.0002, beta_1=0.5)
	model.compile(loss='binary_crossentropy', optimizer=opt)
	return model
1
2
3
4
5
6
7
8
9
10
11
12
13
14

判别器模型中，进行了相应的编译过程，而生成器模型没有进行编译过程， 本身因为他只是为了生成向量，并不是进行分类过程，同时他后面还要连接判别器模型。

重点在这里，在GAN模型的构造过程中，将判别器模型的参数trainable=False，这个步骤能够让GAN模型在训练过程中，判别器的权值不用被更新，其所传达的思想很简单，就是要在GAN训练时只更新生成器的权值。

但是，为什么这样做就能成功呢？而且，需要注意的是，判别器的模型已经编译了最后的分类过程，同时GAN中的判别器模型就是前面的判别器模型，并没有进行deepcopy之类的操作。如果不是同一个模型的话，那么判别器的单独的训练成果必然是不能提现到GAN模型中的。
所以，这里要解决的问题就是为什么这样能够实现一个能够训练（权值更新），一个不能呢？

3. trainable与compile的关系

关于这部分内容，我一开始也很疑惑，特别是同一个模型不同的地方不同的表现；这里的关键点就在于trainable与compile的设置。关于这部分内容，github上也有两个issue[3][4]与其相关，其中[3]是直接来解决这个问题的。具体来说一下[3]的内容。

把这段话直接引用过来：

By setting trainable=False after the discriminator has been compiled the discriminator is still trained during discriminator.train_on_batch but since it’s set to non-trainable before the combined model is compiled it’s not trained during combined.train_on_batch.

[3]的问题就是，判别器模型和GAN混合模型中的判别器是同一个模型，他们没有使用deepcopy之类的操作，为什么设置了trainable=False另外一个模型还能训练。
而他的解答，翻译过来就是说， 在编译了模型之后再调用这个模型的trainable=False，判别器依然是可以在他自己的训练过程中可以更新权值，而混合的GAN模型在编译之前就设置了这个参数，他的判别器就不会被更新权值。但是，他的解答只是给出了具体现象或者说结果，没有解释处具体原理。但从他的话里可以知道**关键点在于compile的部分。
在issue[4]中，提到了keras官网中给出的解释，具体内容在网址[5]的“How can I freeze layers and do fine-tuning?”部分。

Calling compile() on a model is meant to “freeze” the behavior of that model. This implies that the trainable attribute values at the time the model is compiled should be preserved throughout the lifetime of that model, until compile is called again. Hence, if you change trainable, make sure to call compile() again on your model for your changes to be taken into account.

这里的解释是从compile部分来说明：在一个模型上调用compile时，代表着将冻结这个模型的行为，那么trainable的行为，在这个模型的整个生命过程中，都将被保持，除非这个模型被二次编译。因此如果要改变行为，那么就需要重新调用compile。

从上面的解释中可以知道，compile之后，这个模型的具体内容就已经被保存了。在前面的GAN例子中就可以看到这个东西的流程，判别器模型被编译，但是在构建GAN模型时，又重新进行了设置，同时进行了编译。那么也就是说，他们时共享的权值（实际上他们使用的模型在引用上都是同一个位置），只不过在编译过程中，只有GAN设置了判别器的不可训练。
所以才会出现，两者之前使用的模型都是同一个，只不过一个是可训练，一个是不可训练；来看看issue[3]中给出的代码。

    # build the discriminator
    print('Discriminator model:')
    discriminator = build_discriminator()
    discriminator.compile(
        optimizer=Adam(lr=adam_lr, beta_1=adam_beta_1),
        loss=['binary_crossentropy', 'sparse_categorical_crossentropy']
    )
    discriminator.summary()

    # build the generator
    generator = build_generator(latent_size)

    latent = Input(shape=(latent_size, ))
    image_class = Input(shape=(1,), dtype='int32')

    # get a fake image
    fake = generator([latent, image_class])

    # we only want to be able to train generation for the combined model
    discriminator.trainable = False
    fake, aux = discriminator(fake)
    combined = Model([latent, image_class], [fake, aux])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

为了验证是否权值进行了更新，可以利用一下代码：

    for layer in self.discriminator.layers:
        print (layer.get_weights())
1
2

注：在新版的keras中，如果进行了这种设置，会导致keras产生报警，就会问你，在编译之后又设置了
trainable，但是没有调用compile，这里不一致。之前的时候看到过一篇文章说，这个警告是为了警告新用户对这部分不理解。但是也从侧面说明了前面的问题，在调用了compile之后，trainable的内容的确就伴随了编译之后的模型，所以你改了之后，系统发现了这个不一致。这部分可以在考虑考虑，但是这种方式应该是没有错误的。为了摆脱这种警告，文章[6]采用的方式是在训练之前，分别修改trainable参数，具体如下：

# Train discriminator
discriminator.trainable = True                            # get rid of warning messages (doesn't affect training)
dloss = discriminator.train_on_batch(x_all, y_all)        # this trains only discriminator, doesn't touch gen.
        
noise = np.random.normal(size=[n_batch, 100])
y_fake = np.ones([n_batch, 1])
discriminator.trainable = False                           # get rid of warning messages 
gloss = gan_model.train_on_batch(noise, y_fake)
1
2
3
4
5
6
7
8

4. 总结

本篇文章中，讲解了前面的疑惑，就是为什么这样设置能够同时以两种属性对待同一个模型，其实本质上就是compile的问题。虽然这部分问题产生于GAN的学习过程中，但实际上在迁移学习，或者使用以后的一些模型例如vgg这种时，都会有这种需求，也就是保证某层或者整个模型的参数不更新。

参考文章

[1]GAN的学习
[2]How to Develop a GAN for Generating MNIST Handwritten Digits
[3]puzzled about “discriminator.trainable=False”
[4]Keras setting discriminator to non-trainable forever
[5]Keras FAQ
[6]3110_GAN_FC_MNIST.html