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

这两日翻了须臾间机器学习实战那本书,算法是合情合理,只是代码不够自个儿,笔者是个搞算法的,那点从代码上就能看出来。但是多少位置选择numpy搞数组,搞矩阵,总是感到奇异,多个是内需运用叁方包numpy,即便那一个包为主能够说必备了,不过对于一些菜鸟,连pip都用不佳,装的numpy也是种种主题材料,所以说能不用依然尽量不用,第一个正是究竟是数据,代码样例里面写的唯有多少个case,可是实在采取起来,一定是要上数据库的,假使是array是不合乎从数据库中读写多少的。由此综合上述两点,笔者就把那段代码改成list格局了,当然,也可能有人会说自家对numpy很熟悉啊,而且作为规范的数学包,矩阵的运算方面也很方便,小编不否定,那小编那段代码大概对你不合乎,你能够参考书上的代码,直接照打并领会就好了。

声称:本篇博文是读书《机器学习实战》一书的点子路程,系原创,若转载请标明来源。

机器学习算法_knn,机器学习。k-近邻算法

K目前邻(k-Nearest
Neighbor,KNN)分类算法能够说是最简便易行的机器学习算法了。它应开销量差别特征值之间的相距方法实行分类。它的思索很简短:假设二个样书在特色空间中的k个最相似(即特征空间中最贴近)的样本中的大多数属于某三个档案的次序,则该样本也属于这一个类型。

knn,不多说了,互联网书上讲那几个的一大堆,轻易说便是运用新样本new_case的各维度的数值与已有old_亚洲必赢手机入口,case各维度数值的欧式距离总结

  1. K-近邻算法的形似流程:

k-近邻算法一般流程

  • 壹征集数据:能够应用别的方法。
  • 2绸缪数据:距离计算机本领讨论所供给的数值,最棒是结构化的数据格式。
  • 叁分析数据:能够选用别的措施。
  • ④磨练算法:此步骤不适用于k-近邻算法。
  • 5测试算法:总计错误率。
  • 六行使算法:首先须要输入样本数量和结构化的输入结果,然后运维k-近邻算法推断输入数据分别属于格外分类,最终动用对计量出的归类实践后续的拍卖。

亚洲必赢手机入口 1

依赖上航海用教室所示,有两类区别的范本数量,分别用巴黎绿的小圆锥形和壬申革命的小三角形表示,而图正中间的丰富深藕灰的圆所标示的数目则是待分类的数目。相当于说,现在,
大家不知晓中间那么些藤黄的数额是从属于哪一类(铁锈棕小长方形or森林绿小三角形),上面,大家就要化解那个主题素材:给这一个浅荧光色的圆分类。

  • 假若K=三,中灰圆点的近日的三个邻居是2个革命小三角形和三个鲜红小长方形,少数从属于诸多,基于总计的措施,判断青色的这么些待分类点属于深红的三角形一类。
  • 若是K=伍,暗绿圆点的近日的五个邻居是二个革命三角形和一个蓝灰的星型,照旧个别从属于繁多,基于计算的法门,判断黄铜色的那么些待分类点属于浅紫的星型壹类。
    于此大家看出,当无法看清当前待分类点是从属于已知分类中的哪1类时,我们能够依照总计学的商议看它所处的地点特征,衡量它相近邻居的权重,而把它归为(或分配)到权重更加大的那1类。那正是K近邻算法的宗旨绪想。其根本还在于K值的取舍,所以理应谨慎。

KNN算法中,所选用的近邻都以早已不易分类的对象。该方式在定类决策上只依据最接近的二个依然几个样本的门类来调节待分样本所属的项目。

KNN 算法自个儿轻易有效,它是一种 lazy-learning
算法,分类器不需求选拔操练集实行练习,练习时间复杂度为0。KNN
分类的企图复杂度和教练集中的文书档案数目成正比,也正是说,假使训练集普通话档总量为
n,那么 KNN 的归类时间复杂度为O(n)。

其算法描述如下:

欧式距离那里也不说了,有意思味能够去翻自家那篇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

二)遵照距离递增次序排序;

聊天一些,不多也不少,上面上代码,代码中配有伪代码,方便阅读,假如还看不老子@楚能够留言,笔者把详细注明加上

(③)分析数据:能够应用别的措施。

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的首先个维度重复三回。
  • tile(A,(三,二))表示A的率先个维度重复1次,然后第1个维度重复二遍。
  • tile(A,(二,贰,3))表示A的首先个维度重复三次,第壹个维度重复二次,第二维重复2回。

三)选用与当下点离开最小的k个点;

 

(四)测试算法:计算基值误差率。

sum函数表达

函数方式:sum(axis = 0 or 一)
函数效用:未有axis参数表示整个相加,axis=0表示按列相加,axis=壹表示根据行的趋势相加(取‘厉害’谐音)

>>> 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
>>>

4)明确前k个点所在类其余出现频率;

以下是代码中应用颜色,接纳html的16进制卡宴GB颜色,在应用时将其改动为10进制数字总计,old_case选用天灰圈,new_case选拔法国红圈

(5)使用算法:首先须求输入样本数量和结构化的出口结果,然后运转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])
>>>

5)再次来到前k个点出现频率最高的种类作为当前点的估计分类。

石黄(矮瓜颜色)

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

sort函数、sorted函数表达

函数格局:sorted(iterable,cmp,key,reverse)
函数作用:排序

  • sort对列表list实行排序,而sorted可以对list或许iterator进行排序

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

参数类型:
iterable:是可迭代类型;
cmp:用于相比较的函数,比较什么由key决定;
key:用列表成分的有个别属性或函数进行作为关键字,有暗许值,迭代聚聚焦的一项;
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)

源码

诚如落成三个算法后,我们须求先用一个十分小的数据库来测试它的正确,不然一下子给个大数目给它,它也很难消食,而且还不方便人民群众大家分析代码的有效性。

土黑(王瓜颜色)

(一)计算已知种类数据聚焦的点与目前点之间的距离。

 

亚洲必赢手机入口 3

(2)按照距离递增次序排序。

填补用python达成的代码,要给python装numpy和matplotlib库,提议直接装anaconda,装好了anaconda默许安装了spyder,里面集成了那七个库,比较便宜。

色情(金蕉颜色)

(三)接纳与当前点距离最小的k个点。

率先,大家新建三个kNN.py脚本文件,文件之中含有七个函数,3个用来生成小数据库,3个落到实处kNN分类算法。代码如下:

亚洲必赢手机入口 4

(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

浅绛红(小瓜颜色)

(5)重返前k个点出现频率最高的品类作为当下点的预计分类。

  然后咱们在命令行中或在建3个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来分类1个大点的数据库,包含数据维度十分的大和样本数相比多的数据库。那里大家用到几个手写数字的数据库,能够到这里下载。这一个数据库包涵数字0-九的手写体。每种数字大约有200个样本。每一种样本保持在3个txt文件中。手写体图像自个儿的大大小小是32×3贰的2值图,转变来txt文件保留后,内容也是3二x33个数字,0可能一.

测试结果,效果还不赖

(壹)classify0()函数的多少个输入参数:inX
用于分类的输入向量,dataSet是输入的陶冶样本集,labels是标签向量,最后k是用于选用目前邻的多寡,在那之中标签向量的要素数目和矩阵dataSet的行数同样。

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

亚洲必赢手机入口 6

(贰)代码中衡量四个对象距离的方法是欧几里得公式:

编写kNN2.py:

                                                                       
                 亚洲必赢手机入口 7

 

(叁)shape函数是numpy.core.fromnumeric中的函数,它的功能是读取矩阵的长度,例如shape[0]即便读取矩阵第一维度的长度。它的输入参数能够使3个平头表示维度,也得以是1个矩阵。

# -*- 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类型。

测试分外不难,编写二个main.py:

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

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

(5)sum函数中进入参数。sum(a,axis=0)也许是.sum(axis=1) ,axis=0
就是平凡的相加 ;出席axis=一现在便是将四个矩阵的每壹行向量相加。

接下来运维main.py观望正确率:

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

933个预测正确
accuracy is:98.63%

 (7)   get() 函数重返字典钦点键的值,如若值不在字典中再次回到暗中认可值。

 版权申明:原来的书文地址

(八)sorted进行排序,sorted(iterable, cmp=None, key=None, reverse=False)

         iterable:是可迭代类型;
         cmp:用于比较的函数,比较什么由key决定;
       
 key:用列表元素的有些属性或函数实行作为首要字,有暗许值,迭代聚集中的一项;
         reverse:排序规则. reverse = True  降序 大概 reverse = False
升序,有私下认可值。
         再次来到值:是1个通过排序的可迭代类型,与iterable一样。

3 示例-使用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

代码解释:

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

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

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

(肆)len()得到列表中的成分个数。

(5)zeros(shape, dtype=float,
order=’C’),重回来3个给定形状和项目标用0填充的数组;

         参数:shape:形状

                   dtype:数据类型,可选参数,暗中认可numpy.float64

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

                                     b,布尔值,true or false

                                     i,整数,如i8(64位)

                                     u,无符号整数,u8(6肆人)

                                    f,浮点数,f8(64位)

                                   c,浮点负数,

                                   o,对象,

                                   s,a,字符串,s24

                                   u,unicode,u24

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

(陆)strip()
方法用于移除字符串头尾内定的字符,暗中认可删除空白符(包含’\n’, ‘\r’,
 ‘\t’,  ‘ ‘)。

 (柒)split()便是将三个字符串差距成多少个字符串组成的列表。

叁.二 筹算数据:归一化数值

分化的性质,其数值的取值范围不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.3 测试算法:作为完整程序验证分类器

普通把已部分数据百分之九十看作战磨炼练样本分类器,其他10%多少去测试分类器,核查分类器的精确率。

代码完成:

 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

伍 附-对数据解析的数据可视化

 代码完结:

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

 

发表评论

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

网站地图xml地图