一、分类与回归
监督机器学习问题主要有两种，分别叫作分类（classification）与回归（regression）。
区分分类任务和回归任务有一个简单方法，就是问一个问题：输出是否具有某种连续性。 如果在可能的结果之间具有连续性，那么它就是一个回归问题；不存在连续性，则一般是分类问题。
二、泛化、过拟合与欠拟合
在监督学习中，在训练数据上构建模型，然后能够对没见过的新数据（这些新数据与训练集具有相同的特性）做出准确预测。如果模型能够对没见过的数据做出准确预测，我们就说它能够从训练集泛化（generalize）到测试集。我们想要构建一个泛化精度尽可能高的模型。判断一个算法在新数据上表现好坏的唯一度量，就是在测试集上的评估。
过拟合（Overfitting）是指模型在训练数据上表现优异，但在新的数据集上性能不佳的现象。这是因为过拟合模型过度关注训练数据的细节和噪声，导致泛化能力差，无法很好地适应新的数据。
欠拟合（underfitting）是指模型在训练和预测时表现都不好的情况。具体来说，模型在训练集和测试集上的表现都不好，说明模型没有很好地捕捉到数据特征，无法有效地拟合数据。
我们的模型越复杂，在训练数据上的预测结果就越好。但是，如果我们的模型过于复杂， 我们开始过多关注训练集中每个单独的数据点，模型就不能很好地泛化到新数据上。 二者之间存在一个最佳位置，可以得到最好的泛化性能。这就是我们想要的模型。下图是：模型复杂度与训练精度和测试精度之间的权衡关系图。
模型复杂度与数据集大小的关系
模型复杂度与训练数据集中输入的变化密切相关：数据集中包含的数据点的变化范围越大，在不发生过拟合的前提下可以使用的模型就越复杂。通常来说，收集更多的数据点可以有更大的变化范围，所以更大的数据集可以用来构建更复杂的模型。
三、监督学习算法
我们使用mglearn库中make_forge方法生成一个模拟的二分类数据集 forge ，这个数据集有两个特征。我们先绘制一个散点图来观察数据，图像以第一个特征为 x 轴，第二个特征为 y 轴。每个数据点对应图像中的一点。每个点的颜色和形状对应其类别：
import matplotlib.pyplot as plt
import mglearn
# 生成数据集
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))
plt.show()输出结果：
数据集形状 X.shape: (26, 2)
再使用mglearn中的make_wave方法模拟的 wave 数据集来说明回归算法。wave 数据集只有一个输入特征和一个连续的目标变量（或响应），后者是模型想要预测的对象。下面绘制的图像来观察wave数据集，单一特征位于 x 轴，回归目标（输出）位于 y 轴：
forge 和 wave数据集都非常简单，是低维数据集，因此可视化它们也很容易。从特征较少的数据集（也叫低维数据集）中得出的结论可能并不适用于特征较多的数据集（也叫高维数据集）。
下面学习还会用到 scikit-learn 中两个真实世界的数据集：威斯康星州乳腺癌数据集（简称 cancer）和 某地房价数据集。scikit-learn 中的数据集被保存为 Bunch 对象，里面包含真实数据以及一些数据集信息。
cancer数据集，里面记录了乳腺癌肿瘤的临床检查数据。每个肿瘤都被标记为“良性”（benign，表示无害肿瘤）或“恶性”（malignant，表示癌性肿瘤），其任务是基于人体组织的检查数据来学习预测肿瘤是否为恶性。
housing房价数据集（回归数据集），根据该地的房屋的公路可达性、是否临近河流等特征信息，来预测未来房价的中位数。两个数据集和它们的相关信息可以通过以下代码了解：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import mglearn
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))}))
# 查看 feature_names 属性，获得每个特征的语义说明
print("Feature names:\n{}".format(cancer.feature_names))
#=======================================================================
from sklearn.datasets import fetch_openml
housing = fetch_openml(name="house_prices", as_frame=True)
print("housing.keys(): \n{}".format(housing.keys()))
print("Shape of housing data: {}".format(housing.data.shape))
print("Sample counts per class:\n{}".format({n: v for n, v in zip(housing.target_names, np.bincount(housing.target))}))
# 查看 feature_names 属性，获得每个特征的语义说明
print("Feature names:\n{}".format(housing.feature_names))
下面开始机器学习算法的基础学习。我还是从最简单的k-NN 机器学习算法开始学习。在这之前先介绍下mglearn这个库，mglearn是一个专为《Python机器学习》（"Python Machine Learning" by Sebastian Raschka and Vahid Mirjalili）一书设计的Python库，它提供了一系列用于机器学习和数据科学教学目的的示例数据集、实用功能和辅助工具。这个库并不是广泛使用的通用机器学习库。它的Github地址：amueller/introduction_to_ml_with_python: Notebooks and code for the book "Introduction to Machine Learning with Python"
安装：pip install mglearn 。安装后可以在代码中导入：import mglearn
这个专栏的Python机器学习笔记，就是我基于《Python Machine Learning》 by Sebastian Raschka and Vahid Mirjalili 这本书的学习笔记记录。
1.k近邻
1.1 k近邻分类
k-NN 算法最简单的版本只考虑一个最近邻，也就是与我们想要预测的数据点最近的训练数据点。预测结果就是这个训练数据点的已知输出。下面我们看下这种分类方法在 forge 数据集上的应用。
import matplotlib.pyplot as plt
import mglearn
# mglearn 这个轻量级的包中已经封装了画图方法和forge数据集获取方法
mglearn.plots.plot_knn_classification(n_neighbors=1)
plt.show()设置1个最近邻参数，输出图形：
上图是单一最近邻模型对 forge 数据集的预测结果。添加了 3 个新数据点（用五角星表示）。对于每个新数据点，标记了训练集中与它最近的点。单一最近邻算法的预测结果就是那个点的标签（对应五角星的颜色）。
还可以设置任意个（k 个）邻居。这也是 k 近邻算法名字的由来。 在多于一个邻居的情况时，我们用“投票法”（voting）来指定标签。也就是说，对于每个测试点，我们数一数多少个邻居属于类别 0，多少个邻居属于类别 1。然后将出现次数更多的类别（也就是 k 个近邻中占多数的类别）作为预测结果。下面的用到 3 个近邻测试：
import matplotlib.pyplot as plt
import mglearn
# mglearn 这个轻量级的包中已经封装了画图方法和forge数据集获取方法
mglearn.plots.plot_knn_classification(n_neighbors=3)
plt.show()输出图形：
上图是：3 近邻模型对 forge 数据集的预测结果。预测结果可以从五角星的颜色看出。可以发现，左上角新数据点的预测结果与只用一个邻居时的预测结果不同。
下面通过 scikit-learn 来应用 k 近邻算法。先将数据分为训练集和测试集，以便评估泛化性能：
import mglearn
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)
# 导入KNN类并将其实例化。设定邻居的个数参数。设为 3：
from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=3)
# 利用训练集对这个分类器进行拟合。对于 KNeighborsClassifier 来说就是保存数据集，以便在预测时计算与邻居之间的距离：
clf.fit(X_train, y_train)
# 调用 predict 方法来对测试数据进行预测。
# 对于测试集中的每个数据点，都要计算它在训练集的最近邻，然后找出其中出现次数最多的类别：
print("Test set predictions: {}".format(clf.predict(X_test)))
# 对测试数据和测试标签调用 score 方法，评估模型的泛化能力
print("Test set accuracy: {:.2f}".format(clf.score(X_test, y_test)))输出结果：
Test set predictions: [1 0 1 0 1 0 0]
Test set accuracy: 0.86
可以看到，模型精度约为 86%，也就是说，在测试数据集中，模型对其中 86% 的 样本预测的类别都是正确的。
1.2 分析KNeighborsClassifier
对于二维数据集，我们还可以在 xy 平面上画出所有可能的测试点的预测结果。我们根据平面中每个点所属的类别对平面进行着色。这样可以查看决策边界（decision boundary）， 即算法对类别 0 和类别 1 的分界线。 下列代码分别将 1 个、3 个和 9 个邻居三种情况的决策边界可视化：
import matplotlib.pyplot as plt
import mglearn
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)
# 导入KNN类并将其实例化。设定邻居的个数参数。设为 3：
from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=3)
# 利用训练集对这个分类器进行拟合。对于 KNeighborsClassifier 来说就是保存数据集，以便在预测时计算与邻居之间的距离：
clf.fit(X_train, y_train)
# 调用 predict 方法来对测试数据进行预测。
# 对于测试集中的每个数据点，都要计算它在训练集的最近邻，然后找出其中出现次数最多的类别：
print("Test set predictions: {}".format(clf.predict(X_test)))
# 对测试数据和测试标签调用 score 方法，评估模型的泛化能力
print("Test set accuracy: {:.2f}".format(clf.score(X_test, y_test)))
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)
plt.show()输出图形：
上图是：不同 n_neighbors 值的 k 近邻模型的决策边界。从上图左边第一个图可以看出，使用单一邻居绘制的决策边界紧跟着训练数据。随着邻居个数越来越多，决策边界也越来越平滑。更平滑的边界对应更简单的模型。换句话说，使用更少的邻居对应更高的模型复杂度，而使用更多的邻居对应更低的模型复杂度。假如考虑极端情况，即邻居个数等于训练集中所有数据点的个数， 那么每个测试点的邻居都完全相同（即所有训练点），所有预测结果也完全相同（即训练集中出现次数最多的类别）。
我们使用现实世界的乳腺癌数据集上cancer 来试试能否证实之前讨论过的模型复杂度和泛化能力之间的关系。先将数据集分成训练集和测试集，然后用不同的邻居个数对训练集和测试集的性能进行评估。
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
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()
plt.show()输出图形：
上面图像的 x 轴是 n_neighbors，y 轴是训练集精度和测试集精度。虽然现实世界的图像很少有非常平滑的，但我们仍可以看出过拟合与欠拟合的一些特征。仅使用单一近邻时，训练集上的预测结果十分完美。但随着邻居个数的增多，模型变得更简单，训练集精度也随之下降。单 一邻居时的测试集精度比使用更多邻居时要低，这表示单一近邻的模型过于复杂。相 反，当考虑 10 个邻居时，模型又过于简单，性能甚至变得更差。最佳性能在中间的某处， 邻居个数大约为 6。最差的性能约为 88% 的精度，这个结果仍然可以接受。
1.3 k近邻回归
k 近邻算法也可以用于回归。先从单一近邻开始，使用mglearn生成的 wave 数据集。添加了 3 个测试数据点，在 x 轴上用绿色五角星表示。利用单一邻居的预测结果就是最近邻的目标值。在下面代码的输出图形中用蓝色五角星表示：
import matplotlib.pyplot as plt
import mglearn
# plot_knn_regression方法中使用的是模拟的wave数据集，导入后可以查看此方法源码
mglearn.plots.plot_knn_regression(n_neighbors=1)
plt.show()输出下图：单一近邻回归对 wave 数据集的预测结果
同样，也可以用多个近邻进行回归。在使用多个近邻时，预测结果为这些邻居的平均值：
import matplotlib.pyplot as plt
import mglearn
# plot_knn_regression方法中使用的是模拟的wave数据集，导入后可以查看此方法源码
mglearn.plots.plot_knn_regression(n_neighbors=3)
plt.show()输出图形：3 个近邻回归对 wave 数据集的预测结果
用于回归的 k 近邻算法在 scikit-learn 的 KNeighborsRegressor 类中实现。其用法与 KNeighborsClassifier 类似：
import mglearn
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import train_test_split
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)))
# 以用 score 方法来评估模型，对于回归问题，这一方法返回的是R^2 分数。
# R^2 分数也叫作决定系数，是回归模型预测的优度度量，位于 0 到 1 之间。
# R^2 等于 1 对应完美预测，R^2 等于 0 对应常数模型，即总是预测训练集响应（y_train）的平均值
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，表示模型的拟合相对较好。
1.4 分析KNeighborsRegressor
对于一维数据集，可以查看所有特征取值对应的预测结果。为了便于绘图，我们创建一个由许多点组成的测试数据集：
import numpy as np
import matplotlib.pyplot as plt
import mglearn
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import train_test_split
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)
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 predictions", "Training data/target",
"Test data/target"], loc="best")
plt.show()输出图形：不同 n_neighbors 值的 k 近邻回归的预测结果对比
从图中可以看出，仅使用单一邻居，训练集中的每个点都对预测结果有显著影响，预测结果的图像经过所有数据点。这导致预测结果非常不稳定。考虑更多的邻居之后，预测结果变得更加平滑，但对训练数据的拟合也不好。
1.5 优点、缺点和参数
KNeighbors 分类器有 2 个重要参数：邻居个数与数据点之间距离的度量方法。 在实践中，使用较小的邻居个数（比如 3 个或 5 个）往往可以得到比较好的结果，但实际使用的时候要调节这个参数以取得更好的效果。如果选择合适的距离度量方法，则默认使用欧式距离，大多数情况下的效果都很好。 k-NN 的优点之一就是模型很容易理解，不需要过多调节就可以得到不错的性能。构建最近邻模型的速度通常很快，但如果训练集很大（特征数很多或者样本数很大），预测速度会比较慢。 使用 k-NN 算法时，对数据进行预处理是很重要的。这一算法对于有很多特征（几百或更多）的数据集往往效果不好，对于大多数特征的大多数取值都为 0 的数据集 （稀疏数据集），这一算法的效果尤其不好。 虽然 k 近邻算法很容易理解，但由于预测速度慢且不能处理具有很多特征的数据集，所以在实践中往往不会用到。