knn 深度学习_knn深度学习 - CSDN
精华内容
参与话题
  • 深度学习分类算法系列之 -KNN

    千次阅读 2018-07-26 22:07:51
    先看一个实例来体会一下什么叫做KNN。已知一堆数据a和一堆数据0,然后有一个未知数据c,要判断c到底属于a还是0.如果是1NN,就找到离C最近的数据,离哪一个最近,就判断c属于哪一类。如果利用3NN,如下图所示,以c为...

    先看一个实例来体会一下什么叫做KNN。已知一堆数据a和一堆数据0,然后有一个未知数据c,要判断c到底属于a还是0.如果是1NN,就找到离C最近的数据,离哪一个最近,就判断c属于哪一类。如果利用3NN,如下图所示,以c为半径画圆,直到找出三个数为止,分别有一个a,两个0,则说明c属于0.(注意K一定是奇数可以保证不会平票)

    接下来通过一个实例来讲一下KNN

    分类问题:

    一个学生是不是三好学生通过德智体三个方面来进行评价。如果我们的样本空间如下:(所谓样本空间,又叫Training Data,也就是用于机器学习的数据)

       学生编号   向量1 向量2 向量3   是否为三好学生
           赵1      9      8    9          是
           钱2     8      7   8          是
           孙3    4     6   7       不是
          李4    3     5     9      不是
          周5   9   3   9        是
         吴6 2   9  7       ?

     

     

     

     

     

     

     

     

    那么吴6是三好学生不是呢?我们使用KNN算法来判断。假设K=3,K应该是一个奇数,这样可以保证不会有平票,下面是我们计算(2,9,7)到所有点的距离。(距离公式,可以参看K-Means算法中的一些距离定义)

     

       学生编号   向量1 向量2 向量3 到吴六的距离   是否为三好学生
           赵一      9      8    9 (9-2)^{22 ^{}}(9-2)^{2}+(8-9))^{2}+(9-7)^{2}=54          是
           钱二     8    7   8 (8-2)^{2}+(7-9))^{2}+(8-7)^{2}=41          是
           孙三    4     6   7 (4-2)^{2}+(6-9))^{2}+(7-7)^{2}=13       不是
          李四    3     5     9 (3-2)^{2}+(5-9))^{2}+(9-7)^{2}=21      不是
          周五   9   3   9 (9-2)^{2}+(3-9))^{2}+(9-9)^{2}=85        是

     

     

     

     

     

     

     

     

     

     

    离吴六最近的几个人是孙三,李四,钱二,只有钱儿是三好学生,孙三和李四都不是,那么吴六也不是三好学生了,这样就可以把吴六分类为不是三好学生。

    当然利用kNN也可以解决回归问题,但是最大最有效的就是分类问题了。2)对于KNN算法中找到离自己最近的K个点需要使用到最大堆数据结构。也会做出阐述。

    接下来先通过一个实例来使用KNN对MNIST最经典的字符识别做一下分类实验。

    代码如下:

     

    程序说明:1.因为使用的为one_hot编码,故Ytr为n*10的数组,每个数组形式都为【九个0+一个1】的形式,找到Ytr【nn_index】后只需要使用np.argmax()函数找到1所在位置即为数字。

    补充:关于placeholder与reduce_sum的一些问题

    说明:
    reduce_sum() 就是求和,由于求和的对象是tensor,所以是沿着tensor的某些维度求和。函数名中加了reduce是表示求和后会降维,当然可以通过设置参数来保证不降维,但是默认就是要降维的。

    参数解释:
    1)input_tensor:输入的张量。
    2)axis:沿着哪个维度求和。
    对于二维的input_tensor张量,0表示按列求和,1表示按行求和,[0, 1]表示先按列求和再按行求和。
    3)keep_dims:默认值为Flase,表示默认要降维。若设为True,则不降维。
    4)name:名字。
    5)reduction_indices:默认值是None,即把input_tensor降到 0维,也就是一个数。
    对于2维input_tensor,reduction_indices=0时,按列;reduction_indices=1时,按行。
    注意,reduction_indices与axis不能同时设置。

    其中当shape为三维矢量,比如[2,2,3]

    后两维表示矩阵为[2,3]格式的,分为两层

    那么数据格式是这样的。运用在reduce_sum中,如果axis=0,则第一维求和。即上下数分别对应求和。如果axis=1,则第二维求和,即第一行+第二行,求出结果是一行三列。axis=2.则第三维求和,即第一列+第二列+第三列。结果是两行一列

     

    展开全文
  • 机器学习 - knn算法

    2017-07-26 18:56:37
    knn - k近邻算法,是一种利用相似度来对测试样本做出预测的非参数方法。

    knn - k近邻算法,是一种利用相似度来对测试样本做出预测的非参数方法。knn基本算法非常简单,这里主要分析knn算法的不足改进方法。这里用Python实现了一下,并在minist数据集上测试。


    1. 算法实现

    # -*- coding: utf-8 -*-
    """ 
    create_train_test_data & get_all_data: 处理minist数据
    analysis_date_data: 解析date数据
    """
    import os
    import numpy as np
    
    
    def analysis_date_data():
        """ 解析date数据 """
        with open("../data/date_data/datingTestSet.txt", "r") as f:
            rows_data = f.readlines()
            length = len(rows_data)
            data = np.zeros((length, 4))
            for i in range(length):
                data[i,:] = rows_data[i].strip().split("\t")
                
        # norm the date data
        for i in range(0,3):
            data_col0_max = data[:,i].max(axis=0)
            data_col1_min = data[:,i].min(axis=0)
            data[:,i] = (data[:,i] - data_col1_min) / (data_col0_max - data_col1_min)
        return data
    
    
    def create_train_test_data(filesName):
        """ 生成(train_x,train_y), (test_x,test_y) """
        filesNum = len(filesName)
        data = np.zeros((filesNum, 1024), np.int)
        label = []
        for i in range(filesNum):
            label.append(int(filesName[i][0]))
            with open("../data/trainingDigits/" + filesName[i], "r") as f:
                for j in range(32):
                    each_file_row = f.readline().strip("\n")
                    for k in range(32):
                        data[i, 32*j+k] = int(each_file_row[k])
        return data, label
    
    
    def get_all_data():
        """ get训练所需的所有数据, train_x, train_y, test_x """
        train_files_dir = os.listdir("../data/trainingDigits")
        test_files_dir = os.listdir("../data/testDigits")
        
        train_x, train_y = create_train_test_data(train_files_dir)
        test_x, test_y = create_train_test_data(test_files_dir)
        return np.array(train_x), np.array(train_y), np.array(test_x), np.array(test_y)
    
    
    if __name__ == "__main__":
        train_x, train_y, test_x, test_y = get_all_data()


    # -*- coding: utf-8 -*-
    import numpy as np
    import matplotlib.pyplot as plt
    from model.prepare_data import get_all_data
    
    
    class KNN(object):
        def __init__(self, k):
            """ 1. 初始化参数, k代表近邻个数 """
            self.k = k;
            
        def compute_label(self, k_distance):
            """ 在长度为k的列表中寻找出现次数组多的数, 作为预测的label """
            class_label = {}
            length = len(k_distance)
            for i in range(length):
                class_label[k_distance[i]] = class_label.get(k_distance[i], 0) + 1
            return sorted(class_label.items(), key=lambda x: x[1], reverse=True)[0][0]
        
        def predict(self, train_x, train_y, test_x):
            """ 2. predict 
            test_rows: test dataset的样本个数
            prediction: 预测值
            distance: 一个test样本与所有train样本的距离
            argsort_distance: 对distance进行argsort结果
            k_distance
            """
            if isinstance(train_x, np.ndarray) and isinstance(train_y, np.ndarray) and isinstance(test_x, np.ndarray):
                pass
            else:  
                raise(Exception("numpy.ndarray is required for input parameters."))
            
            test_rows = test_x.shape[0]
            prediction = np.zeros((test_rows,), np.int)
            for i in range(test_rows):
                distance = np.sum((test_x[i, :] - train_x)**2, axis=1)
                argsort_distance = np.argsort(distance)
                k_distance = train_y[argsort_distance[0:self.k]]
                prediction[i] = self.compute_label(k_distance)
            return prediction
        
        def compute_precision(self, prediction, test_y):
            """ 3. 计算预测的正确率 """
            if isinstance(test_y, np.ndarray):
                pass
            else:
                raise(Exception("numpy.ndarray is required for input parameters."))
                
            precision = 1 - np.abs(prediction - test_y).sum() / len(prediction)
            return precision
        
        def draw_precision(self, precision):
            """ 4. 画出预测的正确率 """
            plt.figure()
            plt.plot(range(1,len(precision)+1), precision, "y")
            plt.title("precision")
            plt.xlabel("k")
            plt.ylabel("precision")
            plt.ylim((0,1.1))
            return plt
        
    
    if __name__ == "__main__":
        train_x, train_y, test_x, test_y = get_all_data()
        
        precision = []
        for k in range(1,10):
            obj = KNN(k)
            prediction = obj.predict(train_x, train_y, test_x)
            precision.append(obj.compute_precision(prediction, test_y))
            
        obj.draw_precision(precision).show()


    2. 优点 & 缺点

    2.1 优点

    算法原理简单易懂,估计是最简单又流行的机器学习算法。


    2.2 缺点

    1)普通knn算法,极易受到不平衡数据影响。如果某一类本身数据就很少,利用knn进行相似度搜索的时候,几乎无可避免的会将其他类别数据计算进当前类别。

    2)最近邻算法易受噪声数据,脏数据影响,knn避开了这个问题。

    3)需要一次性加载所有数据进内存。

    4)计算量大,由于knn是非参数学习算法,对于每一个测试样本,都要遍历所有训练样本来计算相似度,这对大数据是不可接受的。

    5)不适合大数据处理。


    3. 改进方式

    1)调整不平衡数据。

    2)kd树改进,可以提高搜索效率。



    展开全文
  • 深度学习与计算机视觉系列(2)_图像分类与KNN

    万次阅读 多人点赞 2016-07-27 11:19:13
    图像分类问题这是很久以前就引起关注的一类图像相关问题。 对于一张输入的图片,要判定它属于给定的一些标签/类别中的哪一个。看似很简单的一个问题,这么多年却一直是计算机视觉的一个核心问题。...

    作者: 寒小阳
    时间:2015年11月。
    出处:http://blog.csdn.net/han_xiaoyang/article/details/49949535
    声明:版权所有,转载请注明出处,谢谢

    1. 图像分类问题

    这是人每天自然而然会做的事情,普通到大部分时候,我们都感知不到我们在完成一个个这样的任务。早晨起床洗漱,你要看看洗漱台一堆东西中哪个是杯子,哪个是你的牙刷;吃早餐的时候你要分辨食物和碗碟…
    抽象一下,对于一张输入的图片,要判定它属于给定的一些标签/类别中的哪一个。看似很简单的一个问题,这么多年却一直是计算机视觉的一个核心问题,应用场景也很多。它的重要性还体现在,其实其他的一些计算机视觉的问题(比如说物体定位和识别、图像内容分割等)都可以基于它去完成。

    咱们举个例子从机器学习的角度描述一下这个问题^_^

    计算机拿到一张图片(如下图所示),然后需要给出它对应{猫,狗,帽子,杯子}4类的概率。人类是灰常牛逼的生物,我们一瞥就知道这货是猫。然而对计算机而言,他们是没办法像人一样『看』到整张图片的。对它而言,这是一个3维的大矩阵,包含248*400个像素点,每个像素点又有红绿蓝(RGB)3个颜色通道的值,每个值在0(黑)-255(白)之间,计算机就需要根据这248*400*3=297600个数值去判定这货是『猫』

    猫图像=>矩阵

    1.1 图像识别的难点

    图像识别看似很直接。但实际上包含很多挑战,人类可是经过数亿年的进化才获得如此强大的大脑,对于各种物体有着精准的视觉理解力。总体而言,我们想『教』会计算机去认识一类图,会有下面这样一些困难:

    • 视角不同,每个事物旋转或者侧视最后的构图都完全不同
    • 尺寸大小不统一,相同内容的图片也可大可小
    • 变形,很多东西处于特殊的情形下,会有特殊的摆放和形状
    • 光影等干扰/幻象
    • 背景干扰
    • 同类内的差异(比如椅子有靠椅/吧椅/餐椅/躺椅…)

    图像面临的挑战

    1.2 识别的途径

    首先,大家想想就知道,这个算法并不像『对一个数组排序』或者『求有向图的最短路径』,我们没办法提前制定一个流程和规则去解决。定义『猫』这种动物本身就是一件很难的事情了,更不要说去定义一只猫在图像上的固定表现形式。所以我们寄希望于机器学习,使用『Data-driven approach/数据驱动法』来做做尝试。简单说来,就是对于每个类别,我们都找一定量的图片数据,『喂』给计算机,让它自己去『学习和总结』每一类的图片的特点。对了,这个过程和小盆友学习新鲜事物是一样一样的。『喂』给计算机学习的图片数据就和下图的猫/狗/杯子/帽子一样:

    Data-driven approach

    1.3 机器学习解决图像分类的流程/Pipeline

    整体的流程和普通机器学习完全一致,简单说来,也就下面三步:

    • 输入:我们的给定K个类别的N张图片,作为计算机学习的训练集
    • 学习:让计算机逐张图片地『观察』和『学习』
    • 评估:就像我们上学学了东西要考试检测一样,我们也得考考计算机学得如何,于是我们给定一些计算机不知道类别的图片让它判别,然后再比对我们已知的正确答案。

    2. 最近邻分类器(Nearest Neighbor Classifier)

    先从简单的方法开始说,先提一提最近邻分类器/Nearest Neighbor Classifier,不过事先申明,它和深度学习中的卷积神经网/Convolutional Neural Networks其实一点关系都没有,我们只是从基础到前沿一点一点推进,最近邻是图像识别一个相对简单和基础的实现方式。

    2.1 CIFAR-10

    CIFAR-10是一个非常常用的图像分类数据集。数据集包含60000张32*32像素的小图片,每张图片都有一个类别标注(总共有10类),分成了50000张的训练集和10000张的测试集。如下是一些图片示例:

    CIFAR-10例子

    上图中左边是十个类别和对应的一些示例图片,右边是给定一张图片后,根据像素距离计算出来的,最近的10张图片。

    2.2 基于最近邻的简单图像类别判定

    假如现在用CIFAR-10数据集做训练集,判断一张未知的图片属于CIFAR-10中的哪一类,应该怎么做呢。一个很直观的想法就是,既然我们现在有每个像素点的值,那我们就根据输入图片的这些值,计算和训练集中的图片距离,找最近的图片的类别,作为它的类别,不就行了吗。

    恩,想法很直接,这就是『最近邻』的思想。偷偷说一句,这种直接的做法在图像识别中,其实效果并不是特别好。比如上图是按照这个思想找的最近邻,其实只有3个图片的最近邻是正确的类目。

    即使这样,作为最基础的方法,还是得掌握,我们来简单实现一下吧。我们需要一个图像距离评定准则,比如最简单的方式就是,比对两个图像像素向量之间的l1距离(也叫曼哈顿距离/cityblock距离),公式如下:

    d1(I1,I2)=pIp1Ip2

    其实就是计算了所有像素点之间的差值,然后做了加法,直观的理解如下图:

    矩阵的l1距离

    我们先把数据集读进内存:

    #! /usr/bin/env python
    #coding=utf-8
    import os
    import sys
    import numpy as np
    
    def load_CIFAR_batch(filename):
        """
        cifar-10数据集是分batch存储的,这是载入单个batch
    
        @参数 filename: cifar文件名
        @r返回值: X, Y: cifar batch中的 data 和 labels
        """
    
        with open(filename, 'r') as f:
            datadict=pickle.load(f)
    
            X=datadict['data']
            Y=datadict['labels']
    
            X=X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype("float")
            Y=np.array(Y)
    
            return X, Y
    
    
    def load_CIFAR10(ROOT):
        """
        读取载入整个 CIFAR-10 数据集
    
        @参数 ROOT: 根目录名
        @return: X_train, Y_train: 训练集 data 和 labels
                 X_test, Y_test: 测试集 data 和 labels
        """
    
        xs=[]
        ys=[]
    
        for b in range(1,6):
            f=os.path.join(ROOT, "data_batch_%d" % (b, ))
            X, Y=load_CIFAR_batch(f)
            xs.append(X)
            ys.append(Y)
    
        X_train=np.concatenate(xs)
        Y_train=np.concatenate(ys)
    
        del X, Y
    
        X_test, Y_test=load_CIFAR_batch(os.path.join(ROOT, "test_batch"))
    
        return X_train, Y_train, X_test, Y_test
    
    # 载入训练和测试数据集
    X_train, Y_train, X_test, Y_test = load_CIFAR10('data/cifar10/') 
    # 把32*32*3的多维数组展平
    Xtr_rows = X_train.reshape(X_train.shape[0], 32 * 32 * 3) # Xtr_rows : 50000 x 3072
    Xte_rows = X_test.reshape(X_test.shape[0], 32 * 32 * 3) # Xte_rows : 10000 x 3072

    下面我们实现最近邻的思路:

    class NearestNeighbor:
      def __init__(self):
        pass
    
      def train(self, X, y):
        """ 
        这个地方的训练其实就是把所有的已有图片读取进来 -_-||
        """
        # the nearest neighbor classifier simply remembers all the training data
        self.Xtr = X
        self.ytr = y
    
      def predict(self, X):
        """ 
        所谓的预测过程其实就是扫描所有训练集中的图片,计算距离,取最小的距离对应图片的类目
        """
        num_test = X.shape[0]
        # 要保证维度一致哦
        Ypred = np.zeros(num_test, dtype = self.ytr.dtype)
    
        # 把训练集扫一遍 -_-||
        for i in xrange(num_test):
          # 计算l1距离,并找到最近的图片
          distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)
          min_index = np.argmin(distances) # 取最近图片的下标
          Ypred[i] = self.ytr[min_index] # 记录下label
    
        return Ypred
    
    nn = NearestNeighbor() # 初始化一个最近邻对象
    nn.train(Xtr_rows, Y_train) # 训练...其实就是读取训练集
    Yte_predict = nn.predict(Xte_rows) # 预测
    # 比对标准答案,计算准确率
    print 'accuracy: %f' % ( np.mean(Yte_predict == Y_test) )

    最近邻的思想在CIFAR上得到的准确度为38.6%,我们知道10各类别,我们随机猜测的话准确率差不多是1/10=10%,所以说还是有识别效果的,但是显然这距离人的识别准确率(94%)实在是低太多了,不那么实用。

    2.3 关于最近邻的距离准则

    我们这里用的距离准则是l1距离,实际上除掉l1距离,我们还有很多其他的距离准则。

    • 比如说l2距离(也就是大家熟知的欧氏距离)的计算准则如下:

    d2(I1,I2)=p(Ip1Ip2)2
    • 比如余弦距离计算准则如下:

    1I1I2||I1||||I2||

    更多的距离准则可以参见scipy相关计算页面.

    3. K最近邻分类器(K Nearest Neighbor Classifier)

    这是对最近邻的思想的一个调整。其实我们在使用最近邻分类器分类,扫描CIFAR训练集的时候,会发现,有时候不一定距离最近的和当前图片是同类,但是最近的一些里有很多和当前图片是同类。所以我们自然而然想到,把最近邻扩展为最近的N个临近点,然后统计一下这些点的类目分布,取最多的那个类目作为自己的类别。

    恩,这就是KNN的思想。

    KNN其实是一种特别常用的分类算法。但是有个问题,我们的K值应该取多少呢。换句话说,我们找多少邻居来投票,比较靠谱呢?

    3.1 交叉验证与参数选择

    在现在的场景下,假如我们确定使用KNN来完成图片类别识别问题。我们发现有一些参数是肯定会影响最后的识别结果的,比如:

    • 距离的选择(l1,l2,cos等等)
    • 近邻个数K的取值。

    每组参数下其实都能产生一个新的model,所以这可以视为一个模型选择/model selection问题。而对于模型选择问题,最常用的办法就是在交叉验证集上实验。

    数据总量就那么多,如果我们在test data上做模型参数选择,又用它做效果评估,显然不是那么合理(因为我们的模型参数很有可能是在test data上过拟合的,不能很公正地评估结果)。所以我们通常会把训练数据分为两个部分,一大部分作为训练用,另外一部分就是所谓的cross validation数据集,用来进行模型参数选择的。比如说我们有50000训练图片,我们可以把它分为49000的训练集和1000的交叉验证集。

    # 假定已经有Xtr_rows, Ytr, Xte_rows, Yte了,其中Xtr_rows为50000*3072 矩阵
    Xval_rows = Xtr_rows[:1000, :] # 构建1000的交叉验证集
    Yval = Ytr[:1000]
    Xtr_rows = Xtr_rows[1000:, :] # 保留49000的训练集
    Ytr = Ytr[1000:]
    
    # 设置一些k值,用于试验
    validation_accuracies = []
    for k in [1, 3, 5, 7, 10, 20, 50, 100]:
    
      # 初始化对象
      nn = NearestNeighbor()
      nn.train(Xtr_rows, Ytr)
      # 修改一下predict函数,接受 k 作为参数
      Yval_predict = nn.predict(Xval_rows, k = k)
      acc = np.mean(Yval_predict == Yval)
      print 'accuracy: %f' % (acc,)
    
      # 输出结果
      validation_accuracies.append((k, acc))

    这里提一个在很多地方会看到的概念,叫做k-fold cross-validation,意思其实就是把原始数据分成k份,轮流使用其中k-1份作为训练数据,而剩余的1份作为交叉验证数据(因此其实对于k-fold cross-validation我们会得到k个accuracy)。以下是5-fold cross-validation的一个示例:

    k-fold 交叉验证

    以下是我们使用5-fold cross-validation,取不同的k值时,得到的accuracy曲线(补充一下,因为是5-fold cross-validation,所以在每个k值上有5个取值,我们取其均值作为此时的准确度)

    5-fold 交叉验证

    可以看出大概在k=7左右有最佳的准确度。

    3.2 最近邻方法的优缺点

    K最近邻的优点大家都看出来了,思路非常简单清晰,而且完全不需要训练…不过也正因为如此,最后的predict过程非常耗时,因为要和全部训练集中的图片比对一遍。

    实际应用中,我们其实更加关心实施predict所消耗的时间,如果有一个图像识别app返回结果要半小时一小时,你一定第一时间把它卸了。我们反倒不那么在乎训练时长,训练时间稍微长一点没关系,只要最后应用的时候识别速度快效果好,就很赞。后面会提到的深度神经网络就是这样,深度神经网络解决图像问题时训练是一个相对耗时间的过程,但是识别的过程非常快。

    另外,不得不多说一句的是,优化计算K最近邻时间问题,实际上依旧到现在都是一个非常热门的问题。Approximate Nearest Neighbor (ANN)算法是牺牲掉一小部分的准确度,而提高很大程度的速度,能比较快地找到近似的K最近邻,现在已经有很多这样的库,比如说FLANN.

    最后,我们用一张图来说明一下,用图片像素级别的距离来实现图像类别识别,有其不足之处,我们用一个叫做t-SNE的技术把CIFAR-10的所有图片按两个维度平铺出来,靠得越近的图片表示其像素级别的距离越接近。然而我们瞄一眼,发现,其实靠得最近的并不一定是同类别的。

    像素级别图像距离排列

    其实观察一下,你就会发现,像素级别接近的图片,在整张图的颜色分布上,有很大的共性,然而在图像内容上,有时候也只能无奈地呵呵嗒,毕竟颜色分布相同的不同物体也是非常多的。

    参考资料与原文

    cs231n 图像分类与KNN

    展开全文
  • 深度学习第二课--图像识别与KNN

    千次阅读 2016-06-01 23:03:19
    深度学习第二课–图像识别与KNN

    图像分类的难点

    • 视角不同
    • 尺寸不同
    • 变形
    • 光影
    • 背景干扰
    • 同类内的差异
      例如躺椅、座椅、

    图像识别的核心

    数据驱动学习。就像人看过很多猫以后,就知道什么是猫。把很多同一类的图片“喂给”计算机,让计算机自己去学习该类图片的特征。之后做出评估。
    

    KNN解决图片分类

    利用图片与图片之间的距离。根据距离最近的N张图片的标签决定预测图片的分类。图片之间的距离可以用曼哈顿距离、欧式距离或者余弦距离表示。
    KNN的优点是思路简单,但是预测的时候需要与所有训练集图片比较,时间长。而且效果也不好。基本上是颜色一致的图片是最近邻的。
    
    展开全文
  • 深度学习-KNN原理

    2020-07-18 13:52:27
    KNN 分类的计算复杂度和训练集中的文档数目成正比,也就是说,如果训练集中文档总数为n,那么KNN 的分类时间复杂度为O(n)。 基本原理 基于统计的方法 来进行样本点分类判别 对于未知类别属性数据集中的点:...
  • 参考:https://blog.csdn.net/xundh/article/details/73611249 包括算法解释、代码和数据集。
  •   在学习深度和图像识别的时候,看见了一个比较有意思的算法——KNN算法,该算法是图像分类中最简单的算法之一。 基础理论   KNN算法全称是K-最近邻算法,英文名称是K-NearestNeighbor,简称为KNN;从算法名称上...
  • 文章目录引言人脸数据获取处理图片读取到并数组中调用opencv内置函数进行人脸识别knn算法进行人脸识别使用Dense层神经网络进行人脸识别 引言 人脸识别和人脸检测不同,人脸检测时检测到人脸位置,而人脸识别是基于...
  • knn 第一个学习的深度学习算法

    千次阅读 2016-12-04 22:42:30
    在几经摸索下,终于用python开始写下了自己的第一个机器学习算法KNN 这是一个分类算法,可以通过已有标签,判断一个输入的事物是不是已知的标签,其实这个算法算是入门级的,用来练手刚刚好 写完以后觉得,机器...
  • 深度学习基础(一)——KNN与SVM

    千次阅读 2017-09-28 23:52:06
    1,上午继续看书,主要看了深度学习的发展历程以及主要技术介绍 2,中午思考了决策树算法中的数据准备阶的矩阵装换,将类似Excel数据表格的形式数据转换为0-1矩阵  数据大致格式为:表头为特征向量名称以及输出...
  • KNN 的优缺点
  • 深度学习(二) 什么是深度学习

    千次阅读 2018-07-22 11:01:00
    在以前机器学习比较流行的一般是KNN和SVM但由于大数据和计算机能力等不断出现,是原来的模型不能更好的适应,所以深度学习开始得到广泛的关注。 2. 深度学习厉害公司: 谷歌、facebook、百度。 3. 深度学习范畴:...
  • 这是一个使用knn把特征向量进行分类的demo。 Knn算法的思想简单说就是:看输入的sample点周围的k个点都属于哪个类,哪个类的点最多,就把sample归为哪个类。也就是说,训练集是一些已经被手动打好标签的数据,knn会...
  • 学习KNN(一) 图像分类与KNN原理

    万次阅读 2018-04-07 19:43:29
    学习KNN(一) 图像分类与KNN原理 学习KNN(二)KNN算法手写数字识别的OpenCV实现 学习KNN(三)KNN+HOG实现手写数字识别 简介 KNN算法,即K近邻算法是一种监督学习算法,本质上是要在给定的训练样本中找到与...
  • 先来看深度学习的代码: # 由于发现使用KNN算法对于facebook地区的分类实在是缓慢 # 因此尝试使用深度学习的方法 import tensorflow as tf import numpy as np import pandas as pd from sklearn.model_selection ...
  • Kmeans 与 kNN 虽然都是以 K 打头,但却是两类算法——kNN 为监督学习中的分类算法,而 Kmeans 则是非监督学习中的聚类算法;二者相同之处:均利用近邻信息来标注类别。 Kmeans 是聚类算法中最为简单、高效的。 核心...
  • 2、KNN 算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别,则该样本也属于这个类别,并具有这个类别上样本的特性。 3、类别决策时,只与极少量的相邻样本有关。 4、距离的测量...
  •  要说很多现在最火的AI是什么,那就是深度学习。那么深度学习和机器学习有什么关系呢?我们可以通过一问一答的形式来解决。   1、什么是机器学习?  机器学习一般是指传统的人工智能方法,它包括bayes、决策树...
  • 文章目录机器学习深度学习深度学习练习题 机器学习 1.机器学习实战(1) k-近邻算法(kNN)和决策树 2.机器学习实战(2) 基于概率论的分类方法:朴素贝叶斯 python3 3.机器学习实战(3) Logistic回归 逻辑回归 基于python3...
1 2 3 4 5 ... 20
收藏数 10,294
精华内容 4,117
关键字:

knn 深度学习