Python语言实现KNN算法

置顶 已于 2023-03-14 22:47:50 修改
阅读量2.1k 收藏 30
点赞数 3
文章标签： python 分类算法 机器学习
于 2019-10-14 15:56:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tida_yake/article/details/102512744
版权

目录

Python语言重写knn算法

前文：这是一个刚入门机器学习和Python语言的 随 缘 记录学习过程的博客。 那我们就开始。

knn算法介绍

knn（k-NearestNeighbor），中译：k最近邻分类算法。算法要完成的事情是：一组已分类数据集，一组待分数据，根据knn算法将待分数据分好类。
明白要做什么，这个过程的分类准则就是knn算法。其核心就是，由近邻数据的类别决定待分数据的类别。
那么判断是否为近邻又由什么决定呢？——距离，确切来说是，欧式距离。空间中有两个点 a(x0, y0)，b(x1, y1) ，两点之间的距离就是欧式距离。公式请自查。
放图说话，下图都是表示knn决策过程。
在这里插入图片描述在这里插入图片描述

其也能进行回归分析，详细内容请参考近邻算法_百度百科，点击这里。

算法步骤及实现

具体实现参考了近邻算法_百度百科，下面将算法步骤和算法实现放在一起。

数据结构

数据存取方式采用操作列表的方式，这里考虑的是熟练度。当然推荐选择导入 Numpy ，操作效率更高。

算法流程图

在这里插入图片描述

1.训练集和测试集

先获取训练集数据和测试集数据，实现过程中先采用的训练集和测试集是，自编的简单数据。

myDataset = {'data':[[2, 3, 0, 0], [3, 4, 0, 0], [4, 5, 0, 0], [5, 6, 0, 0]],
             'target':[2, 1, 0, 1]}
X_train, y_train = myDataset['data'], myDataset['target']
X_test = [[1, 2, 0, 0],[0, 0, 0, 0]]

具体真正使用的训练集和测试集是，鸢尾花数据集。

iris_dataset = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris_dataset['data'], iris_dataset['target'], random_state=0)

2.设定k值

k值，是决定了待测数据 X_test 会有 k 个邻居。

def __init__(self, n_neighbors):
	'''指定近邻个数'''
	self.n_neighbors = n_neighbors # 近邻数
	# self.x_new = [] # 预测数据集

3.创建预先序列

百科中第四步，优先级队列在本文名为：预先序列 。预先序列其实就是近邻序列，其大小等于 k ，具体说是，预先序列计算处理得到的距离的预先序列 distList 。关于创建预先序列的用途，我的理解是，当 k > 1时，即待分数据会有 k 个邻居时，在不采用预先序列的情况下，同样的，会产生一个 k 大小的近邻序列，并且在生成序列过程中第 i ( i < k ) 个数据都需要进行判断数据是否需要更新。而采用了预先序列，每次比大小的两方，一个是训练数据集，另一个就会变成 distList 中的最大值，更新最大值即可，会减少判断次数。
使用每个数据的ID(索引)建立预先序列

 self.idList = random.sample(range(0, len(x_train)), self.n_neighbors) # 获取空间大小为k的预先序列,k个随机的元组,k=n_neighbors

计算距离

def get_deftDist(self, tp):
    '''计算测试数据与预先序列的距离'''
    list = [] # 存放预测数据与预先序列的距离，列表含有k个距离
    '''
    for i in range(len(self.x_new)):
        tp = self.x_new[i]
    '''
    for j in range(len(self.idList)):
        sum = 0
        index = self.idList[j]
        for k in range(len(tp)):
            sum += (tp[k]-self.x_train[index][k])**2 
        sum = math.sqrt(sum)
        list.append(sum)
    return list

4.更新预先序列

遍历训练集，计算当前训练集数据 X_traini 与待分数据 X_testj 的距离 L ，比较 L 与预先的最大距离 LMax 大小，若大于，直接进入下一训练集数据 X_traini+1 ，若小于，将 LMax 对应的序列数据替换成 X_traini 。
在需要替换时，其实还需要一步判断，在构建预先序列时，K个随机值构成的 idList 可能已经包含了当前训练集数据 X_train_i 的索引值即 i ，所以如果替换元素的话，近邻队列不就出现1或多个重复的元素了吗？，那么分类应该会有误差。参考百科中的第 6 步，似乎没有考虑到。
解决上文提到的 “ 判断 ” 

if j not in self.idList:
	index = distList.index(Lmax) # 获取最大预先距离的索引
	self.idList[index] = j # 换为当前训练数据的id
	distList[index] = L # 更新最大预先距离

算法当前步骤所有代码

distList = self.get_deftDist(tp) # 获取此时测试数据x_new[i]与预先序列的距离
for j in range(len(self.x_train)):
	Lmax = max(distList)
	L = 0
	for k in range(len(self.x_train[j])):
	    L += (tp[k]-self.x_train[j][k])**2 # 遍历训练集，计算当前x_new[i]训练集与x_train[j]的距离
	L = math.sqrt(L)
	if L >= Lmax:
	    continue # 若当前所得距离大于预先序列距离的最大值，进入下一个训练数据
	else:
	    # 更新预先序列中的距离和对应训练数据的id
	    if j not in self.idList:
	        index = distList.index(Lmax) # 获取最大预先距离的索引
	        self.idList[index] = j # 换为当前训练数据的id
	        distList[index] = L # 更新最大预先距离

5.获取测试集所属类

遍历最后的近邻序列，选择出其中多数类，得出测试数据集的所需类。

flag = [0, 0, 0]
	for m in range(len(self.idList)): # 遍历预先序列中，计算其中的多数类，判断测试数据属于哪类
	    indI = self.idList[m]
	    targetI = self.y_train[indI]
	    if targetI == 0:
	        flag[0] += 1
	    elif targetI == 1:
	        flag[1] += 1
	    elif targetI == 2:
	        flag[2] += 1
	    #print(flag)
	#print('测试数据所属类: ', flag.index(max(flag)))
	targetList.append(flag.index(max(flag))) # 返回第一个极大值的索引值

预测模型的精准度

除了上述knn算法的五个步骤外，还额外添加了计算模型的精确值的方法 score() 。

def score(self, y_pre, y_test):
	'''计算精确值'''
	count = 0
	scoreList = list(map(lambda x: x[0]-x[1], zip(y_pre, y_test)))
	for i in scoreList:
	    if i == 0:
	        count += 1
	score = count/len(scoreList)
	return score

完整代码

算法结构是仿照 KNeighborsClassifier的使用过程。

knn = KNeighborsClassifier(n_neighbors=31) #设定近邻指标

knn.fit(X_train, y_train)

y_pre = knn.predict(X_test)

score = knn.score(X_test, y_test)
KNeighborsClassifierMyKNNMykNN的方法功能
–init–()–init–()设定近邻个数
fit()get_trainData()获取训练集数据
predict()predict()产生预测模型
score()score()计算精确度
完整knn代码
import random
import time
import math

#import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

class MyKNN:
    
    def __init__(self, n_neighbors):
        '''指定近邻个数'''
        self.n_neighbors = n_neighbors # 近邻数
        # self.x_new = [] # 预测数据集
           
    def predict(self, x_new):
        '''预测模型, 更新近邻序列和得出测试数据所属类'''
        targetList = [] # 存储预测数据的预测所属类
        for i in range(len(x_new)):
            tp = x_new[i]
            #print(tp)
            distList = self.get_deftDist(tp) # 获取此时测试数据x_new[i]与预先序列的距离
            for j in range(len(self.x_train)):
                Lmax = max(distList)
                L = 0
                for k in range(len(self.x_train[j])):
                    L += (tp[k]-self.x_train[j][k])**2 # 遍历训练集，计算当前x_new[i]训练集与x_train[j]的距离
                L = math.sqrt(L)
                if L >= Lmax:
                    continue # 若当前所得距离大于预先序列距离的最大值，进入下一个训练数据
                else:
                    # 更新预先序列中的距离和对应训练数据的id
                    if j not in self.idList:
                        index = distList.index(Lmax) # 获取最大预先距离的索引
                        self.idList[index] = j # 换为当前训练数据的id
                        distList[index] = L # 更新最大预先距离
                #distList[i].append(L)
        #return sorted(distList)
            flag = [0, 0, 0]
            for m in range(len(self.idList)): # 遍历预先序列中，计算其中的多数类，判断测试数据属于哪类
                indI = self.idList[m]
                targetI = self.y_train[indI]
                if targetI == 0:
                    flag[0] += 1
                elif targetI == 1:
                    flag[1] += 1
                elif targetI == 2:
                    flag[2] += 1
                #print(flag)
            #print('测试数据所属类: ', flag.index(max(flag)))
            targetList.append(flag.index(max(flag))) # 返回第一个极大值的索引值
            #print('the distance:\n{}'.format(self.distList))
        return targetList
            
    def get_trainData(self, x_train, y_train):
        '''获取训练集数据'''
        self.x_train = x_train
        self.y_train = y_train
        self.idList = random.sample(range(0, len(x_train)), self.n_neighbors) ''' 获取空间大小为k的预先序列,k个随机的元         	
        组,k=n_neighbors'''
        #self.deftDic = {'id':self.idList, 'distance':self.distList, 'target':self.y_train}
        
    def get_deftDist(self, tp):
        '''计算测试数据与预先序列的距离'''
        list = [] # 存放预测数据与预先序列的距离，列表含有k个距离
        '''
        for i in range(len(self.x_new)):
            tp = self.x_new[i]
        '''
        for j in range(len(self.idList)):
            sum = 0
            index = self.idList[j]
            for k in range(len(tp)):
                sum += (tp[k]-self.x_train[index][k])**2 
            sum = math.sqrt(sum)
            list.append(sum)
        return list
    
    def score(self, y_pre, y_test):
        '''计算精确值'''
        count = 0
        scoreList = list(map(lambda x: x[0]-x[1], zip(y_pre, y_test)))
        for i in scoreList:
            if i == 0:
                count += 1
        score = count/len(scoreList)
        return score

#myDataset = {'data':[[2, 3, 0, 0], [3, 4, 0, 0], [4, 5, 0, 0], [5, 6, 0, 0]],
#             'target':[2, 1, 0, 1]}
#X_train, y_train = myDataset['data'], myDataset['target']
#X_test = [[1, 2, 0, 0],[0, 0, 0, 0]]
        
iris_dataset = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris_dataset['data'], iris_dataset['target'], random_state=0)

start = time.time()      

knn = MyKNN(n_neighbors=1)

knn.get_trainData(X_train, y_train)
y_pre = knn.predict(X_test)

print('Holding time: ', time.time()-start) # 输出KNN运行时间，时间效率
print('the kind of X_test:\n{}'.format(y_pre)) # 输出测试数据的预测类别
print('the score:{:.2}'.format(knn.score(y_pre, y_test))) # 输出模型精准度
tida_yake
关注
  • 3
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
python实现KNN算法
07-25
内含数据集。先执行cut_data.py划分训练集和测试集，再执行main.py即可。
手写算法-python代码实现自定义的KNN
weixin_44700798的博客
12-13 3544
手写算法-python代码实现自定义的KNN普通KNN存在的问题自定义权重python代码实现sklearn的KNN库对比 普通KNN存在的问题 上篇文章，我们梳理了一下KNN，其中谈到一个问题： 做分类任务时，K个近邻数据，到样本的距离都不一样，但是我们都一视同仁，统计最大样本数对应的y标签，作为预测标签，这样明显不太合理，例如： import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import make_cla
KNN算法的Python实现
最新发布
m0_74864756的博客
04-02 607
K近邻算法（K-Nearest Neighbors，KNN）是一种基本的机器学习算法，也是一种分类和回归方法。它的原理很简单，即根据特征相似度来进行分类或回归预测。K近邻（K-Nearest Neighbor, KNN）是一种最经典和最简单的有监督学习方法之一。在KNN算法中，首先需要给定一个训练集，其中包含了已知分类标签的样本数据。然后，通过计算待预测样本与训练集中各个样本的特征距离，选择与待预测样本最相似的K个训练样本（即K个最近邻）
python实现KNN算法（公式推导+源代码）
11-16 7186
今天这篇文章要介绍的是KNN（k近邻算法），这是一种简单的分类算法，它的思想是通过测量不同特征值之间的距离进行分类的。 这样说你可能不太懂，那下面我们就通过一个简单的例子来形象的概述下。 以下面这张图为例，我们在这张图上可以看到有三种不同类别的形状（正方形、圆形、三角形），其中他们的分布也是比较不集中的。 假设我们在内圆里面要判断某个东西是属于哪一类别的话，我们该怎么做呢 ？ 方法很简单，就是在内圆里面选择K个数据离我（图中 ？表示）最近的几个点，然后根据少数服从多数的原则，将多数的类别作为我预
机器语言-Python手动实现knn算法
weixin_42578646的博客
10-14 814
KNN算法 K近邻法(k-nearst neighbors,KNN)是一种很基本的机器学习方法。它的思想是： 在训练集中数据和标签已知的情况下，输入测试数据，将测试数据的特征与训练集中对应的特征进行相互比较，找到训练集中与之最为相似的前K个数据，则该测试数据对应的类别就是K个数据中出现次数最多的那个分类。 kNN算法三要素： k值的选取，距离度量的方式和分类决策规则 KNN算法的步骤： 1、收集数...
knn(k近邻算法)——python
热门推荐
PY洋洋
01-30 2万+
1. 基本定义 2. 算法原理 2.1 算法优缺点 2.2 算法参数 2.3 变种 3.算法中的距离公式 4.案例实现 4.1 导入相关库 4.2 读取数据 4.3 读取变量名 4.4 定义X,Y数据 4.5 分离训练集和测试集 4.6 计算欧式距离 4.7可视化距离矩阵 4.8 预测样本 4.9 查看正确率 4.10 交叉验证 5.scikit-learn的算法实现 5.1 对上述的再次实现： 5.2 另一种实现方式
分类算法KNN的python实现
辉的博客
12-28 3940
KNN算法是有监督学习中的分类算法，它是一种非参的，惰性的算法模型。非参的意思并不是说这个算法不需要参数，而是意味着这个模型不会对数据做出任何的假设，与之相对的是线性回归（我们总会假设线性回归是一条直线）。也就是说KNN建立的模型结构是根据数据来决定的，这也比较符合现实的情况，毕竟在现实中的情况往往与理论上的假设是不相符的。惰性的意思是指模型在使用前不会被训练，只有当使用的时候才会被训练。KNN算法优点： 简单易用，相比其他算法，KNN算是比较简洁明了的算法。即使没有很高的数学基础也能搞清楚它的原理。
K近邻（KNN）原理及python实现
qq_46033892的博客
08-10 3215
knn最近邻入门学习以及python代码实现
机器学习：Python实现KNN算法
m0_52331159的博客
03-25 950
使用Python实现KNN 3 实验背景 本实验将演示使用Python的第三方库Numpy实现KNN算法，对训练样本进行建模，并对待测样本进行类别划分。KNN算法需要确定K值、距离度量和分类决策规则。 5.2 定义KNN函数 5.3 显示待测样本的标签完成分类 提示：shape用法
使用python实现knn算法
12-25
本文实例为大家分享了python实现knn算法的...knn算法实现 数据处理 #从文件中读取数据，返回的数据和分类均为二维数组 def loadDataSet(filename): dataSet = [] labels = [] fr = open(filename) for line in fr.
python可视化实现KNN算法
01-20
这里通过python的绘图工具Matplotlib包可视化实现机器学习中的KNN算法。 需要提前安装python的Numpy和Matplotlib包。 KNN–最近邻分类算法，算法逻辑比较简单，思路如下： 1.设一待分类数据iData,先计算其到已...
Python代码实现KNN算法
09-20
主要为大家详细介绍了Python代码实现KNN算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
【机器学习】两种方法实现KNN算法：纯Python实现 + 调用Sklearn库实现（使用Iris数据集）
杨小浩浩的博客
05-25 6494
KNN算法是机器学习中一种常见的监督学习方法，对于初学者来说比较友善。本文首先介绍KNN算法的基础知识，再介绍两种方法实现KNN算法。 目录算法简介数据集简介纯Python实现调用Sklearn库实现 算法简介 算法步骤： 计算已知类别数据集中的点与当前点之间的距离； 按照距离递增次序排序； 选取与当前点距离最小的k个点； 确定前k个点所在类别的出现频率； 返回前k个点出现频率最高的类别作为当前点的预测分类。 算法中的距离共分为两种： 数据集简介 鸢尾花（Iris）数据集是机器学习中应用比较广泛的数
KNN（python实现）
Nick
12-19 2568
kNN算法流程 一般情况下，kNN有如下流程：  （1）收集数据：确定训练样本集合测试数据；  （2）计算测试数据和训练样本集中每个样本数据的距离； 常用的距离计算公式：  欧式距离公式：d(x,y)=∑ni=1(xi−yi)2−−−−−−−−−−−−√d(x,y)=∑i=1n(xi−yi)2  曼哈顿距离公式：d(x,y)=∑ni=1|xi−yi|d(x,y)=∑i=1n|xi−yi| （...
用python实现KNN算法
技术宅--火狼的专栏
04-22 5739
KNN简介 KNN(K-nearest neighbor)，即K近邻算法。当需要表示一个样本（值）的时候，就使用于该样本最接近的K个邻居来决定。KNN即可以用于分类，也可以用于回归。 数据集地址 https://vincentarelbundock.github.io/Rdatasets/csv/datasets/iris.csv RNN算法 # -*- coding:utf-8 -*- import numpy as np class KNN: def __init__(self,k):
Python实现KNN算法（附源码）
不断学习，不断进步，提高自己
05-31 4053
本篇我们将讨论一种广泛使用的分类技术，称为k邻近算法，或者说K最近邻(KNN，k-Nearest Neighbor)。所谓K最近邻，是k个最近的邻居的意思，即每个样本都可以用它最接近的k个邻居来代表。01、KNN算法思想如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。KNN方法在类别决策时，只与极少量的相邻样本有关。
Python实现KNN算法
qq_62945476的博客
03-25 1万+
KNN算法
python实现knn算法案例_Python实现的knn算法示例
05-13
以下是 Python 实现的 KNN 算法示例： ```python import numpy as np class KNN: def __init__(self, k=3): self.k = k def fit(self, X, y): self.X = X self.y = y def predict(self, X): y_pred = [] for x in X: distances = np.sqrt(np.sum((self.X - x)**2, axis=1)) indices = np.argsort(distances)[:self.k] labels = self.y[indices] y_pred.append(max(labels, key=list(labels).count)) return y_pred ``` 其中，`KNN` 类有三个方法： - `__init__(self, k=3)`：初始化方法，参数 `k` 为最近邻的个数，默认为 3。 - `fit(self, X, y)`：训练方法，参数 `X` 为训练数据，`y` 为标签。 - `predict(self, X)`：预测方法，参数 `X` 为测试数据，返回预测结果。 在该实现中，使用了 `numpy` 库计算欧氏距离和排序。`np.argsort()` 函数返回数组中元素从小到大排序后对应的索引，因此取前 `k` 个索引即为最近邻的索引。最后，返回最近邻中出现最多的标签作为预测结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值