Machine Learning-kNN

准备工作

由于之前 Windows 本上的 Python 版本混乱，所以第一步工作是重新安装 Python 并且配置环境。

快速配置 Python 环境的步骤：

1. 下载 Anaconda ，并且安装。

   安装时可以选择把 Anaconda 添加到系统环境变量中，不然之后得自己手动添加

2. 安装 Pycharm ，并且安装。

3. 命令行中测试 conda 命令和 python 命令

   如果报错没有此命令，可能还需要手动添加其他环境变量，一般来说添加三个是完整的：

4. 最后创建自己的项目目录

初探 k 近邻算法 kNN

k nearest neighbours

原理：

来自维基百科的图：

简单地说就是：找到离目标 data 最近的 k 个已分类的 ( classified ) 数据，根据这 k 个数据来给这个 data 分类。

上图中：

k = 1 时， 绿色的 ⚪ 就被分类到 🔺 里面了

k = 5 时， 绿色的 ⚪ 就被分类到 ⬜️ 里面了

主要内容有两点：

1. distance 的计算：怎样才算近邻

2. k 的选择：究竟选几个近邻

用 Python 导入数据

from numpy import *
import operator

def createDataSet():
    group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])
    labels = ['A', 'A', 'B', 'B']
    return group, labels

使用 group, labels = createDataSet() 我们就能获得一个 dataSet 了

用 Python 初步实现 kNN

# inX, the data to be classified.
# dataSet, an array of two-dimension coordinate.
# labels, classes that data in the above array differently belong to.
# k, quantity of the neighbours.
def classify0(inX, dataSet, labels, k):
    # dataSet is an array and it has the 'shape' attribute.
    # shape = {tuple}(rows, columns)
    dataSetSize = dataSet.shape[0]
    # tile() makes a new matrix.
    # diffMat, the subtract of target matrix and each member of the dataSet
    diffMat = tile(inX, (dataSetSize, 1)) - dataSet
    sqDiffMat = diffMat ** 2
    sqDistances = sqDiffMat.sum(axis=1)
    distances = sqDistances ** 0.5
    sortedDistIndicies = distances.argsort()
    classCount = {}
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1
    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

说几个不容易理解的地方（主要是个人 python 基础薄弱）：

关于 NumPy 的 array

直接上图，实际上 NumPy 中的 array 是 ndarray ( N-dimensional array )，它的结构是上图，其中涉及到的 data-type object 和 array scalar types 我们之后单独再讲，参考 devdocs.io（因为 NumPy 自身确实是一个非常优秀的科学计算库，值得深入学习）。

在这里我们知道了 group 是一个 ndarray, 作为对比， labels 则是一个普通的 list， 这一点可以在 Pycharm 的 Python Console 里面看到：

可以看到 group 作为一个 ndarray 要比普通的 list 多了很多属性，更易于修改。

关于 NumPy 的 tile() 函数

tile 这个英语单词本身的意思是 “铺开” 和 “瓷砖”，这个函数的作用是对一个矩阵进行扩容。
NumPy.tile(A, reps) 函数的文档：https://docs.scipy.org/doc/numpy/reference/generated/numpy.tile.html

一位大佬图解了一维和二维的情况

简单地说：

1. 低维向高维平铺，在已有维度上铺开之后需要向外加中括号提高到高维

2. 高维向低维平铺，低维铺完即可

3. 同等维度平铺，对应维度铺开

4. 最终维度是 max(A.ndim, d)，其中 d 为 reps 的维数

回到代码中，tile(inX, (dataSetSize, 1))将 inX （待分类的数据，一维数组）平铺成了和dataSet 一样的行数，由于 dataSet 中也是坐标，因此扩充之后可以进行减法，获得偏移量

剩余的计算

剩余的计算仍然带有浓浓的矩阵风格：矩阵元素平方，按照轴的方向相加，最后再开方

排序：由于是数之排序，直接使用了 NumPy 的 argsort() 函数

分类的步骤

1. 拿到排序好了的近邻

2. 在已经有的 dataSet 中找到这个距离对应的类别

3. 把 classCount 中相应类别属性值加一（涉及到 dict.get()方法）

4. 用 sorted() 函数将 classCount 的 items 进行排序，其中涉及到 dict.items和operator.itemgetter()

   dict.get(key, [default value]) 方法：取 dict 中的 key 属性的值，如果没有这个属性，新建它并且赋值以 default value

   dict.items() 方法：返回 (key, value) pairs，注意不要再用 iteritems() 了，那是 Python 2 中的写法

   operatior.itemgetter(index) 方法：拿到一个对象的索引为 index 的值

至此我们基本把书上的 kNN 完整看了一遍，但是离应用还挺远（很多地方限定很多），下面就用它做点实战吧。

In Action – Dating Site Matches

从文件中读取数据

def file2matrix(filename):
    fr = open(filename)
    arrayOLines = fr.readlines()
    numberOfLines = len(arrayOLines)
    returnMat = zeros((numberOfLines, 3))
    classLabelVector = []
    index = 0
    for line in arrayOLines:
        line = line.strip()
        listFromLine = line.split('\t')
        returnMat[index, :] = listFromLine[0:3]
        classLabelVector.append(basestring(listFromLine[-1]))
        index += 1
    return returnMat, classLabelVector

数据的初步处理

命令：

>>> import matplotlib
>>> import matplotlib.pyplot as plt 
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.scatter(datingDataMat[:,1], datingDataMat[:,2])
>>> plt.show()

第一个散点图：

---

>>> import kNN
>>> datingDataMat, datingLabels = kNN.file2matrix('datingTestSet2.txt')
>>> import matplotlib
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> from numpy import * # 这一步不能少，不然会报错
>>> ax.scatter(datingDataMat[:,1], datingDataMat[:,2], 15.0*array(datingLabels), 15.0*array(datingLabels))
>>> plt.show()

第二张图：

数据的单位化

def autoNorm(dataSet):
    minVals = dataSet.min(0)
    maxVals = dataSet.max(0)
    ranges = maxVals - minVals
    normDataSet = zeros(shape(dataSet))
    m = dataSet.shape[0]
    normDataSet = dataSet - tile(minVals, (m, 1))
    normDataSet = normDataSet / tile(ranges, (m, 1))
    return normDataSet, ranges, minVals

在约会这个例子中由于有的项数值较大，但是影响因素并不大，因此需要进行单位化把所有的差值限制在 0~1 之间（或者 -1 ~1 ）

步骤如下：

1. 先用 ndarray.min() 和ndarray.max() 拿到对应的最小值与最大值，两个的结果都是 shape 为 (1, 3)

2. 拿到差值 ranges

3. 按照 dataSet 的 shape 初始化一个零矩阵

4. 拿到 dataSet 的行数

5. 将 minVals 的 shape 由 (1, 3) 铺开为 (1000, 3)，并用 dataSet 做减法

6. 元素层面（Element wise）做除法（注意不是矩阵除法），做单位化

7. 返回单位化的矩阵和差值、最小值

Error rate 计算

一个 classifier 需要 tester ，需要计算正确率

def datingClassTest():
    hoRatio = 0.10 # holdRatio, ratio of data held back for test, the rest of this are used for judge.

    datingDataMat, datingLabels = file2matrix('datingTestSet2.txt')
    normMat, ranges, minVals = autoNorm(datingDataMat)
    # get the rows of normMat
    m = normMat.shape[0]
    #get the num of the data for test.

    numTestVecs = int(m * hoRatio)
    errorCount = 0.0
    for i in range(numTestVecs):
        classifierResult = classify0(normMat[i, :], normMat[numTestVecs:m, :], datingLabels[numTestVecs:m], 3)
        print ("The classifier came back with: %d, the real answer is: %d" %(classifierResult, datingLabels[i]))
        if(classifierResult != datingLabels[i]):
            errorCount += 1
    # errorCount / float(numTestVecs) calculates the error rate.

    print ("The total  error rate is: %f" %(errorCount / float(numTestVecs)))

其中有一些地方可能不太容易理解：

• normMat[i, :] 是 normMat 的一个切片，i 行， all 列

• normMat[numTestVecs:m, :] 也是 normMat 的一个切片：行，从 （索引值）numTestVecs 行开始到 m 行；列，all

  这里理解了应该就知道这个例子中我们拿的是最后 10% 的数据，同样我们可以改一改

• datingLabels[numTestVecs:m] 是 datingLabels 的一个切片，由于 datingLabels 自身是 list 类型，因此它表示的是 datingLabels 的索引值从 numTestVecs 到 m 的一个切片

其余逻辑应该都比较容易理解。

组装起来

def classifyPerson():
    resultList = ["Not at all", "In small doses", "In large doses"]
    percentTats = float(input("percentage of time spent playing video games?"))
    ffMiles = float(input("frequent flier miles earned per year?"))
    iceCream = float(input("liters of licecream consumed per year?"))
    datingDataMat, datingLabels = file2matrix('datingTestSet2.txt')
    normMat, ranges, minVals = autoNorm(datingDataMat)
    inArr = array([ffMiles, percentTats, iceCream])
    classifierResult = classify0((inArr - minVals) / ranges, normMat, datingLabels, 3)
    print ("You will probably like this person:", resultList[classifierResult - 1])

在这里我们把前面写到几乎所有的功能函数都用了，前面每一个函数我们都做了详细解析。

1. 定义分类组

2. 取到三个参数（我们的 classify0() 函数不止能算二维 distance，同样地，其他函数都是面向 ndarray）

3. 取到已有数据集

4. 对已有数据集单位化

5. 用 classify0() 将这一个新的点进行分类

6. 将结果打印出来。

In Action – Handwring Recognition

from os import listdir
......
def handwritingClassTest():
    hwLabels = []
    trainingFileList = listdir('trainingDigits')
    m = len(trainingFileList)
    trainingMat = zeros((m, 1024))
    for i in range(m):
        fileNameStr = trainingFileList[i]
        fileStr = fileNameStr.split('.')[0]
        classNumStr = int(fileStr.split('_')[0])
        hwLabels.append(classNumStr)
        trainingMat[i, :] = img2vector('trainingDigits/%s' %fileNameStr)
    testFileList = listdir('testDigits')
    errorCount = 0.0
    mTest = len(testFileList)
    for i in range(mTest):
        fileNameStr = testFileList[i]
        fileStr = fileNameStr.split('.')[0]
        classNumStr = int(fileStr.split('_')[0])
        vectorUnderTest = img2vector('testDigits/%s' %fileNameStr)
        classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)
        print("The classifier came back with: %d, the real answer is: %d" %(classifierResult, classNumStr))
        if(classifierResult != classNumStr): errorCount += 1;
    print("\nThe total number of errors is: %d" %errorCount)
    print("\nThe total error rate is: %f" %(errorCount / float(mTest)))

• os.listdir(path)： Return a list containing the names of the entries in the directory given by path. 给文件夹名，获取到所有文件夹内的文件名的一个 list

过程：

1. 创建一个行数为总训练文件数，列数为 1024 的零矩阵

2. 进入循环

   1. 拿到文件名

   2. 用split()方法去掉文件名中的 . 和_

   3. 把文件名的数字放进类别中（这里因为给的测试数据都是已知类别的，并且表现在了文件命名中）

   4. 把图片转成的 vector 存进 trainingMat

3. 拿到测试数据的文件列表和它的长度

4. 进入循环

   1. 拿到各个文件名的数字

   2. 把图片转成的 vector 存进 vectorUnderTest

   3. 使用 classify() 函数做分类

5. 比较根据 kNN 分类与正确分类，打印出错误数和错误率

下面把图片（实际是 txt）转 vector 代码补上：

# 32 * 32 规格的 txt
def img2vector(filename):
    returnVect = zeros((1, 1024))
    fr = open(filename)
    for i in range(32):
        lineStr = fr.readline()
        for j in range(32):
            returnVect[0,32*i+j] = int(lineStr[j])
    return returnVect

至此，我们的 kNN 算法基本上结束了

kNN 分类与正确分类，打印出错误数和错误率

下面把图片（实际是 txt）转 vector 代码补上：

# 32 * 32 规格的 txt
def img2vector(filename):
    returnVect = zeros((1, 1024))
    fr = open(filename)
    for i in range(32):
        lineStr = fr.readline()
        for j in range(32):
            returnVect[0,32*i+j] = int(lineStr[j])
    return returnVect

至此，我们的 kNN 算法基本上结束了