精华内容
下载资源
问答
  • 更准确的模型需要更多的数据,对于传统非神经网络机器学习方法,不同的特征需要有各自相符合的数据扩增方法。 1. 在使用opencv_traincascade.exe 过程中,图像读取在 classifier.train -> updateTrainingSet( ...

            更准确的模型需要更多的数据,对于传统非神经网络机器学习方法,不同的特征需要有各自相符合的数据扩增方法。


    1.   在使用opencv_traincascade.exe 过程中,图像读取在

             classifier.train ->  updateTrainingSet( requiredLeafFARate, tempLeafFARate )->fillPassedSamples( 0, numPos, true, 0, posConsumed )->imgReader.getPos( img ) :  imgReader.getNeg( img )过程中。


    2. 在进行数据增强的过程中,从createSample开始,保证vecFile和样本数目长度一致。

    修改代码段依次为:

    //int cvCreateTrainingSamplesFromInfoRf(const char* infoname, const char* vecfilename,
    int cvCreateSamplesPlus(const char* infoname, const char* vecfilename, int num,
    	int showsamples,
    	int winwidth, int winheight)
    {
    	CvEnhanseData      enhanser;
    
        char fullname[PATH_MAX];
        char* filename;
    
        FILE* info;
        FILE* vec;
        //IplImage* src = 0;
        //IplImage* sample;
        cv::Mat src, sample;
        int line;
        int error;
        int i;
        int x, y, width, height;
        int total;
    
        assert(infoname != NULL);
        assert(vecfilename != NULL);
    
        total = 0;
        if (!icvMkDir(vecfilename))
        {
    
    #if CV_VERBOSE
            fprintf(stderr, "Unable to create directory hierarchy: %s\n", vecfilename);
    #endif /* CV_VERBOSE */
    
            return total;
        }
    
        info = fopen(infoname, "r");
        if (info == NULL)
        {
    
    #if CV_VERBOSE
            fprintf(stderr, "Unable to open file: %s\n", infoname);
    #endif /* CV_VERBOSE */
    
            return total;
        }
    
        vec = fopen(vecfilename, "wb");
        if (vec == NULL)
        {
    
    #if CV_VERBOSE
            fprintf(stderr, "Unable to open file: %s\n", vecfilename);
    #endif /* CV_VERBOSE */
    
            fclose(info);
    
            return total;
        }
    
        //sample = cvCreateImage(cvSize(winwidth, winheight), IPL_DEPTH_8U, 1);
    
        icvWriteVecHeader(vec, num, winwidth, winheight);
    
        if (showsamples)
        {
            cvNamedWindow("Sample", CV_WINDOW_AUTOSIZE);
        }
    
        strcpy(fullname, infoname);
        filename = strrchr(fullname, '\\');
        if (filename == NULL)
        {
            filename = strrchr(fullname, '/');
        }
        if (filename == NULL)
        {
            filename = fullname;
        }
        else
        {
            filename++;
        }
    
        for (line = 1, error = 0, total = 0; total < num; line++)
        {
            int count;
    
            error = (fscanf(info, "%s %d", filename, &count) != 2);
            if (!error)
            {
                //src = cvLoadImage(fullname, 0);
                //error = (src == NULL);
    
                src = cv::imread(fullname, 0);
                error = (src.data == NULL);
    
                if (error)
                {
    
    #if CV_VERBOSE
                    fprintf(stderr, "Unable to open image: %s\n", fullname);
    #endif /* CV_VERBOSE */
    
                }
            }
            for (i = 0; (i < count) && (total < num); i++, total++)
            {
                error = (fscanf(info, "%d %d %d %d", &x, &y, &width, &height) != 4);
                if (error) break;
                //cvSetImageROI(src, cvRect(x, y, width, height));
                //cvResize(src, sample, width >= sample->width &&height >= sample->height ? CV_INTER_AREA : CV_INTER_LINEAR);
                cv::resize(src, sample, cv::Size(winwidth,winheight));
    
                //if (showsamples)
                //{
                //    cvShowImage("Sample", sample);
                //    if (cvWaitKey(0) == 27)
                //    {
                //        showsamples = 0;
                //    }
                //}
    
                //icvWriteVecSample(vec, sample);
    
                {
                    int extNum = 7;
    
                    //IplImage* sample2 = cvCreateImage(cvGetSize(sample), IPL_DEPTH_8U, sample->nChannels);
                    //cvCopyImage(sample, sample2);
    
                    std::vector<cv::Mat > imgLIst(extNum);
                    cv::Mat inMat(sample);//此句导致占用释放错误
                    enhanser.EnhanceData(inMat, extNum, 1, imgLIst);
    
                    for (int i = 0; i < extNum; ++i)
                    {//把Mat 生成移除来//已不必要
    
                        //IplImage* sampleT = nullptr;// = nullptr;
                        //*sampleT = IplImage(imgLIst[i]);
                        //icvWriteVecSample(vec, sampleT);
                        icvWriteVecSamplePlus(vec,imgLIst[i]);
    
                        //if (sampleT)
                        //{
                        //    cvReleaseImage(&sampleT);
                        //}
                    }
    
    
                }
            }
    
            //if (src)
            //{
            //    cvReleaseImage(&src);
            //}
    
            if (error)
            {
    
    #if CV_VERBOSE
                fprintf(stderr, "%s(%d) : parse error", infoname, line);
    #endif /* CV_VERBOSE */
    
                break;
            }
        }
    
        //if (sample)
        //{
        //    cvReleaseImage(&sample);
        //}
    
        fclose(vec);
        fclose(info);
    
        return total;
    }

    修改函数:void icvWriteVecSample

    //对每个图像写入正样本Vec
    void icvWriteVecSamplePlus(FILE* file, cv::Mat &sample)
    {
    	//CvMat* mat, stub;
    	int r, c;
    	short tmp;
    	uchar chartmp;
    
    	//mat = cvGetMat(sample, &stub);
    	chartmp = 0;
    	fwrite(&chartmp, sizeof(chartmp), 1, file);
    	for (r = 0; r < sample.rows; r++)
    	{
    		for (c = 0; c < sample.cols; c++)
    		{
    			//tmp = (short)(CV_MAT_ELEM(*mat, uchar, r, c));
    			tmp = (short)(sample.at<unsigned char>(r,c));
    			fwrite(&tmp, sizeof(tmp), 1, file);
    		}
    	}
    }

    使用C++语言替换掉使用C语言的版本。

    同时对生成新的Vec增加int extNum = 7;倍。

    转载于:https://www.cnblogs.com/wishchin/p/9199959.html

    展开全文
  • 数据读取与数据扩增

    2020-05-23 23:29:10
    学习目标 学习Python和Pytorch中图像读取 ...由于训练集与测试集合中可能存在潜在的位置偏差,使得模型在测试集中很难达到训练集中的效果,几何变换可以有效地克服训练数据中存在的位置偏差,而且易于实现,许多图

    学习目标
    学习Python和Pytorch中图像读取
    学会扩增方法和使用Pytorch读取赛题数据
    数据读取与数据扩增

    图像读取

    Pillow
    Pillow是Python图像处理函式库(PIL)的一个分支。Pillow提供了常见的图像读取和处理的操作,而且可以与ipython notebook无缝集成,是应用比较广泛的库。

    常用数据扩增方法
    几何变换:
    由于训练集与测试集合中可能存在潜在的位置偏差,使得模型在测试集中很难达到训练集中的效果,几何变换可以有效地克服训练数据中存在的位置偏差,而且易于实现,许多图像处理库都包含这个功能。
    颜色变换:
    图片在输入计算机之前,通常会被编码为张量(高度×宽度×颜色通道),所以可以在色彩通道空间进行数据增强,比如将某种颜色通道关闭,或者改变亮度值。
    旋转 | 反射变换:
    选择一个角度,左右旋转图像,可以改变图像内容朝向。关于旋转角度需要慎重考虑,角度太大或者太小都不合适,适宜的角度是1度 到 20度。

    噪声注入:
    从高斯分布中采样出的随机值矩阵加入到图像的RGB像素中,通过向图像添加噪点可以帮助CNN学习更强大的功能。

    内核过滤器:
    内核滤镜是在图像处理中一种非常流行的技术,比如锐化和模糊。将特定功能的内核滤镜与图像进行卷积操作,就可以得到增强后的数据。直观上,数据增强生成的图像可能会使得模型面对这种类型的图像具有更高的鲁棒性。

    混合图像:
    通过平均图像像素值将图像混合在一起是一种非常违反直觉的数据增强方法。对于人来说,混合图像生成的数据似乎没有意义。虽然这种方法缺乏可解释性,但是作为一种简单有效的数据增强算法,有一系列的工作进行相关的研究。Inoue在图像每个像素点混合像素值来混合图像,Summers和Dinneen又尝试以非线性的方法来混合图像,Takahashi和Matsubara通过随机图像裁剪和拼接来混合图像,以及后来的mixup方法均取得了不错的成果。

    随机擦除:
    随机擦除是Zhong等人开发的数据增强技术。他们受到Dropout机制的启发,随机选取图片中的一部分,将这部分图片删除,这项技术可以提高模型在图片被部分遮挡的情况下性能,除此之外还可以确保网络关注整个图像,而不只是其中的一部分。

    缩放变换:
    图像按照一定的比例进行放大和缩小并不改变图像中的内容,可以增加模型的泛化性能。

    移动:
    向左,向右,向上或向下移动图像可以避免数据中的位置偏差,比如在人脸识别数据集合中,如果所有图像都居中,使用这种数据增强方法可以避免可能出现的位置偏差导致的错误。

    翻转变换
    通常是关于水平或者竖直的轴进行图像翻转操作,这种扩充是最容易实现的扩充,并且已经证明对ImageNet数据集有效。

    裁剪
    如果输入数据集合的大小是变化的,裁剪可以作为数据预处理的一个手段,通过裁剪图像的中央色块,可以得到新的数据。在实际使用过程之中,这些数据增强算法不是只使用一种,而是使用一套数据增强策略,在AutoAugment这篇文章中,作者尝试让模型自动选择数据增强策略。

    展开全文
  • 深度学习之数据扩增

    2020-05-23 18:45:26
    在深度学习中数据扩增非常重要,可以增加训练样本数量,同时可以在一定程度上缓解模型过拟合,提高模型的泛化能力,可以扩展样本空间。 二、常⻅的数据扩增⽅方法 常见的数据扩增方法主要是从图像颜色,尺寸,形态,...

    一、数据扩增简介
    在深度学习中数据扩增非常重要,可以增加训练样本数量,同时可以在一定程度上缓解模型过拟合,提高模型的泛化能力,可以扩展样本空间。
    二、常⻅的数据扩增⽅方法
    常见的数据扩增方法主要是从图像颜色,尺寸,形态,空间和像素角度进行变换。不同的数据扩增方法可以自由组合,得到更加丰富的数据扩增方法。以torchvision为例,常用的数据扩增方法包括:

    1. transforms.CenterCrop 对图片中心进行裁剪
    2. transforms.ColorJitter 对图像颜色的对比度,饱和度和零度进行变换
    3. transforms.FiveCrop 对图像四个角和中心进行裁剪得到5份图像
    4. transforms.Grayscale 对图像进行灰度变换
    5. transforms.Pad 使用固定值进行像素填充
    6. transforms.RandomAffine 随机放射变换
    7. transforms.RandomCrop 随机区域裁剪
    8. transforms.RandomHorizontalFlip 随机水平翻转
    9. transforms.RandomRotation 随机旋转
    10. transforms.RandomVerticaIFlip随机垂直翻转
      三、常用数据扩增库
      1.torchvision
      https://github.com/pytorch/vision
      pytorch官方提供的数据扩增库,提供了基本的数据扩增方法,可无缝与torch进行集成,数据扩增方法种类较少,速度中等。
      2.imgaug
      https://github.com/aleju/imgaug
      imgaug常用第三方数据扩增库,提供多样数据扩增方法,组合起来方便,速度较快。
      3.albumentations
      https://albumentations.readthedocs.io
      常用第三方数据扩增库,提供多样数据扩增方法,对图像分类、语意分割、物体检测、关键点检测都支持,速度较快。
    展开全文
  • 数据扩增python实现

    千次阅读 2019-04-09 10:28:13
    训练深度学习模型,当训练数据不够时,往往需要进行数据扩增,常见的数据扩增方法有: # 1 尺寸 # 2 旋转 # 3 镜像 # 4 平移 # 5 亮度不变 # 6 色度不变 # 7 对比度不变 # 8 锐度 from PIL import Image, ...

    训练深度学习模型,当训练 数据不够时,往往需要进行数据扩增,常见的数据扩增方法有:

    # 1 尺寸
    # 2 旋转
    # 3 镜像
    # 4 平移
    # 5 亮度不变
    # 6 色度不变
    # 7 对比度不变
    # 8 锐度

    from PIL import Image, ImageEnhance
    import numpy as np
    import imutils
    import os
    
    # 1 尺寸:8
    # 2 旋转 9
    # 3 镜像 3
    # 4 平移 9
    # 5 亮度不变 9
    # 6 色度不变 7
    # 7 对比度不变 7
    # 8 锐度 7
    
    #尺寸调整
    def ImgResize(Img,ScaleFactor):
        ImgSize = Img.size #获得图像原始尺寸
        NewSize = [int(ImgSize[0]*ScaleFactor),int(ImgSize[1]*ScaleFactor)]  #获得图像新尺寸,保持长宽比
        Img = Img.resize(NewSize)     #利用PIL的函数进行图像resize,类似matlab的imresize函数
        return Img
    
    def ImgResizeTo(Img,NewSize):
        Img = Img.resize(NewSize)     #利用PIL的函数进行图像resize,类似matlab的imresize函数
        return Img
    
    #旋转
    def ImgRotate(Img,Degree):
        return Img.rotate(Degree) #利用PIL的函数进行图像旋转,类似matlab imrotate函数
    
    #利用PIL的函数进行水平以及上下镜像
    def ImgLRMirror(Img):
        return Img.transpose(Image.FLIP_LEFT_RIGHT)
    
    def ImgTBMirror(Img):
        return Img.transpose(Image.FLIP_TOP_BOTTOM)
    
    # 亮度,增强因子为1.0是原始图像
    def BrightEnchance(Img, factor):
        enh_bri = ImageEnhance.Brightness(Img)
        image_brightened = enh_bri.enhance(factor)
        return image_brightened
    
    # 色度,增强因子为1.0是原始图像
    def ColorEnchance(Img, factor):
        enh_col = ImageEnhance.Color(Img)
        image_colored = enh_col.enhance(factor)
        return image_colored
    
    #对比度,增强因子为1.0是原始图片
    def ContrastEnchance(Img, factor):
        enh_con = ImageEnhance.Contrast(Img)
        image_contrasted = enh_con.enhance(factor)
        return image_contrasted
    
    # 锐度,增强因子为1.0是原始图片
    def SharpEnchance(Img, factor):
        enh_sha = ImageEnhance.Sharpness(Img)
        image_sharped = enh_sha.enhance(factor)
        return image_sharped
    
    
    # data_path = '/home/xiqi/PycharmProjects/FBMS/Dataset/Trainingset/'
    data_path = 'G:/Experiment/data/train/images/'
    video_list = os.listdir(data_path)
    
    save_path = 'G:/Experiment/data/train/augmentation_images/'
    if not os.path.exists(save_path):  # 文件夹不存在,则创建
        os.mkdir(save_path)
    
    img_list = os.listdir(data_path)
    for j in range(0, len(img_list)):
        print(j)
        img_path = os.path.join(data_path, img_list[j])  # 图片文件
        if os.path.isfile(img_path):
            Img = Image.open(img_path)
            # 1 尺寸
            scale_img1 = ImgResize(Img,0.2)
            scale_img2 = ImgResize(Img,0.4)
            scale_img3 = ImgResize(Img,0.6)
            scale_img4 = ImgResize(Img,0.8)
            scale_img5 = ImgResize(Img,1)
            scale_img6 = ImgResize(Img, 1.2)
            scale_img7 = ImgResize(Img, 1.4)
            scale_img8 = ImgResize(Img, 1.5)
            save_scale_path1 = os.path.join(save_path, 'scale_img1_'+img_list[j])
            save_scale_path2 = os.path.join(save_path, 'scale_img2_'+img_list[j])
            save_scale_path3 = os.path.join(save_path, 'scale_img3_'+img_list[j])
            save_scale_path4 = os.path.join(save_path, 'scale_img4_'+img_list[j])
            save_scale_path5 = os.path.join(save_path, 'scale_img5_'+img_list[j])
            save_scale_path6 = os.path.join(save_path, 'scale_img6_'+img_list[j])
            save_scale_path7 = os.path.join(save_path, 'scale_img7_'+img_list[j])
            save_scale_path8 = os.path.join(save_path, 'scale_img8_'+img_list[j])
            scale_img1.save(save_scale_path1)
            scale_img2.save(save_scale_path2)
            scale_img3.save(save_scale_path3)
            scale_img4.save(save_scale_path4)
            scale_img5.save(save_scale_path5)
            scale_img6.save(save_scale_path6)
            scale_img7.save(save_scale_path7)
            scale_img8.save(save_scale_path8)
    
            # 2 旋转
            rotate_img1 = ImgRotate(Img,10)
            rotate_img2 = ImgRotate(Img,30)
            rotate_img3 = ImgRotate(Img,45)
            rotate_img4 = ImgRotate(Img,90)
            rotate_img5 = Img
            rotate_img6 = ImgRotate(Img, 120)
            rotate_img7 = ImgRotate(Img, 135)
            rotate_img8 = ImgRotate(Img, 170)
            rotate_img9 = ImgRotate(Img, 180)
            save_rotate_path1 = os.path.join(save_path, 'rotate_img1_'+img_list[j])
            save_rotate_path2 = os.path.join(save_path, 'rotate_img2_'+img_list[j])
            save_rotate_path3 = os.path.join(save_path, 'rotate_img3_'+img_list[j])
            save_rotate_path4 = os.path.join(save_path, 'rotate_img4_'+img_list[j])
            save_rotate_path5 = os.path.join(save_path, 'rotate_img5_'+img_list[j])
            save_rotate_path6 = os.path.join(save_path, 'rotate_img6_'+img_list[j])
            save_rotate_path7 = os.path.join(save_path, 'rotate_img7_'+img_list[j])
            save_rotate_path8 = os.path.join(save_path, 'rotate_img8_'+img_list[j])
            save_rotate_path9 = os.path.join(save_path, 'rotate_img9_'+img_list[j])
            rotate_img1.save(save_rotate_path1)
            rotate_img2.save(save_rotate_path2)
            rotate_img3.save(save_rotate_path3)
            rotate_img4.save(save_rotate_path4)
            rotate_img5.save(save_rotate_path5)
            rotate_img6.save(save_rotate_path6)
            rotate_img7.save(save_rotate_path7)
            rotate_img8.save(save_rotate_path8)
            rotate_img9.save(save_rotate_path9)
    
            # 镜像
            mirror_img1 = ImgLRMirror(Img)
            mirror_img2 = ImgTBMirror(Img)
            mirror_img3 = Img
            save_mirror_path1 = os.path.join(save_path, 'mirror_img1_'+img_list[j])
            save_mirror_path2 = os.path.join(save_path, 'mirror_img2_'+img_list[j])
            save_mirror_path3 = os.path.join(save_path, 'mirror_img3_'+img_list[j])
            mirror_img1.save(save_mirror_path1)
            mirror_img2.save(save_mirror_path2)
            mirror_img3.save(save_mirror_path3)
    
            # 平移
            array_img = np.array(Img) # PIL.Image 转 numpy.array
            translation_img1 = imutils.translate(array_img, 60, 60)
            translation_img2 = imutils.translate(array_img, -60, 60)
            translation_img3 = imutils.translate(array_img, 60, -60)
            translation_img4 = imutils.translate(array_img, -60, -60)
            translation_img5 = array_img
            translation_img6 = imutils.translate(array_img, 30, 30)
            translation_img7 = imutils.translate(array_img, -30, 30)
            translation_img8 = imutils.translate(array_img, 30, -30)
            translation_img9 = imutils.translate(array_img, -30, -30)
            save_translation_path1 = os.path.join(save_path, 'translation_img1_'+img_list[j])
            save_translation_path2 = os.path.join(save_path, 'translation_img2_'+img_list[j])
            save_translation_path3 = os.path.join(save_path, 'translation_img3_'+img_list[j])
            save_translation_path4 = os.path.join(save_path, 'translation_img4_'+img_list[j])
            save_translation_path5 = os.path.join(save_path, 'translation_img5_'+img_list[j])
            save_translation_path6 = os.path.join(save_path, 'translation_img6_'+img_list[j])
            save_translation_path7 = os.path.join(save_path, 'translation_img7__'+img_list[j])
            save_translation_path8 = os.path.join(save_path, 'translation_img8_'+img_list[j])
            save_translation_path9 = os.path.join(save_path, 'translation_img9_'+img_list[j])
            translation_img1 = Image.fromarray(translation_img1)
            translation_img2 = Image.fromarray(translation_img2)
            translation_img3 = Image.fromarray(translation_img3)
            translation_img4 = Image.fromarray(translation_img4)
            translation_img5 = Image.fromarray(translation_img5)
            translation_img6 = Image.fromarray(translation_img6)
            translation_img7 = Image.fromarray(translation_img7)
            translation_img8 = Image.fromarray(translation_img8)
            translation_img9 = Image.fromarray(translation_img9)
            translation_img1.save(save_translation_path1)
            translation_img2.save(save_translation_path2)
            translation_img3.save(save_translation_path3)
            translation_img4.save(save_translation_path4)
            translation_img5.save(save_translation_path5)
            translation_img6.save(save_translation_path6)
            translation_img7.save(save_translation_path7)
            translation_img8.save(save_translation_path8)
            translation_img9.save(save_translation_path9)
    
    
            # 以下只对原图操作,亮度,增强因子为0.0将产生黑色图像;为1.0将保持原始图像
            bright_img1 = BrightEnchance(Img, 0.3)
            bright_img2 = BrightEnchance(Img, 0.4)
            bright_img3 = BrightEnchance(Img, 0.5)
            bright_img4 = BrightEnchance(Img, 0.6)
            bright_img5 = BrightEnchance(Img, 0.7)
            bright_img6 = BrightEnchance(Img, 0.8)
            bright_img7 = BrightEnchance(Img, 0.9)
            bright_img8 = BrightEnchance(Img, 0.9)
            bright_img9 = Img
            save_bright_path1 = os.path.join(save_path, 'bright_img1_'+img_list[j])
            save_bright_path2 = os.path.join(save_path, 'bright_img2_'+img_list[j])
            save_bright_path3 = os.path.join(save_path, 'bright_img3_'+img_list[j])
            save_bright_path4 = os.path.join(save_path, 'bright_img4_'+img_list[j])
            save_bright_path5 = os.path.join(save_path, 'bright_img5_'+img_list[j])
            save_bright_path6 = os.path.join(save_path, 'bright_img6_'+img_list[j])
            save_bright_path7 = os.path.join(save_path, 'bright_img7__'+img_list[j])
            save_bright_path8 = os.path.join(save_path, 'bright_img8_'+img_list[j])
            save_bright_path9 = os.path.join(save_path, 'bright_img9_'+img_list[j])
            bright_img1.save(save_bright_path1)
            bright_img2.save(save_bright_path2)
            bright_img3.save(save_bright_path3)
            bright_img4.save(save_bright_path4)
            bright_img5.save(save_bright_path5)
            bright_img6.save(save_bright_path6)
            bright_img7.save(save_bright_path7)
            bright_img8.save(save_bright_path8)
            bright_img9.save(save_bright_path9)
    
            # 色度,增强因子为1.0是原始图像,大于1增强,小于1减弱
            color_img1 = ColorEnchance(Img, 0.5)
            color_img2 = ColorEnchance(Img, 0.7)
            color_img3 = ColorEnchance(Img, 0.9)
            color_img4 = ColorEnchance(Img, 1.1)
            color_img5 = ColorEnchance(Img, 1.3)
            color_img6 = ColorEnchance(Img, 1.5)
            color_img7 = Img
            save_color_path1 = os.path.join(save_path, 'color_img1_'+img_list[j])
            save_color_path2 = os.path.join(save_path, 'color_img2_' + img_list[j])
            save_color_path3 = os.path.join(save_path, 'color_img3_' + img_list[j])
            save_color_path4 = os.path.join(save_path, 'color_img4_' + img_list[j])
            save_color_path5 = os.path.join(save_path, 'color_img5_' + img_list[j])
            save_color_path6 = os.path.join(save_path, 'color_img6_' + img_list[j])
            save_color_path7 = os.path.join(save_path, 'color_img7_' + img_list[j])
            color_img1.save(save_color_path1)
            color_img2.save(save_color_path2)
            color_img3.save(save_color_path3)
            color_img4.save(save_color_path4)
            color_img5.save(save_color_path5)
            color_img6.save(save_color_path6)
            color_img7.save(save_color_path7)
    
    
            #对比度,增强因子为1.0是原始图片,大于1增强,小于1减弱
            contrast_img1 = ContrastEnchance(Img, 0.5)
            contrast_img2 = ContrastEnchance(Img, 0.7)
            contrast_img3 = ContrastEnchance(Img, 0.9)
            contrast_img4 = ContrastEnchance(Img, 1.1)
            contrast_img5 = ContrastEnchance(Img, 1.3)
            contrast_img6 = ContrastEnchance(Img, 1.5)
            contrast_img7 = Img
            save_contrast_path1 = os.path.join(save_path, 'contrast_img1_' + img_list[j])
            save_contrast_path2 = os.path.join(save_path, 'contrast_img2_' + img_list[j])
            save_contrast_path3 = os.path.join(save_path, 'contrast_img3_' + img_list[j])
            save_contrast_path4 = os.path.join(save_path, 'contrast_img4_' + img_list[j])
            save_contrast_path5 = os.path.join(save_path, 'contrast_img5_' + img_list[j])
            save_contrast_path6 = os.path.join(save_path, 'contrast_img6_' + img_list[j])
            save_contrast_path7 = os.path.join(save_path, 'contrast_img7_' + img_list[j])
            contrast_img1.save(save_contrast_path1)
            contrast_img2.save(save_contrast_path2)
            contrast_img3.save(save_contrast_path3)
            contrast_img4.save(save_contrast_path4)
            contrast_img5.save(save_contrast_path5)
            contrast_img6.save(save_contrast_path6)
            contrast_img7.save(save_contrast_path7)
    
            # 锐度,增强因子为1.0是原始图片,大于1增强,小于1减弱
            sharp_img1 = SharpEnchance(Img, 0.5)
            sharp_img2 = SharpEnchance(Img, 0.7)
            sharp_img3 = SharpEnchance(Img, 0.9)
            sharp_img4 = SharpEnchance(Img, 1.1)
            sharp_img5 = SharpEnchance(Img, 1.3)
            sharp_img6 = SharpEnchance(Img, 1.5)
            sharp_img7 = Img
            save_sharp_path1 = os.path.join(save_path, 'sharp_img1_' + img_list[j])
            save_sharp_path2 = os.path.join(save_path, 'sharp_img2_' + img_list[j])
            save_sharp_path3 = os.path.join(save_path, 'sharp_img3_' + img_list[j])
            save_sharp_path4 = os.path.join(save_path, 'sharp_img4_' + img_list[j])
            save_sharp_path5 = os.path.join(save_path, 'sharp_img5_' + img_list[j])
            save_sharp_path6 = os.path.join(save_path, 'sharp_img6_' + img_list[j])
            save_sharp_path7 = os.path.join(save_path, 'sharp_img7_' + img_list[j])
            sharp_img1.save(save_sharp_path1)
            sharp_img2.save(save_sharp_path2)
            sharp_img3.save(save_sharp_path3)
            sharp_img4.save(save_sharp_path4)
            sharp_img5.save(save_sharp_path5)
            sharp_img6.save(save_sharp_path6)
            sharp_img7.save(save_sharp_path7)

     

    展开全文
  • 数据扩增:在深度学习中通过数据扩增增加训练集的样本,也可有效缓解模型过拟合的情况。 扩增方法有很多:从颜色空间、尺度空间到样本空间,根据不同任务数据扩增都有相应的区别。 对于图像分类,数据扩增一般不
  • 在深度学习中数据扩增方法非常重要,数据扩增可以增加训练集的样本,同时也可以有效缓解模型过拟合的情况,也可以给模型带来的更强的泛化能力 常见数据扩增方法 以torchvision为例,常见的数据扩增方法包括: ...
  • 数据扩增是一种有效的正则化方法,可以防止模型过拟合,在深度学习模型训练过程中应用广泛。数据扩增的目的是增加数据集中样本的数据量,同时也可以有效增加样本的语义空间。 需注意: 不同的数据,拥有不同的数据...
  • 数据扩增是一种有效的正则化方法,可以防止模型过拟合,在深度学习模型训练过程中应用广泛。 数据扩增的目的是增加数据集中样本的数据量,同时也可以有效增加样本的语义空间。 需注意: 不同的数据,拥有不同的...
  • 数据扩增是一种有效的正则化方法,可以防止模型过拟合,在深度学习模型训练过程中应用广泛。数据扩增的目的是增加数据集中样本的数据量,同时也可以有效增加样本的语义空间。 需要注意: 不同的数据,拥有不同的...
  • 数据扩增方法:数据扩增是一种有效的正则化方法,可以防止模型过拟合,在深度学习模型训练过程中应用广泛。数据扩增的目的是增加数据集中样本的数据量,同时也可以有效增加样本的语义空间。 对于图像分类,数据...
  • 数据扩增再增加了训练集样本的同时,也可以有效地缓解过拟合的情况,使模型具有更强的泛化能力。 数据扩增的方法有很多,从颜色空间、尺度空间到样本空间,根据不同任务,数据扩增都有区别。对于图像分类,数据扩增...
  • 在Kaggle视觉竞赛中,数据扩增(Data Augmentation)是不可少的环节。数据扩增可以增加训练集的样本,同时也可以有效环节模型过拟合的情况,也可以给模型带来的更强的泛化能力...
  • 主要用来增加训练数据量,丰富数据多样性,从而达到降低训练模型的过拟合性,增强模型的范化能力。pytorch中的torchvision.transforms模块中有方便易用的图形变换功能,可以用来进行图形数据的增广,现将代码和运行...
  • 数据扩增的意义:增加训练样本量,也可以有效增加样本的语义空间。是一种有效的正则化方法,可以防止模型过拟合。 数据扩增方法分类: 标签不变的数据扩增方法:数据变换后图像类别不变 标签变化的数据扩增方法:...
  • Task02:数据读取与数据扩增 Task03:字符识别模型 Task04:模型训练与验证 Task05:模型集成 底到镜一 比赛链接 Part2:数据读取与数据扩增 文章目录1. 数据读取 1.1. 图像读取  1.1.1. matplotlib  1.1.2....
  • 反例是分类错误的示例,对重新训练和改进模型具有重要意义。我们框架的关键组件包括一个反例生成器,它生成由模型和错误表错误分类的数据项。错误表是一种新颖的数据结构,用于存储与错误分类有关的信息。它可用于...
  • 数据扩增的作用是增加训练集的样本,同时也可以有效缓解模型过拟合的情况,也可以给模型带来的更强的泛化能力。 2.数据扩增方法 仅从单样本数据来看,数据扩增针对一个样本的时候,就是对样本本身从颜色空间、尺度...
  • 在计算机视觉任务中,数据扩增是一种基于较少数据、产生大量训练样本,进而提升模型性能的有效方法。传统数据扩增方法主要借助于图像域的翻转、平移、旋转等简单变换。而本期讲者王语霖提出了一种隐式语义数据扩增...
  • 本章对语义分割任务中常见的数据扩增方法进行介绍,并使用OpenCV和albumentations两个库完成具体的数据扩增操作。...数据扩增是一种有效的正则化方法,可以防止模型过拟合,在深度学习模型训练过程中
  • 摘要在本文中,我们介绍了随机擦除,一种简单而有效的数据扩增技术用于训练卷积神经网络(CNN)。在训练阶段,随机擦除在图像中随机选择一个矩形区域,并用随机值擦除其中的像素。在这个过程中,生成了不同遮挡程度的...
  • 在深度学习中数据扩增方法非常重要,数据扩增可以增加训练集的样本,同时也可以有效缓解模型过拟合的情况,也可以给模型带来的更强的泛化能力。 以torchvision为例,常见的数据扩增方法包括: transforms.CenterCrop...
  • 1图像的读取 pillow from PIL import Image im =Image.open(image_path) im_gray = Image.open(image_path).convert(“L” 1.2 ...数据扩增可以增加训练集的样本,同时也可以有效缓解模型过拟合的情
  • 街景字符编码识别(一) —— 赛题理解天池CV赛事-街景字符编码识别(二) —— 数据读取与数据扩增天池CV赛事-街景字符编码识别(三)—— 字符识别模型天池CV赛事-街景字符编码识别(四)—— 模型训练与验证天池CV赛事-...
  • 数据扩增一定程度上可以缓解类别的不平衡性,也可以扩展样本的多样性。 在机器学习训练中,还有一个很难绕开的问题是 【过拟合】,过拟合的主要原因是学习到了一些 “假模式”(这也是因果律被诟病的主要原因之一)...
  • 在深度学习中数据扩增方法非常重要,数据扩增可以增加训练集的样本,同时也可以有效缓解模型过拟合的情况,也可以给模型带来的更强的泛化能力。 数据扩增为什么有用? 在深度学习模型训练过程中,数据扩增是必不可...
  • 但自从团队用机器学习解锁了特别的数据扩增策略,再用自动扩增来的新数据集训练目标检测模型,事情就完全不同了。注意:目标检测和分类不一样,分类不需要标注边界框,而目标检测需要。△左边是自动扩增数据,右边是...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 199
精华内容 79
关键字:

数据扩增训练模型