[Paddle学习笔记][05][对抗生成网络]

摘要:
本例程使用DCGAN网络和MNIST数据集生成数字字符。

说明:

生成对抗网络(Generative Adversarial Network [1],简称GAN)是非监督式学习的一种方法,通过让两个神经网络相互博弈的方式进行学习。本例程使用DCGAN网络和MNIST数据集生成数字字符。

实验代码:

importpaddle
importpaddle.fluid as fluid
importnumpy as np

importmath
importmatplotlib.pyplot as plt
%matplotlib inline

#全局变量
use_cuda = 1 #是否使用GPU
batch_size = 128 #每批读取数据
epoch_num = 20 #训练迭代周期
noise_size = 100 #噪声维度

#判别网络
defD(image):
    #输入图像: N*C*H*W=N*1*28*28, H/W=(H/W-F+2*P)/S+1, 网络层数: 4
    image = fluid.layers.reshape(x=image, shape=[-1, 1, 28, 28])
    
    conv_pool_1 = fluid.nets.simple_img_conv_pool( #输出: N*64*12*12
        input=image, num_filters=64, filter_size=5, act='leaky_relu',
        pool_size=2, pool_stride=2, param_attr='conv_pool_1_w', bias_attr='conv_pool_1_b')
    conv_pool_2 = fluid.nets.simple_img_conv_pool( #输出: N*128*4*4
        input=conv_pool_1, num_filters=128, filter_size=5, act='leaky_relu',
        pool_size=2, pool_stride=2, param_attr='conv_pool_2_w', bias_attr='conv_pool_2_b')
    bn1 =fluid.layers.batch_norm(
        input=conv_pool_2, act='leaky_relu', name='bn1',
        param_attr='bn1_w', bias_attr='bn1_b', moving_mean_name='bn1_m', moving_variance_name='bn1_v')
    fc1 = fluid.layers.fc(                         #输出: N*1024
        input=bn1, size=1024, act=None,
        param_attr='fc1_w', bias_attr='fc1_b')
    bn2 =fluid.layers.batch_norm(
        input=fc1, act='leaky_relu', name='bn2',
        param_attr='bn2_w', bias_attr='bn2_b', moving_mean_name='bn2_m', moving_variance_name='bn2_v')
    
    #输出标签: 1为真实图像,0为虚假图像
    logit = fluid.layers.fc(                       #输出: N*1
        input=bn2, size=1, act='sigmoid',
        param_attr='fc2_w', bias_attr='fc2_b')
    
    returnlogit

#生成网络
defG(noise):
    #输入噪声: N*100, 网络层数: 4
    fc3 = fluid.layers.fc(                     #输出: N*2048
        input=noise, size=2048, act=None,
        param_attr='fc3_w', bias_attr='fc3_b')
    bn3 =fluid.layers.batch_norm(
        input=fc3, act='relu', name='bn3',
        param_attr='bn3_w', bias_attr='bn3_b', moving_mean_name='bn3_m', moving_variance_name='bn3_v')
    fc4 = fluid.layers.fc(                     #输出: N*6272
        input=bn3, size=6272, act=None,
        param_attr='fc4_w', bias_attr='fc4_b')
    bn5 =fluid.layers.batch_norm(
        input=fc4, act='relu', name='bn5',
        param_attr='bn5_w', bias_attr='bn5_b', moving_mean_name='bn5_m', moving_variance_name='bn5_v')
    
    reshape = fluid.layers.reshape(x=bn5, shape=[-1, 128, 7, 7])
    
    deconv1 = fluid.layers.conv2d_transpose(   #输出: N*128*14*14
        input=reshape, output_size=[14, 14], 
        num_filters=128, filter_size=5, stride=2, padding=2, dilation=1, act='relu',
        param_attr='deconv1_w', bias_attr='deconv1_b')
    deconv2 = fluid.layers.conv2d_transpose(   #输出: N*1*28*28
        input=deconv1, output_size=[28, 28], 
        num_filters=1, filter_size=5, stride=2, padding=2, dilation=1, act='tanh',
        param_attr='deconv2_w', bias_attr='deconv2_b')
    
    #输出图像
    image = fluid.layers.reshape(x=deconv2, shape=[-1, 784])
    
    returnimage

#显示图像
defshow_image(total_image):
    n =int(math.ceil(math.sqrt(total_image.shape[0])))
    total_image = total_image.reshape((n, n, 28, 28)).transpose((0, 2, 1, 3)).reshape((n*28, n*28))
    fig= plt.figure(figsize=(8, 8))
    plt.axis('off')
    plt.imshow(total_image, cmap='Greys_r', vmin=-1, vmax=1)
    plt.show(fig)

#训练模型
deftrain():
    #读取数据
    train_reader =paddle.batch(
        paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=60000),
        batch_size=batch_size)
    
    #配置训练判别网络
    d_program = fluid.Program() #获取判别网络
with fluid.program_guard(d_program):
        #输入图像
        d_image = fluid.data(name='image', shape=[None, 784], dtype='float32') #输入图像: N*1*28*28
        d_label = fluid.data(name='label', shape=[None, 1], dtype='float32')   #图像标签: N*1
        
        #判别图像
        d_logit =D(d_image)
        
        #计算损失
        d_loss = fluid.layers.sigmoid_cross_entropy_with_logits(x=d_logit, label=d_label)
        d_avg_loss =fluid.layers.mean(d_loss)
        
    #配置训练生成网络
    dg_program = fluid.Program() #获取判别生成网络
with fluid.program_guard(dg_program):
        #输入噪声
        g_noise = fluid.data(name='noise', shape=[None, noise_size], dtype='float32')               #输入噪声: N*100
        noise_shape =fluid.layers.shape(g_noise)
        g_label = fluid.layers.fill_constant(value=1.0, shape=[noise_shape[0], 1], dtype='float32') #图像标签: N*1
        
        #生成图像
        g_image =G(g_noise)
        
        #克隆生成网络
        g_program =dg_program.clone()
        g_program_test = dg_program.clone(for_test=True)
        
        #判别图像
        dg_logit =D(g_image)
        
        #计算损失
        dg_loss = fluid.layers.sigmoid_cross_entropy_with_logits(x=dg_logit, label=g_label)
        dg_avg_loss =fluid.layers.mean(dg_loss)
    
    #配置优化方法
    optimizer = fluid.optimizer.Adam(learning_rate=0.0002) #Adam算法
d_parameters = [p.name for p ind_program.global_block().all_parameters()]
    optimizer.minimize(loss=d_avg_loss, parameter_list=d_parameters) #最小化判别网络平均损失值
g_parameters = [p.name for p ing_program.global_block().all_parameters()]
    optimizer.minimize(loss=dg_avg_loss, parameter_list=g_parameters) #最小化生成网络平均损失值

    #启动程序
    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() #获取执行设备
    exe = fluid.Executor(place) #获取执行程序
    exe.run(fluid.default_startup_program()) #运行启动程序
    
    #训练模型
    for epoch inrange(epoch_num):
        for batch, train_data inenumerate(train_reader()):
            #准备训练数据
            if len(train_data) !=batch_size:
                continue
            real_images = np.array(list(map(lambda x: x[0], train_data))).reshape(-1, 784).astype('float32')
            real_labels = np.ones(shape=[real_images.shape[0], 1], dtype='float32')
            
            fake_noises = np.random.uniform(low=-1.0, high=1.0, size=[batch_size, noise_size]).astype('float32')
            fake_labels = np.zeros(shape=[real_images.shape[0], 1], dtype='float32')

            #生成虚假图像
            fake_images =exe.run(
                program=g_program, 
                feed={'noise': fake_noises}, 
                fetch_list=[g_image])[0]
     
            #训练判别模型:判断虚假图片为假的损失
            d_avg_loss_fake =exe.run(
                program=d_program,
                feed={'image': fake_images, 'label': fake_labels},
                fetch_list=[d_avg_loss])[0][0]
            
            #训练判别模型:判断真实图片为真的损失
            d_avg_loss_real =exe.run(
                program=d_program,
                feed={'image': real_images, 'label': real_labels},
                fetch_list=[d_avg_loss])[0][0]
            
            #计算判别损失
            d_avg_loss_n = d_avg_loss_fake +d_avg_loss_real
     
            #训练生成模型
            for i in range(2):
                noise = np.random.uniform(low=-1.0, high=1.0, size=[batch_size, noise_size]).astype('float32')
                dg_avg_loss_n =exe.run(
                    program=dg_program,
                    feed={'noise': noise},
                    fetch_list=[dg_avg_loss])[0][0]

            #显示生成图像
            if batch % 10 ==0:
                #获取生成图像
                noise = np.random.uniform(low=-1.0, high=1.0, size=[batch_size, noise_size]).astype('float32')
                generate_images =exe.run(
                    program=g_program_test,
                    feed={'noise': noise},
                    fetch_list=[g_image])[0]
                
                total_image =np.concatenate([real_images, generate_images])
                
                #显示生成图像 
                print("Epoch: {0}, Batch: {1}, D AVG Loss: {2}, DG AVG Loss: {3}".format(epoch, batch, d_avg_loss_n, dg_avg_loss_n))
                show_image(total_image)

#主函数
if __name__ == "__main__":
    train()

实验结果:

8行为训练集字符,后8行为生成字符

Epoch: 19, Batch: 460, D AVG Loss: 1.1578519344329834, DG AVG Loss: 0.6636089086532593

[Paddle学习笔记][05][对抗生成网络]第1张

参考资料:

https://www.paddlepaddle.org.cn/documentation/docs/zh/user_guides/cv_case/gan/README.cn.html

免责声明:文章转载自《[Paddle学习笔记][05][对抗生成网络]》仅用于学习参考。如对内容有疑问,请及时联系本站处理。

上篇Subversion版本控制环境在Windows系统下的安装实现socket非阻塞设置下篇

宿迁高防,2C2G15M,22元/月;香港BGP,2C5G5M,25元/月 雨云优惠码:MjYwNzM=

随便看看

UOS怎么安装谷歌浏览器

这是安装完成的截图点击UOS左下角启动器图标,拉至最底下,找到“Chromium网页浏览器”,点击启动以下是启动的界面截图...

Jboss

同时,为了扩大JBoss的企业市场,JBoss已经签署了许多渠道合作伙伴。2004年6月,JBoss宣布JBoss应用服务器已通过Sun公司的J2EE认证。这是JBoss应用服务器历史上最重要的里程碑。JBossAOP 1.0于2004年10月发布。这也证实了JBoss是一家创新型公司。JBoss应用服务器5.0于2008年12月6日正式发布。新版本的应用服...

【转】MUD教程--巫师入门教程4

在MUD中,为了解决定时触发某种现象,一般有两种方法,一种是通过call_out()延时呼叫,另一种就是通过心跳。于是,对于要跨起离线前后的象做牢这类的事,大多都是采用condition。附:由于大多数MUD里的心跳是每两秒调一次,5+random是5至14次,因此可以看出每一个condition被调用的时间是平均19秒。然后它会按照condition的名字...

VSCode, 当今最流行的免费开源代码编辑器,微软出品,必属精品

Visual Studio代码是一个轻量级但功能强大的源代码编辑器,可以在桌面上运行,可以用于Windows、MacOS和Linux。直接在编辑器中检查差异,暂时保存文件并提交。Visual Studio代码产品在初始操作中的内部代码控制可以通过编辑器内的SCM支持(包括丰富的Git集成)加快发布周期。用户界面-介绍VSCode编辑器的基本UI、命令和功能。...

NodeJs使用jwt生成token以及使用express-jwt校验和解密token

=0){//当数据库有当前用户时,它返回tokenlettoken=jwt.sign;res.send}else{res.send}}catch{//p抛出异常并将其发送到错误中间件以处理console.log;next;}})//注册接口路由器。post('/register',异步(req,res,next)=˃{let{用户名,密码,昵称}=req-b...

MongoDB 查看集合的统计信息

--1查看集合的统计信息srs0:“size”:“ok”:可以理解为集合名称计数:集合中的文档总数大小:连续分配的数据块索引:最近分配的块的大小paddingFactor:所有索引索引的总大小大小:--2显示rs0:db。东西。stats(1024)(KB);{“ns”:“count”:“size”:“indexSize”:...