精华内容
下载资源
问答
  • 数据增广

    2020-02-24 18:33:20
    图像增广(image augmentation)技术通过对训练图像做一系列随机改变,来产生相似但又不同的训练样本,从而扩大训练数据集的规模 图像增广的另一种解释是,随机改变训练样本可以降低模型对某些属性的依赖,从而提高...

    图像增广

    大规模数据集是成功应用深度神经网络的前提。图像增广(image augmentation)技术通过对训练图像做一系列随机改变,来产生相似但又不同的训练样本,从而扩大训练数据集的规模

    图像增广的另一种解释是,随机改变训练样本可以降低模型对某些属性的依赖,从而提高模型的泛化能力。例如,我们可以对图像进行不同方式的裁剪,使感兴趣的物体出现在不同位置,从而减轻模型对物体出现位置的依赖性。我们也可以调整亮度、色彩等因素来降低模型对色彩的敏感度

    可以说图像增广的作用有:扩大训练集规模、降低模型对某些属性的依赖

    导入实验用的数据

    %matplotlib inline
    import os
    os.listdir("/home/kesci/input/img2083/")
    
    import time
    import torch
    from torch import nn, optim
    from torch.utils.data import Dataset, DataLoader
    import torchvision
    import sys
    from PIL import Image
    
    sys.path.append("/home/kesci/input/")
    #置当前使用的GPU设备仅为0号设备
    os.environ["CUDA_VISIBLE_DEVICES"] = "0"   
    
    import d2lzh1981 as d2l
    
    # 定义device,是否使用GPU,依据计算机配置自动会选择
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    print(torch.__version__)
    print(device)

    图像增广的例子:

    d2l.set_figsize()
    img = Image.open('/home/kesci/input/img2083/img/cat1.jpg')
    d2l.plt.imshow(img)

    在这里插入图片描述
    定义绘图函数

    # 本函数已保存在d2lzh_pytorch包中方便以后使用
    def show_images(imgs, num_rows, num_cols, scale=2):
        figsize = (num_cols * scale, num_rows * scale)
        _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
        for i in range(num_rows):
            for j in range(num_cols):
                axes[i][j].imshow(imgs[i * num_cols + j])
                axes[i][j].axes.get_xaxis().set_visible(False)
                axes[i][j].axes.get_yaxis().set_visible(False)
        return axes

    大部分图像增广方法都有一定的随机性。为了方便观察图像增广的效果,接下来我们定义一个辅助函数apply。这个函数对输入图像img多次运行图像增广方法aug并展示所有的结果。

    def apply(img, aug, num_rows=2, num_cols=4, scale=1.5):
        Y = [aug(img) for _ in range(num_rows * num_cols)]
        show_images(Y, num_rows, num_cols, scale)

    翻转和裁剪

    左右翻转图像通常不改变物体的类别。它是最早也是最广泛使用的一种图像增广方法。下面我们通过torchvision.transforms模块创建RandomHorizontalFlip实例来实现一半概率的图像水平(左右)翻转。
    在这里插入图片描述

    在这里插入图片描述
    在下面的代码里,我们每次随机裁剪出一块面积为原面积10%∼100%的区域,且该区域的宽和高之比随机取自0.5∼2,然后再将该区域的宽和高分别缩放到200像素。若无特殊说明,本节中a和b之间的随机数指的是从区间[a,b]中随机均匀采样所得到的连续值。

    In [8]:
    
    shape_aug = torchvision.transforms.RandomResizedCrop(200, scale=(0.1, 1), ratio=(0.5, 2))
    apply(img, shape_aug)

    在这里插入图片描述

    变换颜色

    另一类增广方法是变化颜色。我们可以从4个方面改变图像的颜色:亮度(brightness)、对比度(contrast)、饱和度(saturation)和色调(hue)。在下面的例子里,我们将图像的亮度随机变化为原图亮度的50%(1−0.5)∼150%(1+0.5)。
    在这里插入图片描述
    随机变换色调在这里插入图片描述
    对比度
    在这里插入图片描述
    我们也可以同时设置如何随机变化图像的亮度(brightness)、对比度(contrast)、饱和度(saturation)和色调(hue)。
    在这里插入图片描述

    叠加多个图像增广方法

    实际应用中我们会将多个图像增广方法叠加使用。我们可以通过Compose实例将上面定义的多个图像增广方法叠加起来,再应用到每张图像之上。
    在这里插入图片描述

    使用图像增广训练模型

    下面我们来看一个将图像增广应用在实际训练中的例子。这里我们使用CIFAR-10数据集,而不是之前我们一直使用的Fashion-MNIST数据集。这是因为Fashion-MNIST数据集中物体的位置和尺寸都已经经过归一化处理,而CIFAR-10数据集中物体的颜色和大小区别更加显著。下面展示了CIFAR-10数据集中前32张训练图像。

    CIFAR_ROOT_PATH = '/home/kesci/input/cifar102021'
    all_imges = torchvision.datasets.CIFAR10(train=True, root=CIFAR_ROOT_PATH, download = True)
    # all_imges的每一个元素都是(image, label)
    show_images([all_imges[i][0] for i in range(32)], 4, 8, scale=0.8);

    在这里插入图片描述
    为了在预测时得到确定的结果,我们通常只将图像增广应用在训练样本上,而不在预测时使用含随机操作的图像增广。在这里我们只使用最简单的随机左右翻转。此外,我们使用ToTensor将小批量图像转成PyTorch需要的格式,即形状为(批量大小, 通道数, 高, 宽)、值域在0到1之间且类型为32位浮点数。

    flip_aug = torchvision.transforms.Compose([
         torchvision.transforms.RandomHorizontalFlip(),
         torchvision.transforms.ToTensor()])
    
    no_aug = torchvision.transforms.Compose([
         torchvision.transforms.ToTensor()])

    接下来我们定义一个辅助函数来方便读取图像并应用图像增广。有关DataLoader的详细介绍,可参考更早的3.5节图像分类数据集(Fashion-MNIST)。

    num_workers = 0 if sys.platform.startswith('win32') else 4
    def load_cifar10(is_train, augs, batch_size, root=CIFAR_ROOT_PATH):
        dataset = torchvision.datasets.CIFAR10(root=root, train=is_train, transform=augs, download=False)
        return DataLoader(dataset, batch_size=batch_size, shuffle=is_train, num_workers=num_workers)

    我们在CIFAR-10数据集上训练5.11节(残差网络)中介绍的ResNet-18模型。
    我们先定义train函数使用GPU训练并评价模型。

    # 本函数已保存在d2lzh_pytorch包中方便以后使用
    def train(train_iter, test_iter, net, loss, optimizer, device, num_epochs):
        net = net.to(device)
        print("training on ", device)
        batch_count = 0
        for epoch in range(num_epochs):
            train_l_sum, train_acc_sum, n, start = 0.0, 0.0, 0, time.time()
            for X, y in train_iter:
                X = X.to(device)
                y = y.to(device)
                y_hat = net(X)
                l = loss(y_hat, y)
                optimizer.zero_grad()
                l.backward()
                optimizer.step()
                train_l_sum += l.cpu().item()
                train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
                n += y.shape[0]
                batch_count += 1
            test_acc = d2l.evaluate_accuracy(test_iter, net)
            print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec'
                  % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))

    然后就可以定义train_with_data_aug函数使用图像增广来训练模型了。该函数使用Adam算法作为训练使用的优化算法,然后将图像增广应用于训练数据集之上,最后调用刚才定义的train函数训练并评价模型。

    def train_with_data_aug(train_augs, test_augs, lr=0.001):
        batch_size, net = 256, d2l.resnet18(10)
        optimizer = torch.optim.Adam(net.parameters(), lr=lr)
        loss = torch.nn.CrossEntropyLoss()
        train_iter = load_cifar10(True, train_augs, batch_size)
        test_iter = load_cifar10(False, test_augs, batch_size)
        train(train_iter, test_iter, net, loss, optimizer, device, num_epochs=10)
    
    train_with_data_aug(flip_aug, no_aug)
    展开全文
  • 数据增广论文

    2019-01-29 10:27:09
    数据增广论文Chuanhai Zhang et al. 2017 Keywords: Real data augmentation Unbalanced data Image classification
  • 数据增广数据增广之详细理解

    千次阅读 2020-05-22 14:52:18
    数据增广是深度学习中常用的技巧之一,主要用于增加训练数据集,让数据集尽可能的多样化,使得训练的模型具有更强的泛化能力.现有的各大深度学习框架都已经自带了数据增广,但是平时在用的使用只是直接调用了对应的...

    来自 | 知乎

    地址 | https://zhuanlan.zhihu.com/p/43665254

    作者 | 燕小花

    编辑 | 机器学习算法与自然语言处理公众号

    本文仅作学术分享,若侵权,请联系后台删文处理

     

    引言

    数据增广是深度学习中常用的技巧之一,主要用于增加训练数据集,让数据集尽可能的多样化,使得训练的模型具有更强的泛化能力.现有的各大深度学习框架都已经自带了数据增广,但是平时在用的使用只是直接调用了对应的接口函数,而没有进行详细的分析.在实际应用中,并非所有的增广方式都适用当前的训练数据,你需要根据自己的数据集特征来确定应该使用哪几种数据增广方式.这篇文章的目的是为了更好地理解各种增广方式及其背后的真正原理. 
    目前数据增广主要包括:水平/垂直翻转,旋转,缩放,裁剪,剪切,平移,对比度,色彩抖动,噪声等,这里因为时间问题,有部分还每有完成,后续会进行更新.

     

    数据增广

    所有的数据增广在操作的时候默认是以图像中心点进行的.从数学角度来看,任何操作都可以分成以下几个步骤:1). 首先将旋转点移动到原点处 ;2). 执行如2所描述的绕原点的旋转;3). 再将旋转点移回到原来的位置;这里为了更好地理解,给出一个示例:

    假设图像的原始坐标为  ,平移后的坐标为  ,则平移前和平移后的坐标关系为:

    图像平移

    平移是指所有的像素在x和y方向各平移和,平移变换对应的数学矩阵为

    这里给出平移后的具体实例(这里平移后我采用的是倒映填充):

    图像翻转(图像镜像)

    图像翻转包括水平翻转和垂直翻转.水平翻转的变换矩阵为:

    垂直翻转的变换矩阵为:

    这里给出翻转后的具体实例(这里平移后我采用的是倒映填充):

    图像旋转

    图像旋转是指以某个点(默认为图像中心点)为中心进行任意角度的旋转,其变换矩阵为:

    这里给出旋转后的具体实例(这里平移后我采用的是倒映填充):

    图像缩放

    图像缩放是指对当前图像进行任意尺度的缩放,其变换矩阵为:

    这里给出缩放后的具体实例(这里平移后我采用的是倒映填充):

    图像错切

    图像,其变换矩阵为:

    这里给出错切后的具体实例(这里平移后我采用的是倒映填充):

    图像裁剪

    深度学习的裁剪的常用做法是将图片缩放到原图的1.1倍,然后在缩放后的图像上进行裁剪操作,具体的裁剪实例如下:

    组合变换

    在深度学习中的数据增广一般会采用多种增广方式的组合,这里就会涉及到矩阵乘法运算,根据其运算的规则,可以知道不同的组合顺序结果是不一样的,即线性代数中的  ,当然特例除外.

    为了更好地解释,假设给定平移变换矩阵 ,旋转矩阵  ,缩放矩阵,为了说明这里我给出两个不同的组合变换.对于组合变换一,其组合后的矩阵如下:;对于组合变换二,其组合后的矩阵如下: ,对于两种不同的组合其结果如下:

    数据增广之源码实现

    这里使用python和opencv来实现上述中的各种变换,具体的源码如下:

    
    #coding=utf-8
    ################################################
    # 数据增广,包括
    # 2018.09.02 add
    ################################################
    import numpy as np
    import os
    import cv2
    import copy
    
    
    class DataAugment:
        def __init__(self,debug=False):
            self.debug=debug
            print("Data augment...")
    
        def basic_matrix(self,translation):
            """基础变换矩阵"""
            return np.array([[1,0,translation[0]],[0,1,translation[1]],[0,0,1]])
    
        def adjust_transform_for_image(self,img,trans_matrix):
            """根据图像调整当前变换矩阵"""
            transform_matrix=copy.deepcopy(trans_matrix)
            height, width, channels = img.shape
            transform_matrix[0:2, 2] *= [width, height]
            center = np.array((0.5 * width, 0.5 * height))
            transform_matrix = np.linalg.multi_dot([self.basic_matrix(center), transform_matrix, self.basic_matrix(-center)])
            return transform_matrix
    
        def apply_transform(self,img,transform):
            """仿射变换"""
            output = cv2.warpAffine(img, transform[:2, :], dsize=(img.shape[1], img.shape[0]),
                                    flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT, borderValue=0,)   #cv2.BORDER_REPLICATE,cv2.BORDER_TRANSPARENT
            return output
    
        def apply(self,img,trans_matrix):
            """应用变换"""
            tmp_matrix=self.adjust_transform_for_image(img, trans_matrix)
            out_img=self.apply_transform(img, tmp_matrix)
            if self.debug:
                self.show(out_img)
            return out_img
    
        def random_vector(self,min,max):
            """生成范围矩阵"""
            min=np.array(min)
            max=np.array(max)
            print(min.shape,max.shape)
            assert min.shape==max.shape
            assert len(min.shape) == 1
            return np.random.uniform(min, max)
    
        def show(self,img):
            """可视化"""
            cv2.imshow("outimg",img)
            cv2.waitKey()
    
        def random_transform(self,img,min_translation,max_translation):
            """平移变换"""
            factor=self.random_vector(min_translation,max_translation)
            trans_matrix=np.array([[1, 0, factor[0]],[0, 1, factor[1]],[0, 0, 1]])
            out_img=self.apply(img,trans_matrix)
            return trans_matrix, out_img
    
        def random_flip(self,img,factor):
            """水平或垂直翻转"""
            flip_matrix = np.array([[factor[0], 0, 0],[0, factor[1], 0],[0, 0, 1]])
            out_img=self.apply(img,flip_matrix)
            return flip_matrix, out_img
    
        def random_rotate(self,img,factor):
            """随机旋转"""
            angle=np.random.uniform(factor[0],factor[1])
            print("angle:{}".format(angle))
            rotate_matrix=np.array([[np.cos(angle), -np.sin(angle), 0],[np.sin(angle), np.cos(angle), 0],[0, 0, 1]])
            out_img=self.apply(img,rotate_matrix)
            return rotate_matrix, out_img
    
        def random_scale(self,img,min_translation,max_translation):
            """随机缩放"""
            factor=self.random_vector(min_translation, max_translation)
            scale_matrix = np.array([[factor[0], 0, 0],[0, factor[1], 0],[0, 0, 1]])
            out_img=self.apply(img,scale_matrix)
            return scale_matrix, out_img
    
        def random_shear(self,img,factor):
            """随机剪切,包括横向和众向剪切"""
            angle = np.random.uniform(factor[0], factor[1])
            print("fc:{}".format(angle))
            crop_matrix = np.array([[1, factor[0], 0], [factor[1], 1, 0], [0, 0, 1]])
            out_img=self.apply(img,crop_matrix)
            return crop_matrix, out_img
    
    
    if __name__=="__main__":
        demo=DataAugment(debug=True)
        img=cv2.imread("/pathto/dataArgu/wr.jpg")
    
        # 平移测试
        _,outimg=demo.random_transform(img,(0.1,0.1),(0.2,0.2))  #(-0.3,-0.3),(0.3,0.3)
    
    
       # 垂直变换测试
        _, outimg =demo.random_flip(img,(1.0,-1.0))
    
        # 水平变换测试
        _, outimg =demo.random_flip(img, (-1.0, 1.0))
       
    
        # 旋转变换测试
         _, outimg =demo.random_rotate(img,(0.5,0.8))
       
        # # 缩放变换测试
         _, outimg =demo.random_scale(img,(1.2, 1.2),(1.3,1.3))
    
        # 随机裁剪测试
        _, outimg =demo.random_shear(img,(0.2,0.3))
    
        # 组合变换
        t1,_=demo.random_transform(img,(-0.3,-0.3),(0.3,0.3))
        t2,_=demo.random_rotate(img,(0.5,0.8))
        t3,_=demo.random_scale(img,(1.5,1.5),(1.7,1.7))
        tmp=np.linalg.multi_dot([t1,t2,t3])
        print("tmp:{}".format(tmp))
        out=demo.apply(img,tmp)

    本章中还有几个方法未实现,后续会补上.如果文中有理解错误的地方,欢迎指正.

     

    重磅!忆臻自然语言处理-学术微信交流群已成立

    可以扫描下方二维码,小助手将会邀请您入群交流,

    注意:请大家添加时修改备注为 [学校/公司 + 姓名 + 方向]

    例如 —— 哈工大+张三+对话系统。

    号主,微商请自觉绕道。谢谢!

    推荐阅读:

    【长文详解】从Transformer到BERT模型

    赛尔译文 | 从头开始了解Transformer

    百闻不如一码!手把手教你用Python搭一个Transformer

    展开全文
  • 众所周知在搞深度学习的时候数据是一个大问题,实践证明增加数据量在深度学习过程中能提高模型的性能,因此当数据集非常小的时候数据增广就成为了一个必要手段,而数据增广又分为在线增广和离线增广,下面介绍一下这...

    众所周知在搞深度学习的时候数据是一个大问题,实践证明增加数据量在深度学习过程中能提高模型的性能,因此当数据集非常小的时候数据增广就成为了一个必要手段,而数据增广又分为在线增广和离线增广,下面介绍一下这两个方法的区别并列举pytorch和Keras的数据增广方法帮助理解。

    数据增广就是对现有的数据进行一些图形学或者几何学上的图像变换,网上有很多介绍的因此这里就不过多介绍了。

    在线增广即在模型训练过程中一边训练一边对数据进行增广,这种方法优点是不需要将增广的数据合成出来,因此节省了数据的存储空间,具有很高的灵活性,并且理论上来说训练过程中的数据量是无限的,但是这也可能导致一个问题每个epoch训练的图像都是不一样的,在进行分类或者其他对数据变化要求不太高的任务时这种方法能取得很好的效果,但是在进行如文字识别等对数据变化要求很高的任务时可能不会取得太好的提升,尤其是当数据增广后图像变化很大的情况下模型甚至无法很好的收敛,这种情况下可以尝试离线增广或者在做增广的时候提高使用原图像的概率。

    离线增广即在进行模型训练之前就对数据进行增广并生成图像,这种方法的优点是增广的数据可视化,使得开发者能够控制好增广数据的效果,由于离线增广的数据往往都是有限的因此可以很好的评价数据增广对模型性能的提升,但是缺点是需要将增广数据生成出来因此占用更多的存储空间并且灵活性差。

    下面介绍pytorch和Keras进行数据增广的demo。

    import torchvision
    # 定义数据增广的操作
    transforms = torchvision.transforms.Compose([
         torchvision.transforms.Resize((224, 224)),  #将图像resize
         torchvision.transforms.ColorJitter(hue=.05, saturation=.05),#色彩扰动
         torchvision.transforms.RandomHorizontalFlip(), #随机水平翻转
         torchvision.transforms.RandomRotation(20, resample=PIL.Image.BILINEAR) #随机旋转
    ])
    #加载训练数据并使用增广
    dataset = torchvision.datasets.ImageFolder('datapath', transform=transforms)
    #此方法是在线增广,之后可将dataset传入Dataloader,同一张图像在训练过程中的每个epoch都是不同的。
    from tensorflow.keras.preprocessing.image import ImageDataGenerator
    #定义数据增广操作
    train_datagen = ImageDataGenerator(
            rescale=1./255,#将像素值归一化到[0,1]之间
            shear_range=0.2,  # 错切变换
            zoom_range=0.2, #在宽或高的方向放大图像
            rotation_range=15)#旋转
    #加载训练数据集并应用增广
    train_generator = train_datagen.flow_from_directory(
            'datapath', #数据集路径
            target_size=(100, 100), #将图像resize到100X100
            batch_size=5, 
            class_mode='binary',
            save_to_dir='augdatapath',#保存增广数据的路径
            save_prefix='aug',#增广数据明明前缀
            save_format='png')#增广数据保存格式
    #生成增广数据,每调用next()函数一次就生成batch里面图像的增广图像,此处batch_size为5,4个循环生成#20张增广图像。
    for i in range(4):
        train_generator.next()

    pytorch支持在线增广,生成离线增广数数据只需调用相应的transforms方法应用在图像上即可,而Keras不仅支持在线增广,而且也支持生成离线增广数据,在flow_from_directory()方法中有相应的保存增广数据的参数。数据增广的方法有很多,本文只是帮助理解在线增广和离线增广的区别。

    展开全文
  • 数据增广(数据增强)方式

    千次阅读 2020-06-18 22:11:56
    青出于蓝而胜于蓝,超越MixUp、CutMix的样本混合数据增广新算法FMix
     
    

    细节增强

    见本人另一篇博文:小波(小波包)变换 频率/频域 与 图像细节处理

    远距离图像的特色增广

    产生柏林噪声时,有两个概念:
    频率(frequencies):晶体格的边长(即采样间隔,例如频率越高,单位面积(特指二维)内的晶格数目越多,看起来噪声纹理“越密集”。)
    振幅(amplitudes):返回值的幅度范围
    而在地形生成中,地形可能会有大段连绵、高耸山地,也会有丘陵和蚀坑,更小点的有岩石块,甚至更小的鹅卵石块。为了模拟出这样的自然噪声特性,我们可以使用不同的参数进行多几次柏林噪声计算,然后将结果叠加在一起。
    在这里插入图片描述

    python的noise库中,有现成的2D柏林噪声noise2,具有几个参数Octaves,persistence,lacunarity。
    Octaves:用于叠加的倍频(噪声图形)的组数
    persistence:第i+1组倍频的幅度等于第i组倍频的幅度的persistence倍
    lacunarity:第i+1组倍频的频率等于第i组倍频的频率的lacunarity倍
    持续度越大,振幅越大,对于图像而言图像更加混乱,对比更加突出,能看出更多细节。
    在这里插入图片描述
    叠加每次的不同的频率是为了让图像在原有的噪声函数的基础上增加更多的细节信息。
    在这里插入图片描述

    相机的测光根据暗的前景和亮的背景计算平均曝光设置。得到的图像展示了在这类照明情况下拍摄的效果。无论是前景还是背景的曝光都不正确。 让较暗的前景变亮会去掉背景中剩余的细节,而还原背景中的细节则会让主要对象只留下一个轮廓。

    python opencv-批量调整图片的曝光率(gamma变换)
    OpenCV使用直方图均衡,修正曝光过度和曝光不足的图片
    Skimage图像处理教程3)曝光度调整

    展开全文
  • DL图像数据增广

    千次阅读 2018-07-09 10:36:55
    数据增广计算机视觉有七类分类问题: 不同的视角,不同的大小,物体的形变问题,物体的遮挡问题,光照条件,背景复杂的问题,每一类中有多种形态的问题。 而数据增广的思路也就是解决这个问题。数据增广如何增广...
  • 一、数据增广

    2020-08-04 20:31:01
    一、数据增广 在图像分类任务中,图像数据的增广是一种常用的正则化方法,常用于数据量不足或者模型参数较多的场景。在本章节中,我们将对除 ImageNet 分类任务标准数据增广外的8种数据增广方式进行简单的介绍和...
  • GitHub:数据增广最全资料集锦.pdf
  • 数据增广下的人脸识别研究.pdf
  • caffe数据层数据增广

    千次阅读 2018-06-04 09:52:21
    caffe数据层相关学习以及训练在线数据增广caffe数据层是将已经生成好的LMDB文件中的label和数据读入到Datum数据结构体中,然后将数据转化到Blob中,进而进行数据传递,才能进行数据训练。目前使用的data_layer是经过...
  • 本资源是基于BP神经网络的利用MATLAB实现的手写识别,资源内部固有的数据集是借用Goolge实验室和本人自己制作的,使用者可以自己利用里面的数据增广制作扩充数据集。本资仅供源供学习参考。
  • pytorch数据增广

    千次阅读 2019-09-06 23:54:13
    常用的数据增广方法 1. 对图片进行按比例缩放 2. 对图片进行随机位置的截取 3. 对图片进行随机的水平和竖直翻转 4. 对图片进行随机角度的旋转 5. 对图片进行亮度、对比度和颜色的随机变化 下面使用torchvision演示...
  • 数据增广论文收集

    2021-10-09 15:49:24
    数据增广 KeepAugment: A Simple Information-Preserving Data Augmentation Approach 中文讲解:论文阅读
  • 目标检测数据增广,简单的旋转、分割等。简单有效
  • 条件BERT数据增广

    2019-04-28 11:56:02
    数据增广是在任务数据量稀缺时非常有用的方法。文章《Conditional BERT Contextual Augmentation》通过改变BERT的输入,在原始BERT模型上fine-tune,将预训练语言模型引入数据增广任务中,并取得了很好的效果。 ...
  • 1.数据增广的介绍 做数据的增强有三种方式。第一种即是用更多的sensor传感器取capture捕捉更多的数据,这种方法在一些大公司使用较多,缺点是花费较大,且需要人工去标记数据;另一种方法是使用GAN(生成式对抗网络...
  • 图像预处理之数据增广

    千次阅读 2019-02-27 10:12:38
    图像的数据增广 文章目录图像的数据增广数据增广的几种方式相关工具包相关代码Url 数据增广的几种方式 翻转变换 flip 随机修剪 random crop 色彩抖动 color jittering 平移变换 shift 尺度变换 scale 对比度变换 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,790
精华内容 4,716
关键字:

数据增广