devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深度卷积生成对抗网络DCGAN——生成手写数字图片_生成对抗网络实现手写数字

作者：2023面试高手 | 2024-02-16 14:37:12

赞

踩

生成对抗网络实现手写数字

前言

本文使用深度卷积生成对抗网络（DCGAN）生成手写数字图片，代码使用Keras API与tf.GradientTape 编写的，其中tf.GradientTrape是训练模型时用到的。

 本文用到imageio 库来生成gif图片，如果没有安装的，需要安装下：

  1. # 用于生成 GIF 图片
  2. pip install -q imageio

目录

前言

一、什么是生成对抗网络？

二、加载数据集

三、创建模型

3.1 生成器

3.1 判别器

四、定义损失函数和优化器

4.1 生成器的损失和优化器

4.2 判别器的损失和优化器

五、训练模型

5.1 保存检查点

5.2 定义训练过程

5.3 训练模型

六、评估模型

一、什么是生成对抗网络？

生成对抗网络（GAN），包含生成器和判别器，两个模型通过对抗过程同时训练。

生成器，可以理解为“艺术家、创造者”，它学习创造看起来真实的图像。

判别器，可以理解为“艺术评论家、审核者”，它学习区分真假图像。

训练过程中，生成器在生成逼真图像方便逐渐变强，而判别器在辨别这些图像的能力上逐渐变强。

当判别器不能再区分真实图片和伪造图片时，训练过程达到平衡。

本文，在MNIST数据集上演示了该过程。随着训练的进行，生成器所生成的一系列图片，越来越像真实的手写数字。

二、加载数据集

使用MNIST数据，来训练生成器和判别器。生成器将生成类似于MNIST数据集的手写数字。

  1. (train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()
  2.  
  3. train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
  4. train_images = (train_images - 127.5) / 127.5 # 将图片标准化到 [-1, 1] 区间内
  5.  
  6. BUFFER_SIZE = 60000
  7. BATCH_SIZE = 256
  8.  
  9. # 批量化和打乱数据
  10. train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)

三、创建模型

主要创建两个模型，一个是生成器，另一个是判别器。

3.1 生成器

生成器使用 tf.keras.layers.Conv2DTranspose 层，来从随机噪声中产生图片。

然后把从随机噪声中产生图片，作为输入数据，输入到Dense层，开始。

后面，经过多次上采样，达到所预期 28x28x1 的图片尺寸。

  1. def make_generator_model():
  2.     model = tf.keras.Sequential()
  3.     model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
  4.     model.add(layers.BatchNormalization())
  5.     model.add(layers.LeakyReLU())
  6.  
  7.     model.add(layers.Reshape((7, 7, 256)))
  8.     assert model.output_shape == (None, 7, 7, 256) # 注意：batch size 没有限制
  9.  
  10.     model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
  11.     assert model.output_shape == (None, 7, 7, 128)
  12.     model.add(layers.BatchNormalization())
  13.     model.add(layers.LeakyReLU())
  14.  
  15.     model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
  16.     assert model.output_shape == (None, 14, 14, 64)
  17.     model.add(layers.BatchNormalization())
  18.     model.add(layers.LeakyReLU())
  19.  
  20.     model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
  21.     assert model.output_shape == (None, 28, 28, 1)
  22.  
  23.     return model

用tf.keras.utils.plot_model( )，看一下模型结构

 

用summary()，看一下模型结构和参数

使用尚未训练的生成器，创建一张图片，这时的图片是随机噪声中产生。

  1. generator = make_generator_model()
  2.  
  3. noise = tf.random.normal([1, 100])
  4. generated_image = generator(noise, training=False)
  5.  
  6. plt.imshow(generated_image[0, :, :, 0], cmap='gray')

3.1 判别器

判别器是基于 CNN卷积神经网络 的图片分类器。

  1. def make_discriminator_model():
  2.     model = tf.keras.Sequential()
  3.     model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',
  4.                                      input_shape=[28, 28, 1]))
  5.     model.add(layers.LeakyReLU())
  6.     model.add(layers.Dropout(0.3))
  7.  
  8.     model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
  9.     model.add(layers.LeakyReLU())
  10.     model.add(layers.Dropout(0.3))
  11.  
  12.     model.add(layers.Flatten())
  13.     model.add(layers.Dense(1))
  14.  
  15.     return model

用tf.keras.utils.plot_model( )，看一下模型结构

用summary()，看一下模型结构和参数

四、定义损失函数和优化器

由于有两个模型，一个是生成器，另一个是判别器；所以要分别为两个模型定义损失函数和优化器。

首先定义一个辅助函数，用于计算交叉熵损失的，这个两个模型通用。

  1. # 该方法返回计算交叉熵损失的辅助函数
  2. cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)

4.1 生成器的损失和优化器

1）生成器损失

生成器损失，是量化其欺骗判别器的能力；如果生成器表现良好，判别器将会把伪造图片判断为真实图片（或1）。

这里我们将把判别器在生成图片上的判断结果，与一个值全为1的数组进行对比。

  1. def generator_loss(fake_output):
  2.     return cross_entropy(tf.ones_like(fake_output), fake_output)

2）生成器优化器

generator_optimizer = tf.keras.optimizers.Adam(1e-4)

4.2 判别器的损失和优化器

1）判别器损失

判别器损失，是量化判断真伪图片的能力。它将判别器对真实图片的预测值，与全值为1的数组进行对比；将判别器对伪造（生成的）图片的预测值，与全值为0的数组进行对比。

  1. def discriminator_loss(real_output, fake_output):
  2.     real_loss = cross_entropy(tf.ones_like(real_output), real_output)
  3.     fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
  4.     total_loss = real_loss + fake_loss
  5.     return total_loss

2）判别器优化器

discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)

五、训练模型

5.1 保存检查点

保存检查点，能帮助保存和恢复模型，在长时间训练任务被中断的情况下比较有帮助。

  1. checkpoint_dir = './training_checkpoints'
  2. checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
  3. checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
  4.                                  discriminator_optimizer=discriminator_optimizer,
  5.                                  generator=generator,
  6.                                  discriminator=discriminator)

5.2 定义训练过程

  1. EPOCHS = 50
  2. noise_dim = 100
  3. num_examples_to_generate = 16
  4.  
  5.  
  6. # 我们将重复使用该种子（因此在动画 GIF 中更容易可视化进度）
  7. seed = tf.random.normal([num_examples_to_generate, noise_dim])

训练过程中，在生成器接收到一个“随机噪声中产生的图片”作为输入开始。

判别器随后被用于区分真实图片（训练集的）和伪造图片（生成器生成的）。

两个模型都计算损失函数，并且分别计算梯度用于更新生成器与判别器。

  1. # 注意 `tf.function` 的使用
  2. # 该注解使函数被“编译”
  3. @tf.function
  4. def train_step(images):
  5.     noise = tf.random.normal([BATCH_SIZE, noise_dim])
  6.  
  7.     with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
  8.       generated_images = generator(noise, training=True)
  9.  
  10.       real_output = discriminator(images, training=True)
  11.       fake_output = discriminator(generated_images, training=True)
  12.  
  13.       gen_loss = generator_loss(fake_output)
  14.       disc_loss = discriminator_loss(real_output, fake_output)
  15.  
  16.     gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
  17.     gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
  18.  
  19.     generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
  20.     discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
  21.  
  22. def train(dataset, epochs):
  23.   for epoch in range(epochs):
  24.     start = time.time()
  25.  
  26.     for image_batch in dataset:
  27.       train_step(image_batch)
  28.  
  29.     # 继续进行时为 GIF 生成图像
  30.     display.clear_output(wait=True)
  31.     generate_and_save_images(generator,
  32.                              epoch + 1,
  33.                              seed)
  34.  
  35.     # 每 15 个 epoch 保存一次模型
  36.     if (epoch + 1) % 15 == 0:
  37.       checkpoint.save(file_prefix = checkpoint_prefix)
  38.  
  39.     print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))
  40.  
  41.   # 最后一个 epoch 结束后生成图片
  42.   display.clear_output(wait=True)
  43.   generate_and_save_images(generator,
  44.                            epochs,
  45.                            seed)
  46.  
  47. # 生成与保存图片
  48. def generate_and_save_images(model, epoch, test_input):
  49.   # 注意 training` 设定为 False
  50.   # 因此，所有层都在推理模式下运行（batchnorm）。
  51.   predictions = model(test_input, training=False)
  52.  
  53.   fig = plt.figure(figsize=(4,4))
  54.  
  55.   for i in range(predictions.shape[0]):
  56.       plt.subplot(4, 4, i+1)
  57.       plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
  58.       plt.axis('off')
  59.  
  60.   plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
  61.   plt.show()

5.3 训练模型

调用上面定义的train（）函数，来同时训练生成器和判别器。

注意，训练GAN可能比较难的；生成器和判别器不能互相压制对方，需要两种达到平衡，它们用相似的学习率训练。

  1. %%time
  2. train(train_dataset, EPOCHS)

在刚开始训练时，生成的图片看起来很像随机噪声，随着训练过程的进行，生成的数字越来越真实。训练大约50轮后，生成器生成的图片看起来很像MNIST数字了。

训练了15轮的效果：

训练了30轮的效果：

训练过程：

恢复最新的检查点

checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))

六、评估模型

这里通过直接查看生成的图片，来看模型的效果。使用训练过程中生成的图片，通过imageio生成动态gif。

  1. # 使用 epoch 数生成单张图片
  2. def display_image(epoch_no):
  3.   return PIL.Image.open('image_at_epoch_{:04d}.png'.format(epoch_no))
  4.  
  5. display_image(EPOCHS)
  1. anim_file = 'dcgan.gif'
  2.  
  3. with imageio.get_writer(anim_file, mode='I') as writer:
  4.   filenames = glob.glob('image*.png')
  5.   filenames = sorted(filenames)
  6.   last = -1
  7.   for i,filename in enumerate(filenames):
  8.     frame = 2*(i**0.5)
  9.     if round(frame) > round(last):
  10.       last = frame
  11.     else:
  12.       continue
  13.     image = imageio.imread(filename)
  14.     writer.append_data(image)
  15.   image = imageio.imread(filename)
  16.   writer.append_data(image)
  17.  
  18. import IPython
  19. if IPython.version_info > (6,2,0,''):
  20.   display.Image(filename=anim_file)

完整代码：

  1. import tensorflow as tf
  2. import glob
  3. import imageio
  4. import matplotlib.pyplot as plt
  5. import numpy as np
  6. import os
  7. import PIL
  8. from tensorflow.keras import layers
  9. import time
  10.  
  11. from IPython import display
  12.  
  13. (train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()
  14.  
  15. train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
  16. train_images = (train_images - 127.5) / 127.5 # 将图片标准化到 [-1, 1] 区间内
  17.  
  18. BUFFER_SIZE = 60000
  19. BATCH_SIZE = 256
  20.  
  21. # 批量化和打乱数据
  22. train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
  23.  
  24. # 创建模型--生成器
  25. def make_generator_model():
  26.     model = tf.keras.Sequential()
  27.     model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
  28.     model.add(layers.BatchNormalization())
  29.     model.add(layers.LeakyReLU())
  30.  
  31.     model.add(layers.Reshape((7, 7, 256)))
  32.     assert model.output_shape == (None, 7, 7, 256) # 注意：batch size 没有限制
  33.  
  34.     model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
  35.     assert model.output_shape == (None, 7, 7, 128)
  36.     model.add(layers.BatchNormalization())
  37.     model.add(layers.LeakyReLU())
  38.  
  39.     model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
  40.     assert model.output_shape == (None, 14, 14, 64)
  41.     model.add(layers.BatchNormalization())
  42.     model.add(layers.LeakyReLU())
  43.  
  44.     model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
  45.     assert model.output_shape == (None, 28, 28, 1)
  46.  
  47.     return model
  48.  
  49. # 使用尚未训练的生成器，创建一张图片，这时的图片是随机噪声中产生。
  50. generator = make_generator_model()
  51.  
  52. noise = tf.random.normal([1, 100])
  53. generated_image = generator(noise, training=False)
  54.  
  55. plt.imshow(generated_image[0, :, :, 0], cmap='gray')
  56. tf.keras.utils.plot_model(generator)
  57.  
  58. # 判别器
  59. def make_discriminator_model():
  60.     model = tf.keras.Sequential()
  61.     model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',
  62.                                      input_shape=[28, 28, 1]))
  63.     model.add(layers.LeakyReLU())
  64.     model.add(layers.Dropout(0.3))
  65.  
  66.     model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
  67.     model.add(layers.LeakyReLU())
  68.     model.add(layers.Dropout(0.3))
  69.  
  70.     model.add(layers.Flatten())
  71.     model.add(layers.Dense(1))
  72.  
  73.     return model
  74.  
  75. # 使用（尚未训练的）判别器来对图片的真伪进行判断。模型将被训练为为真实图片输出正值，为伪造图片输出负值。
  76. discriminator = make_discriminator_model()
  77. decision = discriminator(generated_image)
  78. print (decision)
  79.  
  80. # 首先定义一个辅助函数，用于计算交叉熵损失的，这个两个模型通用。
  81. cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
  82.  
  83. # 生成器的损失和优化器
  84. def generator_loss(fake_output):
  85.     return cross_entropy(tf.ones_like(fake_output), fake_output)
  86. generator_optimizer = tf.keras.optimizers.Adam(1e-4)
  87.  
  88. # 判别器的损失和优化器
  89. def discriminator_loss(real_output, fake_output):
  90.     real_loss = cross_entropy(tf.ones_like(real_output), real_output)
  91.     fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
  92.     total_loss = real_loss + fake_loss
  93.     return total_loss
  94. discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)
  95.  
  96. # 保存检查点
  97. checkpoint_dir = './training_checkpoints'
  98. checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
  99. checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
  100.                                  discriminator_optimizer=discriminator_optimizer,
  101.                                  generator=generator,
  102.                                  discriminator=discriminator)
  103.  
  104. # 定义训练过程
  105. EPOCHS = 50
  106. noise_dim = 100
  107. num_examples_to_generate = 16
  108.  
  109. # 我们将重复使用该种子（因此在动画 GIF 中更容易可视化进度）
  110. seed = tf.random.normal([num_examples_to_generate, noise_dim])
  111.  
  112. # 注意 `tf.function` 的使用
  113. # 该注解使函数被“编译”
  114. @tf.function
  115. def train_step(images):
  116.     noise = tf.random.normal([BATCH_SIZE, noise_dim])
  117.  
  118.     with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
  119.       generated_images = generator(noise, training=True)
  120.  
  121.       real_output = discriminator(images, training=True)
  122.       fake_output = discriminator(generated_images, training=True)
  123.  
  124.       gen_loss = generator_loss(fake_output)
  125.       disc_loss = discriminator_loss(real_output, fake_output)
  126.  
  127.     gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
  128.     gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
  129.  
  130.     generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
  131.     discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
  132.  
  133. def train(dataset, epochs):
  134.   for epoch in range(epochs):
  135.     start = time.time()
  136.  
  137.     for image_batch in dataset:
  138.       train_step(image_batch)
  139.  
  140.     # 继续进行时为 GIF 生成图像
  141.     display.clear_output(wait=True)
  142.     generate_and_save_images(generator,
  143.                              epoch + 1,
  144.                              seed)
  145.  
  146.     # 每 15 个 epoch 保存一次模型
  147.     if (epoch + 1) % 15 == 0:
  148.       checkpoint.save(file_prefix = checkpoint_prefix)
  149.  
  150.     print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))
  151.  
  152.   # 最后一个 epoch 结束后生成图片
  153.   display.clear_output(wait=True)
  154.   generate_and_save_images(generator,
  155.                            epochs,
  156.                            seed)
  157.  
  158. # 生成与保存图片
  159. def generate_and_save_images(model, epoch, test_input):
  160.   # 注意 training` 设定为 False
  161.   # 因此，所有层都在推理模式下运行（batchnorm）。
  162.   predictions = model(test_input, training=False)
  163.  
  164.   fig = plt.figure(figsize=(4,4))
  165.  
  166.   for i in range(predictions.shape[0]):
  167.       plt.subplot(4, 4, i+1)
  168.       plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
  169.       plt.axis('off')
  170.  
  171.   plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
  172.   plt.show()
  173.  
  174. # 训练模型
  175. train(train_dataset, EPOCHS)
  176.  
  177. # 恢复最新的检查点
  178. checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
  179.  
  180. # 评估模型
  181. # 使用 epoch 数生成单张图片
  182. def display_image(epoch_no):
  183.   return PIL.Image.open('image_at_epoch_{:04d}.png'.format(epoch_no))
  184.  
  185. display_image(EPOCHS)
  186.  
  187. anim_file = 'dcgan.gif'
  188.  
  189. with imageio.get_writer(anim_file, mode='I') as writer:
  190.   filenames = glob.glob('image*.png')
  191.   filenames = sorted(filenames)
  192.   last = -1
  193.   for i,filename in enumerate(filenames):
  194.     frame = 2*(i**0.5)
  195.     if round(frame) > round(last):
  196.       last = frame
  197.     else:
  198.       continue
  199.     image = imageio.imread(filename)
  200.     writer.append_data(image)
  201.   image = imageio.imread(filename)
  202.   writer.append_data(image)
  203.  
  204. import IPython
  205. if IPython.version_info > (6,2,0,''):
  206.   display.Image(filename=anim_file)

参考：https://www.tensorflow.org/tutorials/generative/dcgan

一篇文章“简单”认识《生成对抗网络》(GAN)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/94319
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号