KNN算法

1.K近邻算法基础实例

import numpy as np
import matplotlib.pyplot as plt

raw_data_X=[[3.9,2.3],
            [3.1,1.7],
            [1.3,3.3],
            [3.5,4.6],
            [2.2,2.8],
            [7.4,4.6],
            [5.7,3.5],
            [9.1,2.5],
            [7.7,3.4],
            [7.9,0.7]]
raw_data_y=[0,0,0,0,0,1,1,1,1,1]

X_train=np.array(raw_data_X)
y_train=np.array(raw_data_y)

x=np.array([8,3])

plt.scatter(X_train[y_train==0,0],X_train[y_train==0,1],color='g')
plt.scatter(X_train[y_train==1,0],X_train[y_train==1,1],color='r')
plt.scatter(x[0],x[1],color='b')
plt.show()

#KNN过程
from math import sqrt   
distances=[sqrt(np.sum((x_train-x)**2)) for x_train in X_train]    
nearest=np.argsort(distances)             #nearest得到与x从近到远的点的序号
k=6
topK_y=[y_train[i] for i in nearest[:k]]  #topK_y得到最近的k个点所属的类别

from collections import Counter
votes=Counter(topK_y)                  #Counter({0:1,1:5})

predict_y=votes.most_common(1)[0][0]   #votes.most_common(1)=[(1,5)]
print(predict_y)   

2.scikit-learn中的机器学习算法封装

机器学习算法一般过程：

k近邻算法非常特殊，可以被认为是没有模型的算法，为了和其他算法统一，可以认为训练数据集就是算法本身。

import numpy as np

raw_data_X=[[3.9,2.3],
            [3.1,1.7],
            [1.3,3.3],
            [3.5,4.6],
            [2.2,2.8],
            [7.4,4.6],
            [5.7,3.5],
            [9.1,2.5],
            [7.7,3.4],
            [7.9,0.7]]
raw_data_y=[0,0,0,0,0,1,1,1,1,1]

X_train=np.array(raw_data_X)
y_train=np.array(raw_data_y)

x=np.array([8,3])

from sklearn.neighbors import KNeighborsClassifier
kNN_classifier=KNeighborsClassifier(n_neighbors=6)
kNN_classifier.fit(X_train,y_train)
X_predit=x.reshape(1,-1)               #待预测的样本转化成矩阵形式             
y_predit=kNN_classifier.predict(x)
print(y_predit[0])

3.训练数据集和测试数据集的拆分

利用鸢尾花数据集，将原本的数据集（150,4），拆分成训练集（120,4）和测试集（30,4）

且因为数据和标签是一一对应的，使用shuffle函数时要一起打乱。

import numpy as np
from sklearn import datasets

iris=datasets.load_iris()
X=iris.data        #(150,4)
y=iris.target      #(150,)

shuffle_indexes=np.random.permutation(len(X))
test_ratio=0.2
test_size=int(len(X)*test_ratio)     #规定测试集个数

test_indexes=shuffle_indexes[:test_size]  #测试集索引
train_indexes=shuffle_indexes[test_size:] #训练集索引


X_train=X[train_indexes]        #(120,4)
y_train=y[train_indexes]        #(120,)
X_test=X[test_indexes]          #(30,4)
y_test=y[test_indexes]          #(30,)

或者直接调用sklearn中的train_test_split函数

from sklearn import datasets
iris=datasets.load_iris()
X=iris.data        #(150,4)
y=iris.target      #(150,)

#sklearn中调用拆分数据集
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)    #random_state=666)随机种子，可以复现之前的额结果

from sklearn.neighbors import  KNeighborsClassifier
kNN_classifier=KNeighborsClassifier(n_neighbors=3)
kNN_classifier.fit(X_train,y_train)
            
y_predit=kNN_classifier.predict(X_test)
print(sum(y_predit==y_test)/len(y_test))   #预测准确率

4.分类准确度

 利用手写数字识别数据集，不同方法计算分类的准确率

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from sklearn import datasets

digits=datasets.load_digits()
X=digits.data            #(1797,64)
y=digits.target          #(1797,)

some_digit=X[666]        #显示某个数字
some_digit_image=some_digit.reshape(8,8)
plt.imshow(some_digit_image,cmap=matplotlib.cm.binary)
plt.show()

#拆分数据集
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,random_state=666)

#训练数据集
from sklearn.neighbors import KNeighborsClassifier
knn_clf=KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train,y_train)

#方法一：手动计算准确率
y_predict=knn_clf.predict(X_test)
print(sum(y_predict==y_test)/len(y_test))

#方法二：调用sklearn（需要计算预测值）
y_predict=knn_clf.predict(X_test)
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, y_predict))

#方法三：调用sklearn（不用计算预测值）
print(knn_clf.score(X_test, y_test))

5.超参数

超参数：运行之前需要确定的参数。（egKNN中的参数k）

模型参数：算法过程中学习的参数。

超参数1：k

利用手写数字识别数据集，进行调参，找出最好的k。

from sklearn import datasets

digits=datasets.load_digits()
X=digits.data            #(1797,64)
y=digits.target          #(1797,)

#拆分数据集
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,random_state=666)

from sklearn.neighbors import KNeighborsClassifier
best_score=0.0
best_k=-1
for k in range(1,11):
    knn_clf=KNeighborsClassifier(n_neighbors=k)
    knn_clf.fit(X_train,y_train)
    score=knn_clf.score(X_test, y_test)
    if score>best_score:
        best_k=k
        best_score=score
print('best_k=',best_k)
print('best_score=',best_score)

如果上面的搜索结果best_k=10，作为边界值，需要扩大范围，继续搜索两边。

超参数2：权重

考虑距离权重（以距离的倒数作为权重，距离越近的权重越大，距离越远的权重越小）可以解决平票问题。

KNeighborsClassifier中的参数weights='uniform'时，不考虑权重，distance时要考虑权重。

from sklearn import datasets

digits=datasets.load_digits()
X=digits.data            #(1797,64)
y=digits.target          #(1797,)

#拆分数据集
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,random_state=666)

#确定最好的k和method
from sklearn.neighbors import KNeighborsClassifier
best_method=''
best_score=0.0
best_k=-1
for method in ['uniform','distance']:
    for k in range(1,11):
        knn_clf=KNeighborsClassifier(n_neighbors=k,weights=method)
        knn_clf.fit(X_train,y_train)
        score=knn_clf.score(X_test, y_test)
        if score>best_score:
            best_k=k
            best_score=score
            best_method=method
print('best_method=',best_method)
print('best_k=',best_k)
print('best_score=',best_score)

超参数3：距离

距离包括欧拉距离（默认）、曼哈顿距离

明可夫斯基距离

p=1时为曼哈顿距离；p=2时为欧拉距离。

KNeighborsClassifier中的参数p，p就是明可夫斯基中的p。p只有在weights='distance'才有意义。

from sklearn import datasets

digits=datasets.load_digits()
X=digits.data            #(1797,64)
y=digits.target          #(1797,)

#拆分数据集
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,random_state=666)

#确定最好的p
from sklearn.neighbors import KNeighborsClassifier
best_p=-1
best_score=0.0
best_k=-1
for k in range(1,11):
    for p in range(1,6):
        knn_clf=KNeighborsClassifier(n_neighbors=k,weights='distance',p=p)
        knn_clf.fit(X_train,y_train)
        score=knn_clf.score(X_test, y_test)
        if score>best_score:
            best_k=k
            best_score=score
            best_p=p
print('best_p=',best_p)
print('best_k=',best_k)
print('best_score=',best_score)

6.网格搜索Grid Search

cv即交叉验证。

from sklearn import datasets

digits=datasets.load_digits()
X=digits.data            #(1797,64)
y=digits.target          #(1797,)

#拆分数据集
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,random_state=666)

#网格搜索
param_grid=[
    {
         'weights':['uniform'],
         'n_neighbors':[i for i in range(1,11)]
     },
    {
         'weights':['distance'],
         'n_neighbors':[i for i in range(1,11)],
         'p':[i for i in range(1,6)]
     }
    ]
from sklearn.neighbors import KNeighborsClassifier
knn_clf=KNeighborsClassifier()

from sklearn.model_selection import GridSearchCV
grid_search=GridSearchCV(knn_clf, param_grid)

grid_search.fit(X_train,y_train)
print(grid_search.best_estimator_)    #显示全部最佳参数组合
print(grid_search.best_score_)        #准确度
print(grid_search.best_params_)       #显示我们给定的参数的最佳组合
knn_clf=grid_search.best_estimator_
knn_clf.score(X_test,y_test)

GridSearchCV更多参数

1. n_jobs：默认为1，单核；等于-1时，全部核用来网格搜索
2. verbose：不同的值相应的搜索输出不一样，通常为2

更多距离定义：向量空间余弦相似度、调整余弦相似度、皮尔森相关系数、Jaccard系数

7.数据归一化（Feature Scaling）

将所有的数据映射到同一尺度

• 最值归一化（normalization）：把所有数据映射到0-1之间，适用于数据分布有明显边界的情况，受outliner影响较大。

• 均值方差归一化（standardization）：把所有数据归一到均值为0，方差为1的分布中。适用于数据分布没有明显边界，有可能存在极端数据值。

#最值归一化（一维）
import numpy as np
x=np.random.randint(0,100,size=100)
print((x-np.min(x))/(np.max(x)-np.min(x)))

#最值归一化（二维）
X=np.random.randint(0,100,(50,2))
X=np.array(X,dtype=float)
#如果有n列，使用for循环实现
X[:,0]=(X[:,0]-np.min(X[:,0]))/(np.max(X[:,0])-np.min(X[:,0]))
X[:,1]=(X[:,1]-np.min(X[:,1]))/(np.max(X[:,1])-np.min(X[:,1]))

#均值方差归一化
X2=np.random.randint(0,100,(50,2))
X2=np.array(X,dtype=float)
X2[:,0]=(X2[:,0]-np.mean(X2[:,0]))/np.std(X2[:,0])
X2[:,1]=(X2[:,1]-np.mean(X2[:,1]))/np.std(X2[:,1])

8.scikit-learn中的Scaler

对测试数据集如何归一化？

使用训练数据集得出的mean_train和std_train进行计算

原因：测试数据集是模拟真实环境的，但真实环境可能无法得到所有测试数据的均值和方差

from sklearn import datasets

iris=datasets.load_iris()
X=iris.data
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.2,random_state=666)

from sklearn.preprocessing import StandardScaler
standardScaler=StandardScaler()
standardScaler.fit(X_train)

X_train=standardScaler.transform(X_train)             #训练集归一化
X_test_standard=standardScaler.transform(X_test)      #测试集归一化

from sklearn.neighbors import KNeighborsClassifier
knn_clf=KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train, y_train)
print(knn_clf.score(X_test_standard,y_test))          #如果训练集进行了归一化，那测试集也需要归一化，同步的