第二章 监督学习

监督学习主要利用一组已知类别的样本调整分类器的参数，使其达到所要求性能的过程
预测某个结果，并且还有输入/输出对的示例

2.1 分类与回归

监督机器学习问题主要有两种：

• 分类
• 回归

分类问题的目标是预测标签，这些标签来自预定义的可选列表，例如鸢尾花分类、垃圾邮件识别
回归问题的目标是预测一个连续值（浮点数），例如预测收入
区分两者有一个简单方法，就是问一个问题：输出是否具有某种连续性

2.2 泛化、过拟合与欠拟合

在监督学习中，我们想要在训练数据上构建模型，然后能够对没见过的新数据（这些新数据与训练数据具有相同的特性）做出准确预测

• 如果一个模型能够对没见过的数据做出准确预测，我们就说它能够从训练数据泛化（generalize）到测试集
• 构建一个对现有信息量来说过于复杂的模型，称为过拟合（overfitting)
• 构建一个对现有信息量来说过于简单的模型，称为欠拟合（underfitting)

如果在拟合模型时过分关注训练集的细节，得到了一个在训练集上表现很好，但不能泛化到新数据上的模型，就存在过拟合
反之，如果模型过于简单，无法抓住数据的全部内容以及数据中的变化，模型甚至在训练集上的表现很差，就存在欠拟合

我们的模型越复杂，在训练数据上的预测结果就越好。但是，如果我们的模型过于复杂，我们开始过多关注训练集中每个单独的数据点，模型就不能很好地泛化到新数据上
通常来说，收集更多的数据点可以有更大的变化范围，所以更大的数据集可以用来构建更复杂的模型

2.3 监督学习算法

2.3.1 一些样本数据集

1. 一个模拟的二分类数据集示例是forge数据集，它有两个特征。

#导入相关库
import pandas as pd
import numpy as np
import mglearn
import matplotlib.pyplot as plt
%matplotlib inline

#生成数据集
X,y = mglearn.datasets.make_forge()
#数据集绘图
mglearn.discrete_scatter(X[:,0],X[:,1],y)
plt.legend(["Class 0","Class 1"],loc=4)
plt.xlabel("First feature")
plt.ylabel("Second feature")
print("X.shape:{}".format(X.shape))
结果如下：
X.shape:(26, 2)

从X.shape可以看出，这个数据集包含26个数据点和2个特征

2. 我们用模拟的wave数据集来说明回归算法，wave数据集只有一个输入特征和一个连续的目标变量，后者是模型想要预测的对象

#wave数据集
X,y = mglearn.datasets.make_wave(n_samples=40)
plt.plot(X,y,'o')
plt.ylim(-3,3)
plt.xlabel("Feature")
plt.ylabel("Target")

两个现实中的数据

3. 威斯康星州乳腺癌数据集cancer，每个肿瘤都被标记为”良性“或"恶性”，其任务是基于人体组织的测量数据来学习预测肿瘤是否为恶性

#cancer数据集
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
print("cancer.keys(): \n{}".format(cancer.keys()))
print("Shape of cancer data: {}".format(cancer.data.shape))
print("Sample counts per class:\n{}".format({n: v for n,v in zip(cancer.target_names,np.bincount(cancer.target))}))

输出结果：
cancer.keys(): 
dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename'])
Shape of cancer data: (569, 30)
Sample counts per class:
{'malignant': 212, 'benign': 357}

这个数据集共包含569个数据点，每个数据点有30个特征
在569个数据点中，212个被标记为恶性，357个被标记为良性

np.bincount()函数用于统计一个非负的list或array中元素的出现次数

4. 波士顿房价数据集，主要任务是利用犯罪率、是否邻近查尔斯河、公路可达性等信息，来预测20世纪70年代波士顿房价的中位数，这个数据集包含506个数据点和13个特征

#波士顿房价数据集
from sklearn.datasets import load_boston
boston = load_boston()
print("boston.keys(): \n{}".format(boston.keys()))
print("Data shape:{}".format(boston.data.shape))
输出结果：
boston.keys(): 
dict_keys(['data', 'target', 'feature_names', 'DESCR', 'filename'])
Data shape:(506, 13)

2.3.2 K近邻

想要对新数据点做出预测，算法会在训练数据集中找到最近的数据点，也就是它的”最近邻“

1. K近邻分类
   k-NN算法最简单的版本只考虑一个最近邻，也就是与我们想要预测的数据点最近的训练数据点，预测结果就是这个训练数据点的已知输出。

#foege
X,y = mglearn.datasets.make_forge()
mglearn.plots.plot_knn_classification(n_neighbors=1)

除了仅考虑最近邻，还可以考虑任意个（k个）邻居，这也是k近邻算法名字的来历。
在考虑多于一个邻居的情况时，我们用”投票法“来指定标签，也就是说，我们数一数多少邻居属于类别0，多少个邻居属于类别1，然后将出现次数更多的类别作为预测结果

#foege
X,y = mglearn.datasets.make_forge()
mglearn.plots.plot_knn_classification(n_neighbors=3)

现在看一下如何通过scikit-learn来应用k近邻算法

#k-NN分类
from sklearn.model_selection import train_test_split
X,y = mglearn.datasets.make_forge()

X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=0)

#然后导入类并将其实例化，设定邻居数为3
from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=3)

#利用训练数据对这个分类器进行你和
clf.fit(X_train,y_train)

#调用predict方法来对测试数据进行预测
print("Test set preditions: {}".format(clf.predict(X_test)))

#评估模型的泛化能力好坏
print("Test set accuracy: {:.2f}".format(clf.score(X_test,y_test)))

输出结果：
Test set preditions: [1 0 1 0 1 0 0]
Test set accuracy: 0.86

可以看到，模型的精度约为86%，也就是说，在测试数据集中，模型对其中86%样本预测的类别都是正确的

2. 分析KNeighborsClassifier
   决策边界（decision boundary），算法对类别0和类别1的分界线
   下列代码分别将1个、3个和9个邻居三种情况的决策边界可视化

#决策边界可视化
import mglearn
fig, axes = plt.subplots(1,3,figsize=(10,3))

for n_neighbors, ax in zip([1,3,9],axes):
    #fit方法返回对象本身，所以我们可以将实例化和拟合放在一行代码中
    clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(X,y)
    mglearn.plots.plot_2d_separator(clf, X, fill=True, eps=0.5, ax=ax, alpha=.4)
    mglearn.discrete_scatter(X[:,0], X[:,1], y, ax=ax)
    ax.set_title("{} neighbor(s)".format(n_neighbors))
    ax.set_xlabel("feature 0")
    ax.set_ylabel("feature 1")
axes[0].legend(loc=3)

使用单一邻居绘制的决策边界紧跟着训练数据，随着邻居个数越来越多，决策边界也越来越平滑，更平滑的边界对应更简单的模型
使用更少的邻居对应更高的模型复杂度，而使用更多的邻居对应更低的模型复杂度

下研究一下能否证实之前讨论过的模型复杂度和泛化能力之间的关系，在现实世界的乳腺癌数据集上进行研究

#cancer数据集
from sklearn.datasets import load_breast_cancer
#依据标签y，按原数据中各类比例，分配给train和test，使之各类的数据的比例与原数据集相同
cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(cancer.data,cancer.target,stratify=cancer.target,random_state=66)

training_accuracy = []
test_accuracy = []
#n_neighbors取值从1到10
neighbors_settings = range(1,11)

for n_neighbors in neighbors_settings:
    #构建模型
    clf = KNeighborsClassifier(n_neighbors=n_neighbors)
    clf.fit(X_train,y_train)
    #记录训练集精度
    training_accuracy.append(clf.score(X_train,y_train))
    #记录泛化精度
    test_accuracy.append(clf.score(X_test,y_test))
    
plt.plot(neighbors_settings,training_accuracy,label="Training accuracy")
plt.plot(neighbors_settings,test_accuracy,label="Test accuracy")
plt.ylabel("Accuracy")
plt.xlabel("n_neighbors")
plt.legend()

• 仅考虑单一近邻时，训练集上的预测结果十分完美，但随着邻居个数的增多，模型变得简单，训练精度也随之下降
• 单一邻居时的测试集精度比使用更多邻居时要低，这表示单一近邻的模型过于复杂
• 反之，当考虑10个邻居时，模型又过于简单，性能甚至变得更差
• 最佳性能在中间的某处，邻居个数大约为6
• 不过最差的性能约为88%的精度，这个结果仍然可以接受

3. k近邻回归
   先从单一近邻开始，使用wave数据集

#wave
mglearn.plots.plot_knn_regression(n_neighbors=1)

同样，也可以用多个近邻进行回归，预测结果为这些邻居的平均值

#wave
mglearn.plots.plot_knn_regression(n_neighbors=3)

用于回归的k近邻算法在scikit-learn的KNeighborsRegressor类中实现，用法和KNeighborsClassifier类似：

#k近邻回归
from sklearn.neighbors import KNeighborsRegressor

X, y = mglearn.datasets.make_wave(n_samples=40)
#将wave数据集分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

#模型实例化，并将邻居个数设为3
reg = KNeighborsRegressor(n_neighbors=3)
#利用训练数据和训练目标值来拟合模型
reg.fit(X_train,y_train)
print("Test set predictions: \n{}".format(reg.predict(X_test)))
print("Test set R`2: {:.2f}".format(reg.score(X_test,y_test)))

输出结果：
Test set predictions: 
 [-0.05396539  0.35686046  1.13671923 -1.89415682 -1.13881398 -1.63113382
  0.35686046  0.91241374 -0.44680446 -1.13881398]
Test set R`2: 0.83

这里分数是0.83，表示模型的拟合相对较好

4. 分析KNeighborsRegressor
   对于一维数据集，可以查看所有特征取值对应的预测结果。为了便于绘图，创建一个由许多点组成的测试数据集：

#分析KNneighborsRegressor
fig, axes = plt.subplots(1,3,figsize=(15,4))
#创建1000个数据点，在-3和3之间均匀分布
line = np.linspace(-3,3,1000).reshape(-1,1)
for n_neighbors, ax in zip([1,3,9],axes):
    #利用1个、3个或9个邻居分别进行预测
    reg = KNeighborsRegressor(n_neighbors=n_neighbors)
    reg.fit(X_train,y_train)
    ax.plot(line,reg.predict(line))
    ax.plot(X_train,y_train,'^',c=mglearn.cm2(0),markersize=8)
    ax.plot(X_test,y_test,'v',c=mglearn.cm2(1),markersize=8)
    ax.set_title(
        "{} neighbor(s)\n train score: {:.2f} test score: {:.2f}".format(
        n_neighbors, reg.score(X_train,y_train), reg.score(X_test, y_test)))
    ax.set_xlabel("Feature")
    ax.set_ylabel("Target")
axes[0].legend(['Model prediction', "Training data/target", "Test data/target"],loc='best')

从图中可以看出，仅使用单一邻居，训练集中的每个点都对预测结果有显著影响，预测结果的图像经过所有数据点，这导致预测结果非常不稳定。考虑更多的邻居之后，预测结果变得更加平滑，但对训练数据的拟合也不好。

5. 优点、缺点和参数
   k-NN的优点之一就是模型很容易理解，通常不需要过多调节就可以得到不错的性能。在考虑使用更高级的技术之前，尝试此算法是一种很好的基准方法。
   缺点是如果训练集很大（特征数很多或者样本数很大），预测速度可能会比较慢。这一算法对于有很多特征（几百或更多）的数据集往往效果不好，对于大多数特征的大多数取值为0的数据集（稀疏矩阵）来说，这一算法的效果尤其不好。
   一般来说，KNeighbors分类器有2个重要参数：邻居个数和数据点之间距离的度量方法