精华内容
下载资源
问答
  • 10折交叉验证

    2019-12-30 10:00:04
    我使用10折交叉验证 在10次epoch过程中应该不能更换数据集吧 那么使用交叉验证的话,需要10次epoch后更换数据集 10折交叉验证共训练100次模型? 是这样的吗? 不太清楚这个交叉验证的详细过程 ...

    这里有一个问题

    我的epoch=10

    我使用10折交叉验证

    在10次epoch过程中应该不能更换数据集吧

    那么使用交叉验证的话,需要10次epoch后更换数据集

    10折交叉验证共训练100次模型?

    是这样的吗?

    不太清楚这个交叉验证的详细过程

    展开全文
  • 随机森林的 10 折交叉验证再回到之前的随机森林(希望还没忘记,机器学习算法-随机森林初探(1))library(randomForest) set.seed(304) rf1000 &...

    随机森林的 10 折交叉验证

    再回到之前的随机森林(希望还没忘记,机器学习算法-随机森林初探(1)

    library(randomForest)
    set.seed(304)
    rf1000 <- randomForest(expr_mat, metadata[[group]], ntree=1000)
    rf1000
    
    ## 
    ## Call:
    ##  randomForest(x = expr_mat, y = metadata[[group]], ntree = 1000) 
    ##                Type of random forest: classification
    ##                      Number of trees: 1000
    ## No. of variables tried at each split: 84
    ## 
    ##         OOB estimate of  error rate: 11.69%
    ## Confusion matrix:
    ##       DLBCL FL class.error
    ## DLBCL    57  1  0.01724138
    ## FL        8 11  0.42105263

    除了 OOB,我们还可以怎么评估模型的准确性呢?这里没有测试集,那么就拿原始数据做个评估吧(注意:这样会低估预测错误率):

    # 查看模型的类,为randomForest
    class(rf1000)
    
    ## [1] "randomForest"
    
    # 查看 predict 函数的帮助,默认帮助信息为通用函数 predict 的
    # ?predict
    
    # 查看 randomForest 类的 predict 的帮助(predict+'.'+类名字)
    # 像 print 此类函数,也是如此查看帮助或源码
    #  type 参数: response 表示返回分类的值;prob 表示分类的概率;vote 表示 vote counts
    # ?predict.randomForest

    开始预测

    preds <- predict(rf1000, expr_mat, type="response")

    查看下preds对象,显示的是每个样品被预测为属于什么类。

    preds
    
    ##  DLBCL_1  DLBCL_2  DLBCL_3  DLBCL_4  DLBCL_5  DLBCL_6  DLBCL_7  DLBCL_8  DLBCL_9 DLBCL_10 DLBCL_11 
    ##    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL 
    ## DLBCL_12 DLBCL_13 DLBCL_14 DLBCL_15 DLBCL_16 DLBCL_17 DLBCL_18 DLBCL_19 DLBCL_20 DLBCL_21 DLBCL_22 
    ##    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL 
    ## DLBCL_23 DLBCL_24 DLBCL_25 DLBCL_26 DLBCL_27 DLBCL_28 DLBCL_29 DLBCL_30 DLBCL_31 DLBCL_32 DLBCL_33 
    ##    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL 
    ## DLBCL_34 DLBCL_35 DLBCL_36 DLBCL_37 DLBCL_38 DLBCL_39 DLBCL_40 DLBCL_41 DLBCL_42 DLBCL_43 DLBCL_44 
    ##    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL 
    ## DLBCL_45 DLBCL_46 DLBCL_47 DLBCL_48 DLBCL_49 DLBCL_50 DLBCL_51 DLBCL_52 DLBCL_53 DLBCL_54 DLBCL_55 
    ##    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL    DLBCL 
    ## DLBCL_56 DLBCL_57 DLBCL_58     FL_1     FL_2     FL_3     FL_4     FL_5     FL_6     FL_7     FL_8 
    ##    DLBCL    DLBCL    DLBCL       FL       FL       FL       FL       FL       FL       FL       FL 
    ##     FL_9    FL_10    FL_11    FL_12    FL_13    FL_14    FL_15    FL_16    FL_17    FL_18    FL_19 
    ##       FL       FL       FL       FL       FL       FL       FL       FL       FL       FL       FL 
    ## Levels: DLBCL FL

    计算模型效果评估矩阵(也称混淆矩阵),敏感性、特异性 100%。完美的模型!!!(这里主要是看下predict如何使用,完美的模型只是说构建的完美,不能表示预测性能的完美,因为没有用独立数据集进行评估。)

    library(caret)
    
    ## Warning: package 'caret' was built under R version 4.0.3
    
    ## Loading required package: lattice
    
    ## Loading required package: ggplot2
    
    ## 
    ## Attaching package: 'ggplot2'
    
    ## The following object is masked from 'package:randomForest':
    ## 
    ##     margin
    
    caret::confusionMatrix(preds, metadata[[group]])
    
    ## Confusion Matrix and Statistics
    ## 
    ##           Reference
    ## Prediction DLBCL FL
    ##      DLBCL    58  0
    ##      FL        0 19
    ##                                      
    ##                Accuracy : 1          
    ##                  95% CI : (0.9532, 1)
    ##     No Information Rate : 0.7532     
    ##     P-Value [Acc > NIR] : 3.343e-10  
    ##                                      
    ##                   Kappa : 1          
    ##                                      
    ##  Mcnemar's Test P-Value : NA         
    ##                                      
    ##             Sensitivity : 1.0000     
    ##             Specificity : 1.0000     
    ##          Pos Pred Value : 1.0000     
    ##          Neg Pred Value : 1.0000     
    ##              Prevalence : 0.7532     
    ##          Detection Rate : 0.7532     
    ##    Detection Prevalence : 0.7532     
    ##       Balanced Accuracy : 1.0000     
    ##                                      
    ##        'Positive' Class : DLBCL      
    ##

    predict还可以返回分类的概率 (有了这个是不是就可以绘制 ROC 曲线和计算AUC 值了)。

    preds_prob <- predict(rf1000, expr_mat, type="prob")
    head(preds_prob)
    
    ##         DLBCL    FL
    ## DLBCL_1 0.951 0.049
    ## DLBCL_2 0.972 0.028
    ## DLBCL_3 0.975 0.025
    ## DLBCL_4 0.984 0.016
    ## DLBCL_5 0.963 0.037
    ## DLBCL_6 0.989 0.011

    predict还可以返回分类的vote值。

    preds_prob <- predict(rf1000, expr_mat, type="vote")
    head(preds_prob)
    
    ##         DLBCL    FL
    ## DLBCL_1 0.951 0.049
    ## DLBCL_2 0.972 0.028
    ## DLBCL_3 0.975 0.025
    ## DLBCL_4 0.984 0.016
    ## DLBCL_5 0.963 0.037
    ## DLBCL_6 0.989 0.011

    前面主要是学习下predictconfusionMatrix函数的使用。把前面的代码串起来,就构成了一个随机森林的 10 折交叉验证代码:

    # https://stackoverflow.com/questions/47960427/how-to-calculate-the-oob-of-random-forest
    K = 10
    m = nrow(expr_mat)
    set.seed(1)
    kfold <- sample(rep(1:K, length.out=m), size=m, replace=F)
    
    randomForestCV <- function(x, y, xtest, ytest, type="response", seed=1, ...){
      set.seed(seed)
      model <- randomForest(x, y, ...)
      preds <- predict(model, xtest, type=type)
      return(data.frame(preds, real=ytest))
    }
    
    CV_rf <- lapply(1:K, function(x, ...){ 
      train_set = expr_mat[kfold != x,]
      train_label = metadata[[group]][kfold!=x]
    
      validate_set = expr_mat[kfold == x,]
      validate_label = metadata[[group]][kfold==x]
    
      randomForestCV(x=train_set, y=train_label, xtest=validate_set, ytest=validate_label, ...)
      })
    
    kfold_estimate <- do.call(rbind, CV_rf)

    查看下10 折交叉验证的预测结果

    kfold_estimate
    
    ##          preds  real
    ## DLBCL_3  DLBCL DLBCL
    ## DLBCL_8  DLBCL DLBCL
    ## DLBCL_9  DLBCL DLBCL
    ## DLBCL_35 DLBCL DLBCL
    ## DLBCL_57 DLBCL DLBCL
    ## FL_9     DLBCL    FL
    ## FL_10    DLBCL    FL
    ## FL_18       FL    FL
    ## DLBCL_15 DLBCL DLBCL
    ## DLBCL_16 DLBCL DLBCL
    ## DLBCL_40 DLBCL DLBCL
    ## DLBCL_41 DLBCL DLBCL
    ## DLBCL_42 DLBCL DLBCL
    ## DLBCL_44 DLBCL DLBCL
    ## DLBCL_51 DLBCL DLBCL
    ## DLBCL_53 DLBCL DLBCL
    ## DLBCL_5  DLBCL DLBCL
    ## DLBCL_20 DLBCL DLBCL
    ## DLBCL_25 DLBCL DLBCL
    ## DLBCL_32 DLBCL DLBCL
    ## DLBCL_38 DLBCL DLBCL
    ## FL_2     DLBCL    FL
    ## FL_12    DLBCL    FL
    ## FL_16       FL    FL
    ## DLBCL_4  DLBCL DLBCL
    ## DLBCL_6  DLBCL DLBCL
    ## DLBCL_10 DLBCL DLBCL
    ## DLBCL_14 DLBCL DLBCL
    ## DLBCL_18 DLBCL DLBCL
    ## DLBCL_39 DLBCL DLBCL
    ## FL_1     DLBCL    FL
    ## FL_6        FL    FL
    ## DLBCL_17 DLBCL DLBCL
    ## DLBCL_19 DLBCL DLBCL
    ## DLBCL_22 DLBCL DLBCL
    ## DLBCL_33 DLBCL DLBCL
    ## DLBCL_36 DLBCL DLBCL
    ## DLBCL_45 DLBCL DLBCL
    ## DLBCL_47 DLBCL DLBCL
    ## FL_11    DLBCL    FL
    ## DLBCL_13 DLBCL DLBCL
    ## DLBCL_23 DLBCL DLBCL
    ## DLBCL_37 DLBCL DLBCL
    ## DLBCL_52 DLBCL DLBCL
    ## FL_3        FL    FL
    ## FL_5        FL    FL
    ## FL_17    DLBCL    FL
    ## FL_19       FL    FL
    ## DLBCL_11 DLBCL DLBCL
    ## DLBCL_12 DLBCL DLBCL
    ## DLBCL_27 DLBCL DLBCL
    ## DLBCL_28 DLBCL DLBCL
    ## DLBCL_54 DLBCL DLBCL
    ## DLBCL_56 DLBCL DLBCL
    ## DLBCL_58 DLBCL DLBCL
    ## FL_14    DLBCL    FL
    ## DLBCL_1  DLBCL DLBCL
    ## DLBCL_26    FL DLBCL
    ## DLBCL_29    FL DLBCL
    ## DLBCL_43 DLBCL DLBCL
    ## DLBCL_50 DLBCL DLBCL
    ## FL_8     DLBCL    FL
    ## FL_15       FL    FL
    ## DLBCL_2  DLBCL DLBCL
    ## DLBCL_7  DLBCL DLBCL
    ## DLBCL_48 DLBCL DLBCL
    ## DLBCL_55 DLBCL DLBCL
    ## FL_4        FL    FL
    ## FL_7        FL    FL
    ## FL_13       FL    FL
    ## DLBCL_21 DLBCL DLBCL
    ## DLBCL_24 DLBCL DLBCL
    ## DLBCL_30 DLBCL DLBCL
    ## DLBCL_31 DLBCL DLBCL
    ## DLBCL_34 DLBCL DLBCL
    ## DLBCL_46 DLBCL DLBCL
    ## DLBCL_49 DLBCL DLBCL

    计算模型效果评估矩阵(也称混淆矩阵)。准确性值为0.8581,OOB 的错误率是88.31%,相差不大。但Kappa值不算高0.5614,这也是数据集中两个分组的样本数目不均衡导致的。

    library(caret)
    caret::confusionMatrix(kfold_estimate$preds, kfold_estimate$real)
    
    ## Confusion Matrix and Statistics
    ## 
    ##           Reference
    ## Prediction DLBCL FL
    ##      DLBCL    56  9
    ##      FL        2 10
    ##                                           
    ##                Accuracy : 0.8571          
    ##                  95% CI : (0.7587, 0.9265)
    ##     No Information Rate : 0.7532          
    ##     P-Value [Acc > NIR] : 0.01936         
    ##                                           
    ##                   Kappa : 0.5614          
    ##                                           
    ##  Mcnemar's Test P-Value : 0.07044         
    ##                                           
    ##             Sensitivity : 0.9655          
    ##             Specificity : 0.5263          
    ##          Pos Pred Value : 0.8615          
    ##          Neg Pred Value : 0.8333          
    ##              Prevalence : 0.7532          
    ##          Detection Rate : 0.7273          
    ##    Detection Prevalence : 0.8442          
    ##       Balanced Accuracy : 0.7459          
    ##                                           
    ##        'Positive' Class : DLBCL           
    ## 
    
    # 结果如下

    其它指标前面大都有讲述或?confusionMatrix可看到对应的计算公式。

    重点看下Kappa系数,其也是评估分类准确性的一个指标。在模型评估指标一文有提到,准确性值在各个分类样本不平衡时会更多偏向样品多的类。而Kappa系数则可以综合评估这种不平衡性。Kappa系数在-1和1之间,值越大表示模型性能越好。

    • Kappa=0说明模型和瞎猜差不多。

    • Kappa>0.4说明模型还行。

    • Kappa>0.4说明模型挺好的。

    • 这几个标准未找到确切文献,仅供参考来理解 Kappa 系数。

    其计算公式如下:

    1. 机器学习算法 - 随机森林之决策树初探(1)

    2. 机器学习算法-随机森林之决策树R 代码从头暴力实现(2)

    3. 机器学习算法-随机森林之决策树R 代码从头暴力实现(3)

    4. 机器学习算法-随机森林之理论概述

    5. 随机森林拖了这么久,终于到实战了。先分享很多套用于机器学习的多种癌症表达数据集 https://file.biolab.si/biolab/supp/bi-cancer/projections/。

    6. 机器学习算法-随机森林初探(1)

    7. 机器学习 模型评估指标 - ROC曲线和AUC值

    8. 机器学习 - 训练集、验证集、测试集

    往期精品(点击图片直达文字对应教程)

    后台回复“生信宝典福利第一波”或点击阅读原文获取教程合集

     

    (请备注姓名-学校/企业-职务等)

    展开全文
  • 10折交叉验证深入理解

    万次阅读 多人点赞 2018-12-25 15:22:08
    交叉验证(Cross Validation),有的时候也称作循环估计(Rotation Estimation),是一种统计学上将数据样本切割成较小子集的实用方法,该理论是由Seymour Geisser提出的。 在给定的建模样本中,拿出大部分样本进行...

    交叉验证(Cross Validation),有的时候也称作循环估计(Rotation Estimation),是一种统计学上将数据样本切割成较小子集的实用方法,该理论是由Seymour Geisser提出的。
    在给定的建模样本中,拿出大部分样本进行建模型,留小部分样本用刚建立的模型进行预报,并求这小部分样本的预报误差,记录它们的平方加和。这个过程一直进行,直到所有的样本都被预报了一次而且仅被预报一次。把每个样本的预报误差平方加和,称为PRESS(predicted Error Sum of Squares)。
    常用的精度测试方法主要是交叉验证,例如10折交叉验证(10-fold cross validation),将数据集分成十份,轮流将其中9份做训练1份做验证,10次的结果的均值作为对算法精度的估计,一般还需要进行多次10折交叉验证求均值,例如:10次10折交叉验证,以求更精确一点。这个方法的优势在于,同时重复运用随机产生的子样本进行训练和验证,每次的结果验证一次。

    
    """这里是正确的代码"""
    def cross_10folds(data,folds,jiange,start_index,end_index):
        df_test=data[start_index*jiange:end_index*jiange]  #数据刚好可以做10折交叉验证。
        df_test_index=list(df_test.index)
        df_test_flag=data.index.isin(df_test_index)  #都转换为list来判定成员资格
        diff_flag = [not f for f in df_test_flag] # 不是df_test_flag里面的索引的索引记为df_train_index的索引集合
        df_train= data[diff_flag]
        return df_train,df_test
    
    path='C:/Users/Administrator/Desktop/zhou1.csv'
    columns1=['cid','side_effects']
    import pandas as pd
    #data=pd.read_csv(path)[:100]  #经验证划分完全正确
    data=pd.read_csv(path)
    data.columns=columns1
    folds=10
    jiange=int(data.shape[0]/folds)
    #10次10折交叉验证的代码
    for i in range(1,11):
    	#将数据集随机打散
    	data=data.sample(frac = 1) #随机打乱样本
    	for i in range(1,folds+1):
    	    df_train,df_test=cross_10folds(data,folds,jiange,i-1,i) #起始和尾部索引
    	    df_train.to_csv('C:/Users/Administrator/Desktop/zhou/train_'+str(i)+'.csv',index=True,header=True) #检验对了再改成False
    	    df_test.to_csv('C:/Users/Administrator/Desktop/zhou/test_'+str(i)+'.csv',index=True,header=True)
    
    

    1.matlab版本代码实现:

    %十折交叉验证\
    [m,n]=size(train_bags);     %蛋白质的数量的个数
    indices=crossvalind('Kfold',m,10);
    temp_Hamming_Loss=zeros(1,10);
    temp_Macro_F1=zeros(1,10);
    temp_Micro_F1=zeros(1,10);
    for k=1:1:10
        test=(indices==k);  %获取验证集,但是最后替换掉了
        train=~test;
        train_data=train_bags(train,:);   %训练集的包
        train_target=train_lable(:,train);  %训练集的标记
        test_bags=train_bags(test,:);          %十折交叉验证的测试集包
        test_target=train_lable(:,test);        %十折交叉验证的测试集标记
    

    2.Python3版本代码实现:
    2.1.简易5折交叉验证分割结果打印:未随机打散的情形下

    #简易5折交叉验证分割结果打印:未随机打散的情形下
    from sklearn.cross_validation import KFold
    kf = KFold(150,n_folds=5, shuffle=False)
    for eachfold in kf:
        print(eachfold,'=========') #kf是一个长度为5的list,list中的每个元素是一次10折交叉验证的划分结果。
    

    5折交叉验证划分结果的前半部分是trainset,后半部分是testset

    (array([ 30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,
            43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,
            56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,
            69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,
            82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,
            95,  96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107,
           108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
           121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
           134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
           147, 148, 149]), array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
           17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]))
    ====================================================
    (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
            13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
            26,  27,  28,  29,  60,  61,  62,  63,  64,  65,  66,  67,  68,
            69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,
            82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,
            95,  96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107,
           108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
           121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
           134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
           147, 148, 149]), array([30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
           47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59]))
    ====================================================
    (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
            13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
            26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
            39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
            52,  53,  54,  55,  56,  57,  58,  59,  90,  91,  92,  93,  94,
            95,  96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107,
           108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
           121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
           134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
           147, 148, 149]), array([60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
           77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89]))
    ====================================================
    (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
            13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
            26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
            39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
            52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
            65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
            78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89, 120,
           121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
           134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
           147, 148, 149]), array([ 90,  91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102,
           103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
           116, 117, 118, 119]))
    ====================================================
    (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
            13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
            26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
            39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
            52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
            65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
            78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
            91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103,
           104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
           117, 118, 119]), array([120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
           133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
           146, 147, 148, 149]))
    

    2.2.随机打散数据并做10次10折交叉验证

    # -*- coding: utf-8 -*-
    import numpy as np
    from sklearn import cross_validation
    from sklearn import datasets
    from sklearn import svm
    iris = datasets.load_iris()
    X=iris.data
    Y=iris.target
    
    def tenFolds(X,Y):
        from sklearn.model_selection import StratifiedKFold
        skf= StratifiedKFold(n_splits=10)
        from sklearn.cross_validation import cross_val_score
        clf = svm.SVC(kernel='linear', C=5)
        zhou=[]
        #shoushou=list(skf.split(X,Y)) #发现每一个都是tuple类型的数据
        for train_index,test_index in skf.split(X,Y):
            print('Train: ',train_index,'Test: ',test_index)
            X_train,X_test=X[train_index],X[test_index]
            Y_train,Y_test=Y[train_index],Y[test_index]
            v10=cross_val_score(clf,X_train,Y_train,cv=5).mean() 
            zhou.append(v10)
        print('均值:',np.mean(zhou)) 
        print('方差:',np.std(zhou)) 
        return zhou,np.mean(zhou)+np.std(zhou)
    
    # X:features  Y:targets  cv:k
    import pandas as pd
    all_valid=[]
    mean_var=[]
    #做10次10折交叉验证结果分析
    for i in range(1,11):
        df1=pd.DataFrame(X)
        df2=pd.DataFrame(Y)
        df3=pd.concat([df1,df2],axis=1)
        df3.columns=['f1','f2','f3','f4','label']
        df3=df3.sample(frac = 1) #随机打乱样本
        df3.index=range(150)
        X1=np.array(df3[['f1','f2','f3','f4']])
        Y1=np.array(df3['label'])
        zhou,vsd= tenFolds(X1,Y1)
        all_valid.append(zhou)
        mean_var.append(vsd)
    np.mean(mean_var) 
    

    all_valid

    [0.9777777777777776, 0.962962962962963, 0.962962962962963, 0.9703703703703702, 0.9703703703703702, 0.9703703703703702, 0.9777777777777779, 0.9555555555555555, 0.9555555555555555, 0.9703703703703702]
    [0.9555555555555555, 0.9703703703703704, 0.962962962962963, 0.9555555555555555, 0.9703703703703704, 0.962962962962963, 0.9703703703703702, 0.9925925925925926, 0.9703703703703702, 0.9777777777777776]
    [0.9703703703703704, 0.9777777777777779, 0.9555555555555555, 0.9703703703703704, 0.9703703703703704, 0.9481481481481481, 0.9703703703703704, 0.962962962962963, 0.962962962962963,
     0.9777777777777779]
    [0.9703703703703702, 0.9703703703703702, 0.962962962962963, 0.9851851851851852, 0.962962962962963, 0.962962962962963, 
    0.9703703703703702, 0.9777777777777779, 0.9703703703703702, 0.9703703703703702]
    [0.9777777777777779, 0.962962962962963, 0.9555555555555555, 0.962962962962963, 0.962962962962963, 0.9555555555555555, 
    0.9703703703703702, 0.9777777777777776, 0.9407407407407407, 0.9777777777777776]
    [0.9481481481481481, 0.9703703703703704, 0.9777777777777779, 0.9407407407407409, 0.962962962962963, 0.9555555555555555, 0.9555555555555555, 0.962962962962963, 0.9703703703703702, 0.9851851851851852]
    [0.9777777777777776, 0.9777777777777776, 0.9777777777777776, 0.9703703703703704, 0.9925925925925926, 0.9851851851851852, 0.9777777777777779, 0.9703703703703704, 0.9703703703703704, 0.9851851851851852]
    [0.962962962962963, 0.9703703703703702, 0.9703703703703704, 0.962962962962963, 0.9703703703703702, 0.9777777777777779, 0.9481481481481481, 0.9555555555555555, 0.9481481481481481, 0.9555555555555557]
    [0.962962962962963, 0.9703703703703702, 0.9555555555555555, 0.9703703703703704, 0.9703703703703702, 0.962962962962963, 0.9703703703703702, 0.962962962962963, 0.9555555555555555, 
    0.962962962962963]
    [0.9703703703703702, 0.962962962962963, 0.9555555555555555, 0.962962962962963, 0.9703703703703702, 0.9703703703703702, 0.9777777777777779, 0.9851851851851852, 0.9777777777777779, 0.9703703703703702]
    

    mean_var

    0.9749615103905077
    0.9792592592592592
    0.9755863663546611
    0.9769957569703696
    0.975823919626472
    0.9757929689449547
    0.9855066526904122
    0.9718518518518519
    0.9699876405729984
    0.9784847786297061
    

    分层交叉验证和不平衡数据集的处理:
    https://blog.csdn.net/asialee_bird/article/details/83714612
    Python smote例程:使用sklearn的make_classification生成不平衡数据样本
    https://blog.csdn.net/levy_cui/article/details/86707049

    展开全文
  • DataFrame中自己手动做10折交叉验证时,实现采样出一折后,对原始的总的数据的索引集合与采样出的那一折的索引集合做差,获得另外的9折的索引用于构造训练集。 &amp;amp;quot;&amp;amp;quot;&amp;amp;...

    DataFrame中自己手动做10折交叉验证时,实现采样出一折后,对原始的总的数据的索引集合与采样出的那一折的索引集合做差,获得另外的9折的索引用于构造训练集。

    """1.10折交叉验证中数据的随机划分函数"""
    def cross_10folds(path,columns1):
        import pandas as pd
        #data=pd.read_csv(path)[:100]  #经验证划分完全正确
        data=pd.read_csv(path)
        #将数据集随机打散
        #data.sort_index(inplace=True)  #这个函数好像没有实现打散功能
        data.sample(frac = 1) 
        data.columns=columns1
        folds=10
        df_test=data.sample(n=int(data.shape[0]/folds))  #数据刚好可以做10折交叉验证。
        df_test_index=list(df_test.index)
        #下面是索引做差集的关键原理和代码
        df_test_flag=data.index.isin(df_test_index)  #转换为list来判定成员资格
        diff_flag = [not f for f in df_test_flag] # 不是df_test_flag里面的索引的索引记为df_train_index的索引集合
        df_train= data[diff_flag]
        return df_train,df_test
    path='C:/Users/Administrator/Desktop/zhou1.csv'
    columns=['cid','side_effects']
    df_train,df_test=cross_10folds(path,columns)
    
    
    """2.如果进行10次10折交叉验证"""
    path='C:/Users/Administrator/Desktop/zhou1.csv'
    columns=['cid','side_effects']
    for i in range(1,11):
        df_train,df_test=cross_10folds(path,columns)
        #下面的代码还不能运行,仅代表思路,数据还得处理成数值后才可使用。
        from sklearn.model_selection import train_test_split
        X_train,X_test,y_train,y_test=train_test_split( df_train[:-1],df_train[-1], test_size=0.33, random_state=42)
        #下面是数据的标准化
        from sklearn.preprocessing import StandardScaler
        ss=StandardScaler()
        X_train=ss.fit_transform(X_train)
        X_test=ss.transform(X_test)
        #交叉验证阶段
        from sklearn.cross_validation import cross_val_score
        from sklearn.ensemble import RandomForestClassifier
        rfc=RandomForestClassifier()
        cross_val_score(rfc,X_train,y_train,cv=5) #5折交叉验证
        #模型训练
        rfc.fit(X_train,y_train)
        #预测
        y_predict=rfc.predict(X_test)
        print("准确率:ACC=",rfc.score(y_predict,y_test))
        
        
    
    import pandas as pd
    data=pd.read_csv('C:/Users/Administrator/Desktop/zhou1.csv')
    data.columns=['cid','side_effects']
    folds=10
    df_test=data.sample(n=int(data.shape[0]/folds))  #数据刚好可以做10折交叉验证。
    df_test.index=range(len(df_test))
    df_test_index=list(df_test.index)
    data_index=list(data.index)
    #前面也可以是DataFrame的某一个属性列的内容
    #df_test_flag=data[data.columns[0]].isin(df_test.index) 
    df_test_flag=data.index.isin(df_test.index)  #都转换为list来判定成员资格
    diff_flag = [not f for f in df_test_flag] # 不是df_test_flag里面的索引的索引记为df_train_index的索引集合
    df_train= data[diff_flag] # 重置index 
    #df_train.index = [i for i in range(len(df_train))]
    
    

    做10次10折交叉验证的数据划分,获取10份测试集和10份训练集

    def cross_10folds(data,folds,jiange,start_index,end_index):
        df_test=data[start_index*jiange:end_index*jiange]  #数据刚好可以做10折交叉验证。
        df_test_index=list(df_test.index)
        df_test_flag=data.index.isin(df_test_index)  #都转换为list来判定成员资格
        diff_flag = [not f for f in df_test_flag] # 不是df_test_flag里面的索引的索引记为df_train_index的索引集合
        df_train= data[diff_flag]
        return df_train,df_test
    
    path='C:/Users/Administrator/Desktop/zhou1.csv'
    columns1=['cid','side_effects']
    import pandas as pd
    #data=pd.read_csv(path)[:100]  #经验证划分完全正确
    data=pd.read_csv(path)
    data.columns=columns1
    folds=10
    jiange=int(data.shape[0]/folds)
    #将数据集随机打散
    data=data.sample(frac = 1) #随机打乱样本
    for i in range(1,folds+1):
        df_train,df_test=cross_10folds(data,folds,jiange,i-1,i) #起始和尾部索引
        df_train.to_csv('C:/Users/Administrator/Desktop/zhou/train_'+str(i)+'.csv',index=True,header=True) #检验对了再改成False
        df_test.to_csv('C:/Users/Administrator/Desktop/zhou/test_'+str(i)+'.csv',index=True,header=True)
    
    
    展开全文
  • 十折交叉验证英文名叫做10-fold cross-validation,用来测试...10次的结果的正确率(或差错率)的平均值作为对算法精度的估计,一般还需要进行多次10折交叉验证(例如10次10折交叉验证),再求其均值,作为对算法...
  • 横截面数据分类的经典方法:logit回归,probit回归,lda判别分析,mda判别分析,fda判别分析。...通过10折交叉验证从误判率最低的角度选择模型。//显示结果 logistic lda mda fda 1 0.25806452 0....
  • 决策树代码Python(包含GINI,信息熵构建方法,10折交叉验证,Adaboost以及Boost方法)
  • matlab.10折交叉验证

    2020-12-26 21:54:24
    clc clear all % 导入数据 ...indices = crossvalind('Kfold', data_r, 10); for i = 1 : 10 % 获取第i份测试数据的索引逻辑值 test = (indices == i); % 取反,获取第i份训练数据的索引逻辑值 trai
  • function [cvmse,gam_best,sig2_best] = crossvalidate(Xtrain,Ytrain,gam_min,gam_max,sig2_min,sig2_max,k)%%%%%%%%%%%%%%%%子程序_交叉验证程序%%%函数输入:Xtrain-训练集的输入,Ytrain-训练集的输出,gam_min-...
  • 本节书摘来自异步社区出版社《写给程序员的数据挖掘实践指南》...5.2. 10折交叉验证的例子 第1步,将数据等分到10个桶中。 我们会将50名篮球运动员和50名非篮球运动员分到每个桶中。每个桶当中放入了100人的信息。 ...
  • ML之回归预测之Lasso:利用Lasso算法解决回归(实数值评分预测)问题—采用10折交叉验证(测试集error)来评估LassoCV模型 目录 输出结果 设计思路 核心代码 输出结果 设计思路 核心代码 ...
  • 10折交叉验证 我们构建一个分类器,输入为运动员的身高、体重,输出为其从事的体育项目-体操、田径或篮球。 一旦构建了分类器,我们就可能有兴趣回答类似下述的问题: 1. 该分类器的精确率怎么样? 2. 该分类器...
  • 10折交叉验证我们构建一个分类器,输入为运动员的身高、体重,输出为其从事的体育项目-体操、田径或篮球。 一旦构建了分类器,我们就可能有兴趣回答类似下述的问题: 1. 该分类器的精确率怎么样? 2. 该...
  • #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sun Sep 30 17:12:12 2018 ...所以采用了交叉验证的方式,最终测试集与训练集的准确率能够达到99%,应该是有点过拟合了,结果还是非常满意的。
  • #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sun Sep 30 17:12:12 2018 这是用...所以采用了交叉验证的方式,最终测试集与训练集的准确率能够达到99%,应该是有点过拟合了,结果还是非常满意的。
  • """ Author: Victoria Created on: 2017.9.15 11:00 """ import numpy as np import matplotlib.pyplot as plt def readData(): ...最终输出10折交叉验证和留一法错误率一样 查看完成代码及数据集
  • import numpy as np ...CV = 10 testNum = int(np.floor(n / CV)) tempCake = [i for i in range(n)] for i in range(CV): wholeCake = np.array([i for i in range(n)]) testIndices = np.random.cho...
  • 这道题仍然在抄大神代码的...感想是:sklearn是个好东西,如果没有现成的验证方法,光是10折验证就要造10个表格才行,而用现成的库,一行搞定,嗨森。 sklearn的API文档已收藏书签:http://scikit-learn.org/stab...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 382
精华内容 152
关键字:

10折交叉验证