這裡只講述sklearn中如何使用KNN演算法。

無監督最近鄰

NearestNeighbors （最近鄰）實現了 unsupervised nearest neighbors learning（無監督的最近鄰學習）。 它為三種不同的最近鄰演算法提供統一的介面：BallTree, KDTree, 還有基於 sklearn.metrics.pairwise 的 brute-force 演算法。演算法的選擇可通過關鍵字 ‘algorithm’ 來控制， 並必須是 [‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’] 其中的一個。當預設值設定為 ‘auto’ 時，演算法會嘗試從訓練資料中確定最佳方法。

# ========無監督查詢最近鄰（常在聚類中使用，例如變色龍聚類演算法）==========

from sklearn.neighbors import NearestNeighbors
import numpy as np # 快速操作結構陣列的工具

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])  # 樣本資料
test_x = np.array([[-3.2, -2.1], [-2.6, -1.3], [1.4, 1.0], [3.1, 2.6], [2.5, 1.0], [-1.2, -1.3]]
 
)  # 設定測試資料
# test_x=X  # 測試資料等於樣本資料。這樣就相當於在樣本資料內部查詢每個樣本的鄰節點了。
nbrs = NearestNeighbors(n_neighbors=2, algorithm='ball_tree').fit(X)  # 為X生成knn模型
distances, indices = nbrs.kneighbors(test_x)  # 為test_x中的資料尋找模型中的鄰節點
print('鄰節點：',indices)
print('鄰節點距離：',distances)

# ==============================使用kd樹和Ball樹實現無監督查詢最近鄰========================

from sklearn.neighbors import KDTree,BallTree
import numpy as np # 快速操作結構陣列的工具

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
 
)
# test_x = np.array([[-3.2, -2.1], [-2.6, -1.3], [1.4, 1.0], [3.1, 2.6], [2.5, 1.0], [-1.2, -1.3]])  # 設定測試資料
test_x=X  # 測試資料等於樣本資料。這樣就相當於在樣本資料內部查詢每個樣本的鄰節點了。
kdt = KDTree(X, leaf_size=30, metric='euclidean')
distances,indices = kdt.query(test_x, k=2, return_distance=True)
print('鄰節點：',indices)
print('鄰節點距離：',distances)

最近鄰分類

scikit-learn 實現了兩種不同的最近鄰分類器：KNeighborsClassifier 基於每個查詢點的 k 個最近鄰實現，其中 k 是使用者指定的整數值。RadiusNeighborsClassifier 基於每個查詢點的固定半徑 r 內的鄰居數量實現， 其中 r 是使用者指定的浮點數值。

k -鄰居分類是 KNeighborsClassifier 下的兩種技術中比較常用的一種。k 值的最佳選擇是高度依賴資料的：通常較大的 k 是會抑制噪聲的影響，但是使得分類界限不明顯。

如果資料是不均勻取樣的，那麼 RadiusNeighborsClassifier 中的基於半徑的近鄰分類可能是更好的選擇。

RadiusNeighborsClassifier 中使用者指定一個固定半徑 r，使得稀疏鄰居中的點使用較少的最近鄰來分類。

對於高維引數空間，這個方法會由於所謂的 “維度災難” 而變得不那麼有效。

在兩種k最近鄰分類中，基本的最近鄰分類使用統一的權重：分配給查詢點的值是從最近鄰的簡單多數投票中計算出來的。 在某些環境下，最好對鄰居進行加權，使得更近鄰更有利於擬合。可以通過 weights 關鍵字來實現。

預設值 weights = ‘uniform’ 為每個近鄰分配統一的權重。而 weights = ‘distance’ 分配權重與查詢點的距離成反比。 或者，使用者可以自定義一個距離函式用來計算權重。

# ==========k最近鄰分類=========
import numpy as np # 快速操作結構陣列的工具
from sklearn.neighbors import KNeighborsClassifier,KDTree   # 匯入knn分類器


# 資料集。4種屬性，3種類別
data=[
    [ 5.1,  3.5,  1.4,  0.2, 0],
    [ 4.9,  3.0,  1.4,  0.2, 0],
    [ 4.7,  3.2,  1.3,  0.2, 0],
    [ 4.6,  3.1,  1.5,  0.2, 0],
    [ 5.0,  3.6,  1.4,  0.2, 0],
    [ 7.0,  3.2,  4.7,  1.4, 1],
    [ 6.4,  3.2,  4.5,  1.5, 1],
    [ 6.9,  3.1,  4.9,  1.5, 1],
    [ 5.5,  2.3,  4.0,  1.3, 1],
    [ 6.5,  2.8,  4.6,  1.5, 1],
    [ 6.3,  3.3,  6.0,  2.5, 2],
    [ 5.8,  2.7,  5.1,  1.9, 2],
    [ 7.1,  3.0,  5.9,  2.1, 2],
    [ 6.3,  2.9,  5.6,  1.8, 2],
    [ 6.5,  3.0,  5.8,  2.2, 2],
]

# 構造資料集
dataMat = np.array(data)
X = dataMat[:,0:4]
y = dataMat[:,4]

knn = KNeighborsClassifier(n_neighbors=2,weights='distance')    # 初始化一個knn模型，設定k=2。weights='distance'樣本權重等於距離的倒數。'uniform'為統一權重
knn.fit(X, y)                                          #根據樣本集、結果集，對knn進行建模
result = knn.predict([[3, 2, 2, 5]])                   #使用knn對新物件進行預測
print(result)

最近鄰迴歸

最近鄰迴歸是用在資料標籤為連續變數，而不是離散變數的情況下。分配給查詢點的標籤是由它的最近鄰標籤的均值計算而來的。

scikit-learn 實現了兩種不同的最近鄰迴歸：KNeighborsRegressor 基於每個查詢點的 k 個最近鄰實現， 其中 k 是使用者指定的整數值。RadiusNeighborsRegressor 基於每個查詢點的固定半徑 r 內的鄰點數量實現， 其中 r 是使用者指定的浮點數值。

基本的最近鄰迴歸使用統一的權重：即，本地鄰域內的每個鄰點對查詢點的分類貢獻一致。 在某些環境下，對鄰點加權可能是有利的，使得附近點對於迴歸所作出的貢獻多於遠處點。 這可以通過 weights 關鍵字來實現。預設值 weights = ‘uniform’ 為所有點分配同等權重。 而 weights = ‘distance’ 分配的權重與查詢點距離呈反比。 或者，使用者可以自定義一個距離函式用來計算權重。

# ==============================k最近鄰迴歸========================

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

np.random.seed(0)
X = np.sort(5 * np.random.rand(40, 1), axis=0)
T = np.linspace(0, 5, 500)[:, np.newaxis]
y = np.sin(X).ravel()

# 為輸出值新增噪聲
y[::5] += 1 * (0.5 - np.random.rand(8))

# 訓練迴歸模型
n_neighbors = 5

for i, weights in enumerate(['uniform', 'distance']):
    knn = neighbors.KNeighborsRegressor(n_neighbors, weights=weights)
    y_ = knn.fit(X, y).predict(T)

    plt.subplot(2, 1, i + 1)
    plt.scatter(X, y, c='k', label='data')
    plt.plot(T, y_, c='g', label='prediction')
    plt.axis('tight')
    plt.legend()
    plt.title("KNeighborsRegressor (k = %i, weights = '%s')" % (n_neighbors,weights))

plt.show()