Python底層實現KNN

藉助python自帶的pandas庫匯入資料，很簡單。用的資料是下載到本地的紅酒集。

程式碼如下（示例）：

import pandas as pd
def read_xlsx(csv_path):
    data = pd.read_csv(csv_path)
    print(data)
    return data

KNN演算法中將用到距離，因此歸一化是一個重要步驟，可以消除資料的量綱。我用了歸一化，消除量綱也可以用標準化，但是作為新手，我覺得歸一化比較簡單。

其中最大最小值的計算用到了python中的numpy庫，pandas匯入的資料是DateFrame形式的，np.array()用來將DateFrame形式轉化為可以用numpy計算的ndarray形式。

程式碼如下（示例）：

import numpy as np
def MinMaxScaler(data):
    col = data.shape[1]
    for i in range(0, col-1):
        arr = data.iloc[:, i]
        arr = np.array(arr) #將DataFrame形式轉化為ndarray形式，方便後續用numpy計算
        min = np.min(arr)
        max = np.max(arr)
        arr = (arr-min)/(max-min)
        data.iloc[:, i] = arr
    return data

先將資料值和標籤值分別用x和y劃分開，設定隨機數種子random_state，若不設定，則每次執行的結果會不相同。test_size表示測試集比例。

def train_test_split(data, test_size=0.2, random_state=None):
    col = data.shape[1]
    x = data.iloc[:, 0:col-1]
    y = data.iloc[:, -1]
    x = np.array(x)
    y = np.array(y)
    # 設定隨機種子，當隨機種子非空時，將鎖定隨機數
    if random_state:
        np.random.seed(random_state)
        # 將樣本集的索引值進行隨機打亂
        # permutation隨機生成0-len(data)隨機序列
    shuffle_indexs = np.random.permutation(len(x))
    # 提取位於樣本集中20%的那個索引值
    test_size = int(len(x) * test_size)
    # 將隨機打亂的20%的索引值賦值給測試索引
    test_indexs = shuffle_indexs[:test_size]
    # 將隨機打亂的80%的索引值賦值給訓練索引
    train_indexs = shuffle_indexs[test_size:]
    # 根據索引提取訓練集和測試集
    x_train = x[train_indexs]
    y_train = y[train_indexs]
    x_test = x[test_indexs]
    y_test = y[test_indexs]
    # 將切分好的資料集返回出去
    # print(y_train)
    return x_train, x_test, y_train, y_test

此處用到歐氏距離，pow()函式用來計算冪次方。length指屬性值數量，在計算最近鄰時用到。

def CountDistance(train,test,length):
    distance = 0
    for x in range(length):
        distance += pow(test[x] - train[x], 2)**0.5
    return distance

計算測試集中的一條資料和訓練集中的每一條資料的距離，選擇距離最近的k個，以少數服從多數原則得出標籤值。其中argsort返回的是數值從小到大的索引值，為了找到對應的標籤值。

tip:用numpy計算眾數的方法

import numpy as np
#bincount（）：統計非負整數的個數，不能統計浮點數
counts = np.bincount(nums)
#返回眾數
np.argmax(counts)

少數服從多數原則，計算眾數，返回標籤值。

def getNeighbor(x_train,test,y_train,k):
    distance = []
    #測試集的維度
    length = x_train.shape[1]
    #測試集合所有訓練集的距離
    for x in range(x_train.shape[0]):
        dist = CountDistance(test, x_train[x], length)
        distance.append(dist)
    distance = np.array(distance)
    #排序
    distanceSort = distance.argsort()
    # distance.sort(key= operator.itemgetter(1))
    # print(len(distance))
    # print(distanceSort[0])
    neighbors =[]
    for x in range(k):
        labels = y_train[distanceSort[x]]
        neighbors.append(labels)
        # print(labels)
    counts = np.bincount(neighbors)
    label = np.argmax(counts)
    # print(label)
    return label

呼叫函式時：

getNeighbor(x_train,x_test[0],y_train,3)

用以上KNN演算法預測測試集中每一條資料的標籤值，存入result陣列，將預測結果與真實值比較，計算預測正確的個數與總體個數的比值，即為準確率。

def getAccuracy(x_test,x_train,y_train,y_test):
    result = []
    k = 3
    # arr_label = getNeighbor(x_train, x_test[0], y_train, k)
    for x in range(len(x_test)):
        arr_label = getNeighbor(x_train, x_test[x], y_train, k)
        result.append(arr_label)
    correct = 0
    for x in range(len(y_test)):
        if result[x] == y_test[x]:
           correct += 1
    # print(correct)
    accuracy = (correct / float(len(y_test))) * 100.0
    print("Accuracy:", accuracy, "%")
    return accuracy

KNN算是機器學習中最簡單的演算法，實現起來相對簡單，到此這篇關於Python機器學習之底層實現KNN的文章就介紹到這了。