INT104-lab12 [KNN Algorithm][lambda表达式]

借鉴了老师的代码，但是没有封装

效果还是挺好的 average accuracy>90%

from random import shuffle
import numpy as np
from collections import Counter


def read(path: str) -> tuple:
    f = open(path, "r")
    text = f.readlines()
    f.close()
    X, y = [], []
    class_map, class_idx = {}, 0
    for row in text:
        row = row.strip()
        if len(row) == 0:
            continue
        items = row.split(",")
        X.append([float(item) for item in items[:-1]])
        if items[-1] not in class_map:
            class_idx += 1
            class_map[items[-1]] = class_idx
        y.append(class_map[items[-1]])
    return X, y, len(X[0]), len(y), class_map, class_idx


def randomIdArray(n: int) -> list:
    array = [i for i in range(n)]
    shuffle(array)
    return array


def splitData(X, y, n, m, rate: float) -> tuple:
    if not (1 < rate * n and rate <= 1.0):
        print("Please input rate (0,1] and ensure train size is not empty!")
        return 0, 0, 0, 0
    train_size = int(rate * n)
    train_X, train_y = [], []
    id = randomIdArray(n)
    for _ in range(train_size):
        i = id[_]
        train_X.append(X[i])
        train_y.append(y[i])
    test_X, test_y = [], []
    for _ in range(train_size, n, 1):
        i = id[_]
        test_X.append(X[i])
        test_y.append(y[i])
    test_size = n - train_size
    return train_X, train_y, train_size, test_X, test_y, test_size


def KNN(K: int, X, y, n, class_size):
    predict_y = []
    for x in X:
        distances = []
        for i in range(n):
            distance = np.linalg.norm(np.array(X[i]) - np.array(x))
            distances.append([distance, y[i]])
        distances.sort(key=lambda x: x[0])

        dis = [distances[i][1] for i in range(K)]
        dic = Counter(dis)
        keyMaxValue = -1
        for key in dic.keys():
            if keyMaxValue == -1:
                keyMaxValue = key
            elif dic[key] > dic[keyMaxValue]:
                keyMaxValue = key
        predict_y.append(keyMaxValue)
    return predict_y


def KNN_training(train_X, train_y, train_size, min_K, learing_rate):
    accuracys = []
    for K in range(min_K, int(train_size * learing_rate), 2):
        predict_train_y = KNN(K, train_X, train_y, train_size, class_sz)
        accuracy = (len([i for i in range(train_size) if train_y[i] == predict_train_y[i]]) / train_size)
        accuracys.append([-accuracy, K])
        print("For train set K =", K, "accuracy =", accuracy)
    accuracys.sort(key=lambda x: x[0])
    K = accuracys[0][1]
    print("Training done K =", K)
    return K


def predict(K, test_X, test_y, test_size, class_sz):
    predict_test_y = KNN(K, test_X, test_y, test_size, class_sz)
    accuracy = (len([i for i in range(test_size) if test_y[i] == predict_test_y[i]]) / test_size)
    print("For test set K =", K, "accuracy =", accuracy)


if __name__ == '__main__':
    X, y, m, n, class_map, class_sz = read("iris.data")
    train_X, train_y, train_size, test_X, test_y, test_size = splitData(X, y, n, m, 0.75)
    K = KNN_training(train_X, train_y, train_size, 5, 0.15)
    predict(K, test_X, test_y, test_size, class_sz)