Python机器学习07——K近邻

本系列所有的代码和数据都可以从陈强老师的个人主页上下载：Python数据程序

参考书目：陈强.机器学习及Python应用. 北京：高等教育出版社, 2021.

本系列基本不讲数学原理，只从代码角度去让读者们利用最简洁的Python代码实现机器学习方法。

---

与前面的经典统计学的参数方法不同，后面几章会陆续介绍非参数的监督学习方法，并且与参数方法不同，几乎所有的非参数方法既可以用于回归，也可以用于分类。最简单的非参数方法为K近邻方法，即在超空间上度量与样本最近的点的类别y最多的取值（回归则是取平均）作为预测值。

K近邻回归

本文会将回归和分类都讲述一个例子，首先演示K近邻回归，采用的是经典的非线性的一个数据集mcyle，导入包读取数据如下：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.neighbors import KNeighborsRegressor

#读取数据
mcycle = pd.read_csv('mcycle.csv')
#展示数据形状
mcycle.shape
#展示数据前五行
mcycle.head()

​数据长这个样子，times是x，accel是y。下面画他们的散点图。

#数据的描述性统计
mcycle.describe()

#画散点图
sns.scatterplot(x='times', y='accel', data=mcycle)
plt.title('Simulated Motorcycle Accident')

​很典型的非线性关系。

 取出X和y，进行K近邻估计

X_raw = np.array(mcycle.times)

X = np.array(mcycle.times).reshape(-1, 1)

y = mcycle.accel

画图展示当K=1, 5,10, 15,20,25,30, 40,50,60的时候的回归效果

fig, ax = plt.subplots(3,3, figsize=(9,6), sharex=True, sharey=True)
fig.subplots_adjust(hspace=0.5, wspace=0.5)

for i,k in zip([1, 2, 3, 4,5,6,7,8,9], [1, 5,10, 15,20,25,30, 40,50,60]):
    model = KNeighborsRegressor(n_neighbors=k)
    model.fit(X, y)
    pred = model.predict(np.arange(60).reshape(-1, 1))
    plt.subplot(3, 3, i)
    sns.scatterplot(x='times', y='accel', s=20, data=mcycle, facecolor='none', edgecolor='k')
    plt.plot(np.arange(60), pred, 'b')
    plt.text(0, 55, f'K = {k}')
plt.tight_layout()

​

 我们可以看出，当k值越小，回归的曲线很不光滑，这个时候误差虽然很小，但是存在着过拟合现象模型的泛化能力较差。而当k值越大的时候，回归的曲线越光滑也越平坦，此时可能存在着欠拟合回归函数，不能够捕捉数据的特征。因此要选择一个折中的k=10或者15的时候是最佳的。

进一步采用简单的鸢尾花数据集画出不同K时的模型决策边界。

import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from mlxtend.plotting import plot_decision_regions

X, y = load_iris(return_X_y=True)
X2 = X[:, 2:4]

fig, ax = plt.subplots(2, 2, figsize=(9, 6), sharex=True, sharey=True)
fig.subplots_adjust(hspace=0.1, wspace=0.1)
for i, k in zip([1, 2, 3, 4], [1, 10, 25, 50]):
    model = KNeighborsClassifier(n_neighbors=k)
    model.fit(X2, y)
    plt.subplot(2, 2, i)
    plot_decision_regions(X2, y, model)
    plt.xlabel('petal_length')
    plt.ylabel('petal_width')
    plt.text(0.3, 3, f'K = {k}')
plt.tight_layout()

​

 可以看出当K越大，决策边界越平滑，越不容易过拟合。当然K过大可能也会欠拟合。

---

K近邻分类

使用一个乳腺癌的数据演示K近邻分类，这个数据是sklearn库自带的。特征变量X为肿瘤细胞的特征，响应变量y为恶性肿瘤0，或者是良性肿瘤1。导入包和读取数据

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import GridSearchCV

cancer = load_breast_cancer()

df = pd.DataFrame(cancer.data, columns=cancer.feature_names)
df['diagnosis'] = cancer.target

d = {0: 'malignant', 1: 'benign'}
df['diagnosis'] = df['diagnosis'].map(d)

df.shape

数据形状为(569, 31)，即569个样本，30个特征变量X，和一个响应变量y。

画第一个特征变量（肿瘤的平均半径）和y（肿瘤类别）的箱线图：

sns.boxplot(x='diagnosis', y='mean radius', data=df)

可以看出恶性肿瘤的平均半径大于良性肿瘤 。下面开始机器学习！取出X，y。然后标准化

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=100, random_state=1)

scaler = StandardScaler()
scaler.fit(X_train)
X_train_s = scaler.transform(X_train)
X_test_s = scaler.transform(X_test)

开始K近邻分类

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train_s, y_train)  #拟合
#测试集评价
model.score(X_test_s, y_test)
#预测
pred = model.predict(X_test_s)
pred
#计算混淆矩阵
pd.crosstab(y_test, pred, rownames=['Actual'], colnames=['Predicted'])

效果不错，只有3个分类错误的。

 下面手动寻找最优的K

# Choose optimal K via test set
scores = []
ks = range(1, 51)
for k in ks:
    model = KNeighborsClassifier(n_neighbors=k)
    model.fit(X_train_s, y_train)
    score = model.score(X_test_s, y_test)
    scores.append(score)
print(max(scores))
index_max = np.argmax(scores)
print(index_max)
print(f'Optimal K: {ks[index_max]}')

计算得到k为3时最佳，画图：

# Graph accuracy versus K 

plt.plot(ks, scores, 'o-')
plt.xlabel('K')
plt.axvline(ks[index_max], linewidth=1, linestyle='--', color='k')
plt.ylabel('Accuracy')
plt.title('KNN')
plt.tight_layout()

 

 还可以画不同k时的错误率

# Graph error rate versus K
errors = 1 - np.array(scores)
plt.plot(ks, errors, 'o-')
plt.xlabel('K')
plt.axvline(ks[index_max], linewidth=1, linestyle='--', color='k')
plt.ylabel('Error Rate')
plt.title('KNN')
plt.tight_layout()

用1/k表示模型复杂度，k越小越容易过拟合

# Graph error rate versus 1/K

errors = 1 - np.array(scores)
ks_inverse = 1 / np.array(ks)
plt.plot(ks_inverse, errors, 'o-')
plt.xlabel('1/K')
plt.ylabel('Error Rate')
plt.title('KNN')
plt.tight_layout()

 

 采用10折交叉验证选择最优超参数K：

# Choose optimal K via CV
param_grid = {'n_neighbors': range(1, 51)}
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)
model = GridSearchCV(KNeighborsClassifier(), param_grid, cv=kfold)
model.fit(X_train_s, y_train)

#最优参数
model.best_params_

#此时的准确率（评分）
model.score(X_test_s, y_test)

最优K为12，评分为0.96