python中knn函数 pythonknn算法

新手学习PYTHON中KNN算法的手写识别出现问题 求助

参考了其他博主的代码 想试着运行 然后去理解。结果一直报错，希望大神帮帮忙。

import numpy as np

import os

import kNN

def img2vector(filename):

"""函数将以文本格式出现的32*32的0-1图片，转变成一维特征数组，返回一维数组

Keyword argument:

filename -- 文本格式的图片文件

"""

imgvect = np.zeros((1, 1024))

fr = open(filename)

for i in range(32):

linestr = fr.readline()

for j in range(32):

imgvect[0, 32*i + j] = int(linestr[j])

return imgvect

def handwriteClassfiy(testfile, trainfile, k):

"""函数将trainfile中的文本图片转换成样本特征集和样本类型集，用testfile中的测试样本测试，无返回值

Keyword argument:

testfile -- 测试图片目录

trainfile -- 样本图片目录

"""

trainFileList = os.listdir(trainfile)

trainFileSize = len(trainFileList)

labels = []

trainDataSet = np.zeros((trainFileSize, 1024))

for i in range(trainFileSize):

filenameStr = trainFileList[i]

digitnameStr = filenameStr.split('.')[0]

digitLabels = digitnameStr.split('_')[0]

labels.append(digitLabels)

trainDataSet[i, :] = img2vector(trainfile + '/' + filenameStr)

testFileList = os.listdir(testfile)

testNumber = len(testFileList)

errorcount = 0.0

for testname in testFileList:

testdigit = img2vector(testfile + '/' + testname)

classifyresult = kNN.classfiy(testdigit, trainDataSet, labels, k)

testStr = testname.split('.')[0]

testDigitLabel = testStr.split('_')[0]

if classifyresult != testDigitLabel:

errorcount += 1.0

#print('this test real digit is：%s, and the result is: %s' % (testDigitLabel, classifyresult))

print('k = %d, errorRatio is: %f' % (k, errorcount/float(testNumber)))

return

if __name__ == '__main__':

filename = 'C:/Users/lx/Desktop/MachineLearning-master/kNN/use Python and NumPy/testDigits/0_1.txt'

traindir= 'C:/Users/lx/Desktop/MachineLearning-master/kNN/use Python and NumPy/trainingDigits'

testdir = 'C:/Users/lx/Desktop/MachineLearning-master/kNN/use Python and NumPy/testDigits'

handwriteClassfiy(testdir, traindir, 3)

错误提示Traceback (most recent call last):

File "kNN.py", line 56, in module

handwriteClassfiy(testdir, traindir, 3)

File "kNN.py", line 43, in handwriteClassfiy

classifyresult = kNN.classfiy(testdigit, trainDataSet, labels, k)

AttributeError: module 'kNN' has no attribute 'classfiy'

你这个文件是不是就叫 kNN.py ？如果是的话那你这个里面根本就没有 classfiy 这个属性，当然会报错。

另外，import kNN 是 import 自己？

相关问答

Q1: 简单数字识别(knn算法)

knn算法，即k-NearestNeighbor，后面的nn意思是最近邻的意思，前面的k是前k个的意思，就是找到前k个离得最近的元素

离得最近这个词具体实现有很多种，我使用的是欧式几何中的距离公式

二维中两点x(x1,y1),y(x2,y2)间距离公式为sqrt( (x1-x2)^2+(y1-y2)^2 )

推广到n维就是

x(x1,x2, … ,xn),y(y1,y2, … ,yn)

sqrt [ ∑( x[i] - y[i] )^2 ] (i=1,2, … ,n)

knn算法是要计算距离的，也就是数字之间的运算，而图像是png，jpg这种格式，并不是数字也不能直接参与运算，所以我们需要进行一下转换

如图所示一个数字8，首先要确定的是这一步我做的是一个最简单的转换，因为我假定背景和图之间是没有杂物的，而且整个图只有一个数字（0-9）如果遇到其他情况，比如背景色不纯或者有其他干扰图像需要重新设计转换函数

接下来就是最简单的转换，将图片白色部分（背景）变0，有图像的部分变1。转换后的大小要合适，太小会影响识别准确度，太大会增加计算量。所以我用的是书上的32*32，转换后结果如图所示

这样一来，图片就变成了能进行计算的数字了。

接下来我们需要创建一个库，这个库里面存着0-9这些数字的各种类似上图的实例。因为我们待识别的图像要进行对比，选出前k个最近的，比较的对象就是我们的库。假定库中有0-9十个数字，每个数字各有100个这种由0和1表示的实例，那么我们就有了一共1000个实例。

最后一步就是进行对比，利用开头说的欧式几何距离计算公式，首先这个32*32的方阵要转换成一个1*1024的1024维坐标表示，然后拿这个待识别的图像和库中的1000个实例进行距离计算，选出前k个距离最近的。比如50个，这50个里面出现次数最多的数字除以50就是结果数字的概率。比如50个里面数字8出现40次，那么待识别数字是8的可能性就是40/50 = 80%

个人理解：

只能识别单个数字，背景不能有干扰。如果想多数字识别或者背景有干扰需要针对具体情况考虑具体的图像转01的方法。

数字识别非常依赖库中的图像，库中的图像的样子严重影响图像的识别（因为我们是和库中的一一对比找出距离最近的前k个），所以数字的粗细，高低，胖瘦等待都是决定性因素，建库时一定全面考虑数字的可能样子

计算量比较大，待识别图像要和库中所有实例一一计算，如果使用32*32，就已经是1024维了。如果库中有1000个，那就是1024维向量之间的1000次计算，图像更清晰，库更丰富只会使计算量更大

对于其他可以直接计算距离的数值型问题，可以用欧式距离，也可以用其他能代表距离的计算公式，对于非数值型的问题需要进行合适的转换，转换方式很重要，我觉得首先信息不能丢失，其次要精确不能模糊，要实现图片转换前后是一对一的关系

参考资料：机器学习实战 [美] Peter Harrington 人民邮电出版社

python源码

import numpy

import os

from PIL import Image

import heapq

from collections import Counter

def pictureconvert(filename1,filename2,size=(32,32)):

    #filename1待识别图像，filename2 待识别图像转换为01txt文件输出，size图像大小，默认32*32

    image_file = Image.open(filename1)

    image_file = image_file.resize(size)

    width,height = image_file.size

    f1 = open(filename1,'r')

    f2 = open(filename2,'w')

    for i in range(height):

        for j in range(width):

            pixel = image_file.getpixel((j,i))

            pixel = pixel[0] + pixel[1] + pixel[2]

            if(pixel == 0):

                pixel = 0

            elif(pixel != 765 and pixel != 0):

                pixel = 1

            # 0代表黑色（无图像），255代表白色（有图像）

            # 0/255 = 0,255/255 = 1

            f2.write(str(pixel))

            if(j == width-1):

                f2.write('\n')

    f1.close()

    f2.close()

def imgvector(filename):

    #filename将待识别图像的01txt文件转换为向量

    vector = numpy.zeros((1,1024),numpy.int)

    with open(filename) as f:

        for i in range(0,32):

            linestr = f.readline()

            for j in range(0,32):

                vector[0,32*i+j] = int(linestr[j])

    return  vector

def compare(filename1,filename2):

    #compare直接读取资源库识别

    #filename1资源库目录，filename2 待识别图像01txt文档路径

    trainingfilelist = os.listdir(filename1)

    m = len(trainingfilelist)

    labelvector = []

    trainingmatrix = numpy.zeros((m, 1024), numpy.int8)

    for i in range(0,m):

        filenamestr = trainingfilelist[i]

        filestr = filenamestr.split('.')[0]

        classnumber = int(filestr.split('_')[0])

        labelvector.append(classnumber)

        trainingmatrix[i,:] = imgvector(filename1 + '/' + filenamestr)

    textvector = imgvector(filename2)

    resultdistance = numpy.zeros((1,m))

    result = []

    for i in range(0,m):

        resultdistance[0,i] = numpy.vdot(textvector[0],trainingmatrix[i])

    resultindices = heapq.nlargest(50,range(0,len(resultdistance[0])),resultdistance[0].take)

    for i in resultindices:

        result.append(labelvector[i])

    number = Counter(result).most_common(1)

    print('此数字是',number[0][0],'的可能性是','%.2f%%' % ((number[0][1]/len(result))*100))

def distinguish(filename1,filename2,filename3,size=(32,32)):

    # filename1 png，jpg等格式原始图像路径，filename2 原始图像转换成01txt文件路径，filename3 资源库路径

    pictureconvert(filename1,filename2,size)

    compare(filename3,filename2)

url1 = "/Users/wang/Desktop/number.png"

url2 = "/Users/wang/Desktop/number.txt"

traininglibrary = "/Users/wang/Documents/trainingDigits"

distinguish(url1,url2,traininglibrary)

Q2: 如何用python实现knn算法

1. 数据分类：离散型标签 2. 数据回归：连续型标签 近邻算法python中knn函数的准则是：寻找接近新数据点python中knn函数的训练样本的数目python中knn函数，根据训练样本的信息来预测新数据点的某些信息。

Q3: python之k-近邻算法（sklearn版）

上文借用了numpy和pandas等模块自编了k-近邻算法 python之k-近邻算法（非sklearn版） ，这次借用sklearn轮子来实现一下

数据还是用上篇文章的数据来

上篇文章我们是利用KNN.py中的自编函数panduan在读取数据的过程中来实现的，而这种转变在sklearn中已经有轮子调用了

这里再补充一点：对于类别数据(对于特征值也是适用的),可以分为 标称特征（nominal feature） 和 有序特征(ordinal feature) .

对于我们这里的数据largeDoses，smallDoses，didntLike应该是对应着有序特征

如果在这里'喜欢的类别'本身不带有有序的含义的话，即largeDoses，smallDoses，didntLike三个类别没有序别之分，可以借用sklearn里的功能

可以看到借用sklearn是比较方便的

但是。。。。。但是。。。。以上的0,1,2在算法看来依然是有顺序的，所以我们可以利用 独热编码（one-hot encoding） ，即创建一个新的虚拟特征（dummy feature）

也可以利用pandas里的功能

————————————————————————————————————

特征缩放（feature scaling）对于除了决策树和随机森林两个算法没用以外，对其他算法和优化算法来讲都是必不可少的

即上篇文章所涉及到的

对于线性模型来讲，标准化更加好，一是符合线性模型对权重的处理，二是保留了异常值的信息

———————————————————————————————————

上篇文章对于此类问题的处理见 datingClassTest 函数

K-近邻算法被称之为 惰性算法 ，和其他机器学习算法不一样，因为他仅仅是对训练数据集有记忆功能，而不是从训练集中通过学习得到一个判别函数，即不需要训练，看过上篇文章的小伙伴应该会有体会。 缺点是计算复杂度会随着样本数量的增长而呈线性增长，除非数据集中特征数量有限

Q4: PyOD主要算法（KNN、IForest 和 MCD）的原理及使用

Python Outlier Detection（PyOD）是当下最流行python中knn函数的Python异常检测工具库（toolkit）。该工具库的主要亮点包括python中knn函数：

对于特征空间中的一个样本，如果与之最相似的（即特征空间中距离最近的）k个样本中的大多数都属于某一类别，则该样本的分类结果也是这个类别。

① 什么叫做KD_tree

K：K邻近查询中的k；D：空间是D维空间（Demension）tree：二叉树

② 建树过程

K-D tree的建立就是分裂空间的过程

首先，我们对整个区间 [1 , 15] 建树：先计算区间中所有点在第一维（也就是 x 坐标）上的方差：

平均值 ： ave_1 =5.4

方差 ： varance_1 =9.04

再计算区间中所有点在第二维（也就是 y 坐标）上的方差：

平均值：ave_2 =6.8

方差：varance_2 =10.96

明显看见，varance_2 varance_1 ，那么我们在本次建树中， 分裂方式 ：split_method =2 ， 再将所有的点按照第2维的大小 从小到大排序 ，得到python中knn函数了新的点的一个排列：

（4,2） （1,4） （5,8） （7,9） （10,11）

取中间的点作为分裂点 sorted_mid =（5，8）作为根节点，再把区间 [1 , 2] 建成左子树 , [4 , 5] 建成右子树，此时，直线 ： y = 8 将平面分裂成了两半，前面一半给左儿子，后面一半给了右儿子，如图：

建左子树 [1, 3] 的时候可以发现，这时候 第一维的方差大 ，分裂方式就是1 ，把区间 [ 1, 2 ] 中的点按照 第一维 的大小，从小到大排序 ，取 中间点（1,4） 根节点，再以区间 [ 2, 2] 建立右子树 得到节点 （4,2）

建右子树 [4 , 5] 的时候可以发现，这时还是第一维的方差大， 于是，我们便得到了这样的一颗二叉树 也就是 K-D tree，它把平面分成了如下的小平面， 使得每个小平面中最多有一个点 ：

③ 查询过程：

查询，其实相当于我们要将一个点“添加”到已经建好的 K-D tree 中，但并不是真的添加进去，只是找到python中knn函数他应该 处于的子空间 即可，所以查询就显得简单的。

每次在一个区间中查询的时候，先看这个区间的 分裂方式 是什么，也就是说，先看这个区间是按照哪一维来分裂的，这样如果这个点对应的那一维上面的值比根节点的小，就在根节点的左子树上进行查询操作，如果是大的话，就在右子树上进查询操作。

每次回溯到了根节点（也就是说，对他的一个子树的查找已经完成了）的时候，判断一下，以该点为圆心，目前 找到的最小距离为半径 ，看是否和分裂区间的那一维所构成的平面相交，要是相交的话，最近点可能还在另一个子树上，所以还要再查询另一个子树，同时，还要看能否用根节点到该点的距离来更新我们的最近距离。为什么是这样的，我们可以用一幅图来说明：

① 原理

为了改进KDtree的二叉树树形结构，并且沿着笛卡尔坐标进行划分的低效率，ball tree将在一系列嵌套的超球体上分割数据。也就是说： 使用超球面而不是超矩形划分区域 。虽然在构建数据结构的花费上大过于KDtree，但是在 高维 甚至很高维的数据上都表现的很高效。

球树递归地将数据划分为 由质心C和半径r定义的节点 ，使得节点中的每个点都位于由r和C定义的超球内。通过使用三角不等式来减少邻居搜索的候选点数量。

② 建树过程

选择一个距离当前圆心最远的观测点A，和距离A最远的观测点B，将圆中所有离这两个点最近的观测点都赋给这两个簇的中心，然后计算每一个簇的中心点和包含所有其所属观测点的最小半径。对包含n个观测点的超圆进行分割，只需要线性的时间。

③ 查询

使用ball tree时，先自上而下找到包含target的叶子结点（c, r），从此结点中找到离它最近的观测点。这个距离就是 最近邻的距离的上界 。检查它的 兄弟结点 中是否包含比这个上界更小的观测点。方法是： 如果目标点距离兄弟结点的圆心的距离d 兄弟节点所在的圆半径R + 前面的上界r，则这个兄弟结点不可能包含所要的观测点 。否则，检查这个兄弟结点是否包含符合条件的观测点。

用一个随机超平面来切割数据空间, 直到每个子空间里面只有一个数据点为止。切割次数的多少可用来区分异常。

iForest 由t个iTree孤立树组成，每个iTree是一个二叉树，其实现步骤如下：

可以看到d最有可能是异常，因为其最早就被孤立（isolated）了。

获得t个iTree之后，iForest 训练就结束，然后我们可以用生成的iForest来评估测试数据了。对于一个训练数据x，我们令其遍历每一棵iTree，然后计算x最终落在每个树第几层（x在树的高度），得到x在每棵树的高度平均值。获得每个测试数据的average path length后，我们可以设置一个阈值，低于此阈值的测试数据即为异常。

IForest具有线性时间复杂度。

IForest不适用于特别高维的数据。

最小协方差行列式（Minimum Covariance Determinant）

论文《Minimum covariance determinant and extensions》中有更详细描述。

论文《A Fast Algorithm for the Minimum Covariance Determinant Estimator》有更详细描述。

关于python中knn函数和pythonknn算法的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。