机械学习,机器学习算法_knn

那两日翻了一晃机械学习实战那本书,算法是没有错,只是代码不够本身,我是个搞算法的,那一点从代码上就能看出来。但是多少地点使用numpy搞数组,搞矩阵,总是认为蹊跷,四个是亟需运用三方包numpy,尽管那么些包为主能够说必备了,不过对于一些新手,连pip都用不佳,装的numpy也是各样主题材料,所以说能毫无仍然尽量不用,首个正是毕竟是数额,代码样例里面写的只有几个case,不过实在接纳起来,一定是要上数据库的,即便是array是不合乎从数据库中读写多少的。由此综合上述两点,笔者就把那段代码改成list情势了,当然,也也许有人会说自家对numpy很谙习啊,而且作为正式的数学包,矩阵的运算方面也很方便,作者不否定,那笔者那段代码恐怕对你不合乎,你能够参考书上的代码,直接照打并明白就好了。

扬言:本篇博文是读书《机器学习实战》一书的办法路程,系原创,若转发请标明来源。

k-近邻算法

K近期邻(k-Nearest
Neighbor,KNN)分类算法能够说是最简易的机械学习算法了。它采用衡量不一样特征值之间的离开药方法举办分类。它的考虑很简短:假如二个样书在特色空间中的k个最相似(即特征空间中最贴近)的样本中的大大多属于某一个项目,则该样本也属于那几个类型。

knn,不多说了,网络书上讲这么些的一大堆,轻巧说正是应用新样本new_case的各维度的数值与已有old_case各维度数值的欧式距离总结

  1. K-近邻算法的一般流程:

k-近邻算法一般流程

  • 1搜罗数据:能够采纳任何方法。
  • 二计划数据:距离计算机本领讨论所须求的数值,最棒是结构化的数额格式。
  • 叁分析数据:能够行使此外措施。
  • 肆练习算法:此步骤不适用于k-近邻算法。
  • 伍测试算法:总括错误率。
  • 陆使用算法:首先须要输入样本数量和结构化的输入结果,然后运转k-近邻算法决断输入数据分别属于分外分类,最后采用对计量出的归类试行后续的拍卖。

澳门葡京备用网址 1

传说上海体育场合所示,有两类区别的范本数量,分别用原野绿的小正方形和癸亥革命的小三角形表示,而图正中间的可怜浅米灰的圆所标示的多寡则是待分类的数据。也正是说,未来,
我们不精晓中间这2个中湖蓝的数量是从属于哪1类(卡其色小正方形or石黄小三角形),上边,大家将要化解这么些标题:给这些青黑的圆分类。

  • 假使K=三,油红圆点的近年的二个邻居是1个深褐小三角形和一个奶油色小圆柱形,少数从属于大多,基于总结的措施,判断苹果绿的这一个待分类点属于深藕红的三角一类。
  • 倘若K=五,浅灰褐圆点的近年的四个街坊是1个淡铁锈色三角形和3个银灰的纺锤形,依旧少数从属于好多,基于总计的秘诀,决断铁锈棕的那些待分类点属于葡萄紫的长方形一类。
    于此大家看来,当不可能判断当前待分类点是从属于已知分类中的哪1类时,大家得以依附总计学的批评看它所处的职位特征,衡量它相近邻居的权重,而把它归为(或分配)到权重更加大的那一类。那正是K近邻算法的核心境想。其重要还在于K值的挑选,所以应当谨慎。

KNN算法中,所挑选的街坊都以一度不错分类的目标。该措施在定类决策上只依照最贴近的二个要么多少个样本的种类来支配待分样本所属的体系。

KNN 算法本人轻易实用,它是1种 lazy-learning
算法,分类器不必要利用磨炼集进行演练,练习时间复杂度为0。KNN
分类的估测计算复杂度和教练聚集的文书档案数目成正比,也便是说,假使练习集汉语档总量为
n,那么 KNN 的分类时间复杂度为O(n)。

其算法描述如下:

机械学习,机器学习算法_knn。欧式距离那里也不说了,有乐趣能够去翻笔者那篇python_相差衡量,里面写的很详细,并用符号显示说明,你也足以改成棋盘距离或街区距离试试,速度可能会比欧式距离快,但要么安利欧式距离。

(一)搜聚数据:能够应用此外格局(如爬虫)。

python代码完成认证

毋庸置疑计算包:numpy
运算符模块:operator

1)计算已知连串数据汇总的点与目前点时期的离开;

有一点没搞明白的正是,对坐标进行精度化总计那块,实地度量后显著使用直接总括无论是错误率照旧精度,管理前都要比拍卖后越来越准确,大概原代码使用小数点的概率越来越高些呢,也许那一个总结对于小数计算精度更有救助

(2)筹划数据:距离计算机手艺商量所须求的数值,最棒是结构化的数目格式。

shape函数表达

shape函数是numpy.core.fromnumeric中的函数,它的意义是翻开矩阵也许数组的维数

代码:

>>> a = array([[1,2,3],[5,6,9],[9,8,9]])
>>> a.shape
(3, 3)
>>> a.shape[0]
3

2)根据距离递增次序排序;

聊天一些,不多也不少,下边上代码,代码中配有伪代码,方便阅读,要是还看不老子@楚能够留言,小编把详细注明加上

(3)分析数据:能够应用其余方法。

numpy.tile函数表达

函数情势:tile(A,rep)
效率:重复A的逐条维度
参数类型:
A: Array类的都能够
rep:A沿着各种维度重复的次数

>>> a =array([[1,2,3],[5,6,9],[9,8,9]])
>>> tile(a,3)
array([[1, 2, 3, 1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9, 9, 8, 9]])
>>> tile(a,[3,2])
array([[1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9]])
>>> tile(a,[2,2,3])
array([[[1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9],
        [1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9]],

       [[1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9],
        [1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9]]])

reps的数字从后往前分别对应A的第N个维度的双重次数。

如:

  • tile(A,三)表示A的首先个维度重复1次。
  • tile(A,(叁,二))表示A的率先个维度重复2遍,然后第一个维度重复三回。
  • tile(A,(二,2,3))表示A的首先个维度重复1遍,第1个维度重复3回,第四个维度重复三遍。

3)采取与当下点距离最小的k个点;

 

(肆)测试算法:总括固有误差率。

sum函数表明

函数情势:sum(axis = 0 or 壹)
函数功用:未有axis参数表示全体相加,axis=0表示按列相加,axis=1表示遵照行的势头相加(取‘厉害’谐音)

>>> b = tile(a,[3,2])
>>> b
array([[1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9]])
>>> c = b.sum(axis = 0)
>>> c
array([45, 48, 63, 45, 48, 63])
>>> d = b.sum(axis = 1)
>>> d
array([12, 40, 52, 12, 40, 52, 12, 40, 52])
>>> e = b.sum()
>>> e
312
>>>

四)分明前k个点所在类其余面世频率;

以下是代码中应用颜色,选用html的1陆进制途睿欧GB颜色,在应用时将其改动为十进制数字总计,old_case选用黑古铜色圈,new_case选拔珍珠白圈

(伍)使用算法:首先供给输入样本数量和结构化的出口结果,然后运维K-近邻算法推断输入数据分别属于哪个分类,最终采用对计量出的归类实施后续的拍卖。

argsort函数表明

函数形式:argsort(x) or x.argsort()
参数功用:argsort函数再次回到的是数组值从小到大的索引值

>>> x = array([3,4,2,5,1,6])
#按升序排列
>>> x.argsort()
array([4, 2, 0, 1, 3, 5])
#按升序排列
>>> argsort(-x)
array([5, 3, 1, 0, 2, 4])
>>>

五)重回前k个点出现频率最高的项目作为当下点的推断分类。

浅青(茄子颜色)

  1. K-近邻算法的伪代码和Python代码

sort函数、sorted函数表达

函数方式:sorted(iterable,cmp,key,reverse)
函数功效:排序

  • sort对列表list进行排序,而sorted能够对list可能iterator进行排序

  • sort函数对列表list实行排序时会影响列表list本人,而sorted不会

参数类型:
iterable:是可迭代类型;
cmp:用于比较的函数,相比较什么由key决定;
key:用列表成分的某部属性或函数实行作为关键字,有默许值,迭代会集中的1项;
reverse:排序规则. reverse = True 降序 或然 reverse = False
升序,有暗中同意值。
重临值:是三个透过排序的可迭代类型,与iterable同样。

>>> a = [7,3,9,4,1]
>>> sorted(a)
[1, 3, 4, 7, 9]
>>> a
[7, 3, 9, 4, 1]
>>> a.sort()
>>> a
[1, 3, 4, 7, 9]

对此机器学习而已,Python须求分外安装三件宝,分别是Numpy,scipy和Matplotlib。前两者用于数值计算,后者用于画图。安装相当粗略,直接到各自的官方网址下载回来安装就能够。安装程序会活动寻找我们的python版本和目录,然后安装到python支持的物色路径下。反正就python和那多个插件都默许安装就没难题了。

澳门葡京备用网址 2

对未知连串属性的数量汇总的每一种点依次实践以下操作:

operator.itemgetter函数

>>> a = [1,2,3]
>>> b = operator.itemgetter(1)//定义函数b,获取对象的第1个域的值
>>> b(a)
2
>>> b = operator.itemgetter(0,1)//定义函数b,获取对象的第1个域和第0个的值
>>> b(a)
(1, 2)

源码

诚如完成2个算法后,咱们必要先用四个相当的小的数据库来测试它的没有错,不然一下子给个大数目给它,它也很难消化吸收,而且还不便民大家解析代码的灵光。

茶褐(唐瓜颜色)

(1)总括已知类别数据聚焦的点与日前点之间的距离。

 

澳门葡京备用网址 3

(2)根据距离递增次序排序。

填补用python达成的代码,要给python装numpy和matplotlib库,提议直接装anaconda,装好了anaconda暗中同意安装了spyder,里面集成了那八个库,相比便宜。

色情(金蕉颜色)

(3)采用与当前点距离最小的k个点。

率先,大家新建多少个kNN.py脚本文件,文件之中含有多个函数,三个用来生成小数据库,2个完成kNN分类算法。代码如下:

澳门葡京备用网址 4

(四)明确前k个点所在类其余面世频率。

# -*- coding: utf-8 -*-
from numpy import *
def createDataSet():#创建一个很小的数据库
    group=array([[1.0,0.9],[1.0,1.0],[0.1,0.2],[0.0,0.1]])
    labels=['A','A','B','B']
    return group,labels
#[1.2,1.0]
def kNNClassify(newInput,dataset,labels,k):#knn算法核心
    #先求数据库中每个点到所求点之间的距离
    numSamples=dataset.shape[0] #获取数据库的行数
    diff=tile(newInput,(numSamples,1))-dataset#使用tile函数迭代创建一个numSample行1列的array与dataset做差
    squaredDiff=diff**2#diff中的每一个数都平方
    squaredDist=sum(squaredDiff,axis=1)#每一行两数求和
    distance=squaredDist**0.5#再开方
    #再对距离进行排序
    sortedDistIndices=argsort(distance)#argsort函数对distance中元素从小到大排序,返回序号
    classCount={}
    #统计距离小于等于k的每个点的类别
    for i in xrange(k):
       voteLabel=labels[sortedDistIndices[i]]
       classCount[voteLabel]=classCount.get(voteLabel,0)+1
    maxCount=0              
    #找出离所求点最近的k个点中最多的类别         
    for key,value in classCount.items():
        if maxCount<value:
            maxCount=value
            maxIndex=key
    #返回所求点的类型,算法到此结束
    return maxIndex

白色(小瓜颜色)

(伍)再次来到前k个点出现频率最高的档次作为当下点的估量分类。

  然后大家在命令行中或在建二个python文件那样测试就可以:

澳门葡京备用网址 5

程序代码:

import kNN
from numpy import *

dataSet,labels=kNN.createDataSet()
testX=array([0,0.05])
k=3
maxIndex=kNN.kNNClassify(testX,dataSet,labels,3)
print maxIndex

代码见下

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()     
    classCount={}          
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

  运转程序:此时点[0,0.05]最接近B类。

#!/usr/bin//python
# coding: utf-8

'''
1、获取key和coord_values,样例使用的是list,但是如果真正用在训练上的话list就不适合了,建议改为使用数据库进行读取
2、对坐标进行精度化计算,这个其实我没理解是为什么,可能为了防止错误匹配吧,书上是这样写的
3、指定两个参数,参数一是新加入case的坐标,参数二是需要匹配距离最近的周边点的个数n,这里赢指定单数
4、距离计算,使用欧式距离
  新加入case的坐标与每一个已有坐标计算,这里还有优化空间,以后更新
  计算好的距离与key做成新的key-value
  依据距离排序
  取前n个case
5、取得key
  对前n个case的key进行统计
  取统计量结果最多的key即是新加入case所对应的分组
6、将新加入的values与分组写成key-value加入已有的key-value列队
输入新的case坐标,返回第一步......递归
'''

import operator

def create_case_list():
  # 1代表黄瓜,2代表香蕉,3代表茄子,4代表西葫芦
  case_list = [[25,3,73732],[27.5,8,127492],[13,6,127492],[16,13,50331049],[17,4,18874516],[22,8,13762774],[14,1,30473482],[18,3,38338108]]
  case_type = [1,1,2,2,3,3,4,4]
  return case_list,case_type

def knn_fun(user_coord,case_coord_list,case_type,take_num):
  case_len = len(case_coord_list)
  coord_len = len(user_coord)
  eu_distance = []
  for coord in case_coord_list:
    coord_range = [(user_coord[i] - coord[i]) ** 2 for i in range(coord_len)]
    coord_range = sum(coord_range) ** 0.5
    eu_distance.append(coord_range)
  merage_distance_and_type = zip(eu_distance,case_type)
  merage_distance_and_type.sort()
  type_list = [merage_distance_and_type[i][1] for i in range(take_num)]
  class_count = {}
  for type_case in type_list:
    type_temp = {type_case:1}
    if class_count.get(type_case) == None:
      class_count.update(type_temp)
    else: class_count[type_case] += 1
  sorted_class_count = sorted(class_count.iteritems(), key = operator.itemgetter(1), reverse = True)
  return sorted_class_count[0][0]

def auto_norm(case_list):
  case_len = len(case_list[0])
  min_vals = [0] * case_len
  max_vals = [0] * case_len
  ranges = [0] * case_len
  for i in range(case_len):
    min_list = [case[i] for case in case_list]
    min_vals[i] = min(min_list)
    max_vals[i] = max([case[i] for case in case_list])
    ranges[i] = max_vals[i] - min_vals[i]
  norm_data_list = []
  for case in case_list:
    norm_data_list.append([(case[i] - min_vals[i])/ranges[i] for i in range(case_len)])
  return norm_data_list,ranges,min_vals

def main():
  result_list = ['黄瓜','香蕉','茄子','西葫芦']
  dimension1 = float(input('长度是: '))
  dimension2 = float(input('弯曲度是: '))
  dimension3 = float(input('颜色是: '))
  case_list,type_list = create_case_list()
  #norm_data_list,ranges,min_vals = auto_norm(case_list)
  in_coord = [dimension1,dimension2,dimension3]
  #in_coord_len = len(in_coord)
  #in_coord = [in_coord[i]/ranges[i] for i in range(in_coord_len)]
  #class_sel_result = knn_fun(in_coord,norm_data_list,type_list,3)
  class_sel_result = knn_fun(in_coord,case_list,type_list,3)
  class_sel_result = class_sel_result - 1
  return result_list[class_sel_result]

if __name__ == '__main__':
  a = main()
  print '这货是: %s' %a

代码解释:

 应用:这里我们用kNN来分类二个大点的数据库,蕴含数据维度比相当的大和样本数比较多的数据库。那里我们用到2个手写数字的数据库,能够到这里下载。这几个数据库包蕴数字0-玖的手写体。种种数字大概有200个样本。每一个样本保持在2个txt文件中。手写体图像本身的大小是3二x3贰的二值图,调换成txt文件保留后,内容也是3二x3十5个数字,0恐怕一.

测试结果,效果还不赖

(1)classify0()函数的八个输入参数:inX
用于分类的输入向量,dataSet是输入的操练样本集,labels是标签向量,最终k是用于选拔近期邻的数目,其中标签向量的因素数目和矩阵dataSet的行数一样。

数据库解压后有八个目录:目录trainingDigits存放的是差不多三千个教练多少,testDigits存放大致900个测试数据。

澳门葡京备用网址 6

(贰)代码中衡量五个目的距离的艺术是欧几里得公式:

编写kNN2.py:

                                                                       
                 澳门葡京备用网址 7

 

(三)shape函数是numpy.core.fromnumeric中的函数,它的机能是读取矩阵的长短,举个例子shape[0]不畏读取矩阵第二维度的尺寸。它的输入参数能够使二个整数表示维度,也能够是贰个矩阵。

# -*- coding: utf-8 -*-
from numpy import *
import os
def kNNClassify(newInput,dataset,labels,k):#knn算法核心
    #先求数据库中每个图像与所要分类图像像素值差的平方再开方,用这种计算方法表示距离(相似度)俗称欧氏距离
    numSamples=dataset.shape[0] #获取数据库的行数(即文件夹下的文件数)
    diff=tile(newInput,(numSamples,1))-dataset#使用tile函数迭代创建一个numSample行1列的array与dataset做差
    squaredDiff=diff**2#diff中的每一个数都平方
    squaredDist=sum(squaredDiff,axis=1)#每一行的数求和
    distance=squaredDist**0.5#再开方
    #再对距离进行排序
    sortedDistIndices=argsort(distance)
    classCount={}
    #统计距离为k的每个图像的类别(即统计相似度最小的k个图像所表示的数字)
    for i in xrange(k):  
        voteLabel = labels[sortedDistIndices[i]]  
        classCount[voteLabel] = classCount.get(voteLabel, 0) + 1

    maxCount=0            
    #找出离所求图像类别最近的k个图像中最多的类别       
    for key,value in classCount.items():
        if maxCount<value:
            maxCount=value
            maxIndex=key
    #返回所求图像的类型(类型即数字)
    return maxIndex

#函数img2vector把一张32*32的图像转化成一行向量imgVector
def img2vector(filename):
    rows=32
    cols=32
    imgVector=zeros((1,rows*cols))
    fileIn=open(filename)
    for row in xrange(rows):
        lineStr=fileIn.readline()
        for col in xrange(cols):
            imgVector[0,row*32+col]=int(lineStr[col])
    return imgVector

#函数loadDataSet从文件夹中加载多个文件数据,python对文件数据流加载到内存的操作很方便,这里的代码可以仔细理解加记忆一下
def loadDataSet():
    dataSetDir='/home/chao/Desktop/python_work/knn/'
    trainingFileList=os.listdir(dataSetDir+'trainingDigits')
    numSamples=len(trainingFileList)
    train_x=zeros((numSamples,1024))#使用zeros函数为train_x分配numSamples行,每行1024列,每行为一个图像转化后的数据,总共numSamples行
    train_y=[]#用来存放每个图像的真实值
    for i in xrange(numSamples):
        filename=trainingFileList[i]
        train_x[i,:]=img2vector(dataSetDir+'trainingDigits/%s'%filename)
        label=int(filename.split('_')[0])
        train_y.append(label)
    testingFileList=os.listdir(dataSetDir+'testDigits')
    numSamples=len(testingFileList)
    test_x=zeros((numSamples,1024))#同train_x,但这里表示的是测试图像文件的
    test_y=[]
    for i in xrange(numSamples):
        filename=testingFileList[i]
        test_x[i,:]=img2vector(dataSetDir+'testDigits/%s'%filename)
        label=int(filename.split('_')[0])
        test_y.append(label)
    return train_x,train_y,test_x,test_y

#测试预测准确率
def testHandWritingClass():
    print "第一步:加载数据。。。"
    train_x,train_y,test_x,test_y=loadDataSet()

    numTestSamples=test_x.shape[0]#返回待测试图像的个数
    print "数据加载完成"
    matchCount=0#用来表示预测正确的图像的个数
    #每个待测图像都要调用一次knn预测其值
    for i in xrange(numTestSamples):
        print i
        predict=kNNClassify(test_x[i],train_x,train_y,3)#这里k=3准确率达98.63%,如果改成k=1的话会达到98.97%
        if predict==test_y[i]:
            matchCount+=1
    accuracy=float(matchCount)/numTestSamples
    print matchCount#打印正确预测个数
    print "accuracy is:%.2f%%"%(accuracy*100)#打印正确预测准确率

(四)tile函数是模板numpy.lib.shape_base中的函数。函数的情势是tile(A,reps)

 

        A的品类大概具有类别都能够:array, list, tuple, dict,
matrix以及基本数据类型int, string, float以及bool类型。

测试十分轻便,编写1个main.py:

        reps的品类大概多,能够是tuple,list, dict, array,
int,bool.但不得以是float, string, matrix类型。行列重复copy的次数。

# -*- coding: utf-8 -*-
import kNN2
kNN2.testHandWritingClass()

(五)sum函数中进入参数。sum(a,axis=0)或许是.sum(axis=一) ,axis=0
就是平常的相加 ;插手axis=1现在就是将一个矩阵的每一行向量相加。

接下来运营main.py阅览准确率:

(六)argsort函数重返的是数组值从小到大的索引值。

933个预测正确
accuracy is:98.63%

 (柒)   get() 函数重临字典钦定键的值,假使值不在字典中重临暗中认可值。

 版权声明:原来的小说地址

(八)sorted举办排序,sorted(iterable, cmp=None, key=None, reverse=False)

         iterable:是可迭代类型;
         cmp:用于相比较的函数,比较什么由key决定;
       
 key:用列表成分的某部属性或函数进行作为重要字,有暗中认可值,迭代集结中的1项;
         reverse:排序规则. reverse = True  降序 也许 reverse = False
升序,有私下认可值。
         再次来到值:是三个经过排序的可迭代类型,与iterable一样。

叁 示例-使用K-近邻算法立异约会网址的配对作用

叁.一 企图数据:从文本文件中剖析数据

将待管理数据的格式改换为分类器能够接到的格式。

代码达成:

 1 def file2matrix(filename):
 2     fr = open(filename)
 3     numberOfLines = len(fr.readlines())         #get the number of lines in the file
 4     returnMat = zeros((numberOfLines,3))        #prepare matrix to return
 5     classLabelVector = []                       #prepare labels return   
 6     fr = open(filename)
 7     index = 0
 8     for line in fr.readlines():
 9         line = line.strip()
10         listFromLine = line.split('\t')
11         returnMat[index,:] = listFromLine[0:3]
12         classLabelVector.append(int(listFromLine[-1]))
13         index += 1
14     return returnMat,classLabelVector

代码解释:

(一)file二matrix ()函数的参数,filename接收文件名。

(二)open(路线+文件名,读写形式),读写形式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件。

(叁)readlines() 自动将文件内容分析成一个行的列表,该列表能够由 Python
的 for … in … 结构进行管理。

(4)len()获得列表中的成分个数。

(伍)zeros(shape, dtype=float,
order=’C’),再次回到来1个给定形状和类型的用0填充的数组;

         参数:shape:形状

                   dtype:数据类型,可选参数,暗中同意numpy.float6四

                   dtype类型:t ,位域,如t4代表4位

                                     b,布尔值,true or false

                                     i,整数,如i8(64位)

                                     u,无符号整数,u八(陆11个人)

                                    f,浮点数,f8(64位)

                                   c,浮点负数,

                                   o,对象,

                                   s,a,字符串,s24

                                   u,unicode,u24

                order:可选参数,c代表与c语言类似,行优先;F代表列优先

(陆)strip()
方法用于移除字符串头尾钦赐的字符,暗中认可删除空白符(包罗’\n’, ‘\澳门葡京备用网址 ,r’,
 ‘\t’,  ‘ ‘)。

 (柒)split()正是将2个字符串分歧成三个字符串组成的列表。

3.2 计划数据:归1化数值

今非昔比的性质,其数值的取值范围不1,则计算距离时属性的权重就会不能掌握控制。由此,平时选拔的不二等秘书诀是将数值归一化,如将取值范围管理为0到一恐怕-壹到1之间。其通用公式:

newValue = (oldValue-min) /(max-min)

其间min和max分别是多少聚焦的小小特征值和最大特征值。

代码完结:

1 def autoNorm(dataSet):
2     minVals = dataSet.min(0)
3     maxVals = dataSet.max(0)
4     ranges = maxVals - minVals
5     normDataSet = zeros(shape(dataSet))
6     m = dataSet.shape[0]
7     normDataSet = dataSet - tile(minVals, (m,1))
8     normDataSet = normDataSet/tile(ranges, (m,1))   #element wise divide
9     return normDataSet, ranges, minVals

三.3 测试算法:作为完整程序验证分类器

常备把已部分数据十分之九当做锻炼样本分类器,别的百分之十数目去测试分类器,核查分类器的正确率。

代码落成:

 1 def datingClassTest():
 2     hoRatio = 0.10      #hold out 10%
 3     datingDataMat,datingLabels = file2matrix('datingTestSet2.txt')       #load data setfrom file
 4     normMat, ranges, minVals = autoNorm(datingDataMat)
 5     m = normMat.shape[0]
 6     numTestVecs = int(m*hoRatio)
 7     errorCount = 0.0
 8     for i in range(numTestVecs):
 9         classifierResult = classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)
10         print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i])
11         if (classifierResult != datingLabels[i]): errorCount += 1.0
12     print "the total error rate is: %f" % (errorCount/float(numTestVecs))
13     print errorCount

测试结果:

澳门葡京备用网址 8

基值误差在5%,基本得以兑现对结果的算计。

四.选拔算法:构建完全可用系统

代码达成:

 1 def classifierPerson():
 2    resultList = [u'不喜欢',u'比较喜欢',u'很喜欢']
 3    percentTats = float(raw_input(u"玩视频游戏所耗时间百分百:"))
 4    ffmiles = float(raw_input(u"每年获得的飞行常客里程数:"))
 5    iceCream = float(raw_input(u"每周消耗的冰淇淋公升数:"))
 6    datingDataMat, datingLables = kNN.file2matrix('datingTestSet2.txt')
 7    normMat,ranges,minVals = kNN.autoNorm(datingDataMat )
 8    inArr = array([ffmiles ,percentTats ,iceCream ])
 9    classifierResult = kNN.classify0((inArr-minVals )/ranges,normMat ,datingLables ,3)
10    print u"你对这个人喜欢度: %s" % resultList [classifierResult -1]

运维结果:

澳门葡京备用网址 9

5 附-对数据解析的多寡可视化

 代码达成:

1 def show_data():
2    dataSet,lables = kNN .file2matrix('datingTestSet2.txt')
3    jieguo = kNN .classify0([2674,8.54,8.0],dataSet ,lables ,10)
4    fig= plt.figure()
5    ax = fig.add_subplot(111)
6    ax.scatter(dataSet [:, 1], dataSet [:, 2],
7               15.0*array(lables ),15.0*array(lables))
8    fig.show()
9    raw_input()

运行结果:

澳门葡京备用网址 10

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website