1、KNN算法簡介

KNN (K-Nearest Neighbor) 最鄰近分類算法，其核心思想“近朱者赤，近墨者黑”，由你的鄰居來推斷你的類別。

圖中綠色圓歸為哪一類？
1、如果k=3，綠色圓歸為紅色三角形
2、如果k=5，綠色圓歸為藍色正方形

參考文章

knn算法實現(xiàn)原理：為判斷未知樣本數(shù)據(jù)的類別，以所有已知樣本數(shù)據(jù)作為參照物，計算未知樣本數(shù)據(jù)與所有已知樣本數(shù)據(jù)的距離，從中選取k個與已知樣本距離最近的k個已知樣本數(shù)據(jù)，根據(jù)少數(shù)服從多數(shù)投票法則，將未知樣本與K個最鄰近樣本中所屬類別占比較多的歸為一類。（我們還可以給鄰近樣本加權(quán)，距離越近的權(quán)重越大，越遠越小）

2、KNN算法實現(xiàn)

1、k值選擇：太小容易產(chǎn)生過擬合問題，過度相信樣本數(shù)據(jù)，太大容易產(chǎn)生欠擬合問題，與數(shù)據(jù)貼合不夠解密，決策效率低。

2、樣本數(shù)據(jù)歸一化：最簡單的方式就是所有特征的數(shù)值都采取歸一化處置。

3、一個距離函數(shù)計算兩個樣本之間的距離：通常使用的距離函數(shù)有：歐氏距離、曼哈頓距離、漢明距離等，一般選歐氏距離作為距離度量，但是這是只適用于連續(xù)變量。在文本分類這種非連續(xù)變量情況下，漢明距離可以用來作為度量。通常情況下，如果運用一些特殊的算法來計算度量的話，K近鄰分類精度可顯著提高。

4、KNN優(yōu)點：
1.簡單，易于理解，易于實現(xiàn)，無需估計參數(shù)，無需訓練
2. 適合對稀有事件進行分類
3.特別適合于多分類問題(multi-modal,對象具有多個類別標簽)， KNN比SVM的表現(xiàn)要好

5、KNN缺點：
KNN算法在分類時有個主要的不足是，當樣本不平衡時，如一個類的樣本容量很大，而其他類樣本容量很小時，有可能導致當輸入一個新樣本時，該樣本的K個鄰居中大容量類的樣本占多數(shù)，如下圖所示。該算法只計算最近的鄰居樣本，某一類的樣本數(shù)量很大，那么或者這類樣本并不接近目標樣本，或者這類樣本很靠近目標樣本。無論怎樣，數(shù)量并不能影響運行結(jié)果?？梢圆捎脵?quán)值的方法(和該樣本距離小的鄰居權(quán)值大)來改進。該方法的另一個不足之處是計算量較大，因為對每一個待分類的文本都要計算它到全體已知樣本的距離，才能求得它的K個最近鄰點。
可理解性差，無法給出像決策樹那樣的規(guī)則。

實現(xiàn)KNN算法簡單實例

1、樣本數(shù)據(jù)散點圖展示

# KNN算法實現(xiàn)
import numpy as np
import matplotlib.pyplot as plt

# 樣本數(shù)據(jù) 
data_X = [
        [1.3,6],
        [3.5,5],
        [4.2,2],
        [5,3.3],
        [2,9],
        [5,7.5],
        [7.2,4],
        [8.1,8],
        [9,2.5],
    ]
# 樣本標記數(shù)組
data_y = [0,0,0,0,1,1,1,1,1]

# 將數(shù)組轉(zhuǎn)換成np數(shù)組
X_train = np.array(data_X)
y_train = np.array(data_y)

# 散點圖繪制
# 取等于0的行中的第0列數(shù)據(jù)X_train[y_train==0,0]
plt.scatter(X_train[y_train==0,0],X_train[y_train==0,1],color='red',marker='x')
# 取等于1的行中的第1列數(shù)據(jù)X_train[y_train==1,0]
plt.scatter(X_train[y_train==1,0],X_train[y_train==1,1],color='black',marker='o')
plt.show()

2、新的樣本數(shù)據(jù)，判斷它屬于哪一類

data_new = np.array([4,5])
plt.scatter(X_train[y_train==0,0],X_train[y_train==0,1],color='red',marker='x')
plt.scatter(X_train[y_train==1,0],X_train[y_train==1,1],color='black',marker='o')
plt.scatter(data_new[0],data_new[1],color='blue',marker='s')
plt.show()

3、計算新樣本點與所有已知樣本點的距離

Numpy使用

# 樣本數(shù)據(jù)-新樣本數(shù)據(jù) 的平方，然后開平，存儲距離值到distances中
distances = [np.sqrt(np.sum((data-data_new)**2)) for data in X_train]
# 按照距離進行排序，返回原數(shù)組中索引 升序
sort_index = np.argsort(distances)

# 隨機選一個k值
k = 5

# 距離最近的5個點進行投票表決
first_k = [y_train[i] for i in sort_index[:k]]

# 使用計數(shù)庫統(tǒng)計
from collections import Counter
# 取出結(jié)果為類別0
predict_y = Counter(first_k).most_common(1)[0][0]
predict_y

2.1、調(diào)用scikit-learn庫中KNN算法

2007年，Scikit-learn首次被Google Summer of Code項目開發(fā)使用，現(xiàn)在已經(jīng)被認為是最受歡迎的機器學習Python庫。

安裝：pip install scikit-learn

# 使用scikit-learn中的KNN算法
from sklearn.neighbors import KNeighborsClassifier
# 初始化設(shè)置k大小
knn_classifier = KNeighborsClassifier(n_neighbors=5)
# 喂入數(shù)據(jù)集，以及數(shù)據(jù)類型
knn_classifier.fit(X_train,y_train)
# 放入新樣本數(shù)據(jù)進行預測，需要先轉(zhuǎn)換成二維數(shù)組
knn_classifier.predict(data_new.reshape(1,-1))

3、使用scikit-learn庫生成數(shù)據(jù)集

生成的數(shù)據(jù)，畫出的散點圖

# 數(shù)據(jù)集生產(chǎn)
import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import make_blobs
x,y = make_blobs(
    n_samples=300, # 樣本總數(shù)
    n_features=2, # 生產(chǎn)二維數(shù)據(jù)
    centers=3, # 種類數(shù)據(jù)
    cluster_std=1, # 類內(nèi)的標注差
    center_box=(-10,10), # 取值范圍
    random_state=233, # 隨機數(shù)種子
    return_centers=False, # 類別中心坐標反回值
)
# c指定每個點顏色，s指定點大小
plt.scatter(x[:,0],x[:,1],c=y,s=15)
plt.show()
x.shape,y.shape

3.1、自定義函數(shù)劃分數(shù)據(jù)集

將生成好的數(shù)據(jù)集，劃分成訓練數(shù)據(jù)集和測試數(shù)據(jù)集

# 數(shù)據(jù)集劃分
np.random.seed(233)
# 隨機生成數(shù)組排列下標
shuffle = np.random.permutation(len(x))
train_size = 0.7

train_index = shuffle[:int(len(x)*train_size)]
test_index = shuffle[int(len(x)*train_size):]
train_index.shape,test_index.shape

# 通過下標數(shù)組到數(shù)據(jù)集中取出數(shù)據(jù)
x_train = x[train_index]
y_train = y[train_index]
x_test = x[test_index]
y_test = y[test_index]

# 訓練數(shù)據(jù)集
plt.scatter(x_train[:,0],x_train[:,1],c=y_train,s=15)
plt.show()

# 測試數(shù)據(jù)集
plt.scatter(x_test[:,0],x_test[:,1],c=y_test,s=15)
plt.show()

3.2、使用scikit-learn庫劃分數(shù)據(jù)集

# sklearn劃分數(shù)據(jù)集
from sklearn.model_selection import train_test_split
# 保證3個樣本數(shù)保持原來分布，添加參數(shù)stratify=y
x_train,x_test,y_train,y_test = train_test_split(x,y,train_size=0.7,random_state=233,stratify=y)
from collections import Counter
Counter(y_test)

4、使用scikit-learn庫對鳶尾花數(shù)據(jù)集進行分類

# 使用鳶尾花數(shù)據(jù)集
import numpy as np
from sklearn import datasets

# 加載數(shù)據(jù)集
iris = datasets.load_iris()
# 獲取樣本數(shù)組，樣本類型數(shù)組
X = iris.data
y = iris.target

# 拆分數(shù)據(jù)集
# 不能直接拆分因為現(xiàn)在的y已經(jīng)是排序好的，需要先亂序數(shù)組
# shuffle_index = np.random.permutation(len(X))
# train_ratio = 0.8
# train_size = int(len(y)*train_ratio)
# train_index = shuffle_index[:train_size]
# test_index = shuffle_index[train_size:]
# X_train = X[train_index]
# Y_train = y[train_index]
# X_test = X[test_index]
# Y_test = y[test_index]

from sklearn.model_selection import train_test_split
# 保證3個樣本數(shù)保持原來分布，添加參數(shù)stratify=y
x_train,x_test,y_train,y_test = train_test_split(X,y,train_size=0.8,random_state=666)


# 預測
from sklearn.neighbors import KNeighborsClassifier
# 初始化設(shè)置k大小
knn_classifier = KNeighborsClassifier(n_neighbors=5
                                     )
# 喂入數(shù)據(jù)集，以及數(shù)據(jù)類型
knn_classifier.fit(x_train,y_train)

# 如果關(guān)心預測結(jié)果可以跳過下面所有score返回得分
knn_classifier.score(x_test,y_test)

y_predict = knn_classifier.predict(x_test)

# 評價預測結(jié)果 將y_predict和真是的predict進行比較就可以了
accuracy = np.sum(y_predict == y_test)/len(y_test)
# accuracy

# sklearn中計算準確度的方法
from sklearn.metrics import accuracy_score
accuracy_score(y_test,y_predict)

5、什么是超參數(shù)

在看機器學習時，經(jīng)常碰到一個叫超參數(shù)的參數(shù)（hyper-parameter）的概念，通常情況下，需要對超參數(shù)進行優(yōu)化，給學習選擇一組最優(yōu)超參數(shù)，以提高學習的性能和效果。

KNN算法中超參數(shù)表示什么，表示K的最近鄰居有幾個，是分類表決還是加權(quán)表決。

5.1、實現(xiàn)尋找超參數(shù)

1、加載鳶尾花數(shù)據(jù)集，并拆分數(shù)據(jù)集

# 超參數(shù)
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
import numpy as np

data = load_iris()
X = data.data
y = data.target
X.shape,y.shape
X_train,X_test,y_train,y_test = train_test_split(X,y,train_size=0.7,random_state=233,stratify=y)
X_train.shape,X_test.shape,y_train.shape,y_test.shape

2、尋找最優(yōu)的一組超參數(shù)

# 遍歷所有超參數(shù)，選取準確率
# uniform權(quán)重一直，越近權(quán)重越高distance
# p等于1折線曼哈頓距離計算方式，p=2歐式距離

best_score = -1
best_n = -1
best_p = -1
best_weight = ''

for i in range(1,20):
    for weight in ['uniform','distance']:
        for p in range(1,7):
            neigh = KNeighborsClassifier(
                n_neighbors=i,
                weights=weight,
                p = p
            )
            neigh.fit(X_train,y_train)
            score = neigh.score(X_test,y_test)
            if score>best_score:
                best_score = score
                best_n = i
                best_p = p
                best_weight = weight
print(best_n,best_p,best_weight,best_score)

5.2、使用scikit-learn庫實現(xiàn)

# 使用skleran超參數(shù)搜索
from  sklearn.model_selection import GridSearchCV
params = {
    'n_neighbors':[n for n in range(1,20)],
    'weights':['uniform','distance'],
    'p':[p for p in range(1,7)]
}

grid = GridSearchCV(
    estimator=KNeighborsClassifier(),# 分類模型器
    param_grid=params,# 參數(shù)
    n_jobs=-1 # 自動設(shè)置并行任務數(shù)量
)
# 傳入數(shù)據(jù)集
grid.fit(X_train,y_train)
# 得到超參數(shù)和得分
grid.best_params_
print(grid.best_score_)

# knn對象對測試數(shù)據(jù)集進行預測
y_predict = grid.best_estimator_.predict(X_test)

# sklearn中計算準確度的方法
from sklearn.metrics import accuracy_score
accuracy_score(y_test,y_predict)

6、特征歸一化

為什么做歸一化？
比如說，現(xiàn)在有一組身高和體重的數(shù)據(jù)集(斤,米)，求歐式距離的時候，可以發(fā)現(xiàn)身高在數(shù)據(jù)集中影響非常小，所以需要將數(shù)據(jù)歸一化。

6.1、實現(xiàn)最大最小值歸一化

最值歸一化適用于，值分布在有限的范圍里面，比如說考試分數(shù)0-100，它受特殊值影響比較大，比如正常體重在0-150斤，如果有一個1000斤，那么這個歸一化的數(shù)據(jù)就會失真。

對上面數(shù)據(jù)做最大最小歸一化操作

# 對數(shù)據(jù)做歸一化
X[:5]
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]))
X[:,2] = (X[:,2] - np.min(X[:,2]))/(np.max(X[:,2])-np.min(X[:,2]))
X[:,3] = (X[:,3] - np.min(X[:,3]))/(np.max(X[:,3])-np.min(X[:,3]))
X[:5]

6.2、實現(xiàn)零均值歸一化

除了數(shù)據(jù)有明顯的邊界值，這種方式是最好的，原始數(shù)據(jù)-均值 / 標準差。

假設(shè)有一組數(shù)據(jù)集：[3, 6, 9, 12, 15]

計算平均值：
平均值 = (3 + 6 + 9 + 12 + 15) / 5 = 9

計算方差：
方差 = ((3-9)^2 + (6-9)^2 + (9-9)^2 + (12-9)^2 + (15-9)^2) / 5 = 18

計算標準差：
標準差 = √方差 = √18 ≈ 4.24

# 零均值歸一化
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
import numpy as np

data = load_iris()
X = data.data
y = data.target

X[:5]

# 求均值
np.mean(X[:,0])
# 標準差
np.std(X[:,0])

X[:,0] = (X[:,0]- np.mean(X[:,0]))/(np.std(X[:,0]))
X[:,1] = (X[:,1]- np.mean(X[:,1]))/(np.std(X[:,1]))
X[:,2] = (X[:,2]- np.mean(X[:,2]))/(np.std(X[:,2]))
X[:,3] = (X[:,3]- np.mean(X[:,3]))/(np.std(X[:,3]))
X[:5]

6.3、scikit-learn歸一化使用

# scikit-learn中歸一化
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
import numpy as np

data = load_iris()
X = data.data
y = data.target

X[:5]

from sklearn.preprocessing import StandardScaler
standard_scaler = StandardScaler()
standard_scaler.fit(X)

# 輸出4列特征的均值
standard_scaler.mean_
# 輸出標4列特標準差
standard_scaler.scale_

# X本身沒有改變，我們需要將結(jié)果重新賦值給X
X = standard_scaler.transform(X)
X[:5]

7、KNN實現(xiàn)回歸任務

預測這個值是多少，就是回歸任務，思想和上面做分類一致，也是近朱者赤，近墨者黑，也是找距離最近k個點，也是民主投票，區(qū)別在于這里是求最近k個點的均值

7.1、實現(xiàn)KNN回歸代碼

# KNN 實現(xiàn)回歸任務
# KNN算法實現(xiàn)
import numpy as np
import matplotlib.pyplot as plt

# 樣本數(shù)據(jù) 
data_X = [
        [1.3,6],
        [3.5,5],
        [4.2,2],
        [5,3.3],
        [2,9],
        [5,7.5],
        [7.2,4],
        [8.1,8],
        [9,2.5],
    ]
# 樣本標記數(shù)組
data_y = [0.1,0.3,0.5,0.7,0.9,1.1,1.3,1.5,1.7]

X_train = np.array(data_X)
y_train = np.array(data_y)
data_new = np.array([4,5])
plt.scatter(X_train[:,0],X_train[:,1],color='black')
plt.scatter(data_new[0],data_new[1],color='b',marker='s')
for i in range(len(y_train)):
    plt.annotate(y_train[i],xy=X_train[i],xytext=(-15,-15),textcoords='offset points')
plt.show()


distance = [np.sqrt(np.sum((i-data_new)**2)) for i in X_train]
sort_index = np.argsort(distance)
k = 5
first_k = [y_train[i] for i in sort_index[:k]]
np.mean(first_k)

7.2、使用scikit-learn庫實現(xiàn)

# 使用scikit-learn實現(xiàn)
from sklearn.neighbors import KNeighborsRegressor
knn_reg = KNeighborsRegressor(n_neighbors=5)
knn_reg.fit(X_train,y_train)

predict_y = knn_reg.predict(data_new.reshape(1,-1))
predict_y

8、根據(jù)Boston數(shù)據(jù)集建立回歸模型

import numpy as np
import matplotlib.pyplot as plt
import sklearn
from sklearn.model_selection import train_test_split
import pandas as pd 

# 加載波士頓房屋數(shù)據(jù)集
data_url = "http://lib.stat.cmu.edu/datasets/boston"
raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
target = raw_df.values[1::2, 2]

# 數(shù)據(jù)準備
X = data
y = target
X.shape,y.shape

# 數(shù)據(jù)集劃分
X_train,X_test,y_train,y_test = train_test_split(X,y,train_size=0.7,random_state=233)

# 建立回歸模型
from sklearn.neighbors import KNeighborsRegressor
knn_reg = KNeighborsRegressor(n_neighbors=5,weights='distance',p=2)
knn_reg.fit(X_train,y_train)
# 計算得分，發(fā)現(xiàn)得分很低，原因是因為沒有做歸一化處理導致
knn_reg.score(X_test,y_test)

做歸一化處理之后輸出得分文章來源地址http://www.zghlxwxcb.cn/news/detail-846283.html

# 歸一化操作
from sklearn.preprocessing import StandardScaler
standard_scaler = StandardScaler()
standard_scaler.fit(X_train)

# 對x train進行歸一化操作
x_train = standard_scaler.transform(X_train)
x_test = standard_scaler.transform(X_test)

knn_reg.fit(x_train,y_train)
knn_reg.score(x_test,y_test)

到了這里，關(guān)于機器學習KNN最鄰近分類算法的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！