监督学习、分类算法、KNN最近邻算法

分类算法

什么是分类

分类的一般方法

KNN最近邻算法

原理

算法流程

1. 准备数据，对数据进行预处理
2. 选用合适的数据结构存储训练数据和测试元组
3. 设定参数，如k
4. 维护一个大小为k的的按距离由大到小的优先级队列，用于存储最近邻训练元组。随机从训练元组中选取k个元组作为初始的最近邻元组，分别计算测试元组到这k个元组的距离，将训练元组标号和距离存入优先级队列
5. 遍历训练元组集，计算当前训练元组与测试元组的距离，将所得距离L 与优先级队列中的最大距离Lmax
6. 进行比较。若L>=Lmax，则舍弃该元组，遍历下一个元组。若L < Lmax，删除优先级队列中最大距离的元组，将当前训练元组存入优先级队列。
7. 遍历完毕，计算优先级队列中k 个元组的多数类，并将其作为测试元组的类别。
8. 测试元组集测试完毕后计算误差率，继续设定不同的k值重新进行训练，最后取误差率最小的k 值。

KNN算法应用说明

KNN算法归纳

KNN算法存在的缺陷


手写数字识别代码实现

import os
import numpy as np
import  pandas as pd
import matplotlib.pyplot as plt

#强制打印数组
# np.set_printoptions(threshold=10000000000000000)

#数据转换
def data_trans(path):
    #获取文件夹中文件名，返回文件名数组
    dir_list = os.listdir(path)
    #创建len(dir_list)*1025的零数组，行为目标集(训练集，测试集)个数，列为1024个属性+1个tag标签=1025
    dir_array = np.zeros((len(dir_list),1025),dtype=np.int)

    #遍历每个样本，目的-->还原数据-->32*32的数组
    for file_index,file_name in enumerate(dir_list):
        #读取样本中的内容，将其类型赋为str
        dir_one = np.loadtxt(path+file_name,dtype=np.str)
        #获取当前样本的标签
        tag = int(file_name.split("_")[0])

        #创建32*32的零数组，还原样本样式，并将其类型赋为int
        dir_one_32 = np.zeros((32,32),dtype=np.int)
        #读每个样本中的每个元素数据
        for index,i in enumerate(dir_one):
            #map() 会根据提供的函数对指定序列做映射。格式:map(function, iterable, ...)
            #将样本中每个元素转换为int类型后将其转换为列表类型，最后将其转换为数组类型
            dir_one_32_1 = np.array(list(map(int,i)))
            #将转换后的样本中的每个元素放入32*32的零数组的对应位置上
            dir_one_32[index] = dir_one_32_1
        #展平32*32的数组
        dir_one_32_ravel = dir_one_32.ravel()
        #将展平后的32*32的数组放入总的len(dir_list)*1025的零数组中
        dir_array[file_index, :-1] = dir_one_32_ravel
        #将对应样本的标签放入len(dir_list)*1025的零数组的最后一列位置上
        dir_array[file_index,-1] = tag

    #获取要保存的文件名称
    f_name = path.split("/")[0]
    #保存文件为csv格式
    np.savetxt('{}.csv'.format(f_name),dir_array,fmt="%d")
    #返回最终的len(dir_list)*1025的数组
    return dir_array


#主函数
if __name__ == '__main__':
    #文件夹路径
    #训练集
    path_train = "trainingDigits/"
    #测试集
    path_test = "testDigits/"

    #训练集数据
    train_data = data_trans(path_train)
    #测试集数据
    test_data = data_trans(path_test)

    # 精度列表
    precision_list = []
    #KNN算法,k不能为0，否则会报index out of bounds 索引越界错误
    #更新k值
    for k in range(1,20):
        #存放预测值与真实值不相同时对应数据的个数
        error_list = np.zeros(10,dtype=np.int)
        # 存放预测值与真实值相同时对应数据的个数
        right_list = np.zeros(10, dtype=np.int)

        #存放预测值与真实值相同时的总个数
        right_num = 0
        #存放预测值与真实值不相同时的总个数
        error_num = 0

        #遍历测试集数据
        for test_one in test_data:
            #计算相似值
            d = np.sum((train_data[:,:-1]-test_one[:-1])**2,axis=1)
            #获取前k个相似值的索引
            sorted_index = np.argsort(d)[:k]
            #预测值众数 (mode():众数)
            predict_label = pd.Series(train_data[:,-1][sorted_index],dtype=np.int).mode()[0]
            #真实值
            real_label = test_one[-1]
            # print(real_label)
            # print(predict_label)

            #当预测值与真实值相等时，预测正确个数自增，真实值对应的位置上的正确个数自增
            if predict_label==real_label:
                right_num += 1
                right_list[test_one[-1]]+=1
            #当预测值与真实值不相等时，预测错误个数自增，真实值对应的位置上的错误个数自增
            else:
                error_list[test_one[-1]]+=1
                error_num +=1

        #计算预测精度
        precision = right_num/test_data.shape[0]
        #将预测精度放入精度列表
        precision_list.append(precision)
        print("k:", k, "精度：", precision)
        print(precision_list)


        #计算0-9之间的10个数的错误率
        for i in range(10):
            #当前数字的总个数
            right_and_error = error_list[i]+right_list[i]
            #错误率
            error_rate = error_list[i]/right_and_error
            print("k为{}时数字{}的错误率为{}".format(k,i,error_rate))
        print("======================================")

    plt.figure(figsize=(8, 7))
    plt.plot(range(1,20), precision_list, marker="*")
    plt.show()

    # print(precision_list)
    # print(error_list)
    # print(right_list)
    # print(right_num)
    # print(error_num)