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

GAN,CGAN,DCGAN在MIST数据集上的源码及训练结果对比_dcgan网络和gan网络代码对比

作者：花生_TL007 | 2024-04-22 23:31:06

赞

踩

dcgan网络和gan网络代码对比

    开始自学人工神经网络的时候ANN,CNN,RNN都尝试过了，包括后续的计算机视觉-目标检测算法，听觉-声纹识别，强化学习-五子棋，都进行了编码实验，并且亲手做了一个实际项目《凭证印章签字检查系统》用于银行会计凭证批量检查入库，成功实施投入使用。

    但是对抗生成网络一直没有试过。近期找来了一些源码进行了尝试。写出一些心得体会。并把使用的代码和训练结果给大家分享一下，欢迎评论和指正。

先上图：

训练了三万次 一批32张GAN，生成器和判别器都是使用了全连接:

图片不是很清晰，有很多白点杂物，但基本上能看出数字。

CGAN只训练了两千次，CGAN和GAN用的网络是一样的，只是加入了标签，大致能看出来数字是按照标签的顺序生成的，所以就停止了训练，因为后面的DC_GAN才是最好玩的:

DCGAN网络上的教程要求，所有的激活用leaky-relu，所有的上采样用conv2dTranspose,所有的下采样用conv2d,步长为2，激活函数用tanh和sigmod：

第一次尝试，都用relu，上采样用unmaxpooling2D,下采样用maxpooling2D，果然没效果，生成的图片都一样而且看不出来是数字。分析原因，原因，可能是relu激活和pooling层会造成有些神经元反向传播的时候不可导，而训练生成器的时候卷积深度比较深，造成训练困难，而判别器又因为反复学习正负样本造成神经元死亡。

第二次尝试，生成器用relu和unmaxpooling2D，生成器没用激活函数。判别器用全连接。3万次训练效果如下：

效果还是挺好的！

第三次尝试，按照教程的激活函数和上下采样函数来，生成和判别器都用卷积网络，3万次训练效果如下：

效果不太理想，可能我只是学到了方法，没学到精髓。一些超参数出了问题。

第四次尝试：生成器按照教程的网络，判别器用全连接，训练三万次效果如下：

效果还可以。

总结：

1、对抗网络对激活函数、超参数的要求较高，实验容易失败，需要反复尝试积累经验。

2、对抗网络稳定性不太好。

3、有大神指导会进步很快，希望各路大神不吝指教。

实验源码如下。

GAN:

  1. from __future__ import print_function, division
  2.  
  3. from tensorflow.keras.datasets import mnist
  4. from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout
  5. from tensorflow.keras.layers import BatchNormalization, Activation, ZeroPadding2D
  6. from tensorflow.keras.layers import LeakyReLU
  7. from tensorflow.keras.layers import UpSampling2D, Conv2D
  8. from tensorflow.keras.models import Sequential, Model
  9. from tensorflow.keras.optimizers import Adam
  10. import os
  11. import matplotlib.pyplot as plt
  12.  
  13. import sys
  14.  
  15. import numpy as np
  16.  
  17.  
  18. class GAN(object):
  19.     def __init__(self):
  20.         self.img_rows = 28
  21.         self.img_cols = 28
  22.         self.channels = 1
  23.         self.img_shape = (self.img_rows, self.img_cols, self.channels)
  24.         self.latent_dim = 100
  25.  
  26.         optimizer = Adam(0.0002, 0.5)
  27.  
  28.         # 构建和编译判别器
  29.         self.discriminator = self.build_discriminator()
  30.         self.discriminator.compile(loss='binary_crossentropy',
  31.                                    optimizer=optimizer,
  32.                                    metrics=['accuracy'])
  33.  
  34.         # 构建生成器
  35.         self.generator = self.build_generator()
  36.  
  37.         # 生成器输入噪声，生成假图片
  38.         z = Input(shape=(self.latent_dim,))
  39.         img = self.generator(z)
  40.  
  41.         # 为了组合模型，只训练生成器
  42.         self.discriminator.trainable = False
  43.  
  44.         # 判别器将生成的图片作为输入并确定有效性
  45.         validity = self.discriminator(img)
  46.  
  47.         # The combined model  (stacked generator and discriminator)
  48.         # 训练生成器骗过判别器
  49.         self.combined = Model(z, validity)
  50.         self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)
  51.  
  52.     def build_generator(self):
  53.  
  54.         model = Sequential()
  55.  
  56.         model.add(Dense(256, input_dim=self.latent_dim))
  57.         model.add(LeakyReLU(alpha=0.2))
  58.         model.add(BatchNormalization(momentum=0.8))
  59.  
  60.         model.add(Dense(512))
  61.         model.add(LeakyReLU(alpha=0.2))
  62.         model.add(BatchNormalization(momentum=0.8))
  63.  
  64.         model.add(Dense(1024))
  65.         model.add(LeakyReLU(alpha=0.2))
  66.         model.add(BatchNormalization(momentum=0.8))
  67.  
  68.         # np.prod(self.img_shape)=28x28x1
  69.         model.add(Dense(np.prod(self.img_shape), activation='tanh'))
  70.         model.add(Reshape(self.img_shape))
  71.  
  72.         model.summary()
  73.  
  74.         noise = Input(shape=(self.latent_dim,))
  75.         img = model(noise)
  76.  
  77.         # 输入噪音输出图片
  78.         return Model(noise, img)
  79.  
  80.     def build_discriminator(self):
  81.  
  82.         model = Sequential()
  83.  
  84.         model.add(Flatten(input_shape=self.img_shape))
  85.         model.add(Dense(512))
  86.         model.add(LeakyReLU(alpha=0.2))
  87.         model.add(Dense(256))
  88.         model.add(LeakyReLU(alpha=0.2))
  89.         model.add(Dense(1, activation='sigmoid'))
  90.         model.summary()
  91.  
  92.         img = Input(shape=self.img_shape)
  93.         validity = model(img)
  94.  
  95.         return Model(img, validity)
  96.  
  97.     def train(self, epochs, batch_size=128, sample_interval=50):
  98.         dataPath = 'C:/Users/lenovo/Desktop/MinstGan/mnist.npz'
  99.         # 加载数据集
  100.         (x_train, _), (_, _) = mnist.load_data(path=dataPath)
  101.  
  102.         # 归一化到-1到1
  103.         x_train = x_train / 127.5 - 1.
  104.         print(x_train.shape)
  105.         x_train = np.expand_dims(x_train, axis=3)
  106.         print(x_train.shape)
  107.  
  108.         # Adversarial ground truths
  109.         valid = np.ones((batch_size, 1))
  110.         fake = np.zeros((batch_size, 1))
  111.  
  112.         for epoch in range(epochs):
  113.  
  114.             # ---------------------
  115.             # 训练判别器
  116.             # ---------------------
  117.  
  118.             # X_train.shape[0]Ϊ为数据集的数量，随机生成batch_size个数量的随机数，作为数据的索引
  119.             idx = np.random.randint(0, x_train.shape[0], batch_size)
  120.  
  121.             # 从数据集随机挑选batch_size个数据，作为一个批次训练
  122.             imgs = x_train[idx]
  123.  
  124.             # 噪声维度(batch_size,100)
  125.             noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
  126.  
  127.             # 由生成器根据噪音生成假的图片
  128.             gen_imgs = self.generator.predict(noise)
  129.  
  130.             # 训练判别器，判别器希望真实的图片，打上标签1，假的图片打上标签0
  131.             d_loss_real = self.discriminator.train_on_batch(imgs, valid)
  132.             d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
  133.             d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
  134.  
  135.             # ---------------------
  136.             #  训练生成器
  137.             # ---------------------
  138.  
  139.             noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
  140.  
  141.             # Train the generator (to have the discriminator label samples as valid)
  142.             g_loss = self.combined.train_on_batch(noise, valid)
  143.  
  144.             # 打印loss
  145.             print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100 * d_loss[1], g_loss))
  146.  
  147.             # 每sample_interval个epoch保存一次生成图片
  148.             if epoch % sample_interval == 0:
  149.                 self.sample_images(epoch)
  150.                 if not os.path.exists("keras_model"):
  151.                     os.makedirs("keras_model")
  152.                 self.generator.save_weights("keras_model/G_model%d.hdf5" % epoch, True)
  153.                 self.discriminator.save_weights("keras_model/D_model%d.hdf5" % epoch, True)
  154.  
  155.     def sample_images(self, epoch):
  156.         r, c = 5, 5
  157.         # 重新生成一批噪音，维度为(25,100)
  158.         noise = np.random.normal(0, 1, (r * c, self.latent_dim))
  159.         gen_imgs = self.generator.predict(noise)
  160.  
  161.         # 将生成的图片重新规整0-1之间
  162.         gen_imgs = 0.5 * gen_imgs + 0.5
  163.  
  164.         fig, axs = plt.subplots(r, c)
  165.         cnt = 0
  166.         for i in range(r):
  167.             for j in range(c):
  168.                 axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
  169.                 axs[i, j].axis('off')
  170.                 cnt += 1
  171.         if not os.path.exists("keras_imgs"):
  172.             os.makedirs("keras_imgs")
  173.         fig.savefig("keras_imgs/%d.png" % epoch)
  174.         plt.close()
  175.  
  176.     def test(self, gen_nums=100):
  177.         self.generator.load_weights("keras_model/G_model15000.hdf5", by_name=True)
  178.         self.discriminator.load_weights("keras_model/D_model15000.hdf5", by_name=True)
  179.         noise = np.random.normal(0, 1, (gen_nums, self.latent_dim))
  180.         gen = self.generator.predict(noise)
  181.         print(gen.shape)
  182.         # 重整图片到0-1
  183.         gen = 0.5 * gen + 0.5
  184.         for i in range(0, len(gen)):
  185.             plt.figure(figsize=(128, 128), dpi=1)
  186.             plt.imshow(gen[i, :, :, 0], cmap="gray")
  187.             plt.axis("off")
  188.             if not os.path.exists("keras_gen"):
  189.                 os.makedirs("keras_gen")
  190.             plt.savefig("keras_gen" + os.sep + str(i) + '.jpg', dpi=1)
  191.             plt.close()
  192.  
  193.  
  194. if __name__ == '__main__':
  195.     gan = GAN()
  196.     gan.train(epochs=30000, batch_size=32, sample_interval=1000)
  197.     gan.test()

 

CGAN:

  1. from tensorflow.keras.datasets import mnist
  2. import tensorflow.keras.backend as K
  3. from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout
  4. from tensorflow.keras.layers import BatchNormalization, Activation, ZeroPadding2D
  5. from tensorflow.keras.layers import LeakyReLU,Embedding
  6. from tensorflow.keras.layers import UpSampling2D, Conv2D
  7. from tensorflow.keras.models import Sequential, Model
  8. from tensorflow.keras.optimizers import Adam
  9. import os
  10. import matplotlib.pyplot as plt
  11.  
  12. import sys
  13.  
  14. import numpy as np
  15.  
  16.  
  17. class GAN(object):
  18.     def __init__(self):
  19.         self.img_rows = 28
  20.         self.img_cols = 28
  21.         self.channels = 1
  22.         self.img_shape = (self.img_rows, self.img_cols, self.channels)
  23.         self.latent_dim = 100
  24.  
  25.         optimizer = Adam(0.0002, 0.5)
  26.  
  27.         # 构建和编译判别器
  28.         self.discriminator = self.build_discriminator()
  29.         self.discriminator.compile(loss='binary_crossentropy',
  30.                                    optimizer=optimizer,
  31.                                    metrics=['accuracy'])
  32.         # self.discriminator.compile(loss='sparse_categorical_crossentropy',
  33.         #                            optimizer=optimizer,
  34.         #                            metrics=['accuracy'])
  35.  
  36.         # 构建生成器
  37.         self.generator = self.build_generator()
  38.  
  39.         # 生成器输入噪声，生成假图片
  40.         noise = Input(shape=(self.latent_dim,))
  41.         label = Input(shape=(1,))
  42.         img = self.generator([noise, label])
  43.  
  44.         # 为了组合模型，只训练生成器
  45.         self.discriminator.trainable = False
  46.  
  47.         # 判别器将生成的图片作为输入并确定有效性
  48.         validity = self.discriminator([img, label])
  49.  
  50.         # The combined model  (stacked generator and discriminator)
  51.         # 训练生成器骗过判别器
  52.         self.combined = Model([noise, label], validity)
  53.         self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)
  54.  
  55.     def build_generator(self):
  56.  
  57.         model = Sequential()
  58.  
  59.         model.add(Dense(256, input_dim=self.latent_dim + 10))
  60.         model.add(LeakyReLU(alpha=0.2))
  61.         model.add(BatchNormalization(momentum=0.8))
  62.  
  63.         model.add(Dense(512))
  64.         model.add(LeakyReLU(alpha=0.2))
  65.         model.add(BatchNormalization(momentum=0.8))
  66.  
  67.         model.add(Dense(1024))
  68.         model.add(LeakyReLU(alpha=0.2))
  69.         model.add(BatchNormalization(momentum=0.8))
  70.  
  71.         # np.prod(self.img_shape)=28x28x1
  72.         model.add(Dense(np.prod(self.img_shape), activation='tanh'))
  73.         model.add(Reshape(self.img_shape))
  74.  
  75.         model.summary()
  76.  
  77.         noise = Input(shape=(self.latent_dim,))
  78.         label = Input(shape=(1,), dtype='int32')
  79.         label_embedding = Flatten()(Embedding(10, 10)(label))
  80.         model_input = K.concatenate([noise, label_embedding], axis=1)
  81.         img = model(model_input)
  82.  
  83.         # 输入噪音输出图片
  84.         return Model([noise, label], img)
  85.  
  86.     def build_discriminator(self):
  87.  
  88.         model = Sequential()
  89.  
  90.         model.add(Flatten(input_shape=(28,28,2)))
  91.         model.add(Dense(512))
  92.         model.add(LeakyReLU(alpha=0.2))
  93.         model.add(Dense(256))
  94.         model.add(LeakyReLU(alpha=0.2))
  95.         model.add(Dense(1, activation='sigmoid'))
  96.         model.summary()
  97.         img = Input(shape=self.img_shape)  # 输入 （28，28，1）
  98.         label = Input(shape=(1,), dtype='int32')
  99.         label_embedding = Flatten()(Embedding(10, np.prod(self.img_shape))(label))
  100.         flat_img = Flatten()(img)
  101.         model_input = K.concatenate([flat_img, label_embedding], axis = -1)
  102.         validity = model(model_input)
  103.  
  104.         return Model([img, label], validity)
  105.  
  106.     def train(self, epochs, batch_size=128, sample_interval=50):
  107.         dataPath = 'C:/Users/lenovo/Desktop/MinstGan/mnist.npz'
  108.         # 加载数据集
  109.         (x_train, y_train), (_, _) = mnist.load_data(path=dataPath)
  110.  
  111.         # 归一化到-1到1
  112.         x_train = x_train / 127.5 - 1.
  113.         print(x_train.shape)
  114.         x_train = np.expand_dims(x_train, axis=3)
  115.         print(x_train.shape)
  116.         y_train = np.expand_dims(y_train, axis=1)
  117.         print(y_train.shape)#60000,1
  118.  
  119.         # Adversarial ground truths
  120.         valid = np.ones((batch_size, 1))
  121.         fake = np.zeros((batch_size, 1))
  122.  
  123.         for epoch in range(epochs):
  124.  
  125.             # ---------------------
  126.             # 训练判别器
  127.             # ---------------------
  128.  
  129.             # X_train.shape[0]Ϊ为数据集的数量，随机生成batch_size个数量的随机数，作为数据的索引
  130.             idx = np.random.randint(0, x_train.shape[0], batch_size)
  131.  
  132.             # 从数据集随机挑选batch_size个数据，作为一个批次训练
  133.             imgs = x_train[idx]
  134.             labels = y_train[idx]
  135.  
  136.             # 噪声维度(batch_size,100)
  137.             noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
  138.  
  139.             # 由生成器根据噪音生成假的图片
  140.             gen_imgs = self.generator.predict([noise, labels])
  141.             # 训练判别器，判别器希望真实的图片，打上标签1，假的图片打上标签0
  142.             d_loss_real = self.discriminator.train_on_batch([imgs, labels], valid)
  143.             d_loss_fake2 = self.discriminator.train_on_batch([gen_imgs, labels], fake)
  144.             d_loss = d_loss_real + d_loss_fake2
  145.  
  146.             # ---------------------
  147.             #  训练生成器
  148.             # ---------------------
  149.             # Train the generator (to have the discriminator label samples as valid)
  150.             g_loss = self.combined.train_on_batch([noise, labels], valid)
  151.  
  152.  
  153.             # 每sample_interval个epoch保存一次生成图片
  154.             if epoch % sample_interval == 0:
  155.                 # 打印loss
  156.                 print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100 * d_loss[1], g_loss))
  157.                 self.sample_images(epoch)
  158.                 if not os.path.exists("keras_model"):
  159.                     os.makedirs("keras_model")
  160.                 self.generator.save_weights("keras_model/G_model%d.hdf5" % epoch, True)
  161.                 self.discriminator.save_weights("keras_model/D_model%d.hdf5" % epoch, True)
  162.  
  163.     def sample_images(self, epoch):
  164.         r, c = 4, 5
  165.         # 重新生成一批噪音，维度为(25,100)
  166.         noise = np.random.normal(0, 1, (r * c, self.latent_dim))
  167.         sampled_labels = np.concatenate([np.arange(0, 10).reshape(-1, 1), np.arange(0, 10).reshape(-1, 1)])
  168.         gen_imgs = self.generator.predict([noise, sampled_labels])
  169.  
  170.         # 将生成的图片重新规整0-1之间
  171.         gen_imgs = 0.5 * gen_imgs + 0.5
  172.  
  173.         fig, axs = plt.subplots(r, c)
  174.         cnt = 0
  175.         for i in range(r):
  176.             for j in range(c):
  177.                 axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
  178.                 axs[i, j].axis('off')
  179.                 cnt += 1
  180.         if not os.path.exists("keras_imgs"):
  181.             os.makedirs("keras_imgs")
  182.         fig.savefig("keras_imgs/%d.png" % epoch)
  183.         plt.close()
  184.  
  185.     def retore(self, epoch):
  186.         self.generator.load_weights("keras_model/G_model%d.hdf5" % epoch)
  187.         self.discriminator.load_weights("keras_model/D_model%d.hdf5" % epoch)
  188.  
  189. if __name__ == '__main__':
  190.     gan = GAN()
  191.     # gan.retore(11000)
  192.     gan.train(epochs=30000, batch_size=32, sample_interval=500)

 

DCGAN1:

  1. from tensorflow.keras.datasets import mnist
  2. import tensorflow.keras.backend as K
  3. from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout
  4. from tensorflow.keras.layers import BatchNormalization, Activation, ZeroPadding2D
  5. from tensorflow.keras.layers import LeakyReLU,Embedding
  6. from tensorflow.keras.layers import UpSampling2D, Conv2D
  7. from tensorflow.keras.models import Sequential, Model
  8. from tensorflow.keras.optimizers import Adam
  9. import os
  10. import matplotlib.pyplot as plt
  11.  
  12. import sys
  13.  
  14. import numpy as np
  15.  
  16.  
  17. class GAN(object):
  18.     def __init__(self):
  19.         self.img_rows = 28
  20.         self.img_cols = 28
  21.         self.channels = 1
  22.         self.img_shape = (self.img_rows, self.img_cols, self.channels)
  23.         self.latent_dim = 100
  24.  
  25.         optimizer = Adam(0.0002, 0.5)
  26.  
  27.         # 构建和编译判别器
  28.         self.discriminator = self.build_discriminator()
  29.         self.discriminator.compile(loss='binary_crossentropy',
  30.                                    optimizer=optimizer,
  31.                                    metrics=['accuracy'])
  32.         # self.discriminator.compile(loss='sparse_categorical_crossentropy',
  33.         #                            optimizer=optimizer,
  34.         #                            metrics=['accuracy'])
  35.  
  36.         # 构建生成器
  37.         self.generator = self.build_generator()
  38.  
  39.         # 生成器输入噪声，生成假图片
  40.         noise = Input(shape=(self.latent_dim,))
  41.         label = Input(shape=(1,))
  42.         img = self.generator([noise, label])
  43.  
  44.         # 为了组合模型，只训练生成器
  45.         self.discriminator.trainable = False
  46.  
  47.         # 判别器将生成的图片作为输入并确定有效性
  48.         validity = self.discriminator([img, label])
  49.  
  50.         # The combined model  (stacked generator and discriminator)
  51.         # 训练生成器骗过判别器
  52.         self.combined = Model([noise, label], validity)
  53.         self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)
  54.  
  55.     def build_generator(self):
  56.  
  57.         model = Sequential()
  58.  
  59.         model.add(Dense(128, activation='relu', input_dim=110))
  60.         model.add(Dense(196, activation='relu'))
  61.         model.add(Reshape((7, 7, 4)))
  62.         model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
  63.         model.add(UpSampling2D(size=(2,2)))
  64.         model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
  65.         model.add(UpSampling2D(size=(2,2)))
  66.         model.add(Conv2D(16, (3, 3), activation='relu', padding='same'))
  67.         model.add(Conv2D(1, (3, 3), padding='same'))
  68.  
  69.         model.summary()
  70.  
  71.         noise = Input(shape=(self.latent_dim,))
  72.         label = Input(shape=(1,), dtype='int32')
  73.         label_embedding = Flatten()(Embedding(10, 10)(label))
  74.         model_input = K.concatenate([noise, label_embedding], axis=1)
  75.         img = model(model_input)
  76.  
  77.         # 输入噪音输出图片
  78.         return Model([noise, label], img)
  79.  
  80.     def build_discriminator(self):
  81.  
  82.         model = Sequential()
  83.  
  84.         model.add(Flatten(input_shape=(28,28,2)))
  85.         model.add(Dense(512))
  86.         model.add(LeakyReLU(alpha=0.2))
  87.         model.add(Dense(256))
  88.         model.add(LeakyReLU(alpha=0.2))
  89.         model.add(Dense(1, activation='sigmoid'))
  90.         model.summary()
  91.         img = Input(shape=self.img_shape)  # 输入 （28，28，1）
  92.         label = Input(shape=(1,), dtype='int32')
  93.         label_embedding = Flatten()(Embedding(10, np.prod(self.img_shape))(label))
  94.         flat_img = Flatten()(img)
  95.         model_input = K.concatenate([flat_img, label_embedding], axis = -1)
  96.         validity = model(model_input)
  97.  
  98.         return Model([img, label], validity)
  99.  
  100.     def train(self, epochs, batch_size=128, sample_interval=50):
  101.         dataPath = 'C:/Users/lenovo/Desktop/MinstGan/mnist.npz'
  102.         # 加载数据集
  103.         (x_train, y_train), (_, _) = mnist.load_data(path=dataPath)
  104.  
  105.         # 归一化到-1到1
  106.         x_train = x_train / 127.5 - 1.
  107.         print(x_train.shape)
  108.         x_train = np.expand_dims(x_train, axis=3)
  109.         print(x_train.shape)
  110.         y_train = np.expand_dims(y_train, axis=1)
  111.         print(y_train.shape)#60000,1
  112.  
  113.         # Adversarial ground truths
  114.         valid = np.ones((batch_size, 1))
  115.         fake = np.zeros((batch_size, 1))
  116.  
  117.         for epoch in range(epochs):
  118.  
  119.             # ---------------------
  120.             # 训练判别器
  121.             # ---------------------
  122.  
  123.             # X_train.shape[0]Ϊ为数据集的数量，随机生成batch_size个数量的随机数，作为数据的索引
  124.             idx = np.random.randint(0, x_train.shape[0], batch_size)
  125.  
  126.             # 从数据集随机挑选batch_size个数据，作为一个批次训练
  127.             imgs = x_train[idx]
  128.             labels = y_train[idx]
  129.  
  130.             # 噪声维度(batch_size,100)
  131.             noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
  132.  
  133.             # 由生成器根据噪音生成假的图片
  134.             gen_imgs = self.generator.predict([noise, labels])
  135.             # 训练判别器，判别器希望真实的图片，打上标签1，假的图片打上标签0
  136.             d_loss_real = self.discriminator.train_on_batch([imgs, labels], valid)
  137.             d_loss_fake2 = self.discriminator.train_on_batch([gen_imgs, labels], fake)
  138.             d_loss = d_loss_real + d_loss_fake2
  139.  
  140.             # ---------------------
  141.             #  训练生成器
  142.             # ---------------------
  143.             # Train the generator (to have the discriminator label samples as valid)
  144.             g_loss = self.combined.train_on_batch([noise, labels], valid)
  145.  
  146.             # 打印loss
  147.             print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100 * d_loss[1], g_loss))
  148.  
  149.             # 每sample_interval个epoch保存一次生成图片
  150.             if epoch % sample_interval == 0:
  151.                 self.sample_images(epoch)
  152.                 if not os.path.exists("keras_model"):
  153.                     os.makedirs("keras_model")
  154.                 self.generator.save_weights("keras_model/G_model%d.hdf5" % epoch, True)
  155.                 self.discriminator.save_weights("keras_model/D_model%d.hdf5" % epoch, True)
  156.  
  157.     def sample_images(self, epoch):
  158.         r, c = 4, 5
  159.         # 重新生成一批噪音，维度为(25,100)
  160.         noise = np.random.normal(0, 1, (r * c, self.latent_dim))
  161.         sampled_labels = np.concatenate([np.arange(0, 10).reshape(-1, 1), np.arange(0, 10).reshape(-1, 1)])
  162.         gen_imgs = self.generator.predict([noise, sampled_labels])
  163.  
  164.         # 将生成的图片重新规整0-1之间
  165.         gen_imgs = 0.5 * gen_imgs + 0.5
  166.  
  167.         fig, axs = plt.subplots(r, c)
  168.         cnt = 0
  169.         for i in range(r):
  170.             for j in range(c):
  171.                 axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
  172.                 axs[i, j].axis('off')
  173.                 cnt += 1
  174.         if not os.path.exists("keras_imgs"):
  175.             os.makedirs("keras_imgs")
  176.         fig.savefig("keras_imgs/%d.png" % epoch)
  177.         plt.close()
  178.  
  179.     def retore(self, epoch):
  180.         self.generator.load_weights("keras_model/G_model%d.hdf5" % epoch)
  181.         self.discriminator.load_weights("keras_model/D_model%d.hdf5" % epoch)
  182.  
  183. if __name__ == '__main__':
  184.     gan = GAN()
  185.     # gan.retore(500)
  186.     gan.train(epochs=30000, batch_size=32, sample_interval=300)

 

DCGAN2:

  1. from tensorflow.keras.datasets import mnist
  2. import tensorflow.keras.backend as K
  3. from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout
  4. from tensorflow.keras.layers import BatchNormalization, Activation, ZeroPadding2D
  5. from tensorflow.keras.layers import LeakyReLU,Embedding
  6. from tensorflow.keras.layers import UpSampling2D, Conv2D, MaxPooling2D, Conv2DTranspose
  7. from tensorflow.keras.models import Sequential, Model
  8. from tensorflow.keras.optimizers import Adam
  9. import os
  10. import matplotlib.pyplot as plt
  11.  
  12. import sys
  13.  
  14. import numpy as np
  15.  
  16.  
  17. class GAN(object):
  18.     def __init__(self):
  19.         self.img_rows = 28
  20.         self.img_cols = 28
  21.         self.channels = 1
  22.         self.img_shape = (self.img_rows, self.img_cols, self.channels)
  23.         self.latent_dim = 100
  24.         self.dropout = 0.2
  25.         optimizer = Adam(0.0001, 0.9)
  26.  
  27.         # 构建和编译判别器
  28.         self.discriminator = self.build_discriminator()
  29.         self.discriminator.compile(loss='binary_crossentropy',
  30.                                    optimizer=optimizer,
  31.                                    metrics=['accuracy'])
  32.         # self.discriminator.compile(loss='sparse_categorical_crossentropy',
  33.         #                            optimizer=optimizer,
  34.         #                            metrics=['accuracy'])
  35.  
  36.         # 构建生成器
  37.         self.generator = self.build_generator()
  38.  
  39.         # 生成器输入噪声，生成假图片
  40.         noise = Input(shape=(self.latent_dim,))
  41.         label = Input(shape=(1,))
  42.         img = self.generator([noise, label])
  43.  
  44.         # 为了组合模型，只训练生成器
  45.         self.discriminator.trainable = False
  46.  
  47.         # 判别器将生成的图片作为输入并确定有效性
  48.         validity = self.discriminator([img, label])
  49.  
  50.         # The combined model  (stacked generator and discriminator)
  51.         # 训练生成器骗过判别器
  52.         self.combined = Model([noise, label], validity)
  53.         self.combined.compile(loss='binary_crossentropy', optimizer=optimizer,
  54.                                    metrics=['accuracy'])
  55.  
  56.     def build_generator(self):
  57.  
  58.         model = Sequential()
  59.  
  60.         model.add(Dense(64 * 7 * 7,  input_dim=110))
  61.         model.add(BatchNormalization(momentum=0.9))
  62.         model.add(LeakyReLU(alpha=0.2))
  63.         model.add(Reshape((7, 7, 64)))
  64.         model.add(Conv2DTranspose(64, kernel_size = 3, strides = 2, padding='same'))
  65.         model.add(BatchNormalization(momentum=0.9))
  66.         model.add(LeakyReLU(alpha=0.2))
  67.         model.add(Conv2DTranspose(32,  kernel_size = 3, strides = 2, padding='same'))
  68.         model.add(BatchNormalization(momentum=0.9))
  69.         model.add(LeakyReLU(alpha=0.2))
  70.         model.add(Conv2D(16,  kernel_size = 3, padding='same'))
  71.         model.add(BatchNormalization(momentum=0.9))
  72.         model.add(LeakyReLU(alpha=0.2))
  73.         model.add(Conv2D(1, (3, 3), padding='same', activation='tanh'))
  74.  
  75.         # model.add(Dense(128, activation='relu', input_dim=110))
  76.         # model.add(Dense(16 * 7 * 7, activation='relu'))
  77.         # model.add(Reshape((7, 7, 16)))
  78.         # model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
  79.         # model.add(UpSampling2D(size=(2,2)))
  80.         # model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
  81.         # model.add(UpSampling2D(size=(2,2)))
  82.         # model.add(Conv2D(16, (3, 3), activation='relu', padding='same'))
  83.         # model.add(Conv2D(1, (3, 3), padding='same'))
  84.  
  85.         model.summary()
  86.  
  87.         noise = Input(shape=(self.latent_dim,))
  88.         label = Input(shape=(1,), dtype='int32')
  89.         label_embedding = Flatten()(Embedding(10, 10)(label))
  90.         model_input = K.concatenate([noise, label_embedding], axis=1)
  91.         img = model(model_input)
  92.  
  93.         # 输入噪音输出图片
  94.         return Model([noise, label], img)
  95.  
  96.     def build_discriminator(self):
  97.  
  98.         model = Sequential()
  99.  
  100.         model.add(Conv2D(64, (3, 3), strides=(2,2), input_shape = (28, 28, 2)))
  101.         model.add(LeakyReLU(alpha=0.2))#判别器不能用relu  征造反复标记 成神经元死亡
  102.         model.add(Dropout(self.dropout))
  103.         model.add(Conv2D(128, (3, 3), strides=(2,2)))
  104.         model.add(LeakyReLU(alpha=0.2))
  105.         model.add(Dropout(self.dropout))
  106.         model.add(Conv2D(128, (3, 3), strides=(2,2)))
  107.         model.add(LeakyReLU(alpha=0.2))
  108.         model.add(Dropout(self.dropout))
  109.         model.add(Flatten())
  110.         model.add(Dense(64))
  111.         model.add(LeakyReLU(alpha=0.2))
  112.         model.add(Dense(1, activation='sigmoid'))
  113.  
  114.         model.summary()
  115.         img = Input(shape=self.img_shape)  # 输入 （28，28，1）
  116.         label = Input(shape=(1,), dtype='int32')
  117.         label_embedding = Flatten()(Embedding(10, np.prod(self.img_shape))(label))
  118.         # flat_img = Flatten()(img)
  119.         label_embedding = Reshape(self.img_shape)(label_embedding)
  120.         model_input = K.concatenate([img, label_embedding], axis = -1)
  121.         print(model_input.shape)
  122.         validity = model(model_input)
  123.  
  124.         return Model([img, label], validity)
  125.  
  126.     def train(self, epochs, batch_size=128, sample_interval=50):
  127.         dataPath = 'C:/Users/lenovo/Desktop/MinstGan/mnist.npz'
  128.         # 加载数据集
  129.         (x_train, y_train), (_, _) = mnist.load_data(path=dataPath)
  130.  
  131.         # 归一化到-1到1
  132.         x_train = x_train / 127.5 - 1.
  133.         print(x_train.shape)
  134.         x_train = np.expand_dims(x_train, axis=3)
  135.         print(x_train.shape)
  136.         y_train = np.expand_dims(y_train, axis=1)
  137.         print(y_train.shape)#60000,1
  138.  
  139.         # Adversarial ground truths
  140.         valid = np.ones((batch_size, 1))
  141.         fake = np.zeros((batch_size, 1))
  142.  
  143.         for epoch in range(epochs):
  144.  
  145.             # ---------------------
  146.             # 训练判别器
  147.             # ---------------------
  148.  
  149.             # X_train.shape[0]Ϊ为数据集的数量，随机生成batch_size个数量的随机数，作为数据的索引
  150.             idx = np.random.randint(0, x_train.shape[0], batch_size)
  151.  
  152.             # 从数据集随机挑选batch_size个数据，作为一个批次训练
  153.             imgs = x_train[idx]
  154.             labels = y_train[idx]
  155.  
  156.             # 噪声维度(batch_size,100)
  157.             noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
  158.  
  159.             # 由生成器根据噪音生成假的图片
  160.             gen_imgs = self.generator.predict([noise, labels])
  161.             # 训练判别器，判别器希望真实的图片，打上标签1，假的图片打上标签0
  162.             d_loss_real = self.discriminator.train_on_batch([imgs, labels], valid)
  163.             d_loss_fake = self.discriminator.train_on_batch([gen_imgs, labels], fake)
  164.  
  165.             # ---------------------
  166.             #  训练生成器
  167.             # ---------------------
  168.             # Train the generator (to have the discriminator label samples as valid)
  169.             g_loss = self.combined.train_on_batch([noise, labels], valid)
  170.  
  171.             # 打印loss 真图识别率 假图识别率  诱骗成功率
  172.             print("%d [D realloss: %f, realacc: %.2f%%, fakeloss: %f, fakeacc: %.2f%%] [G loss: %f, acc = %.2f%%]" %
  173.                   (epoch, d_loss_real[0], 100 * d_loss_real[1], d_loss_fake[0], 100 * d_loss_fake[1], g_loss[0], 100 * g_loss[1]))
  174.  
  175.             # 每sample_interval个epoch保存一次生成图片
  176.             if epoch % sample_interval == 0:
  177.                 self.sample_images(epoch)
  178.                 if not os.path.exists("keras_model"):
  179.                     os.makedirs("keras_model")
  180.                 self.generator.save_weights("keras_model/G_model%d.hdf5" % epoch, True)
  181.                 self.discriminator.save_weights("keras_model/D_model%d.hdf5" % epoch, True)
  182.  
  183.     def sample_images(self, epoch):
  184.         r, c = 4, 5
  185.         # 重新生成一批噪音，维度为(25,100)
  186.         noise = np.random.normal(0, 1, (r * c, self.latent_dim))
  187.         sampled_labels = np.concatenate([np.arange(0, 10).reshape(-1, 1), np.arange(0, 10).reshape(-1, 1)])
  188.         gen_imgs = self.generator.predict([noise, sampled_labels])
  189.  
  190.         # 将生成的图片重新规整0-1之间
  191.         gen_imgs = 0.5 * gen_imgs + 0.5
  192.  
  193.         fig, axs = plt.subplots(r, c)
  194.         cnt = 0
  195.         for i in range(r):
  196.             for j in range(c):
  197.                 axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
  198.                 axs[i, j].axis('off')
  199.                 cnt += 1
  200.         if not os.path.exists("keras_imgs"):
  201.             os.makedirs("keras_imgs")
  202.         fig.savefig("keras_imgs/%d.png" % epoch)
  203.         plt.close()
  204.  
  205.     def retore(self, epoch):
  206.         self.generator.load_weights("keras_model/G_model%d.hdf5" % epoch)
  207.         self.discriminator.load_weights("keras_model/D_model%d.hdf5" % epoch)
  208.  
  209. if __name__ == '__main__':
  210.     gan = GAN()
  211.     # gan.retore(4500)
  212.     gan.train(epochs=30000, batch_size=32, sample_interval=300)

 

DC_GAN3:

  1. from tensorflow.keras.datasets import mnist
  2. import tensorflow.keras.backend as K
  3. from tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout
  4. from tensorflow.keras.layers import BatchNormalization, Activation, ZeroPadding2D
  5. from tensorflow.keras.layers import LeakyReLU,Embedding,Conv2DTranspose
  6. from tensorflow.keras.layers import UpSampling2D, Conv2D
  7. from tensorflow.keras.models import Sequential, Model
  8. from tensorflow.keras.optimizers import Adam
  9. import os
  10. import matplotlib.pyplot as plt
  11.  
  12. import sys
  13.  
  14. import numpy as np
  15.  
  16.  
  17. class GAN(object):
  18.     def __init__(self):
  19.         self.img_rows = 28
  20.         self.img_cols = 28
  21.         self.channels = 1
  22.         self.img_shape = (self.img_rows, self.img_cols, self.channels)
  23.         self.latent_dim = 100
  24.  
  25.         optimizer = Adam(0.0002, 0.5)
  26.  
  27.         # 构建和编译判别器
  28.         self.discriminator = self.build_discriminator()
  29.         self.discriminator.compile(loss='binary_crossentropy',
  30.                                    optimizer=optimizer,
  31.                                    metrics=['accuracy'])
  32.         # self.discriminator.compile(loss='sparse_categorical_crossentropy',
  33.         #                            optimizer=optimizer,
  34.         #                            metrics=['accuracy'])
  35.  
  36.         # 构建生成器
  37.         self.generator = self.build_generator()
  38.  
  39.         # 生成器输入噪声，生成假图片
  40.         noise = Input(shape=(self.latent_dim,))
  41.         label = Input(shape=(1,))
  42.         img = self.generator([noise, label])
  43.  
  44.         # 为了组合模型，只训练生成器
  45.         self.discriminator.trainable = False
  46.  
  47.         # 判别器将生成的图片作为输入并确定有效性
  48.         validity = self.discriminator([img, label])
  49.  
  50.         # The combined model  (stacked generator and discriminator)
  51.         # 训练生成器骗过判别器
  52.         self.combined = Model([noise, label], validity)
  53.         self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)
  54.  
  55.     def build_generator(self):
  56.  
  57.         model = Sequential()
  58.  
  59.         # model.add(Dense(128, activation='relu', input_dim=110))
  60.         # model.add(Dense(196, activation='relu'))
  61.         # model.add(Reshape((7, 7, 4)))
  62.         # model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
  63.         # model.add(UpSampling2D(size=(2,2)))
  64.         # model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
  65.         # model.add(UpSampling2D(size=(2,2)))
  66.         # model.add(Conv2D(16, (3, 3), activation='relu', padding='same'))
  67.         # model.add(Conv2D(1, (3, 3), padding='same'))
  68.  
  69.         model.add(Dense(64 * 7 * 7,  input_dim=110))
  70.         model.add(BatchNormalization(momentum=0.9))
  71.         model.add(LeakyReLU(alpha=0.2))
  72.         model.add(Reshape((7, 7, 64)))
  73.         model.add(Conv2DTranspose(64, kernel_size = 3, strides = 2, padding='same'))
  74.         model.add(BatchNormalization(momentum=0.9))
  75.         model.add(LeakyReLU(alpha=0.2))
  76.         model.add(Conv2DTranspose(32,  kernel_size = 3, strides = 2, padding='same'))
  77.         model.add(BatchNormalization(momentum=0.9))
  78.         model.add(LeakyReLU(alpha=0.2))
  79.         model.add(Conv2D(16,  kernel_size = 3, padding='same'))
  80.         model.add(BatchNormalization(momentum=0.9))
  81.         model.add(LeakyReLU(alpha=0.2))
  82.         model.add(Conv2D(1, (3, 3), padding='same', activation='tanh'))
  83.  
  84.         model.summary()
  85.  
  86.         noise = Input(shape=(self.latent_dim,))
  87.         label = Input(shape=(1,), dtype='int32')
  88.         label_embedding = Flatten()(Embedding(10, 10)(label))
  89.         model_input = K.concatenate([noise, label_embedding], axis=1)
  90.         img = model(model_input)
  91.  
  92.         # 输入噪音输出图片
  93.         return Model([noise, label], img)
  94.  
  95.     def build_discriminator(self):
  96.  
  97.         model = Sequential()
  98.  
  99.         model.add(Flatten(input_shape=(28,28,2)))
  100.         model.add(Dense(512))
  101.         model.add(LeakyReLU(alpha=0.2))
  102.         model.add(Dense(256))
  103.         model.add(LeakyReLU(alpha=0.2))
  104.         model.add(Dense(1, activation='sigmoid'))
  105.         model.summary()
  106.         img = Input(shape=self.img_shape)  # 输入 （28，28，1）
  107.         label = Input(shape=(1,), dtype='int32')
  108.         label_embedding = Flatten()(Embedding(10, np.prod(self.img_shape))(label))
  109.         flat_img = Flatten()(img)
  110.         model_input = K.concatenate([flat_img, label_embedding], axis = -1)
  111.         validity = model(model_input)
  112.  
  113.         return Model([img, label], validity)
  114.  
  115.     def train(self, epochs, batch_size=128, sample_interval=50):
  116.         dataPath = 'C:/Users/lenovo/Desktop/MinstGan/mnist.npz'
  117.         # 加载数据集
  118.         (x_train, y_train), (_, _) = mnist.load_data(path=dataPath)
  119.  
  120.         # 归一化到-1到1
  121.         x_train = x_train / 127.5 - 1.
  122.         print(x_train.shape)
  123.         x_train = np.expand_dims(x_train, axis=3)
  124.         print(x_train.shape)
  125.         y_train = np.expand_dims(y_train, axis=1)
  126.         print(y_train.shape)#60000,1
  127.  
  128.         # Adversarial ground truths
  129.         valid = np.ones((batch_size, 1))
  130.         fake = np.zeros((batch_size, 1))
  131.  
  132.         for epoch in range(epochs):
  133.  
  134.             # ---------------------
  135.             # 训练判别器
  136.             # ---------------------
  137.  
  138.             # X_train.shape[0]Ϊ为数据集的数量，随机生成batch_size个数量的随机数，作为数据的索引
  139.             idx = np.random.randint(0, x_train.shape[0], batch_size)
  140.  
  141.             # 从数据集随机挑选batch_size个数据，作为一个批次训练
  142.             imgs = x_train[idx]
  143.             labels = y_train[idx]
  144.  
  145.             # 噪声维度(batch_size,100)
  146.             noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
  147.  
  148.             # 由生成器根据噪音生成假的图片
  149.             gen_imgs = self.generator.predict([noise, labels])
  150.             # 训练判别器，判别器希望真实的图片，打上标签1，假的图片打上标签0
  151.             d_loss_real = self.discriminator.train_on_batch([imgs, labels], valid)
  152.             d_loss_fake2 = self.discriminator.train_on_batch([gen_imgs, labels], fake)
  153.             d_loss = d_loss_real + d_loss_fake2
  154.  
  155.             # ---------------------
  156.             #  训练生成器
  157.             # ---------------------
  158.             # Train the generator (to have the discriminator label samples as valid)
  159.             g_loss = self.combined.train_on_batch([noise, labels], valid)
  160.  
  161.             # 打印loss
  162.             print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100 * d_loss[1], g_loss))
  163.  
  164.             # 每sample_interval个epoch保存一次生成图片
  165.             if epoch % sample_interval == 0:
  166.                 self.sample_images(epoch)
  167.                 if not os.path.exists("keras_model"):
  168.                     os.makedirs("keras_model")
  169.                 self.generator.save_weights("keras_model/G_model%d.hdf5" % epoch, True)
  170.                 self.discriminator.save_weights("keras_model/D_model%d.hdf5" % epoch, True)
  171.  
  172.     def sample_images(self, epoch):
  173.         r, c = 4, 5
  174.         # 重新生成一批噪音，维度为(25,100)
  175.         noise = np.random.normal(0, 1, (r * c, self.latent_dim))
  176.         sampled_labels = np.concatenate([np.arange(0, 10).reshape(-1, 1), np.arange(0, 10).reshape(-1, 1)])
  177.         gen_imgs = self.generator.predict([noise, sampled_labels])
  178.  
  179.         # 将生成的图片重新规整0-1之间
  180.         gen_imgs = 0.5 * gen_imgs + 0.5
  181.  
  182.         fig, axs = plt.subplots(r, c)
  183.         cnt = 0
  184.         for i in range(r):
  185.             for j in range(c):
  186.                 axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
  187.                 axs[i, j].axis('off')
  188.                 cnt += 1
  189.         if not os.path.exists("keras_imgs"):
  190.             os.makedirs("keras_imgs")
  191.         fig.savefig("keras_imgs/%d.png" % epoch)
  192.         plt.close()
  193.  
  194.     def retore(self, epoch):
  195.         self.generator.load_weights("keras_model/G_model%d.hdf5" % epoch)
  196.         self.discriminator.load_weights("keras_model/D_model%d.hdf5" % epoch)
  197.  
  198. if __name__ == '__main__':
  199.     gan = GAN()
  200.     # gan.retore(500)
  201.     gan.train(epochs=30000, batch_size=32, sample_interval=300)

 

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

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

  

闽ICP备14008679号