精华内容
下载资源
问答
  • Adversarial Generation of Training Examples: Applications to Moving Vehicle License Plate ...DCGAN、WGAN、infoGAN数据不够?GAN来凑! 2017年GAN 计算机视觉相关paper汇总 DCGAN生成器结构:
    展开全文
  • 常用数据增强系神奇gan-CycleGan

    千次阅读 2020-08-13 00:44:52
    常用数据增强系类神奇gan-CycleGan 学习目录常用数据增强系类神奇gan-CycleGan学习前言那么什么是CycleGan?CircleGan的安装生成网络的构建Generator判别网络Discriminatorloss计算训练 学习前言 写了一天代码,累加...

    常用数据增强系神奇gan-CycleGan

    学习前言

    写了一天代码,累加懒。本来今天想解读下下yolov4的讲解的,感觉要打太多,就有空写吧。昨天突然产生出灵感,讲讲一些论文里面常提出来的用gan来数据增强吧(改进思路),cycleGan,它的思想也是我也挺喜欢。

    github

    https://github.com/yanjingke/cyclegan

    那么什么是CycleGan?

    许多名画造假者费尽毕生的心血,试图模仿出艺术名家的风格。CycleGAN就可以初步实现这个神奇的功能。这个功能就是风格迁移。
    在这里插入图片描述
    在这里插入图片描述

    CircleGan的安装

    因为由于CycleGAN要用到InstanceNormalization,这个函数在普通的keras内不存在,所以要安装一个新的库。

    首先去github上下载https://github.com/keras-team/keras-contrib库,下载完后解压。cmd 里面进入目录python setup.py install。github下载慢的话,可以把项目clone到码云里面,下载。具体百度吧
    在这里插入图片描述

    生成网络的构建Generator

    生成网络的目标主要是生成你想转换的那张目标
    在这里插入图片描述
    在生成网络中我们使用何凯明大神提出的resnet,其实包括图像复原,还有图像很多相关的就是利用先下采样,在上采样,对图片进行预测和修复。resnet我就不具体介绍:他主要利用了残差块,加深了网络结构,减少了梯度下降的情况。
    在这里插入图片描述

    具体代码如下:

    import keras
    from keras.models import *
    from keras.layers import *
    from keras import layers
    import keras.backend as K
    from keras_contrib.layers.normalization.instancenormalization import InstanceNormalization
    
    IMAGE_ORDERING = 'channels_last'
    def one_side_pad( x ):
        x = ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING)(x)
        if IMAGE_ORDERING == 'channels_first':
            x = Lambda(lambda x : x[: , : , :-1 , :-1 ] )(x)
        elif IMAGE_ORDERING == 'channels_last':
            x = Lambda(lambda x : x[: , :-1 , :-1 , :  ] )(x)
        return x
     def identity_block(input_tensor, kernel_size, filter_num, block):
    
    
        conv_name_base = 'res' + block + '_branch'
        in_name_base = 'in' + block + '_branch'
    
        x = ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING)(input_tensor)
        x = Conv2D(filter_num, (3, 3) , data_format=IMAGE_ORDERING , name=conv_name_base + '2a')(x)
        x = InstanceNormalization(axis=3,name=in_name_base + '2a')(x)
        x = Activation('relu')(x)
    
        x = ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING)(x)
        x = Conv2D(filter_num , (3, 3), data_format=IMAGE_ORDERING , name=conv_name_base + '2c')(x)
        x = InstanceNormalization(axis=3,name=in_name_base + '2c')(x)
        # 残差网络
        x = layers.add([x, input_tensor])
        x = Activation('relu')(x)
        return x
    
    
    def get_resnet(input_height, input_width, channel):
        img_input = Input(shape=(input_height,input_width , 3 ))
        # 128,128,3 -> 128,128,64
        x = ZeroPadding2D((3, 3), data_format=IMAGE_ORDERING)(img_input)
        x = Conv2D(64, (7, 7), data_format=IMAGE_ORDERING)(x)
        x = InstanceNormalization(axis=3)(x)
        x = Activation('relu')(x)
    
        # 128,128,64 -> 64,64,128
        x = ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING)(x)
        x = Conv2D(128, (3, 3), data_format=IMAGE_ORDERING, strides=2)(x)
        x = InstanceNormalization(axis=3)(x)
        x = Activation('relu')(x)
    
        # 64,64,128 -> 32,32,256
        x = ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING)(x)
        x = Conv2D(256, (3, 3), data_format=IMAGE_ORDERING, strides=2)(x)
        x = InstanceNormalization(axis=3)(x)
        x = Activation('relu')(x)
    
        for i in range(9):
            x = identity_block(x, 3, 256, block=str(i))
        
        # 32,32,256 -> 64,64,128
        x = ( UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
        x = ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING)(x)
        x = Conv2D(128, (3, 3), data_format=IMAGE_ORDERING)(x)
        x = InstanceNormalization(axis=3)(x)
        x = Activation('relu')(x)
        
        # 64,64,128 -> 128,128,64
        x = ( UpSampling2D( (2,2), data_format=IMAGE_ORDERING))(x)
        x = ZeroPadding2D((1, 1), data_format=IMAGE_ORDERING)(x)
        x = Conv2D(64, (3, 3), data_format=IMAGE_ORDERING)(x)
        x = InstanceNormalization(axis=3)(x)
        x = Activation('relu')(x)    
    
        # 128,128,64 -> 128,128,3
        x = ZeroPadding2D((3, 3), data_format=IMAGE_ORDERING)(x)
        x = Conv2D(channel, (7, 7), data_format=IMAGE_ORDERING)(x)
        x = Activation('tanh')(x)  
        model = Model(img_input,x)
        return model
    
    

    判别网络Discriminator

    判别网络主要是判别生成的图片的真假。
    在这里插入图片描述
    具体代码,如下:

        def build_discriminator(self):
    
            def conv2d(layer_input, filters, f_size=4, normalization=True):
                d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)
                if normalization:
                    d = InstanceNormalization()(d)
                d = LeakyReLU(alpha=0.2)(d)
                return d
    
            img = Input(shape=self.img_shape)
            # 64,64,64
            d1 = conv2d(img, 64, normalization=False)
            # 32,32,128
            d2 = conv2d(d1, 128)
            # 16,16,256
            d3 = conv2d(d2, 256)
            # 8,8,512
            d4 = conv2d(d3, 512)
            # 对每个像素点判断是否有效
            # 64
            # 8,8,1
            validity = Conv2D(1, kernel_size=3, strides=1, padding='same')(d4)
    
            return Model(img, validity)
    

    在判别网络中最后输出为881.可以理解为有64个评委对图片的真伪做出了打分。

    loss计算

    在判别模型Discriminator的loss,主要采用了均方差,这种计算方式据说可以提高预测的的准确性。训练的标签并不是配对的,而且我们利用网络引导生成的。在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    训练

      # 创建生成模型
            self.g_AB = self.build_generator()
            self.g_BA = self.build_generator()
    
            img_A = Input(shape=self.img_shape)
            img_B = Input(shape=self.img_shape)
    
            # 生成假的B图片
            fake_B = self.g_AB(img_A)
            # 生成假的A图片
            fake_A = self.g_BA(img_B)
    
            # 从B再生成A
            reconstr_A = self.g_BA(fake_B)
            # 从B再生成A
            reconstr_B = self.g_AB(fake_A)
            self.g_AB.summary()
            # 通过g_BA传入img_A
            img_A_id = self.g_BA(img_A)
            # 通过g_AB传入img_B
            img_B_id = self.g_AB(img_B)
    
            # 在这一部分,评价模型不训练。
            self.d_A.trainable = False
            self.d_B.trainable = False
    
            # 评价是否为真
            valid_A = self.d_A(fake_A)
            valid_B = self.d_B(fake_B)
    
            # 训练
            self.combined = Model(inputs=[img_A, img_B],
                                  outputs=[ valid_A, valid_B,
                                            reconstr_A, reconstr_B,
                                            img_A_id, img_B_id ])
            self.combined.compile(loss=['mse', 'mse',
                                        'mae', 'mae',
                                        'mae', 'mae'],
                                loss_weights=[0.5, 0.5,
                                            self.lambda_cycle, self.lambda_cycle,
                                            self.lambda_id, self.lambda_id ],
                                optimizer=optimizer)
    
    
        def train(self, init_epoch, epochs, batch_size=1, sample_interval=50):
    
            start_time = datetime.datetime.now()
    
            valid = np.ones((batch_size,) + self.disc_patch)
            fake = np.zeros((batch_size,) + self.disc_patch)
            if init_epoch!= 0:
                self.d_A.load_weights("weights/%s/d_A_epoch%d.h5" % (self.dataset_name, init_epoch),skip_mismatch=True)
                self.d_B.load_weights("weights/%s/d_B_epoch%d.h5" % (self.dataset_name, init_epoch),skip_mismatch=True)
                self.g_AB.load_weights("weights/%s/g_AB_epoch%d.h5" % (self.dataset_name, init_epoch),skip_mismatch=True)
                self.g_BA.load_weights("weights/%s/g_BA_epoch%d.h5" % (self.dataset_name, init_epoch),skip_mismatch=True)
    
            for epoch in range(init_epoch,epochs):
                self.scheduler([self.combined,self.d_A,self.d_B],epoch)
                for batch_i, (imgs_A, imgs_B) in enumerate(self.data_loader.load_batch(batch_size)):
                    # ------------------ #
                    #  训练生成模型
                    # ------------------ #
                    g_loss = self.combined.train_on_batch([imgs_A, imgs_B],
                                                            [valid, valid,
                                                            imgs_A, imgs_B,
                                                            imgs_A, imgs_B])
                    # ---------------------- #
                    #  训练评价者
                    # ---------------------- #
                    # A到B的假图片,此时生成的是假橘子
                    fake_B = self.g_AB.predict(imgs_A)
                    # B到A的假图片,此时生成的是假苹果
                    fake_A = self.g_BA.predict(imgs_B)
                    # 判断真假图片,并以此进行训练
                    dA_loss_real = self.d_A.train_on_batch(imgs_A, valid)
                    dA_loss_fake = self.d_A.train_on_batch(fake_A, fake)
                    dA_loss = 0.5 * np.add(dA_loss_real, dA_loss_fake)
                    # 判断真假图片,并以此进行训练
                    dB_loss_real = self.d_B.train_on_batch(imgs_B, valid)
                    dB_loss_fake = self.d_B.train_on_batch(fake_B, fake)
                    dB_loss = 0.5 * np.add(dB_loss_real, dB_loss_fake)
    
                    d_loss = 0.5 * np.add(dA_loss, dB_loss)
                    
    
                    elapsed_time = datetime.datetime.now() - start_time
    
                    print ("[Epoch %d/%d] [Batch %d/%d] [D loss: %f, acc: %3d%%] [G loss: %05f, adv: %05f, recon: %05f, id: %05f] time: %s " \
                                                                            % ( epoch, epochs,
                                                                                batch_i, self.data_loader.n_batches,
                                                                                d_loss[0], 100*d_loss[1],
                                                                                g_loss[0],
                                                                                np.mean(g_loss[1:3]),
                                                                                np.mean(g_loss[3:5]),
                                                                                np.mean(g_loss[5:6]),
                                                                                elapsed_time))
    
                    if batch_i % sample_interval == 0:
                        self.sample_images(epoch, batch_i)
                        if epoch % 5 == 0 and epoch != init_epoch:
                            os.makedirs('weights/%s' % self.dataset_name, exist_ok=True)
                            self.d_A.save_weights("weights/%s/d_A_epoch%d.h5" % (self.dataset_name, epoch))
                            self.d_B.save_weights("weights/%s/d_B_epoch%d.h5" % (self.dataset_name, epoch))
                            self.g_AB.save_weights("weights/%s/g_AB_epoch%d.h5" % (self.dataset_name, epoch))
                            self.g_BA.save_weights("weights/%s/g_BA_epoch%d.h5" % (self.dataset_name, epoch))
    
    展开全文
  • AugGAN:基于GAN的图像数据增强

    万次阅读 多人点赞 2018-11-01 16:45:06
    台湾国立清华大学在ECCV2018发表了一篇AugGAN开始把GAN用在数据增强方面了,当然,这并不是这个领域的第一篇。不过很具有参考意义,也很能解决实际问题。所以特地写一个blog研究一番。 读本文需要懂GAN和Auto-...

    数据增强方法无疑是需要重点研究的基本任务之一,因为我们的主流深度学习算法还是一个有监督过程。台湾国立清华大学在ECCV2018发表了一篇AugGAN开始把GAN用在数据增强方面了,当然,这并不是这个领域的第一篇。不过很具有参考意义,也很能解决实际问题。所以特地写一个blog研究一番。

    读本文需要懂GAN和Auto-Encoder的基本算法流程,没有GAN和AE基础的可以看我关于GAN和AE写的详细图解教程:

    GAN》《Auto-Encoder》 

    论文标题: 《AugGAN: Cross Domain Adaptation with GAN-based Data Augmentation》

    论文地址:   http://openaccess.thecvf.com/content_ECCV_2018/papers/Sheng-Wei_Huang_AugGAN_Cross_Domain_ECCV_2018_paper.pdf


    训练数据

    AugGAN的特点是转换准度高,即转换后的数据可用性高,目前在转换数据的可用性上,AugGAN是顶尖算法了。但AugGAN基于语义分割的结构意识,需要有分割数据标签。这点导致AugGAN的数据来源相当困难。不过好在AugGAN的迁移性挺好,也存在这样的数据集,比如SYNTHIA,STA等等。SYNTHIA是电脑合成的图,并非是真实世界得来的数据。SYTHIA示例如下:

    上述就是AugGAN的训练数据了,包含:1. 分割掩模;2,不同领域的图像(春天和冬天,白天和黑夜)。 


     

    AugGAN结构

    数据增强可以分作很多方面,我们对原始数据进行扩充就是数据增强。此文是基于领域变换的数据增强,如文章标题所言,“跨域适应的GAN基数据增强”。首先,要理解这里的跨域的概念。

    栗子是很好举的,我们通常采集数据由于各种限制会导致采集数据十分局限。比如对于行人检测而言,我们白天采集数据,然后用白天采集的数据训练模型,把这个模型用到晚上,就会发现效果很差。于是,你不得不晚上再去采集数据。当然,AugGAN的存在让你不再需要晚上再去采集数据。这里有个原因是,白天数据和晚上数据其实冗余成分很大,只是数据域(domain)的不同。如果能把一个数据域的数据搬移到另一个数据域,是不是就增强了数据呢?我们可以通过白天的数据来生成晚上的数据;我们可以通过夏天的数据生成冬天的数据;我们依然可以通过晴天的数据生成雾霾的数据。这么操作,数据量是不是大大增加了呢?

    很容易让人联想到cycleGAN,这是很优秀的风格变换网络。可以一键把照片换成水彩画,甚至可以换成毕加索风格。但cycleGAN的目的不是为了数据增强,更注重其“艺术性”。数据增强这一块跟AugGAN差别还是不小的,一会儿可以看例子。

    喜欢看GAN相关的文章,是因为这些文章无须过多的trick,一个网络结构就足以抽出文章的精髓(像极了几年前的卷积神经网络,那是一个回不去的年代)。直接丢图:

     用简单的话描述上图,这是自编码器和GAN结合的结构。X,Y就是代表两个领域(比如说白天和黑夜)的数据。首先对X和Y进行编码降维,都会得到一个特征域Z,这个Z会对接两个解码器,一个解码器负责伪装数据,另一个解码器负责恢复数据。

    \hat{X}_{pred}\hat{Y}_{pred}为解码之后得到的掩模,将会和ground truth做一个loss。

    下面详细解析这个框架图


    1. 结构意识(structure-aware)与分割子任务

    结构意识是这篇文章的最大卖点,意思是,让模型在转换图像的时候,明白图像不同位置分别是什么物体或者背景。这就依赖一个分割标签即掩模,如下所示:

    具体怎么让模型知道各自是什么呢?依靠一个叫做权值软共享的操作! 待会儿会好好说这个权值软共享。

    对于结构意识,我们只需在解码的时候还原掩模就可以了,loss function如下:

     \hat{X}表示ground truth的掩模, Px(Ex(x))表示生成的掩模,所以有以上的损失函数。y的loss function和x的完全一致,就不单独列出来了。

    2. 权值共享

    权值共享分为硬共享(hard-sharing)和软共享(soft-sharing),前者直接就是完全一样的权值了,后者通过一些函数约束。

    如上图标注,绿色框代表权值硬共享,即每个Resblock的权值是一样的,蓝色框代表软共享,依靠一定的要求束缚。硬共享的resblock期望找到一种映射准则,而软共享的上采样模块期望建立一定的联系,这也是 structure-aware的实现基础。用掩模的上采样来束缚解压的上采样,这样使得\bar{Y}\hat{X}_{pred}享有一样的结构意识。

    软共享通过训练来实现:

    通过MSE来实现G和P的权值束缚。


    3.循环一致性(cycle-consistency)

     一句话可以描述这个概念:X能够被重构,这就是循环一致性。也可以以此建立一个损失函数,如上。

    4.对抗训练

    训练GAN的生成器和判别器,GAN最基本的概念,有疑问可以看 《GAN

    5.full loss function 

    这就表达了整个模型训练时所用的损失函数了。就是把前面四种损失函数加到一起。


    结果 

     

    用YOLO和Faster RCNN测试了AugGAN的数据增强效果。当然这里的YOLO还是v1,所以表现很菜。可以看出,AugGAN的表现确实抢过非监督图图转换模型UNIT和CycleGAN。 


    总结 

    AugGAN是监督式算法,依赖分割标签。如果数据充足的情况下,AugGAN的转换数据的可用性非常高。但其数据来源成本十分高,虽然具有很强的迁移性,不过对于具体的项目也不太好实用。

    这篇论文提供了一个结构意识的新思路,让模型理解图像的结构信息,这样做转换的时候更具有针对性,所以不容易淹没主要信息。

    展开全文
  • 使用GAN(生成对抗网络)生成一类花卉图片的训练样本

    使用GAN(生成对抗网络)生成一类花卉图片的训练样本

    展开全文
  • 12-GAN-使用GAN生成相似图片-数据增强

    万次阅读 热门讨论 2018-09-12 00:17:03
    本篇将使用GAN(生成对抗网络)生成一类花卉图片的训练样本,也就是说我们现在拥有1000张樱花的图片,但是数据集的量太少导致分类模型的判别能力较弱,而且容易导致过拟合等问题,所以这里我们需要增加训练样本,但是...
  • 1.前言 近年CVPR2018录用了很多person re-id相关论文,本着学习和总结的原则,来对目前行人重识别上最新的方法...本文主要是对目前读到的三篇用GAN进行数据增强的文章进行介绍,分别是《Camera Style Adaptation f...
  • GAN生成数据-数据扩增

    千次阅读 2019-07-11 09:28:53
    http://www.zhuanzhi.ai/document/7fd3ab2d82d75165eff768a06dfb74bf ***一文概览用于数据增强的对抗生成网络架构 https://github.com/AntreasAntoniou/DAGAN ***DAGAN: Data Augmentation Generative ...
  • 协助学长做车辆数据集扩充,从车辆的一个角度生成车辆的另外一个角度,使用GAN网络。目前的GAN网络的输入为512*256的图像,下图为网络输入样例,左边是生成图像,右边是原始图像。将数据集用GAN网络训练后,网络可以...
  • 使用GAN来进行CV数据增强(一)

    千次阅读 2018-08-18 22:44:15
    一.论文 Unlabeled Samples Generated by GAN Improve the Person Re-identification Baseline in vitro...使用原始数据训练DCGAN,然后根据得到的模型产生新的数据作为扩充数据用于训练 设计LSRO(label smoothing...
  • ...如果GAN只是用来生成一些像真是数据一样的数据的话,那不会有像现在这么火。更多的,或者对于机器学习研究员来说,看待的最关键一点应该是GAN可以用来 拟合数据分布 。什么叫拟合数据分布,...
  • 基于GAN的方法用于生成高分辨率遥感数据,以进行数据增强和图像分类。 深度学习框架是:Tensorflow。 Python版本:2.7 CUDA版本:9.1 端子命令: 数据集为UCM,NWPU-RESISC45:(1)UC Merced数据集 (2)NWPU...
  • 具有DiffAugment的数据高效GAN | | | 仅使用100张奥巴马,脾气暴躁的猫,熊猫,叹息桥,美第奇喷泉,天坛的图像而无需预先训练即可生成。 [NEW!]我们的发布了! [NEW!]支持FFHQ培训! 请参阅自述文件。 [NEW...
  • 用python语言,利用对抗抗神经网络(GAN神经)生成一维数据,用python语言,利用对抗抗神经网络(GAN神经)生成一维数据
  • GAN

    2019-03-10 17:27:32
    入坑GAN,首先需要理由,GAN能做什么,为什么要学GANGAN的初衷就是生成不存在于真实世界的数据,类似...进行数据增强,根据已有数据生成更多新数据供以feed,可以减缓模型过拟合现象。 以上的场景都可以找到相...
  • 生成对抗网络(GAN)实例 代码+数据集 很实用的代码,并且简单易学,对深度学习感兴趣的可以看看 数据集有手写图片的识别,也可以替换成自己的数据
  • 使用GAN的图像增强 项目
  • 为了清楚地理解GAN是如何工作的以及如何实现它们,本节将会在MNIST数据集上演示GAN的一个简单实现。 首先,需要构建GAN网络的核心,它由两个主要部分组成:生成器和判别器。生成器将会尝试从某个特定的概率分布中...
  • (ii)然后使用积极的数据和特征增强对找到的稀疏子网进行训练。 这两个子问题都重用了相同的小型实际图像训练集。 这种协调的框架使我们能够专注于较低复杂性和数据效率更高的子问题,从而有效地稳定了培训并提高...
  • 这样生成的大多数图像都没有包含在训练数据集中,说明用GAN生成的数据增强数据集的能力很强。尽管在数据有限的情况下这种情况特别重要,但是基于有限数据训练GAN的问题仍然存在。为了弥补这一缺陷,本文结合迁移...
  • 1. 几种常见的GAN介绍 1.1. 原始GAN 1.2. CGAN 1.3. Semi-Supervised GAN 1.4. AC-GAN 2. Data Augmentation with Few Shot Learning 2.1. SMOTE 2.2. WGAN 2.3. BAGAN 1. 几种常见的...
  • 这是WaveGAN的扩展,以增强房间脉冲响应(RIR)。 您可以在此处找到有关此项目的更多详细信息。 要求 tensorflow-gpu==1.12.0 scipy==1.0.0 matplotlib==3.0.2 librosa==0.6.2 ffmpeg ==4.2.1 cuda ==9.0.176 cudnn ...
  • 第一行:SYNTHIA输入图像,第二行:cycle-GAN昼夜输出,第三行:Aug-GAN昼夜输出; 第4行:KITTI输入图像,第5行:cycle-GAN日夜输出,第6行:Aug-GAN日夜输出。 视频1:使用Cycle-GAN进行顺序比较 左:输入序列,中...
  • GAN增强网络安全

    千次阅读 2019-06-23 16:23:00
    这三个神经网络模块共同构成了对抗神经网络的主体,Alice和Bob组成的网络看做GAN中的生成模型G, 而Eve则被看做GAN中的批判模型D,我们希望Eve恢复秘钥的概率为0.5,在这里是对等于恢复秘钥的位数为明文的1/2,即...
  • 增强GaN器件的特性

    2020-11-23 21:31:33
    简单介绍增强GaN器件的转移特性、输出特性与反向导通特性。
  • 简单介绍了增强GaN器件的驱动电压要求、可靠性问题以及驱动技术。
  • DeLiGAN: 对于多样性和有限数据GAN

    千次阅读 2018-04-18 19:54:10
    DeLiGAN: 对于多样性和有限数据GAN 前言 技术人还是要写技术文啊,写什么情感大戏啊。 开始遨游CVPR2017,主要是为了学习更多的深度学习网络架构 讲道理计算机视觉的深度学习架构是深度学习各领域比较先进的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,182
精华内容 3,272
关键字:

gan数据增强