发 帖  
原厂入驻New

[经验] 95zz44

2019-7-12 04:00:00  833 python 深度学习 机器学习
分享
1
章节目录

  • SGAN
  • 代码实现
  • 训练
  • 结束语

01

SGAN
什么是生成对抗网络:
1.jpg
简单的来说,就是给定一个噪声z的输入,通过生成器的变换把噪声的概率分布空间尽可能的去拟合真实数据的分布空间。


基本框架:
2.jpg
在这里,我们把生成器看的目标看成是要“以假乱真”,判别器的目标是要“明辩真假”。


核心公式:
3.jpg
这个公式我们要分成两个部分来看,先看前半部分:
4.png
这个公式的意思是,先看加号前面Ex~pdata(x) [logD(x)] ,我们希望D最大,所以log(D(x))应该最大,意味着我的判别器可以很好的识别出,真实世界图像是"true",在看加号后面Ez~pz(z) [log(1-D(G(z)))],要让log尽可能的大,需要的是D(G(z))尽可能的小,意味着我们生成模型的图片应该尽可能的被判别模型视为"FALSE"。
再看后半部分:
5.png
我们应该让G尽可能的小,加号前面的式子并没有G,所以无关,在看加号后面的式子Ez~pz(z) [log(1-D(G(z)))],要让G尽可能地小,就要D(G(Z))尽可能的大,也就是说本来就一张→噪声生成的图片,判别器却被迷w惑了,以为是一张真实世界图片。这就是所谓的以假乱真。
6.jpg

02



代码实现
生成器:
  1. ```python
  2.     def build_generator(self):

  3.         model = Sequential()

  4.         model.add(Dense(256, input_dim=self.latent_dim))
  5.         model.add(LeakyReLU(alpha=0.2))
  6.         model.add(BatchNormalization(momentum=0.8))
  7.         model.add(Dense(512))
  8.         model.add(LeakyReLU(alpha=0.2))
  9.         model.add(BatchNormalization(momentum=0.8))
  10.         model.add(Dense(1024))
  11.         model.add(LeakyReLU(alpha=0.2))
  12.         model.add(BatchNormalization(momentum=0.8))
  13.         model.add(Dense(np.prod(self.img_shape), activation='tanh'))
  14.         model.add(Reshape(self.img_shape))

  15.         model.summary()

  16.         noise = Input(shape=(self.latent_dim,))
  17.         img = model(noise)

  18.         return Model(noise, img)
  19. ```
复制代码
生成器的输入是一个100维服从高斯分布的向量,输出是一张28*28*1的图片。  
  1. ```
  2. _________________________________________________________________
  3. Layer (type)                 Output Shape              Param #  
  4. =================================================================
  5. input_2 (InputLayer)         (None, 100)               0        
  6. _________________________________________________________________
  7. sequential_2 (Sequential)    (None, 28, 28, 1)         1493520  
  8. =================================================================
  9. Total params: 1,493,520
  10. Trainable params: 1,489,936
  11. Non-trainable params: 3,584
  12. ```
复制代码

判别器:
  1. ```python
  2.     def build_discriminator(self):

  3.         model = Sequential()

  4.         model.add(Flatten(input_shape=self.img_shape))
  5.         model.add(Dense(512))
  6.         model.add(LeakyReLU(alpha=0.2))
  7.         model.add(Dense(256))
  8.         model.add(LeakyReLU(alpha=0.2))
  9.         model.add(Dense(1, activation='sigmoid'))
  10.         model.summary()

  11.         img = Input(shape=self.img_shape)
  12.         validity = model(img)

  13.         return Model(img, validity)

  14. ```
复制代码


判别器的输入是一张28*28*1的图片和一个一维的真假标签,1代表是真实世界图片,0代表的的生成模型生成的图片。
  1. ```
  2. _________________________________________________________________
  3. Layer (type)                 Output Shape              Param #  
  4. =================================================================
  5. input_1 (InputLayer)         (None, 28, 28, 1)         0        
  6. _________________________________________________________________
  7. sequential_1 (Sequential)    (None, 1)                 533505   
  8. =================================================================
  9. Total params: 533,505
  10. Trainable params: 533,505
  11. Non-trainable params: 0
  12. ```
复制代码

注意了!在SGAN(2104)中,作者并没有用卷积池化等操作,他只是用了最简单的full connection全连接层。

03
训练
条件随机场(Conditional Random Field,简称CRF)是一种判别式无向图模型。生成式模型是直接对联合分布进行建模,而判别式模型则是对条件分布进行建模。前面介绍的隐马尔可夫模型和马尔可夫随机场都是生成式模型,而条件随机场是判别式模型。
定义模型:
  1. ```python

  2. def __init__(self):
  3.         self.img_rows = 28
  4.         self.img_cols = 28
  5.         self.channels = 1
  6.         self.img_shape = (self.img_rows, self.img_cols, self.channels)
  7.         self.latent_dim = 100

  8.         optimizer = Adam(0.0002, 0.5)

  9.         # Build and compile the discriminator
  10.         self.discriminator = self.build_discriminator()
  11.         self.discriminator.summary()
  12.         self.discriminator.compile(loss='binary_crossentropy',
  13.             optimizer=optimizer,
  14.             metrics=['accuracy'])

  15.         # Build the generator
  16.         self.generator = self.build_generator()
  17.         self.generator.summary ()
  18.         # The generator takes noise as input and generates imgs
  19.         z = Input(shape=(self.latent_dim,))
  20.         img = self.generator(z)

  21.         # For the combined model we will only train the generator
  22.         self.discriminator.trainable = False

  23.         # The discriminator takes generated images as input and determines validity
  24.         validity = self.discriminator(img)
  25.         # The combined model  (stacked generator and discriminator)
  26.         # Trains the generator to fool the discriminator
  27.         self.combined = Model(z, validity)
  28.         self.combined.summary()
  29.         self.combined.compile(loss='binary_crossentropy', optimizer=optimizer
  30. ```
复制代码

判别器discriminator只训练判别器的参数;生成器的训练是把生成器和判别器两个网络连在一起,但是冻结判别器的学习率,一起组成combined.用的都是binary_crossentropy二分类的交叉熵作为损失函数.


训练部分:
  1. ```
  2. def train(self, epochs, batch_size=128, sample_interval=50):

  3.     # Load the dataset
  4.     (X_train, _), (_, _) = mnist.load_data()

  5.     # Rescale -1 to 1
  6.     X_train = X_train / 127.5 - 1.
  7.     X_train = np.expand_dims(X_train, axis=3)

  8.     # Adversarial ground truths
  9.     valid = np.ones((batch_size, 1))
  10.     fake = np.zeros((batch_size, 1))

  11.     for epoch in range(epochs):

  12.         # ---------------------
  13.         #  Train Discriminator
  14.         # ---------------------

  15.         # Select a random batch of images
  16.         idx = np.random.randint(0, X_train.shape[0], batch_size)
  17.         imgs = X_train[idx]

  18.         noise = np.random.normal(0, 1, (batch_size, self.latent_dim))

  19.         # Generate a batch of new images
  20.         gen_imgs = self.generator.predict(noise)

  21.         # Train the discriminator
  22.         d_loss_real = self.discriminator.train_on_batch(imgs, valid)
  23.         d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
  24.         d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

  25.         # ---------------------
  26.         #  Train Generator
  27.         # ---------------------

  28.         noise = np.random.normal(0, 1, (batch_size, self.latent_dim))

  29.         # Train the generator (to have the discriminator label samples as valid)
  30.         g_loss = self.combined.train_on_batch(noise, valid)

  31.         # Plot the progress
  32.         print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))

  33.         # IF at save interval => save generated image samples
  34.         if epoch % sample_interval == 0:
  35.             self.sample_images(epoch)
  36. ```
复制代码

先加载数据集,然后每一次训练从数据集里面随机选取一张图片进行训练,训练的时候,真实图片对应的标签是valid=1,生成器生成的图片对应的标签是fake=0;
训练的时候,先训练dloss,dloss由真实世界图片和生成图片以及其标签进行训练.在训练判别器的时候,真实世界图片对应真实的标签valid,生成的图片对应fake标签,也就是让判别器"明辨真假"的过程.在训练生成器的时候,我们输入高斯噪声和噪声标签,等于是告诉生成对抗网络,我给你一个"假的"图片,但是是"真的"标签,也就是我们让生成器以假乱真的过程.不断的在"明辨真假"和"以假乱真"的两个过程不断迭代训练,最终,生成器可以很好的"以假乱真",判别器可以很好的"明辨真假".当我们把生成器的图片给"人"看的时候,人就会被"以假乱真"了。

在服务器上训练:

在训练了30000epoch后
  1. ```
  2. 30000 [D loss: 0.693933, acc.: 57.81%] [G loss: 0.853226]

  3. ```
复制代码
7.jpg



评论

高级模式
您需要登录后才可以回帖 登录 | 注册

发经验
关闭

推荐 上一条 /10 下一条

快速回复 返回顶部 返回列表

九五至尊娱乐官网