2019-07-24 22:01:42 fbher 阅读数 26
  • 阿里云机器学习算法应用实践

    人工智能的商业化应用是下一个风口,阿里云在机器学习算法方面有许多沉淀。本次分享首先是介绍阿里云机器学习PAI,接着会在上面搭建真实的案例,包括心脏病预测、新闻分类等场景。

    13773 人正在学习 去看看 CSDN讲师

1.概念:

       什么是K临近算法,其实可以根据字面上了解,若我现在有一堆点,根据它们的特征我把它们分成若干类,现在再加入一个点,求出这个点是属于哪一个类,我们可以取K个点,然后我们再计算所有点到这个点的欧式距离或者某一种距离,然后选出离它最近的K个点,看这K个点中那种点比较多,然后就把这个点归为哪一类。

      什么是分类,分类是离散的,我们上面说的点的归类也是一种分类。

      什么是回归,回归是连续的,例如在二维坐标系中我们给出若干个点,求一条直线,这就是回归。

 

2.KNN实现分类

         1.我们用sklearn先生成一堆点,然后再用matplotlib将图像显示出来

           

            

2.再把它放进我们生成的KNN分类器中,图像就是我们的分类结果,不同颜色就是不同的类别,y2放的才是这个点正确的分类

 

3.答案

3.KNN实现回归 

生成点

 

2018-03-13 17:37:26 lijianping962464 阅读数 82
  • 阿里云机器学习算法应用实践

    人工智能的商业化应用是下一个风口,阿里云在机器学习算法方面有许多沉淀。本次分享首先是介绍阿里云机器学习PAI,接着会在上面搭建真实的案例,包括心脏病预测、新闻分类等场景。

    13773 人正在学习 去看看 CSDN讲师

本篇文章主要内容:

  • k-临近分类算法概述
  • 从文本文件中解析和导入数据 
  • 使用Matplotlib创建扩散图
  • 归一化数据

一、k-临近算法概述

      简单地说,k-临近算法采用测量不同特征值之间的距离方法进行分类

工作原理:

       存在一个样本数据集合,也称作训练样本集,并且样本集中每个数据都存在标签,即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后,将新数据的每个特征与样本集中数据对应的特征进行比较,然后算法提取样本集中特征最相似(最临近)的数据的分类标签。一般来说,我们只选择样本数据集中前k个最相似的数据,这就是k-临近算法的出处,通常k是不大于20的整数。最后,选择k个最相似数据中出现次数最多的分类,作为新数据的分类。

我们使用欧式距离公式,来计算两个向量点A(x1,y1)与B(x2,y2)之间的距离:


优缺点:

             优点:精度高、对异常值不敏感

             缺点:计算复杂度高、空间复杂度高

             适用数据范围:数值型和标称型

k-临近算法核心内容伪代码如下:

对未知类别属性的数据集中的每个点依次执行以下操作:

           1.计算已知类别数据集中的点与当前点之间的距离

           2.按照距离递增次序排序

           3.选取与当前点距离最小的k个点

           4.确定前k个点所在类别的出现频率

           5.返回前k个点出现频率最高的类别作为当前点的预测分类

二、归一化数据

        在分析数据的过程中,我们很容易发现,因为不同特征的量纲(单位)的不同,不同特征的数据有很大差值,这样对计算结果的影响很大,显然,在运用欧氏距离公式时差值最大的属性对计算结果影响最大。在处理这种不同不同取值范围的特征值时,我们通常采用的方法是将数值归一化,下面的公式可以将任意取值范围的特征值映射到0到1区间内:

                                                       


示例:在约会网站上使用k-临近算法


步骤:

  • 收集数据:提供文本文件
  • 准备数据:使用python解析文本文件
  • 分析数据:使用matplotlib画二维扩散图
  • 设计算法:运用欧式距离公式设计k-临近算法
  • 测试算法:如果预测结果与实际不同,则标记为一个错误
  • 使用算法:产生简单的命令行程序,可以输入一些特征数据以判断对方是否是自己喜欢的类型

具体代码运行如下:

导入numpy库

import numpy as np

读取数据

def filematrix(filename):      #将待处理数据改变为可以接受的格式
    fr=open(filename)           #打开文件
    numberOfLines=len(fr.readlines())     #得到文件的行数   readlines()函数,逐行读取整个文件
    returnMat=np.zeros((numberOfLines,3))     #返回的Numpy零矩阵,numberOfLines行,3列
    #return=np.array(returnMat)
    fr=open(filename)
    classLabelVector=[]    #创建返回的numpy矩阵
    index=0     #计数
    for line in fr.readlines():  #依次读取文件的第一行
        line=line.strip()   #s.strip(rm),当rm空时,默认删除空白符(包括‘\n’,'\r','\t','')
        listFromLine=line.split('\t')  #使用s.split(str=“”,num=string,cout(str))将字符串根据‘\t’分隔符进行切片
        returnMat[index,:]=listFromLine[0:3]  #将数据前三列提取出来,存放到returnMat的Numpy矩阵中,也就是特征矩阵
        classLabelVector.append(int(listFromLine[-1]))#根据文本中标记的喜欢程度进行分类,1代表不喜欢,2代表魅力一般,3代表及具魅力
        index=index+1
    return returnMat,classLabelVector

分析数据

import matplotlib
import matplotlib.pyplot as plt
fig=plt.figure()        #建立一个画布
ax=fig.add_subplot(111)         #在画布中建立图表,fig.add_subplot()函数。画布分割成1行1列,图像
ax.scatter(datingDataMat[:,1],datingDataMat[:,2],10*np.array(datingLabels),10*np.array(datingLabels))  ##第二列和第三列数据,
plt.show()

输出分析结果图(不同的颜色代表不同的特征)


归一化数据

def autoNorm(dataSet):
    minVals=dataSet.min(0)   #每一列的最小值
    maxVals=dataSet.max(0)   #每一列的最大值
    ranges=maxVals-minVals
    normDataSet=np.zeros(np.shape(dataSet))   #shape(dataSet)返回dataSet
    m=dataSet.shape[0]   #返回dataSet的行数
    normDataSet=dataSet-np.tile(minVals,(m,1))   #原dataSet数据矩阵最小值
    normDataSet=normDataSet/np.tile(ranges,(m,1))#矩阵除法
    return normDataSet,ranges,minVals

设计k-临近算法

def classify(inX,dataSet,labels,k):
    dataSetSize=dataSet.shape[0]
    diffMat=np.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]

测试算法

import operator
def datingClassTest():                            #定义函数,进行分类测试
    hoRatio=0.10                                  #10%作为测试集
    datingDataMat,datingLabels=filematrix('datingTestSet2.txt')     #打开数据,
    normMat,ranges,minVals=autoNorm(datingDataMat)                 #调用函数进行数据归一化
    m=normMat.shape[0]                            #获得行数,即总数量
    numTestVecs=int(m*hoRatio)                   #取10%测试数据的个数,变成int类型
    errorCount=0.0                           #错误计数
    for i in range(numTestVecs):
        classifierResult=classify(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3) 
        #取出前10%行作为测试集,后面的作为训练集,标签与数据范围相同,K=3
        print("the classifier came back with:%d,the real answer is:%d"%(classifierResult,datingLabels[i]))
        #classifierResult分类测试计算出的值,datingLabels[i]真实值
        if(classifierResult!=datingLabels[i]): 
            errorCount+=1.0          #预测值与真实值不同时,错误数+1
        print("the total error rate is:%f"%(errorCount/float(numTestVecs)))
        print(errorCount)
datingClassTest() 

最终输出的错误率与错误个数:


使用算法

def classifyPerson():
    resultList=['一点也不受欢迎','比较受欢迎','极具魅力']
    ffMiles=float(input("每年飞行里程大约有多少?"))
    percentTats=float(input("玩游戏的时间百分比是多少?"))
    iceCream=float(input("每年会消耗点多少公升的冰淇淋?"))
    datingDataMat,datingLabels=filematrix('datingTestSet2.txt')
    normMat,ranges,minVals=autoNorm(datingDataMat)
    inArr=np.array([ffMiles,percentTats,iceCream])
    classifierResult=classify((inArr-minVals)/ranges,normMat,datingLabels,3)
    print("你可能是这种人:",resultList[classifierResult-1])
classifyPerson()

输出结果:





2019-04-20 12:11:53 zz133110 阅读数 31
  • 阿里云机器学习算法应用实践

    人工智能的商业化应用是下一个风口,阿里云在机器学习算法方面有许多沉淀。本次分享首先是介绍阿里云机器学习PAI,接着会在上面搭建真实的案例,包括心脏病预测、新闻分类等场景。

    13773 人正在学习 去看看 CSDN讲师

K-临近算法

从今天开始,开始挖个坑。学习《机器学习实战》这本书,然后将学习的笔记记录下来。相关代码请参考:

https://github.com/pbharrin/machinelearninginaction
里面有数据集和源码。但是这是基于python2编写的代码。我的学习笔记都是基于python3 的。会有一些函数的不同。但是思路是一样的。

k近邻属于最简单的机器学习方法了,属于一种分类的方法,监督学习。原理就是计算待分类的点和训练集的距离。然后得出结果。其实准确的说训练集不妥当,因为该算法没有训练的过程,所以属于懒惰学习。

优点:精度高,对异常值不敏感,无数据输入假定

缺点:计算复杂度和空间复杂度高

简单实例

通过简单的一个例子。首先构造一个数据集如下:(记得安装numpy包)

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

在(0,0)和(1,1)坐标附近分别有两个点AA和BB。然后给一个点(0,0),问这个点是属于A还是B。

解决思路如下,就是让(0,0)点分别和剩下的四个点算距离,然后取距离最近的k个值。

tile函数是干嘛的可以参考这篇文章,非常形象,两秒看懂:https://www.jianshu.com/p/9519f1984c70

dataSet = group
k=3
inX = [0,0]
# 计算距离
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 = {}
#选择距离最小的k个点
for i in range(k):
    voteIlable = labels[sortedDistIndicies[i]]
    classCount[voteIlable]=classCount.get(voteIlable,0)+1
#排序
sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)

print(sortedClassCount[0][0])
B

约会数据应用

然后就是通过约会数据做一个分类。如下有一种数据集,(可从这里下载:https://github.com/pbharrin/machinelearninginaction/blob/master/Ch02/datingTestSet.txt):

40920	8.326976	0.953952	largeDoses
14488	7.153469	1.673904	smallDoses
26052	1.441871	0.805124	didntLike
...

4列分别表示的意思是,每年获得的飞行常客里程数、玩游戏所消耗的时间百分比、每周消耗冰激凌的公升数、喜爱程度。

这是训练集,测试内容就是提供里程数、游戏时间和冰激凌量,让你分析一下是女性对该人喜爱程度。

需要先下载一下sklearn库。这里的作用就是将喜爱程度largeDosessmallDosesdidntLike转化为1,2,3。

下面的代码就是读取数据,然后把文本的数据分为训练集returnMat 和标签classLabelVector

from numpy import *
from sklearn.preprocessing import LabelEncoder,MinMaxScaler
from sklearn import preprocessing
import operator 
def file2matrix(filename):
    fr = open(filename, encoding='UTF-8-sig')
    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(listFromLine[-1]) 
        index +=1
    le = preprocessing.LabelEncoder()
    classLabelVector =le.fit_transform(classLabelVector)+1
    return returnMat,classLabelVector
 

运行瞅一下结果,注意地址别照抄。

file2matrix('data/datingTestSet.txt')

(array([[4.0920000e+04, 8.3269760e+00, 9.5395200e-01],
        [1.4488000e+04, 7.1534690e+00, 1.6739040e+00],
        [2.6052000e+04, 1.4418710e+00, 8.0512400e-01],
        ...,
        [2.6575000e+04, 1.0650102e+01, 8.6662700e-01],
        [4.8111000e+04, 9.1345280e+00, 7.2804500e-01],
        [4.3757000e+04, 7.8826010e+00, 1.3324460e+00]]),
 array([2, 3, 1, 1, 1, 1, 2, 2, 1, 2, 1, 1, 3, 1, 1, 1, 1, 1, 3, 2, 3, 1,
        ...
        2, 3, 3, 3, 3, 3, 1, 2, 2, 2], dtype=int64))

这一步就是把数据显示一下,数据可视化。下载matplotlib。运行结果的图就是游戏和冰激凌之间对于喜爱程度的一个可视化。
这一步就是把数据显示一下,数据可视化。下载matplotlib。运行结果的图就是游戏和冰激凌之间对于喜爱程度的一个可视化。

import matplotlib
import matplotlib.pyplot as plt
datingData,datingLable=file2matrix('data/datingTestSet.txt')
fig =plt.figure()
ax = fig.add_subplot(111)#画子图用的。就是画布fig里面可以有好多子图
ax.scatter(datingData[:,1],datingData[:,2],8*array(datingLable),array(datingLable))
#scatter(x,y,size,color) 前两个表示坐标轴,第三表示点的大小。第四个是颜色

在这里插入图片描述
航空里程和冰激凌量的对于喜爱程度的可视化。

ax.scatter(datingData[:,0],datingData[:,2],8*array(datingLable),array(datingLable))
plt.show()

在这里插入图片描述

航空里程和游戏时间的对于喜爱程度的可视化。

plt.scatter(datingData[:,0],datingData[:,1],8*array(datingLable),array(datingLable))
plt.show()

在这里插入图片描述(题外话:这些数据细思极恐,哈哈哈哈哈哈哈哈哈哈)

归一化数值

先说什么是归一化,就是把上面列举的那些参数都处理在0到1之间,或者-1到1。

= 归一化结果= \frac{当前数值-最小值}{最大值-最小值}

为什么要归一化,因为飞行距离的数据数量级大概是千和万左右的数量级。而其他两者则是十位或者个位数。这就导致算距离的结果严重受飞行距离的影响。也就是该参数占得权重太大了。因而为了让三者参数平衡,所以进行归一化。下面的程序和结果可以看到,归一化之后的数据样式。

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
print(autoNorm(datingData))
(array([[0.44832535, 0.39805139, 0.56233353],
       [0.15873259, 0.34195467, 0.98724416],
       [0.28542943, 0.06892523, 0.47449629],
       ...,
       [0.29115949, 0.50910294, 0.51079493],
       [0.52711097, 0.43665451, 0.4290048 ],
       [0.47940793, 0.3768091 , 0.78571804]]), array([9.1273000e+04, 2.0919349e+01, 1.6943610e+00]), array([0.      , 0.      , 0.001156]))

数据集设置好之后,就开始分类了。classify0这个函数就是一开始简单例子中的代码。

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.items(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]



hoRatio=0.1
datingData,datingLable=file2matrix('data/datingTestSet.txt')
normMat,ranges,minVals=autoNorm(datingData)
m=normMat.shape[0]
numTestVecs = int(m*hoRatio) 
errorCount=0.0
for i in range(numTestVecs): 
    classifierResult = classify0(normMat[i,:],normMat[numTestVecs-1:m,:],datingLable[numTestVecs-1:m],3)
    print ("the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLable[i]))
    if (classifierResult != datingLable[i]): errorCount += 1.0
print( "the total error rate is: %f" % (errorCount/float(numTestVecs))) 
    
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 3, the real answer is: 3
...
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the total error rate is: 0.040000

手写数字识别

在这里插入图片描述
数据是这样的,数据下载:https://github.com/pbharrin/machinelearninginaction/blob/master/Ch02/digits.zip

如果把1代表是黑色,0是白色,一个数据是一个像素点。这样就可以形成手写内容。k近邻的分类可以想象成把训练集的数据0-9的模样和测试数据求距离。这个距离其实可以代表图片的重合度。距离短重合度高,这样来识别。

首先先读取将这些数据读取为向量。

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
testVector= img2vector('data/testDigits/0_13.txt')
testVector[0,32:63]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1.,
       1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

之后进行分类。每个文件就是一个数字,分为训练和测试集,其文件名都是采用数字和编号进行编码。也就是说上图编码为0_1.txt。按照这样的方式编码,所以我们取出“_”前面的数字作为标签。

from os import listdir
def handwritingClassTest():
    hwLabels=[]
    trainingFileList = listdir('data/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('data/trainingDigits/%s' % fileNameStr)
    testFileList =  listdir('data/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('data/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.0
    print ("\nthe total number of errors is: %d" % errorCount)
    print ("\nthe total error rate is: %f" % (errorCount/float(mTest)))
    
handwritingClassTest()
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
...
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9

the total number of errors is: 10

the total error rate is: 0.010571
2019-01-03 18:59:13 weixin_41919646 阅读数 166
  • 阿里云机器学习算法应用实践

    人工智能的商业化应用是下一个风口,阿里云在机器学习算法方面有许多沉淀。本次分享首先是介绍阿里云机器学习PAI,接着会在上面搭建真实的案例,包括心脏病预测、新闻分类等场景。

    13773 人正在学习 去看看 CSDN讲师

K临近算法实现

最近开始学习机器学习算法,这是我写的第一篇博客,主要为了记录自己每天学习了什么,课程内容来自于慕课网。

首先导入我们需要用到的numpy 和 matplotlib函数库

import numpy as np
import matplotlib.pyplot as plt

训练数据集

raw_data_X=[[3.393533211,2.331273381],
           [3.110073483,1.781539638],
           [1.343808831,3.368360954],
           [3.582294042,4.679179110],
           [2.280362439,2.866990263],
           [7.423436942,4.696522875],
           [5.745051997,3.533989803],
           [9.172168622,2.511101045],
           [7.792783481,3.424088941],
           [7.939820817,0.791637231]
           ]
raw_data_y=[0,0,0,0,0,1,1,1,1,1]
x_train=np.array(raw_data_X)
x_train
y_train=np.array(raw_data_y)
y_train

数据可视化,通过散点图来标记不同类别

plt.scatter(x_train[y_train==0,0],x_train[y_train==0,1],color='g')
plt.scatter(x_train[y_train==1,0],x_train[y_train==1,1],color='r')
plt.show()

shuj

添加测试点,用蓝色标记进行可视化

x=np.array([8.093607318,3.365731514])
plt.scatter(x_train[y_train==0,0],x_train[y_train==0,1],color='g')
plt.scatter(x_train[y_train==1,0],x_train[y_train==1,1],color='r')
plt.scatter(x[0],x[1],color='b')
plt.show()

在这里插入图片描述

KNN过程


//距离
from math import sqrt
distances=[sqrt(np.sum((x_train-x)**2)) for x_train in x_train]
distances
//最近距离
nearest=np.argsort(distances)
nearest
k=6
//最近6个点的y值
topk_y=[y_train[i] for i in nearest[:k]]
topk_y
//计算相同y值个数
from collections import Counter
votes=Counter(topk_y)
//选出个数最多的y值,即为预测值
predict=votes.most_common(1)[0][0]
predict

一篇自己的读书笔记,如有错误欢迎批评指教,如有侵权删。

2015-08-06 17:13:42 xcc_xing99 阅读数 654
  • 阿里云机器学习算法应用实践

    人工智能的商业化应用是下一个风口,阿里云在机器学习算法方面有许多沉淀。本次分享首先是介绍阿里云机器学习PAI,接着会在上面搭建真实的案例,包括心脏病预测、新闻分类等场景。

    13773 人正在学习 去看看 CSDN讲师

官方用书:机器学习实战(Machine Learning in Action)


好了,下面继续。

第2章主要讲述了k临近(k-NearestNeighbor算法,所以关于算法本身的思想就不在赘述,不了解的同学请参考下面的百度百科链接:http://baike.baidu.com/link?url=k1Md78fE3ETrLyDYwL8-3 度娘的解释已经很全面了,本编重点在书中例题的实现,和解释。

2.1.1 准备:使用Python导入数据

首先创建一个名为knn.py的文件,可以存放在电脑的任意位置,接下来打开knn.py 编写我们的代码。

from numpy import*
import operator

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

如果有同学不了解numpy或者operator模块的话,建议先百度一下,后面会有用(本博有关于operator的官方教程翻译)。


接下来我们测试一下这个代码:

打开终端,进入knn.py的文件目录 再进入python


如果可以和图片中的一样顺利运行的话,恭喜,knn.py已经完成。

2.1.2 实施knn算法

接下来我们在knn.py里继续编写 ,我们要写的是最主要的算法:knn算法

def classify0(inX,dataSet,labels,k):
	dataSetsize=dataSet.shape[0]
	diffMat=tile(inX,(dataSetsize,1))-dataSet
	sqDiffMat=diffMat**2
	sqDistance=sqDiffMat.sum(axis=1)
	distance=sqDistance**0.5
	sortedDistanceIndicies=distance.argsort()
	classCount={}
	for i in range(k):
		voteIlabel=labels[sortedDistanceIndicies[i]]
		classCount[voteIlabel]=classCount.get(voteIlabel,0)+1
	sortedClassCount=sorted(classCount.iteritems(),key=operator.itemgetter(1),reverse=True)
	return sortedClassCount[0][0]
这里就用到了operator 和 numpy 库里的函数了,不了解的赶快去补补。

接下来我们测试一下:

from knn import*

group,label=createDataSet()
print classify0([0.5,0.5],group,label,3)
运行下来的结果应该是B吧,如果是B,那么恭喜你,完成编写!


通过上面,我们就实现了一个最简单,最基础的knn算法。

2.2.1 准备数据:从文件中解析数据

在knn.py中添加下面的代码,使其可以从文件中读入数据:

def filematrix(filename):
	fin=open(filename)
	arryofLines=fin.readlines()
	numberofLines=len(arryofLines)
	returnMat=zeros((numberofLines,3))
	classLabelvector=[]
	index=0
	for line in arryofLines:
		line=line.strip()
		listFromLine=line.split('\t')
		returnMat[index,:]=listFromLine[0:3]
		classLabelvector.append(int(listFromLine[-1]))
		index+=1
	return returnMat.classLabelvector
可见使用python进行文件操作还是很方便的。







k-临近算法学习

阅读数 15

K临近算法

阅读数 1428

没有更多推荐了,返回首页