6.21

5.md

@@ -160,3 +160,205 @@ Fold: 3, N_train: 600, N_test: 200
 我们可以看到，在每次迭代中，我们都调用函数来获得得分。我们也知道了模型如何运行。
 
 同样值得了解是的，我们可以对我们尝试拟合的模型，获取预测得分。我们也会讨论如何创建你自己的评分函数。
+
+## 5.3 使用 ShuffleSplit 交叉验证
+
+`ShuffleSplit`是最简单的交叉验证技巧之一。这个交叉验证技巧只是将数据的样本用于指定的迭代数量。
+
+### 准备
+
+`ShuffleSplit`是另一个简单的交叉验证技巧。我们会指定数据集中的总元素，并且它会考虑剩余部分。我们会浏览一个例子，估计单变量数据集的均值。这有点类似于重采样，但是它说明了一个原因，为什么我们在展示交叉验证的时候使用交叉验证。
+
+### 操作步骤
+
+首先，我们需要创建数据集。我们使用 NumPy 来创建数据集，其中我们知道底层的均值。我们会对半个数据集采样，来估计均值，并看看它和底层的均值有多接近。
+
+```py
+>>> import numpy as np
+
+>>> true_loc = 1000 
+>>> true_scale = 10 
+>>> N = 1000
+
+>>> dataset = np.random.normal(true_loc, true_scale, N)
+
+>>> import matplotlib.pyplot as plt
+
+>>> f, ax = plt.subplots(figsize=(7, 5))
+
+>>> ax.hist(dataset, color='k', alpha=.65, histtype='stepfilled'); 
+>>> ax.set_title("Histogram of dataset");
+
+>>> f.savefig("978-1-78398-948-5_06_06.png") 
+```
+
+NumPy 输出如下：
+
+![](img/5-3-1.jpg)
+
+现在，让我们截取前一半数据集，并猜测均值：
+
+```py
+>>> from sklearn import cross_validation
+
+>>> holdout_set = dataset[:500] 
+>>> fitting_set = dataset[500:]
+
+>>> estimate = fitting_set[:N/2].mean()
+
+>>> import matplotlib.pyplot as plt
+
+>>> f, ax = plt.subplots(figsize=(7, 5))
+
+>>> ax.set_title("True Mean vs Regular Estimate")
+
+>>> ax.vlines(true_loc, 0, 1, color='r', linestyles='-', lw=5,
+              alpha=.65, label='true mean') 
+>>> ax.vlines(estimate, 0, 1, color='g', linestyles='-', lw=5,
+              alpha=.65, label='regular estimate')
+
+>>> ax.set_xlim(999, 1001)
+
+>>> ax.legend()
+
+>>> f.savefig("978-1-78398-948-5_06_07.png") 
+```
+
+输出如下：
+
+![](img/5-3-2.jpg)
+
+现在，我们可以使用`ShuffleSplit `在多个相似的数据集上拟合估计值。
+
+```py
+
+>>> from sklearn.cross_validation import ShuffleSplit
+
+>>> shuffle_split = ShuffleSplit(len(fitting_set))
+
+>>> mean_p = []
+
+>>> for train, _ in shuffle_split:
+        mean_p.append(fitting_set[train].mean())
+        shuf_estimate = np.mean(mean_p)
+
+>>> import matplotlib.pyplot as plt
+
+>>> f, ax = plt.subplots(figsize=(7, 5))
+
+>>> ax.vlines(true_loc, 0, 1, color='r', linestyles='-', lw=5,
+              alpha=.65, label='true mean') 
+>>> ax.vlines(estimate, 0, 1, color='g', linestyles='-', lw=5,
+              alpha=.65, label='regular estimate') 
+>>> ax.vlines(shuf_estimate, 0, 1, color='b', linestyles='-', lw=5,
+              alpha=.65, label='shufflesplit estimate')
+
+>>> ax.set_title("All Estimates") 
+>>> ax.set_xlim(999, 1001)
+
+>>> ax.legend(loc=3)
+```
+
+输出如下：
+
+![](img/5-3-3.jpg)
+
+我们可以看到，我们得到了类似于预期的估计值，但是我们可能使用多个样本来获取该值。
+
+## 5.4 分层的 k-fold
+
+这个秘籍中，我们会快速查看分层的 k-fold 估值。我们会浏览不同的秘籍，其中分类的表示在某种程度上是不平衡的。分层的 k-fold 非常不错，因为他的模式特地为维持分类的比例而设计。
+
+### 准备
+
+我们打算创建一个小型的数据集。这个数据集中，我们随后会使用分层的 k-fold 验证。我们想让它尽可能小，以便我们查看变化。对于更大的样本，可能并不是特别好。
+
+我们之后会绘制每一步的分类比例，来展示如何维护分类比例。
+
+```py
+>>> from sklearn import datasets 
+>>> X, y = datasets.make_classification(n_samples=int(1e3),
+           weights=[1./11])
+
+```
+
+让我们检查分类的总体权重分布：
+
+```py
+>>> y.mean()
+0.90300000000000002
+```
+
+90.5% 的样本都是 1，其余为 0。
+
+### 操作步骤
+
+让我们创建分层 k-fold 对象，并通过每个折叠来迭代。我们会度量为 1 的`verse `比例。之后，我们会通过分割数字来绘制分类比例，来看看是否以及如何发生变化。这个代码展示了为什么它非常好。我们也会对基本的`ShuffleSplit`绘制这个代码。
+
+```py
+>>> from sklearn import cross_validation
+
+>>> n_folds = 50
+
+>>> strat_kfold = cross_validation.StratifiedKFold(y,
+                  n_folds=n_folds) 
+>>> shuff_split = cross_validation.ShuffleSplit(n=len(y),
+                  n_iter=n_folds)
+
+>>> kfold_y_props = [] 
+>>> shuff_y_props = []
+
+>>> for (k_train, k_test), (s_train, s_test) in zip(strat_kfold,  
+>>> shuff_split):         
+        kfold_y_props.append(y[k_train].mean())       
+        shuff_y_props.append(y[s_train].mean()) 
+```
+
+现在，让我们绘制每个折叠上的比例：
+
+```py
+
+>>> import matplotlib.pyplot as plt
+
+>>> f, ax = plt.subplots(figsize=(7, 5))
+
+>>> ax.plot(range(n_folds), shuff_y_props, label="ShuffleSplit",
+            color='k') 
+>>> ax.plot(range(n_folds), kfold_y_props, label="Stratified",
+            color='k', ls='--') 
+>>> ax.set_title("Comparing class proportions.")
+
+>>> ax.legend(loc='best')
+
+```
+
+输出如下：
+
+![](img/5-4-1.jpg)
+
+我们可以看到，分层的 k-fold 的每个折叠的比例，在每个折叠之间是稳定的。
+
+### 工作原理
+
+分层 k-fold 的原理是选取`y`值。首先，获取所有分类的比例，之后将训练集和测试集按比例划分。这可以推广到多个标签：
+
+```py
+
+>>> import numpy as np
+
+>>> three_classes = np.random.choice([1,2,3], p=[.1, .4, .5],
+                    size=1000)
+
+>>> import itertools as it
+
+>>> for train, test in cross_validation.StratifiedKFold(three_classes, 5):
+        print np.bincount(three_classes[train])
+        
+[  0  90 314 395] 
+[  0  90 314 395]
+[  0  90 314 395] 
+[  0  91 315 395] 
+[  0  91 315 396]
+```
+
+我们可以看到，我们得到了每个分类的样例大小，正好是训练集合测试集的比例。