INT104-lab13[Parzen Window Method][此方法无数据集划分]

利用高斯函数，使得较近的数据点决策作用更大！

代码也比较简洁！Accuracy=0.9466666666666667 

注意一下：

其实h=1的选取相当于你的先验知识；或者说多尝试几次

让电脑自己试错，有时候其实方法直接的界定其实没有那么严格啦

 

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
    class_anti_map = {}
    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_map[items[-1]] = class_idx
            class_anti_map[class_idx] = items[-1]
            class_idx += 1
        y.append(class_map[items[-1]])
    return X, y, len(y), len(X[0]), class_map, class_idx, class_anti_map


def parzenWindowAlgorithm(X, y, class_map, class_anti_map, class_size, n, m, hyperparameter):
    dic = Counter(y)
    P0 = [(dic[class_map[class_anti_map[i]]] / n) for i in range(class_size)]
    P1 = []
    hd = np.power(hyperparameter, m)
    for x in X:
        p = [0 for _ in range(class_size)]
        for i in range(n):
            dis = np.linalg.norm((np.array(x) - np.array(X[i]) / hyperparameter))
            fai = gaussianKernel(dis)
            p[y[i]] += fai / hd
        P1.append(p)
    predict_y = []
    for i in range(n):
        p = []
        for k in range(class_size):
            p.append([-P0[k] * P1[i][k], k])
        p.sort(key=lambda x: x[0])
        predict_y.append(p[0][1])
    return predict_y


def gaussianKernel(u):
    return np.exp(-u * u / 2) / np.sqrt(2 * np.pi)


if __name__ == '__main__':
    X, y, n, m, class_map, class_size, class_anti_map = read("iris.data")

    predict_y = parzenWindowAlgorithm(X, y, class_map, class_anti_map, class_size, n, m, 1)

    for i in range(n):
        print("No.", (i + 1), X[i], "y =", y[i], "predict_y =", predict_y[i], (y[i] == predict_y[i]))
    print("Accuracy =", (len([i for i in range(n) if y[i] == predict_y[i]]) / n))