精华内容
下载资源
问答
  • R语言选模型/用AIC BIC adjustRsq 十折交叉验证 LOOCV等验证/择参 以fama三因子模型和CAMP模型为例@理科班的习习同学 引入包与数据预处理 install.packages("leaps") install.packages("car") install.packages(...

    R语言选模型/用AIC BIC adjustRsq 十折交叉验证 LOOCV等验证/择参 以fama三因子模型和CAMP模型为例@理科班的习习同学

    引入包与数据预处理

    install.packages("leaps") 
    install.packages("car") 
    install.packages("caret") 
    library("car")
    library("leaps") 
    library("heavy") 
    library("caret")
    mt=read.csv("XIXI-Data.csv")
    mt$X=as.Date(mt$X,"%Y/%m/%d") #修改日期格式并赋值给X列
    ff=read.csv("F-F_Research_Data_Factors_daily.csv",header=T,skip=4
    + )#引入三因子信息
    dat=merge(mt,ff,by= "X") #和另一个数据集按照日期进行拼接,如果本来就是一整个数据集,这两部可以忽略
    attach(dat)#方便后面写语句
    

    回归

    fama三因子模型的公式是
    下面是基本介绍:
    Here, Rt, RM,t and µt are the net returns of the asset, the market portfolio and the risk-free asset from t−1 to t, respectively. The market excess return is the first risk factor, while the second and the third ones are SMB (small minus big) and HML (high minus low). To be more specific, SMB is the difference in returns on a portfolio of small stocks and a portfolio of large stocks. “Small” and “big” refer to the size of the market value of a stock. HML is the difference in returns on a portfolio of high book-to-market value stocks and a portfolio of low book-tomarket value stocks. SMBt and HMLt are the differences in returns in the t-th period given by (t−1,t].

    > n=dim(dat)[1] #计算一列有多少数
    > R_g=Adj.Close[-1]/Adj.Close[-n] #后一项除以前一项算回报率
    > R_n=R_g-1 #净回报率
    > lef_term=(R_n-RF[-1]) #三因子模型的左边
    > reg1=lm(lef_term~Mkt.RF[-1]+SMB[-1]+HML[-1])#回归
    > vif(reg1)#计算vif 
    > #下面跟一段VIF的解释
    > # The VIF for Mkt.RF is 1.056693. It means its squared standard error is 1.056693 times larger than it would be if the other predictors are deleted or were not correlated with it. The same as the other 2 elements. The VIF of these 3 elements proved that they estimate their coefficient doesn’t have large errors which means there is not a collinearity problem.
    > summary(reg1)
    Call:
    lm(formula = lef_term ~ Mkt.RF[-1] + SMB[-1] + HML[-1])
    
    Residuals:
          Min        1Q    Median        3Q       Max 
    -0.049696 -0.005057  0.000259  0.005244  0.042138 
    
    Coefficients:
                  Estimate Std. Error t value Pr(>|t|)    
    (Intercept)  0.0003031  0.0003389   0.894    0.371    
    Mkt.RF[-1]   0.7387009  0.0417026  17.714  < 2e-16 ***
    SMB[-1]     -0.4195117  0.0697805  -6.012 2.87e-09 ***
    HML[-1]      0.0645699  0.0617378   1.046    0.296    
    ---
    Signif. codes:  0***0.001**0.01*0.05.0.1 ‘ ’ 1
    
    Residual standard error: 0.009249 on 748 degrees of freedom
    Multiple R-squared:  0.3052,    Adjusted R-squared:  0.3024 
    F-statistic: 109.5 on 3 and 748 DF,  p-value: < 2.2e-16
    

    CAMP模型拟合与比较

    > CAPM_reg1=lm(lef_term~Mkt.RF[-1])
    > summary(CAPM_reg1)
    
    Call:
    lm(formula = lef_term ~ Mkt.RF[-1])
    
    Residuals:
          Min        1Q    Median        3Q       Max 
    -0.049022 -0.004929  0.000278  0.005352  0.045007 
    
    Coefficients:
                 Estimate Std. Error t value Pr(>|t|)    
    (Intercept) 0.0003638  0.0003458   1.052    0.293    
    Mkt.RF[-1]  0.6924356  0.0415120  16.680   <2e-16 ***
    ---
    Signif. codes:  0***0.001**0.01*0.05.0.1 ‘ ’ 1
    
    Residual standard error: 0.009464 on 750 degrees of freedom
    Multiple R-squared:  0.2706,    Adjusted R-squared:  0.2696 
    F-statistic: 278.2 on 1 and 750 DF,  p-value: < 2.2e-16
    > BIC(reg1)
    [1] -4880.385
    > BIC(CAPM_reg1)
    [1] -4857.045
    #BIC越小越好,summary里有调整的R方信息,R方越接近1越好
    #十折交叉验证
    > reg_dif =data.frame(lef_term,Mkt.RF[-1],SMB[-1],HML[-1])
    > CAPM_dif=data.frame(lef_term,Mkt.RF[-1])
    > train.control=trainControl(method="cv",number=10)
    > set.seed(1)
    > reg_cv=train(lef_term~.,data=reg_dif,method="lm", trControl=train.control)
    > set.seed(1)
    > CAPM_reg_cv=train(lef_term~., data = CAPM_dif,method="lm", trControl=train.control)
    > TestMSE_FF=as.numeric(reg_cv$results[2])^2
    > TestMSE_CAPM=as.numeric(CAPM_reg_cv$results[2])^2
    > TestMSE_FF
    [1] 8.486705e-05
    > TestMSE_CAPM
    [1] 8.867714e-05
    #test error 越小越好
    #LOOCV交叉验证
    > train.control=trainControl(method="LOOCV")
    > set.seed(1)
    > reg_cv2=train(lef_term~.,data=reg_dif,method="lm", trControl=train.control) 
    > set.seed(1)
    > CAPM_reg_cv2=train(lef_term~., data = CAPM_dif,method="lm", trControl=train.control)
    > TestMSE_FF2=as.numeric(reg_cv2$results[2])^2
    > TestMSE_CAPM2=as.numeric(CAPM_reg_cv2$results[2])^2
    > TestMSE_FF2
    [1] 8.617911e-05
    > TestMSE_CAPM2
    [1] 8.984655e-05
    #test error 越小越好
    #上面都证明了要选fama三因子,拟合好
    

    择参

    
    > regsub=regsubsets(lef_term~.,data=reg_dif) #择参函数
    > regsub_sum=summary(regsub)
    > regsub_sum$which #可以看出穷举的留多少参数时选哪个参
      (Intercept) Mkt.RF..1. SMB..1. HML..1.
    1        TRUE       TRUE   FALSE   FALSE
    2        TRUE       TRUE    TRUE   FALSE
    3        TRUE       TRUE    TRUE    TRUE
    > plot(regsub_sum$adjr2,xlab="Number of Variables",ylab="Adjusted RSq",type = "l")#看参数数量如何影响调节R方
    > plot(regsub_sum$cp,xlab="Number of Variables",ylab="Cp",type = "l")
    > plot(regsub_sum$bic,xlab="Number of Variables",ylab="BIC",type = "l")
    > #十折交叉验证和LOOCV验证
    > train.control=trainControl(method="cv",number=10)
    > set.seed(1)
    > dif1=data.frame(lef_term,Mkt.RF[-1])
    > sub_reg_cv1=train(lef_term~., data = dif1,method="lm", trControl=train.control)
    > M1=as.numeric(sub_reg_cv1$results[2])^2
    > set.seed(1)
    > dif2=data.frame(lef_term,Mkt.RF[-1],SMB[-1])
    > sub_reg_cv2=train(lef_term~., data = dif2,method="lm", trControl=train.control)
    > M2=as.numeric(sub_reg_cv2$results[2])^2
    > set.seed(1)
    > dif3=data.frame(lef_term,Mkt.RF[-1],SMB[-1],HML[-1])
    > sub_reg_cv3=train(lef_term~., data = dif3,method="lm", trControl=train.control)
    > M3=as.numeric(sub_reg_cv3$results[2])^2
    > M1
    [1] 8.867714e-05
    > M2
    [1] 8.451847e-05
    > M3
    [1] 8.486705e-05
    
    
    展开全文
  • [PearsonR, PearsonP, SpearmanR, SpearmanP, yhat, R2 ] = BenStuff_CrossValCorr( x,y, [MathMagic], [OmNullModel] ) 留一法交叉验证的简单线性回归输入变量: x, y:数据向量(x(n) 和 y(n) 对应一对观测值) ...
  • 交叉验证LOOCV matlab代码GPR_loocv LOOCV 计算代码,用于确定从 GPR 剖面计算碎片厚度反演的阈值。 使用 xval_tsB.csv 中的真实厚度测量值来训练天线单元升高 27 cm 时的阈值,以及 xval_tsAC.csv 中天线单元为 19 ...
  • LOOCV交叉验证

    2019-05-31 00:25:33
    mlr=cv.glm(data=d,glmfit=ml,K=100) #k=n=100 #广义线性模型的交叉验证:估算K折交叉验证的预计误差 mlr$delta ml2=glm(y~poly(x,2),data=d) mlr2=cv.glm(data=d,glmfit=ml2,K=100) mlr2$delta ml3=glm(y~...

    #p是多少个变量x,p=1;n是100,记录了n行数据
    set.seed(1)
    y=rnorm(100)
    x=rnorm(100)
    y=x-2x^2+rnorm(100)
    plot(x,y)
    ##############
    set.seed(1)
    y=rnorm(100)
    x=rnorm(100)
    y=x-2
    x^2+rnorm(100)

    error=c() #因为循环里出现了error[i]
    d=cbind(x,y) #c是竖着合并 r是横着合并
    d=as.data.frame(d)
    #前两步可合并为 d= data.frame(x,y)

    for(i in 1:100)
    {
    m1=glm(y~x,data = d[-i,]) #去掉第i行的线性方程,此时一横行就是一个x+y了
    pred_m1=predict(m1,newdata=d[i,])
    error[i]=d[i,2]-pred_m1 #第i行第二列即y:真实值-预测值
    }
    sum(error^2)/dim(d)[1] #MSE LOOCV 1代表行,2代表列,即100

    ###################
    library(boot)
    ml=glm(y~x,data=d)
    mlr=cv.glm(data=d,glmfit=ml,K=100) #k=n=100 #广义线性模型的交叉验证:估算K折交叉验证的预计误差
    mlr$delta

    ml2=glm(y~poly(x,2),data=d)
    mlr2=cv.glm(data=d,glmfit=ml2,K=100)
    mlr2$delta

    ml3=glm(y~poly(x,3),data=d)
    mlr3=cv.glm(data=d,glmfit=ml3,K=100)
    mlr3$delta

    ml4=glm(y~poly(x,4),data=d)
    mlr4=cv.glm(data=d,glmfit=ml4,K=100)
    mlr4$delta

    ##########这样可以找最小的MSE
    error=c()
    E = c()
    d=data.frame(x,y)
    for (j in 1:4) {
    for (i in 1:100){
    m1=glm(y~poly(x,j),data=d[-i,])
    pred_m1=predict(m1,newdata=d[i,])
    error[i]=d[i,2]-pred_m1
    E[j]=sum(error^2)/dim(d)[1]
    }
    }
    which.min(E)

    展开全文
  • Python为给定模型执行留一法交叉验证实战LOOCV(leave-one-out cross-validation) 目录 Python为给定模型执行留一法交叉验证实战LOOCV(leave-one-out cross-validation) 加载必要的函数和库 创建仿真数据 ...

    Python为给定模型执行留一法交叉验证实战LOOCV(leave-one-out cross-validation)

    目录

    Python为给定模型执行留一法交叉验证实战LOOCV(leave-one-out cross-validation)

    展开全文
  • 交叉验证LOOCV matlab代码AMVML 基于自适应多视图多标签学习的潜在 miRNA-疾病关联预测 有关详细信息,请参阅 Readme.pdf 文件。 方法说明 AMVML 是一种计算框架,可以有效且可靠地发现潜在的疾病相关 miRNA。 它从...
  • 交叉验证LOOCV matlab代码明码表 用于潜在 miRNA 疾病关联预测的自加权多核多标签学习 有关详细信息,请参阅 Readme.pdf 文件。 方法说明 我们提出了一种新的自加权多核多标签学习方法,用于潜在的 miRNA 疾病关联...
  • 交叉验证LOOCV matlab代码basic_SVM Matlab 代码 此页面是使用basic_SVM (基本支持向量机)函数的快速手册。 此代码位于 basic_SVM是一组运行机器学习进行分类的函数。 它需要一组特征和相应的类作为输入。 目前它...
  • 交叉验证是什么? 在模型建立中,通常有两个数据集:训练集(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

    展开全文
  • 1. 交叉验证 1.1 简介 1.2 具体方法 1.3 留一交叉验证详解 2. looclass 命令 2.1 命令安装 2.2 命令语法 3. Stata 实操 4. 参考文献 5. 相关推文 1. 交叉验证 1.1 简介 在实际的训练中,训练...
  • 机器学习面试题集 - 详解四种交叉验证方法
  • 机器学习基础篇(四)——交叉验证 一、概述 交叉验证是在机器学习建立模型和验证模型参数时常用的办法。顾名思义,交叉验证就是重复的使用数据,把得到的样本数据进行切分,组合为不同的训练集和测试集,用训练集来...
  • k值交叉验证 交叉验证集Cross-Validation also referred to as out of sampling technique is an essential element of a data science project. It is a resampling procedure used to evaluate machine learning ...
  • SVM与交叉验证

    2012-05-24 09:17:33
    svm参数中的交叉验证法,并结合网格训练进行。
  • K折交叉验证 使用 train/test split 进行模型评估的缺点 ①最终模型与参数的选取将极大程度依赖于你对训练集和测试集的划分方法 ②该方法只用了部分数据进行模型的训练 为了消除这一变化因素,我们可以...
  • 拓端tecdat|R语言k折交叉验证

    千次阅读 2019-06-18 15:57:33
    “机器学习中需要把数据分为训练集和测试集,因此如何划分训练集和测试集就成为...K折交叉验证(k-fold cross-validation)首先将所有数据分割成K个子样本,不重复的选取其中一个子样本作为测试集,其他K-1个样本...
  • 交叉验证

    2020-07-19 14:05:03
    概述Holdout 交叉验证K-Fold 交叉验证Leave-P-Out 交叉验证总结概述交叉验证是在机器学习建立模型和验证模型参数时常用的办法。顾名思义,就是重复的使用数据,把得到的样...
  • 交叉验证 python

    千次阅读 2018-05-22 16:51:21
    以下简称交叉验证(Cross Validation)为CV.CV是用来验证分类器的性能一种统计分析方法,基本思想是把在某种意义下将原始数据(dataset)进行分组,一部分做为训练集(train set),另一部分做为验证集(validation set),首先...
  • 交叉验证LOOCV matlab代码fMRI 研究中的混合效应多级分析 (MEMA) 和典型相关分析 (CCA) 在留一主题交叉验证 (LOOCV) 中使用 MEMA 和 CCA 的分析框架指南 基于受试者间的异质性,从 fMRI 数据中寻找行为数据与神经元...
  • R语言交叉验证(详细)

    万次阅读 多人点赞 2018-01-23 17:09:47
    k-折交叉验证k-折交叉验证(K-fold cross-validation)是交叉验证方法里一种。它是指将样本集分为k份,其中k-1份作为训练数据集,而另外的1份作为验证数据集。用验证集来验证所得分类器或者模型的错误率。一般需要...
  • 深度学习(三)超参数与交叉验证

    千次阅读 2018-05-30 22:10:50
    超参数是指在机器学习中在算法训练开始前预设的一些参数值,这些参数值一般无法通过算法本身学会更改,比如KNN算法中的Manhattan distance(曼哈顿距离)、Euclidean ...超参数的确定可以通过交叉验证的方法。 ...
  • 1. The tenfold cross validation was used to determine parameters gamma, beta, and delta.
  • 交叉验证(也称为“过采样”技术)是数据科学项目的基本要素。 它是一种重采样过程,用于评估机器学习模型并访问该模型对独立测试数据集的性能。 在本文中,您可以阅读以下大约8种不同的交叉验证技术,各有其优缺点...
  • K折交叉验证,python 简单实现。

    千次阅读 2019-07-04 17:39:44
    K折交叉验证,英文名叫做K-fold cross-validation,用来测试算法准确性。是常用的测试方法。将数据集分成K份,轮流将其中K-1份作为训练数据,1份作为测试数据,进行试验。 # -*- coding:utf-8 -*- #author :xinle...
  • 交叉验证(也称为“过采样”技术)是数据科学项目的基本要素。 它是一种重采样过程,用于评估机器学习模型并访问该模型对独立测试数据集的性能。 在本文中,您可以阅读以下大约8种不同的交叉验证技术,各有其优缺点...
  • 我们还将学习交叉验证和执行它的各种方法。 模型的稳定性? 总是需要验证你的机器学习模型的稳定性。换句话说,你不能把这个模型与你的训练数据相匹配,并预测它的未来日期,然后希望它每次都能...

空空如也

空空如也

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

交叉验证loocv