1 什么是随机森林？
　　作为新兴起的、高度灵活的一种机器学习算法，随机森林（Random Forest，简称RF）拥有广泛的应用前景，从市场营销到医疗保健保险，既可以用来做市场营销模拟的建模，统计客户来源，保留和流失，也可用来预测疾病的风险和病患者的易感性。最初，我是在参加校外竞赛时接触到随机森林算法的。最近几年的国内外大赛，包括2013年百度校园电影推荐系统大赛、2014年阿里巴巴天池大数据竞赛以及，参赛者对随机森林的使用占有相当高的比例。此外，据我的个人了解来看，一大部分成功进入答辩的队伍也都选择了Random Forest 或者 GBDT 算法。所以可以看出，Random Forest在准确率方面还是相当有优势的。
　　那说了这么多，那随机森林到底是怎样的一种算法呢？
　　如果读者接触过决策树（Decision Tree）的话，那么会很容易理解什么是随机森林。随机森林就是通过集成学习的思想将多棵树集成的一种算法，它的基本单元是决策树，而它的本质属于机器学习的一大分支&&集成学习（Ensemble Learning）方法。随机森林的名称中有两个关键词，一个是&随机&，一个就是&森林&。&森林&我们很好理解，一棵叫做树，那么成百上千棵就可以叫做森林了，这样的比喻还是很贴切的，其实这也是随机森林的主要思想--集成思想的体现。&随机&的含义我们会在下边部分讲到。
　　其实从直观角度来解释，每棵决策树都是一个分类器（假设现在针对的是分类问题），那么对于一个输入样本，N棵树会有N个分类结果。而随机森林集成了所有的分类投票结果，将投票次数最多的类别指定为最终的输出，这就是一种最简单的 Bagging 思想。
2 随机森林的特点
　　我们前边提到，随机森林是一种很灵活实用的方法，它有如下几个特点：
在当前所有算法中，具有极好的准确率/It is unexcelled in accuracy among current algorithms；
能够有效地运行在大数据集上/It runs efficiently on large data bases；
能够处理具有高维特征的输入样本，而且不需要降维/It can handle thousands of input variables without variable deletion；
能够评估各个特征在分类问题上的重要性/It gives estimates of what variables are important in the classification；
在生成过程中，能够获取到内部生成误差的一种无偏估计/It generates an internal unbiased estimate of the generalization error as the forest building progresses；
对于缺省值问题也能够获得很好得结果/It has an effective method for estimating missing data and maintains accuracy when a large proportion of the data are missing
　　实际上，随机森林的特点不只有这六点，它就相当于机器学习领域的Leatherman（多面手），你几乎可以把任何东西扔进去，它基本上都是可供使用的。在估计推断映射方面特别好用，以致都不需要像SVM那样做很多参数的调试。具体的随机森林介绍可以参见随机森林主页：。
3 随机森林的相关基础知识
　　随机森林看起来是很好理解，但是要完全搞明白它的工作原理，需要很多机器学习方面相关的基础知识。在本文中，我们简单谈一下，而不逐一进行赘述，如果有同学不太了解相关的知识，可以参阅其他博友的一些相关博文或者文献。
　　1）信息、熵以及信息增益的概念
　　这三个基本概念是决策树的根本，是决策树利用特征来分类时，确定特征选取顺序的依据。理解了它们，决策树你也就了解了大概。
　　引用香农的话来说，信息是用来消除随机不确定性的东西。当然这句话虽然经典，但是还是很难去搞明白这种东西到底是个什么样，可能在不同的地方来说，指的东西又不一样。对于机器学习中的决策树而言，如果带分类的事物集合可以划分为多个类别当中，则某个类（xi）的信息可以定义如下:
　　I(x)用来表示随机变量的信息，p(xi)指是当xi发生时的概率。
　　熵是用来度量不确定性的，当熵越大，X=xi的不确定性越大，反之越小。对于机器学习中的分类问题而言，熵越大即这个类别的不确定性更大，反之越小。
　　信息增益在决策树算法中是用来选择特征的指标，信息增益越大，则这个特征的选择性越好。
　　这方面的内容不再细述，感兴趣的同学可以看&&这篇博文。
　　2）决策树
　　决策树是一种树形结构，其中每个内部节点表示一个属性上的测试，每个分支代表一个测试输出，每个叶节点代表一种类别。常见的决策树算法有C4.5、ID3和CART。
　　3）集成学习　
　　集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成单预测，因此优于任何一个单分类的做出预测。
　　随机森林是集成学习的一个子类，它依靠于决策树的投票选择来决定最后的分类结果。你可以在这找到用python实现集成学习的文档：。
4 随机森林的生成
　　前面提到，随机森林中有许多的分类树。我们要将一个输入样本进行分类，我们需要将输入样本输入到每棵树中进行分类。打个形象的比喻：森林中召开会议，讨论某个动物到底是老鼠还是松鼠，每棵树都要独立地发表自己对这个问题的看法，也就是每棵树都要投票。该动物到底是老鼠还是松鼠，要依据投票情况来确定，获得票数最多的类别就是森林的分类结果。森林中的每棵树都是独立的，99.9%不相关的树做出的预测结果涵盖所有的情况，这些预测结果将会彼此抵消。少数优秀的树的预测结果将会超脱于芸芸&噪音&，做出一个好的预测。将若干个弱分类器的分类结果进行投票选择，从而组成一个强分类器，这就是随机森林bagging的思想（关于bagging的一个有必要提及的问题：bagging的代价是不用单棵决策树来做预测，具体哪个变量起到重要作用变得未知，所以bagging改进了预测准确率但损失了解释性。）。下图可以形象地描述这个情况：
　　有了树我们就可以分类了，但是森林中的每棵树是怎么生成的呢？
　　每棵树的按照如下规则生成：
　　1）如果训练集大小为N，对于每棵树而言，随机且有放回地从训练集中的抽取N个训练样本（这种采样方式称为bootstrap sample方法），作为该树的训练集；
　　从这里我们可以知道：每棵树的训练集都是不同的，而且里面包含重复的训练样本（理解这点很重要）。
　　为什么要随机抽样训练集？（add @）
　　如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的，这样的话完全没有bagging的必要；
　　为什么要有放回地抽样？（add @）
　　我理解的是这样的：如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是"有偏的"，都是绝对"片面的"（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决，这种表决应该是"求同"，因此使用完全不同的训练集来训练每棵树这样对最终分类结果是没有帮助的，这样无异于是"盲人摸象"。
　　2）如果每个样本的特征维度为M，指定一个常数m&&M，随机地从M个特征中选取m个特征子集，每次树进行分裂时，从这m个特征中选择最优的；
　　3）每棵树都尽最大程度的生长，并且没有剪枝过程。
　　一开始我们提到的随机森林中的&随机&就是指的这里的两个随机性。两个随机性的引入对随机森林的分类性能至关重要。由于它们的引入，使得随机森林不容易陷入过拟合，并且具有很好得抗噪能力（比如：对缺省值不敏感）。
　　随机森林分类效果（错误率）与两个因素有关：
森林中任意两棵树的相关性：相关性越大，错误率越大；
森林中每棵树的分类能力：每棵树的分类能力越强，整个森林的错误率越低。
　　减小特征选择个数m，树的相关性和分类能力也会相应的降低；增大m，两者也会随之增大。所以关键问题是如何选择最优的m（或者是范围），这也是随机森林唯一的一个参数。
5 袋外错误率（oob error）
　　上面我们提到，构建随机森林的关键问题就是如何选择最优的m，要解决这个问题主要依据计算袋外错误率oob error（out-of-bag error）。
　　随机森林有一个重要的优点就是，没有必要对它进行交叉验证或者用一个独立的测试集来获得误差的一个无偏估计。它可以在内部进行评估，也就是说在生成的过程中就可以对误差建立一个无偏估计。
　　我们知道，在构建每棵树时，我们对训练集使用了不同的bootstrap sample（随机且有放回地抽取）。所以对于每棵树而言（假设对于第k棵树），大约有1/3的训练实例没有参与第k棵树的生成，它们称为第k棵树的oob样本。
　　而这样的采样特点就允许我们进行oob估计，它的计算方式如下：
　　（note：以样本为单位）
　　1）对每个样本，计算它作为oob样本的树对它的分类情况（约1/3的树）；
　　2）然后以简单多数投票作为该样本的分类结果；
　　3）最后用误分个数占样本总数的比率作为随机森林的oob误分率。
　　（文献原文：Put each case left out in the construction of the kth tree down the kth tree to get a classification. In this way, a test set classification is obtained for each case in about one-third of the trees. At the end of the run, take j to be the class that got most of the votes every time case n was oob. The proportion of times that j is not equal to the true class of n averaged over all cases is the oob error estimate. This has proven to be unbiased in many tests.）
　　oob误分率是随机森林泛化误差的一个无偏估计，它的结果近似于需要大量计算的k折交叉验证。
6 随机森林工作原理解释的一个简单例子
　　描述：根据已有的训练集已经生成了对应的随机森林，随机森林如何利用某一个人的年龄（Age）、性别（Gender）、教育情况（Highest Educational Qualification）、工作领域（Industry）以及住宅地（Residence）共5个字段来预测他的收入层次。
　　收入层次 :
　　　　Band 1 : Below $40,000
　　　　Band 2: $40,000 &&150,000
　　　　Band 3: More than $150,000
　　随机森林中每一棵树都可以看做是一棵CART（分类回归树），这里假设森林中有5棵CART树，总特征个数N=5，我们取m=1（这里假设每个CART树对应一个不同的特征）。
　　CART 1 : Variable Age
　　CART 2 : Variable&Gender
　　CART 3 : Variable Education
　　CART 4 : Variable&Residence
　　CART 5 : Variable&Industry
　　我们要预测的某个人的信息如下：
　　1. Age : 35 2. Gender : M 3. Highest Educational Qualification : D 4. Industry : M 5. Residence : Metro.
　　根据这五棵CART树的分类结果，我们可以针对这个人的信息建立收入层次的分布情况：
　　最后，我们得出结论，这个人的收入层次70%是一等，大约24%为二等，6%为三等，所以最终认定该人属于一等收入层次（小于$40,000）。
7 随机森林的Python实现
　　利用Python的两个模块，分别为pandas和scikit-learn来实现随机森林。
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import numpy as np
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['is_train'] = np.random.uniform(0, 1, len(df)) &= .75
df['species'] = pd.Factor(iris.target, iris.target_names)
train, test = df[df['is_train']==True], df[df['is_train']==False]
features = df.columns[:4]
clf = RandomForestClassifier(n_jobs=2)
y, _ = pd.factorize(train['species'])
clf.fit(train[features], y)
preds = iris.target_names[clf.predict(test[features])]
pd.crosstab(test['species'], preds, rownames=['actual'], colnames=['preds'])
　　分类结果：
　　与其他机器学习分类算法进行对比：
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.lda import LDA
from sklearn.qda import QDA
# step size in the mesh
names = ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Decision Tree",
"Random Forest", "AdaBoost", "Naive Bayes", "LDA", "QDA"]
classifiers = [
KNeighborsClassifier(3),
SVC(kernel="linear", C=0.025),
SVC(gamma=2, C=1),
DecisionTreeClassifier(max_depth=5),
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
AdaBoostClassifier(),
GaussianNB(),
X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1)
rng = np.random.RandomState(2)
X += 2 * rng.uniform(size=X.shape)
linearly_separable = (X, y)
datasets = [make_moons(noise=0.3, random_state=0),
make_circles(noise=0.2, factor=0.5, random_state=1),
linearly_separable
figure = plt.figure(figsize=(27, 9))
# iterate over datasets
for ds in datasets:
# preprocess dataset, split into training and test part
X = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
# just plot the dataset first
cm = plt.cm.RdBu
cm_bright = ListedColormap(['#FF0000', '#0000FF'])
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
# Plot the training points
ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
# and testing points
ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
# iterate over classifiers
for name, clf in zip(names, classifiers):
ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, m_max]x[y_min, y_max].
if hasattr(clf, "decision_function"):
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
# Put the result into a color plot
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
# Plot also the training points
ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
# and testing points
ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
alpha=0.6)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
ax.set_title(name)
ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
size=15, horizontalalignment='right')
figure.subplots_adjust(left=.02, right=.98)
plt.show()
　　这里随机生成了三个样本集，分割面近似为月形、圆形和线形的。我们可以重点对比一下决策树和随机森林对样本空间的分割：
　　1）从准确率上可以看出，随机森林在这三个测试集上都要优于单棵决策树，90%&85%，82%&80%，95%=95%；
　　2）从特征空间上直观地可以看出，随机森林比决策树拥有更强的分割能力（非线性拟合能力）。
　　更多有关随机森林的代码：
8 参考内容
阅读(...) 评论()模型评估方法
& 假如我们有一个带标签的数据集D，我们如何选择最优的模型？ 衡量模型好坏的标准是看这个模型在新的数据集上面表现的如何，也就是看它的泛化误差。因为实际的数据没有标签，所以泛化误差是不可能直接得到的。于是我们需要在数据集D上面划分出来一小部分数据测试D的性能，用它来近似代替泛化误差。
& 有三种方法可以进行上面的划分操作：留出法、交叉验证法、自助法。
& 留出法的想法很简单，将原始数据直接划分为互斥的两类，其中一部分用来训练模型，另外一部分用来测试。前者就是训练集，后者就是测试集。
& 在sklearn当中，使用train_test_split可以将数据分为训练集和测试集，下面使用鸢尾花数据集看一看
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn import datasets
from sklearn import svm
iris = datasets.load_iris()
print(iris.data.shape, iris.target.shape)
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.4, random_state=0)
print(X_train.shape, y_train.shape)
print(X_test.shape, y_test.shape)
clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
print( clf.score(X_test, y_test) )
& 输出结果如下，test_size可以接受一个浮点数来表示测试集的比例：
(150, 4) (150,)
(90, 4) (90,)
(60, 4) (60,)
& 留出法非常的简单。但是存在一些问题，比如有些模型还需要进行超参数评估，这个时候还需要划分一类数据集，叫做验证集。最后数据集的划分划分变成了这样：训练集，验证集还有测试集。 训练集是为了进行模型的训练，验证集是为了进行参数的调整，测试集是为了看这个模型的好坏。
& 但是，上面的划分依然有问题，划分出来验证集还有测试集，那么我们的训练集会变小。并且还有一个问题，那就是我们的模型会随着我们选择的训练集和验证集不同而不同。所以这个时候，我们引入了交叉验证（cross-validation 简称cv）
交叉验证：
& 交叉验证的基本思想是这样的：将数据集分为k等份，对于每一份数据集，其中k-1份用作训练集，单独的那一份用作测试集。
运用交叉验证进行数据集划分
下面的函数是一些划分的策略，方便我们自己划分数据，并且我们假设数据是独立同分布的（iid）
KFold方法 &k折交叉验证
上面说的将数据集划分为k等份的方法叫做k折交叉验证。sklearn中的 KFold是它的实现：
from sklearn.model_selection import KFold
import numpy as np
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([1, 2, 3, 4])
kf = KFold(n_splits=2)
for train_index, test_index in kf.split(X):
print('train_index', train_index, 'test_index', test_index)
train_X, train_y = X[train_index], y[train_index]
test_X, test_y = X[test_index], y[test_index]
输出如下：
train_index [2 3] test_index [0 1]
train_index [0 1] test_index [2 3]
通过KFold函数，我们可以很方便的得到我们所需要的训练集，还有测试集。
RepeatedKFold &p次k折交叉验证
在实际当中，我们只进行一次k折交叉验证还是不够的，我们需要进行多次，最典型的是：10次10折交叉验证，RepeatedKFold方法可以控制交叉验证的次数。
from sklearn.model_selection import RepeatedKFold
import numpy as np
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([1, 2, 3, 4])
kf = RepeatedKFold(n_splits=2, n_repeats=2, random_state=0)
for train_index, test_index in kf.split(X):
print('train_index', train_index, 'test_index', test_index)
输出结果如下：
train_index [0 1] test_index [2 3]
train_index [2 3] test_index [0 1]
train_index [1 3] test_index [0 2]
train_index [0 2] test_index [1 3]
LeaveOneOut 留一法
留一法是k折交叉验证当中，k=n（n为数据集个数）的情形
from sklearn.model_selection import LeaveOneOut
X = [1, 2, 3, 4]
loo = LeaveOneOut()
for train_index, test_index in loo.split(X):
print('train_index', train_index, 'test_index', test_index)
输出结果如下：
train_index [1 2 3] test_index [0]
train_index [0 2 3] test_index [1]
train_index [0 1 3] test_index [2]
train_index [0 1 2] test_index [3]
留一法的缺点是：当n很大的时候，计算量会很大，因为需要进行n次模型的训练，而且训练集的大小为n-1。建议k折交叉验证的时候k的值为5或者10。
LeavePOut &留P法
基本原理和留一法一样，它会产生&个训练集和测试集
from sklearn.model_selection import LeavePOut
X = [1, 2, 3, 4]
lpo = LeavePOut(p=2)
for train_index, test_index in lpo.split(X):
print('train_index', train_index, 'test_index', test_index)
输出结果如下：
train_index [2 3] test_index [0 1]
train_index [1 3] test_index [0 2]
train_index [1 2] test_index [0 3]
train_index [0 3] test_index [1 2]
train_index [0 2] test_index [1 3]
train_index [0 1] test_index [2 3]
ShuffleSplit &随机分配
使用ShuffleSplit方法，可以随机的把数据打乱，然后分为训练集和测试集。它还有一个好处是可以通过random_state这个种子来重现我们的分配方式，如果没有指定，那么每次都是随机的。
from sklearn.model_selection import ShuffleSplit
import numpy as np
X = np.arange(5)
ss = ShuffleSplit(n_splits=4, random_state=0, test_size=0.25)
for train_index, test_index in ss.split(X):
print('train_index', train_index, 'test_index', test_index)
输出结果如下（因为指定了random_state的值，所以，当你运行这段代码的时候，你的结果和我的是一样的）：
train_index [1 3 4] test_index [2 0]
train_index [1 4 3] test_index [0 2]
train_index [4 0 2] test_index [1 3]
train_index [2 4 0] test_index [3 1]
其它特殊情况的数据划分方法
1：对于分类数据来说，它们的target可能分配是不均匀的，比如在医疗数据当中得癌症的人比不得癌症的人少很多，这个时候，使用的数据划分方法有 &StratifiedKFold &，StratifiedShuffleSplit
2：对于分组数据来说，它的划分方法是不一样的，主要的方法有 GroupKFold，LeaveOneGroupOut，LeavePGroupOut，GroupShuffleSplit
3：对于时间关联的数据，方法有TimeSeriesSplit
运用交叉验证进行模型评估
& 上面讲的是如何使用交叉验证进行数据集的划分。当我们用交叉验证的方法并且结合一些性能度量方法来评估模型好坏的时候，我们可以直接使用sklearn当中提供的交叉验证评估方法，这些方法如下：
cross_value_score
& 这个方法能够使用交叉验证来计算模型的评分情况，使用方法如下所示：
from sklearn import datasetsfrom sklearn import svmfrom sklearn.model_selection import cross_val_scoreiris = datasets.load_iris()clf = svm.SVC(kernel='linear', C=1)scores = cross_val_score(clf, iris.data, iris.target, cv=5)print(scores)
输出结果如下：&[ 0.. 0... ]&
clf是我们使用的算法，
cv是我们使用的交叉验证的生成器或者迭代器，它决定了交叉验证的数据是如何划分的，当cv的取值为整数的时候，使用(Stratified)KFold方法。
你也可也使用自己的cv，如下所示：
from sklearn.model_selection import ShuffleSplit
my_cv = ShuffleSplit(n_splits=3, test_size=0.3, random_state=0)
scores = cross_val_score(clf, iris.data, iris.target, cv=my_cv)
还有一个参数是&scoring，决定了其中的分数计算方法。
如我们使用 &&scores = cross_val_score(clf, iris.data, iris.target, cv=5, scoring='f1_macro')&
那么得到的结果将是这样的：&[ 0.. 0... ]&
cross_validate
& cross_validate方法和cross_validate_score有个两个不同点：它允许传入多个评估方法，可以使用两种方法来传入，一种是列表的方法，另外一种是字典的方法。最后返回的scores为一个字典，字典的key为：dict_keys(['fit_time', 'score_time', 'test_score', 'train_score'])
下面是它的演示代码，当scoring传入列表的时候如下：
from sklearn.model_selection import cross_validate
from sklearn.svm import SVC
from sklearn.datasets import load_iris
iris = load_iris()
scoring = ['precision_macro', 'recall_macro']
clf = SVC(kernel='linear', C=1, random_state=0)
scores = cross_validate(clf, iris.data, iris.target, scoring=scoring,cv=5, return_train_score=False)
print(scores.keys())
print(scores['test_recall_macro'])
结果如下：
dict_keys(['fit_time', 'score_time', 'test_precision_macro', 'test_recall_macro'])
当scoring传入字典的时候如下：
from sklearn.model_selection import cross_validate
from sklearn.svm import SVC
from sklearn.metrics import make_scorer,recall_score
from sklearn.datasets import load_iris
iris = load_iris()
scoring = {'prec_macro': 'precision_macro','rec_micro': make_scorer(recall_score, average='macro')}
clf = SVC(kernel='linear', C=1, random_state=0)
scores = cross_validate(clf, iris.data, iris.target, scoring=scoring,cv=5, return_train_score=False)
print(scores.keys())
print(scores['test_rec_micro'])
结果如下：
dict_keys(['fit_time', 'score_time', 'test_prec_macro', 'test_rec_micro'])
cross_validate是如何工作的，它的结果又是什么？
& 我们讨论参数只有estimator，X和Y这种情况，当只传入这三个参数的时候，cross_validate依然使用交叉验证的方法来进行模型的性能度量，它会返回一个字典来看模型的性能如何的，字典的key为：dict_keys(['fit_time', 'score_time', 'test_score', 'train_score'])，表示的是模型的训练时间，测试时间，测试评分和训练评分。用两个时间参数和两个准确率参数来评估模型，这在我们进行简单的模型性能比较的时候已经够用了。
cross_val_predict
cross_val_predict 和 cross_val_score的使用方法是一样的，但是它返回的是一个使用交叉验证以后的输出值，而不是评分标准。它的运行过程是这样的，使用交叉验证的方法来计算出每次划分为测试集部分数据的值，知道所有的数据都有了预测值。假如数据划分为[1,2,3,4,5]份，它先用[1,2,3,4]训练模型，计算出来第5份的目标值，然后用[1,2,3,5]计算出第4份的目标值，直到都结束为止。
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_predict
from sklearn import metrics
iris = load_iris()
clf = SVC(kernel='linear', C=1, random_state=0)
predicted = cross_val_predict(clf, iris.data, iris.target, cv=10)
print(predicted)
print(metrics.accuracy_score(predicted, iris.target))
结果如下：
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 2 1
1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 1 2 2 2 2
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
我们刚开始介绍的留出法（hold-out）还有我们介绍的交叉验证法（cross validation），这两种方法都可以进行模型评估。当然，还有一种方法，那就是自助法（bootstrapping），它的基本思想是这样的，对于含有m个样本的数据集D，我们对它进行有放回的采样m次，最终得到一个含有m个样本的数据集D',这个数据集D'会有重复的数据,我们把它用作训练数据。按照概率论的思想，在m个样本中，有1/e的样本从来没有采到，将这些样本即D\D'当做测试集。具体的推导见周志华的机器学习2.2.3。自助法在数据集很小的时候可以使用，在集成学习的时候也有应用。
周志华 《机器学习》
阅读(...) 评论()