精华内容
下载资源
问答
  • 数据增强技术,采用开源框架keras代码库进行数据扩增,通过平移、旋转、裁剪、等方法对原始图像进行操作,得到更多的类似的目标图像。
  • 输入原始图片所在文件夹,原始图片标签,输出增强后的图片文件夹名及输出标签名,运行即可。
  • 对训练数据集进行数据增强代码

    千次阅读 多人点赞 2019-07-07 21:53:01
    对训练数据集进行数据增强代码 原代码如下所示: ### 本代码共采用了四种数据增强,如采用其他数据增强方式,可以参考本代码,随意替换。 imageDir 为原数据集的存放位置 saveDir 为数据增强后数据的存放位置 ### ...

    对训练数据集进行数据增强代码(离线)

    原代码如下所示:

    
    ###
    本代码共采用了四种数据增强,如采用其他数据增强方式,可以参考本代码,随意替换。
    imageDir 为原数据集的存放位置
    saveDir  为数据增强后数据的存放位置
    ###
    
    def flip(root_path,img_name):   #翻转图像
        img = Image.open(os.path.join(root_path, img_name))
        filp_img = img.transpose(Image.FLIP_LEFT_RIGHT)
        # filp_img.save(os.path.join(root_path,img_name.split('.')[0] + '_flip.jpg'))
        return filp_img
    
    def rotation(root_path, img_name):
        img = Image.open(os.path.join(root_path, img_name))
        rotation_img = img.rotate(20) #旋转角度
        # rotation_img.save(os.path.join(root_path,img_name.split('.')[0] + '_rotation.jpg'))
        return rotation_img
    
    def randomColor(root_path, img_name): #随机颜色
        """
        对图像进行颜色抖动
        :param image: PIL的图像image
        :return: 有颜色色差的图像image
        """
        image = Image.open(os.path.join(root_path, img_name))
        random_factor = np.random.randint(0, 31) / 10.  # 随机因子
        color_image = ImageEnhance.Color(image).enhance(random_factor)  # 调整图像的饱和度
        random_factor = np.random.randint(10, 21) / 10.  # 随机因子
        brightness_image = ImageEnhance.Brightness(color_image).enhance(random_factor)  # 调整图像的亮度
        random_factor = np.random.randint(10, 21) / 10.  # 随机因子
        contrast_image = ImageEnhance.Contrast(brightness_image).enhance(random_factor)  # 调整图像对比度
        random_factor = np.random.randint(0, 31) / 10.  # 随机因子
        return ImageEnhance.Sharpness(contrast_image).enhance(random_factor)  # 调整图像锐度
    
    
    def contrastEnhancement(root_path, img_name):  # 对比度增强
        image = Image.open(os.path.join(root_path, img_name))
        enh_con = ImageEnhance.Contrast(image)
        contrast = 1.5
        image_contrasted = enh_con.enhance(contrast)
        return image_contrasted
    
    def brightnessEnhancement(root_path,img_name):#亮度增强
        image = Image.open(os.path.join(root_path, img_name))
        enh_bri = ImageEnhance.Brightness(image)
        brightness = 1.5
        image_brightened = enh_bri.enhance(brightness)
        return image_brightened
    
    def colorEnhancement(root_path,img_name):#颜色增强
        image = Image.open(os.path.join(root_path, img_name))
        enh_col = ImageEnhance.Color(image)
        color = 1.5
        image_colored = enh_col.enhance(color)
        return image_colored
    
    from PIL import Image
    from PIL import ImageEnhance
    import os
    import cv2
    import numpy as np
    imageDir="/home/admin324/PycharmProjects/data/UC/train"     #要改变的图片的路径文件夹
    saveDir="/home/admin324/PycharmProjects/data/UC/train_aug"   #要保存的图片的路径文件夹
    
    for name in os.listdir(imageDir):
    
        saveName= name[:-4]+"id.jpg"
        image = Image.open(os.path.join(imageDir, name))
        image.save(os.path.join(saveDir,saveName))
    
        saveName= name[:-4]+"be.jpg"
        saveImage=brightnessEnhancement(imageDir,name)
        saveImage.save(os.path.join(saveDir,saveName))
    
        saveName= name[:-4]+"fl.jpg"
        saveImage=flip(imageDir,name)
        saveImage.save(os.path.join(saveDir,saveName))
    
        saveName= name[:-4]+"ro.jpg"
        saveImage=rotation(imageDir,name)
        saveImage.save(os.path.join(saveDir,saveName))
    
    
    
    展开全文
  • yolov5数据增强代码解读

    千次阅读 2021-07-27 14:50:29
    yolov5中用到的数据增强方法: self.mosaic 启用马赛克增强 self.mosaic_border = [-img_size // 2, -img_size // 2] 马赛克扩充 albumentations.Blur(p=0.1), 用一个随机尺寸的核来模糊图片 albumentations.Median...

    yolov5中用到的数据增强方法:
    self.mosaic 启用马赛克增强
    self.mosaic_border = [-img_size // 2, -img_size // 2] 马赛克扩充
    albumentations.Blur(p=0.1), 用一个随机尺寸的核来模糊图片
    albumentations.MedianBlur(p=0.1), 使用中值滤波
    albumentations.ToGray(p=0.01)], 转化成灰度图
    HSV color-space HSV空间的数据增强,包括(H色彩,S饱和度,B亮度)
    img = np.flipud(img) 上下翻转
    img = np.fliplr(img) 水平翻转
    mixup(img, labels, *load_mosaic(self, random.randint(0, self.n - 1))) Mixup图像混叠增广

    在utils/datasets.py里

    class LoadImagesAndLabels(Dataset):  # for training/testing
        def __init__(self, path, img_size=640, batch_size=16, augment=False, hyp=None, rect=False, image_weights=False,
                     cache_images=False, single_cls=False, stride=32, pad=0.0, prefix=''):
            self.img_size = img_size
            self.augment = augment    ##是否采用数据增强
            self.hyp = hyp
            self.image_weights = image_weights
            self.rect = False if image_weights else rect
            self.mosaic = self.augment and not self.rect  # 是否启用马赛克增强
            self.mosaic_border = [-img_size // 2, -img_size // 2]    ##是否启用马赛克扩充
            self.stride = stride
            self.path = path
            self.albumentations = Albumentations() if augment else None     ##如果数据增强,用pytorch自带的Albumentations()进行数据增强
    	...
    	...
    	    def __getitem__(self, index):
            index = self.indices[index]  # linear, shuffled, or image_weights
    
            hyp = self.hyp
            mosaic = self.mosaic and random.random() < hyp['mosaic']
            if mosaic:
                # Load mosaic
                img, labels = load_mosaic(self, index)
                shapes = None
    
                # MixUp augmentation
                if random.random() < hyp['mixup']:
                    img, labels = mixup(img, labels, *load_mosaic(self, random.randint(0, self.n - 1)))
    
            else:
                # Load image
                img, (h0, w0), (h, w) = load_image(self, index)
    
                # Letterbox
                shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size  # final letterboxed shape
                img, ratio, pad = letterbox(img, shape, auto=False, scaleup=self.augment)
                shapes = (h0, w0), ((h / h0, w / w0), pad)  # for COCO mAP rescaling
    
                labels = self.labels[index].copy()
                if labels.size:  # normalized xywh to pixel xyxy format
                    labels[:, 1:] = xywhn2xyxy(labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1])
    
                if self.augment:
                    img, labels = random_perspective(img, labels,
                                                     degrees=hyp['degrees'],
                                                     translate=hyp['translate'],
                                                     scale=hyp['scale'],
                                                     shear=hyp['shear'],
                                                     perspective=hyp['perspective'])
    
            nl = len(labels)  # number of labels
            if nl:
                labels[:, 1:5] = xyxy2xywhn(labels[:, 1:5], w=img.shape[1], h=img.shape[0], clip=True, eps=1E-3)
    
            if self.augment:
                # Albumentations
                img, labels = self.albumentations(img, labels)   ##此处调用utils中的augmentation中的数据增强
    
                # HSV color-space
                augment_hsv(img, hgain=hyp['hsv_h'], sgain=hyp['hsv_s'], vgain=hyp['hsv_v'])
    
                # Flip up-down
                if random.random() < hyp['flipud']:
                    img = np.flipud(img)
                    if nl:
                        labels[:, 2] = 1 - labels[:, 2]
    
                # Flip left-right
                if random.random() < hyp['fliplr']:
                    img = np.fliplr(img)
                    if nl:
                        labels[:, 1] = 1 - labels[:, 1]
    
                # Cutouts
                # labels = cutout(img, labels, p=0.5)
    
            labels_out = torch.zeros((nl, 6))
            if nl:
                labels_out[:, 1:] = torch.from_numpy(labels)
    
            # Convert
            img = img.transpose((2, 0, 1))[::-1]  # HWC to CHW, BGR to RGB
            img = np.ascontiguousarray(img)
    
            return torch.from_numpy(img), labels_out, self.img_files[index], shapes
    
    
    

    utils中的augmentation.py

    class Albumentations:
        # YOLOv5 Albumentations class (optional, only used if package is installed)
        def __init__(self):
            self.transform = None    
            try:
                import albumentations as A     ##需要安装albumentations
                check_version(A.__version__, '1.0.3')  # version requirement
    
                self.transform = A.Compose([
                    A.Blur(p=0.1),
                    A.MedianBlur(p=0.1),
                    A.ToGray(p=0.01)],
                    bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))       ##这里只用到了A.Blur,A.MedianBlur,A.ToGray三种数据增强
    
                logging.info(colorstr('albumentations: ') + ', '.join(f'{x}' for x in self.transform.transforms if x.p))
            except ImportError:  # package not installed, skip
                pass
            except Exception as e:
                logging.info(colorstr('albumentations: ') + f'{e}')
    
        def __call__(self, im, labels, p=1.0):
            if self.transform and random.random() < p:
                new = self.transform(image=im, bboxes=labels[:, 1:], class_labels=labels[:, 0])  # transformed
                im, labels = new['image'], np.array([[c, *b] for c, b in zip(new['class_labels'], new['bboxes'])])
            return im, labels
    
    train_transform = albumentations.Compose([
            albumentations.Resize(RESIZE_SIZE, RESIZE_SIZE),
            albumentations.OneOf([
                albumentations.RandomGamma(gamma_limit=(60, 120), p=0.9),
                albumentations.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.9),
                albumentations.CLAHE(clip_limit=4.0, tile_grid_size=(4, 4), p=0.9),
            ]),
            albumentations.OneOf([
                albumentations.Blur(blur_limit=4, p=1),
                albumentations.MotionBlur(blur_limit=4, p=1),
                albumentations.MedianBlur(blur_limit=4, p=1)
            ], p=0.5),
            albumentations.HorizontalFlip(p=0.5),
            albumentations.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=20,
                                            interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, p=1),
            albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0)
        ])
    
    
    def mixup(im, labels, im2, labels2):
        # Applies MixUp augmentation https://arxiv.org/pdf/1710.09412.pdf
        r = np.random.beta(32.0, 32.0)  # mixup ratio, alpha=beta=32.0
        im = (im * r + im2 * (1 - r)).astype(np.uint8)
        labels = np.concatenate((labels, labels2), 0)
        return im, labels
        Resize就是拉伸图片修改尺寸
        RandomGamma就是使用gamma变换
        RandomBrightnessContrast就是随机选择图片的对比度和亮度
        CLAHE是一种对比度受限情况下的自适应直方图均衡化算法
        blur就是用一个随机尺寸的核来模糊图片,这个尺寸小于等于blur_limit
        motion blur和上面一样,随机的核,然后使用运动模糊算法来图例图片,运动模糊简单的说就是因为摄像机运动造成的那种模糊的动感。
        medianBlur就是使用中值滤波。
        HorizontalFlip水平翻转
        ShiftScaleRotate这个就是平移缩放旋转三个一,给力!
        Normalize这个就是图像归一化了。
    

    想要修改yolov5中离线增强数据的方法参考:https://cloud.tencent.com/developer/article/1660972

    yolov5中的矩形训练
    在这里插入图片描述

    可以看到yolov5会对图片进行填充,填充为正方形从而传入网络进行训练,可以看到这里面有很多冗余的信息,会让网络产生很多无意义的候选框,矩形训练就是减少这些冗余信息,减少网络产生的无意义的框的数量,加快网络训练速度。yolov5网络的总步长为32,所以其实只要图片边长能够整除32就可以了,不一定完全需要正方形图片传入网络,矩形训练就是将图片填充为最小的32的倍数边长,从而减小冗余信息。
    在这里插入图片描述值得一提的是,除了矩形训练,还有矩形推理,也就是在做检测的时候也这样填充,从而加快推理速度,减少推理时间。

    参考:https://blog.csdn.net/Q1u1NG/article/details/107362572
    Mixup图像混叠增广参考:https://blog.csdn.net/zandaoguang/article/details/108525787

    展开全文
  • 文本数据增强方法(EDA和回译)代码,解压密码在https://blog.csdn.net/herosunly/article/details/113997077中。
  • 针对这一难题,本文提出了一种基于生成对抗网络的数据增强方法,并将其应用于解决由于数据匮乏,神经网络难以训练的问题.实验结果表明,合成的数据和真实的数据相比既具有语义上的相似性,同时又能呈现出文本上的...
  • 图像数据增强

    2018-07-17 10:31:18
    图像数据增强,包括旋转,颜色变暗,变量,镜像等等,基于python,可进行批量图像处理。保证可用,好用。对于做深度学习特别好用。
  • 目标检测中的数据增强是比较复杂,每一次改变图像同时也要考虑boxes的信息,比起目标分类更加局限性,比如翻转,左右翻转一般影响不大,但上下翻转造成的影响就截然不同。下面操作坐标点全是xyxy形式 resize操作 先...
  • 数据增强方法

    2019-03-03 19:38:38
    深度学习在数据量较小的情况下需要进行数据增强操作。本代码可以进行执行,增强数据
  • python实现图像数据增强,实现对数据的增强,包括调亮,调暗,裁剪,镜像等等等,操作简单,可批量处理
  • python图像数据增强

    2019-03-16 16:47:01
    代码用于实现图像数据增强,对图片进行批量处理。包括图片旋转、翻转、模糊、增加噪声、亮度几种处理。运行需要安装python、opencv、numpy等。 使用时将图片统一放在img文件夹中,并将img文件夹和下载的py文件放在...
  • 在参加一个目标检测的比赛时写的一个代码,因为官方提供的数据集较小,深度学习需要的数据集也比较大,因而自己便做了一个数据离线增强,即通过翻转、旋转、加噪声等方式扩充数据
  • labelme数据增强

    2018-09-08 12:12:34
    在终端中运行命令python a.py生成20张数据增强后的图片及其对应的json文件,包括翻转,加噪,模糊,加减曝光等图片 在终端中运行python labelme2COCO.py生成COCO格式数据集,可以进行mask-rcnn 和faster-rcnn 等的输入...
  • Matlab数据增强

    2018-10-23 09:50:04
    matlab的一个小脚本,用于训练数据不够时数据增强使用
  • 数据增强方法及代码

    千次阅读 多人点赞 2019-07-06 16:27:57
    文章目录参考链接摘要什么是数据增强空间几何变换类翻转(Flip)裁剪(crop)旋转(rotate)缩放变形(scale)平移变换(shift)颜色变换类噪声变换类其他图像标准化遮挡实例AlexNetYOLO 参考链接 【技术综述】一文...

    参考链接

    【技术综述】一文道尽深度学习中的数据增强方法(上) - 简书
    https://www.jianshu.com/p/99450dbdadcf

    【技术综述】一文道尽深度学习中的数据增强方法(下) - 简书
    https://www.jianshu.com/p/661221525139

    Image Data Processing - 江冬的博客 | JD Blog
    http://www.jiangdongzml.com/2018/03/16/Image_Data_Processing/

    图像数据增强 - 代码片段 - 码云 Gitee.com
    https://gitee.com/hamjarl/codes/yl7q9g4bhv61ej2i8pnu319

    tensorflow实现数据增强(随机裁剪、翻转、对比度设置、亮度设置) - 修炼之路 - CSDN博客
    https://blog.csdn.net/sinat_29957455/article/details/80629098

    Data Augmentation–数据增强解决你有限的数据集 - chang_rj的博客 - CSDN博客
    https://blog.csdn.net/u010801994/article/details/81914716

    摘要

    本文主要针对tensorflow和PIL的数据增强方法做一个总结,所有代码来源于互联网。

    部分方式的代码,真的是各种没有。

    如果有大量数据增强方法需求的小伙伴,可以用这个【技术综述】一文道尽深度学习中的数据增强方法(上) - 简书博客提到的插件aleju/imgaug: Image augmentation for machine learning experiments来使用更多数据增强方法,这个插件功能非常强大,在此就不赘述了。

    什么是数据增强

    Data Augmentation,基于有限的数据生成更多等价(同样有效)的数据,丰富训练数据的分布,使通过训练集得到的模型泛化能力更强。

    举个例子:

    img

    上面的左侧大图为原图,右侧小图是对左图做了一些随机的裁剪、缩放、旋转操作得来的。

    右边的每张图对于网络来说都是不同的输入,这样就将数据扩充到10倍。

    假如我们输入网络的图片的分辨率大小是256×256,若采用随机裁剪成224×224的方式,那么一张图最多可以产生32×32张图,数据量扩充将近1000倍。

    但因许多图相似度太高,实际的效果并不等价。

    如果再辅助其他的数据增强方法,将获得更多的数据集,这就是数据增强的本质。

    空间几何变换类

    import matplotlib.pyplot as plt
    # tensorflow
    import tensorflow as tf
    
    image_raw_data=tf.gfile.FastGFile(img_path,'rb').read()
    img_data=tf.image.decode_jpeg(image_raw_data)
    # PIL
    from PIL import Image,ImageChops,ImageEnhance
    
    img_data = Image.open(img_path)
    

    翻转(Flip)

    翻转包括水平翻转、垂直翻转和对角线翻转。

    with tf.Session() as sess:
        # tensorflow
        flipped1=tf.image.flip_left_right(img_data)
        flipped2=tf.image.flip_up_down(img_data)
        transpose_img=tf.image.transpose_image(img_data)
        # PIL
        flipped1=Image.FLIP_LEFT_RIGHT(img_data)
        flipped2=Image.FLIP_UP_DOWN(img_data)
        transpose_img=Image.TRANSPOSE(img_data)    
        
        for i,img in enumerate([img_data,flipped1,flipped2,transpose_img]):
            plt.subplot(1,4,i+1)
            plt.tight_layout()
            plt.imshow(img.eval())
        plt.show()
    

    [外链图片转存失败(img-GG6HRltC-1562401382764)(数据增强.assets/1562328431016.png)]

    裁剪(crop)

    裁剪图片的感兴趣区域(ROI),通常在训练的时候,会采用随机裁剪的方法。

        # tensorflow
        img = tf.image.random_crop(img_data, [400, 600, 3])
        # tf.image.central_crop(image,0.5) 按比例裁剪
        
        with tf.Session() as sess:
            img = sess.run(img)
            plt.subplot(1,2,1)
            plt.imshow(img)
            plt.title("tensorflow")
        
        # PIL
        img = img_data.crop((200, 100, 800, 500))  # 参数为坐标左上右下
        plt.subplot(1, 2, 2)
        plt.imshow(img)
        plt.title("PIL")
        plt.show()
    

    [外链图片转存失败(img-qQmlk2ks-1562401382764)(数据增强.assets/1562333687678.png)]

    旋转(rotate)

    对图像做一定角度的旋转操作

        # tensorflow
        img = tf.image.rot90(img_data, 1)
    
        with tf.Session() as sess:
            img = sess.run(img)
            plt.subplot(1,2,1)
            plt.title("tensorflow")
            plt.imshow(img)
    
        # PIL
        img = img_data.rotate(90)  # 逆时针旋转
        plt.subplot(1, 2, 2)
        plt.title("PIL")
        plt.imshow(img)
        plt.show()
    

    [外链图片转存失败(img-jU0xgyst-1562401382764)(数据增强.assets/1562334574494.png)]

    缩放变形(scale)

    随机选取图像的一部分,然后将其缩放到原图像尺度。

        # PIL
        plt.subplot(1,2,1)
        plt.title("original")
        plt.imshow(img_data)
    
        img = img_data.crop((200, 100, 800, 500))
        img = img.resize((1000,600),resample=Image.LANCZOS)
        plt.subplot(1,2,2)
        plt.title("scale")
        plt.imshow(img)
        plt.show()
    

    [外链图片转存失败(img-ji2cA96A-1562401382765)(数据增强.assets/1562335238968.png)]

    平移变换(shift)

    图像整体平移一段距离

    	# PIL
        plt.subplot(1,2,1)
        plt.title("original")
        plt.imshow(img)
    
        img = ImageChops.offset(img_data,200,100)
        plt.subplot(1,2,2)
        plt.title("scale")
        plt.imshow(img)
        plt.show()
    

    在这里插入图片描述

    颜色变换类

        # tensorflow
        #随机设置图片的亮度
        random_brightness = tf.image.random_brightness(img_data,max_delta=30)
        #随机设置图片的对比度
        random_contrast = tf.image.random_contrast(img_data,lower=0.2,upper=1.8)
        #随机设置图片的色度
        random_hue = tf.image.random_hue(img_data,max_delta=0.3)
        #随机设置图片的饱和度
        random_satu = tf.image.random_saturation(img_data,lower=0.2,upper=1.8)
    

    [外链图片转存失败(img-En0K5zT7-1562401382765)(数据增强.assets/1562396202140.png)]

    	# PIL
        # 调整图像的饱和度
        random_factor1 = np.random.randint(5, 20) / 10.  # 随机因子
        color_image = ImageEnhance.Color(img_data).enhance(random_factor1)  
        # 调整图像的亮度
        random_factor2 = np.random.randint(5, 21) / 10.
        brightness_image = ImageEnhance.Brightness(img_data).enhance(random_factor2)  
        # 调整图像对比度
        random_factor3 = np.random.randint(5, 20) / 10.
        contrast_image = ImageEnhance.Contrast(img_data).enhance(random_factor3)
        # 调整图像的锐度
        random_factor4 = np.random.randint(5, 20) / 10.
        sharp_image = ImageEnhance.Sharpness(img_data).enhance(random_factor4)   
    

    [外链图片转存失败(img-mHOcLAkq-1562401382765)(数据增强.assets/1562396486182.png)]

    噪声变换类

    import skimage
    from PIL import Image
    import matplotlib.pyplot as plt
    import numpy as np
    
    if __name__ == "__main__":
    
        img_data = Image.open("timg.jpg", 'r')
        img = np.array(img_data)
    
        plt.subplot(1, 2, 1)
        plt.title("origin")
        plt.imshow(img_data)
    
        img_noise = skimage.util.random_noise(img, mode="gaussian")
    
        plt.subplot(1, 2, 2)
        plt.title("gaussian")
        plt.imshow(img_noise)
    
        plt.show()
    # skimage.util.random_noise函数的mode参数
    mode : str, optional
            One of the following strings, selecting the type of noise to add:
    
            - 'gaussian'  Gaussian-distributed additive noise.
            - 'localvar'  Gaussian-distributed additive noise, with specified
                          local variance at each point of `image`.
            - 'poisson'   Poisson-distributed noise generated from the data.
            - 'salt'      Replaces random pixels with 1.
            - 'pepper'    Replaces random pixels with 0 (for unsigned images) or
                          -1 (for signed images).
            - 's&p'       Replaces random pixels with either 1 or `low_val`, where
                          `low_val` is 0 for unsigned images or -1 for signed
                          images.
            - 'speckle'   Multiplicative noise using out = image + n*image, where
                          n is uniform noise with specified mean & variance.
    

    在这里插入图片描述

    import numpy as np
    from PIL import Image
    import matplotlib.pyplot as plt
    import math
    import random
    import cv2
    import scipy.misc
    import scipy.signal
    import scipy.ndimage
    
    def medium_filter(im, x, y, step):
        sum_s=[]
        for k in range(-int(step/2),int(step/2)+1):
            for m in range(-int(step/2),int(step/2)+1):
                sum_s.append(im[x+k][y+m])
        sum_s.sort()
        return sum_s[(int(step*step/2)+1)]
    
    def mean_filter(im, x, y, step):
        sum_s = 0
        for k in range(-int(step/2),int(step/2)+1):
            for m in range(-int(step/2),int(step/2)+1):
                sum_s += im[x+k][y+m] / (step*step)
        return sum_s
    
    def convert_2d(r):
        n = 3
        # 3*3 滤波器, 每个系数都是 1/9
        window = np.ones((n, n)) / n ** 2
        # 使用滤波器卷积图像
        # mode = same 表示输出尺寸等于输入尺寸
        # boundary 表示采用对称边界条件处理图像边缘
        s = scipy.signal.convolve2d(r, window, mode='same', boundary='symm')
        return s.astype(np.uint8)
    
    # def convert_3d(r):
    #     s_dsplit = []
    #     for d in range(r.shape[2]):
    #         rr = r[:, :, d]
    #         ss = convert_2d(rr)
    #         s_dsplit.append(ss)
    #     s = np.dstack(s_dsplit)
    #     return s
    
    
    def add_salt_noise(img):
        rows, cols, dims = img.shape 
        R = np.mat(img[:, :, 0])
        G = np.mat(img[:, :, 1])
        B = np.mat(img[:, :, 2])
    
        Grey_sp = R * 0.299 + G * 0.587 + B * 0.114
        Grey_gs = R * 0.299 + G * 0.587 + B * 0.114
    
        snr = 0.9
        mu = 0
        sigma = 0.12
        
        noise_num = int((1 - snr) * rows * cols)
    
        for i in range(noise_num):
            rand_x = random.randint(0, rows - 1)
            rand_y = random.randint(0, cols - 1)
            if random.randint(0, 1) == 0:
                Grey_sp[rand_x, rand_y] = 0
            else:
                Grey_sp[rand_x, rand_y] = 255
        
        Grey_gs = Grey_gs + np.random.normal(0, 48, Grey_gs.shape)
        Grey_gs = Grey_gs - np.full(Grey_gs.shape, np.min(Grey_gs))
        Grey_gs = Grey_gs * 255 / np.max(Grey_gs)
        Grey_gs = Grey_gs.astype(np.uint8)
    
        # 中值滤波
        Grey_sp_mf = scipy.ndimage.median_filter(Grey_sp, (8, 8))
        Grey_gs_mf = scipy.ndimage.median_filter(Grey_gs, (8, 8))
    
        # 均值滤波
        n = 3
        window = np.ones((n, n)) / n ** 2
        Grey_sp_me = convert_2d(Grey_sp)
        Grey_gs_me = convert_2d(Grey_gs)
    
        plt.subplot(321)
        plt.title('Grey salt and pepper noise')
        plt.imshow(Grey_sp, cmap='gray')
        plt.subplot(322)
        plt.title('Grey gauss noise')
        plt.imshow(Grey_gs, cmap='gray')
    
        plt.subplot(323)
        plt.title('Grey salt and pepper noise (medium)')
        plt.imshow(Grey_sp_mf, cmap='gray')
        plt.subplot(324)
        plt.title('Grey gauss noise (medium)')
        plt.imshow(Grey_gs_mf, cmap='gray')
    
        plt.subplot(325)
        plt.title('Grey salt and pepper noise (mean)')
        plt.imshow(Grey_sp_me, cmap='gray')
        plt.subplot(326)
        plt.title('Grey gauss noise (mean)')
        plt.imshow(Grey_gs_me, cmap='gray')
        plt.show()
    
        
    
    
    def main():
        img = np.array(Image.open('LenaRGB.bmp'))
        add_salt_noise(img)
    
    
    
    if __name__ == '__main__':
        main()
    

    img

    其他

    图像标准化

        # tensorflow
        # 将图像均值变为0,方差变为1
        tf.image.per_image_standardization(img_data)
    

    [外链图片转存失败(img-H4cJBytB-1562401382766)(数据增强.assets/1562397416908.png)]

    遮挡

        # PIL
        img_data.paste(paste_data,(200,300,200+paste_data.size[0],300+paste_data.size[1]))
    

    [外链图片转存失败(img-vQaFWXbk-1562401382766)(数据增强.assets/1562400269664.png)]

    实例

    AlexNet

    数据增强的第一种形式由生成图像转化和水平反射组成。

    数据增强的第二种形式包含改变训练图像中RGB通道的强度。

    YOLO

    随机裁剪、旋转

    变换颜色、变换饱和度(saturation)、变换曝光度(exposure shifts)

    展开全文
  • 睿智的目标检测-番外篇——数据增强在目标检测中的应用学习前言数据增强做了什么 学习前言 数据增强是非常重要的提高目标检测算法鲁棒性的手段,学习一下对身体有好处! 数据增强做了什么 ...

    睿智的目标检测-番外篇——数据增强在目标检测中的应用(数据增强代码的参数解读)

    学习前言

    数据增强是非常重要的提高目标检测算法鲁棒性的手段,学习一下对身体有好处!
    在这里插入图片描述

    数据增强做了什么

    数据增强其实就是让图片变得更加多样。比如说原图是一个电脑
    在这里插入图片描述
    如果不使用数据增强的话这个电脑就只是一个电脑,每次训练的电脑都是这样的样子的,但是我们实际生活中电脑是多样的。

    因此我们可以通过改变亮度,图像扭曲等方式使得图像变得更加多种多样,如下图所示,尽管亮度,形态发生了细微改变,但本质上,这些东西都依然是电脑。
    在这里插入图片描述
    改变后的图片放入神经网络进行训练可以提高网络的鲁棒性,降低各方面额外因素对识别的影响。

    目标检测中的图像增强

    在目标检测中如果要增强数据,并不是直接增强图片就好了,还要考虑到图片扭曲后框的位置。

    也就是框的位置要跟着图片的位置进行改变。

    如果大家对我的目标检测代码有少许研究的话,应该都可以看到。我特别喜欢用这个数据增强代码:

    def get_random_data(annotation_line, input_shape, random=True, max_boxes=20, jitter=.5, hue=.1, sat=1.5, val=1.5, proc_img=True):
        '''random preprocessing for real-time data augmentation'''
        line = annotation_line.split()
        image = Image.open(line[0])
        iw, ih = image.size
        h, w = input_shape
        box = np.array([np.array(list(map(int,box.split(',')))) for box in line[1:]])
    
        # 对图像进行缩放并且进行长和宽的扭曲
        new_ar = w/h * rand(1-jitter,1+jitter)/rand(1-jitter,1+jitter)
        scale = rand(.25, 2)
        if new_ar < 1:
            nh = int(scale*h)
            nw = int(nh*new_ar)
        else:
            nw = int(scale*w)
            nh = int(nw/new_ar)
        image = image.resize((nw,nh), Image.BICUBIC)
    
        # 将图像多余的部分加上灰条
        dx = int(rand(0, w-nw))
        dy = int(rand(0, h-nh))
        new_image = Image.new('RGB', (w,h), (128,128,128))
        new_image.paste(image, (dx, dy))
        image = new_image
    
        # 翻转图像
        flip = rand()<.5
        if flip: image = image.transpose(Image.FLIP_LEFT_RIGHT)
    
        # 色域扭曲
        hue = rand(-hue, hue)
        sat = rand(1, sat) if rand()<.5 else 1/rand(1, sat)
        val = rand(1, val) if rand()<.5 else 1/rand(1, val)
        x = rgb_to_hsv(np.array(image)/255.)
        x[..., 0] += hue
        x[..., 0][x[..., 0]>1] -= 1
        x[..., 0][x[..., 0]<0] += 1
        x[..., 1] *= sat
        x[..., 2] *= val
        x[x>1] = 1
        x[x<0] = 0
        image_data = hsv_to_rgb(x) # numpy array, 0 to 1
    
        # 将box进行调整
        box_data = np.zeros((max_boxes,5))
        if len(box)>0:
            np.random.shuffle(box)
            box[:, [0,2]] = box[:, [0,2]]*nw/iw + dx
            box[:, [1,3]] = box[:, [1,3]]*nh/ih + dy
            if flip: box[:, [0,2]] = w - box[:, [2,0]]
            box[:, 0:2][box[:, 0:2]<0] = 0
            box[:, 2][box[:, 2]>w] = w
            box[:, 3][box[:, 3]>h] = h
            box_w = box[:, 2] - box[:, 0]
            box_h = box[:, 3] - box[:, 1]
            box = box[np.logical_and(box_w>1, box_h>1)] # discard invalid box
            if len(box)>max_boxes: box = box[:max_boxes]
            box_data[:len(box)] = box
        
        return image_data, box_data
    

    里面有一些比较重要的参数如:
    scale = rand(.25, 2)
    jitter=.5;
    hue=.1;
    sat=1.5;
    val=1.5;

    其中:
    1、scale代表原图片的缩放比率,rand(.25, 2)表示在0.25到2之间缩放。
    2、jitter代表原图片的宽高的扭曲比率,jitter=.5表示在0.5到1.5之间扭曲。
    3、hue=.1,sat=1.5,val=1.5;分别代表hsv色域中三个通道的扭曲,分别是:色调(H),饱和度(S),明度(V)。

    实际效果如下:
    原图:
    在这里插入图片描述
    增强后:
    在这里插入图片描述

    全部代码

    全部代码构成如下:

    from PIL import Image, ImageDraw
    import numpy as np
    from matplotlib.colors import rgb_to_hsv, hsv_to_rgb
    
    def rand(a=0, b=1):
        return np.random.rand()*(b-a) + a
    
    def get_random_data(annotation_line, input_shape, random=True, max_boxes=20, jitter=.5, hue=.1, sat=1.5, val=1.5, proc_img=True):
        '''random preprocessing for real-time data augmentation'''
        line = annotation_line.split()
        image = Image.open(line[0])
        iw, ih = image.size
        h, w = input_shape
        box = np.array([np.array(list(map(int,box.split(',')))) for box in line[1:]])
    
        # 对图像进行缩放并且进行长和宽的扭曲
        new_ar = w/h * rand(1-jitter,1+jitter)/rand(1-jitter,1+jitter)
        scale = rand(.25,2)
        if new_ar < 1:
            nh = int(scale*h)
            nw = int(nh*new_ar)
        else:
            nw = int(scale*w)
            nh = int(nw/new_ar)
        image = image.resize((nw,nh), Image.BICUBIC)
    
        # 将图像多余的部分加上灰条
        dx = int(rand(0, w-nw))
        dy = int(rand(0, h-nh))
        new_image = Image.new('RGB', (w,h), (128,128,128))
        new_image.paste(image, (dx, dy))
        image = new_image
    
        # 翻转图像
        flip = rand()<.5
        if flip: image = image.transpose(Image.FLIP_LEFT_RIGHT)
    
        # 色域扭曲
        hue = rand(-hue, hue)
        sat = rand(1, sat) if rand()<.5 else 1/rand(1, sat)
        val = rand(1, val) if rand()<.5 else 1/rand(1, val)
        x = rgb_to_hsv(np.array(image)/255.)
        x[..., 0] += hue
        x[..., 0][x[..., 0]>1] -= 1
        x[..., 0][x[..., 0]<0] += 1
        x[..., 1] *= sat
        x[..., 2] *= val
        x[x>1] = 1
        x[x<0] = 0
        image_data = hsv_to_rgb(x) # numpy array, 0 to 1
    
        # 将box进行调整
        box_data = np.zeros((max_boxes,5))
        if len(box)>0:
            np.random.shuffle(box)
            box[:, [0,2]] = box[:, [0,2]]*nw/iw + dx
            box[:, [1,3]] = box[:, [1,3]]*nh/ih + dy
            if flip: box[:, [0,2]] = w - box[:, [2,0]]
            box[:, 0:2][box[:, 0:2]<0] = 0
            box[:, 2][box[:, 2]>w] = w
            box[:, 3][box[:, 3]>h] = h
            box_w = box[:, 2] - box[:, 0]
            box_h = box[:, 3] - box[:, 1]
            box = box[np.logical_and(box_w>1, box_h>1)] # discard invalid box
            if len(box)>max_boxes: box = box[:max_boxes]
            box_data[:len(box)] = box
        
        return image_data, box_data
    def normal_(annotation_line, input_shape):
        '''random preprocessing for real-time data augmentation'''
        line = annotation_line.split()
        image = Image.open(line[0])
        box = np.array([np.array(list(map(int,box.split(',')))) for box in line[1:]])
    
        return image, box
    
    
    if __name__ == "__main__":
        with open("2007_train.txt") as f:
            lines = f.readlines()
        a = np.random.randint(0,len(lines))
        line = lines[a]
    
        image_data, box_data = normal_(line,[416,416])
        img = image_data
    
        for j in range(len(box_data)):
            thickness = 3
            left, top, right, bottom  = box_data[j][0:4]
            draw = ImageDraw.Draw(img)
            for i in range(thickness):
                draw.rectangle([left + i, top + i, right - i, bottom - i],outline=(255,255,255))
        img.show()
        
        image_data, box_data = get_random_data(line,[416,416])
        print(box_data)
        img = Image.fromarray((image_data*255).astype(np.uint8))
        for j in range(len(box_data)):
            thickness = 3
            left, top, right, bottom  = box_data[j][0:4]
            draw = ImageDraw.Draw(img)
            for i in range(thickness):
                draw.rectangle([left + i, top + i, right - i, bottom - i],outline=(255,255,255))
        img.show()
    
        # img = Image.open(r"F:\Collection\yolo_Collection\keras-yolo3-master\Mobile-yolo3-master/VOCdevkit/VOC2007/JPEGImages/00000.jpg")
    
        # left, top, right, bottom = 527,377,555,404
    
        # draw = ImageDraw.Draw(img)
    
        # draw.rectangle([left, top, right, bottom])
        # img.show()
    
    展开全文
  • 数据增强程序

    2018-11-21 15:38:41
    对一组数据按步长为1,一次截取固定长度的数据,对于大量数据集可以进行批量处理并保存
  • 图像数据增强方式及其实现代码

    千次阅读 2019-08-23 13:07:29
    本文利用opencv和numpy实现了以上数据增强方法,代码如下 水平翻转 def horizon_flip(img): ''' 图像水平翻转 :param img: :return:水平翻转后的图像 ''' return img[:, ::-1] 垂直翻转...
  • 数据增强的方法总结及代码实现

    万次阅读 多人点赞 2018-10-02 22:31:05
    一、数据增强方法总结  1、平移。在图像平面上对图像以一定方式进行平移。 2、翻转图像。沿着水平或者垂直方向翻转图像。 3、旋转角度。随机旋转图像一定角度; 改变图像内容的朝向。 4、随机颜色。对图像进行...
  • 图像数据增强python代码

    千次阅读 2019-03-28 13:26:44
    安装 安装请参考https://github.com/aleju/imgaug 在安装时,如果Shapely这个库安装不上,请到https://pypi.org/project/Shapely/#history下载... pip install xxx_shaplely.whl ...from imgaug import augmenter...
  • python代码实现目标检测数据增强 目标检测数据增强 疫情期间在家也要科研,碰上了数据增强,找了很多代码,但是还是没跑通,最后选择了这种处理方式来完成数据增强处理。同时特别感谢csdn上给我提供帮助的大佬们,...
  • 语义分割数据增强python代码

    千次阅读 2019-02-19 14:41:42
    gamma transform def gamma_transform(img, gamma): gamma_table = [np.power(x / 255.0, gamma) * 255.0 for x in range(256)] gamma_table = np.round(np.array(gamma_table)).astype((np.uint8)) ...
  • 数据增强 1. 翻转变换 flip 2. 随机修剪 random crop 3. 色彩抖动 color jittering 4. 平移变换 shift 5. 尺度变换 scale 6. 对比度变换 contrast 7. 噪声扰动 noise 8. 旋转变换/反射变换 Rotation/refle.....
  • 图片数据集批量数据增强

    千次阅读 热门讨论 2020-09-29 15:57:03
    图片数据集批量数据增强(九种图像处理方法,增加到10倍)数据增强代码参考批量数据增强代码代码文件说明 数据增强代码 ck+数据集直接用于表情识别数量较少,去掉contempt大概在900张左右(个人处理,不同处理方法会...
  • YoloV4当中的Mosaic数据增强方法(附代码讲解)

    千次阅读 热门讨论 2020-08-08 12:20:00
    上一期中讲解了图像分类和目标检测中的数据增强的区别和联系,这期讲解数据增强的进阶版- yolov4中的Mosaic数据增强方法以及CutMix。前言Yolov4的mosaic数据增强参考...
  • 无监督数据增强(UDA)的TensorFlow代码
  • data augmentation 数据增强方法总结 高手之道-海康威视研究院ImageNet2016竞赛经验分享 常用数据增强方法总结及实现 论文:ImageNet Classification with Deep Convolutional Neural Networks 【常用方法】 1、...
  • 在图像分类任务中,图像数据增强一般是大多数人会采用的方法之一,这是由于深度学习对数据集的大小有一定的要求,若原始的数据集比较小,无法很好地满足网络模型的训练,从而影响模型的性能,而图像增强是对原始图像...
  • 一文详细综述数据增强方法(附代码)

    千次阅读 2019-12-29 19:22:28
    导读在深度学习时代,数据的规模越大、质量越高,模型就能够拥有更好的泛化能力,数据直接决定了模型学习的上限。然而在实际工程中,采集的数据很难覆盖全部的场景,比如图像的光照条件,同一场景拍摄...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 339,229
精华内容 135,691
关键字:

数据增强代码