Scikit Learn - KNN 学习

---

k-NN（k-Nearest Neighbor）是最简单的机器学习算法之一，本质上是非参数和惰性的。非参数意味着没有对基础数据分布的假设，即模型结构是根据数据集确定的。惰性学习或基于实例的学习意味着为了模型生成的目的，不需要任何训练数据点，并且在测试阶段使用整个训练数据。

k-NN 算法由以下两个步骤组成 -

步骤1

在此步骤中，它计算并存储训练集中每个样本的 k 个最近邻。

第2步

在此步骤中，对于未标记的样本，它从数据集中检索 k 个最近邻。然后在这些k个近邻中，通过投票来预测类别（获得多数票的类别获胜）。

sklearn.neighbors模块实现了 k 最近邻算法，提供了无监督和有监督的基于邻居的学习方法的功能。

无监督最近邻实现不同的算法（BallTree、KDTree 或 Brute Force）来查找每个样本的最近邻。这个无监督版本基本上只是上面讨论的步骤 1，并且是许多需要邻居搜索的算法（KNN 和 K-means 是著名的）的基础。简单来说，它是用于实现邻居搜索的无监督学习器。

另一方面，基于邻居的监督学习用于分类和回归。

无监督 KNN 学习

正如所讨论的，存在许多需要最近邻搜索的算法，例如 KNN 和 K-Means。这就是为什么 Scikit-learn 决定将邻居搜索部分作为自己的“学习器”来实现。将邻居搜索作为单独的学习器进行的原因是，计算所有成对距离来查找最近邻居显然效率不高。让我们看看 Sklearn 用于实现无监督最近邻学习的模块以及示例。

Scikit 学习模块

sklearn.neighbors.NearestNeighbors是用于实现无监督最近邻学习的模块。它使用名为 BallTree、KDTree 或 Brute Force 的特定最近邻算法。换句话说，它充当这三种算法的统一接口。

参数

下表包含NearestNeighbors模块使用的参数-

实施例

下面的示例将使用sklearn.neighbors.NearestNeighbors模块查找两组数据之间的最近邻居。

首先，我们需要导入所需的模块和包 -

from sklearn.neighbors import NearestNeighbors
import numpy as np

现在，导入包后，定义我们想要找到最近邻居的数据集 -

Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])

接下来，应用无监督学习算法，如下 -

nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm = 'ball_tree')

接下来，用输入数据集拟合模型。

nrst_neigh.fit(Input_data)

现在，找到数据集的 K 邻居。它将返回每个点的邻居的索引和距离。

distances, indices = nbrs.kneighbors(Input_data)
indices

输出

array(
   [
      [0, 1, 3],
      [1, 2, 0],
      [2, 1, 0],
      [3, 4, 0],
      [4, 5, 3],
      [5, 6, 4],
      [6, 5, 4]
   ], dtype = int64
)
distances

输出

array(
   [
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712],
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712]
   ]
)

上面的输出显示每个点的最近邻居是该点本身，即为零。这是因为查询集与训练集匹配。

例子

我们还可以通过生成稀疏图来显示相邻点之间的连接，如下所示 -

nrst_neigh.kneighbors_graph(Input_data).toarray()

输出

array(
   [
      [1., 1., 0., 1., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 0., 0., 1., 1., 0., 0.],
      [0., 0., 0., 1., 1., 1., 0.],
      [0., 0., 0., 0., 1., 1., 1.],
      [0., 0., 0., 0., 1., 1., 1.]
   ]
)

一旦我们拟合无监督的NearestNeighbors模型，数据将存储在基于参数'algorithm'的值集的数据结构中。之后，我们可以在需要邻居搜索的模型中使用这个无监督学习器的邻居。

完整的工作/可执行程序

from sklearn.neighbors import NearestNeighbors
import numpy as np
Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])
nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm='ball_tree')
nrst_neigh.fit(Input_data)
distances, indices = nbrs.kneighbors(Input_data)
indices
distances
nrst_neigh.kneighbors_graph(Input_data).toarray()

监督 KNN 学习

基于邻居的监督学习用于以下目的 -

• 分类，针对具有离散标签的数据
• 回归，针对具有连续标签的数据。

最近邻分类器

我们可以借助以下两个特征来理解基于邻居的分类 -

• 它是根据每个点的最近邻居的简单多数投票计算得出的。
• 它只是存储训练数据的实例，这就是为什么它是一种非泛化学习。

Scikit-learn 模块

以下是 scikit-learn 使用的两种不同类型的最近邻分类器 -

最近邻回归器

它用于数据标签本质上连续的情况。分配的数据标签是根据其最近邻居的标签的平均值计算的。

以下是 scikit-learn 使用的两种不同类型的最近邻回归器 -

K邻居回归器

该回归器名称中的 K 表示 k 个最近邻，其中k是用户指定的整数值。因此，顾名思义，这个回归器基于 k 个最近邻实现学习。k值的选择取决于数据。让我们通过一个实现示例来更好地理解它。

以下是 scikit-learn 使用的两种不同类型的最近邻回归器 -

实施例

在此示例中，我们将使用 scikit-learn KNeighborsRegressor在名为 Iris Flower 数据集的数据集上实现 KNN 。

首先，导入 iris 数据集，如下所示 -

from sklearn.datasets import load_iris
iris = load_iris()

现在，我们需要将数据分为训练数据和测试数据。我们将使用 Sklearn train_test_split函数将数据拆分为 70（训练数据）和 20（测试数据）的比例 -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

接下来，我们将借助 Sklearn 预处理模块进行数据缩放，如下所示 -

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

接下来，从 Sklearn 导入KNeighborsRegressor类并提供邻居值，如下所示。

例子

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 8)
knnr.fit(X_train, y_train)

输出

KNeighborsRegressor(
   algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = None, n_neighbors = 8, p = 2,
   weights = 'uniform'
)

例子

现在，我们可以找到 MSE（均方误差）如下 -

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

输出

The MSE is: 4.4333349609375

例子

现在，用它来预测值，如下所示 -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

输出

[0.66666667]

完整的工作/可执行程序

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=8)
knnr.fit(X_train, y_train)

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

半径邻居回归器

该回归器名称中的 Radius 表示指定半径 r 内的最近邻居，其中 r 是用户指定的浮点值。因此，顾名思义，该回归器基于每个训练点的固定半径 r 内的邻居数量来实现学习。让我们在实现示例的帮助下更好地理解它 -

实施例

在此示例中，我们将使用 scikit-learn RadiusNeighborsRegressor在名为 Iris Flower 数据集的数据集上实现 KNN -

首先，导入 iris 数据集，如下所示 -

from sklearn.datasets import load_iris
iris = load_iris()

现在，我们需要将数据分为训练数据和测试数据。我们将使用 Sklearn train_test_split 函数将数据拆分为 70（训练数据）和 20（测试数据）的比例 -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)

接下来，我们将借助 Sklearn 预处理模块进行数据缩放，如下所示 -

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

接下来，从 Sklearn 导入RadiusneighborsRegressor类并提供半径值，如下所示 -

import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X_train, y_train)

例子

现在，我们可以找到 MSE（均方误差）如下 -

print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))

输出

The MSE is: The MSE is: 5.666666666666667

例子

现在，用它来预测值，如下所示 -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))

输出

[1.]

完整的工作/可执行程序

from sklearn.datasets import load_iris

iris = load_iris()

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X_train, y_train)
print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))