交叉验证_交叉验证法 - CSDN
交叉验证 订阅
交叉验证(Cross-validation)主要用于建模应用中,例如PCR、PLS回归建模中。在给定的建模样本中,拿出大部分样本进行建模型,留小部分样本用刚建立的模型进行预报,并求这小部分样本的预报误差,记录它们的平方加和。 展开全文
交叉验证(Cross-validation)主要用于建模应用中,例如PCR、PLS回归建模中。在给定的建模样本中,拿出大部分样本进行建模型,留小部分样本用刚建立的模型进行预报,并求这小部分样本的预报误差,记录它们的平方加和。
信息
外文名
Cross validation
特    点
PCR 、PLS 回归建模中
中文名
交叉验证
实    质
建模应用中
交叉验证思想介绍
在使用训练集对参数进行训练的时候,经常会发现人们通常会将一整个训练集分为三个部分(比如mnist手写训练集)。一般分为:训练集(train_set),评估集(valid_set),测试集(test_set)这三个部分。这其实是为了保证训练效果而特意设置的。其中测试集很好理解,其实就是完全不参与训练的数据,仅仅用来观测测试效果的数据。而训练集和评估集则牵涉到下面的知识了。因为在实际的训练中,训练的结果对于训练集的拟合程度通常还是挺好的(初始条件敏感),但是对于训练集之外的数据的拟合程度通常就不那么令人满意了。因此我们通常并不会把所有的数据集都拿来训练,而是分出一部分来(这一部分不参加训练)对训练集生成的参数进行测试,相对客观的判断这些参数对训练集之外的数据的符合程度。这种思想就称为交叉验证(Cross Validation) [1]  。
收起全文
精华内容
参与话题
  • 全栈工程师开发手册 (作者:栾鹏) python数据挖掘系列教程 学习预测函数的参数,并在相同数据集上进行测试是一种错误的做法: 一个仅给出测试用例标签的模型将会获得极高的分数,但对于尚未出现过的数据它则...

    分享一个朋友的人工智能教程。零基础!通俗易懂!风趣幽默!还带黄段子!大家可以看看是否对自己有帮助:点击打开

    docker/kubernetes入门视频教程


    全栈工程师开发手册 (作者:栾鹏)
    python数据挖掘系列教程

    学习预测函数的参数,并在相同数据集上进行测试是一种错误的做法: 一个仅给出测试用例标签的模型将会获得极高的分数,但对于尚未出现过的数据它则无法预测出任何有用的信息。 这种情况称为 overfitting(过拟合). 为了避免这种情况,在进行(监督)机器学习实验时,通常取出部分可利用数据作为 test set(测试数据集) X_test, y_test。

    利用 scikit-learn 包中的 train_test_split 辅助函数可以很快地将实验数据集划分为任何训练集(training sets)和测试集(test sets)。

    计算交叉验证的指标

    使用交叉验证最简单的方法是在估计器和数据集上调用 cross_val_score 辅助函数。

    保留数据的数据转换

    正如在训练集中保留的数据上测试一个 predictor (预测器)是很重要的一样,预处理(如标准化,特征选择等)和类似的 data transformations 也应该从训练集中学习,并应用于预测数据以进行预测

    cross_validate 函数和多度量评估

    cross_validate 函数与 cross_val_score 在下面的两个方面有些不同 -

    • 它允许指定多个指标进行评估.
    • 除了测试得分之外,它还会返回一个包含训练得分,拟合次数, score-times (得分次数)的一个字典。

    交叉验证迭代器

    K折交叉验证KFold 将所有的样例划分为 k 个组,称为折叠 (fold) (如果 k = n, 这等价于 Leave One Out(留一) 策略),都具有相同的大小(如果可能)。预测函数学习时使用 k - 1 个折叠中的数据,最后一个剩下的折叠会用于测试。

    K折重复多次RepeatedKFold 重复 K-Fold n 次。当需要运行时可以使用它 KFold n 次,在每次重复中产生不同的分割。

    留一交叉验证LeaveOneOut (或 LOO) 是一个简单的交叉验证。每个学习集都是通过除了一个样本以外的所有样本创建的,测试集是被留下的样本。 因此,对于 n 个样本,我们有 n 个不同的训练集和 n 个不同的测试集。这种交叉验证程序不会浪费太多数据,因为只有一个样本是从训练集中删除掉的:

    留P交叉验证LeavePOut 与 LeaveOneOut 非常相似,因为它通过从整个集合中删除 p 个样本来创建所有可能的 训练/测试集。对于 n 个样本,这产生了 {n \choose p} 个 训练-测试 对。与 LeaveOneOut 和 KFold 不同,当 p > 1 时,测试集会重叠。

    用户自定义数据集划分ShuffleSplit 迭代器将会生成一个用户给定数量的独立的训练/测试数据划分。样例首先被打散然后划分为一对训练测试集合。

    设置每次生成的随机数相同: 可以通过设定明确的 random_state ,使得伪随机生成器的结果可以重复。

    基于类标签、具有分层的交叉验证迭代器

    如何解决样本不平衡问题? 使用StratifiedKFold和StratifiedShuffleSplit 分层抽样。 一些分类问题在目标类别的分布上可能表现出很大的不平衡性:例如,可能会出现比正样本多数倍的负样本。在这种情况下,建议采用如 StratifiedKFold 和 StratifiedShuffleSplit 中实现的分层抽样方法,确保相对的类别频率在每个训练和验证 折叠 中大致保留。

    StratifiedKFold 是 k-fold 的变种,会返回 stratified(分层) 的折叠:每个小集合中, 各个类别的样例比例大致和完整数据集中相同。

    StratifiedShuffleSplit 是 ShuffleSplit 的一个变种,会返回直接的划分,比如: 创建一个划分,但是划分中每个类的比例和完整数据集中的相同。

    用于分组数据的交叉验证迭代器

    如何进一步测试模型的泛化能力? **留出一组特定的不属于测试集和训练集的数据。**有时我们想知道在一组特定的 groups 上训练的模型是否能很好地适用于看不见的 group 。为了衡量这一点,我们需要确保验证对象中的所有样本来自配对训练折叠中完全没有表示的组。

    GroupKFold 是 k-fold 的变体,它确保同一个 group 在测试和训练集中都不被表示。 例如,如果数据是从不同的 subjects 获得的,每个 subject 有多个样本,并且如果模型足够灵活以高度人物指定的特征中学习,则可能无法推广到新的 subject 。 GroupKFold 可以检测到这种过拟合的情况。

    LeaveOneGroupOut 是一个交叉验证方案,它根据第三方提供的 array of integer groups (整数组的数组)来提供样本。这个组信息可以用来编码任意域特定的预定义交叉验证折叠。

    每个训练集都是由除特定组别以外的所有样本构成的。

    LeavePGroupsOut 类似于 LeaveOneGroupOut ,但为每个训练/测试集删除与 P 组有关的样本。

    GroupShuffleSplit 迭代器是 ShuffleSplit 和 LeavePGroupsOut 的组合,它生成一个随机划分分区的序列,其中为每个分组提供了一个组子集。

    时间序列分割

    TimeSeriesSplit 是 k-fold 的一个变体,它首先返回 k 折作为训练数据集,并且 (k+1) 折作为测试数据集。 请注意,与标准的交叉验证方法不同,连续的训练集是超越前者的超集。 另外,它将所有的剩余数据添加到第一个训练分区,它总是用来训练模型。

    这个类可以用来交叉验证以固定时间间隔观察到的时间序列数据样本。

    代码实现

    from sklearn.model_selection import train_test_split,cross_val_score,cross_validate # 交叉验证所需的函数
    from sklearn.model_selection import KFold,LeaveOneOut,LeavePOut,ShuffleSplit # 交叉验证所需的子集划分方法
    from sklearn.model_selection import StratifiedKFold,StratifiedShuffleSplit # 分层分割
    from sklearn.model_selection import GroupKFold,LeaveOneGroupOut,LeavePGroupsOut,GroupShuffleSplit # 分组分割
    from sklearn.model_selection import TimeSeriesSplit # 时间序列分割
    from sklearn import datasets  # 自带数据集
    from sklearn import svm  # SVM算法
    from sklearn import preprocessing  # 预处理模块
    from sklearn.metrics import recall_score  # 模型度量
    
    iris = datasets.load_iris()  # 加载数据集
    print('样本集大小:',iris.data.shape,iris.target.shape)
    
    # ===================================数据集划分,训练模型==========================
    X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)  # 交叉验证划分训练集和测试集.test_size为测试集所占的比例
    print('训练集大小:',X_train.shape,y_train.shape)  # 训练集样本大小
    print('测试集大小:',X_test.shape,y_test.shape)  # 测试集样本大小
    clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train) # 使用训练集训练模型
    print('准确率:',clf.score(X_test, y_test))  # 计算测试集的度量值(准确率)
    
    
    #  如果涉及到归一化,则在测试集上也要使用训练集模型提取的归一化函数。
    scaler = preprocessing.StandardScaler().fit(X_train)  # 通过训练集获得归一化函数模型。(也就是先减几,再除以几的函数)。在训练集和测试集上都使用这个归一化函数
    X_train_transformed = scaler.transform(X_train)
    clf = svm.SVC(kernel='linear', C=1).fit(X_train_transformed, y_train) # 使用训练集训练模型
    X_test_transformed = scaler.transform(X_test)
    print(clf.score(X_test_transformed, y_test))  # 计算测试集的度量值(准确度)
    
    # ===================================直接调用交叉验证评估模型==========================
    clf = svm.SVC(kernel='linear', C=1)
    scores = cross_val_score(clf, iris.data, iris.target, cv=5)  #cv为迭代次数。
    print(scores)  # 打印输出每次迭代的度量值(准确度)
    print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))  # 获取置信区间。(也就是均值和方差)
    
    # ===================================多种度量结果======================================
    scoring = ['precision_macro', 'recall_macro'] # precision_macro为精度,recall_macro为召回率
    scores = cross_validate(clf, iris.data, iris.target, scoring=scoring,cv=5, return_train_score=True)
    sorted(scores.keys())
    print('测试结果:',scores)  # scores类型为字典。包含训练得分,拟合次数, score-times (得分次数)
    
    
    # ==================================K折交叉验证、留一交叉验证、留p交叉验证、随机排列交叉验证==========================================
    # k折划分子集
    kf = KFold(n_splits=2)
    for train, test in kf.split(iris.data):
        print("k折划分:%s %s" % (train.shape, test.shape))
        break
    
    # 留一划分子集
    loo = LeaveOneOut()
    for train, test in loo.split(iris.data):
        print("留一划分:%s %s" % (train.shape, test.shape))
        break
    
    # 留p划分子集
    lpo = LeavePOut(p=2)
    for train, test in loo.split(iris.data):
        print("留p划分:%s %s" % (train.shape, test.shape))
        break
    
    # 随机排列划分子集
    ss = ShuffleSplit(n_splits=3, test_size=0.25,random_state=0)
    for train_index, test_index in ss.split(iris.data):
        print("随机排列划分:%s %s" % (train.shape, test.shape))
        break
    
    # ==================================分层K折交叉验证、分层随机交叉验证==========================================
    skf = StratifiedKFold(n_splits=3)  #各个类别的比例大致和完整数据集中相同
    for train, test in skf.split(iris.data, iris.target):
        print("分层K折划分:%s %s" % (train.shape, test.shape))
        break
    
    skf = StratifiedShuffleSplit(n_splits=3)  # 划分中每个类的比例和完整数据集中的相同
    for train, test in skf.split(iris.data, iris.target):
        print("分层随机划分:%s %s" % (train.shape, test.shape))
        break
    
    
    # ==================================组 k-fold交叉验证、留一组交叉验证、留 P 组交叉验证、Group Shuffle Split==========================================
    X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 8.8, 9, 10]
    y = ["a", "b", "b", "b", "c", "c", "c", "d", "d", "d"]
    groups = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3]
    
    # k折分组
    gkf = GroupKFold(n_splits=3)  # 训练集和测试集属于不同的组
    for train, test in gkf.split(X, y, groups=groups):
        print("组 k-fold分割:%s %s" % (train, test))
    
    # 留一分组
    logo = LeaveOneGroupOut()
    for train, test in logo.split(X, y, groups=groups):
        print("留一组分割:%s %s" % (train, test))
    
    # 留p分组
    lpgo = LeavePGroupsOut(n_groups=2)
    for train, test in lpgo.split(X, y, groups=groups):
        print("留 P 组分割:%s %s" % (train, test))
    
    # 随机分组
    gss = GroupShuffleSplit(n_splits=4, test_size=0.5, random_state=0)
    for train, test in gss.split(X, y, groups=groups):
        print("随机分割:%s %s" % (train, test))
    
    
    # ==================================时间序列分割==========================================
    tscv = TimeSeriesSplit(n_splits=3)
    TimeSeriesSplit(max_train_size=None, n_splits=3)
    for train, test in tscv.split(iris.data):
        print("时间序列分割:%s %s" % (train, test))
    
    展开全文
  • 交叉验证(简单交叉验证、k折交叉验证、留一法)

    万次阅读 多人点赞 2016-05-11 11:57:50
    文章介绍了三种交叉验证的方法,在做分类时很常用。

    针对经验风险最小化算法的过拟合的问题,给出交叉验证的方法,这个方法在做分类问题时很常用:

    一:简单的交叉验证的步骤如下:

    1、 从全部的训练数据 S中随机选择 中随机选择 s的样例作为训练集 train,剩余的 作为测试集 作为测试集 test。

    2、 通过对测试集训练 ,得到假设函数或者模型 。
    3、 在测试集对每一个样本根据假设函数或者模型,得到训练集的类标,求出分类正确率。

    4,选择具有最大分类率的模型或者假设。

    这种方法称为 hold -out cross validation 或者称为简单交叉验证。由于测试集和训练集是分开的,就避免了过拟合的现象

    二:k折交叉验证 k-fold cross validation

    1、 将全部训练集 S分成 k个不相交的子集,假设 S中的训练样例个数为 m,那么每一个子 集有 m/k 个训练样例,,相应的子集称作 {s1,s2,…,sk}。
    2、每次从分好的子集中里面,拿出一个作为测试集,其它k-1个作为训练集

    3、根据训练训练出模型或者假设函数。
    4、 把这个模型放到测试集上,得到分类率。

    5、计算k次求得的分类率的平均值,作为该模型或者假设函数的真实分类率。

    这个方法充分利用了所有样本。但计算比较繁琐,需要训练k次,测试k次。


    三:留一法  leave-one-out cross validation

    留一法就是每次只留下一个样本做测试集,其它样本做训练集,如果有k个样本,则需要训练k次,测试k次。

    留一发计算最繁琐,但样本利用率最高。适合于小样本的情况。

    展开全文
  • 交叉验证(Cross Validation)

    万次阅读 多人点赞 2018-06-05 11:32:22
    交叉验证(Cross Validation)常见的交叉验证方法如下:1、简单交叉验证将原始数据随机分为两组,一组做为训练集,一组做为验证集,利用训练集训练分类器,然后利用验证集验证模型,记录最后的分类准确率为此分类器...

    交叉验证(Cross Validation)

    常见的交叉验证方法如下:

    1、简单交叉验证


    将原始数据随机分为两组,一组做为训练集,一组做为验证集,利用训练集训练分类器,然后利用验证集验证模型,记录最后的分类准确率为此分类器的性能指标。

    好处:

    处理简单,只需随机把原始数据分为两组即可

    坏处:

    但没有达到交叉的思想,由于是随机的将原始数据分组,所以最后验证集分类准确率的高低与原始数据的分组有很大的关系,得到的结果并不具有说服性。

    2、2-折交叉验证(2-fold Cross Validation,记为2-CV)

    做法是将数据集分成两个相等大小的子集,进行两次的分类器训练。在第一次中,一个子集作为训练集,另一个便作为测试集;在第二次训练中,则将训练集与测试集对换,

    其并不常用:

    主要原因是训练集样本数太少,不足以代表母体样本的分布,导致te测试阶段辨识率容易出现明显落差。

    3、K-折交叉验证(K-fold Cross Validation,记为K-CV)


    将原始数据分成K组(一般是均分),将每个子集数据分别做一次验证集,其余的K-1组子集数据作为训练集,这样会得到K个模型,用这K个模型最终的验证集的分类准确率的平均数作为此K-CV下分类器的性能指标。K一般大于等于2,实际操作时一般从3开始取,只有在原始数据集合数据量小的时候才会尝试取2。

    应用最多,K-CV可以有效的避免过拟合与欠拟合的发生,最后得到的结果也比较具有说服性。

    Eg:

    十折交叉验证

    1.     将数据集分成十份,轮流将其中9份作为训练数据,1份作为测试数据,进行试验。每次试验都会得出相应的正确率。

    2.     10次的结果的正确率的平均值作为对算法精度的估计,一般还需要进行多次10折交叉验证(例如10次10折交叉验证),再求其均值,作为对算法准确性的估计

    此外:

    1.     多次 k 折交叉验证再求均值,例如:10 次10 折交叉验证,以求更精确一点。

    2.     划分时有多种方法,例如对非平衡数据可以用分层采样,就是在每一份子集中都保持和原始数据集相同的类别比例。

    3.     模型训练过程的所有步骤,包括模型选择,特征选择等都是在单个折叠 fold 中独立执行的。

    4、留一交叉验证(Leave-One-Out Cross Validation记为LOO-CV)

    在数据缺乏的情况下使用,如果设原始数据有N个样本,那么LOO-CV就是N-CV,即每个样本单独作为验证集,其余的N-1个样本作为训练集,故LOO-CV会得到N个模型,用这N个模型最终的验证集的分类准确率的平均数作为此下LOO-CV分类器的性能指标。

    优点:

    (1)每一回合中几乎所有的样本皆用于训练模型,因此最接近原始样本的分布,这样评估所得的结果比较可靠。

    (2)实验过程中没有随机因素会影响实验数据,确保实验过程是可以被复制的。

    缺点:

    计算成本高,需要建立的模型数量与原始数据样本数量相同。当数据集较大时几乎不能使用。


    展开全文
  • 为什么要用交叉验证

    万次阅读 多人点赞 2017-06-21 12:09:31
    什么是交叉验证法? 为什么用交叉验证法? 主要有哪些方法?优缺点? 各方法应用举例? 什么是交叉验证法?它的基本思想就是将原始数据(dataset)进行分组,一部分做为训练集来训练模型,另一部分做为测试集来评价...

    本文结构:

    • 什么是交叉验证法?
    • 为什么用交叉验证法?
    • 主要有哪些方法?优缺点?
    • 各方法应用举例?

    什么是交叉验证法?

    它的基本思想就是将原始数据(dataset)进行分组,一部分做为训练集来训练模型,另一部分做为测试集来评价模型。


    为什么用交叉验证法?

    1. 交叉验证用于评估模型的预测性能,尤其是训练好的模型在新数据上的表现,可以在一定程度上减小过拟合。
    2. 还可以从有限的数据中获取尽可能多的有效信息。

    主要有哪些方法?

    1. 留出法 (holdout cross validation)

    在机器学习任务中,拿到数据后,我们首先会将原始数据集分为三部分:训练集、验证集和测试集
    训练集用于训练模型,验证集用于模型的参数选择配置,测试集对于模型来说是未知数据,用于评估模型的泛化能力。

    这个方法操作简单,只需随机把原始数据分为三组即可。
    不过如果只做一次分割,它对训练集、验证集和测试集的样本数比例,还有分割后数据的分布是否和原始数据集的分布相同等因素比较敏感,不同的划分会得到不同的最优模型,而且分成三个集合后,用于训练的数据更少了。

    于是有了 2. k 折交叉验证(k-fold cross validation)加以改进:

    k 折交叉验证通过对 k 个不同分组训练的结果进行平均来减少方差,因此模型的性能对数据的划分就不那么敏感。

    • 第一步,不重复抽样将原始数据随机分为 k 份。
    • 第二步,每一次挑选其中 1 份作为测试集,剩余 k-1 份作为训练集用于模型训练。
    • 第三步,重复第二步 k 次,这样每个子集都有一次机会作为测试集,其余机会作为训练集。
    • 在每个训练集上训练后得到一个模型,
    • 用这个模型在相应的测试集上测试,计算并保存模型的评估指标,
    • 第四步,计算 k 组测试结果的平均值作为模型精度的估计,并作为当前 k 折交叉验证下模型的性能指标。

    k 一般取 10,
    数据量小的时候,k 可以设大一点,这样训练集占整体比例就比较大,不过同时训练的模型个数也增多。
    数据量大的时候,k 可以设小一点。

    当 k=m 即样本总数时,叫做 3. 留一法(Leave one out cross validation),每次的测试集都只有一个样本,要进行 m 次训练和预测。
    这个方法用于训练的数据只比整体数据集少了一个样本,因此最接近原始样本的分布。
    但是训练复杂度增加了,因为模型的数量与原始数据样本数量相同。
    一般在数据缺乏时使用。

    此外:

    1. 多次 k 折交叉验证再求均值,例如:10 次 10 折交叉验证,以求更精确一点。
    2. 划分时有多种方法,例如对非平衡数据可以用分层采样,就是在每一份子集中都保持和原始数据集相同的类别比例。
    3. 模型训练过程的所有步骤,包括模型选择,特征选择等都是在单个折叠 fold 中独立执行的。

    还有一种比较特殊的交叉验证方式,Bootstrapping: 通过自助采样法,即在含有 m 个样本的数据集中,每次随机挑选一个样本,再放回到数据集中,再随机挑选一个样本,这样有放回地进行抽样 m 次,组成了新的数据集作为训练集。

    这里会有重复多次的样本,也会有一次都没有出现的样本,原数据集中大概有 36.8% 的样本不会出现在新组数据集中。

    优点是训练集的样本总数和原数据集一样都是 m,并且仍有约 1/3 的数据不被训练而可以作为测试集。
    缺点是这样产生的训练集的数据分布和原数据集的不一样了,会引入估计偏差。
    此种方法不是很常用,除非数据量真的很少。


    各方法应用举例?

    1. 留出法 (holdout cross validation)

    下面例子,一共有 150 条数据:

    >>> import numpy as np
    >>> from sklearn.model_selection import train_test_split
    >>> from sklearn import datasets
    >>> from sklearn import svm
    
    >>> iris = datasets.load_iris()
    >>> iris.data.shape, iris.target.shape
    ((150, 4), (150,))

    用 train_test_split 来随机划分数据集,其中 40% 用于测试集,有 60 条数据,60% 为训练集,有 90 条数据:

    >>> X_train, X_test, y_train, y_test = train_test_split(
    ...     iris.data, iris.target, test_size=0.4, random_state=0)
    
    >>> X_train.shape, y_train.shape
    ((90, 4), (90,))
    >>> X_test.shape, y_test.shape
    ((60, 4), (60,))

    用 train 来训练,用 test 来评价模型的分数。

    >>> clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
    >>> clf.score(X_test, y_test)                           
    0.96...

    2. k 折交叉验证(k-fold cross validation)

    最简单的方法是直接调用 cross_val_score,这里用了 5 折交叉验证:

    >>> from sklearn.model_selection import cross_val_score
    >>> clf = svm.SVC(kernel='linear', C=1)
    >>> scores = cross_val_score(clf, iris.data, iris.target, cv=5)
    >>> scores                                              
    array([ 0.96...,  1.  ...,  0.96...,  0.96...,  1.        ])

    得到最后平均分为 0.98,以及它的 95% 置信区间:

    >>> print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))
    Accuracy: 0.98 (+/- 0.03)

    我们可以直接看一下 K-fold 是怎样划分数据的:
    X 有四个数据,把它分成 2 折,
    结果中最后一个集合是测试集,前面的是训练集,
    每一行为 1 折:

    >>> import numpy as np
    >>> from sklearn.model_selection import KFold
    
    >>> X = ["a", "b", "c", "d"]
    >>> kf = KFold(n_splits=2)
    >>> for train, test in kf.split(X):
    ...     print("%s %s" % (train, test))
    [2 3] [0 1]
    [0 1] [2 3]

    同样的数据 X,我们看 LeaveOneOut 后是什么样子,
    那就是把它分成 4 折,
    结果中最后一个集合是测试集,只有一个元素,前面的是训练集,
    每一行为 1 折:

    >>> from sklearn.model_selection import LeaveOneOut
    
    >>> X = [1, 2, 3, 4]
    >>> loo = LeaveOneOut()
    >>> for train, test in loo.split(X):
    ...     print("%s %s" % (train, test))
    [1 2 3] [0]
    [0 2 3] [1]
    [0 1 3] [2]
    [0 1 2] [3]

    资料:
    机器学习
    http://scikit-learn.org/stable/modules/cross_validation.html
    https://ljalphabeta.gitbooks.io/python-/content/kfold.html
    http://www.csuldw.com/2015/07/28/2015-07-28%20crossvalidation/


    推荐阅读
    历史技术博文链接汇总
    也许可以找到你想要的

    展开全文
  • 交叉验证(Cross Validation)简介

    万次阅读 多人点赞 2014-05-27 11:56:55
    以下简称交叉验证(Cross Validation)为CV.CV是用来验证分类器的性能一种统计分析方法,基本思想是把在某种意义下将原始数据(dataset)进行分组,一部分做为训练集(train set),另一部分做为验证集(validation set),首先...
  • 交叉验证

    千次阅读 2018-12-18 15:27:30
    交叉验证其实就是为了检查模型的泛化行和稳定性,让模型的输出更加可靠。 因为当我们只将训练数据划分一次时,有可能划分的不好,所以模型的结果会有偏差,不可靠。所以,我们可以使用交叉验证。经常使用的是k-fold...
  • 几种交叉验证方法介绍及对比

    万次阅读 2018-01-23 12:17:08
    交叉验证交叉验证是一种用来评价一个训练出的模型是否可以推广到另一个数据结构相同的数据集上的方法。主要用于PCR 、PLS 回归建模等建模应用中。主要用于估计一个预测模型在实际数据应用中的准确度。它是一种统计学...
  • 机器学习 | 交叉验证

    2018-11-15 17:44:34
    但是,在许多实际应用中数据是不充足的,为了选择好的模型,可以采用交叉验证方法,交叉验证的基本思想是重复地使用数据;把给定的数据进行切分,将切分的数据组合为训练集和测试集,在此基础上反复地进行训练、...
  • 交叉验证(Cross-validation)

    千次阅读 2015-12-21 21:23:55
    交叉验证是一种用来评价一个统计分析的结果是否可以推广到一个独立的数据集上的技术。主要用于预测,即,想要估计一个预测模型的实际应用中的准确度。它是一种统计学上将数据样本切割成较小子集的实用方法。于是可以...
  • 交叉验证是什么?

    千次阅读 2019-07-12 20:17:10
    交叉验证是什么? Cross Validation是一种评估模型性能的重要方法,主要用于在多个模型中(不同种类模型或同一种类不同超参数组合)挑选出在当前问题场景下表现最优的模型(model selection)。cv主要分为以下...
  • sklearn中的交叉验证(Cross-Validation)

    万次阅读 多人点赞 2017-05-14 01:49:30
    这个repo 用来记录一些python技巧、书籍、学习链接等,...今天主要记录一下sklearn中关于交叉验证的各种用法,主要是对sklearn官方文档 Cross-validation: evaluating estimator performance进行讲解,英文水平好...
  • 交叉验证 matlab实现

    万次阅读 2016-05-02 19:15:33
    转自:... crossvalind交叉验证 Generate cross-validation indices 生成交叉验证索引 Syntax语法 Indices = crossvalind('Kfold', N, K) K折交叉 [Train, Test] = crossvalind('Ho
1 2 3 4 5 ... 20
收藏数 93,538
精华内容 37,415
关键字:

交叉验证