精华内容
下载资源
问答
  • knn最近邻算法 目录: (Table of Contents:) What is KNN? 什么是KNN? Working of KNN algorithm KNN算法的工作 What happens when K changes? 当K变化时会发生什么? How to select appropriate K? 如何选择合适的...

    knn最近邻算法

    目录: (Table of Contents:)

    1. What is KNN?

      什么是KNN?
    2. Working of KNN algorithm

      KNN算法的工作
    3. What happens when K changes?

      当K变化时会发生什么?
    4. How to select appropriate K?

      如何选择合适的K?
    5. Limitation of KNN

      KNN的局限性
    6. Real-world application of KNN

      KNN的实际应用
    7. Conclusion

      结论

    1.什么是KNN? (1. What is KNN?)

    K nearest neighbors (KNN) is a supervised machine learning algorithm. A supervised machine learning algorithm’s goal is to learn a function such that f(X) = Y where X is the input, and Y is the output. KNN can be used both for classification as well as regression. In this article, we will only talk about classification. Although for regression, there is just a minute change.

    K最近邻居(KNN)是一种受监督的机器学习算法。 监督式机器学习算法的目标是学习一个函数,使得f(X)= Y,其中X是输入,Y是输出。 KNN可用于分类和回归。 在本文中,我们仅讨论分类。 尽管要进行回归,但只有一分钟的变化。

    The properties of KNN is that it is a lazy learning algorithm and a non-parametric method.

    KNN的特性是它是一种惰性学习算法和非参数方法。

    Lazy learning means the algorithm takes almost zero time to learn because it only stores the data of the training part (no learning of a function). The stored data will then be used for the evaluation of a new query point.

    惰性学习意味着该算法几乎只需花费零时间进行学习,因为它仅存储训练部分的数据(不学习功能)。 然后,存储的数据将用于评估新的查询点。

    The non-parametric method refers to a method that does not assume any distribution. Therefore, KNN does not have to find any parameter for the distribution. While in the parametric method, the model finds new parameters, which in turn will be used for the prediction purpose. The only hyperparameter (provided by the user to the model) KNN has is K, which is the number of points that needs to be considered for comparison purpose.

    非参数方法是指不假定任何分布的方法。 因此,KNN不必为分布找到任何参数。 在参数化方法中,模型会找到新参数,这些参数又将用于预测目的。 KNN唯一的超参数(由用户提供给模型)是K,这是比较目的需要考虑的点数。

    Image for post
    Source资源

    In the above image, yellow is the query point, and we want to know which class it belongs to (red or green).

    在上图中,黄色是查询点,我们想知道它属于哪个类(红色或绿色)。

    With K=3, the 3 nearest neighbors of the yellow point are considered, and the class is assigned to the query point based on the majority (e.g., 2 green and 1 red — then it is of green class). Similarly, for K=5, 5 nearest neighbors are considered for the comparison, and the majority will decide which class the query point belongs to. One thing to notice here, if the value of K is even, it might create problems when taking a majority vote because the data has an even number of classes (i.e., 2). Therefore, choose K as an odd number when the data has an even number of classes and even number when the data has an odd number of classes.

    在K = 3的情况下,考虑了黄点的3个最近邻居,并且基于多数(例如2个绿色和1个红色-那么它是绿色类别)将类别分配给查询点。 类似地,对于K = 5,将考虑5个最近的邻居进行比较,并且大多数将决定查询点属于哪个类。 这里要注意的一件事是,如果K的值为偶数,则在多数表决中可能会产生问题,因为数据具有偶数个类(即2)。 因此,当数据具有偶数个类别时,选择K作为奇数;当数据具有奇数个类别时,选择K作为奇数。

    2. KNN算法的工作 (2. Working of KNN algorithm)

    In the training phase, the model will store the data points. In the testing phase, the distance from the query point to the points from the training phase is calculated to classify each point in the test dataset. Various distances can be calculated, but the most popular one is the Euclidean distance (for smaller dimension data).

    在训练阶段,模型将存储数据点。 在测试阶段,计算从查询点到训练阶段的点之间的距离,以对测试数据集中的每个点进行分类。 可以计算各种距离,但是最流行的是欧几里得距离(用于较小尺寸的数据)。

    Euclidean distance between a query point (q) and a training data point (p) is defined as

    查询点(q)和训练数据点(p)之间的欧式距离定义为

    Image for post
    Source资源

    Other distance measures such as Manhattan, Hamming, and Chebyshev distance can also be used based on the data, which is out of the scope of this article.

    也可以根据数据使用其他距离度量,例如Manhattan,Hamming和Chebyshev距离,这不在本文的讨论范围之内。

    Let’s learn it with an example:

    让我们用一个例子来学习它:

    We have 500 N-dimensional points, with 300 being class 0 and 200 being class 1.

    我们有500个N维点,其中300个是0类,而200个是1类。

    The procedure for calculating the class of query point is:

    计算查询点类别的过程是:

    1. The distance of all the 500 points is calculated from the query point.

      从查询点算出所有500个点的距离。
    2. Based on the value of K, K nearest neighbors are used for the comparison purpose.

      基于K的值,将K个最近的邻居用于比较目的。
    3. Let’s say K=7, 4 out of 7 points are of class 0, and 3 are of class 1. Then based on the majority, the query point p is assigned as class 0.

      假设K = 7,则7个点中有4个是0类,而3个是1类。然后基于多数,将查询点p分配为0类。

    3. K改变时会发生什么? (3. What happens when K changes?)

    Image for post
    Decision Surface separating the red and blue class with k=1 (left) and k=5 (right). Image by author
    决策面用k = 1(左)和k = 5(右)分隔红色和蓝色类。 图片作者

    K=1 means that it will take one nearest neighbor and classify the query point based on that. The surface that divides the classes will be very uneven (many vertices).

    K = 1表示它将采用一个最近的邻居,并根据该邻居对查询点进行分类。 划分类别的表面将非常不平坦(许多顶点)。

    The problem that arises here is if an outlier is present in the data, the decision surface considers that as a data point. Due to this, KNN will perform exceptionally well on the training dataset but will misclassify many points on the test dataset (unseen data). This is considered as overfitting, and therefore, KNN is sensitive to outliers.

    此处出现的问题是,如果数据中存在异常值,则决策面会将其视为数据点。 因此,KNN将在训练数据集上表现异常出色,但会错误分类测试数据集上的许多点(看不见的数据)。 这被认为是过度拟合,因此,KNN对异常值敏感。

    As the value of K increases, the surface becomes smooth and will not consider the outliers as data points. This will better generalize the model on the test dataset also.

    随着K值的增加,表面变得平滑,并且不会将离群值视为数据点。 这也将更好地将模型推广到测试数据集。

    If K value is extremely large, the model will underfit and will be unable to classify the new data point. For example, if K is equal to the total number of data points, no matter where the query point lies, the model will always classify the query point based on the majority class of the whole dataset.

    如果K值非常大,则模型将无法拟合,并且将无法对新数据点进行分类。 例如,如果K等于数据点的总数,则无论查询点位于何处,模型都将始终基于整个数据集的多数类对查询点进行分类。

    Choosing a correct value K will give accurate results. But how to choose that?

    选择正确的值K将得出准确的结果。 但是如何选择呢?

    4.如何选择合适的K? (4. How to select appropriate K?)

    In real-world problems, the dataset is separated into three parts, namely, training, validation, and test data. In KNN, the training data points get stored, and no learning is performed. Validation data is to check the model performance, and the test data is used for prediction.

    在实际问题中,数据集分为三个部分,即训练,验证和测试数据。 在KNN中,将存储训练数据点,并且不执行任何学习。 验证数据用于检查模型性能,测试数据用于预测。

    To select optimal K, plot the error of model (error = 1 — accuracy) on training as well as on the validation dataset. The best K is where the validation error is lowest, and both training and validation errors are close to each other.

    要选择最佳K,请在训练以及验证数据集上绘制模型误差(误差= 1-精度)。 最佳K是验证误差最低的地方,训练和验证误差彼此接近。

    Image for post
    Source来源

    5. KNN的局限性 (5. Limitation of KNN)

    Time complexity and space complexity is enormous, which is a major disadvantage of KNN. Time complexity refers to the time model takes to evaluate the class of the query point. Space complexity refers to the total memory used by the algorithm. If we have n data points in training and each point is of m dimension. Then time complexity is of order O(nm), which will be huge if we have higher dimension data. Therefore, KNN is not suitable for high dimensional data.

    时间复杂度和空间复杂度是巨大的,这是KNN的主要缺点。 时间复杂度是指时间模型用来评估查询点的类。 空间复杂度是指算法使用的总内存。 如果我们在训练中有n个数据点,而每个点都是m维。 然后,时间复杂度约为O(nm),如果我们具有更高维度的数据,它将非常庞大。 因此,KNN不适合用于高维数据。

    Another disadvantage is if the data point is far away from the classes present (no similarity), KNN will classify the point even if it is an outlier. In order to overcome the problem of time complexity, algorithms such as KD-Tree and Locality Sensitive Hashing (LSH) can be used, which is not covered in this article.

    另一个缺点是,如果数据点与现有的类相距太远(没有相似性),则KNN将对点进行分类,即使它是一个异常值也是如此。 为了克服时间复杂性的问题,可以使用诸如KD-Tree和本地敏感哈希(LSH)之类的算法,本文不做介绍。

    6. KNN的实际应用 (6. Real-world application of KNN)

    1. KNN can be used for Recommendation Systems. Although in the real world, more sophisticated algorithms are used for the recommendation system. KNN is not suitable for high dimensional data, but KNN is an excellent baseline approach for the systems. Many companies make a personalized recommendation for its consumers, such as Netflix, Amazon, YouTube, and many more.

      KNN可用于推荐系统。 尽管在现实世界中,推荐系统仍使用更复杂的算法。 KNN不适合用于高维数据,但是KNN是系统的出色基线方法。 许多公司为其消费者提供个性化推荐,例如Netflix,亚马逊,YouTube等。
    2. KNN can search for semantically similar documents. Each document is considered as a vector. If documents are close to each other, that means the documents contain identical topics.

      KNN可以搜索语义相似的文档。 每个文档都被视为向量。 如果文档彼此靠近,则意味着文档包含相同的主题。
    3. KNN can be effectively used in detecting outliers. One such example is Credit Card fraud detection.

      KNN可以有效地用于检测异常值。 这样的例子之一就是信用卡欺诈检测。

    7.结论 (7. Conclusion)

    K- Nearest Neighbors (KNN) identifies the nearest neighbors given the value of K. It is lazy learning and non-parametric algorithm. KNN works on low dimension dataset while faces problems when dealing with high dimensional data.

    K-最近邻居(KNN)在给定K值的情况下识别最近邻居。这是惰性学习和非参数算法。 KNN适用于低维数据集,但在处理高维数据时会遇到问题。

    翻译自: https://towardsdatascience.com/k-nearest-neighbors-knn-algorithm-23832490e3f4

    knn最近邻算法

    展开全文
  • KNN最近邻算法

    2019-10-02 08:04:32
    K最近邻(K-Nearest Neighbor,KNN)算法,是著名的模式识别统计学方法,在机器学习分类算法中占有相当大的地位。它是一个理论上比较成熟的方法。既是最简单的机器学习算法之一,也是基于实例的学习方法中最基本的,又...

    算法概述

    K最近邻(K-Nearest Neighbor,KNN)算法,是著名的模式识别统计学方法,在机器学习分类算法中占有相当大的地位。它是一个理论上比较成熟的方法。既是最简单的机器学习算法之一,也是基于实例的学习方法中最基本的,又是最好的文本分类算法之一。

    基本思想

    如果一个实例在特征空间中的K个最相似(即特征空间中最近邻)的实例中的大多数属于某一个类别,则该实例也属于这个类别。所选择的邻居都是已经正确分类的实例。
    该算法假定所有的实例对应于N维欧式空间中的一个点。通过计算一个点与其他所有点之间的距离,取出与该点最近的K个点,然后统计这K个点里面所属分类比例最大的,则这个点属于该分类。
    该算法涉及3个主要因素:实例集、距离或相似的衡量、k的大小。
    一个实例的最近邻是根据标准欧氏距离定义的。更精确地讲,把任意的实例x表示为下面的特征向量:

    (x1,x2,x3....,xn)其中xi表示为该实例的第i个属性。

    基本思想

    如果一个实例在特征空间中的K个最相似(即特征空间中最近邻)的实例中的大多数属于某一个类别,则该实例也属于这个类别。所选择的邻居都是已经正确分类的实例。
    该算法假定所有的实例对应于N维欧式空间Ân中的点。通过计算一个点与其他所有点之间的距离,取出与该点最近的K个点,然后统计这K个点里面所属分类比例最大的,则这个点属于该分类。
    该算法涉及3个主要因素:实例集、距离或相似的衡量、k的大小。
    一个实例的最近邻是根据标准欧氏距离定义的。更精确地讲,把任意的实例x表示为下面的特征向量:

    kNN算法图例

    简单来说,KNN可以看成:有那么一堆你已经知道分类的数据,然后当一个新数据进入的时候,就开始跟训练数据里的每个点求距离,然后挑离这个训练数据最近的K个点看看这几个点属于什么类型,然后用少数服从多数的原则,给新数据归类。

     

    KNN算法的决策过程

    下图中有两种类型的样本数据,一类是蓝色的正方形,另一类是红色的三角形,中间那个绿色的圆形是待分类数据:

    KNN算法的决策过程图例

    如果K=3,那么离绿色点最近的有2个红色的三角形和1个蓝色的正方形,这三个点进行投票,于是绿色的待分类点就属于红色的三角形。而如果K=5,那么离绿色点最近的有2个红色的三角形和3个蓝色的正方形,这五个点进行投票,于是绿色的待分类点就属于蓝色的正方形

     

    距离加权最近邻算法

    对k-最近邻算法的一个显而易见的改进是对k个近邻的贡献加权,根据它们相对查询点xq的距离,将较大的权值赋给较近的近邻。加权欧氏距离公式。在传统的欧氏距离中,各特征的权重相同,也就是认定各个特征对于分类的贡献是相同的,显然这是不符合实际情况的。同等的权重使得特征向量之间相似度计算不够准确, 进而影响分类精度。加权欧氏距离公式,特征权重通过灵敏度方法获得(根据业务需求调整,例如关键字加权、词性加权等)

    如果使用按距离加权,那么允许所有的训练样例影响xq的分类事实上没有坏处,因为非常远的实例对(xq)的影响很小。考虑所有样例的惟一不足是会使分类运行得更慢。如果分类一个新的查询实例时考虑所有的训练样例,我们称此为全局(global)法。如果仅考虑最靠近的训练样例,我们称此为局部(local)法。

     

    KNN的优缺点

    (1)优点

    ①简单,易于理解,易于实现,无需参数估计,无需训练;
    ②精度高,对异常值不敏感(个别噪音数据对结果的影响不是很大);
    ③适合对稀有事件进行分类;
    ④特别适合于多分类问题(multi-modal,对象具有多个类别标签),KNN要比SVM表现要好.
    (2)缺点
    ①对测试样本分类时的计算量大,空间开销大,因为对每一个待分类的文本都要计算它到全体已知样本的距离,才能求得它的K个最近邻点。目前常用的解决方法是事先对已知样本点进行剪辑,事先去除对分类作用不大的样本;
    ②可解释性差,无法给出决策树那样的规则;
    ③最大的缺点是当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数。该算法只计算“最近的”邻居样本,某一类的样本数量很大,那么或者这类样本并不接近目标样本,或者这类样本很靠近目标样本。无论怎样,数量并不能影响运行结果。可以采用权值的方法(和该样本距离小的邻居权值大)来改进;
    ④消极学习方法。

     

    对k-近邻算法的说明

     

    按距离加权的k-近邻算法是一种非常有效的归纳推理方法。它对训练数据中的噪声有很好的鲁棒性,而且当给定足够大的训练集合时它也非常有效。注意通过取k个近邻的加权平均,可以消除孤立的噪声样例的影响。
    问题一:近邻间的距离会被大量的不相关属性所支配。
    应用k-近邻算法的一个实践问题是,实例间的距离是根据实例的所有属性(也就是包含实例的欧氏空间的所有坐标轴)计算的。这与那些只选择全部实例属性的一个子集的方法不同,例如决策树学习系统。
    比如这样一个问题:每个实例由20个属性描述,但在这些属性中仅有2个与它的分类是有关。在这种情况下,这两个相关属性的值一致的实例可能在这个20维的实例空间中相距很远。结果,依赖这20个属性的相似性度量会误导k-近邻算法的分类。近邻间的距离会被大量的不相关属性所支配。这种由于存在很多不相关属性所导致的难题,有时被称为维度灾难(curse of dimensionality)。最近邻方法对这个问题特别敏感。
    解决方法:当计算两个实例间的距离时对每个属性加权。
    这相当于按比例缩放欧氏空间中的坐标轴,缩短对应于不太相关属性的坐标轴,拉长对应于更相关的属性的坐标轴。每个坐标轴应伸展的数量可以通过交叉验证的方法自动决定。
    问题二:应用k-近邻算法的另外一个实践问题是如何建立高效的索引。因为这个算法推迟所有的处理,直到接收到一个新的查询,所以处理每个新查询可能需要大量的计算。
    解决方法:目前已经开发了很多方法用来对存储的训练样例进行索引,以便在增加一定存储开销情况下更高效地确定最近邻。一种索引方法是kd-tree(Bentley 1975;Friedman et al. 1977),它把实例存储在树的叶结点内,邻近的实例存储在同一个或附近的结点内。通过测试新查询xq的选定属性,树的内部结点把查询xq排列到相关的叶结点。

     

    Python实现KNN

    import numpy as np
    
    
    class KNearestNeighbor(object):
        def __init__(self, datas=None, targets=None, predict_sample=None, k=3):
            self.datas = datas
            self.targets = targets
            self.predict_sample = predict_sample
            self.k = k
            self.dis = np.zeros(self.targets.shape)
            self.distance()
            self.k_dis = {}
            self.predict_label = self.predict()
            print(self.predict_label)
    
        def distance(self):
            for i in range(len(self.targets)):
                self.dis[i] = sum([x * x for x in (self.datas[i] - self.predict_sample)])
    
        def predict(self):
            loc = np.argsort(self.dis)[:self.k]
            for i in range(len(loc)):
                if self.targets[loc[i]] in self.k_dis.keys():
                    self.k_dis[self.targets[loc[i]]] += 1
                else:
                    self.k_dis[self.targets[loc[i]]] = 1
            key, value = self.targets[loc[0]], self.k_dis[self.targets[loc[0]]]
            for k, v in self.k_dis.items():
                if value < v:
                    key, value = k, v
            return key

    用python实现的knn代码处理一下sklearn中的iris数据集

    #! /usr/bin/env python
    # -*- coding:utf-8 -*-
    import numpy as np
    from sklearn.datasets import load_iris
    
    
    class KNearestNeighbor(object):
        def __init__(self, datas=None, targets=None, predict_sample=None, k=3):
            self.datas = datas
            self.targets = targets
            self.predict_sample = predict_sample
            self.k = k
            self.dis = np.zeros(self.targets.shape)
            self.distance()
            self.k_dis = {}
            self.predict_label = self.predict()
            print(self.predict_label)
    
        def distance(self):
            for i in range(len(self.targets)):
                self.dis[i] = sum([x * x for x in (self.datas[i] - self.predict_sample)])
    
        def predict(self):
            loc = np.argsort(self.dis)[:self.k]
            for i in range(len(loc)):
                if self.targets[loc[i]] in self.k_dis.keys():
                    self.k_dis[self.targets[loc[i]]] += 1
                else:
                    self.k_dis[self.targets[loc[i]]] = 1
            key, value = self.targets[loc[0]], self.k_dis[self.targets[loc[0]]]
            for k, v in self.k_dis.items():
                if value < v:
                    key, value = k, v
            return key
    
    
    def main():
        datas, targets = load_iris().data, load_iris().target
        error_times = 0
        for i in range(len(datas)):
            predict_sample = datas[i]
            knn = KNearestNeighbor(datas, targets, predict_sample)
            print(targets[i])
            print("***************")
            if knn.predict_label != targets[i]:
                error_times +=1
        print("error times: ", error_times)
    
    
    if __name__ == '__main__':
        main()

     

    转载于:https://www.cnblogs.com/pythonlearing/p/9955315.html

    展开全文
  • kNN最近邻算法

    2019-06-20 17:07:12
    邻近算法,或者说K最近邻(kNN,k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻,就是k个最近的邻居的意思,说的是每个样本都可以用它最接近的k个邻居来代表。 kNN算法的核心思想是...

    百度百科:
    邻近算法,或者说K最近邻(kNN,k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻,就是k个最近的邻居的意思,说的是每个样本都可以用它最接近的k个邻居来代表。
    kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别,则该样本也属于这个类别,并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。 kNN方法在类别决策时,只与极少量的相邻样本有关。由于kNN方法主要靠周围有限的邻近的样本,而不是靠判别类域的方法来确定所属类别的,因此对于类域的交叉或重叠较多的待分样本集来说,kNN方法较其他方法更为适合。
    1.分析算法
    该算法首先需要取一个参数K,假设取的K为3,对于每个新的样本点,K邻近算法就是再所有样本中找离这个新点最近的三个点,统计三个点所属类别,然后统计出数量最多的那个类别,就是新样本的类别
    2.数学理论
    通过分析K邻近算法,邻近就是计算两者之间的距离,常用的计算距离的公式一般用欧氏距离:
    在这里插入图片描述

    二维空间中两个点的距离等于x,y两坐标差的平方和在开根
    在这里插入图片描述

    import numpy  as  np
    ##十个样本点,两列值分别是颜色深度和酒精浓度,前5个都是红酒类型,后5个都是啤酒类型
    X_sample=[[14.23,5.64],
           [13.2,4.38],
           [13.16,5.68],
           [14.37,4.80],
           [13.24,4.32],
           [12.07,2.76],
           [12.43,3.94],
           [11.79,3.0],
           [12.37,2.12],
           [12.04,2.6]]
    ##0表示红酒,1表示啤酒
    y_sample=[0,0,0,0,0,1,1,1,1,1]
    
    ##在机器学习值中常用的numpy的array数组而不是列别list,因为array速度快也能执行向量运算
    ##新的一杯酒的信息:
    x_test=np.array([12.8,4.1])
    ##样本点的数组形式
    X_train=np.array(X_sample)
    ##样本类型的数组形式
    y_train=np.array(y_sample)
    
    ##有了x,y坐标就可以绘制一张散点图
    import matplotlib.pyplot  as  plt
    # 使用自带的样式进行美化
    plt.style.use('ggplot')
    ##表示figure 的大小为宽、长(单位为英寸),关于参数可分析源代码
    plt.figure(figsize=(10,6))
    
    plt.scatter(X_train[y_train==1,0],X_train[y_train==1,1],s=100,c='g',label='啤酒')
    plt.scatter(X_train[y_train==0,0],X_train[y_train==0,1],s=100,c='r',label='红酒')
    plt.scatter(x_test[0],x_test[1],s=100,c='y')
    
    ##显示中文
    from pylab import *
    ##this is the instance used by the matplotlib classes
    
    ##指定字体
    mpl.rcParams['font.sans-serif'] = ['SimSun']
    
    
    ##将True改为False,作用就是解决负号'-'显示为方块的问题
    plt.rcParams['axes.unicode_minus']=False
    
    ##x轴名称
    plt.xlabel('酒精浓度')
    ##y轴名称
    plt.ylabel('颜色浓度')
    ##显示图例 添加数据的是后写入label参数
    plt.legend(loc='lower right')
    ##plt.tight_layout()会自动调整子图参数,使之填充整个图像区域,不会出现图重叠之类的问题
    plt.tight_layout()
    
    plt.savefig('酒的样本.png')
    
    
    ##计算距离的公式由很多,一般常用欧式距离:二维空间中两个点的距离等于x,y两坐标差的平方和在开根
    from math import sqrt
    ##根据欧拉公式计算新样本点到每个样本点的距离
    distances=[sqrt(np.sum((x-x_test)**2))for x in X_train]
    # print(distances)
    
    ##接着找出距离新样本最近的3个点
    
    ##np.argsort()返回样本点的索引位置
    sort=np.argsort(distances)
    
    ##通过索引值就能在y_train找出酒的类型,再统计排名前3的
    
    top=[y_train[i] for  i in sort[:3]]
    print(top)
    ##获取数组中数量最多的元素,也就是最频繁的那个元素
    ##1.max方法:
    s=max(top, key=top.count)
    print(s)
    ##2.用collections包的Counter函数
    from collections  import  Counter
    v=Counter(top).most_common(1)[0][0]
    if v==0:
           print("新样本为:红酒")
    else:
           print("新样本为啤酒")
    

    ##结果:

    在这里插入图片描述

    [1, 0, 0]
    0
    新样本为:红酒
    

    遇到的问题:
    matplotlib.pyplot作出的图不显示中文

    解决:

    ##查看matplotlib下fonts
    [kiosk@asimov ~/anaconda3/envs/python3/lib/python3.6/site-packages/matplotlib/mpl-data/fonts/ttf]$ ls   
    cmb10.ttf                       LICENSE_DEJAVU
    cmex10.ttf                      LICENSE_STIX
    cmmi10.ttf                      local.conf
    cmr10.ttf                       STIXGeneralBolIta.ttf
    cmss10.ttf                      STIXGeneralBol.ttf
    cmsy10.ttf                      STIXGeneralItalic.ttf
    /home/kiosk/anaconda3/envs/python3/lib/python3.6/site-packages/matplotlib/mpl-data/fonts/ttf
    
    [root@asimov ~]#fc-list :lang=zh  ##查找本地 中文字体
    /usr/share/fonts/wqy-microhei/wqy-microhei.ttc: WenQuanYi Micro Hei Mono,文泉驛>等寬微米黑,文泉驿等宽微米黑:style=Regular
    
    ##下载个宋体的ttf字体并解压
    
    [root@asimov /home/kiosk/repod]#cp  simsun.ttf  /usr/share/fonts/simsun/
    ##安装字体:
    [root@asimov /usr/share/fonts/simsun]#mkfontscale
    [root@asimov /usr/share/fonts/simsun]#mkfontdir
    [root@asimov /usr/share/fonts/simsun]#fc-cache
    [root@asimov /usr/share/fonts/simsun]#ls
    fonts.dir  fonts.scale  simsun.ttf
    
    [root@asimov ~]#fc-list :lang=zh
    /usr/share/fonts/simsun/simsun.ttf: SimSun,宋体
    ##将simsun.ttf cp到matplotlib的字体库中
    [root@asimov /usr/share/fonts/simsun]#cp  simsun.ttf /home/kiosk/anaconda3/envs/python3/lib/python3.6/site-packages/matplotlib/mpl-data/fonts/ttf
    ##删除matplotlib的缓存目录
    [kiosk@asimov ~/.cache]$ rm   -fr  matplotlib/
    ##指定字体,然后运行代码就可以显示中文了
    mpl.rcParams['font.sans-serif'] = ['SimSun']
    

    参考博客:https://blog.csdn.net/dgatiger/article/details/50414549

    展开全文
  • KNN最近邻算法java实现

    2017-04-25 18:56:20
    KNN最近邻算法java实现
  • knn最近邻算法是一种分类以及回归算法,算法原理是一个样本与样本集中k个样本最相似,如果这k个样本的大多数也属于同一个类别,则该样本也属于这一类。关于knn算法的详细原理读者可以在网上找一些资料了解下,这里...

    knn最近邻算法是一种分类以及回归算法,算法原理是一个样本与样本集中k个样本最相似,如果这k个样本的大多数也属于同一个类别,则该样本也属于这一类。关于knn算法的详细原理读者可以在网上找一些资料了解下,这里主要介绍使用knn进行mnist手写数字的识别。
    关于mnist数据的解析,读者可以自己从网上下载相应压缩文件,用python自己编写解析代码,由于这里主要研究knn算法,为了图简单,直接使用Keras的mnist手写数字解析模块。
    本次代码运行环境为:
    python 3.6.8
    opencv-python 4.4.0.46
    opencv-contrib-python 4.4.0.46
    以下是使用knn进行手写数字的训练代码:

    import cv2
    import numpy as np
    from keras.datasets import mnist
    from keras import utils
    
    if __name__=='__main__':
    
        #直接使用Keras载入的训练数据(60000, 28, 28) (60000,)
        (train_images,train_labels),(test_images,test_labels)=mnist.load_data()
        #变换数据的形状并归一化
        train_images=train_images.reshape(train_images.shape[0],-1)#(60000, 784)
        train_images=train_images.astype('float32')/255
    
        test_images=test_images.reshape(test_images.shape[0],-1)
        test_images=test_images.astype('float32')/255
        
        #将标签数据转为float32
        train_labels=train_labels.astype(np.float32)
        test_labels=test_labels.astype(np.float32)
    
        #传入knn的训练数据形状为(60000, 784) 训练标签为(60000,)
    
         #创建knn对象
        knn=cv2.ml.KNearest_create()
        #设置k值 默认的k=10
        knn.setDefaultK(5)
        #设置是分类还是回归
        knn.setIsClassifier(True)
    
        #开始训练
        knn.train(train_images,cv2.ml.ROW_SAMPLE,train_labels)
        
        #手写数字识别保存的knn模型非常大 有两百多兆
        knn.save('mnist_knn.xml')
    
        #进行模型准确率的测试 结果是一个元组 第一个值为数据1的结果
        test_pre=knn.predict(test_images)
        test_ret=test_pre[1]
    
        #计算准确率
        test_ret=test_ret.reshape(-1,)
        test_sum=(test_ret==test_labels)
        acc=test_sum.mean()
        print(acc)
    

    使用knn进行手写数字训练后,得到了一个knn模型,这个模型文件有两百多兆,这也是knn算法的弊端,训练数据比较多,模型就会很大。
    在这里插入图片描述
    这个模型在测试数据上的准确率为0.9688,算的上非常高的准确率了,接下来使用这个knn模型进行单个手写数字的识别。
    识别如下这上手写数字图片:
    在这里插入图片描述
    对手写数字图片进行识别的代码如下:

    import cv2
    import numpy as np
    
    if __name__=='__main__':
        #读取图片
        img=cv2.imread('shuzi.jpg',0)
        img_sw=img.copy()
    
        #将数据类型由uint8转为float32
        img=img.astype(np.float32)
        #图片形状由(28,28)转为(784,)
        img=img.reshape(-1,)
        #增加一个维度变为(1,784)
        img=img.reshape(1,-1)
        #图片数据归一化
        img=img/255
    
        #载入knn模型
        knn=cv2.ml.KNearest_load('mnist_knn.xml')
        #进行预测
        img_pre=knn.predict(img)
        print(img_pre[1])
    
        cv2.imshow('test',img_sw)
        cv2.waitKey(0)
    

    运行结果为:
    在这里插入图片描述
    由此可见,成功识别了该张手写数字图片。

    展开全文
  • 本次要整理记录的笔记是关于KNN最近邻算法,以及利用KNN最近邻算法实现手写体数字识别的相关内容。 首先先了解一下什么是KNN最近邻算法,下面引用维基百科的定义: 在模式识别领域中,最近邻居法(KNN算法,又译K-...
  • KNN最近邻算法理解

    千次阅读 2019-03-20 21:54:39
    k-最近邻算法是基于实例的学习方法中最基本的,先介绍基于实例学习的相关概念。 基于实例的学习 已知一系列的训练样例,很多学习方法为目标函数建立起明确的一般化描述;但与此不同,基于实例的学习方法只是简单地...
  • knn最近邻算法(有监督学习)KNN算法缺点例子数据可视化sklearn实现 KNN 对有标签的数据进行分类。计算所有样本和x的距离,得到距离最近的k(k为超参数)个样本点,哪种类别占据多数,x就被划分为哪一类。 k值一般...
  • KNN最近邻算法(K - Nearest Neighbors)

    千次阅读 2018-07-27 11:27:19
    KNN最近邻算法(K - Nearest Neighbors) K最近邻算法是一种分类算法,算法思想是一个样本与数据集中的K个样本最相似,如果这K个样本中的大多数属于某一类别,则该样本也属于某一类别。 常见KNN的问题 有一个...
  • KNN最近邻算法ppt

    热门讨论 2020-03-30 09:05:05
    是上学期的pre用的ppt,放上来做个留档~
  • 在上一篇博客《OpenCV4学习笔记(54)》中,整理了关于KNN最近邻算法的一些相关内容和一个手写体数字识别的例子。但是上次所实现的手写体数字识别,每次只能固定地输入测试图像进行预测,而且所使用的也是从OpenCV...
  • K近邻(K Nearest Neighbor,KNN),可以做分类,也可以做回归。 一、基本思想 给定一组训练集,有一个需要判断类别的输入实例,离输入实例最近的K个训练数据属于哪个类别,就判断输入实例属于哪个类别。 二...
  • KNN最近邻算法(K-NearestNeighbor)

    千次阅读 2017-01-26 04:03:51
    KNN最邻近算法
  • 元学习论文总结||小样本学习论文总结 2017-2019年计算机视觉顶会文章收录 AAAI2017-...分类 :kNN(k nearest neighbour)最近邻算法(Python) kNN算法概述 kNN算法是比较好理解,也比较容易编写的分类算法。 ...
  • KNN(K-NearestNeighbor)是机器学习入门级的分类算法,非常简单。它实现将距离近的样本点划为同一类别;KNN中的K指的是近邻个数,也就是最近的K个点 ;根据它距离最近的K个点是什么类别来判断属于哪个类别。 KNN...
  • 算法功能 分类(核心功能),回归 算法类型 有监督学习,惰性学习(没有产生模型),距离类模型 数据输入 包含数据标签y,特征空间中至少包含K个训练样本 特征空间中各个特征的量纲需要统一,...
  • 在阅读《图解算法》时,感觉此书对于KNN算法的讲解非常生动形象,故按自己思路重新整理,与大家分享 1.区别一种水果 假设在一张桌子上按水果特征摆着两堆水果。一堆是橙子,一堆是柚子, 现在,在这个桌子的一处...
  • amp;mid=100000162&amp;idx=1&...k-NN是一种基本的分类和回归方法,用于分类时,算法思路较简单:通过计算不同特征之间的距离方法来得到最近的k个训练实例,根据k个实例的类别采用多数表...
  • Python KNN最近邻分类算法

    千次阅读 2016-11-14 23:08:59
    KNN最近邻算法:利用向量之间的距离来分类。 步骤: 第一步:计算新样本与已知分类样本之间的距离。 第二步:将所求距离按从小到大排列。 第三步:选取距离最近的k个样本。 第四步:将新样本归为以上k个样本大多数中...
  • K最近邻(kNN,k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。其指导思想是”近朱者赤,近墨者黑“,即由你的邻居来推断出你的类别。所谓K最近邻,就是k个最近的邻居的意思,说的是每个样本都...
  • KNN K最近邻算法

    2017-03-11 14:02:05
    K Nearest Neighbor,KNN,K最近邻算法。 算法原理: (1)计算未知类别数据点与已知类别数据点之间的距离,并按降序排序。 (2)选取与未知类别数据点距离最小的k个点。 (3)以k个点中出现频率最高的类别...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,662
精华内容 4,264
关键字:

knn最近邻算法