K-近邻算法（KNN）识别手写数字_手写识别knn邻近算法

• k-近邻算法概述
• 算法
• KNN中的几个常见写法
  • numpy.ndarray
  • numpy.ndarray.shape
  • numpy.tile(A,reps)
• 实例-手写数字识别系统

k-近邻算法概述

KNN算法采用测量不同特征值之间的距离方法进行分类，输出一个分类族群。

主要工作原理：
存在一个训练样本集，并且每个样本集中每个数据都存在标签，即数据和对应所属分类的对应关系。
输入没有标签的新数据，将新数据的每个特征值与样本集中每一数据的特征比较，算法提取样本集最相似（最近邻）的分类标签，
一般是前 K 个 <= 20 ，然后选取这 K 个中出现标签最多的一个标签，作为新数据的分类。

• 优点： 精度高，对异常值不敏感，无数据输入假定。
• 缺点： 计算复杂度高，空间复杂度高。
• 适用数据范围：数值型和标称型。

一般步骤：

• 准备数据 从文本中解析数据等
• 分析数据 Matplotlib 创建散点图
• 准备数据 归一化数据，即“统一度量”
• 测试算法 作为完成程序验证分类器
• 使用算法

算法

伪代码：

对未知类别属性的数据集中的每个点依次执行以下操作:
(1) 计算已知类别数据集中的点与当前点之间的距离;
(2) 按照距离递增次序排序;
(3) 选取与当前点距离最小的k个点;
(4) 确定前k个点所在类别的出现频率;
(5) 返回前k个点出现频率最高的类别作为当前点的预测分类
1
2
3
4
5
6

KNN.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-


from numpy import *
import operator

# 样本集及分类
group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])
labels = ['A', 'A', 'B', 'B']


def classify0(inX, data_set, labels, k):
    # 计算距离
    data_set_size = data_set.shape[0]
    diff_mat = tile(inX, (data_set_size, 1)) - data_set
    sq_diff_mat = diff_mat ** 2
    sq_distances = sq_diff_mat.sum(axis=1)
    distances = sq_distances ** 0.5
    '''
    argsort 对值（距离）进行排序，
    选取距离最小的k个点
    '''
    sorted_dist_indicies = distances.argsort()
    class_count = {}
    for i in range(k):
        vote_ilabel = labels[sorted_dist_indicies[i]]
        class_count[vote_ilabel] = class_count.get(vote_ilabel, 0) + 1
    sorted_class_count = sorted(class_count.items(), key=operator.itemgetter(1), reverse=True)
    return sorted_class_count[0][0]


if __name__ == '__main__':
    print(classify0([0, 0], group, labels, 3))

# output is B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
'
运行
运行

KNN中的几个常见写法

numpy.ndarray

类型
numpy中只有 ndarray 的类型，并没有 array，用 IDLE 可以看到用array来区分list。
创建ndarray时候调用的array()实际上是构造函数，可以用isinstance()函数查看。

numpy.ndarray.shape

属性
return Tuple of array.dimensions
返回这个array的维度。

另外 numpy.rshape
ndarray.rshape
同理

numpy.tile(A,reps)

construct an array by repeating A the number of times given by reps

• A： array_like

• reps: array_like
  the number of repetitons of A along each axis
  通常用来构造出符合大小的矩阵。

• Returns: ndarray

each axis 实际意义就是按照 axis=0,axis=1…对应

把array按照[]拆开，最外面就是axis=0
相关讨论：
https://stackoverflow.com/questions/17079279/how-is-axis-indexed-in-numpys-array

实例-手写数字识别系统

识别的样本集合：

目录结构：

• testDigits

• trainingDigits

• KNN.py
• kNN手写数字识别.py

只多了将图像转换为测试向量这一步骤。将 32*32 图像=> 1*1024 vector。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from KNN import *
import os


# return 1*1024  a vector
def img2vector(filename):
    return_vect = zeros((1, 1024))
    fr = open(filename)
    # 32*32 img => 1*1024
    for i in range(32):
        line_str = fr.readline()
        for j in range(32):
            return_vect[0, i + j * 32] = int(line_str[j])
    return return_vect


def handwriting_class_test():
    hw_labels = []
    training_file_list = os.listdir('trainingDigits')
    m = len(training_file_list)
    training_mat = zeros((m, 1024))
    for i in range(m):
        # get class_num_str and labels
        file_name_str = training_file_list[i]
        file_str = file_name_str.split('.')[0]
        class_num_str = int(file_str.split('_')[0])
        hw_labels.append(class_num_str)
        training_mat[i, :] = img2vector('trainingDigits/{}'.format(file_name_str))
    test_file_list = os.listdir('testDigits')
		# testDigits
    error_count = 0.0
    m_test = len(test_file_list)
    for i in range(m_test):
        # get class_num_str
        file_name_str = test_file_list[i]
        file_str = file_name_str.split('.')[0]
        class_num_str = int(file_str.split('_')[0])
        vector_under_test = img2vector('testDigits/{}'.format(file_name_str))
        # classify0(inX, group, labels, K)
        classifier_result = classify0(vector_under_test, training_mat, hw_labels, 3)
        print('the classifier result is {},and the real num is {}.'.format(classifier_result, class_num_str))
        # if not match ,error_count += 1
        if (classifier_result != class_num_str): error_count += 1
    print('error rate is {}.'.format(error_count / float(m_test)))


if __name__ == '__main__':
    handwriting_class_test()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

输出：