精华内容
参与话题
问答
  • 机器学习之KNN最邻近分类算法

    万次阅读 多人点赞 2018-09-15 13:13:33
    KNN(K-Nearest Neighbor)最邻近分类算法是数据挖掘分类(classification)技术中最简单的算法之一,其指导思想是”近朱者赤,近墨者黑“,即由你的邻居来推断出你的类别。 KNN最邻近分类算法的实现原理:为了...

    前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到教程

    KNN算法简介

    KNN(K-Nearest Neighbor)最邻近分类算法是数据挖掘分类(classification)技术中最简单的算法之一,其指导思想是”近朱者赤,近墨者黑“,即由你的邻居来推断出你的类别。

    KNN最邻近分类算法的实现原理:为了判断未知样本的类别,以所有已知类别的样本作为参照,计算未知样本与所有已知样本的距离,从中选取与未知样本距离最近的K个已知样本,根据少数服从多数的投票法则(majority-voting),将未知样本与K个最邻近样本中所属类别占比较多的归为一类。

              以上就是KNN算法在分类任务中的基本原理,实际上K这个字母的含义就是要选取的最邻近样本实例的个数,在 scikit-learn 中 KNN算法的 K 值是通过 n_neighbors 参数来调节的,默认值是 5。

              如下图所示,如何判断绿色圆应该属于哪一类,是属于红色三角形还是属于蓝色四方形?如果K=3,由于红色三角形所占比例为2/3,绿色圆将被判定为属于红色三角形那个类,如果K=5,由于蓝色四方形比例为3/5,因此绿色圆将被判定为属于蓝色四方形类。

    由于KNN最邻近分类算法在分类决策时只依据最邻近的一个或者几个样本的类别来决定待分类样本所属的类别,而不是靠判别类域的方法来确定所属类别的,因此对于类域的交叉或重叠较多的待分样本集来说,KNN方法较其他方法更为适合。

               KNN算法的关键:

               (1) 样本的所有特征都要做可比较的量化

               若是样本特征中存在非数值的类型,必须采取手段将其量化为数值。例如样本特征中包含颜色,可通过将颜色转换为灰度值来实现距离计算。

               (2) 样本特征要做归一化处理

               样本有多个参数,每一个参数都有自己的定义域和取值范围,他们对距离计算的影响不一样,如取值较大的影响力会盖过取值较小的参数。所以样本参数必须做一些 scale 处理,最简单的方式就是所有特征的数值都采取归一化处置。

               (3) 需要一个距离函数以计算两个样本之间的距离

               通常使用的距离函数有:欧氏距离、余弦距离、汉明距离、曼哈顿距离等,一般选欧氏距离作为距离度量,但是这是只适用于连续变量。在文本分类这种非连续变量情况下,汉明距离可以用来作为度量。通常情况下,如果运用一些特殊的算法来计算度量的话,K近邻分类精度可显著提高,如运用大边缘最近邻法或者近邻成分分析法。

    以计算二维空间中的A(x1,y1)、B(x2,y2)两点之间的距离为例,欧氏距离和曼哈顿距离的计算方法如下图所示:

    (4) 确定K的值

               K值选的太大易引起欠拟合,太小容易过拟合,需交叉验证确定K值。

    KNN算法的优点:

               1.简单,易于理解,易于实现,无需估计参数,无需训练;

               2. 适合对稀有事件进行分类;

               3.特别适合于多分类问题(multi-modal,对象具有多个类别标签), kNN比SVM的表现要好。

    KNN算法的缺点:

               KNN算法在分类时有个主要的不足是,当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数,如下图所示。该算法只计算最近的邻居样本,某一类的样本数量很大,那么或者这类样本并不接近目标样本,或者这类样本很靠近目标样本。无论怎样,数量并不能影响运行结果。可以采用权值的方法(和该样本距离小的邻居权值大)来改进。

    该方法的另一个不足之处是计算量较大,因为对每一个待分类的文本都要计算它到全体已知样本的距离,才能求得它的K个最近邻点。

    可理解性差,无法给出像决策树那样的规则。

    KNN算法实现

    要自己动手实现KNN算法其实不难,主要有以下三个步骤:

               算距离:给定待分类样本,计算它与已分类样本中的每个样本的距离;

               找邻居:圈定与待分类样本距离最近的K个已分类样本,作为待分类样本的近邻;

               做分类:根据这K个近邻中的大部分样本所属的类别来决定待分类样本该属于哪个分类;

    以下是使用Python实现KNN算法的简单示例:

    import math
    import csv
    import operator
    import random
    import numpy as np
    from sklearn.datasets import make_blobs
    
    #Python version 3.6.5
    
    # 生成样本数据集 samples(样本数量) features(特征向量的维度) centers(类别个数)
    def createDataSet(samples=100, features=2, centers=2):
        return make_blobs(n_samples=samples, n_features=features, centers=centers, cluster_std=1.0, random_state=8)
    
    # 加载鸢尾花卉数据集 filename(数据集文件存放路径)
    def loadIrisDataset(filename):
        with open(filename, 'rt') as csvfile:
            lines = csv.reader(csvfile)
            dataset = list(lines)
            for x in range(len(dataset)):
                for y in range(4):
                    dataset[x][y] = float(dataset[x][y])
            return dataset
        
    # 拆分数据集 dataset(要拆分的数据集) split(训练集所占比例) trainingSet(训练集) testSet(测试集)
    def splitDataSet(dataSet, split, trainingSet=[], testSet=[]):
        for x in range(len(dataSet)):
            if random.random() <= split:
                trainingSet.append(dataSet[x])
            else:
                testSet.append(dataSet[x])
    # 计算欧氏距离 
    def euclideanDistance(instance1, instance2, length):
        distance = 0
        for x in range(length):
            distance += pow((instance1[x] - instance2[x]), 2)
        return math.sqrt(distance)
    
    # 选取距离最近的K个实例
    def getNeighbors(trainingSet, testInstance, k):
        distances = []
        length = len(testInstance) - 1
        for x in range(len(trainingSet)):
            dist = euclideanDistance(testInstance, trainingSet[x], length)
            distances.append((trainingSet[x], dist))
        distances.sort(key=operator.itemgetter(1))
        
        neighbors = []
        for x in range(k):
            neighbors.append(distances[x][0])
        return neighbors
    
    #  获取距离最近的K个实例中占比例较大的分类
    def getResponse(neighbors):
        classVotes = {}
        for x in range(len(neighbors)):
            response = neighbors[x][-1]
            if response in classVotes:
                classVotes[response] += 1
            else:
                classVotes[response] = 1
        sortedVotes = sorted(classVotes.items(), key=operator.itemgetter(1), reverse=True)
        return sortedVotes[0][0]
    
    # 计算准确率
    def getAccuracy(testSet, predictions):
        correct = 0
        for x in range(len(testSet)):
            if testSet[x][-1] == predictions[x]:
                correct += 1
        return (correct / float(len(testSet))) * 100.0
    
    
    def main():
        # 使用自定义创建的数据集进行分类
        # x,y = createDataSet(features=2)
        # dataSet= np.c_[x,y]
        
        # 使用鸢尾花卉数据集进行分类
        dataSet = loadIrisDataset(r'C:\DevTolls\eclipse-pureh2b\python\DeepLearning\KNN\iris_dataset.txt')
            
        print(dataSet)
        trainingSet = []
        testSet = []
        splitDataSet(dataSet, 0.75, trainingSet, testSet)
        print('Train set:' + repr(len(trainingSet)))
        print('Test set:' + repr(len(testSet)))
        predictions = []
        k = 7
        for x in range(len(testSet)):
            neighbors = getNeighbors(trainingSet, testSet[x], k)
            result = getResponse(neighbors)
            predictions.append(result)
            print('>predicted=' + repr(result) + ',actual=' + repr(testSet[x][-1]))
        accuracy = getAccuracy(testSet, predictions)
        print('Accuracy: ' + repr(accuracy) + '%')
    main()
        
    

    尾花卉数据文件百度网盘下载链接:https://pan.baidu.com/s/10vI5p_QuM7esc-jkar2zdQ 密码:4und

    KNN算法应用

    使用KNN算法处理简单分类任务

    在scikit-learn中,内置了若干个玩具数据集(Toy Datasets),还有一些API让我们可以自己动手生成一些数据集。接下来我们将使用scikit-learn的make_blobs函数来生成一个样本数量为200,分类数量为2的数据集,并使用KNN算法来对其进行分类。

    # 导入画图工具
    import matplotlib.pyplot as plt
    # 导入数组工具
    import numpy as np
    # 导入数据集生成器
    from sklearn.datasets import make_blobs
    # 导入KNN 分类器
    from sklearn.neighbors import KNeighborsClassifier
    # 导入数据集拆分工具
    from sklearn.model_selection import train_test_split
    
    # 生成样本数为200,分类数为2的数据集
    data=make_blobs(n_samples=200, n_features=2,centers=2, cluster_std=1.0, random_state=8)
    X,Y=data
    
    # 将生成的数据集进行可视化
    # plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    # plt.show()
    
    clf = KNeighborsClassifier()
    clf.fit(X,Y)
    
    # 绘制图形
    x_min,x_max=X[:,0].min()-1,X[:,0].max()+1
    y_min,y_max=X[:,1].min()-1,X[:,1].max()+1
    xx,yy=np.meshgrid(np.arange(x_min,x_max,.02),np.arange(y_min,y_max,.02))
    z=clf.predict(np.c_[xx.ravel(),yy.ravel()])
    
    z=z.reshape(xx.shape)
    plt.pcolormesh(xx,yy,z,cmap=plt.cm.Pastel1)
    plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    plt.xlim(xx.min(),xx.max())
    plt.ylim(yy.min(),yy.max())
    plt.title("Classifier:KNN")
    
    # 把待分类的数据点用五星表示出来
    plt.scatter(6.75,4.82,marker='*',c='red',s=200)
    
    # 对待分类的数据点的分类进行判断
    res = clf.predict([[6.75,4.82]])
    plt.text(6.9,4.5,'Classification flag: '+str(res))
    
    plt.show()

     程序执行后得到结果如下图所示:

    使用KNN算法处理多元分类任务

    接下来,我们再使用scikit-learn的make_blobs函数来生成一个样本数量为500,分类数量为5的数据集,并使用KNN算法来对其进行分类。

    # 导入画图工具
    import matplotlib.pyplot as plt
    # 导入数组工具
    import numpy as np
    # 导入数据集生成器
    from sklearn.datasets import make_blobs
    # 导入KNN 分类器
    from sklearn.neighbors import KNeighborsClassifier
    # 导入数据集拆分工具
    from sklearn.model_selection import train_test_split
    
    # 生成样本数为500,分类数为5的数据集
    data=make_blobs(n_samples=500, n_features=2,centers=5, cluster_std=1.0, random_state=8)
    X,Y=data
    
    # 将生成的数据集进行可视化
    # plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    # plt.show()
    
    clf = KNeighborsClassifier()
    clf.fit(X,Y)
    
    # 绘制图形
    x_min,x_max=X[:,0].min()-1,X[:,0].max()+1
    y_min,y_max=X[:,1].min()-1,X[:,1].max()+1
    xx,yy=np.meshgrid(np.arange(x_min,x_max,.02),np.arange(y_min,y_max,.02))
    z=clf.predict(np.c_[xx.ravel(),yy.ravel()])
    
    z=z.reshape(xx.shape)
    plt.pcolormesh(xx,yy,z,cmap=plt.cm.Pastel1)
    plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    plt.xlim(xx.min(),xx.max())
    plt.ylim(yy.min(),yy.max())
    plt.title("Classifier:KNN")
    
    # 把待分类的数据点用五星表示出来
    plt.scatter(0,5,marker='*',c='red',s=200)
    
    # 对待分类的数据点的分类进行判断
    res = clf.predict([[0,5]])
    plt.text(0.2,4.6,'Classification flag: '+str(res))
    plt.text(3.75,-13,'Model accuracy: {:.2f}'.format(clf.score(X, Y)))
    
    plt.show()

     程序执行后得到结果如下图所示:

    使用KNN算法进行回归分析

    这里我们使用scikit-learn的make_regression生成数据集来进行实验,演示KNN算法在回归分析中的表现。

    # 导入画图工具
    import matplotlib.pyplot as plt
    # 导入数组工具
    import numpy as np
    
    # 导入用于回归分析的KNN模型
    from sklearn.neighbors import KNeighborsRegressor
    # 导入数据集拆分工具
    from sklearn.model_selection import train_test_split
    # 导入数据集生成器
    from sklearn.datasets.samples_generator import make_regression
    from docutils.utils.math.math2html import LineWriter
    
    # 生成样本数为200,分类数为2的数据集
    X,Y=make_regression(n_samples=100,n_features=1,n_informative=1,noise=50,random_state=8)
    
    # 将生成的数据集进行可视化
    # plt.scatter(X,Y,s=80, c='orange',  cmap=plt.cm.spring, edgecolors='k')
    # plt.show()
    reg = KNeighborsRegressor(n_neighbors=5)
    
    reg.fit(X,Y)
    
    # 将预测结果用图像进行可视化
    z = np.linspace(-3,3,200).reshape(-1,1)
    plt.scatter(X,Y,c='orange',edgecolor='k')
    plt.plot(z,reg.predict(z),c='k',Linewidth=3)
    #
    plt.title("KNN Regressor")
    
    plt.show()

      程序执行后得到结果如下图所示:

    KNN算法项目实战----酒的分类

    from sklearn.datasets.base import load_wine
    from sklearn.model_selection import train_test_split
    from sklearn.neighbors import KNeighborsClassifier
    import numpy as np
    
    # 从 sklearn的datasets模块载入数据集加载酒的数据集
    wineDataSet=load_wine()
    print(wineDataSet)
    print("红酒数据集中的键:\n{}".format(wineDataSet.keys()))
    print("数据概况:\n{}".format(wineDataSet['data'].shape))
    print(wineDataSet['DESCR'])
    
    # 将数据集拆分为训练数据集和测试数据集
    X_train,X_test,y_train,y_test=train_test_split(wineDataSet['data'],wineDataSet['target'],random_state=0)
    print("X_train shape:{}".format(X_train.shape))
    print("X_test shape:{}".format(X_test.shape))
    print("y_train shape:{}".format(y_train.shape))
    print("y_test shape:{}".format(y_test.shape))
    
    knn = KNeighborsClassifier(n_neighbors=1)
    knn.fit(X_train,y_train)
    print(knn)
    
    # 评估模型的准确率
    print('测试数据集得分:{:.2f}'.format(knn.score(X_test,y_test)))
    
    # 使用建好的模型对新酒进行分类预测
    X_new = np.array([[13.2,2.77,2.51,18.5,96.6,1.04,2.55,0.57,1.47,6.2,1.05,3.33,820]])
    prediction = knn.predict(X_new)
    print("预测新酒的分类为:{}".format(wineDataSet['target_names'][prediction]))

     执行程序后打印如下结果:

    X_train shape:(133, 13)
    X_test shape:(45, 13)
    y_train shape:(133,)
    y_test shape:(45,)
    KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
               metric_params=None, n_jobs=1, n_neighbors=1, p=2,
               weights='uniform')
    测试数据集得分:0.76
    预测新酒的分类为:['class_2']

    参考书籍:《深入浅出 Python 机器学习》 作者:段小手

    展开全文
  • 带你搞懂朴素贝叶斯分类算法

    万次阅读 多人点赞 2017-04-14 16:19:33
    贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单,也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到...

    最新人工智能论文:http://paperreading.club

    带你搞懂朴素贝叶斯分类算

    贝叶斯分类是一类分类算法的总称,这类算法均以贝叶斯定理为基础,故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单,也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法,希望有利于他人理解。

     

    1  分类问题综述

     对于分类问题,其实谁都不会陌生,日常生活中我们每天都进行着分类过程。例如,当你看到一个人,你的脑子下意识判断他是学生还是社会上的人;你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱”之类的话,其实这就是一种分类操作。

     

    既然是贝叶斯分类算法,那么分类的数学描述又是什么呢?

     

    从数学角度来说,分类问题可做如下定义:已知集合,确定映射规则y = f(x),使得任意有且仅有一个,使得成立。

     

    其中C叫做类别集合,其中每一个元素是一个类别,而I叫做项集合(特征集合),其中每一个元素是一个待分类项,f叫做分类器。分类算法的任务就是构造分类器f。

     

    分类算法的内容是要求给定特征,让我们得出类别,这也是所有分类问题的关键。那么如何由指定特征,得到我们最终的类别,也是我们下面要讲的,每一个不同的分类算法,对应着不同的核心思想。

     

    本篇文章,我会用一个具体实例,对朴素贝叶斯算法几乎所有的重要知识点进行讲解。

     

    2  朴素贝叶斯分类

    那么既然是朴素贝叶斯分类算法,它的核心算法又是什么呢?

    是下面这个贝叶斯公式:

     

     

    换个表达形式就会明朗很多,如下:

     

     

    我们最终求的p(类别|特征)即可!就相当于完成了我们的任务。

     

    3  例题分析

    下面我先给出例子问题。

     

    给定数据如下:

     

     

    现在给我们的问题是,如果一对男女朋友,男生想女生求婚,男生的四个特点分别是不帅,性格不好,身高矮,不上进,请你判断一下女生是还是不嫁

     

    这是一个典型的分类问题,转为数学问题就是比较p(嫁|(不帅、性格不好、身高矮、不上进))与p(不嫁|(不帅、性格不好、身高矮、不上进))的概率,谁的概率大,我就能给出嫁或者不嫁的答案!

    这里我们联系到朴素贝叶斯公式:

     

     

    我们需要求p(嫁|(不帅、性格不好、身高矮、不上进),这是我们不知道的,但是通过朴素贝叶斯公式可以转化为好求的三个量.

     

    p(不帅、性格不好、身高矮、不上进|嫁)、p(不帅、性格不好、身高矮、不上进)、p(嫁)(至于为什么能求,后面会讲,那么就太好了,将待求的量转化为其它可求的值,这就相当于解决了我们的问题!

     

    4  朴素贝叶斯算法的朴素一词解释

    那么这三个量是如何求得?

     

    是根据已知训练数据统计得来,下面详细给出该例子的求解过程。

    回忆一下我们要求的公式如下:

     

     

    那么我只要求得p(不帅、性格不好、身高矮、不上进|嫁)、p(不帅、性格不好、身高矮、不上进)、p(嫁)即可,好的,下面我分别求出这几个概率,最后一比,就得到最终结果。

     

    p(不帅、性格不好、身高矮、不上进|嫁) = p(不帅|嫁)*p(性格不好|嫁)*p(身高矮|嫁)*p(不上进|嫁),那么我就要分别统计后面几个概率,也就得到了左边的概率!

     

    等等,为什么这个成立呢?学过概率论的同学可能有感觉了,这个等式成立的条件需要特征之间相互独立吧!

     

    对的!这也就是为什么朴素贝叶斯分类有朴素一词的来源,朴素贝叶斯算法是假设各个特征之间相互独立,那么这个等式就成立了!

     

    但是为什么需要假设特征之间相互独立呢?

     

     

    1、我们这么想,假如没有这个假设,那么我们对右边这些概率的估计其实是不可做的,这么说,我们这个例子有4个特征,其中帅包括{帅,不帅},性格包括{不好,好,爆好},身高包括{高,矮,中},上进包括{不上进,上进},那么四个特征的联合概率分布总共是4维空间,总个数为2*3*3*2=36个。

     

    36个,计算机扫描统计还可以,但是现实生活中,往往有非常多的特征,每一个特征的取值也是非常之多,那么通过统计来估计后面概率的值,变得几乎不可做,这也是为什么需要假设特征之间独立的原因。

     

    2、假如我们没有假设特征之间相互独立,那么我们统计的时候,就需要在整个特征空间中去找,比如统计p(不帅、性格不好、身高矮、不上进|嫁),

     

    我们就需要在嫁的条件下,去找四种特征全满足分别是不帅,性格不好,身高矮,不上进的人的个数,这样的话,由于数据的稀疏性,很容易统计到0的情况。 这样是不合适的。

     

    根据上面俩个原因,朴素贝叶斯法对条件概率分布做了条件独立性的假设,由于这是一个较强的假设,朴素贝叶斯也由此得名!这一假设使得朴素贝叶斯法变得简单,但有时会牺牲一定的分类准确率。

     

    好的,上面我解释了为什么可以拆成分开连乘形式。那么下面我们就开始求解!

     

    我们将上面公式整理一下如下:

     

     

    下面我将一个一个的进行统计计算(在数据量很大的时候,根据中心极限定理,频率是等于概率的,这里只是一个例子,所以我就进行统计即可)。

     

    p(嫁)=?

    首先我们整理训练数据中,嫁的样本数如下:

     

    则 p(嫁) = 6/12(总样本数) = 1/2

     

    p(不帅|嫁)=?统计满足样本数如下:

     

    则p(不帅|嫁) = 3/6 = 1/2 在嫁的条件下,看不帅有多少

     

    p(性格不好|嫁)= ?统计满足样本数如下:

     

    则p(性格不好|嫁)= 1/6

     

    p(矮|嫁) = ?统计满足样本数如下:

     

    则p(矮|嫁) = 1/6

     

    p(不上进|嫁) = ?统计满足样本数如下:

     

    则p(不上进|嫁) = 1/6

     

    下面开始求分母,p(不帅),p(性格不好),p(矮),p(不上进)

    统计样本如下:

     

     

    不帅统计如上红色所示,占4个,那么p(不帅) = 4/12 = 1/3

     

     

    性格不好统计如上红色所示,占4个,那么p(性格不好) = 4/12 = 1/3

     

     

    身高矮统计如上红色所示,占7个,那么p(身高矮) = 7/12

     

     

    不上进统计如上红色所示,占4个,那么p(不上进) = 4/12 = 1/3

     

    到这里,要求p(不帅、性格不好、身高矮、不上进|嫁)的所需项全部求出来了,下面我带入进去即可,

     

    = (1/2*1/6*1/6*1/6*1/2)/(1/3*1/3*7/12*1/3)

     

    下面我们根据同样的方法来求p(不嫁|不帅,性格不好,身高矮,不上进),完全一样的做法,为了方便理解,我这里也走一遍帮助理解。首先公式如下:

     

     

    下面我也一个一个来进行统计计算,这里与上面公式中,分母是一样的,于是我们分母不需要重新统计计算!

     

    p(不嫁)=?根据统计计算如下(红色为满足条件):

     

     

    则p(不嫁)=6/12 = 1/2

     

    p(不帅|不嫁) = ?统计满足条件的样本如下(红色为满足条件):

     

     

    则p(不帅|不嫁) = 1/6

     

    p(性格不好|不嫁) = ?据统计计算如下(红色为满足条件):


    则p(性格不好|不嫁) =3/6 = 1/2

     

    p(矮|不嫁) = ?据统计计算如下(红色为满足条件):

     

    则p(矮|不嫁) = 6/6 = 1

     

    p(不上进|不嫁) = ?据统计计算如下(红色为满足条件):

    则p(不上进|不嫁) = 3/6 = 1/2

     

    那么根据公式:

     

    p (不嫁|不帅、性格不好、身高矮、不上进) = ((1/6*1/2*1*1/2)*1/2)/(1/3*1/3*7/12*1/3)

    很显然(1/6*1/2*1*1/2) > (1/2*1/6*1/6*1/6*1/2)

     

    于是有p (不嫁|不帅、性格不好、身高矮、不上进)>p (嫁|不帅、性格不好、身高矮、不上进)

     

    所以我们根据朴素贝叶斯算法可以给这个女生答案,是不嫁!!!!

     

    5  朴素贝叶斯分类的优缺点

    优点:

    (1) 算法逻辑简单,易于实现(算法思路很简单,只要使用贝叶斯公式转化医学即可!

    (2)分类过程中时空开销小(假设特征相互独立,只会涉及到二维存储

     

    缺点:

     

    理论上,朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此,这是因为朴素贝叶斯模型假设属性之间相互独立,这个假设在实际应用中往往是不成立的,在属性个数比较多或者属性之间相关性较大时,分类效果不好。

     

    而在属性相关性较小时,朴素贝叶斯性能最为良好。对于这一点,有半朴素贝叶斯之类的算法通过考虑部分关联性适度改进。

     

    整个例子详细的讲解了朴素贝叶斯算法的分类过程,希望对大家的理解有帮助~

     

    参考:李航博士《统计学习方法》

    算法杂货铺--分类算法之朴素贝叶斯分类(Naive Bayesian classification)

     

    致谢:德川,皓宇,继豪,施琦


    原文地址:https://mp.weixin.qq.com/s?__biz=MzI4MDYzNzg4Mw==&mid=2247483819&idx=1&sn=7f1859c0a00248a4c658fa65f846f341&chksm=ebb4397fdcc3b06933816770b928355eb9119c4c80a1148b92a42dc3c08de5098fd6f278e61e#rd

    展开全文
  • 基于CNN的垃圾分类模型

    万次阅读 多人点赞 2018-01-10 15:44:21
    基于TensorFlow和Keras的垃圾分类模型 本篇博客主要介绍基于TensorFlow和Keras实现垃圾分类模型,目前是一篇占坑的博客,由于该项目目前用于参加比赛,因此暂时不能提供代码,感兴趣的可以私信我一起交流,识别...

    数据集代码下载地址:https://download.csdn.net/download/github_39611196/13103484

    前言

    识别结果如下所示:
    在这里插入图片描述

    国家大力推行垃圾分类可以实现环境保护,但是也对很多不熟悉垃圾分类的人造成了困扰,需要一种自动化的垃圾分类方法,以实现更加便捷的垃圾分类。
    在这里插入图片描述
    本文提出了基于卷积神经网络(Convolutional Neural Network,CNN)的垃圾分类方法,主要实现对6类生活垃圾进行分类,包括可回收垃圾(5类:硬纸板、铜制品、塑料瓶、玻璃瓶和废弃纸张)和不可回收垃圾。

    准备数据

    首先爬取图片数据,并从中每类挑选400张可用的图片,并将数据集按照9:1的比例划分为训练集和测试集。

    硬纸板
    在这里插入图片描述
    玻璃瓶
    在这里插入图片描述
    铜制品
    在这里插入图片描述
    废弃纸张
    在这里插入图片描述
    塑料瓶
    在这里插入图片描述
    不可回收垃圾
    在这里插入图片描述

    数据地址(个人整理的数据集,需要的可自行下载):

    https://www.kaggle.com/asdasdasasdas/garbage-classification

    搭建网络

    在准备完数据后,搭建6层CNN网络对数据集进行训练,最后进行测试,测试准确率为0.85。其中CNN网络包括4个卷积层、4个最大池化层和2个全连接层,前5层使用了ReLU激活函数,最后一层使用了SoftMax激活函数。

    训练和测试

    根据搭建的CNN网络对数据进行训练和测试。
    在这里插入图片描述

    完整代码

    prepare_image.py:用于对输入图像做预处理

    # encoding:utf-8
    '''
    对需要进行预测的图片进行预处理
    '''
    from keras.preprocessing.image import ImageDataGenerator
    from keras.preprocessing.image import ImageDataGenerator, load_img, img_to_array
    from keras.applications.imagenet_utils import preprocess_input
    import numpy as np
    
    
    def prepare_image(img_path, model):
        # 加载图像
        img = load_img(img_path, target_size=(512, 384))        # x = np.array(img, dtype='float32')test
        # 图像预处理
        x = img_to_array(img)
        x = np.expand_dims(x, axis=0)
        x = preprocess_input(x)
        results = model.predict(x)
        print(results)
        return results
    

    train.py:用于训练垃圾分类模型

    # encoding:utf-8
    '''
    用于训练垃圾分类模型
    '''
    from keras.preprocessing.image import ImageDataGenerator
    from keras.models import Sequential
    from keras.layers import Conv2D, MaxPooling2D
    from keras.layers import Activation, Dropout, Flatten, Dense
    from keras.callbacks import ModelCheckpoint
    from keras import backend as K
    
    # dimensions of our images.
    img_width, img_height = 512, 384
    
    train_data_dir = 'data/train'
    validation_data_dir = 'data/validation'
    nb_train_samples = 2357
    nb_validation_samples = 170
    epochs = 30
    batch_size = 20
    
    if K.image_data_format() == 'channels_first':
        input_shape = (3, img_width, img_height)
    else:
        input_shape = (img_width, img_height, 3)
    
    model = Sequential()
    model.add(Conv2D(32, (3, 3), input_shape=input_shape))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    model.add(Conv2D(32, (3, 3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    model.add(Conv2D(64, (3, 3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    model.add(Flatten())
    model.add(Dense(64))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(6))  # 6分类
    model.add(Activation('softmax'))  # 采用Softmax
    
    model.compile(loss='categorical_crossentropy',  # 多分类
                  optimizer='rmsprop',
                  metrics=['accuracy'])
    
    # this is the augmentation configuration we will use for training
    train_datagen = ImageDataGenerator(
        rescale=1. / 255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True)
    
    # this is the augmentation configuration we will use for testing:
    # only rescaling
    test_datagen = ImageDataGenerator(rescale=1. / 255)
    
    train_generator = train_datagen.flow_from_directory(
        train_data_dir,
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='categorical')  # 多分类
    
    validation_generator = test_datagen.flow_from_directory(
        validation_data_dir,
        target_size=(img_width, img_height),
        batch_size=batch_size,
        class_mode='categorical')  # 多分类
    
    filepath="weights-improvement-{epoch:02d}-{val_acc:.2f}.h5"
    checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=0, save_best_only=False, save_weights_only=False, mode='auto', period=1)
    callbacks_list = [checkpoint]
    
    model.fit_generator(
        train_generator,
        steps_per_epoch=nb_train_samples // batch_size,
        epochs=epochs,
        callbacks=callbacks_list,
        validation_data=validation_generator,
        validation_steps=nb_validation_samples // batch_size)
    

    plot.py:用于显示图片预测结果

    # encoding:utf-8
    '''
    用于对预测结果图片进行显示
    '''
    import cv2
    import numpy as np
    
    # 根据预测结果显示对应的文字label
    classes_types = ['cardboard', 'glass', 'trash']
    
    
    def generate_result(result):
        for i in range(3):
            if(result[0][i] == 1):
                print(i)
                return classes_types[i]
    
    
    def show(img_path, results):
        # 对结果进行显示
        frame = cv2.imread(img_path)
        font = cv2.FONT_HERSHEY_SIMPLEX
        cv2.putText(frame, generate_result(results), (10, 140), font, 3, (255, 0, 0), 2, cv2.LINE_AA)
        cv2.imshow('img', frame)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    

    predict.py:用于对测试数据集进行测试

    # encoding:utf-8
    '''
    加载垃圾分类模型
    '''
    from keras.models import Sequential
    from keras.layers import Conv2D, MaxPooling2D
    from keras.layers import Activation, Dropout, Flatten, Dense
    from keras import backend as K
    
    
    def model():
        # dimensions of our images.
        img_width, img_height = 512, 384
        if K.image_data_format() == 'channels_first':
            input_shape = (3, img_width, img_height)
        else:
            input_shape = (img_width, img_height, 3)
    
        model = Sequential()
        model.add(Conv2D(32, (3, 3), input_shape=input_shape))
        model.add(Activation('relu'))
        model.add(MaxPooling2D(pool_size=(2, 2)))
    
        model.add(Conv2D(32, (3, 3)))
        model.add(Activation('relu'))
        model.add(MaxPooling2D(pool_size=(2, 2)))
    
        model.add(Conv2D(64, (3, 3)))
        model.add(Activation('relu'))
        model.add(MaxPooling2D(pool_size=(2, 2)))
    
        model.add(Flatten())
        model.add(Dense(64))
        model.add(Activation('relu'))
        model.add(Dropout(0.5))
        model.add(Dense(3))  # 3分类
        model.add(Activation('softmax'))  # 采用Softmax
    
        model.compile(loss='categorical_crossentropy',  # 多分类
                      optimizer='rmsprop',
                      metrics=['accuracy'])
    
        model.load_weights("weights.h5")
        return model
    

    main.py:对各个模块进行调用,测试图片并显示最终结果

    # encoding:utf-8
    '''
    调用各个模块实现对图片的测试和显示结果
    '''
    from plot import show
    import predict
    from prepare_image import prepare_image
    
    
    def detect(img_path):
        model = predict.model()
        results = prepare_image(img_path=img_path, model=model)
        show(img_path=img_path, results=results)
    
    if __name__ == '__main__':
    
        detect("test/15.jpg")
    

    使用步骤

    训练
    调用train.py对训练数据集进行训练,得到weights.h5权值文件。
    测试
    调用main.py进行测试。

    分类的准确率不是很高,主要存在两个问题

    第一个问题:数据集过于杂乱,在选择不可回收垃圾数据集时,只要不属于前五类而且为不可回收垃圾,都放到了不可回收垃圾类别下,无法很好的进行特征的学习。

    第二个问题是,模型只有6层,较为简单,学习能力不够强。

    改进思路

    针对第一个问题,可以对数据集进行清洗,以便更好地对特征进行学习;针对第二个问题,可以选择一些比较成熟的模型架构,如VGG16或者ResNet,通过迁移学习进行改进。

    写在最后

    集中回答大家几个问题:
    1、数据集和代码在哪下载?
    根据文中链接进行下载。
    2、找不到weights.h5配置文件?
    weights.h5配置文件需要通过train.py文件训练生成,即在运行main.py文件之前需要运行train.py文件
    3、代码报错问题?
    由于代码是三年前写的了,因此可能由于TensorFlow和Keras的版本,会出现报错,需要大家自行查找解决方案。

    展开全文
  • 混淆矩阵就是分别统计分类模型归错类,归对类的观测值个数,然后把结果放在一个表里展示出来。这个表就是混淆矩阵。 数据分析与挖掘体系位置 混淆矩阵是评判模型结果的指标,属于模型评估的一部分。此外,混淆...

    简介

    混淆矩阵是ROC曲线绘制的基础,同时它也是衡量分类型模型准确度中最基本,最直观,计算最简单的方法。

    一句话解释版本:

    混淆矩阵就是分别统计分类模型归错类,归对类的观测值个数,然后把结果放在一个表里展示出来。这个表就是混淆矩阵。

     

     

    数据分析与挖掘体系位置

    混淆矩阵是评判模型结果的指标,属于模型评估的一部分。此外,混淆矩阵多用于判断分类器(Classifier)的优劣,适用于分类型的数据模型,如分类树(Classification Tree)、逻辑回归(Logistic Regression)、线性判别分析(Linear Discriminant Analysis)等方法。

    在分类型模型评判的指标中,常见的方法有如下三种:

    1. 混淆矩阵(也称误差矩阵,Confusion Matrix)
    2. ROC曲线
    3. AUC面积

    本篇主要介绍第一种方法,即混淆矩阵,也称误差矩阵。

    此方法在整个数据分析与挖掘体系中的位置如下图所示。

     

    混淆矩阵的定义

    混淆矩阵(Confusion Matrix),它的本质远没有它的名字听上去那么拉风。矩阵,可以理解为就是一张表格,混淆矩阵其实就是一张表格而已。

    以分类模型中最简单的二分类为例,对于这种问题,我们的模型最终需要判断样本的结果是0还是1,或者说是positive还是negative。

    我们通过样本的采集,能够直接知道真实情况下,哪些数据结果是positive,哪些结果是negative。同时,我们通过用样本数据跑出分类型模型的结果,也可以知道模型认为这些数据哪些是positive,哪些是negative。

    因此,我们就能得到这样四个基础指标,我称他们是一级指标(最底层的):

    • 真实值是positive,模型认为是positive的数量(True Positive=TP)
    • 真实值是positive,模型认为是negative的数量(False Negative=FN):这就是统计学上的第二类错误(Type II Error)
    • 真实值是negative,模型认为是positive的数量(False Positive=FP):这就是统计学上的第一类错误(Type I Error)
    • 真实值是negative,模型认为是negative的数量(True Negative=TN)

    将这四个指标一起呈现在表格中,就能得到如下这样一个矩阵,我们称它为混淆矩阵(Confusion Matrix):

    混淆矩阵的指标

    预测性分类模型,肯定是希望越准越好。那么,对应到混淆矩阵中,那肯定是希望TP与TN的数量大,而FP与FN的数量小。所以当我们得到了模型的混淆矩阵后,就需要去看有多少观测值在第二、四象限对应的位置,这里的数值越多越好;反之,在第一、三象限对应位置出现的观测值肯定是越少越好。

    二级指标

    但是,混淆矩阵里面统计的是个数,有时候面对大量的数据,光凭算个数,很难衡量模型的优劣。因此混淆矩阵在基本的统计结果上又延伸了如下4个指标,我称他们是二级指标(通过最底层指标加减乘除得到的):

    • 准确率(Accuracy)—— 针对整个模型
    • 精确率(Precision)
    • 灵敏度(Sensitivity):就是召回率(Recall)
    • 特异度(Specificity)

    我用表格的方式将这四种指标的定义、计算、理解进行了汇总:

    通过上面的四个二级指标,可以将混淆矩阵中数量的结果转化为0-1之间的比率。便于进行标准化的衡量。

    在这四个指标的基础上在进行拓展,会产令另外一个三级指标

     

    三级指标

    这个指标叫做F1 Score。他的计算公式是:

     

    其中,P代表Precision,R代表Recall。

    F1-Score指标综合了Precision与Recall的产出的结果。F1-Score的取值范围从0到1的,1代表模型的输出最好,0代表模型的输出结果最差。

     

     

    混淆矩阵的实例

    当分类问题是二分问题是,混淆矩阵可以用上面的方法计算。当分类的结果多于两种的时候,混淆矩阵同时适用。

    一下面的混淆矩阵为例,我们的模型目的是为了预测样本是什么动物,这是我们的结果:

    通过混淆矩阵,我们可以得到如下结论:

    Accuracy

    在总共66个动物中,我们一共预测对了10 + 15 + 20=45个样本,所以准确率(Accuracy)=45/66 = 68.2%。

    以猫为例,我们可以将上面的图合并为二分问题:

    Precision

    所以,以猫为例,模型的结果告诉我们,66只动物里有13只是猫,但是其实这13只猫只有10只预测对了。模型认为是猫的13只动物里,有1条狗,两只猪。所以,Precision(猫)= 10/13 = 76.9%

    Recall

    以猫为例,在总共18只真猫中,我们的模型认为里面只有10只是猫,剩下的3只是狗,5只都是猪。这5只八成是橘猫,能理解。所以,Recall(猫)= 10/18 = 55.6%

    Specificity

    以猫为例,在总共48只不是猫的动物中,模型认为有45只不是猫。所以,Specificity(猫)= 45/48 = 93.8%。

    虽然在45只动物里,模型依然认为错判了6只狗与4只猫,但是从猫的角度而言,模型的判断是没有错的。

    (这里是参见了Wikipedia,Confusion Matrix的解释,https://en.wikipedia.org/wiki/Confusion_matrix)

    F1-Score

    通过公式,可以计算出,对猫而言,F1-Score=(2 * 0.769 *  0.556)/( 0.769 +  0.556) = 64.54%

    同样,我们也可以分别计算猪与狗各自的二级指标与三级指标值。

     

     

    ROC曲线在R中的实现

    library(ISLR)
    
    cor(Smarket[,-9])
    attach(Smarket)
    
    # logistic Model
    model_LR <- glm(Direction ~ Lag1 + Lag2 + Lag3 + Lag4 + Lag5 + Volume,
                    family = binomial,
                    data = Smarket)
    
    # Make prediction 
    prob_LR <- predict(model_LR, type = 'response', newdata = Smarket[1:300,])
    prob_LR <- predict(model_LR, type = 'response', newdata = Smarket[,])
    
    
    # create a vector of class predictions based on wether the predicted probability of a market increase is greater than or less than 0.5
    pred_LR <- rep("Down" , 1250)          
    pred_LR[prob_LR > 0.5] = 'Up'        
    
    # Confusion Matrix
    table(pred_LR, Direction)
    

     

    展开全文
  • 基于支持向量机的图像分类(下篇:MATLAB实现)

    万次阅读 多人点赞 2018-04-11 00:19:20
    摘要:本文通过图文详细介绍如何利用支持向量机对图像进行分类,经过上篇文章对原理的介绍,这里介绍利用MATLAB编程实现。后续章节将介绍的主要部分有: 图片数据集整理 特征提取 SVM训练与测试 分类结果...
  • 从决策树学习谈到贝叶斯分类算法、EM、HMM

    万次阅读 多人点赞 2012-05-17 21:06:53
    第一篇:从决策树学习谈到贝叶斯分类算法、EM、HMM (Machine Learning & Data Mining交流群:8986884)引言 最近在面试中,除了基础 & 算法 & 项目之外,经常被问到或被要求介绍和描述下自己所知道...
  • CSDN分类专栏操作演示

    万次阅读 多人点赞 2019-08-21 12:06:53
    博客专栏与文章分类合并为分类专栏,同时新增二级分类功能。新创建的分类专栏不能超过50个(包含二级),标签不能超过3个。 之前创建超过数量的分类专栏不会自动合并,暂时先保持不变。 新分类专栏管理页面如下,...
  • BERT模型实战之多文本分类(附源码)

    万次阅读 多人点赞 2019-03-21 11:00:36
    写在前面 BERT模型也出来很久了,之前看了论文学习...这篇文章的内容还是以比较简单文本分类任务入手,数据集选取的是新浪新闻cnews,包括了[‘体育’, ‘财经’, ‘房产’, ‘家居’, ‘教育’, ‘科技’, ‘时尚’...
  • opencv3.3版本训练自己的物体分类

    万次阅读 多人点赞 2018-01-09 11:04:22
    Opencv训练自己分类器 注:此文是我整理了网上的各方资料汇集而成,由于在实践中遇到了很多坑,所以把自己的成功训练的经验写下来做个笔记给大家做个参考,本文所使用 opencv版本为3.3 下载链接:...
  • 图像分类

    万次阅读 2018-01-21 15:31:47
    图像物体分类与检测算法综述 转自《计算机学报》 目录 图像物体分类与检测算法综述 目录 图像物体分类与检测概述 物体分类与检测的难点与挑战 物体分类与检测数据库 物体分类与检测发展历程 ...
  • 分类问题的评估(二分类&多分类

    万次阅读 2018-06-02 09:19:10
    对于二分类问题,可将样例根据其真实类别和分类器预测类别划分为: 真正例(True Positive,TP):真实类别为正例,预测类别为正例。 假正例(False Positive,FP):真实类别为负例,预测类别为正例。 假负例...
  • 文本分类——常见分类模型

    万次阅读 多人点赞 2018-11-06 17:37:56
      文本分类方法模型主要分为两个大类,一类是基于规则的分类模型;另一类是基于概率统计的模型。 基于规则的模型   基于规则的分类模型相对简单,易于实现。它在特定领域的分类往往能够取得较好的效果。相对于...
  • 分类

    万次阅读 2018-09-21 21:23:10
    分类器的作用:常规任务是利用给定的类别、已知的训练数据来学习分类规则和分类器,然后对未知数据进行分类(或预测)。逻辑回归(logistics)、SVM等常用于解决二分类问题,对于多分类问题(multi-class ...
  • 数据挖掘算法——常用分类算法总结

    万次阅读 多人点赞 2019-06-17 10:55:22
    常用分类算法总结分类算法总结NBC算法LR算法SVM算法ID3算法C4.5 算法C5.0算法KNN 算法ANN 算法 分类算法总结 分类是在一群已经知道类别标号的样本中,训练一种分类器,让其能够对某种未知的样本进行分类分类算法...
  • 对于分类器,或者说分类算法,评价指标主要有precision,recall,F-score1,以及即将要讨论的ROC和AUC。本文通过对这些指标的原理做一个简单的介绍,然后用python分别实现二分类和多分类的ROC曲线。 1 基本概念...
  • 本文为原创文章:http://blog.csdn.net/programmer_wei/article/details/52072939Logistic Regression(逻辑回归)是机器学习中一个非常非常常见的模型,在实际生产环境中也常常被使用,是一种经典的分类模型(不是...
  • 详解sigmoid与softmax, 多分类及多标签分类

    万次阅读 多人点赞 2018-09-19 21:35:50
    详解sigmoid与softmax, 多分类及多标签分类激活函数介绍sigmoid激活函数sigmoid激活函数的性质sigmoid激活函数的使用 激活函数介绍 对于熟悉机器学习或神经网络的读者来说,sigmoid与softmax两个激活函数并不陌生,...
  • 该案例是实际开发中运用,java递归查询分类分类下所有子分类。代码走起:1.jsp页面布局样式这里不再介绍,js业务逻辑展示分类树形结构如下:/** * 商品分类操作 */ /** * 初始化 */ $(function(){ //加载树 ...
  • 我本次对4类文本进行分类((所有截图代码和数据集最后附带免费下载地址)) 主要步骤: 1.各种读文件,写文件 2.使用jieba分词将中文文本切割 3.对处理之后的文本开始用TF-IDF算法进行单词权值的计算 4....
  • 分类和多分类问题的评价指标总结

    万次阅读 多人点赞 2019-07-09 18:51:55
    分类评价指标 准确率(Accuracy) 评价分类问题的性能指标一般是分类准确率,即对于给定的数据,分类正确的样本数占总样本数的比例。 注意:准确率这一指标在Unbalanced数据集上的表现很差,因为如果我们的正负...
  • 分类及多标签分类算法

    万次阅读 2019-04-08 19:49:55
    一、单标签多分类 1、单标签二分类算法原理 1、单标签二分类这种问题是我们最常见的算法问题,主要是指label 标签的取值只有两种,并且算法中只有一个需要预测的label标签; 直白来讲就是每个实例的可能类别...
  • 快速搭建垃圾分类模型
  • 新闻分类:多分类问题

    千次阅读 2018-09-13 21:25:54
    因为有多个类别,且每个数据点只能划分到一个类别,所以是单标签、多分类问题 准备数据 首先,加载数据 from keras.datasets import reuters (train_data, train_labels), (test_data, test_labels)...
  • 一对一方法是在任意两类样本之间设计创建一个二值分类器,对每一个样本都需要用所有的二值分类器进行分类,然后得票最多的类别即为该未知样本的预测类别。这样的话,两类样本我们就要设计C22个分类器,三类样本就要...
  • PyTorch: Softmax多分类实战

    万次阅读 热门讨论 2018-02-11 12:41:11
    分类一种比较常用的做法是在最后一层加softmax归一化,值最大的维度所对应的位置则作为该样本对应的类。本文采用PyTorch框架,选用经典图像数据集mnist学习一波多分类。 MNIST数据集 MNIST 数据集(手写数字...
  • 文本分类:短文本分类

    千次阅读 2018-09-13 11:49:25
    文本分类:短文本分类 应用场景:我们在和智能产品(如智能音箱,服务机器人,智能电话,车机,手机助手等)对话时。产生的一般都是口语化的短文本。那么如何对短文本进行分类来识别用户意图呢。下面介绍一下集中...
  • 机器学习系列(七)——分类问题(classification)

    万次阅读 多人点赞 2018-08-19 19:28:41
    这一篇博客将介绍机器学习中另一个重要的任务——分类(classification),即找一个函数判断输入数据所属的类别,可以是二类别问题(是/不是),也可以是多类别问题(在多个类别中判断输入数据具体属于哪一个类别)...
  • IP地址的分类方法及怎样判别IP属于哪一类 IP地址的地址块概念理解及地址块范围划分方法 IP地址中的特殊地址详解 IP地址中的单播、组播、广播简析 分类编址:通过IP地址和掩码计算网络地址详解 分类编址:基于IP...
  • ML之分类预测之ElasticNet:利用ElasticNet回归对二分类数据集构建二分类器(DIY交叉验证+分类的两种度量PK) 目录 输出结果 设计思路 核心代码 输出结果 设计思路 核心代码 #(4)交叉...
  • 分类:基于规则的分类技术

    千次阅读 2018-09-30 16:13:05
    基于规则的分类是一种比较简单的分类技术,下面从以下几个方面对其进行介绍  1.任务  所有的分类技术的任务都是利用数据集训练出分类器,然后为每条记录贴上标签,对其进行分类,基于规则的分类任务也是如此。 ...

空空如也

1 2 3 4 5 ... 20
收藏数 554,376
精华内容 221,750
关键字:

分类