K近邻代码

• 电影分类
• 手写数字分类
• sklearn库KNN对莺尾花分类
• sklearn库KNN回归用法
• sklearn的K近邻模块API介绍

电影分类

import numpy as np
import operator    #运算符模块，用来排序
import matplotlib.pyplot as plt

def create_data():
    data = np.array([[1,1.1],
                     [1.0,1.0],
                     [0,0],
                     [0.1,0.2]])
    label = ['A','A','B','B']

    return data,label

def plot(data):

    A_x_data=data[0:2,0]
    A_y_data=data[0:2,1]
    B_x_data = data[2:,0]
    B_y_data = data[2:,1]
    plt.plot(A_x_data,A_y_data,'ro',label='A')
    plt.plot(B_x_data,B_y_data,'g*',label='B')
    plt.legend()
    plt.show()

def classify(inX, data, labels, k): # 分类0
    """
    :param inX:  用于分类的输人向量是inX，就是未知种类
    :param data: 数据的特征
    :param labels: 标签
    :param k: k的取值
    :return: 
    """
    data_size = data.shape[0]

    # tile重复inX，变成(data_size,1)的形状，inX是一个整体
    diff_mat = np.tile(inX,(data_size,1))-data

    # 计算欧式距离
    sqDiffmat= diff_mat**2
    sqdistances=sqDiffmat.sum(axis=1)
    distances=sqdistances**0.5

    # 排序，数据按照从小到大排序，argsort()方法返回来的是在原来数据中的对应索引
    sorted_distance_indicies = distances.argsort()# 排序

    class_count={}
    for i in range(k):
        vote_label = labels[sorted_distance_indicies[i]]
        class_count[vote_label] = class_count.get(vote_label,0)+1
    sorted_class_count = sorted(class_count.items(),
                                key=operator.itemgetter(1),
                                reverse=True)
    print(sorted_class_count)
    return sorted_class_count[0][0]

data,label=create_data()
classify([0,0],data,label,3)

手写数字分类

import numpy as np
import operator
import time
import random
import matplotlib.pyplot as plt
import matplotlib.image as img
import os

"""
只能识别数字0-9，图像的大小 32*32像素的黑白图像
数据扁平化

"""

filepath=r'.\digits' # 数字数据存放的文件夹，每一个数字是一个txt文件,大小32x32

def show_img(vector):
    plt.imshow(vector.reshape((32,32)))
    plt.show()


def classify(inX, data, labels, k): # 分类0
    """
    :param inX:  用于分类的输人向量是inX，就是未知种类
    :param data: 数据的特征
    :param labels: 标签
    :param k: k的取值
    :return: 
    """
    data_size = data.shape[0]

    # tile重复inX，变成(data_size,1)的形状，inX是一个整体
    diff_mat = np.tile(inX,(data_size,1))-data

    # 计算欧式距离
    sqDiffmat= diff_mat**2
    sqdistances=sqDiffmat.sum(axis=1)
    distances=sqdistances**0.5

    # 排序，数据按照从小到大排序，argsort()方法返回来的是在原来数据中的对应索引
    sorted_distance_indicies = distances.argsort()# 排序


    class_count={}
    for i in range(k):
        vote_label = labels[sorted_distance_indicies[i]]
        class_count[vote_label] = class_count.get(vote_label,0)+1
    sorted_class_count = sorted(class_count.items(),
                                key=operator.itemgetter(1),
                                reverse=True)
  #  print(sorted_class_count)
    return sorted_class_count[0][0]


def img_to_vector(filename):
    return_vec = np.zeros((1,1024))

    file = open(filename)
    for i in range(32):
        line_data = file.readline()
        for j in range(32):
            return_vec[0,32*i+j]=int(line_data[j])
    return return_vec


def hand_write_classify(filepath):
    #训练
    hand_write_labels=[]
    filepath_train=filepath+r'\\' + 'trainingDigits'
    train_file_list = os.listdir(filepath_train)
    # print(train_file_list)
    number_total=len(train_file_list)
    train_matrix =np.zeros((number_total,1024))
    for i in range(number_total):
        file_name = train_file_list[i]
        file_str = file_name.split('.')[0]
        class_number = int(file_str.split('_')[0])

        hand_write_labels.append(class_number)

        train_matrix[i,:]=img_to_vector(filepath_train+'\\'+file_name)

    filepath_test = filepath+'\\'+'testDigits'
    test_file_list=os.listdir(filepath_test)
    error_count = 0
    number_test = len(test_file_list)
    for i in range(number_test):
        file_name = test_file_list[i]
        file_str = file_name.split('.')[0]
        class_number = int(file_str.split('_')[0])

        vector_test = img_to_vector(filepath_test + '\\' + file_name)

        classify_result=classify(vector_test,train_matrix,hand_write_labels,5)
        print('knn result is>>：%s,real result is>>：%s'%(classify_result,class_number))

        # 统计错误率
        if classify_result != class_number:
            error_count +=1
            show_img(vector_test)
        print('错误率：',error_count/(number_test))

if __name__ == '__main__':
    hand_write_classify(filepath)

sklearn库KNN对莺尾花分类

from sklearn import neighbors
from sklearn import datasets

# 初始化
knn = neighbors.KNeighborsClassifier()

# 返回一个数据库，sklearn里面的数据  使用莺尾花数据
iris = datasets.load_iris()
print('iris: ',iris)       # 数据是一个字典格式
print(iris.data)
print(iris.target)         # 标签
print(iris.target_names)   # 标签名

# 在python算法上大多有一个fit，指建立一个模型
knn.fit(iris.data,iris.target)

# 预测
predicted_label = knn.predict([[0.1,0.2,0.3,0.4]])
print('predicted_label: ',predicted_label)

KNN回归

# 和分类API用法一样
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
neigh = KNeighborsRegressor(n_neighbors=2)
neigh.fit(X, y)

print(neigh.predict([[1.5]]))

sklearn中KNN算法API介绍

# API介绍
from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier()

"""
类中参数介绍：
	n_neighbors=5, 
		默认为5，就是k-NN的k的值，选取最近的k个点

	weights='uniform', 
    	默认是uniform，参数可以是uniform、distance，也可以是用户自己定义的函数。
    	uniform是均等的权重，就说所有的邻近点的权重都是相等的。
    	distance是不均等的重，距离近的点比距离远的点的影响大。
	    用户自定义的函数，接收距离的数组，返回一组维数相同的权重

	algorithm='auto',
    	快速k近邻搜索算法，默认参数为auto，可以理解为算法自己决定合适的搜索算法。
    	除此之外，用户也可以自己指定搜索算法ball_tree、kd_tree、brute方法进行搜索，
    	brute是蛮力搜索，也就是线性扫描，当训练集很大时，计算非常耗时。
    	kd_tree，构造kd树存储数据以便对其进行快速检索的树形数据结构，kd树也就是数据结		  构中的二叉树。以中值切分构造的树，每个结点是一个超矩形，在维数小于20时效率高。
    	ball tree是为了克服kd树高纬失效而发明的，其构造过程是以质心C和半径r分割样本空间，每个节点是一个超球体。

	leaf_size=30,
    	默认是30，这个是构造的kd树和ball树的大小。
    	这个值的设置会影响树构建的速度和搜索速度，同样也影响着存储树所需的内存大小。需要根据问题的性质选择最优的大小
    
	p=2,
    	距离度量公式。在KNN基础知识里面介绍了，我们使用欧氏距离公式进行距离度量。
    	除此之外，还有其他的度量方法：
    	例如曼哈顿距离。这个参数默认为2，也就是默认使用欧式距离公式进行距离度量。
    	也可以设置为1，使用曼哈顿距离公式进行距离度量。
    
	metric='minkowski',
    	用于距离度量，默认度量是minkowski，也就是p=2的欧氏距离(欧几里德度量
    	
    metric_params=None, 
    	距离公式的其他关键参数，这个可以不管，使用默认的None即可
    
	n_jobs=None,
    	并行处理设置。默认为1，临近点搜索并行工作数。如果为-1，那么CPU的所有cores都用于并行工作**kwargs)


方法介绍：
	fit()：训练模型
    predict(x_test,y_test)：预测模型
    score(): 返回模型在测试集上的准确率
    predict_proba(x_test)：返回test每种标记的概率
    kneighbors([x_tets,n_neighbors,return_distace]) :
    	返回样本点的k邻近点。如果return_distance=True，同时还返回到这些近邻点的距离    
    kneighbors_graph([X,n_neighbors,mode]) : 返回样本点的连接图


"""