精华内容
下载资源
问答
  • 其实之前学习都很散的学习,对于训练集、验证集测试集都没有特别的区分。这么一段时间算是在以前的基础上还是学到了一些东西(虽然都些很简单的东西),但是我还是写写吧万一我忘了呢。哈哈哈! 训练集 其实我们...

    其实之前学习都是很散的学习,对于训练集、验证集和测试集都没有特别的区分。这么一段时间算是在以前的基础上还是学到了一些东西(虽然都是些很简单的东西),但是我还是写写吧万一我忘了呢。哈哈哈!

    训练集

    其实我们在拿到训练数据的时候,我们都会把数据分成两部分,训练集也就是其中之一。顾名思义,我们需要训练集来对我们的网络权重(weight)和偏倚(bias)来训练,而我们所有参数的更新都是通过误差来更新的,而这个误差也就是我们定义的损失函数,常见的损失函数有均方差(回归问题)、交叉熵(分类问题)等,我们的网络通过一系列的矩阵乘法进行前向传播,在和实际值对比之后,通过损失函数得到误差。现在有了误差之后,我们就得更新权重,而更新权重的方法我们称之为:优化方法,常见的就是梯度下降等优化方式。而训练集的主要目的就是更新这些权重等参数。

    验证集

    其实验证集算是训练集分出来的一部分,这个是在网络训练完成之后,我们调整超参数所用的数据集。所谓超参数就是决定网络的结构和学习方式的一些参数,像是网络的学习率、优化函数、网络的层数和隐藏层的个数等。之所以不用测试集来调整参数,你可以这么理解:测试集的数据必须是未知的。为了让网络的泛化能力最大化,我们不能透露一点点测试集的数据,一旦网络在测试集上训练过之后,对于网络来说这个数据集就已经不算是未知了,也就没有办法更好的说明我们网络的泛化能力了。所以,这就是验证集的意义。常见的算法有:留出法和K折交叉验证。

    留出法
    # 留出法
    import numpy as np
    import keras
    line = 10000
    np.random.shuffle(data) #打乱数据
    validation_data = data[:10000]
    train_data = data[:]
    
    model=get_model()
    model.train(train_data)
    validation_score = model.evaluate(validation_data)
    #超参数调节完成之后,将训练数据和验证数据相加然后进行一次网络的总训练。
    
    K折交叉验证
    #一般就是数据量比较小的时候可能会用K折交叉验证。
    k = 4 #四折
    number = len(data) // k #整除K
    np.random.shuffle(data)
    validation_score=[]
    for fold in range(k):
        validation_data = data[fold*number:(fold+1)*number]
        train_data = np.concatenate(data[:fold*number],data[(fold+1)*number:]) #将剩下的部分拼接在一起
        
        model = C_model()
        model.train(train_data)
        validation_score = model.evaluate(train_data)
        validation_scores.append(validation_score)
        
    validation_score = np.average(validation_scores) #这一步得到了平均的loss然后进行超参数的调整。
    

    当然还有一个方法叫做重复K折交叉验证,我个人觉得也就是在K折循环的基础再外套一个大循环,然后在大循环里面每次打乱一下数据。

    测试集

    这个就是用来模拟我们网络遇到实际数据时的情况,然后我们可以找一些评估的函数来评估我们网络的泛化能力。像是准确率呀,或者其他啥的。

    展开全文
  • 交叉验证

    2018-04-18 20:06:13
    “你集测试还是集测试?!” “啥…” 来来来,捋捋都有哪些交叉验证方法吧! Cross-validation Two types of cross-validation can be distinguished, exhaustive and non-exhaustive cross-validation....

    交叉验证(整理自维基百科)

    在某次会议上…

    “你是开集测试还是闭集测试?!”

    “啥…”

    来来来,捋捋都有哪些交叉验证方法吧!

    Cross-validation

    Two types of cross-validation can be distinguished, exhaustive and non-exhaustive cross-validation.

    (交叉验证可分为,穷尽和非穷尽)

    Exhaustive cross-validation(穷尽)

    Exhaustive cross-validation methods are cross-validation methods which learn and test on all possible ways to divide the original sample into a training and a validation set.

    Leave-p-out cross-validation

    Leave-p-out cross-validation (LpO CV) involves using p observations as the validation set and the remaining observations as the training set. This is repeated on all ways to cut the original sample on a validation set of p observations and a training set.

    (数据集 n 样本,留出 p 测试,n-p 训练,p 样本的选择需穷尽所有情况,计算量大)

    Leave-one-out cross-validation(留一法)

    Leave-one-out cross-validation (LOOCV) is a particular case of leave-p-out cross-validation with p = 1. The process looks similar to jackknife; however, with cross-validation you compute a statistic on the left-out sample(s), while with jackknifing you compute a statistic from the kept samples only.

    (数据集 n 样本,留出 1 测试,n-1 训练,共需训练、测试 n 次)

    Non-exhaustive cross-validation(非穷尽)

    Non-exhaustive cross validation methods do not compute all ways of splitting the original sample. Those methods are approximations of leave-p-out cross-validation.

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

    In k-fold cross-validation, the original sample is randomly partitioned into k equal sized subsamples. Of the k subsamples, a single subsample is retained as the validation data for testing the model, and the remaining k − 1 subsamples are used as training data.

    (将数据集随机划分为 k 份,不一定等分,1 份测试,k-1 份测试,共需训练、测试 k 次)

    (当数据集非等分时,计算最终测试的准确率不能直接对 k 次测试的准确率取均值;以分类任务为例,应先将 k 次测试中,分类正确的样本数求和,再除以总样本数)

    (常使用多次十折交叉验证,例如 10 次 10 折交叉验证,即随机划分 10 次数据集到 10 份,共需训练、测试 100 次;选择十折并不是绝对的,只是某些统计测试中表明该选择最为适合)

    Holdout method(简单交叉验证)

    In the holdout method, we randomly assign data points to two sets d0 and d1, usually called the training set and the test set, respectively. The size of each of the sets is arbitrary although typically the test set is smaller than the training set. We then train on d0 and test on d1.

    (将数据集划分为训练集和测试集,共需训练、测试 1 次)

    Repeated random sub-sampling validation

    This method, also known as Monte Carlo cross-validation.

    (没深查,感兴趣的同学,了解一下?)

    以上

    展开全文
  • 交叉验证是什么? 在模型建立中,通常有两个数据集:训练集(train)和测试集(test)。训练集用来训练模型;测试集是完全不参与训练的数据,仅仅用来观测测试效果的数据。 一般情况下,训练的结果对于训练集的拟合...

    交叉验证是什么?

    在模型建立中,通常有两个数据集:训练集(train)和测试集(test)。训练集用来训练模型;测试集是完全不参与训练的数据,仅仅用来观测测试效果的数据。

    一般情况下,训练的结果对于训练集的拟合程度通常还是挺好的,但是在测试集总的表现却可能不行。比如下面的例子:
    在这里插入图片描述

    • 图一的模型是一条线型方程。 可以看到,所有的红点都不在蓝线上,所以导致了错误率很高,这是典型的不拟合的情况
    • 图二 的蓝线则更加贴近实际的红点,虽然没有完全重合,但是可以看出模型表示的关系是正确的。
    • 图三,所有点都在蓝线上,这时候模型计算出的错误率很低,(甚至将噪音都考虑进去了)。这个模型只在训练集中表现很好,在测试集中的表现就不行。 这是典型的‘过拟合’情况。

    所以,训练的模型需要找出数据之间‘真正’的关系,避免‘过拟合’的情况发生。

    交叉验证:就是在训练集中选一部分样本用于测试模型。
    保留一部分的训练集数据作为验证集/评估集,对训练集生成的参数进行测试,相对客观的判断这些参数对训练集之外的数据的符合程度。

    留一验证(LOOCV,Leave one out cross validation )

    只从可用的数据集中保留一个数据点,并根据其余数据训练模型。此过程对每个数据点进行迭代,比如有n个数据点,就要重复交叉验证n次。例如下图,一共10个数据,就交叉验证十次
    在这里插入图片描述

    优点:

    • 适合小样本数据集
    • 利用所有的数据点,因此偏差将很低

    缺点:

    • 重复交叉验证过程n次导致更高的执行时间
    • 测试模型有效性的变化大。因为针对一个数据点进行测试,模型的估计值受到数据点的很大影响。如果数据点被证明是一个离群值,它可能导致更大的变化

    LOOCC是保留一个数据点,同样的你也可以保留P个数据点作为验证集,这种方法叫LPOCV(Leave P Out Cross Validation)

    LOOCC代码

    R

    score = list()
    
    LOOCV_function = function(x,label){
     for(i in 1:nrow(x)){
     training = x[-i,]
     model = #... train model on training
     validation = x[i,]
     pred = predict(model, validation[,setdiff(names(validation),label)])
     score[[i]] = rmse(pred, validation[[label]]) # score/error of ith fold
     }
     return(unlist(score)) # returns a vector
     }
    

    验证集方法

    交叉验证的步骤如下:

    1. 保留一个样本数据集, (取出训练集中20%的样本不用)
    2. 使用数据集的剩余部分训练模型 (使用另外的80%样本训练模型)
    3. 使用验证集的保留样本。(完成模型后,在20%的样本中测试)
    4. 如果模型在验证数据上提供了一个肯定的结果,那么继续使用当前的模型。

    优点: 简单方便。直接将训练集按比例拆分成训练集和验证集,比如50:50。

    缺点: 没有充分利用数据, 结果具有偶然性。如果按50:50分,会损失掉另外50%的数据信息,因为我们没有利用着50%的数据来训练模型。

    验证集方法代码

    Python 使用train_test_split

    from sklearn.model_selection import train_test_split
    train, validation = train_test_split(data, test_size=0.50, random_state = 5)
    
    

    train_test_split,划分成train 和test 两部分,其中train用来训练模型,test用来评估模型,模型通过fit方法从train数据集中学习,调用score方法在test集上进行评估。

    from sklearn.model_selection import train_test_split
    from sklearn.linear_model import LogisticRegression
    
    #已经导入数据
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=20, shuffle=True)
    
    # Logistic Regression
    model = LogisticRegression()
    model.fit(X_train, y_train)
    prediction = model.predict(X_test)
    print('The accuracy of the Logistic Regression is: {0}'.format(metrics.accuracy_score(prediction,y_test)))
    

    R

    set.seed(101) # Set Seed so that same sample can be reproduced in future also
    
    # Now Selecting 50% of data as sample from total 'n' rows of the data
    sample <- sample.int(n = nrow(data), size = floor(.50*nrow(data)), replace = F)
    train <- data[sample, ]
    test  <- data[-sample, ]
    

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

    针对上面通过train_test_split划分,从而进行模型评估方式存在的弊端,提出Cross Validation 交叉验证。

    Cross Validation:简言之,就是进行多次train_test_split划分;每次划分时,在不同的数据集上进行训练、测试评估,从而得出一个评价结果;如果是5折交叉验证,意思就是在原始数据集上,进行5次划分,每次划分进行一次训练、评估,最后得到5次划分后的评估结果,一般在这几次评估结果上取平均得到最后的 评分。k-fold cross-validation ,其中,k一般取5或10。
    在这里插入图片描述

    1. 训练模型需要在大量的数据集基础上,否则就不能够识别数据中的趋势,导致错误产生
    2. 同样需要适量的验证数据点。 验证集太小容易导致误差
    3. 多次训练和验证模型。需要改变训练集和验证集的划分,有助于验证模型。
      步骤:
    4. 随机将整个数据集分成k折;
    5. 如图中所示,依次取每一折的数据集作验证集,剩余部分作为训练集
    6. 算出每一折测试的错误率
    7. 取这里K次的记录平均值 作为最终结果

    优点:

    • 适合大样本的数据集
    • 经过多次划分,大大降低了结果的偶然性,从而提高了模型的准确性。
    • 对数据的使用效率更高。train_test_split,默认训练集、测试集比例为3:1。如果是5折交叉验证,训练集比测试集为4:1;10折交叉验证训练集比测试集为9:1。数据量越大,模型准确率越高。

    缺点:

    • 对数据随机均等划分,不适合包含不同类别的数据集。比如:数据集有5类数据(ABCDE各占20%),抽取出来的也正好是按照类别划分的5类,第一折全是A,第二折全是B……这样就会导致,模型学习到测试集中数据的特点,用BCDE训练的模型去测试A类数据、ACDE的模型测试B类数据,这样准确率就会很低。

    如何确定K值?

    • 一般情况下3、5是默认选项,常建议用K=10。
    • k值越低,就越有偏差;K值越高偏差就越小,但是会受到很大的变化。
    • k值越小,就越类似于验证集方法;而k值越大,则越接近LOOCV方法。

    k-fold代码

    Python 使用cross_val_score或者KFold

    cross_val_score直接将整个交叉验证过程连接起来。

    from sklearn.model_selection import cross_val_score
    model  = LogisticRegression()
    scores = cross_val_score(model,X, y,cv=3) #cv:默认是3折交叉验证,可以修改cv=5,变成5折交叉验证。
    print("Cross validation scores:{}".format(scores))
    print("Mean cross validation score:{:2f}".format(scores.mean()))
    

    KFold 可以显示具体的划分情况。

    from sklearn.model_selection import KFold 
    
    kf = KFold(n_splits=5, random_state=None) # 5折
    
    #显示具体划分情况
    for train_index, test_index in kf.split(X):
          print("Train:", train_index, "Validation:",test_index)
          X_train, X_test = X[train_index], X[test_index] 
          y_train, y_test = y[train_index], y[test_index] 
    
    i = 1
    for train_index, test_index in kf.split(X, y):
        print('\n{} of kfold {}'.format(i,kf.n_splits))
        X_train, X_test = X[train_index], X[test_index] 
        y_train, y_test = y[train_index], y[test_index]
        model = LogisticRegression(random_state=1)
        model.fit(X_train, y_train)
        pred_test = model.predict(X_test)
        score = metrics.accuracy_score(y_test, pred_test)
        print('accuracy_score', score)
        i += 1
        #pred_test = model.predict(X_test)
        pred = model.predict_proba(X_test)[:, 1]
    

    R code

    library(caret)
    data(iris)
    
    # Define train control for k fold cross validation
    train_control <- trainControl(method="cv", number=10)
    # Fit Naive Bayes Model
    model <- train(Species~., data=iris, trControl=train_control, method="nb")
    # Summarise Results
    print(model)
    

    分层交叉验证 (Stratified k-fold cross validation)

    分层是重新将数据排列组合,使得每一折都能比较好地代表整体。

    比如下面这个例子:在一个二分类问题上,原始数据一共有两类(F和M),F:M的数据量比例大概是 1:3;划分了5折,每一折中F和M的比例都保持和原数据一致(1:3)。

    这样就避免了随机划分可能产生的的情况,像是一折全是F,其他3折都是M。

    在这里插入图片描述

    下图是标准交叉验证和分层交叉验证的区别:
    标准交叉验证(即K折交叉验证):直接将数据分成几折;
    分层交叉验证:先将数据分类(class1,2,3),然后在每个类别中划分三折。
    在这里插入图片描述

    分层验证代码

    Python 使用cross_val_scoreStratifiedKFold

    from sklearn.model_selection import StratifiedKFold
    skf = StratifiedKFold(n_splits=5,shuffle=False,random_state=0)
    
    # X is the feature set and y is the target
    for train_index, test_index in skf.split(X,y): 
        print("Train:", train_index, "Validation:", test_index) 
        X_train, X_test = X[train_index], X[test_index] 
        y_train, y_test = y[train_index], y[test_index]
        
    model = LogisticRegression()
    scores = cross_val_score(model,X,y,cv=skf)
    print("straitified cross validation scores:{}".format(scores))
    print("Mean score of straitified cross validation:{:.2f}".format(scores.mean()))
    

    ** R code**

    library(caret)
    # Folds are created on the basis of target variable
    folds <- createFolds(factor(data$target), k = 10, list = FALSE)
    

    重复交叉验证( k-fold cross validation with repetition)

    如果训练集不能很好地代表整个样本总体,分层交叉验证就没有意义了。这时候,可以使用重复交叉验证。

    重复验证代码

    Python:RepeatedKFold重复K折交叉验证

    kf = RepeatedKFold(n_splits=5, n_repeats=2, random_state=None)  #默认是5折
    
    for train_index, test_index in kf.split(X):
          print("Train:", train_index, "Validation:",test_index)
          X_train, X_test = X[train_index], X[test_index] 
          y_train, y_test = y[train_index], y[test_index]
            
    i = 1
    for train_index, test_index in kf.split(X, y):
        print('\n{} of kfold {}'.format(i,i))
        X_train, X_test = X[train_index], X[test_index] 
        y_train, y_test = y[train_index], y[test_index]
        model = LogisticRegression(random_state=1)
        model.fit(X_train, y_train)
        pred_test = model.predict(X_test)
        score = metrics.accuracy_score(y_test, pred_test)
        print('accuracy_score', score)
        i += 1
        #pred_test = model.predict(X_test)
        pred = model.predict_proba(X_test)[:, 1]
    

    对抗验证(Adversarial Validation)

    在处理实际数据集时,经常会出现测试集和训练集截然不同的情况。因此,可能导致交叉验证结果不一致

    在这种情况下,可以使用对抗验证法:总体思路是根据特征分布创建一个分类模型,以检查训练集和测试集之间的相似程度。

    步骤:

    1. 组合训练集和测试集;
    2. 分配0/1标签(0-训练、1-测试);
    3. 建立模型,(如果模型AUC在0.7以上,表示分类器表现较好,也间接说明train 和test 差异度较大
    4. 评估二进制分类任务来量化两个数据集的分布是否一致;
    5. 找出和测试集最相似的数据样本
    6. 构成与测试集最相似的验证集;

    优点: 使验证策略在训练集和测试集高度不同的情况下更加可靠。

    缺点: 一旦测试集的分布发生变化,验证集可能不再适合评估模型。

    对抗验证代码

    #1. 将目标变量删除
    train.drop(['target'], axis = 1, inplace = True)
    
    #2. 创建新的目标变量:训练集为1;测试集为0
    train['is_train'] = 1
    test['is_train'] = 0
    
    #3. 合并训练集和测试集
    df = pd.concat([train, test], axis = 0)
    
    #4. 使用新变量训练分类模型,并预测概率
    y = df['is_train']; df.drop('is_train', axis = 1, inplace = True) 
    # Xgboost parameters
    xgb_params = {'learning_rate': 0.05, 
                  'max_depth': 4,
                  'subsample': 0.9,        
                  'colsample_bytree': 0.9,
                  'objective': 'binary:logistic',
                  'silent': 1, 
                  'n_estimators':100, 
                  'gamma':1,         
                  'min_child_weight':4}   
    clf = xgb.XGBClassifier(**xgb_params, seed = 10)
    probs = clf.predict_proba(x1)[:,1]
    
    #5. 使用步骤4中计算的概率对序列集进行排序,并将前n%个样本/行作为验证集(n%是您希望保留在验证集中的序列集的分数)
    new_df = pd.DataFrame({'id':train.id, 'probs':probs})
    new_df = new_df.sort_values(by = 'probs', ascending=False) # 30% validation set
    val_set_ids = new_df.iloc[1:np.int(new_df.shape[0]*0.3),1]
    #val_set_ids将为提供列训练集的ID,这些ID将构成与测试集最相似的验证集。
    

    时间序列的交叉验证(Cross Validation for time series)

    对于时间序列的数据集,不能像上述方法一样随机地划分验证集。为了解决时间序列的预测问题,可以尝试时间序列交叉验证:采用正向链接的策略,即按照时间顺序划分每一折的数据集。

    假设我们有一个时间序列,表示在n年内消费者对某一产品的年需求量。
    在这里插入图片描述
    我们逐步选择新的训练集和测试集。我们从一个最小的训练集开始(这个训练集具有拟合模型所需的最少观测数)逐步地,每次都会更换训练集和测试集。在大多数情况下,不必一个个点向前移动,可以设置一次跨5个点/10个点。在回归问题中,可以使用以下代码执行交叉验证。

    时间序列代码

    pythonTimeSeriesSplit

    from sklearn.model_selection import TimeSeriesSplit
    X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
    y = np.array([1, 2, 3, 4])
    tscv = TimeSeriesSplit(n_splits=3)
    
    for train_index, test_index in tscv.split(X):
         print("Train:", train_index, "Validation:", val_index)
         X_train, X_test = X[train_index], X[val_index]
         y_train, y_test = y[train_index], y[val_index]
    
    TRAIN: [0] TEST: [1]
    TRAIN: [0 1] TEST: [2]
    TRAIN: [0 1 2] TEST: [3]
    

    R code

    library(fpp)
    library(forecast)
    e <- tsCV(ts, Arima(x, order=c(2,0,0), h=1) #CV for arima model
    sqrt(mean(e^2, na.rm=TRUE)) # RMSE
    #h =1意味着我们只接受1步超前预报的误差。
    #(h=4)4步前进误差如下图所示。如果想评估多步预测的模型,可以使用此选项。
    

    在这里插入图片描述

    参考链接:https://www.analyticsvidhya.com/blog/2018/05/improve-model-performance-cross-validation-in-python-r/
    其他网上找到的有关文章:
    关于时间序列的:https://zhuanlan.zhihu.com/p/99674163
    关于对抗验证的:https://zhuanlan.zhihu.com/p/137580733

    展开全文
  • 交叉验证及并行搜索

    2018-04-06 16:12:01
    简单交叉验证方法:首先随机地将已给数据分为两个部分,一部分作为训练集,一部分作为测试集;其中最常见的分割方式就是70%作为训练集,30%作为测试集;然后用训练集在各种不同模型下(参数不同)进行训练,从而得到不同的...

    1.简单交叉验证

    简单交叉验证方法是:首先随机地将已给数据分为两个部分,一部分作为训练集,一部分作为测试集;其中最常见的分割方式就是70%作为训练集,30%作为测试集;然后用训练集在各种不同模型下(参数不同)进行训练,从而得到不同的模型;最后选出测试误差最小的模型,作为最终模型.

    举例: 例如用支持向量机(用法戳此处)来对iris数据集进行分类.一开始时我们不知道用多项式核函数好,还是径向基核函数好(或者是其它),于是我们就用简单交叉验证来选择模型.

    第一步:将数据集以7:3分割;
    第二步:分别对两个不同的模型进行训练;
    第三步:选择得分高(误差小)的模型;

    from sklearn.datasets import load_iris
    from sklearn.cross_validation import train_test_split
    from sklearn.svm import SVC
    
    datas=load_iris()
    # Step 1.
    X_train,X_test,y_train,y_test=train_test_split(datas.data,datas.target, test_size=0.3,random_state=5)
    # random_state 是随机种子值,给一个定值的作用就是每次都选取同样的验证集和测试集;不然每次运行选择的验证集和测试集都不一样
    
    # Step 2.
    svc_pol=SVC(kernel='poly',degree=3)
    svc_pol.fit(X_train,y_train)
    print svc_pol.score(X_test,y_test)
    
    svc_rbf=SVC(kernel='rbf')
    svc_rbf.fit(X_train,y_train)
    print svc_rbf.score(X_test,y_test)
    
    # Step 3.
    # 以下为评分:
    0.955555555556
    0.977777777778
    # 可以看出选择径向基核函数的效果更佳
    

    虽然通过简单交叉验证可以对模型的泛化能力进行评估;但通过这一验证方法优化的模型性能也不稳定,原因在于对验证集集合随机采样的不确定性.换句话说,可能只是因为你的划分方式导致了一个比较好的结果.因此,更加高级的方式应该是:K折交叉验证(当k=1时就是简单交叉验证了)

    2.K折交叉验证

    K折交叉验证可以理解为从事了多次简单交叉验证的过程.其思想是:将数据集平均分割成K个互不相交的子集;然后每次将其中的K-1个子集作为训练集,余下的作为测试集;重复进行K次,最后选出次中平局误差最小的模型.

    这里写图片描述

    举例:在上面的例子当中,我们知道选择径向基核函数的效果更佳;但是在这种情况下(选择径向基核函数),还有其它的参数我们选择的是默认值(比如惩罚系数C=1为默认),难道选择默认值的效果就是最好的? 接下来,我们就对不同的模型,采用6折交叉验证来进行评估.

    from sklearn.datasets import load_iris
    from sklearn.cross_validation import cross_val_score
    from sklearn.svm import SVC
    
    datas=load_iris()
    X=datas.data
    y=datas.target
    
    
    rbf_c1=SVC(kernel='rbf',C=1.0)
    rbf_c2=SVC(kernel='rbf',C=2.0)
    
    result1=cross_val_score(rbf_c1,X,y,cv=6)
    print result1
    print result1.mean()
    
    result2=cross_val_score(rbf_c2,X,y,cv=6)
    print result2
    print result2.mean()
    
    #以下为输出结果
    [ 0.96296296  1.          1.          0.91666667  1.          1.        ]
    0.979938271605
    
    [ 0.96296296  1.          0.95833333  0.95833333  1.          1.        ]
    0.979938271605
    
    

    result表示进行6次简单交叉验证所得到的评分.我们可以看到两者6次的平均值都是一样的,也就是说选哪个模型都行了.

    K折交叉验证很好的帮我们解决了"参数"选择的问题,问什么要加引号呢? 是因为我们此时仅仅只是徘徊在2个(或者几个)参数的选择上,所以可以这样手动的进行模型选择.试想一下,如果有大量的参数呢? 例如上面的支持向量机中,最基本的就有C=1.0,gamma=′auto′C=1.0, gamma='auto'C=1.0,gamma=auto这两个参数,如果C和gamma的取值范围为都为1-10,那么这时就有100个模型,但总不能一个一个的来训练吧. 所以此时就要用到并行搜索.

    3.并行搜索

    由于超参数的空间是无尽的,因此超参数的组合配置只能是"更优"解,没有最优解.通常情况下我们依靠并行搜索对多种超参数组合进行暴力搜索.

    举例:使用支持向量机,对20newsgroups进行分类

    第一步:导入20newsgroups,将数据集分割成训练集和测试集;
    第二步:并且使用TFidf进行向量化;
    第三步:设置参数列表,并开始训练模型
    第四部:选择评分最高的模型(参数)

    注:此处的测试集不用于训练模型,在于测试模型的泛化能力

    # Setp 1.
    news=fetch_20newsgroups()
    X_train,X_test,y_train,y_test=train_test_split(news.data,news.target,test_size=0.25,random_state=3)
    
    # Setp 2.
    tfidf=TfidfVectorizer(analyzer='word',stop_words='english')
    X_train_tfidf=tfidf.fit_transform(X_train)
    X_test_tfidf=tfidf.transform(X_test)
    
    # Setp 3.(由于数据集特别大,花了19分钟才训练完成)
    parameters={'C':np.logspace(-1,1,2),'gamma':np.logspace(-2,1,3)}
    
    svc=SVC()
    gs=GridSearchCV(svc,parameters,n_jobs=-1,cv=5,verbose=1)
    gs.fit(X_train_tfidf,y_train)
    

    注意:

    (1).参数列表就是模型对应的参数名,如此处:

    SVC(self, C=1.0, kernel='rbf', degree=3, gamma='auto',coef0=0.0, shrinking=True, probability=False,tol=1e-3, cache_size=200, class_weight=None,verbose=False,max_iter=-1,decision_function_shape=None,random_state=None)
    

    (2).GridSearchCV()
    n_jobs默认值为1,表示只启动一个核进行运算;但由于K次交叉验证都是相互独立的,所以可以同时一起并行计算,n_jobs=-1表示所有核一起运算.
    cv=5表示5折交叉验证

    #Step 4.
    print gs.best_score_
    print gs.best_params_
    
    # 以下为输出结果
    # Fitting 5 folds for each of 6 candidates, totalling 30 fits
    # [Parallel(n_jobs=-1)]: Done  30 out of  30 | elapsed: 19.0min finished
    # 0.898055391868
    # {'C': 10.0, 'gamma': 0.31622776601683794}
    

    从上面我们可以看出,在C=[0.1,10.],gamma=[0.01,0.3162,10.]C=[0.1,10.], gamma=[0.01,0.3162,10.]C=[0.1,10.],gamma=[0.01,0.3162,10.]这6种组合中,当C=10,gamma=0.316C=10,gamma=0.316C=10,gamma=0.316时,模型的分类能力最强.我们可以用下面的方法来验证:

    svc1=SVC(C=0.1,gamma=0.01)
    svc2=SVC(C=10.0,gamma=0.316)
    svc1.fit(X_train_tfidf,y_train)
    svc2.fit(X_train_tfidf,y_train)
    print svc1.score(X_test_tfidf,y_test)
    print svc2.score(X_test_tfidf,y_test)
    
    # 输出结果
    #0.0922587486744
    #0.914457405444
    

    相差了不止一点点

    运行环境 python2.7 scikit-learn-0.18
    源码
    参考:

    • Python机器学习及实践
    • 统计学习方法

    更多内容欢迎扫码关注公众号月来客栈!
    在这里插入图片描述

    展开全文
  • 在上篇博客中,我们看到测试集和训练集在同一个模型上会表现不同的结果。我们通过学习曲线可以直观的看到具体过拟合还是欠拟合,从而调整参数,进行不断验证,直到找到一个在训练集表现好的数据。 总结一句话,...
  • 特征选择,归一化是数据处理中必备的两个步骤,交叉验证是模型评估以及超参数搜索中经常用到的方法。然而在实际操作中,初学者往往会有这样的**疑问**: (1)是先做特征选择还是先划分 训练集-验证集-测试集? (2...
  • 交叉验证 我们之前训练模型的时候呢会传一个或多个超参数(例如,学习率,阈值等)那我们...之前我们都把数据分为测试集和训练集,现在再把训练集进行拆分,分成和验证集和训练集。 流程:先用训练集拆分成两部...
  • 1. 当有训练集、验证集测试集的时候,可以通过验证集来监控模型是否发生过拟合,以及时停止训练,而测试集是用来评估最终模型泛化能力。当使用十折交叉验证后,九成的数据用作训练集,一成的数据用作验证集,在...
  • 1. 网格搜索GridSearchCV中,其实已经包含了交叉验证了(cv默认值10)。那通过网格搜索得到最优参数后,正式训练模型时,使用训练数据(用原始数据切分出训练数据测试数据),还是用完整的数据呢? ...
  • 模型的训练与验证 ...需要注意:无论训练集还是验证集有标签的,测试集是没有标签的。 2.有三种划分验证集方法 1.留一法2.交叉验证法3.自助采样法 3.模型的训练与验证 1.构造训练集和验证集 2.
  • 1)随着训练集样本数的增加,训练集的分数从最大值逐渐下降,而交叉验证集的分数从最小值逐渐上升,训练集的分数总是高于测试集的分数; 2)若训练集、验证集的准确率都很低,说明一个高偏差模型,属于欠拟合的...
  • 学习曲线什么?...左上角的偏差很高,训练集和验证集的准确率都很低,很可能欠拟合。我们可以增加模型参数,比如,构建更多的特征,减小正则项。此时通过增加数据量不起作用的。当训练集和...
  • 学习曲线就是通过画出不同训练集大小时训练集和交叉验证的准确率,可以看到模型在新数据上的表现,进而来判断模型是否方差偏高或偏差过高,以及增大训练集是否可以减小过拟合。 怎么解读? 当训练集和测试集的...
  • 学习曲线什么?学习曲线就是通过画出...左上角的偏差很高,训练集和验证集的准确率都很低,很可能欠拟合。我们可以增加模型参数,比如,构建更多的特征,减小正则项。此时通过增加数据量不起作用的。当训练集...
  • 模型的选择与调优 1、交叉验证 ...交叉验证是和网格搜索配合使用的: 超参数搜索-网格搜索API 还是拿K-近邻的代码来举例,加入了交叉验证和网格搜索: def knncls(): """ K-近邻预测用户签到位置 :ret
  • 算法评估

    2020-05-15 11:08:51
    在训练集上得到多组模型后,在交叉验证集上计算交叉验证误差,选取代价函数值最小的模型,在测试集上计算推广误差:代价函数、误分率等。 一般算法不理想,要么偏差大(欠拟合),要么方差大(过拟合)。 ...
  • 从一个简单的能快速实现的算法开始,实现该算法并用交叉验证集数据测试这个算法 绘制学习曲线,决定增加更多数据,或者添加更多特征,还是其他选择 进行误差分析:人工检查交叉验证集中我们算法中产生预测误差的...
  • 构建一个学习算法

    2019-07-30 22:32:55
    2.绘制学习曲线,通过观察学习曲线,判断模型欠拟合还是过拟合,然后决定通过增加测试集,增加特征,或者其他有效方法 3.进行误差分析,人工检查交叉验证集中算法判断错误的实例,看看这些实例是否有某种系统化的...
  • 还是说,只有在交叉验证的条件下,才需要这样切分数据? 顺便问下,这个数据集到底要怎么切分法?我问过人,据说常规情况下,大部分模型都需要设置超参的。而设置超参的话,就必须切分出验证集(该验证集用于超参...
  • 机器学习要点总结

    2021-01-27 17:42:54
    如果验证集测试集的准确率都较低,说明欠拟合;如果两者的准确率差异较大,说明过拟合。 过拟合的应对措施包括: 1)交叉验证,例如K折交叉验证。 2)用更多的数据参与训练,数据增强其中的一中方法,包括翻转、...
  •   机器学习领域,无论在工业界还是在学术界都存在着对模型...  将数据集分成3个互斥的集合:训练集、验证集测试集。 (2)交叉验证法(cross validation)   先将数据集划分成k个大小相似的互斥子集。然...
  • 模型评估与选择

    2018-07-18 18:08:57
    【1】测试数据:测试集、校验集 (1)误差越小,模型越好。 (2)在校验集中,数据量不是很大时,会采用k折交叉验证。每折都会计算出一个超参数,最后超参数取平均值。 (3)sklearn中,交叉验证和网格搜索合并为...
  • 机器学习的设计

    2019-06-02 21:20:42
    从一个简单的能快速实现的算法开始,实现该算法并用交叉验证集数据测试这个算法 ; 2). 绘制学习曲线,决定增加更多数据,或者添加更多特征,还是其他选择 ; 3). 进行误差分析:人工检查交叉验证集中我们算法中...
  • 一般导出Excel csv格式,通过python、R语言处理数据挖掘工具和平台python、R语言等caffee、tensorflow、python、R语言数据计算框架Spark实现数据计算数据显示R语言的数据呈现数据分析算法、挖掘算法划分数据和...
  • 从一个简单的能快速实现的算法开始,实现该算法并用交叉验证集数据测试这个算法 绘制学习曲线,决定增加更多数据,或者添加更多特征,还是其他选择 进行误差分析:人工检查交叉验证集中我们算法中产生预测误差的...
  • 以iris数据集合SVM分类器为例,使用sklearn的...2、划分训练集和测试集 3、设置超参数C=0.05, gamme=0.1训练SVM模型 交叉验证结果准确率0.86,结果好像还不错!!! 4、使用learning_curve绘制分类器学习曲线...
  • 当对结果进行交叉验证时 训练集和测试集结果表现都不行 则为欠拟合 当训练集结果大于预测集,,推测可能特征过于复杂,则为过拟合 欠拟合原因以及解决办法 原因:学习到数据的特征过少 解决办法: 增加数据的特征...
  • 从一个简单的能快速实现的算法开始,实现该算法并用交叉验证集数据测试这个算法 绘制学习曲线,决定增加更多数据,或者添加更多特征,还是其他选择 进行误差分析:人工检查交叉验证集中我们算法中产生预测误差的...

空空如也

空空如也

1 2 3
收藏数 56
精华内容 22
关键字:

交叉验证是测试集还是验证集