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

    千次阅读 2021-02-02 20:10:37
    Mosaic数据增强 在Yolo-V4的paper中,以及在还未发表paper的Yolo-V5中,都有一个很重要的技巧,就是Mosaic数据增强,这种数据增强方式简单来说就是把4张图片,通过随机缩放、随机裁减、随机排布的方式进行拼接。根据...

    原文链接:https://www.yuque.com/huoxiangshouxiangwanghuo/xg3nah/momd0o

    Mosaic数据增强

    在Yolo-V4的paper中,以及在还未发表paper的Yolo-V5中,都有一个很重要的技巧,就是Mosaic数据增强,这种数据增强方式简单来说就是把4张图片,通过随机缩放、随机裁减、随机排布的方式进行拼接。根据论文的说法,优点是丰富了检测物体的背景和小目标,并且在计算Batch Normalization的时候一次会计算四张图片的数据,使得mini-batch大小不需要很大,一个GPU就可以达到比较好的效果。

    在这里插入图片描述

    • 优点
      • 丰富数据集:随机使用4张图片,随机缩放,再随机分布进行拼接,大大丰富了检测数据集,特别是随机缩放增加了很多小目标,让网络的鲁棒性更好
      • 减少GPU:直接计算4张图片的数据,使得Mini-batch大小并不需要很大,一个GPU就可以达到比较好的效果
    • 缺点
      • 如果我们的数据集本身就有很多的小目标,那么Mosaic数据增强会导致本来较小的目标变得更小,导致模型的泛化能力变差
    展开全文
  • mosaic数据增强

    2020-12-20 21:13:00
    mosaic数据增强 Mosaic数据增强 Mosaic数据增强方法是YOLOV4论文中提出来的,主要思想是将四张图片进行随机裁剪,再拼接到一张图上作为训练数据。这样做的好处是丰富了图片的背景,并且四张图片拼接在一起变相地提高...

    mosaic数据增强

    Mosaic数据增强

    Mosaic数据增强方法是YOLOV4论文中提出来的,主要思想是将四张图片进行随机裁剪,再拼接到一张图上作为训练数据。这样做的好处是丰富了图片的背景,并且四张图片拼接在一起变相地提高了batch_size,在进行batch normalization的时候也会计算四张图片,所以对本身batch_size不是很依赖,单块GPU就可以训练YOLOV4。
    以下是我根据pytorch YOLOV4的代码对Mosaic数据增强进行的整理。

    在这里插入图片描述

    图1

    部分代码展示:

    oh, ow, oc = img.shape    # img为读取的图片数据      
    # self.cfg.jitter为cfg文件中的参数,默认给的是0.2                                              
    dh, dw, dc = np.array(np.array([oh, ow, oc]) * self.cfg.jitter, dtype=np.int)  
    # 首先生成一些随机偏移的坐标,分别代表左右上下                                    
    pleft = random.randint(-dw, dw)   
    pright = random.randint(-dw, dw)  
    ptop = random.randint(-dh, dh)    
    pbot = random.randint(-dh, dh) 
    # 裁剪部分的长和宽
    swidth = ow - pleft - pright
    sheight = oh - ptop - pbot     
    1234567891011
    

    整个Mosaic过程如图一所示,图一展示的是pleft,pright,ptop,pbot都大于0时的情况,首先在原图上找到以(pleft,pright)为左上角,swidth,sheight为宽和长的矩形,然后取这个矩形和原图的交集(也就是深绿色的部分)。

    注意:图1中(2)这里不是直接取的交集出来,而是先创建一个宽为swidth,长为sheight的矩形,再将矩形赋值为原图RGB三个通道的均值,然后再将上面说的交集部分根据计算的坐标放在这个矩形上面,只不过图一是基于pleft,pright,ptop,pbot都大于0时的情况,所以正好放在(0, 0)坐标上。具体可以参考一以下代码。

    # new_src_rect也就是上面说的交集的坐标(x1, y1, x2, y2)
     new_src_rect = rect_intersection(src_rect, img_rect)                                                                                                                        
     dst_rect = [max(0, -pleft), max(0, -ptop), max(0, -pleft) + new_src_rect[2] - new_src_rect[0], 
                 max(0, -ptop) + new_src_rect[3] - new_src_rect[1]]  
                                                
    cropped = np.zeros([sheight, swidth, 3])                                   
    cropped[:, :, ] = np.mean(img, axis=(0, 1))                                
    # 这里就是将交集部分放在矩形上                                                      
    cropped[dst_rect[1]:dst_rect[3], dst_rect[0]:dst_rect[2]] = \              
        img[new_src_rect[1]:new_src_rect[3], new_src_rect[0]:new_src_rect[2]]  
    12345678910
    

    然后对图片进行resize,resize为网络输入所需要的分辨率,默认情况下就是608x608大小。然后根据计算的左上坐标,以及随机得到的宽CutX,长Cuty,裁剪一部分区域作为一张新图的左上部分。图1中(4)红框表示裁剪的区域,注意:图1中(4)左上角的(0, 0)坐标是因为pleft,pright大于0,根据计算所得。计算裁剪坐标的过程可参照以下代码。

    # 根据网络的输入大小随机计算的cut_x、cut_y,min_offset为预设参数,默认为0.2
    # cfg.w,cfg.h为网络的输入大小,默认为608
     cut_x = random.randint(int(self.cfg.w * min_offset), int(self.cfg.w * (1 - min_offset)))
     cut_y = random.randint(int(self.cfg.h * min_offset), int(self.cfg.h * (1 - min_offset)))
    # 裁剪坐标的计算过程                                                                                 
    left_shift = int(min(cut_x, max(0, (-int(pleft) * self.cfg.w / swidth))))                         
    top_shift = int(min(cut_y, max(0, (-int(ptop) * self.cfg.h / sheight))))                          
                                                                                                      
    right_shift = int(min((self.cfg.w - cut_x), max(0, (-int(pright) * self.cfg.w / swidth))))        
    bot_shift = int(min(self.cfg.h - cut_y, max(0, (-int(pbot) * self.cfg.h / sheight))))               
    # 这里的ai参数为图一中的(3), out_img初始化的新图
    # 该函数的功能就是图1中(3)到(5)的过程,分别将裁剪的图片粘贴到新图的左上,右上,左下,右下
    # 循环4次,每循环一次粘贴一次,每次根据给的参数i粘贴到哪个部分                                       
    out_img, out_bbox = blend_truth_mosaic(out_img, ai, truth.copy(), self.cfg.w, self.cfg.h, cut_x,  
                                           cut_y, i, left_shift, right_shift, top_shift, bot_shift)   
    123456789101112131415
    

    以下是blend_truth_mosaic函数细节:

    def blend_truth_mosaic(out_img, img, bboxes, w, h, cut_x, cut_y, i_mixup,                                        
                           left_shift, right_shift, top_shift, bot_shift):                                           
        left_shift = min(left_shift, w - cut_x)                                                                      
        top_shift = min(top_shift, h - cut_y)                                                                        
        right_shift = min(right_shift, cut_x)                                                                        
        bot_shift = min(bot_shift, cut_y)                                                                            
                                                                                                                     
        if i_mixup == 0:                                                                                             
            bboxes = filter_truth(bboxes, left_shift, top_shift, cut_x, cut_y, 0, 0)                                 
            out_img[:cut_y, :cut_x] = img[top_shift:top_shift + cut_y, left_shift:left_shift + cut_x]                
        if i_mixup == 1:                                                                                             
            bboxes = filter_truth(bboxes, cut_x - right_shift, top_shift, w - cut_x, cut_y, cut_x, 0)                
            out_img[:cut_y, cut_x:] = img[top_shift:top_shift + cut_y, cut_x - right_shift:w - right_shift]          
        if i_mixup == 2:                                                                                             
            bboxes = filter_truth(bboxes, left_shift, cut_y - bot_shift, cut_x, h - cut_y, 0, cut_y)                 
            out_img[cut_y:, :cut_x] = img[cut_y - bot_shift:h - bot_shift, left_shift:left_shift + cut_x]            
        if i_mixup == 3:                                                                                             
            bboxes = filter_truth(bboxes, cut_x - right_shift, cut_y - bot_shift, w - cut_x, h - cut_y, cut_x, cut_y)
            out_img[cut_y:, cut_x:] = img[cut_y - bot_shift:h - bot_shift, cut_x - right_shift:w - right_shift]      
                                                                                                                     
        return out_img, bboxes                                                                                       
    123456789101112131415161718192021
    

    最后说明一下对于标签框的处理,图1中可以看到,当进行裁剪的时候,如果裁剪了样本当中的标签框的部分区域,则将其舍弃,保留裁剪之后还完整的标签框。

    下图为pleft,pright,ptop,pbot都小于0的裁剪情况:
    在这里插入图片描述

    图2

    由于时间关系,我只画了比较容易画的两种情况图,也只做了粘贴左上角的部分,但其实也都是一个道理。
    本文只做了Mosaic的裁剪部分详解,当然个人觉得比较关键的也是这个部分,其实当中还有一些其他增强操作,例如随机翻转,模糊,HSV增强等等,这个暂时还没有做,后续会进行更新。

    操作完成之后然后再将原始图片按照 第一张图片摆放在左上,第二张图片摆放在左下,第三张图片摆放在右下,第四张图片摆放在右上四个方向位置摆好。

    最后,这是我根据pytorch YOLOV4的代码,自己的理解,如果有错,欢迎指正,谢谢。

    展开全文
  • 睿智的目标检测28——YoloV4当中的Mosaic数据增强方法学习前言什么是Mosaic数据增强方法实现思路全部代码 学习前言 哈哈哈!我又来数据增强了! 什么是Mosaic数据增强方法 Yolov4的mosaic数据增强参考了CutMix数据...

    睿智的目标检测28——YoloV4当中的Mosaic数据增强方法

    学习前言

    哈哈哈!我又来数据增强了!
    在这里插入图片描述

    什么是Mosaic数据增强方法

    Yolov4的mosaic数据增强参考了CutMix数据增强方式,理论上具有一定的相似性!
    CutMix数据增强方式利用两张图片进行拼接。
    在这里插入图片描述
    但是mosaic利用了四张图片,根据论文所说其拥有一个巨大的优点是丰富检测物体的背景!且在BN计算的时候一下子会计算四张图片的数据!
    就像下图这样:
    在这里插入图片描述

    实现思路

    1、每次读取四张图片。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    2、分别对四张图片进行翻转、缩放、色域变化等,并且按照四个方向位置摆好。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    3、进行图片的组合和框的组合
    在这里插入图片描述

    全部代码

    全部代码构成如下:

    from PIL import Image, ImageDraw
    import numpy as np
    from matplotlib.colors import rgb_to_hsv, hsv_to_rgb
    import math
    def rand(a=0, b=1):
        return np.random.rand()*(b-a) + a
    
    def merge_bboxes(bboxes, cutx, cuty):
    
        merge_bbox = []
        for i in range(len(bboxes)):
            for box in bboxes[i]:
                tmp_box = []
                x1,y1,x2,y2 = box[0], box[1], box[2], box[3]
    
                if i == 0:
                    if y1 > cuty or x1 > cutx:
                        continue
                    if y2 >= cuty and y1 <= cuty:
                        y2 = cuty
                        if y2-y1 < 5:
                            continue
                    if x2 >= cutx and x1 <= cutx:
                        x2 = cutx
                        if x2-x1 < 5:
                            continue
                    
                if i == 1:
                    if y2 < cuty or x1 > cutx:
                        continue
    
                    if y2 >= cuty and y1 <= cuty:
                        y1 = cuty
                        if y2-y1 < 5:
                            continue
                    
                    if x2 >= cutx and x1 <= cutx:
                        x2 = cutx
                        if x2-x1 < 5:
                            continue
    
                if i == 2:
                    if y2 < cuty or x2 < cutx:
                        continue
    
                    if y2 >= cuty and y1 <= cuty:
                        y1 = cuty
                        if y2-y1 < 5:
                            continue
    
                    if x2 >= cutx and x1 <= cutx:
                        x1 = cutx
                        if x2-x1 < 5:
                            continue
    
                if i == 3:
                    if y1 > cuty or x2 < cutx:
                        continue
    
                    if y2 >= cuty and y1 <= cuty:
                        y2 = cuty
                        if y2-y1 < 5:
                            continue
    
                    if x2 >= cutx and x1 <= cutx:
                        x1 = cutx
                        if x2-x1 < 5:
                            continue
    
                tmp_box.append(x1)
                tmp_box.append(y1)
                tmp_box.append(x2)
                tmp_box.append(y2)
                tmp_box.append(box[-1])
                merge_bbox.append(tmp_box)
        return merge_bbox
    
    def get_random_data(annotation_line, input_shape, random=True, hue=.1, sat=1.5, val=1.5, proc_img=True):
        '''random preprocessing for real-time data augmentation'''
        h, w = input_shape
        min_offset_x = 0.4
        min_offset_y = 0.4
        scale_low = 1-min(min_offset_x,min_offset_y)
        scale_high = scale_low+0.2
    
        image_datas = [] 
        box_datas = []
        index = 0
    
        place_x = [0,0,int(w*min_offset_x),int(w*min_offset_x)]
        place_y = [0,int(h*min_offset_y),int(w*min_offset_y),0]
        for line in annotation_line:
            # 每一行进行分割
            line_content = line.split()
            # 打开图片
            image = Image.open(line_content[0])
            image = image.convert("RGB") 
            # 图片的大小
            iw, ih = image.size
            # 保存框的位置
            box = np.array([np.array(list(map(int,box.split(',')))) for box in line_content[1:]])
            
            # image.save(str(index)+".jpg")
            # 是否翻转图片
            flip = rand()<.5
            if flip and len(box)>0:
                image = image.transpose(Image.FLIP_LEFT_RIGHT)
                box[:, [0,2]] = iw - box[:, [2,0]]
    
            # 对输入进来的图片进行缩放
            new_ar = w/h
            scale = rand(scale_low, scale_high)
            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)
    
            # 进行色域变换
            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 = hsv_to_rgb(x)
    
            image = Image.fromarray((image*255).astype(np.uint8))
            # 将图片进行放置,分别对应四张分割图片的位置
            dx = place_x[index]
            dy = place_y[index]
            new_image = Image.new('RGB', (w,h), (128,128,128))
            new_image.paste(image, (dx, dy))
            image_data = np.array(new_image)/255
    
            # Image.fromarray((image_data*255).astype(np.uint8)).save(str(index)+"distort.jpg")
            
            index = index + 1
            box_data = []
            # 对box进行重新处理
            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
                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)]
                box_data = np.zeros((len(box),5))
                box_data[:len(box)] = box
            
            image_datas.append(image_data)
            box_datas.append(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()
    
        
        # 将图片分割,放在一起
        cutx = np.random.randint(int(w*min_offset_x), int(w*(1 - min_offset_x)))
        cuty = np.random.randint(int(h*min_offset_y), int(h*(1 - min_offset_y)))
    
        new_image = np.zeros([h,w,3])
        new_image[:cuty, :cutx, :] = image_datas[0][:cuty, :cutx, :]
        new_image[cuty:, :cutx, :] = image_datas[1][cuty:, :cutx, :]
        new_image[cuty:, cutx:, :] = image_datas[2][cuty:, cutx:, :]
        new_image[:cuty, cutx:, :] = image_datas[3][:cuty, cutx:, :]
    
        # 对框进行进一步的处理
        new_boxes = merge_bboxes(box_datas, cutx, cuty)
    
        return new_image, new_boxes
    
    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:]])
     
        iw, ih = image.size
        image = image.transpose(Image.FLIP_LEFT_RIGHT)
        box[:, [0,2]] = iw - box[:, [2,0]]
    
        return image, box
    
    if __name__ == "__main__":
        with open("2007_train.txt") as f:
            lines = f.readlines()
        a = np.random.randint(0,len(lines))
        # index = 0
        # line_all = lines[a:a+4]
        # for line in line_all:
        #     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()
        #     # img.save(str(index)+"box.jpg")
        #     index = index+1
            
        line = lines[a:a+4]
        image_data, box_data = get_random_data(line,[416,416])
        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.save("box_all.jpg")
    
    展开全文
  • Yolov4 mosaic 数据增强

    万次阅读 2020-04-27 17:59:13
    mosaic 数据增强 Yolov4的mosaic 数据增强是参考CutMix数据增强,理论上类似,CutMix的理论可以参考这篇CutMix,但是mosaic利用了四张图片,据论文其优点是丰富检测物体的背景,且在BN计算的时候一下子会计算四张...

    mosaic 数据增强

    Yolov4的mosaic 数据增强是参考CutMix数据增强,理论上类似,CutMix的理论可以参考这篇CutMix,但是mosaic利用了四张图片,据论文其优点是丰富检测物体的背景,且在BN计算的时候一下子会计算四张图片的数据,使得mini-batch大小不需要很大,那么一个GPU就可以达到比较好的效果。

    实现方法

    伪代码:

    for data, target in batches:
    	w, h  = (data[0]).shape
    	cut_x = random(0.2w, 0.8w)
    	cut_y = random(0.2h, 0.8h)
    	s1, s2, s3, s4 = area(block1) / wh, .....(分块所占比例)
    	d1 = data[random_index][0, :(h-cut_y), 0:cut_x, :]
    	d2 = data[random_index][1, (h-cut_y):, 0:cut_x, :]
    	d3 = data[random_index][2, (h-cut_y):, cut_x:, :]
    	d4 = data[random_index][3, :(h-cut_y), cut_x:, :]
    	x = concat(d1, d2, d3, d4)
    	y = target[random_index]*s1 + target[random_index]*s2 + target[random_index]*s3 + target[random_index]*s4
    

    以上伪代码适用于分类的数据,检测的数据需要合并annotations,后面更新。
    python代码在github

    效果图:
    在这里插入图片描述
    对于用于检测的数据,首先对图片的处理和上面对分类数据处理一致,对于annotations需要对框的坐标在合成图中进行调整,超出边界的需要裁剪,效果图如下:
    在这里插入图片描述
    代码请见github,后期更新代码实现细节

    展开全文
  • 【YOLOv4探讨 之三】mosaic数据增强

    千次阅读 2021-02-10 23:30:33
    进入正题,我们聊一聊YOLOv4中使用的mosaic数据增强。关于mosaic数据增强相关文章不少,三个月前这个方面的学习开了个头,那时候各路诸侯都是以TensorFlow框架为主,我这里依然坚持分析研究darknet框架下的数据增强...
  • YOLOV4-Mosaic数据增强详解

    千次阅读 热门讨论 2020-05-27 20:49:22
    Mosaic数据增强 Mosaic数据增强方法是YOLOV4论文中提出来的,主要思想是将四张图片进行随机裁剪,再拼接到一张图上作为训练数据。这样做的好处是丰富了图片的背景,并且四张图片拼接在一起变相地提高了batch_size,...
  • 简单看了一个yolov4的介绍,mosaic数据增强简单说就是四张图片合一,长宽随机变化。理想的实现是结合图片集和标签集,对单张图片标注过之后,四张合一的图片就不用再标注。这里只做一个简单的实现,仅仅把四张图片...
  • Mosaic数据增强---python实现

    千次阅读 2020-07-30 18:18:10
    Mosaic数据增强 什么是Mosaic数据增强方法 Yolov4的mosaic数据增强参考了CutMix数据增强方式,理论上具有一定的相似性! CutMix数据增强方式利用两张图片进行拼接。 但是mosaic利用了四张图片,根据论文所说其拥有...
  • 把hyp.scratch.yaml文件中的mosaic:设置为1.0,表示对全部数据做mosaic数据增强;把mosaic设置成0.0表示不做mosaic数据增强。 mosaic: 1.0时,跑了10个epoch就能达到50%的准确率,而mosaic: 0.0时,跑50个epoch才能...
  • YoloV4当中的Mosaic数据增强方法(附代码讲解)

    千次阅读 热门讨论 2020-08-08 12:20:00
    上一期中讲解了图像分类和目标检测中的数据增强的区别和联系,这期讲解数据增强的进阶版- yolov4中的Mosaic数据增强方法以及CutMix。前言Yolov4的mosaic数据增强参考...
  • Mosaic数据增强方法介绍 mosaic数据增强利用了四张图片,对四张图片进行拼接,每一张图片都有其对应的框框,将四张图片拼接之后就获得一张新的图片,同时也获得这张图片对应的框框,然后我们将这样一张新的图片传入...
  • 目标检测基础——mosaic数据增强

    千次阅读 热门讨论 2020-07-16 16:45:59
    自从Yolo v4论文发表以后,新的数据增强方式mosaic备受关注。本文实现该数据增强方式: 先看看train.txt中的文件格式 img_path x1,y1,x2,y2,cls /home/gp/dukto/Xray_match/data/train/JPEGImages/300059.jpg 91,...
  • YOLOv4中的Mosaic数据增强方式实现代码 Mosaic是一种通过混合4张训练图像的数据增强方式,示例如下图,这样做也同时混合了四张图片的语义,目的在于使被检测的目标超出它们普遍的语义,使得模型具有更好的鲁棒性。...
  • 数据集转换成VOC格式,代码与上面可得。 yolo3整体的文件夹构架如下: 本文使用VOC格式进行训练。 训练前将标签文件放在VOCdevkit文件夹下的VOC2007文件夹下的Annotation中。 训练前将图片文件放在VOCdevkit...
  • yoloV4mosaic数据增强,同步Pascal VOC格式的XML标注信息talk is cheap, show code. talk is cheap, show code. from PIL import Image, ImageDraw import numpy as np from matplotlib.colors import rgb_to_hsv, ...
  • def load_mosaic(self, index): """ 将四张图片拼接在一张马赛克图像中 :param self: :param index: 需要获取的图像索引 :return: """ # loads images in a mosaic labels4 = [] # 拼接图像的label信息 s ...
  • mosaic(img_files,index,img_size,labels): # loads images in a mosaic labels4 = [] s = img_size xc, yc = [int(random.uniform(s * 0.5, s * 1.5)) for _ in range(2)] # mosaic center x, y indices = [index] ...
  • 文章目录RetinaNet/FCOS loss优化multi scale训练mosaic数据增强 所有代码已上传到本人github repository:https://github.com/zgcr/pytorch-ImageNet-CIFAR-COCO-VOC-training 如果觉得有用,请点个star哟! 下列...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,694
精华内容 677
关键字:

mosaic数据增强