K折验证

模块化的K折验证：

Scikit中提取带K-Fold接口的交叉验证接口sklearn.model_selection.cross_validate，但是该接口没有数据shuffle功能，所以一般结合Kfold一起使用。如果数据在分组前已经经过了shuffle处理，比如使用train_test_split分组，那就可以直接使用cross_val_score接口

cross_validate依然使用交叉验证的方法来进行模型的性能度量，它会返回一个字典来看模型的性能如何的，字典的key为：dict_keys([‘fit_time’, ‘score_time’, ‘test_score’, ‘train_score’])，表示的是模型的训练时间，测试时间，测试评分和训练评分。用两个时间参数和两个准确率参数来评估模型，这在我们进行简单的模型性能比较的时候已经够用了。

from sklearn import model_selection
cv_result = model_selection.cross_validate(model, train_data, train_lables, cv  = 10) #模型，训练集，训练标签，次数
print(cv_result['test_score'].mean())
print(cv_result)

• cross_val_score返回评分标准

>>> from sklearn import metrics
>>> 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, scoring='f1_macro')
>>> scores                                              
array([0.96..., 1.  ..., 0.96..., 0.96..., 1.        ])

• cross_val_predict 和 cross_val_score的使用方法是一样的，但是它返回的是一个使用交叉验证以后的输出值，而不是评分标准。它的运行过程是这样的，使用交叉验证的方法来计算出每次划分为测试集部分数据的值，知道所有的数据都有了预测值。假如数据划分为[1,2,3,4,5]份，它先用[1,2,3,4]训练模型，计算出来第5份的目标值，然后用[1,2,3,5]计算出第4份的目标值，直到都结束为止。

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_predict, KFold
lr = LogisticRegression()
kf = KFold(5,shuffle=True, random_state=1)
predictions = cross_val_predict(lr, features, target, cv=kf)#预测值
predictions = pd.Series(predictions)

自定义K折验证

• 数据划分

# 1> 数据划分 取20%做测试样本，剩下做训练样本
 
import pandas as pd
import numpy as np
dt = pd.read_excel('model.xls')
simpler = np.random.permutation(len(dt))
dt = dt.take(simpler) #导入随机函数shuffle，用来打乱数据 注意：不能用shuffle
dt = dt.as_matrix() #将表格转成矩阵格式

• 十折决策树算法

from sklearn.tree import DecisionTreeClassifier #导入决策树模型
from __future__ import division
from sklearn.metrics import confusion_matrix
p = 0.1 #设置训练集的比例
N = 1/p
correctRate = []
for i in range(int(N)):
    demotest = dt[int(len(dt)*(p*i)):int(len(dt)*(p*(i+1))), :]
    demotrain = np.row_stack((dt[:int(len(dt)*(p*i)), :], dt[int(len(dt)*(p*(i+1))):, :]))
    
    tree = DecisionTreeClassifier() # 建立决策树模型
    tree.fit(demotrain[:,:3], demotrain[:,3]) #训练模型
    
    predict_CartResult = tree.predict(demotest[:,:3]) # 测试模型
    cm = confusion_matrix(demotest[:,3], predict_CartResult)
    cRate = (cm[1,1] + cm[0,0]) / cm.sum()
    correctRate.append(cRate)
print sum(correctRate)/len(correctRate) # 求这是个正确率的均值 #predict_classes（随数据集的组合而变化）

• 十折LM神经网络

# #构建LM神经网络模型
from keras.models import Sequential #导入神经网络初始化函数
from keras.layers.core import Dense, Activation #导入神经网络层函数、激活函数
from __future__ import division
from sklearn.metrics import confusion_matrix
 
p = 0.1 #设置训练集的比例
N = 1/p
correctRateLM = []
for i in range(int(N)):
    demotest = dt[int(len(dt)*(p*i)):int(len(dt)*(p*(i+1))), :]
    demotrain = np.row_stack((dt[:int(len(dt)*(p*i)), :], dt[int(len(dt)*(p*(i+1))):, :]))
    
    net = Sequential() # 建立神经网络
    net.add(Dense(input_dim = 3, output_dim = 10)) # 添加输入层（3节点）到隐藏层（10节点）的连接
    net.add(Activation('relu')) # 隐藏层使用relu激活函数（通过实验确定的relu函数）
    net.add(Dense(input_dim = 10, output_dim = 1)) # 添加隐藏层（10节点）到输出层（1节点）的连接
    net.add(Activation('sigmoid')) # 输出层使用sigmoid激活函数
    net.compile(loss = 'binary_crossentropy', optimizer = 'adam',metrics=None)#编译模型，用adam方法求解
    net.fit(demotrain[:,:3], demotrain[:,3], nb_epoch=1000, batch_size=1)# 训练模型，循环1000次
    
    predict_result = net.predict_classes(demotest[:,:3]).reshape(len(demotest)) #预测结果变形,预测结果都是nx1维数组
    cm = confusion_matrix(demotest[:,3],predict_result)
    cRate = (cm[1,1] + cm[0,0]) / cm.sum()
    correctRateLM.append(cRate)
print sum(correctRateLM)/len(correctRateLM) # 求这是个正确率的均值