keras学习之：全网最简单GAN 网络研究，教你产生手写的数字

最新推荐文章于 2022-03-11 21:15:19 发布
最新推荐文章于 2022-03-11 21:15:19 发布
阅读量600 收藏 10
点赞数
分类专栏： tensorflow学习 Keras学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42902997/article/details/110917609
版权

文章目录

导包

import keras
from keras.layers import *
from keras.optimizers import *
from keras.losses import *
from keras.utils import to_categorical
from keras.models import Model
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

数据集（手写数字识别）

(x_train,y_train),(x_test,y_test) = mnist.load_data()

x_train = x_train.reshape(60000, 28, 28,1)
x_test = x_test.reshape(10000, 28, 28,1)

挑选数据：使用 “1” 这个类别的图片作为基准

indexes = np.where(y_train==1)          ## “1” 类别的图片的所有索引

real_img_count = indexes[0].shape[0]    ## 查看选出来的图片的数量 --> 6742 张
print(real_img_count)

target_imgs = x_train[indexes]          ## 通过索引把 x_train 中所有的 “1” 拿出来
target_labels = y_train[indexes]        ## 通过索引把 y_train 中所有的 “1” 拿出来

plt.imshow(target_imgs[2].reshape(28,28))  # 画个图看一下我们是不是真的拿到了想要的图片
  • 最后一行的 reshape 只是因为 plt.imshow 要求的输出格式的原因。
    在这里插入图片描述

核心代码

1.生成器

def generator():
    noise = Input((100,))			
    x = Dense(2048,activation=None)(noise)
    x = LeakyReLU()(x)
    x = BatchNormalization()(x)
    x = Dense(1024,activation=None)(x)
    x = LeakyReLU()(x)
    x = BatchNormalization()(x)
    x = Dense(784,activation=None)(x)
    x = LeakyReLU()(x)
    x = Reshape((28,28,1))(x)
    return Model(noise,x)

gen = generator()
  • 看网上很多教程，把 generator 写的很复杂，还通过卷积层和 upsampling 进行上采样，不利于初学者理解，其实 generator 的构造就注意三点即可：
    1. 一定要通过各种网络层产生足够的参数用来训练（既可以用卷积层也可以粗暴的用全连接层，这样对初学者搭建网络很友好），比如本文为了掩饰简单粗暴就使用了 Dense 层的堆积
    2. 保证最后一层全连接层的参数能够被 reshape 成你想要产生的图片的维度，比如我们要产生的图片维度是 28*28*1，那么我们就最后一个 Dense 层设计为 784，如果你要产生的图片维度是 32*32*3，那最后一个Dense层就设计为 32*32*3 = 3072。再通过最后的 Reshape 层进行约束即可
    3. 最后一点是防止梯度的消失问题，尽量使用 LeakyRelu 而不用 sigmoid 或者其他激活函数（这是公认的经验）；为了收敛迅速使用 BatchNormalization 层锦上添花
  • 因为后面，generator 要包在 GAN 网络里面，通过 GAN 网络的训练来迭代 generator 的参数，所以 generator 不需要单独训练，因此不用在这里 compile generator
  • 我的 generator 的参数量我控制在 300 万左右，如下图所示：
    在这里插入图片描述

2. 鉴别器

def discriminator():
    inputs = Input((28,28,1))
    x = Conv2D(filters=64,kernel_size=3,strides=2,padding='valid')(inputs)
    x = Conv2D(filters=128,kernel_size=3,strides=2,padding='valid')(x)
    x = Conv2D(filters=256,kernel_size=3,strides=2,padding='valid')(x)
    x = Flatten()(x)
    x = Dense(512,activation='relu')(x)
    x = Dense(1,activation='sigmoid')(x)
    
    return Model(inputs,x)

dis = discriminator()
dis.compile(optimizer=Adam(0.0001),loss=binary_crossentropy,metrics=['accuracy'])

  • 鉴别器就更简单了，你只需要保证两点即可：

    1. 输入的维度是你图片的维度
    2. 产生足够的参数来进行训练
    3. 最后一个 Dense 层只有 1 个神经元；因为 discriminator 的作用就是把输入分类成 0 或者 1，他认为真的样本他就给他 1，他认为假的样本就给 0；因此最后一层肯定要用 sigmoid 函数归一化到 0~1 之间

  • 因为 discriminator 需要单独训练，因此在这里先 compile 一下

  • 我把鉴别器的参数量控制在 100 万左右。

3. GAN 网络的构造

batch_size = 64			
epochs = 10000

generated_img = []								# 每训练100个epochs就把一张图片放入这个列表，看整个过程产生的图片的差别
discriminator_loss = []							# 用来存放每个 epoch 的鉴别器的 loss
gan_loss = []									# 用来存放每个 epoch 的 GAN 网络的 loss，其实就代表生成器的 loss，因为训练 GAN 的时候冻结了鉴别器的参数
for epoch in range(epochs):

    ## 随机产生噪声，每个 epoch 产生一个 batchsize 这么多的 (100,)的噪声
    noise = np.random.random((batch_size,100))
    
	## 每个 epoch 都用生成器将噪声生成图片，这个图片是 fake_imgs，对应的标签就是 0，所以每个 epoch 标签的个数就是 batch_size 个
	
    fake_img = gen.predict(noise)				 # fake_img 的维度 --> (batchsize,28,28,1)
    fake_img_labels = np.zeros((batch_size,1))   # ---> 0 ，维度-->(batchsize,1)
    
    ## 每个 epoch 都从我们选出的 “1” 的所有图片中挑选随机的 batchsize 张图作为 real_imgs
    pick_indexes = np.random.randint(0,real_img_count,(batch_size,))			# np.random.randint(0,6742,(64,))
    real_img = target_imgs[pick_indexes]		# real_imgs 的维度 --> (batchsize,28,28,1)
    real_img_labels = np.ones((batch_size,1))    # ---> 1，维度-->(batchsize,1)
    
    ## 结合 fake_imgs 和 real_imgs 以及 他们的 label
    data = np.concatenate([fake_img,real_img])
    labels = np.concatenate([fake_img_labels,real_img_labels])
    
    ## 训练 discriminator
    loss = dis.train_on_batch(data,labels)
    discriminator_loss.append(loss[-1])				#每一个 batchsize中取最后一个 loss 作为这个 epoch 的loss
    print("discriminator_loss:%f"%loss[-1])

    ## 训练 gan 网络，更新 generator 的参数
    
    loss_gan = ga.train_on_batch(noise,real_img_labels)
    print("loss_gan:%f"%loss_gan[-1])
    
    gan_loss.append(loss_gan[-1])
    print("epoch:%d" % epoch + "========")
   
    
    ## 每 100 个 epoch 就存一张图到 generated 列表中,10000个 epoch 就相当于存了100张图片进去
    if epoch%100 == 0:
        im = fake_img[0].reshape((28,28))
        generated_img.append(im)

打印最后生成的结果

1. 前10张图的生成效果

for i in range(0,10):
    plt.subplot(2,5,i+1)		# 只打印前十张图
    plt.imshow(generated_img[i])

在这里插入图片描述

2. 最后10张图的生成效果

for i in range(90,100):
    plt.subplot(2,5,i-90+1)		## 只打印最后十张图
    plt.imshow(generated_img[i])

在这里插入图片描述

  • 可以看到，我们已经几乎成功地完成了 “1” 类图片的生成

打印训练过程的 loss

plt.plot(discriminator_loss)
plt.plot(gan_loss)

在这里插入图片描述

  • 可以看看到，GAN 在训练的时候，loss 一直在震荡，没有稳定的收敛，虽然没有收敛，但是依然产生了很好效果的数据，至于如何解决 loss 震荡和收敛的问题，大家可以去查阅资料作进一步的了解。

整体代码

  • 为了给大家更加直观的整体效果，在这里附上整体的代码，我使用的是：
    • jupyter notebook 来实现的
    • keras-gpu 2.3.1；
    • GTX1080Ti，
    • 10000次 epoch 只需要 5 分钟就可以跑完~~
    import keras
from keras.layers import *
from keras.optimizers import *
from keras.losses import *
from keras.utils import to_categorical
from keras.models import Model
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

(x_train,y_train),(x_test,y_test) = mnist.load_data()

x_train = x_train.reshape(60000, 28, 28,1)
x_test = x_test.reshape(10000, 28, 28,1)

# y_train = to_categorical(y_train)
# y_test = to_categorical(y_test)

### 第一类的索引，选出第一类的数据以及其 labels

indexes = np.where(y_train==1)          ## “1” 类别的图片的所有索引

real_img_count = indexes[0].shape[0]    ## 查看选出来的图片的数量 --> 6742 张
print(real_img_count)
target_imgs = x_train[indexes]          ## 通过索引把 x_train 中所有的 “1” 拿出来
target_labels = y_train[indexes]        ## 通过索引把 y_train 中所有的 “1” 拿出来

plt.imshow(target_imgs[2].reshape(28,28))  # 画个图看一下我们是不是真的拿到了想要的图片

### 建立 GAN 网络，用来生成第一类的图片

def generator():
    noise = Input((100,))
    x = Dense(2048,activation=None)(noise)
    x = LeakyReLU()(x)
    x = BatchNormalization()(x)
    x = Dense(1024,activation=None)(x)
    x = LeakyReLU()(x)
    x = BatchNormalization()(x)
    x = Dense(784,activation=None)(x)
    x = LeakyReLU()(x)
    x = Reshape((28,28,1))(x)
    return Model(noise,x)

gen = generator()


def discriminator():
    inputs = Input((28,28,1))
    x = Conv2D(filters=64,kernel_size=3,strides=2,padding='valid')(inputs)
    x = Conv2D(filters=128,kernel_size=3,strides=2,padding='valid')(x)
    x = Conv2D(filters=256,kernel_size=3,strides=2,padding='valid')(x)
    x = Flatten()(x)
    x = Dense(512,activation='relu')(x)
    x = Dense(1,activation='sigmoid')(x)
    
    return Model(inputs,x)

dis = discriminator()
dis.compile(optimizer=Adam(0.0001),loss=binary_crossentropy,metrics=['accuracy'])

def gan():
    inputs = Input((100,))
    fake_img = gen(inputs)
    dis.trainable=False
    score = dis(fake_img)
    return Model(inputs,score)    ## 这个 score 越接近1越好

ga = gan()
ga.compile(optimizer=RMSprop(0.0001),loss=binary_crossentropy,metrics=['accuracy'])


batch_size = 64
epochs = 10000

generated_img = []
discriminator_loss = []
gan_loss = []

for epoch in range(epochs):
    ## 随机产生噪声
    noise = np.random.random((batch_size,100))
    
    fake_img = gen.predict(noise)
    fake_img_labels = np.zeros((batch_size,1))   # ---> 0 
    
    pick_indexes = np.random.randint(0,real_img_count,(batch_size,))
    real_img = target_imgs[pick_indexes]
    real_img_labels = np.ones((batch_size,1))    # ---> 1
    
    ## 结合 fake_imgs 和 real_imgs 以及 他们的 label
    data = np.concatenate([fake_img,real_img])
    labels = np.concatenate([fake_img_labels,real_img_labels])
    
    ## 训练 discriminator
    
    loss = dis.train_on_batch(data,labels)
    discriminator_loss.append(loss[-1])
    print("discriminator_loss:%f"%loss[-1])

    
    ## 训练 gan 网络，更新 generator 的参数
    
    loss_gan = ga.train_on_batch(noise,real_img_labels)
    print("loss_gan:%f"%loss_gan[-1])
    
    gan_loss.append(loss_gan[-1])
    print("epoch:%d" % epoch + "========")


    
    if epoch%100 == 0:
        im = fake_img[0].reshape((28,28))
        generated_img.append(im)
    


for i in range(0,10):
    plt.subplot(2,5,i+1)
    plt.imshow(generated_img[i])

for i in range(90,100):
    plt.subplot(2,5,i-90+1)
    plt.imshow(generated_img[i])


plt.plot(discriminator_loss)
plt.plot(gan_loss)

牛刀小试：生成 fashion_mnist数据集中的图片

  • 结果还是很好的~
  • 一共10000个 epoch
  • 每1000 个 epoch 画一张图

结果

在这里插入图片描述

loss

在这里插入图片描述

暖仔会飞
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
深度学习：Keras入门(二)之卷积神经网络(CNN)
01-26
简单来说，卷积(或内积)就是一种先把对应位置相乘然后再把结果相加的运算。(具体含义或者数学公式可以查阅相关资料)
GAN-生成手写数字-Keras
weixin_33928137的博客
12-29 510
from keras.models import Sequential from keras.layers import Dense from keras.layers import Reshape from keras.layers.core import Activation from keras.layers.normalization import BatchNormaliza...
Keras【极简】GAN
ArYe
02-24 730
文章目录网络结构图像生成器判别者欺诈者附录代码 网络结构 图像生成器 判别者 欺诈者 附录 en cn Generative Adversarial Networks 生成式对抗网络 discriminator 代码 from keras.datasets import mnist from keras.layers import Input, Dense, Re...
Keras学习之：教你简单地写个 GAN 网络
qq_42902997的博客
11-15 1610
文章目录1. GAN 网络原理1.1 generator 1. GAN 网络原理 GAN 网络由两个最主要的部分构成： generator discriminator 1.1 generator 生成器的作用很简单，那就是输入一个噪声，输出一个特定尺寸的图片、文本、数据等，在本文的例子中，generator 生成的数据是图片。先来看一下 generator 网络的定义： def generator(input_shape,channel): model = Sequential() #
Keras手写数字识别(初识MNIST数据集)
weixin_41137655的博客
11-13 1917
这篇文章将会分成两个部分，第一部分将简单认识一下keras中的手写数据集MNIST，第二部分将会介绍用Keras建立多层感知器模型，然后训练模型，评估模型的准确率，最后用训练完成的模型识别MNIST的手写数字。 1.MNIST简介 MNIST是深度学习的经典入门demo，它是由Yann LeCun搜集的，这个demo是由6万张训练图片和1万张测试图片构成的，每张图片都是28px*28px大小，而且...
基于Keras的生成对抗网络（1）——利用Keras搭建简单GAN生成手写体数字
Wendy的博客
03-23 784
0、前言 GAN网络是近两年深度学习领域的新秀，本文和之后的初识生成对抗网络系列旨在浅显理解传统GAN，分享学习心得。 关于为什么使用Keras进行搭建，而不是如日中天的TensorFlow和pytorch，因为keras是对新手最友好，最简单实用的深度学习框架，因此首先利用keras进行搭建，等充分理解GAN的结构和参数之后，再利用TensorFlow或pytorch进行搭建。 一、GAN结构 普通GAN的结构就是利用全连接层+激活函数，这里不过多介绍。 二、函数代码 2.1 生成器Generator 生
用Keras搭建GAN：图像去模糊中的应用
02-24
所有的Keras代码可GAN中两个网络的训练相互竞争。生成器（generator）合成具有说服力的假输入来误导判别器（discriminator），而判别器则是来识别这个输入是真的还是假的。训练过程主要有三步1.根据噪声，生成器合成...
keras学习 手写数字识别
01-06
keras.engine.sequential.Sequential()#所处包和模块中位置 from keras import models network = models.Sequential(layers，name)#从model模块调用，参数可选填或者不填 network.add(layer)#添加层的方法，若初始化...
Keras_GAN网络_keras_GaN_gan网络应用_
10-01
应用Keras实现GAN网络的实现，用于学习基本的知识，新手练习使用
用keras写一个生成对抗网络（GAN）
a_123456598的博客
07-19 4656
什么是生成对抗网络（GAN）？ 1、GAN的用途？ GAN的初衷就是生成不存在于真实世界的数据，类似于使得 AI具有创造力或者想象力。 应用场景如下： （1）AI作家，AI画家等需要创造力的AI体； （2）将模糊图变清晰(去雨，去雾，去抖动，去马赛克等)，这需要AI具有所谓的“想象力”，能脑补情节； （3）进行数据增强，根据已有数据生成更多新数据供以feed，可以减缓模型过拟合现象。 2、GAN的结构： 理解GAN的两大护法G和D G是generator，生成器:负责凭空捏造数据出来 ..
tensorflow keras从入门到精通——DcGAN生成手写数字
swpucwf的博客
11-03 740
导库 from keras.models import Sequential from keras.layers import Dense, BatchNormalization from keras.layers import Reshape from keras.layers.core import Activation from keras.layers.convolutional import UpSampling2D from keras.layers.convolutional import C
GAN学习：Keras入门
Cream_Cicilian的博客
03-11 5634
Keras入门1.环境配置2.搭建一个简单的网络3.多元线性回归3.1 准备数据集3.2 环境配置3.2代码3.4 结果 学习视频：来自bilibili 1.环境配置 在annaconda下创建一个新的虚拟环境 配置： tensorflow需要指定为2.0版本，注意tensorflow和keras的版本一定要对应，对应查看 pip install tensorflow==2.0 pip install keras==2.3.1 2.搭建一个简单的网络 搭建一个网络，去得到公式y=3*x+7，为一元线性回归
深度学习自学记录（5）——简单明了地实现Keras的生成对抗网络（GAN）（含代码）
qq_40784418的博客
04-27 1539
深度学习自学记录（5）——简单明了地实现Keras的生成式对抗网络（GAN）1、生成式对抗网络（GAN）的原理2、GAN的训练思路3、GAN的Keras实现 1、生成式对抗网络（GAN）的原理 2、GAN的训练思路 3、GAN的Keras实现 ...
keras学习之：获取神经网络中间层的输出结果
qq_42902997的博客
11-11 7855
文章目录1. 定义神经网络2. 导入数据集3. 训练网络 1. 定义神经网络 这里定义了一个简单的 CNN 网络 import keras,os from keras.models import Sequential from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Dropout import numpy as np from keras.models import Model os.environ["CUDA_VISIBLE_DEV
Keras学习之：冻结神经网络的特定层，进行训练
qq_42902997的博客
11-13 6797
文章目录1. 构建神经网络2. 冻结特定层的网络权重3. 冻结与非冻结的效果对比3.1 冻结网络训练的结果3.2 解冻网络训练的结果3.3 结论4. 冻结更多的参数，看是否会降低训练精度5. 冻结整个网络的全部参数，看会出现什么情况 1. 构建神经网络 这里以简单的 cnn 网络为例 注意：由于我在第 2 步中冻结了输出层的参数，为了与其他层进行区分，我在定义网络的时候给输出层起了个名字，“output”，如果不使用网络中的 name 属性对网络命名，那么系统会在 .summary 的时候自动给网络的层分
Keras调用单个或者多个GPU训练的方法
qq_42902997的博客
10-27 4300
前期准备： 下载和安装自己 nvidia 驱动 按照nvidia 驱动的版本号安装 cuda 和 cudnn 安装 anaconda 添加 anaconda 的环境变量 创建 conda 的虚拟环境 1. 安装 keras-gpu （因为 conda 会将一系列的附带包全部安装适配版本，例如 cudatoolkit，tensorflow-gpu，所以直接用 conda 安装 keras-gpu 即可） 进行这一步，默认读者已经安装了 anaconda 并且创建了自己的虚拟环境； conda ins
Keras学习之：keras 自带的经典模型加载和使用（vgg-16，resnet，mobilenet，densenet等）
qq_42902997的博客
11-16 3877
你还在为自己搭建网络结构而烦恼么 你还在为自己找不到合适的网络做实验而苦闷么 看完这篇文章，给你不一样的新世界 1. 模块导入 这里以 vgg-16 模块的导入和使用为例，给大家做简单的演示 from keras_applications import vgg16 2. 模型实例化 vgg_16 = vgg16.VGG16(input_shape=(224,224,3), weights=None, include_.
Keras 大坑解决之：fit_generator 停不下来的问题
qq_42902997的博客
10-27 1707
场景 今天下午用 vgg-16 来训练 mnist 网络： 50000 个 sample 1 个 epoch batchsize = 64 使用 2 个 gpu 1080 ti显卡，跑了一下午就是停不下来了 问题呈现 看这里该死的 unknown，一眼望不到头，训练了 20多万个 step 就是停不下来 原因分析 因为使用的 fit_generator 来训练，这本质是一个生成器，所以如果不指定每个 epoch 的训练步数 step 他就会无限循环下去·····，以至于我跑了一下午，精度到了 99
Keras学习之：如何使用 fit_generator进行训练，如何创建 generator
qq_42902997的博客
11-16 1631
文章目录1. 为什么要使用 fit_generator2. 如何创建 generator3. 如何使用 fit_generator4. 完整代码 1. 为什么要使用 fit_generator 我们都知道我们在进行神经网络训练的时候如果使用 model.fit 的方式训练， 那么我们需要把整个 x_train 加载到内存中，而 keras 自带的一些 datasets 又很小，在训练的时候完全可以这么做，所以如果是 keras 的小白，可能觉得 fit 是一个很好用的训练方法，而且也习惯了这种方式。 但
基于Keras构建GAN网络用于手写数字图像生成
最新发布
04-23
使用Keras构建GAN网络用于手写数字图像生成的步骤大致如下： 1. 准备数据集：需要准备手写数字图像的数据集，并将其分为训练集和测试集。 2. 定义生成器网络：生成器网络通常是一个多层的神经网络，其输入为噪声...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

暖仔会飞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值