python 留一交叉验证的实例

目录
  • python 留一交叉验证
    • 基本原理
    • 代码实现
  • 留一法交叉验证 Leave-One-Out Cross Validation
    • 我们用SKlearn库来实现一下LOO

python 留一交叉验证

基本原理

K折交叉验证

简单来说,K折交叉验证就是:

  • 把数据集划分成K份,取出其中一份作为测试集,另外的K - 1份作为训练集。
  • 通过训练集得到回归方程,再把测试集带入该回归方程,得到预测值。
  • 计算预测值与真实值的差值的平方,得到平方损失函数(或其他的损失函数)。
  • 重复以上过程,总共得到K个回归方程和K个损失函数,其中损失函数最小的回归方程就是最优解。

留一交叉验证

留一交叉验证是K折交叉验证的特殊情况,即:将数据集划分成N份,N为数据集总数。就是只留一个数据作为测试集,该特殊情况称为“留一交叉验证”。

代码实现

'''留一交叉验证'''
import numpy as np

# K折交叉验证
data = [[12, 1896], [11, 1900], [11, 1904], [10.8, 1908], [10.8, 1912], [10.8, 1920], [10.6, 1924], [10.8, 1928],
        [10.3, 1932], [10.3, 1936], [10.3, 1948], [10.4, 1952], [10.5, 1956], [10.2, 1960], [10.0, 1964], [9.95, 1968],
        [10.14, 1972], [10.06, 1976], [10.25, 1980], [9.99, 1984], [9.92, 1988], [9.96, 1992], [9.84, 1996],
        [9.87, 2000], [9.85, 2004], [9.69, 2008]]

length = len(data)

# 得到训练集和测试集
def Get_test_train(length, data, i):
    test_data = data[i]  # 测试集
    train_data = data[:]
    train_data.pop(i)  # 训练集
    return train_data, test_data

# 得到线性回归直线
def Get_line(train_data):
    time = []
    year = []
    average_year_time = 0
    average_year_year = 0

    for i in train_data:
        time.append(i[0])
        year.append(i[1])

    time = np.array(time)
    year = np.array(year)

    average_year = sum(year) / length  # year拔
    average_time = sum(time) / length  # time拔

    for i in train_data:
        average_year_time = average_year_time + i[0] * i[1]
        average_year_year = average_year_year + i[1] ** 2
    average_year_time = average_year_time / length  # (year, time)拔
    average_year_year = average_year_year / length  # (year, year)拔
    # 线性回归:t = w0 + w1 * x
    w1 = (average_year_time - average_year * average_time) / (average_year_year - average_year * average_year)
    w0 = average_time - w1 * average_year
    return w0, w1

# 得到损失函数
def Get_loss_func(w0, w1, test_data):
    time_real = test_data[0]
    time_predict = eval('{} + {} * {}'.format(w0, w1, test_data[1]))
    loss = (time_predict - time_real) ** 2
    dic['t = {} + {}x'.format(w0, w1)] = loss
    return dic

if __name__ == '__main__':
    dic = {}  # 存放建为回归直线,值为损失函数的字典

    for i in range(length):
        train_data, test_data = Get_test_train(length, data, i)
        w0, w1 = Get_line(train_data)
        Get_loss_func(w0, w1, test_data)
        dic = Get_loss_func(w0, w1, test_data)

    min_loss = min(dic.values())
    best_line = [k for k, v in dic.items() if v == min_loss][0]
    print('最佳回归直线:', best_line)
    print('最小损失函数:', min_loss)

留一法交叉验证 Leave-One-Out Cross Validation

交叉验证法,就是把一个大的数据集分为 k 个小数据集,其中 k−1 个作为训练集,剩下的 1 11 个作为测试集,在训练和测试的时候依次选择训练集和它对应的测试集。这种方法也被叫做 k 折交叉验证法(k-fold cross validation)。最终的结果是这 k 次验证的均值。

此外,还有一种交叉验证方法就是 留一法(Leave-One-Out,简称LOO),顾名思义,就是使 k kk 等于数据集中数据的个数,每次只使用一个作为测试集,剩下的全部作为训练集,这种方法得出的结果与训练整个测试集的期望值最为接近,但是成本过于庞大。

我们用SKlearn库来实现一下LOO

from sklearn.model_selection import LeaveOneOut

# 一维示例数据
data_dim1 = [1, 2, 3, 4, 5]

# 二维示例数据
data_dim2 = [[1, 1, 1, 1],
             [2, 2, 2, 2],
             [3, 3, 3, 3],
             [4, 4, 4, 4],
             [5, 5, 5, 5]]

loo = LeaveOneOut() # 实例化LOO对象

# 取LOO训练、测试集数据索引
for train_idx, test_idx in loo.split(data_dim1):
    # train_idx 是指训练数据在总数据集上的索引位置
    # test_idx 是指测试数据在总数据集上的索引位置
    print("train_index: %s, test_index %s" % (train_idx, test_idx))

# 取LOO训练、测试集数据值
for train_idx, test_idx in loo.split(data_dim1):
    # train_idx 是指训练数据在总数据集上的索引位置
    # test_idx 是指测试数据在总数据集上的索引位置
    train_data = [data_dim1[i] for i in train_idx]
    test_data = [data_dim1[i] for i in test_idx]
    print("train_data: %s, test_data %s" % (train_data, test_data))

data_dim1的输出:

train_index: [1 2 3 4], test_index [0]
train_index: [0 2 3 4], test_index [1]
train_index: [0 1 3 4], test_index [2]
train_index: [0 1 2 4], test_index [3]
train_index: [0 1 2 3], test_index [4]

train_data: [2, 3, 4, 5], test_data [1]
train_data: [1, 3, 4, 5], test_data [2]
train_data: [1, 2, 4, 5], test_data [3]
train_data: [1, 2, 3, 5], test_data [4]
train_data: [1, 2, 3, 4], test_data [5]

data_dim2的输出:

train_index: [1 2 3 4], test_index [0]
train_index: [0 2 3 4], test_index [1]
train_index: [0 1 3 4], test_index [2]
train_index: [0 1 2 4], test_index [3]
train_index: [0 1 2 3], test_index [4]

train_data: [[2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4], [5, 5, 5, 5]], test_data [[1, 1, 1, 1]]
train_data: [[1, 1, 1, 1], [3, 3, 3, 3], [4, 4, 4, 4], [5, 5, 5, 5]], test_data [[2, 2, 2, 2]]
train_data: [[1, 1, 1, 1], [2, 2, 2, 2], [4, 4, 4, 4], [5, 5, 5, 5]], test_data [[3, 3, 3, 3]]
train_data: [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [5, 5, 5, 5]], test_data [[4, 4, 4, 4]]
train_data: [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], test_data [[5, 5, 5, 5]]

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • python实现K折交叉验证

    本文实例为大家分享了python实现K折交叉验证的具体代码,供大家参考,具体内容如下 用KNN算法训练iris数据,并使用K折交叉验证方法找出最优的K值 import numpy as np from sklearn import datasets from sklearn.neighbors import KNeighborsClassifier from sklearn.model_selection import KFold # 主要用于K折交叉验证 # 导入iris数据集 iris =

  •  分享Python 中的 7 种交叉验证方法

    目录 一.什么是交叉验证? 二.它是如何解决过拟合问题的? 1.HoldOut交叉验证 2.K折交叉验证 3.分层K折交叉验证 4.LeavePOut交叉验证 5.留一交叉验证 6.蒙特卡罗交叉验证(ShuffleSplit) 7.时间序列交叉验证 在任何有监督机器学习项目的模型构建阶段,我们训练模型的目的是从标记的示例中学习所有权重和偏差的最佳值. 如果我们使用相同的标记示例来测试我们的模型,那么这将是一个方法论错误,因为一个只会重复刚刚看到的样本标签的模型将获得完美的分数,但无法预测任何有用

  • Python sklearn KFold 生成交叉验证数据集的方法

    源起: 1.我要做交叉验证,需要每个训练集和测试集都保持相同的样本分布比例,直接用sklearn提供的KFold并不能满足这个需求. 2.将生成的交叉验证数据集保存成CSV文件,而不是直接用sklearn训练分类模型. 3.在编码过程中有一的误区需要注意: 这个sklearn官方给出的文档 >>> import numpy as np >>> from sklearn.model_selection import KFold >>> X = [&quo

  • 详解python实现交叉验证法与留出法

    在机器学习中,我们经常在训练集上训练模型,在测试集上测试模型.最终的目标是希望我们的模型在测试集上有最好的表现. 但是,我们往往只有一个包含m个观测的数据集D,我们既要用它进行训练,又要对它进行测试.此时,我们就需要对数据集D进行划分. 对于数据集D的划分,我们尽量需要满足三个要求: 训练集样本量充足 训练模型时的计算量可以忍受 不同的划分方式会得出不同的训练集和测试集,从而得出不同的结果,我们需要消除这种影响 我们将分别介绍留出法.交叉验证法,以及各自的python实现.自助法(bootstr

  • Python实现K折交叉验证法的方法步骤

    学习器在测试集上的误差我们通常称作"泛化误差".要想得到"泛化误差"首先得将数据集划分为训练集和测试集.那么怎么划分呢?常用的方法有两种,k折交叉验证法和自助法.介绍这两种方法的资料有很多.下面是k折交叉验证法的python实现. ##一个简单的2折交叉验证 from sklearn.model_selection import KFold import numpy as np X=np.array([[1,2],[3,4],[1,3],[3,5]]) Y=np.a

  • python 留一交叉验证的实例

    目录 python 留一交叉验证 基本原理 代码实现 留一法交叉验证 Leave-One-Out Cross Validation 我们用SKlearn库来实现一下LOO python 留一交叉验证 基本原理 K折交叉验证 简单来说,K折交叉验证就是: 把数据集划分成K份,取出其中一份作为测试集,另外的K - 1份作为训练集. 通过训练集得到回归方程,再把测试集带入该回归方程,得到预测值. 计算预测值与真实值的差值的平方,得到平方损失函数(或其他的损失函数). 重复以上过程,总共得到K个回归方程

  • sklearn和keras的数据切分与交叉验证的实例详解

    在训练深度学习模型的时候,通常将数据集切分为训练集和验证集.Keras提供了两种评估模型性能的方法: 使用自动切分的验证集 使用手动切分的验证集 一.自动切分 在Keras中,可以从数据集中切分出一部分作为验证集,并且在每次迭代(epoch)时在验证集中评估模型的性能. 具体地,调用model.fit()训练模型时,可通过validation_split参数来指定从数据集中切分出验证集的比例. # MLP with automatic validation set from keras.mode

  • JSONLINT:python的json数据验证库实例解析

    JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,易于人阅读和编写. JSON 函数 使用 JSON 函数需要导入 json 库:import json. 函数 描述 json.dumps 将 Python 对象编码成 JSON 字符串 json.loads 将已编码的 JSON 字符串解码为 Python 对象 随着前后端分离和 REST APIs 的火热,开发者不断寻找着一种灵活的.优雅的方式验证 json 数据.有直接手动获取数据验证的,也有使用

  • 使用sklearn的cross_val_score进行交叉验证实例

    在构建模型时,调参是极为重要的一个步骤,因为只有选择最佳的参数才能构建一个最优的模型.但是应该如何确定参数的值呢?所以这里记录一下选择参数的方法,以便后期复习以及分享. (除了贝叶斯优化等方法)其它简单的验证有两种方法: 1.通过经常使用某个模型的经验和高超的数学知识. 2.通过交叉验证的方法,逐个来验证. 很显然我是属于后者所以我需要在这里记录一下 sklearn 的 cross_val_score: 我使用是cross_val_score方法,在sklearn中可以使用这个方法.交叉验证的原

  • Python个人博客程序开发实例框架设计

    目录 1.数据库(models.py) 1.1 管理员 Admin 1.2 分类 Category 1.3 文章 Post 1.4 评论 Comment 1.5 社交链接 Link 2.生成虚拟数据(fakes.py) 3.模板 3.1 模板上下文 3.2 渲染导航链接 3.3 Flash消息分类 4.表单(forms.py) 4.1 登录表单 4.2 文章表单 4.3 分类表单 4.4 评论表单 5.视图函数(blueprints:admin.auth.blog) 6.电子邮件支持(email

随机推荐