机器学习原理与实战 | K近邻算法实践

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

KNN算法中，其算法参数是K，参数选择需要根据数据来决定。K值越大，模型的偏差越大，对噪声数据越不敏感，当K值很大时，可能造成模型欠拟合；K值越小，模型的方差就会越大，当K值太小，就会造成模型过拟合。

K-近邻算法有一些变种，其中之一就是可以增加邻居的权重。默认情况下，在计算距离时，都是使用相同的权重。实际上，我们可以针对不同的邻居指定不同的权重，如距离越近权重越高。这个可以通过指定算法的weights参数来实现。

另外一个变种是，使用一定半径内的点取代距离最近的K个点。在scikit-learn里，RadiusNeighborsClassifier类实现了这个算法的变种。当数据采样不均匀时，该算法变种可以取得更好的性能。

1. KNN实现分类

# from sklearn.datasets.samples_generator import make_blobs
from sklearn.datasets import make_blobs

# 根据中心点随机生成数据
centers = [[-2, 2], [2, 2], [0, 4]]
# centers = [[-2, 0], [2, 0], [0, 4], [0,2]]
X, y = make_blobs(n_samples=100, centers=centers, random_state=0, cluster_std=0.40)

# 画出数据
plt.figure(figsize=(12,8))
c = np.array(centers)
plt.scatter(X[:, 0], X[:, 1], c=y, s=100, cmap='cool');         # 画出样本
plt.scatter(c[:, 0], c[:, 1], s=100, marker='^', c='orange');   # 画出中心点

使用KNeighborsClassifier来对算法进行训练，下面进行单样本预测

from sklearn.neighbors import KNeighborsClassifier
# 模型训练
k = 5
clf = KNeighborsClassifier(n_neighbors=k)
clf.fit(X, y)

# 进行预测
X_sample = [0, 2]
X_sample = np.array(X_sample).reshape(1, -1)
# 根据两个x坐标预测一个y坐标
y_sample = clf.predict(X_sample)
# 使用kneighbors()方法，把这个样本周围距离最近的5个点取出来。取出来的点是训练样本X里的索引，从0开始计算。
neighbors = clf.kneighbors(X_sample, return_distance=False)

# 其中，这里输出的1表示一个样本，如果是多个样本，则为n，neighbors里面就会存储n个样本距离最近的前k个点
X_sample.shape, X.shape, y.shape, y_sample.shape, neighbors.shape

((1, 2), (100, 2), (100,), (1,), (1, 5))

# 画出示意图
plt.figure(figsize=(12, 8))
plt.scatter(X[:, 0], X[:, 1], c=y, s=100, cmap='cool')    # 样本
plt.scatter(c[:, 0], c[:, 1], s=100, marker='^', c='k')   # 中心点
plt.scatter(X_sample[0][0], X_sample[0][1], marker="x", 
            s=100, cmap='cool')    # 待预测的点

for i in neighbors[0]:
    # 预测点与距离最近的 5 个样本的连线。其中第一个列表是存放x坐标，第二个列表存放y的坐标
    plt.plot([X[i][0], X_sample[0][0]], [X[i][1], X_sample[0][1]], 
             'k--', linewidth=0.6)

多样本预测，上诉图中只使用了一个样本进行可视化，但是一般来说需要处理多个样本，这里使用同样的方法来可视化结果

# 这里的k设置为5
X_sample = np.random.randint(-2,4,[5, 2])
neighbors = clf.kneighbors(X_sample, return_distance=False)

X_sample.shape, neighbors.shape

((5, 2), (5, 5))

# 画出示意图
plt.figure(figsize=(12, 8))
plt.scatter(X[:, 0], X[:, 1], c=y, s=100, cmap='cool')    # 样本
plt.scatter(c[:, 0], c[:, 1], s=100, marker='^', c='k')   # 中心点
plt.scatter(X_sample[:,0], X_sample[:,1], marker="x", s=100, cmap='cool')    # 待预测的点

for i,neighbors_data in enumerate(neighbors):
    # 预测点与距离最近的 5 个样本的连线。其中第一个列表是存放x坐标，第二个列表存放y的坐标
    for t in neighbors_data:
        plt.plot([X[t][0], X_sample[i][0]], [X[t][1], X_sample[i][1]], 'k--', linewidth=0.6)

如上图所示，直接根据最近的k个值来决定样本的类别

2. KNN实现回归

# 生成训练样本
n_dots = 40
X = 5 * np.random.rand(n_dots, 1)
y = np.cos(X).ravel()

# 添加一些噪声
y += 0.2 * np.random.rand(n_dots) - 0.1

# 显示图像
plt.scatter(X,y,s=20)

<matplotlib.collections.PathCollection at 0x1db687e7888>

# 训练模型
from sklearn.neighbors import KNeighborsRegressor

k = 5
# 回归训练
knn = KNeighborsRegressor(k)
knn.fit(X, y)

# 生成足够密集的点并进行预测
T = np.linspace(0, 5, 500).reshape(-1,1)
# 得到密集区间内的预测点
y_pred = knn.predict(T)

# 使用score()方法计算拟合曲线对训练样本的拟合准确性
# knn.score(X, y)
# out: 0.9790114894878551

# 再把这些预测点连起来，构成一条拟合曲线
plt.plot(T,y_pred,c='k')
# 显示原散点图图像
plt.scatter(X,y,s=20,c='r')

<matplotlib.collections.PathCollection at 0x1db6894cdc8>

3. 示例：KNN实现糖尿病预测

加载数据集

import pandas as pd

data = pd.read_csv('E:/学习/机器学习/b站资料/scikit-learn机器学习/code/datasets/pima-indians-diabetes/diabetes.csv')
data.head(6)

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age	Outcome
0	6	148	72	35	0	33.6	0.627	50	1
1	1	85	66	29	0	26.6	0.351	31	0
2	8	183	64	0	0	23.3	0.672	32	1
3	1	89	66	23	94	28.1	0.167	21	0
4	0	137	40	35	168	43.1	2.288	33	1
5	5	116	74	0	0	25.6	0.201	30	0

# 可以进一步观察数据集里的阳性和阴性样本的个数：
data.groupby("Outcome").size()

Outcome
0    500
1    268
dtype: int64

把8个特征值分离出来，作为训练数据集，把Outcome列分离出来作为目标值。然后，把数据集划分为训练数据集和测试数据集。

X = data.iloc[:, 0:8]
Y = data.iloc[:, 8]

print('shape of X {}; shape of Y {}'.format(X.shape,Y.shape))
      
from sklearn.model_selection import train_test_split
X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.2)

X_train.shape, X_test.shape, Y_train.shape, Y_test.shape

shape of X (768, 8); shape of Y (768,)





((614, 8), (154, 8), (614,), (154,))

分别使用普通的KNN算法、带权重的KNN算法和指定半径的KNN算法对数据集进行拟合并计算评分：

from sklearn.neighbors import KNeighborsClassifier, RadiusNeighborsClassifier

# 三种模型的构建：k值均为2
k = 5
models = []
models.append(("KNN", KNeighborsClassifier(n_neighbors=k)))
models.append(("KNN with weights", KNeighborsClassifier(n_neighbors=k, weights="distance")))
models.append(("Radius Neighbors", RadiusNeighborsClassifier(n_neighbors=k, radius=500.0)))

# 训练结构存储
results = []
for name, model in models:
    # 训练
    model.fit(X_train, Y_train)
    # 保存测试结果
    results.append((name, model.score(X_test, Y_test)))
for i in range(len(results)):
    print("name: {}; score: {}".format(results[i][0],results[i][1]))

name: KNN; score: 0.7077922077922078
name: KNN with weights; score: 0.7142857142857143
name: Radius Neighbors; score: 0.6493506493506493

怎么样更准确地对比算法准确性呢？一个方法是，多次随机分配训练数据集和交叉验证数据集，然后求模型准确性评分的平均值。scikit-learn提供了KFold和cross_val_score()函数来处理这种问题：

• KFold把数据集分成10份，其中1份会作为交叉验证数据集来计算模型准确性，剩余的9份作为训练数据集。
• cross_val_score()函数总共计算出10次不同训练数据集和交叉验证数据集组合得到的模型准确性评分，最后求平均值。

from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score

results = []
for name, model in models:
    # 把数据集分成10份，其中1份会作为交叉验证数据集来计算模型准确性，剩余的9份作为训练数据集。
    kfold = KFold(n_splits=10)
    # 函数总共计算出10次不同训练数据集和交叉验证数据集组合得到的模型准确性评分
    cv_result = cross_val_score(model, X, Y, cv=kfold)
    results.append((name, cv_result))
for i in range(len(results)):
    # 组合评分去平均值输出
    print("name: {}; cross val score: {}".format(results[i][0],results[i][1].mean()))

name: KNN; cross val score: 0.7265550239234451
name: KNN with weights; cross val score: 0.7265550239234451
name: Radius Neighbors; cross val score: 0.6497265892002735

可以查看一下result的结果:

results

[('KNN',
  array([0.63636364, 0.83116883, 0.7012987 , 0.63636364, 0.71428571,
         0.75324675, 0.74025974, 0.80519481, 0.68421053, 0.76315789])),
 ('KNN with weights',
  array([0.64935065, 0.83116883, 0.68831169, 0.63636364, 0.71428571,
         0.75324675, 0.75324675, 0.79220779, 0.68421053, 0.76315789])),
 ('Radius Neighbors',
  array([0.5974026 , 0.71428571, 0.54545455, 0.5974026 , 0.64935065,
         0.61038961, 0.81818182, 0.67532468, 0.68421053, 0.60526316]))]

可以查看一下models的结果:

models

[('KNN', KNeighborsClassifier()),
 ('KNN with weights', KNeighborsClassifier(weights='distance')),
 ('Radius Neighbors', RadiusNeighborsClassifier(radius=500.0))]

对比了不同的模型效果之后，可以进行训练与结果分析

knn = KNeighborsClassifier(n_neighbors=4)

# 训练
knn.fit(X_train, Y_train)
# 测试
train_score = knn.score(X_train, Y_train)
test_score = knn.score(X_test, Y_test)

print("train score: {}; test score: {}".format(train_score, test_score))

train score: 0.8110749185667753; test score: 0.7142857142857143

从这个输出中可以看到两个问题：

• 一是对训练样本的拟合情况不佳，这说明算法模型太简单了，无法很好地拟合训练样本
• 二是模型的准确性欠佳，不到72%的预测准确性

画出学习曲线证实结论

from sklearn.model_selection import ShuffleSplit
from utils import plot_learning_curve

knn = KNeighborsClassifier(n_neighbors=2)
# 多次计算使其平滑
cv = ShuffleSplit(n_splits=10, test_size=0.2, random_state=0)
plt.figure(figsize=(10, 6))
# 这里划分了5次，所以对应五个点
plot_learning_curve(plt, knn, "Learn Curve for KNN Diabetes", 
                    X, Y, ylim=(0.0, 1.01), cv=cv);

从图中可以看出来，训练样本评分较低，且测试样本与训练样本距离较大，这是典型的欠拟合现象。KNN算法没有更好的措施来解决欠拟合问题,什么KNN算法不是针对这一问题的好模型？下面进行特征选择与可视化出来

特征选择及数据可视化

8个特征，无法在这么高的维度里画出数据，并直观地观察。一个解决办法是特征选择，即只选择2个与输出值相关性最大的特征，这样就可以在二维平面上画出输入特征值与输出值的关系了。scikit-learn在sklearn.feature_selection包里提供了丰富的特征选择方法。可以使用SelectKBest来选择相关性最大的两个特征：

from sklearn.feature_selection import SelectKBest

selector = SelectKBest(k=2)
X_new = selector.fit_transform(X, Y)
X_new[:5]

array([[148. ,  33.6],
       [ 85. ,  26.6],
       [183. ,  23.3],
       [ 89. ,  28.1],
       [137. ,  43.1]])

只使用这2个相关性最高的特征的话,对比不同的KNN模型

results = []
for name, model in models:
    kfold = KFold(n_splits=10)
    # 这里使用了X_new来进行训练
    cv_result = cross_val_score(model, X_new, Y, cv=kfold)
    results.append((name, cv_result))
for i in range(len(results)):
    print("name: {}; cross val score: {}".format(
        results[i][0],results[i][1].mean()))

name: KNN; cross val score: 0.7369104579630894
name: KNN with weights; cross val score: 0.7199419002050581
name: Radius Neighbors; cross val score: 0.6510252904989747

还是普通的KNN模型准确性较高, 实验的结果比使用8个特征还要好

现在我们只有2个特征，可以很方便地在二维坐标上画出所有的训练样本，观察这些数据的分布情况：

plt.figure(figsize=(14, 10))
plt.ylabel("BMI")
plt.xlabel("Glucose")
plt.scatter(X_new[Y==0][:,0],X_new[Y==0][:,1],s=20,c='r',marker='x')
plt.scatter(X_new[Y==1][:,0],X_new[Y==1][:,1],s=20,c='b',marker='x')
plt.title("Data distribution")

Text(0.5, 1.0, 'Data distribution')

从图中可以看出，在中间数据集密集的区域，阳性样本和阴性样本几乎重叠在一起了,所以比较难以检测