精华内容
下载资源
问答
  • python划分训练和测试集
    千次阅读
    2021-02-25 10:40:53

    自动划分训练集和测试集

    前言

    在进行深度学习的模型训练时,我们通常需要将数据进行划分,划分成训练集和测试集,若数据集太大,数据划分花费的时间太多!!!
    不多说,上代码(python代码)

    代码

    # *_*coding: utf-8 *_*
    
    import os
    import random
    import shutil
    import time
    
    def copyFile(fileDir,origion_path1,class_name):
        name = class_name
        path = origion_path1
        image_list = os.listdir(fileDir) # 获取图片的原始路径
        image_number = len(image_list)
        train_number = int(image_number * train_rate)
        train_sample = random.sample(image_list, train_number) # 从image_list中随机获取0.75比例的图像.
        test_sample = list(set(image_list) - set(train_sample))
        sample = [train_sample, test_sample]
        
        # 复制图像到目标文件夹
        for k in range(len(save_dir)):
                if os.path.isdir(save_dir[k]) and os.path.isdir(save_dir1[k]):
                    for name in sample[k]:
                        name1 = name.split(".")[0] + '.xml'
                        shutil.copy(os.path.join(fileDir, name), os.path.join(save_dir[k], name))
                        shutil.copy(os.path.join(path, name1), os.path.join(save_dir1[k], name1))
                else:
                    os.makedirs(save_dir[k])
                    os.makedirs(save_dir1[k])
                    for name in sample[k]:
                        name1 = name.split(".")[0] + '.xml'
                        shutil.copy(os.path.join(fileDir, name), os.path.join(save_dir[k], name))
                        shutil.copy(os.path.join(path, name1), os.path.join(save_dir1[k], name1))
    
    if __name__ == '__main__':
        time_start = time.time()
    
        # 原始数据集路径
        origion_path = './JPEGImages/'
        origion_path1 = './Annotations/'
    
        # 保存路径
        save_train_dir = './train/JPEGImages/'
        save_test_dir = './test/JPEGImages/'
        save_train_dir1 = './train/Annotations/'
        save_test_dir1 = './test/Annotations/'
        save_dir = [save_train_dir, save_test_dir]
        save_dir1 = [save_train_dir1, save_test_dir1]
    
        # 训练集比例
        train_rate = 0.75
    
        # 数据集类别及数量
        file_list = os.listdir(origion_path)
        num_classes = len(file_list)
        for i in range(num_classes):
            class_name = file_list[i]
        copyFile(origion_path,origion_path1,class_name)
        print('划分完毕!')
        time_end = time.time()
        print('---------------')
        print('训练集和测试集划分共耗时%s!' % (time_end - time_start))
    

    1.需要修改的地方
    1)origion_path:图片路径
    2)origion_path1:xml文件路径
    3)train_rate:训练集比例

    2.执行文件deal.py后生成
    train-img:训练集图片数据
    train-xml:训练集xml数据
    test-img:测试集图片数据
    test-xml:测试及xml数据

    3.train_rate可以根据实际情况进行调整,一般train:test是3:1

    注:每次划分数据都是随机的,每次执行时将之前划分好的数据保存或者重命名,不然会重复写入到4个文件夹中

    总结

    代码还是比较简洁的,有什么问题可以留言。

    更多相关内容
  • 今天小编就为大家分享一篇python 划分数据集为训练集和测试集的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 随机从列表中取出元素: import random dataSet = [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10]] trainDataSet = random.sample(dataSet, 3) ... 获取训练集和测试集(将数据按比例随机划分) :parame
  • 主要介绍了Python分割训练集和测试集的方法示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 内容概要:python脚本划分训练测试集。可以把coco、voc格式的数据转换成yolo系列数据。经过大量实践验证无bug 源代码:python脚本 适合人群:学生、具备一定编程基础,工作1-3年的研发人员、想入门人工智能的爱好...
  • 接下来,直接给出大家响应的代码,并对每一行进行标注,希望能够帮到大家。 需要用到的是库是。numpy 、sklearn。 #导入相应的库(对数据库进行切分需要用到的库是sklearn.model_selection 中的 train_test_split)...
  • python划分训练集、验证集和测试集

    千次阅读 2022-02-21 15:39:04
    # 将图片和标注数据按比例切分为 训练集和测试集、验证集 import shutil import random import os # 原始路径 image_original_path = 'a/images/' label_original_path = 'a/annotations/' # 训练集路径 train_...

    将图片和标注文件分别划分到文件夹中去

    # 将图片和标注数据按比例切分为 训练集和测试集、验证集
    import shutil
    import random
    import os
    
    # 原始路径
    image_original_path = 'a/images/'
    label_original_path = 'a/annotations/'
    # 训练集路径
    train_image_path = 'a/train/images/'
    train_label_path = 'a/train/labels/'
    # 验证集路径
    val_image_path = 'a/val/images/'
    val_label_path = 'a/val/labels/'
    # 测试集路径
    test_image_path = 'a/test/images/'
    test_label_path = 'a/test/labels/'
    
    # 数据集划分比例,训练集80%,验证集10%,测试集10%
    train_percent = 0.8
    val_percent = 0.1
    test_percent = 0.1
    
    # 检查文件夹是否存在
    def mkdir():
        if not os.path.exists(train_image_path):
            os.makedirs(train_image_path)
        if not os.path.exists(train_label_path):
            os.makedirs(train_label_path)
    
        if not os.path.exists(val_image_path):
            os.makedirs(val_image_path)
        if not os.path.exists(val_label_path):
            os.makedirs(val_label_path)
    
        if not os.path.exists(test_image_path):
            os.makedirs(test_image_path)
        if not os.path.exists(test_label_path):
            os.makedirs(test_label_path)
    
    
    def main():
        mkdir()
    
        total_txt = os.listdir(label_original_path)
        num_txt = len(total_txt)
        list_all_txt = range(num_txt)  # 范围 range(0, num)
    
        num_train = int(num_txt * train_percent)
        num_val = int(num_txt * val_percent)
        num_test = num_txt - num_train - num_val
    
        train = random.sample(list_all_txt, num_train)
        # train从list_all_txt取出num_train个元素
        # 所以list_all_txt列表只剩下了这些元素:val_test
        val_test = [i for i in list_all_txt if not i in train]
        # 再从val_test取出num_val个元素,val_test剩下的元素就是test
        val = random.sample(val_test, num_val)
        # 检查两个列表元素是否有重合的元素
        # set_c = set(val_test) & set(val)
        # list_c = list(set_c)
        # print(list_c)
        # print(len(list_c))
    
        print("训练集数目:{}, 验证集数目:{},测试集数目:{}".format(len(train), len(val), len(val_test) - len(val)))
        for i in list_all_txt:
            name = total_txt[i][:-4]
    
            srcImage = image_original_path + name + '.jpg'
            srcLabel = label_original_path + name + '.txt'
    
            if i in train:
                dst_train_Image = train_image_path + name + '.jpg'
                dst_train_Label = train_label_path + name + '.txt'
                shutil.copyfile(srcImage, dst_train_Image)
                shutil.copyfile(srcLabel, dst_train_Label)
            elif i in val:
                dst_val_Image = val_image_path + name + '.jpg'
                dst_val_Label = val_label_path + name + '.txt'
                shutil.copyfile(srcImage, dst_val_Image)
                shutil.copyfile(srcLabel, dst_val_Label)
            else:
                dst_test_Image = test_image_path + name + '.jpg'
                dst_test_Label = test_label_path + name + '.txt'
                shutil.copyfile(srcImage, dst_test_Image)
                shutil.copyfile(srcLabel, dst_test_Label)
    
    
    if __name__ == '__main__':
        main()
    
    
    
    

    下面这个代码仅仅将每个数据的名字划分成训练集、验证集和测试集,上面那个会将图片和标注文件分别放到不同的文件夹。

    这里是贴的B站一个博主的.py文件—Bubbliiiing!!这个博主人超好的

    import os
    import random
    import xml.etree.ElementTree as ET
    
    from utils.utils import get_classes
    
    #--------------------------------------------------------------------------------------------------------------------------------#
    #   annotation_mode用于指定该文件运行时计算的内容
    #   annotation_mode为0代表整个标签处理过程,包括获得VOCdevkit/VOC2007/ImageSets里面的txt以及训练用的2007_train.txt、2007_val.txt
    #   annotation_mode为1代表获得VOCdevkit/VOC2007/ImageSets里面的txt
    #   annotation_mode为2代表获得训练用的2007_train.txt、2007_val.txt
    #--------------------------------------------------------------------------------------------------------------------------------#
    annotation_mode     = 0
    #-------------------------------------------------------------------#
    #   必须要修改,用于生成2007_train.txt、2007_val.txt的目标信息
    #   与训练和预测所用的classes_path一致即可
    #   如果生成的2007_train.txt里面没有目标信息
    #   那么就是因为classes没有设定正确
    #   仅在annotation_mode为0和2的时候有效
    #-------------------------------------------------------------------#
    classes_path = 'model_data/voc_classes.txt'  # 类别名称,例如person,cat,dog等等
    #--------------------------------------------------------------------------------------------------------------------------------#
    #   trainval_percent用于指定(训练集+验证集)与测试集的比例,默认情况下 (训练集+验证集):测试集 = 9:1 
    #   train_percent用于指定(训练集+验证集)中训练集与验证集的比例,默认情况下 训练集:验证集 = 9:1 
    #   仅在annotation_mode为0和1的时候有效
    #--------------------------------------------------------------------------------------------------------------------------------#
    trainval_percent = 0.9
    train_percent = 0.9
    #-------------------------------------------------------#
    #   指向VOC数据集所在的文件夹
    #   默认指向根目录下的VOC数据集
    #-------------------------------------------------------#
    VOCdevkit_path = 'VOCdevkit'
    
    VOCdevkit_sets = [('2007', 'train'), ('2007', 'val')]
    classes, _  = get_classes(classes_path)
    
    def convert_annotation(year, image_id, list_file):
        in_file = open(os.path.join(VOCdevkit_path, 'VOC%s/Annotations/%s.xml'%(year, image_id)), encoding='utf-8')
        tree=ET.parse(in_file)
        root = tree.getroot()
    
        for obj in root.iter('object'):
            difficult = 0 
            if obj.find('difficult')!=None:
                difficult = obj.find('difficult').text
            cls = obj.find('name').text
            if cls not in classes or int(difficult)==1:
                continue
            cls_id = classes.index(cls)
            xmlbox = obj.find('bndbox')
            b = (int(float(xmlbox.find('xmin').text)), int(float(xmlbox.find('ymin').text)), int(float(xmlbox.find('xmax').text)), int(float(xmlbox.find('ymax').text)))
            list_file.write(" " + ",".join([str(a) for a in b]) + ',' + str(cls_id))
            
    if __name__ == "__main__":
        random.seed(0)
        if annotation_mode == 0 or annotation_mode == 1:
            print("Generate txt in ImageSets.")
            xmlfilepath = os.path.join(VOCdevkit_path, 'VOC2007/Annotations')
            saveBasePath = os.path.join(VOCdevkit_path, 'VOC2007/ImageSets/Main')
            temp_xml = os.listdir(xmlfilepath)
            total_xml = []
            for xml in temp_xml:
                if xml.endswith(".xml"):
                    total_xml.append(xml)
    
            num = len(total_xml)  
            list = range(num)  
            tv = int(num*trainval_percent)  
            tr = int(tv*train_percent)  
            trainval = random.sample(list,tv)  
            train = random.sample(trainval,tr)  
            
            print("train and val size",tv)
            print("train size",tr)
            ftrainval = open(os.path.join(saveBasePath,'trainval.txt'), 'w')  
            ftest = open(os.path.join(saveBasePath,'test.txt'), 'w')  
            ftrain = open(os.path.join(saveBasePath,'train.txt'), 'w')  
            fval = open(os.path.join(saveBasePath,'val.txt'), 'w')  
            
            for i in list:  
                name=total_xml[i][:-4]+'\n'  
                if i in trainval:  
                    ftrainval.write(name)  
                    if i in train:  
                        ftrain.write(name)  
                    else:  
                        fval.write(name)  
                else:  
                    ftest.write(name)  
            
            ftrainval.close()  
            ftrain.close()  
            fval.close()  
            ftest.close()
            print("Generate txt in ImageSets done.")
    
        if annotation_mode == 0 or annotation_mode == 2:
            print("Generate 2007_train.txt and 2007_val.txt for train.")
            for year, image_set in VOCdevkit_sets:
                image_ids = open(os.path.join(VOCdevkit_path, 'VOC%s/ImageSets/Main/%s.txt'%(year, image_set)), encoding='utf-8').read().strip().split()
                list_file = open('%s_%s.txt'%(year, image_set), 'w', encoding='utf-8')
                for image_id in image_ids:
                    list_file.write('%s/VOC%s/JPEGImages/%s.jpg'%(os.path.abspath(VOCdevkit_path), year, image_id))
    
                    convert_annotation(year, image_id, list_file)
                    list_file.write('\n')
                list_file.close()
            print("Generate 2007_train.txt and 2007_val.txt for train done.")
    
    
    展开全文
  • 今天用一个实例给大家写写在机器学习中如何进行训练集和测试集划分。实例操练首先导入今天要使用的数据集import pandas as pddf = pd.read_csv("carprices.csv")df.head()这是一个汽车销售的数据集,里面的变量...

    今天用一个实例给大家写写在机器学习中如何进行训练集和测试集的划分。

    实例操练

    首先导入今天要使用的数据集

    import pandas as pddf = pd.read_csv("carprices.csv")df.head()

    20200703035239_aaca1e8d21d98d3dfd647410cde33547_1.jpeg

    这是一个汽车销售的数据集,里面的变量包括汽车里程、使用年限、销售价格。我们今天要做的就是用汽车里程、使用年限来建立一个预测销售价格的机器学习模型。

    首先,我们画图看一看数据关系

    import matplotlib.pyplot as pltplt.scatter(df['Mileage'],df['Sell Price($)'])plt.scatter(df['Age(yrs)'],df['Sell Price($)'])

    运行以上代码可以出2个点图,分别展示汽车里程和销售价格的关系和使用年限和销售价格的关系。

    20200703035239_aaca1e8d21d98d3dfd647410cde33547_2.jpeg

    使用年限和销售价格的关系散点图

    20200703035239_aaca1e8d21d98d3dfd647410cde33547_3.jpeg

    汽车里程和销售价格的关系散点图

    通过两个散点图,我们可以发现使用线性回归模型进行建模还是比较好的方法,现在我们就要进行训练集和测试集的划分了

    训练集 用来训练模型,估计参数

    测试集 用来测试和评估训练出来的模型好坏,不能用于训练模型

    划分数据集实操

    首先我们要指定数据和数据标签

    X = df[['Mileage','Age(yrs)']]y = df['Sell Price($)']

    在本例中,数据集为汽车里程和使用年限构成的数据框,标签为汽车价格。

    然后我们用train_test_split方法分割数据为训练集和测试集,代码如下

    from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)

    讲解一下train_test_split的参数:

    train_test_split的基本形式如下

    X_train,X_test, y_train, y_test =sklearn.model_selection.train_test_split(train_data,train_target,test_size=0.4, random_state=0,stratify=y_train)

    其中

    train_data:所要划分的样本特征集

    train_target:所要划分的样本结果

    test_size:样本占比,如果是整数的话就是样本的数量

    random_state:是随机数的种子,在需要重复试验的时候,保证得到一组一样的随机数

    stratify是为了保持split前类的分布,通常在类分布不平衡的情况下会用到stratify

    在我们的例子中,我们只给出了test_size=0.3,所以我们按照7:3划分得到了训练集和测试集,而且这个划分是随机的。我们可以看一看训练数据长啥样

    X_trainy_train

    以上代码可以分别输出训练集的数据和标签。

    建立线性回归模型

    from sklearn.linear_model import LinearRegressionclf = LinearRegression()clf.fit(X_train, y_train)

    通过以上代码我们便建立了回归模型,运用此模型我们可以进行对X_test的预测

    clf.predict(X_test)

    然后,我们将模型预测值和实际的y_test值进行对比可以得到模型正确率。

    clf.score(X_test, y_test)

    20200703035239_aaca1e8d21d98d3dfd647410cde33547_4.jpeg

    可以看到,我们训练的线性回归模型的正确率达到90%多。

    展开全文
  • 本节主要介绍了训练集和测试集划分、交叉验证的各种方法以及代码实现。

    目录

    4.1Python代码实现划分训练集和测试集

    4.2 交叉验证

    4.2.1 交叉验证提出的目的       

    4.2.2 留一交叉验证 

     4.2.3 K-折交叉验证

     4.2.3.1 重复随机子抽样验证

    4.2.4 嵌套交叉验证

    4.2.4.1 k*l 折交叉验证

    4.2.4.2 带有验证和测试集的 k 折交叉验证

    4.2.4.3 拟合度量

    4.2.4.4 时间序列模型的交叉验证    

    4.2.5 应用

    4.2.6 Python代码实现K-折交叉验证数据集划


     4.1Python代码实现划分训练集和测试集

              伪随机函数介绍网站:https://docs.python.org/3/library/random.html。 

    # 导入库
    from random import seed # 用于固定每次生成的随机数都是确定的(伪随机数)
    from random import randrange # 用于生成随机数
    
    def train_test_split(dataset,train=0.6):
        """
        该函数用于划分训练集和测试集
        Parameters
        ----------
        dataset : 二维列表
            传入需要划分成训练集和测试集的数据集.
        train : 浮点数
            传入训练集占整个数据集的比例.默认是0.6.
    
        Returns
        -------
        train_basket : 二维列表
            划分好的训练集.
        dataset_copy : 二维列表
            划分好的测试集.
        """
        # 创建一个空列表用于存放后面划分好的训练集
        train_basket = list()
        # 根据输入的训练集的比例计算出训练集的大小(样本数量)
        train_size = train*len(dataset)
        # 复制出一个新的数据集来做切分,从而不改变原始的数据集
        dataset_copy = list(dataset)
        # 执行循环判断,如果训练集的大小小于所占的比例,就一直往训练集里添加数据
        while len(train_basket) < train_size:
            # 通过randrange()函数随机产生训练集的索引
            random_choose = randrange(len(dataset_copy))
            # 根据上面生成的训练集的索引将数据集中的样本加到train_basket中
            # 注意pop函数会根据索引将数据集中的样本给移除,所以循环结束之后剩下的样本就是测试集
            train_basket.append(dataset_copy.pop(random_choose))
        return train_basket,dataset_copy
    
    
    # 主函数
    if '__main__' == __name__:
        # 定义一个随机种子,使得每次生成的随机数都是确定的(伪随机数)
        seed(666)
        dataset = [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10]]
        # 调用手动编写的train_test_split函数划分训练集和测试集
        train,test = train_test_split(dataset)

    4.2 交叉验证

            有关交叉验证的网站介绍:https://en.wikipedia.org/wiki/Cross-validation_(statistics)#k-fold_cross-validation(注:下面的一些图片转载自该网站,并非原创)。

            交叉验证[2] [3] [4]有时称为旋转估计[5] [6] [7]样本外测试,其是一种重采样方法,它使用数据的不同部分在不同的迭代中测试和训练模型。在预测问题中,通常给模型一个已知数据集(训练数据集)和一个用于测试模型的未知数据集(或首次看到的数据)(称为验证数据集测试)[8] [9]交叉验证的目标是测试模型预测新数据的能力,以标记过度拟合选择偏差等问题[10]并深入了解模型将如何推广到独立数据集(即未知数据集,例如来自实际问题)。一轮交叉验证涉及将数据样本划分互补子集,对一个子集(称为训练集)执行分析,并在另一个子集(称为验证集测试集)上验证分析。为了减少可变性,在大多数方法中,使用不同的分区执行多轮交叉验证,并将验证结果在各轮中组合(例如求平均准确率)以估计模型的预测性能。总之,交叉验证在预测中结合平均准确率,以得出更准确的模型预测性能。[11]

    图1 比较五种分类模型的交叉验证准确率和假阴性(高估)百分比。气泡大小代表交叉验证准确度的标准偏差(十倍)  

    4.2.1 交叉验证提出的目的       

            假设一个模型具有一个或多个未知参数,以及一个模型可以拟合的数据集(训练数据集)。拟合过程优化模型参数,使模型尽可能地拟合训练数据。如果从与训练数据相同的群体中获取独立的验证数据样本,通常会证明该模型不适合验证数据而适合训练数据。这种差异的大小可能很大,尤其是当训练数据集的大小很小,或者模型中的参数数量很大时。交叉验证是一种估计这种影响大小的方法。在线性回归中,存在实际目标 y 1, ..., y n,和向量  x 1 , ..., n。向量i的分量表示为i 1 , ..., ip。如果使用最小二乘法以超平面 ŷ = a + β T x的形式将函数拟合到数据 ( i , yi )  1 ≤  i  ≤  n,则可以使用均方误差(MSE) 评估拟合。训练集 ( x i , y i )  1 ≤  i  ≤  n上给定估计参数值aβ的 MSE定义为:

     图2 均方误差公式

            交叉验证可以用于检查模型是否已经过拟合,在这种情况下,验证集中的 MSE 将大大超过其预期值。(线性回归中的交叉验证也很有用,因为它可以用来选择最优的正则化 成本函数)在大多数其他回归过程中(例如逻辑回归),没有简单的公式来计算预期的样本外拟合。因此,交叉验证是一种普遍适用的方法,可以使用数值计算代替理论分析来预测模型在不可用数据上的性能。

    4.2.2 留一交叉验证 

    图3 当 n = 8 个样本时,留一法交叉验证 (LOOCV) 的说明。总共将训练和测试 8 个模型

     4.2.3 K-折交叉验证

            在k折交叉验证中,原始样本被随机划分为k个大小相等的子样本。在k个子样本中,保留一个子样本作为验证数据用于测试模型,剩余的k -1 个子样本用作训练数据。然后交叉验证过程重复k次,k个子样本中的每个子样本只使用一次作为验证数据。然后可以对结果进行平均以产生单个估计。这种方法相对于重复的随机子抽样的优势在于,所有样本都用于训练和验证,并且每个样本只用于验证一次。通常使用10折交叉验证,[16]但一般来说,k仍然是一个不固定的参数。

            例如,设置k = 2则是 2 折交叉验证。在 2 折交叉验证中,我们将数据集随机打乱为两个集合0和1,使两个集合大小相等(这通常通过打乱数据数组然后将其一分为二来实现)。然后我们在0上进行训练并在1上进行验证,然后在1上进行训练并在0上进行验证 。k = n(样本次数)时,k折交叉验证等效于留一法交叉验证。[17]

            在分层 k折交叉验证中,选择分区以使平均响应值在所有分区中大致相等。在二分类的情况下,这意味着每个分区包含大致相同比例的两种类别标签。重复的交叉验证中,数据被随机分成k个分区多次。因此,模型的性能可以在多次运行中取平均值,但这在实践中很少需要。[18]

    图4 K-折交叉验证图

    图5 当 n = 12 个观测值和 k = 3 时的 k 折交叉验证图示。数据打乱后,总共将训练和测试 3 个模型。

     4.2.3.1 重复随机子抽样验证

            这种方法,也称为蒙特卡罗交叉验证,[21]将数据集的多个随机拆分为训练和验证数据。[22]对于每个这样的拆分,模型都适合训练数据,并使用验证数据评估预测准确性。然后在拆分上平均结果。这种方法的优点(超过k折交叉验证)是训练/验证拆分的比例不依赖于迭代次数(即分区数)。这种方法的缺点是某些样本可能永远不会在验证子样本中被选择,而其他样本可能会被多次选择。换句话说,验证子集可能重叠。该方法还展示了蒙特卡罗变异,这意味着如果使用不同的随机拆分重复分析,结果会有所不同。随着随机分裂的数量接近无穷大,重复随机子抽样验证的结果趋向于留出交叉验证的结果。在这种方法的分层变体中,随机样本的生成方式使得平均响应值(即回归中的因变量)在训练和测试集中相等。如果响应是二分法且数据中两个响应值的表示不平衡,这将特别有用。一种应用重复随机子采样的方法是RANSAC[23]

    4.2.4 嵌套交叉验证

            当交叉验证同时用于选择最佳超参数集和误差估计(和泛化能力评估)时,需要嵌套交叉验证。存在许多变体。至少可以区分两种变体:

    4.2.4.1 k*l 折交叉验证

            这是一个真正嵌套的变体,包含k个集合的外循环和l个集合的内循环。整个数据集被分成k个集合。一个接一个地选择一个集合作为(外)测试集,将其他k -1个集合组合成对应的外训练集。这对k个集合中的每一个重复。每个外部训练集进一步细分为l个集合。一个接一个地选择一个集合作为内部测试(验证)集,并将其他l -1 个集合组合成相应的内部训练集。这对每个l重复套。内部训练集用于拟合模型参数,而外部测试集用作验证集以提供模型拟合的无偏评估。通常,这会针对许多不同的超参数(甚至不同的模型类型)重复,并且验证集用于确定该内部训练集的最佳超参数集(和模型类型)。在此之后,使用来自内部交叉验证的最佳超参数集,在整个外部训练集上拟合一个新模型。然后使用外部测试集评估该模型的性能。

    4.2.4.2 带有验证和测试集的 k 折交叉验证

            当l = k - 1时,这是一种 k*l 折交叉验证 。单个 k 折交叉验证与验证集和测试集一起使用。整个数据集被分成k个集合。一个一个地选择一个集合作为测试集。然后,一个接一个,剩余的一组作为验证集,另一个k- 2 个集合用作训练集,直到所有可能的组合都被评估。与 k*l 折交叉验证类似,训练集用于模型拟合,验证集用于每个超参数集的模型评估。最后,对于选定的参数集,使用测试集来评估具有最佳参数集的模型。在这里,可能有两种变体:要么评估在训练集上训练的模型,要么评估适合训练集和验证集组合的新模型。

    4.2.4.3 拟合度量

            交叉验证的目标是估计模型与数据集的预期拟合程度,该数据集独立于用于训练模型的数据。它可用于估计适合数据和模型的任何定量拟合测量。例如,对于二分类问题,验证集中的每个案例要么被正确预测,要么被错误预测。在这种情况下,可以使用错误分类错误率来总结拟合,尽管也可以使用其他度量,如阳性预测值。当被预测的值连续分布时,均方误差均方根误差中值绝对偏差可以用来总结错误。

    4.2.4.4 时间序列模型的交叉验证    

            由于数据的顺序很重要,交叉验证可能对时间序列模型有问题。更合适的方法是使用滚动交叉验证。[31]但是,如果性能由单个汇总统计量描述,则 Politis 和 Romano 将其描述为固定引导
    [32]的方法可能会起作用。bootstrap 的统计量需要接受时间序列的一个区间,并返回关于它的汇总统计量。对固定引导程序的调用需要指定适当的平均间隔长度。

    4.2.5 应用

            交叉验证可用于比较不同预测建模程序的性能。例如,假设我们对光学字符识别感兴趣,并且我们正在考虑使用支持向量机(SVM) 或k最近邻(KNN) 从手写字符的图像中预测真实字符。使用交叉验证,我们可以客观地比较这两种方法各自的错误分类字符分数。如果我们简单地根据样本内错误率比较这些方法,那么一种方法可能会表现得更好,因为它更灵活,因此更容易过度拟合与其他方法相比。

            交叉验证也可用于变量选择[33]假设我们使用20 种蛋白质的表达水平来预测癌症患者是否会对药物产生反应。一个实际的目标是确定应该使用 20 个特征中的哪个子集来生成最佳预测模型。对于大多数建模过程,如果我们使用样本内错误率比较特征子集,则当使用所有 20 个特征时,性能最佳。然而,在交叉验证下,具有最佳拟合的模型通常只包含被认为是真正有用的特征的一个子集。

            医学统计学的最新发展是它在荟萃分析中的应用。它构成了验证统计量 Vn 的基础,Vn 用于测试荟萃分析汇总估计的统计有效性。[34] 

     4.2.6 Python代码实现K-折交叉验证数据集划分

    # 导入库
    from random import seed # 用于固定每次生成的随机数都是确定的(伪随机数)
    from random import randrange # 用于生成随机数
    
    def k_fold_cross_validation_split(dataset,folds=10):
        """
        该函数用于将数据集执行K-折交叉验证的划分
        Parameters
        ----------
        dataset : 二维列表
            传入需要划分交叉验证的数据集.
        folds : 整型, 可选
            传入交叉验证的折数. 默认是10.
    
        Returns
        -------
        basket_split_data : 三维列表
           存放的是划分好的交叉验证的数据集,三维列表里的每一个二维列表就代表了划分出的一部分样本.
    
        """
        # 定义一个空列表,用于存放划分好的数据集
        basket_split_data = list()
        # 计算每一折里的样本数
        fold_size = int(len(dataset)/folds)
        # 复制出一个新的数据集来做划分,从而不改变原始的数据集
        dataset_copy = list(dataset)
        # 按照需要划分的折数来循环遍历提取 
        for i in range(folds):
            # 定义一个空列表用于存放每一折里的样本数
            basket_random_fold = list()
            # 开始遍历,只要每一折里的样本数小于fold_size,就一直往里面添加数据
            while len(basket_random_fold) < fold_size:
                # 通过randrange()函数随机产生索引
                random_choose_index = randrange(len(dataset_copy))
                # 根据上面生成的随机索引将数据集中的样本加到basket_random_fold中
                basket_random_fold.append(dataset_copy.pop(random_choose_index))
            # 每一折的样本数添加好后,再将其加入到basket_split_data,此变量用于存放后续划分好的所有数据集
            basket_split_data.append(basket_random_fold)
        return basket_split_data
    
    # 主函数
    if '__main__' == __name__:
        # 定义一个随机种子,使得每次生成的随机数都是确定的(伪随机数)
        seed(1)
        dataset = [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10]]
        # 调用手动编写的k_fold_cross_validation_split函数来实现K-折交叉验证数据集的划分
        k_folds_split = k_fold_cross_validation_split(dataset,3)
    展开全文
  • Python划分训练集和测试集小脚本

    千次阅读 2022-04-03 10:21:51
    将数据集划分训练集,测试集 """ import os import random import shutil import math # 创建保存图像的文件夹 def makedir(new_dir): if not os.path.exists(new_dir): os.makedirs(new_dir) random.seed...
  • 众所周知,将一个数据集只区分为训练集和验证集是不行的,还需要有测试集,本博文针对上一篇没有分出测试集的不足,重新划分数据集 直接上代码: #split_data.py #划分数据集flower_data,数据集划分到flower_datas...
  • 数据集的划分以及训练集、验证集和测试集的具体含义.html
  • 有了训练集和测试集,但是没有验证集,只能从训练集中划分 20% 作为验证集,剩下的 80% 作为训练集。 我的划分前的训练集中包含 png 格式图像和 json 格式的标签,需要新建训练集和验证集文件夹,并分别将图像和...
  • 使用python编写程序将数据集划分训练集和测试集
  • 随机划分训练集和测试集python代码

    千次阅读 2022-02-12 21:38:03
    本程序是随机划分训练集和测试集的 """ import os import random import shutil def howmuch(path): sum =0 for i in os.listdir(path): sum+=1 return sum def move(src,dst,number): #随机生成要移动的...
  • ' % class_name) time_end = time.time() print('---------------') print('训练集和测试集划分共耗时%s!' % (time_end - time_start)) 转载:https://www.cnblogs.com/rs-xiaosheng/p/12371709.html
  • X, y = data[:,:-1],data[:,-1] #【利用train_test_split方法,将X,y随机划分训练集(X_train),训练集标签(y_train),测试集(X_test),测试集标签(y_test),按训练集:测试集=7:3的概率划分,到此步骤,...
  • > 步骤回顾 > 1. pandas导入数据 > 2. 自变量和因变量分离 > 3. 缺失值处理 > 4. 字符串变成数字 > 5. 划分训练集和测试集 > 6. 特征缩放
  • 在很多python任务中,我们需要将原始数据进行处理,分成训练集和测试集,以便更深层次的运用这些数据。工具/原料pycharmpython3.7win10/7方法/步骤1首先需要指定编码方式为【utf8】格式,再导入处理数据的包-pandas2...
  • 如何利用python将txt文件划分训练集和测试集“按照8:2的比例对项目分出训练集和测试集”:从数据源中随机抽取80%的数据作为“训练集”,其余的是“测试集” import randomwith open("datasource.txt", 'rt') as ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,373
精华内容 12,149
关键字:

python划分训练和测试集