【python实战】k-近邻算法（1）

一、k-近邻算法的简单实现

代码：

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

from numpy import*

importoperator

 

#已有数据，以及对应的标签

group=array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])

labels=['a','a','b','b']

 

def classify0(inX, dataSet, labels, k):

    dataSetSize = dataSet.shape[0] #获取数据集的行数

 

    #计算距离

    diffMat = tile(inX, (dataSetSize,1)) - dataSet

    sqDiffMat = diffMat**2 #对上述差值求平方  

    sqDistances = sqDiffMat.sum(axis=1) #对于每一行数据求和

    distances = sqDistances**0.5

    sortedDistIndicies = distances.argsort()  #对开方结果建立索引 按从小到大顺序0--（k-1）

 

    #计算距离最小的k个点的Lable

    classCount={}  #建立空字典，类别字典，保存各类别的数目

    fori in range(k):

        voteIlabel = labels[sortedDistIndicies[i]] #先找出开方结果索引表中第i个值对应的Label值

        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1# 存入当前label以及对应的类别值（数个数）

 

    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True) 

#对类别字典进行逆排序，级别数目多的往前放（py3用items(),）

 

    #返回结果

    returnsortedClassCount[0][0] #返回级别字典中（频率最高的）的第一个值，也就是最有可能的Label值

 

#进行分类

print(classify0([1.0,0.8],group,labels,3))

print(classify0([0.5,0.5],group,labels,3))

-----------------------------------------------------------------------------------

作用：将待分类数据集与已有数据集以其标签进行计算，从而得出待分类数据集最有可能所属的类别

参数：

inX:待分类数据集

dataSet：已有数据集，通过createDataSet()函数获取

labels:已有数据集对应的分类标签，通过createDataSet()函数获取

k：设置最小距离数

【参考网址【【http://www.2cto.com/kf/201405/299627.html】】】

------------------------------------------------------------------------------------

[1]numpy函数：shape用法  size=dataset.shape[0] 

shape函数是numpy.core.fromnumeric中的函数，它的功能是读取矩阵的长度，比如shape[0]就是读取矩阵第一维度的长度。它的输入参数可以使一个整数表示维度，也可以是一个矩阵。其他几种用法如下：

[2]numpy函数：tile函数用法   tile(inX,(datasize,1))-dataset

tile函数位于python模块 numpy.lib.shape_base中，他的功能是重复某个数组。比如tile(A,n)，功能是将数组A重复n次，构成一个新的数组，具体的例子：【 例子来源：http://blog.sina.com.cn/s/blog_6bd0612b0101cr3u.html】

>>> a=[[1,2],[2,3]]

>>> tile(a,2)

array([[1, 2, 1, 2],

       [2, 3, 2, 3]])

>>> tile(a,[1,2])             #【1，2】2看作对数组a的一维进行copy,2对a的二维进行copy

array([[1, 2, 1, 2],

       [2, 3, 2, 3]])

>>> tile(a,[2,2])

array([[1, 2, 1, 2],

       [2, 3, 2, 3],

       [1, 2, 1, 2],

       [2, 3, 2, 3]]

[3]numpy函数：sum函数用法 sqDiffMat.sum(axis=1)

sum(sequence[,start])->value                                            【参考网址http://blog.csdn.net/u012005313/article/details/49153261】

函数功能：返回一个数字序列（非字符串）的和，并加上参数'start'值（默认0，如果序列空则返回start的值（如果start为负，则出错）

.sum()函数是模块numpy的一个函数：

默认axis为None，表示将所有元素的值相加，对于二维数组，axis=1表示按行相加 , axis=0表示按列相加

[4]numpy函数：argsort函数用法

http://blog.csdn.net/maoersong/article/details/21875705

#argsort函数返回的是数组值从小到大的索引值  #对开方结果建立索引

>>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])

>>> x = np.array([[0, 3], [2, 2]]) 
    >>> np.argsort(x, axis=0) #按列排序
    array([[0, 1],
              [1, 0]])
    >>> np.argsort(x, axis=1) #按行排序
    array([[0, 1],
           [0, 1]])

[5]python函数：get函数用法

字典dict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值

[6]py3: items()函数

Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。将字典分解为元祖列表，

py2：iteritems()   【http://www.sjsjw.com/kf_code/article/34_20855_10234.asp】

[7]sorted()

operator.itemgetter（1） 函数，即取第二个元素（即出现次数）的次序对元祖进行来排序。逆序：从大到小。

二、k-近邻算法改进约会网站的配对效果

【1】zeros()：该函数功能是创建给定类型的矩阵，并初始化为0

1. #一维数组  
2. zeros(3)  
3. #二维数组  
4. zeros((2,3))  #或  zeros([2,3]) 

【2】line.strip()：截取掉所有的回车字符，然后使用tab字符\t将上一步得到的整行数据分割成一个元素列表

或|for line in file:
者| line.strip().split()这样就把每行的每个字符一个个分开，变成一个list。
【3】int(listFormLine[-1]);python中可以使用索引值-1表示列表中的最后一列元素。此外这里我们必须明确的通知解释器，告诉它列表中存储的元素值为整型，否则python语言会将这些元素当做字符串处理。

执行：

import matplotlib#matplotlib 是python最著名的绘图库
import matplotlib.pyplot as plt #快速绘图pyplot模块虽然用法简单，但不适合在较大的应用程序中使用

fig =plt.figure()#若绘制多幅图表，可以给figure()传递一个整数参数指定Figure对象的序号
ax =fig.add_subplot(111) #画子图
ax.scatter(datingDataMat[:,1],datingDataMat[:,2]) #散点图使用矩阵的第二列（游戏耗费时间）三列数据（消耗冰淇淋）
plt.show()

成功

【matplotlib：http://blog.sina.com.cn/s/blog_6252a9bf0101b257.html】

【http://blog.csdn.net/you_are_my_dream/article/details/53439518】

待续