精华内容
下载资源
问答
  • 基于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)
    

     

    展开全文
  • 文本分类——常见分类模型

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

      文本分类方法模型主要分为两个大类,一类是基于规则的分类模型;另一类是基于概率统计的模型。

    基于规则的模型

      基于规则的分类模型相对简单,易于实现。它在特定领域的分类往往能够取得较好的效果。相对于其它分类模型来说,基于规则的分类模型的优点就是时间复杂度低、运算速度快。在基于规则的分类模型中,使用许多条规则来表述类别。类别规则可以通过领域专家定义,也可以通过计算机学习获得。
      决策树就是一种基于训练学习方法获取分类规则的常见分类模型,它建立对象属性与对象值之间的一种映射。通过构造决策树来对未标注文本进行分类判别。常用的决策树方法包括CART 算法、ID3、C4.5、CHAID 等。
      在Web文本应用领域普遍存在着层级形式,这种层级形式可以通过一颗决策树来描述。决策树的根节点表示整个数据集空间,每个子节点是依据单一属性做出的分支判定,该判定将数据集分成两个或两个以上的分支区域。决策树的叶子节点就是相应类别的数据集合。
      决策树分类模型的一般构建过程:
      1.首先将训练数据分成两部分,一部分(训练集A)用于构建初始决策树,另一部分(训练集B)用来对决策树进行剪枝;
      2.以训练集A作为树的根节点,找出变异量最大的属性变量作为高层分割标准;以训练集A作为树的根节点,找出变异量最大的属性变量作为高层分割标准;
      3.通过对训练集A的学习训练构建一颗初始决策树;通过对训练集A的学习训练构建一颗初始决策树;
      4.再通过训练集B对初始决策树进行剪枝操作;再通过训练集B对初始决策树进行剪枝操作;
      5.一般还要通过递归的过程来构建一颗稳定的决策树,根据预测结果的正确率及未满足条件,则再对决策树进行分支或剪枝。
      决策树的构建过程一般是自上而下的,剪枝的方法有多种,但是具有一致目标,即对目标文本集进行最优分割。决策树可以是二叉树也可以是多叉树。

    基于概率的模型

      假设未标注文档为d,类别集合为C={c1,c2,…,cm} ,概率模型分类是对1≤i≤n 求条件概率模型P(ci|d) ,将与文档d条件概率最大的那个类别作为该文档的输出类别。其中朴素贝叶斯分类器是应用最为广泛的概率分类模型。
      朴素贝叶斯分类的基本思想是利用词组与类别的联合概率来估计给定文档的类别概率。基于贝叶斯分类器的贝叶斯规则如式:

    其中:C和D为随机变量。
      贝叶斯规则计算文档d属于每一个类别的可能性 P(ci|d),然后将文档d标注为概率最大的那一类。对文档d的贝叶斯分类如下式

      先验概率P(ci) 的估计很简单,计算如下式所示:

      其中: N(ci) 表示训练集中类别ci 的样本数量,N为训练集样本总数。 本质上表示训练集样例中类别ci 的比例。

      概率P(d|ci) 计算相对复杂,它首先基于一个贝叶斯假设:文档d为词组元素的集合,集合中词组(元素)之间相互独立。由于文档的表示简化了,所以这也就是朴素(Naïve) 的由来之一。事实上,词组之间并不是相互独立的。虽然这是一种假设独立性,但是朴素贝叶斯还是能够在分类任务中表现出很好的分类效果和鲁棒性。这一假设简化了联合概率的计算,它允许条件概率的乘机来表示联合概率。P(d|ci) 的计算式:

    其中:tk 表示含有n项词组的词组表vi 中的一个词组。因此,估计P(d|ci) 变为估计词组表v中的每一个词组在每一个类别下的概率P(tk|ci)
      概率的估计与分类结果非常依赖于事件空间的选择。下面介绍两种卡内基梅隆大学McCallum 和 Nigam 提出的事件空间模型,并说明相应的P(tk|ci) 是如何估计的。
      1) 多重伯努利模型
      多重伯努利(Multiple-Bernoulli)事件空间是一种布尔独立模型的事件空间,为每一个词组tk 建立一个二值随机变量。最简单的方式就是使用最大似然估计来估计概率,即式:

    其中: df(tk|ci) 表示类别ci 含有词组tk 的样本数量。
      虽然上式来估计概率很简单,但是存在“零概率”问题,真实应用是不可能的。这就需要采用平滑技术来克服“零概率”问题。贝叶斯平滑是一种常用的平滑估计技术。多重伯努利模型的平滑估计如下式所示:

    其中: αkβk 是依赖与词组tk 的参数。一种常见的参数选择方式是αk =1且βk* =0,得到如下概率估计公式

      多重伯努利模型仅仅考虑词组是否出现,而没有考虑出现的多少,而词频也是一个重要分类信息。下面介绍加入词频信息的多项式模型。
      2) 多项式模型
      多项式(Multinomial)时间空间与多重伯努利事件空间类似,但是多项式事件空间假设词组的出现次数是零次或多次,而不是出现与否。
      多项式模型的最大似然估计计算如式:

    其中: tf(tk|ci) 表示训练集中类别ci 中词组tk 出现的次数。 |ci|表示训练集类别ci 中的总词数。加入平滑估计的概率如式:

    这里 αk 是依赖于词组tk 的参数。对所有词组tk* 取αk =1是一种常见选择。这就导致概率估计:

    实际应用中,多项式模型已经表明优于多重伯努利模型。

    基于几何的模型

      使用向量空间模型表示文本,文本就被表示为一个多维的向量,那么它就是多维空间的一个点。通过几何学原理构建一个超平面将不属于同一个类别的文本区分开。最典型的基于几何学原理的分类器是支持向量机(SVM),最简单的SVM应用就是二值分类,就是常见的正例和反例。SVM的目标就是构建能够区分正例和反例的N维空间决策超平面。
      SVM是上世纪九十年代中期,由Vapnik等人逐渐完善的统计机器学习理论。该模型主要用来解决模式识别中的二分类问题,在文本分类、手写识别、图像处理等领域都取得了很好的分类效果。其基本思想就是在向量空间中找到一个决策超平面,该决策超平面能够最大限度地将正例和反例区分开来。在一定的范围内,决策超平面是可以平行移动的,这种平移不会造成训练集数据的分类错误。但是为了获取在未知样本的分类预测中的稳定性,要求分类超平面距离两类样本的距离尽可能大,也就是说,超平面尽可能位于边界区域的中心位置。
      SVM采用计算学习理论的结构风险最小化(Structural Risk Minimization, SRM)原则。其主要思想:以支持向量(Support Vector, SV)作为训练集的基础,在N维空间内寻找能将训练集样本分成两类,并且具有最大边缘(Margin)值的最优超平面(Optimal Separating Hyper-plane,OSH),来达到最大的分类正确率。
      SVM选择最大化边缘距离的分类决策超平面,这个选择不仅直观,而且也得到了理论的支持。对于线性可分数据的超平面以及支持向量的图形解释如图:

    线性可分数据支持向量机示意图

    其中:左上方为正例区域,右下方为反例区域,中间实线为w定义的决策超平面,箭头所示为边缘,虚线方框内的样本表示支持向量。边缘(Margin)的定义如式:

    其中:x- 是训练集距离超平面最近的反例, x+ 是训练集距离超平面最近的正例。定义边缘(Margin)为x- 到决策超平面距离与x+ 到决策超平面距离之和。
      SVM算法中超平面的概念是发现使分离数据最大边缘化的超平面w。一个等价的形式是,寻找解决下列优化问题的决策超平面,如式:

    这一优化目标容易求解,一般通过动态规划来解决。
      现实世界中的数据集很少是线性可分的。为了解决这个问题,一般需要修改SVM优化目标公式加入惩罚因子来完成不满足线性可分约束的训练实例的分类。加入了惩罚因子的SVM最优化目标如式:

    这里ζi 表示允许目标被违反的松弛变量(Stack Variable),这个松弛变量加强了关键损失函数。
      另外一个SVM关键技术是核技巧,通过核函数将线性不可分的训练数据变换或映射到更高维空间中,得到线性可分的数据集。核函数技术大多数情形下都可以提高分类的精度。常用SVM核函数如下:
      线性核:

      多项式核:

      径向基(RBF)核(也称为高斯核):

      SVM能够取得比较好的分类效果。其优点在于:
      1.SVM是一种针对有限样本条件下的分类算法,其目标是得到当前训练集下的最优解而不是样本数趋于无穷大时的最优值,该算法最终将问题转化成二次线性规划寻求最优解问题。从理论上来讲,它得到的是全局最优解,能够避免局部极值问题。
      2.该方法将实际问题通过核函数技巧将线性不可分空间映射到高维线性可分空间,在高维空间中构造线性决策函数来实现原线性不可分空间的决策函数。这保证了SVM具有较好的推广能力,计算的复杂度不再取决于空间维数,而是取决于训练集样本数量。
      3.SVM方法能够很好的处理稀疏数据,更好的捕捉了数据的内在特征,准确率较高。
      SVM虽然有许多优点,但是固有的缺点是不可避免的。其缺点包括:
      1.SVM算法时间和空间复杂度较高,随着训练样本数和类别的增加,分类时间和空间代价很高。
      2.核函数空间变换会增加训练集空间的维数,使得SVM对时间和空间需求加大,又进一步降低了分类的效率。
      3.SVM算法一般含有较多参数,并且参数随着训练样本的不同,呈现较大的差异,调整参数以获得最优分类效果相对困难。而且参数的不同对分类结果的显示出较大的差异性。

    基于统计的模型

      基于统计的机器学习方法已经成为自然语言研究领域里面的主流研究方法。事实上无论是朴素贝叶斯分类模型,还是支持向量机分类模型,也都采用了统计的方式。文本分类算法中一种最典型的基于统计的分类模型就是k近邻(k-Nearest Neighbor,kNN)模型,是比较好的文本分类算法之一。
      kNN分类模型的主要思想:通过给定一个未标注文档d,分类系统在训练集中查找与它距离最接近的k篇相邻(相似或相同)标注文档,然后根据这k篇邻近文档的分类标注来确定文档d的类别。分类实现过程:
      1) 将训练集样本转化为向量空间模型表示形式并计算每一特征的权重;
      2) 采用类似步骤1的方式转化未标注文档d并计算相应词组元素的权重;
      3) 计算文档d与训练集样本中每一样本的距离(或相似度);
      4) 找出与文档d距离最小(或相似度最大)的k篇训练集文本;
      5) 统计这个k篇训练集文本的类别属性,一般将文档d的类归为k中最多的样本类别。

      kNN 分类模型是一种“懒学习”算法,实质上它没有具体的训练学习过程。分类过程只是将未标注文本与每一篇训练集样本进行相似度计算, kNN 算法的时间和空间复杂度较高。因而随着训练集样本的增加,分类的存储资源消耗大,时间代价高。一般不适合处理训练样本较大的分类应用。

    知更鸟博文推荐
    上一篇 文本分类——特征选择概述
    下一篇 文本分类——算法性能评估
    推荐篇 基于Kubernetes、Docker的机器学习微服务系统设计——完整版
    研究篇 RS中文分词   |  MP特征选择   |  NLV文本分类   |  快速kNN
    作者简介
    兴趣爱好 机器学习、云计算、自然语言处理、文本分类、深度学习
    E-mail xsd-jj@163.com (欢迎交流)

    参考文献:
    [1].McCallum,A.,Nigam,K. A comparison of event models for naive Bayes text classification [C]. In: Proc. of the AAAI ’98 Workshop on Learning for Text Categorization. 41 - 48.
    [2].宗成庆. 统计自然语言处理[M].北京:清华大学出版社,2008
    [3].王斌,潘文峰.基于内容的垃圾邮件过滤技术综述[J].中文信息学报,19(5):1-10
    [4].Yang,Y.,Liu,X. A re-examination of text categorization methods [C]. In: Proceedings of the 22nd ACM Int’l Conference on Research and Development in Information Retrieval. Berkeley: ACM Press: 42-49

    版权声明:个人原创,请勿抄袭,欢迎引用,未经许可禁止转载. © 知更鸟
    展开全文
  • 快速搭建垃圾分类模型

    前言

    AI实战:上海垃圾分类系列(一)之快速搭建垃圾分类模型
    AI实战:上海垃圾分类系列(二)之快速搭建垃圾分类模型后台服务
    AI实战:上海垃圾分类系列(三)之快速搭建垃圾分类智能问答机器人

    有上海网友说,如今每天去丢垃圾时,都要接受垃圾分类阿姨的灵魂拷问:“你是什么垃圾?”

    Emmmm…
    1
    为了避免每天阿姨的灵魂拷问,我们最好是出门前提前对垃圾进精准分类。

    下面提供一种快速搭建基于深度学习(AI)的垃圾分类模型,让垃圾分类不再难!


    垃圾分类模型搭建

    使用imagenet的1000个分类,模型网络使用inception-v3。再把1000个分类映射到垃圾的4个类别中,下面看详细步骤。

    • 搭建环境
      Ubuntu16.04
      python3.5
      tensorflow==1.4.0

    • 代码:
      classify_image.py:

    # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
    #
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.
    # ==============================================================================
    
    """Simple image classification with Inception.
    Run image classification with Inception trained on ImageNet 2012 Challenge data
    set.
    This program creates a graph from a saved GraphDef protocol buffer,
    and runs inference on an input JPEG image. It outputs human readable
    strings of the top 5 predictions along with their probabilities.
    Change the --image_file argument to any jpg image to compute a
    classification of that image.
    Please see the tutorial and website for a detailed description of how
    to use this script to perform image recognition.
    https://tensorflow.org/tutorials/image_recognition/
    """
    
    from __future__ import absolute_import
    from __future__ import division
    from __future__ import print_function
    
    import argparse
    import os.path
    import re
    import sys
    import tarfile
    
    import numpy as np
    from six.moves import urllib
    import tensorflow as tf
    
    FLAGS = None
    
    # pylint: disable=line-too-long
    DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'
    # pylint: enable=line-too-long
    
    
    class NodeLookup(object):
      """Converts integer node ID's to human readable labels."""
    
      def __init__(self, 
                    uid_chinese_lookup_path, 
                    label_lookup_path=None,
                    uid_lookup_path=None):
        if not label_lookup_path:
          label_lookup_path = os.path.join(
              FLAGS.model_dir, 'imagenet_2012_challenge_label_map_proto.pbtxt')
        if not uid_lookup_path:
          uid_lookup_path = os.path.join(
              FLAGS.model_dir, 'imagenet_synset_to_human_label_map.txt')
        #self.node_lookup = self.load(label_lookup_path, uid_lookup_path)
        self.node_lookup = self.load_chinese_map(uid_chinese_lookup_path)
        
    
      def load(self, label_lookup_path, uid_lookup_path):
        """Loads a human readable English name for each softmax node.
        Args:
          label_lookup_path: string UID to integer node ID.
          uid_lookup_path: string UID to human-readable string.
        Returns:
          dict from integer node ID to human-readable string.
        """
        if not tf.gfile.Exists(uid_lookup_path):
          tf.logging.fatal('File does not exist %s', uid_lookup_path)
        if not tf.gfile.Exists(label_lookup_path):
          tf.logging.fatal('File does not exist %s', label_lookup_path)
    
        # Loads mapping from string UID to human-readable string
        proto_as_ascii_lines = tf.gfile.GFile(uid_lookup_path).readlines()
        uid_to_human = {}
        #p = re.compile(r'[n\d]*[ \S,]*')
        p = re.compile(r'(n\d*)\t(.*)')
        for line in proto_as_ascii_lines:
          parsed_items = p.findall(line)
          print(parsed_items)
          uid = parsed_items[0]
          human_string = parsed_items[1]
          uid_to_human[uid] = human_string
    
        # Loads mapping from string UID to integer node ID.
        node_id_to_uid = {}
        proto_as_ascii = tf.gfile.GFile(label_lookup_path).readlines()
        for line in proto_as_ascii:
          if line.startswith('  target_class:'):
            target_class = int(line.split(': ')[1])
          if line.startswith('  target_class_string:'):
            target_class_string = line.split(': ')[1]
            node_id_to_uid[target_class] = target_class_string[1:-2]
    
        # Loads the final mapping of integer node ID to human-readable string
        node_id_to_name = {}
        for key, val in node_id_to_uid.items():
          if val not in uid_to_human:
            tf.logging.fatal('Failed to locate: %s', val)
          name = uid_to_human[val]
          node_id_to_name[key] = name
    
        return node_id_to_name
        
      def load_chinese_map(self, uid_chinese_lookup_path):
        # Loads mapping from string UID to human-readable string
        proto_as_ascii_lines = tf.gfile.GFile(uid_chinese_lookup_path).readlines()
        uid_to_human = {}
        p = re.compile(r'(\d*)\t(.*)')
        for line in proto_as_ascii_lines:
          parsed_items = p.findall(line)
          #print(parsed_items)
          uid = parsed_items[0][0]
          human_string = parsed_items[0][1]
          uid_to_human[int(uid)] = human_string
        
        return uid_to_human
    
      def id_to_string(self, node_id):
        if node_id not in self.node_lookup:
          return ''
        return self.node_lookup[node_id]
    
    
    def create_graph():
      """Creates a graph from saved GraphDef file and returns a saver."""
      # Creates graph from saved graph_def.pb.
      with tf.gfile.FastGFile(os.path.join(
          FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:
        graph_def = tf.GraphDef()
        graph_def.ParseFromString(f.read())
        _ = tf.import_graph_def(graph_def, name='')
    
    
    def run_inference_on_image(image):
      """Runs inference on an image.
      Args:
        image: Image file name.
      Returns:
        Nothing
      """
      if not tf.gfile.Exists(image):
        tf.logging.fatal('File does not exist %s', image)
      image_data = tf.gfile.FastGFile(image, 'rb').read()
    
      # Creates graph from saved GraphDef.
      create_graph()
    
      with tf.Session() as sess:
        # Some useful tensors:
        # 'softmax:0': A tensor containing the normalized prediction across
        #   1000 labels.
        # 'pool_3:0': A tensor containing the next-to-last layer containing 2048
        #   float description of the image.
        # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG
        #   encoding of the image.
        # Runs the softmax tensor by feeding the image_data as input to the graph.
        softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')
        predictions = sess.run(softmax_tensor,
                               {'DecodeJpeg/contents:0': image_data})
        predictions = np.squeeze(predictions)
    
        # Creates node ID --> chinese string lookup.
        node_lookup = NodeLookup(uid_chinese_lookup_path='./data/imagenet_2012_challenge_label_chinese_map.pbtxt')
    
        top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]
        for node_id in top_k:
          human_string = node_lookup.id_to_string(node_id)
          score = predictions[node_id]
          print('%s (score = %.5f)' % (human_string, score))
          #print('node_id: %s' %(node_id))
    
    
    def maybe_download_and_extract():
      """Download and extract model tar file."""
      dest_directory = FLAGS.model_dir
      if not os.path.exists(dest_directory):
        os.makedirs(dest_directory)
      filename = DATA_URL.split('/')[-1]
      filepath = os.path.join(dest_directory, filename)
      if not os.path.exists(filepath):
        def _progress(count, block_size, total_size):
          sys.stdout.write('\r>> Downloading %s %.1f%%' % (
              filename, float(count * block_size) / float(total_size) * 100.0))
          sys.stdout.flush()
        filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)
        print()
        statinfo = os.stat(filepath)
        print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')
      tarfile.open(filepath, 'r:gz').extractall(dest_directory)
    
    
    def main(_):
      maybe_download_and_extract()
      image = (FLAGS.image_file if FLAGS.image_file else
               os.path.join(FLAGS.model_dir, 'cropped_panda.jpg'))
      run_inference_on_image(image)
    
    
    if __name__ == '__main__':
      parser = argparse.ArgumentParser()
      # classify_image_graph_def.pb:
      #   Binary representation of the GraphDef protocol buffer.
      # imagenet_synset_to_human_label_map.txt:
      #   Map from synset ID to a human readable string.
      # imagenet_2012_challenge_label_map_proto.pbtxt:
      #   Text representation of a protocol buffer mapping a label to synset ID.
      parser.add_argument(
          '--model_dir',
          type=str,
          default='/tmp/imagenet',
          help="""\
          Path to classify_image_graph_def.pb,
          imagenet_synset_to_human_label_map.txt, and
          imagenet_2012_challenge_label_map_proto.pbtxt.\
          """
      )
      parser.add_argument(
          '--image_file',
          type=str,
          default='',
          help='Absolute path to image file.'
      )
      parser.add_argument(
          '--num_top_predictions',
          type=int,
          default=5,
          help='Display this many predictions.'
      )
      FLAGS, unparsed = parser.parse_known_args()
      tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)
    
    • 下载模型
      python classify_image.py

      下载成功是这个样子的: 3

    • 模型测试

      从网上找一张图片,保存为:./img/2.png,如下:

      1
      测试方法:
      python classify_image.py --image_file ./data/2.png

      结果输出:

      cellular telephone, cellular phone, cellphone, cell, mobile phone (score = 0.70547)
      iPod (score = 0.06823)
      notebook, notebook computer (score = 0.04934)
      modem (score = 0.01472)
      hand-held computer, hand-held microcomputer (score = 0.00770)
      

      可以看到识别结果还是蛮准的,而且给出了top5.

      使用中文标签:
      测试方法:
      python classify_image.py --image_file ./data/2.png

      结果输出:

      移动电话,移动电话,手机,手机,手机 (score = 0.70547)
      iPod (score = 0.06823)
      笔记本,笔记本电脑 (score = 0.04934)
      调制解调器 (score = 0.01472)
      手持电脑,手持微电脑 (score = 0.00770)
      

      有了中文分类类别,下面就可以做垃圾分类映射了。

    垃圾分类映射

    上海对垃圾分干垃圾、湿垃圾、可回收物、有害垃圾四种,生活垃圾主要分干垃圾和湿垃圾。

    上海生活垃圾分类标准及投放要求 【点击查看】

    • 核心思想:
      1、使用4类垃圾分类数据作为标注数据,形如

        0	饮料瓶
        1	废电池
        2	绿叶菜
        3	卫生间用纸
      

      2、使用TextCNN训练分类模型

      • 实战
        1、数据标注
        标注结果见:./data/train_data.txt , ./data/vilid_data.txt

        2、核心代码:
        predict.py :

        import tensorflow as tf
        import numpy as np
        import os, sys
        import data_input_helper as data_helpers
        import jieba
        
        # Parameters
        
        # Data Parameters
        tf.flags.DEFINE_string("w2v_file", "./data/word2vec.bin", "w2v_file path")
        
        # Eval Parameters
        tf.flags.DEFINE_integer("batch_size", 64, "Batch Size (default: 64)")
        tf.flags.DEFINE_string("checkpoint_dir", "./runs/checkpoints/", "Checkpoint directory from training run")
        
        # Misc Parameters
        tf.flags.DEFINE_boolean("allow_soft_placement", True, "Allow device soft device placement")
        tf.flags.DEFINE_boolean("log_device_placement", False, "Log placement of ops on devices")
        
        FLAGS = tf.flags.FLAGS
        FLAGS._parse_flags()
        
        
        class RefuseClassification():
        
            def __init__(self):
            
                self.w2v_wr = data_helpers.w2v_wrapper(FLAGS.w2v_file)#加载词向量
                self.init_model()
                self.refuse_classification_map = {0: '可回收垃圾', 1: '有害垃圾', 2: '湿垃圾', 3: '干垃圾'}
                
                
            def deal_data(self, text, max_document_length = 10):
                
                words = jieba.cut(text)
                x_text = [' '.join(words)]
                x = data_helpers.get_text_idx(x_text, self.w2v_wr.model.vocab_hash, max_document_length)
        
                return x
        
        
            def init_model(self):
                
                checkpoint_file = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
                graph = tf.Graph()
                with graph.as_default():
                    session_conf = tf.ConfigProto(
                                      allow_soft_placement=FLAGS.allow_soft_placement, 
                                      log_device_placement=FLAGS.log_device_placement)
                    self.sess = tf.Session(config=session_conf)
                    self.sess.as_default()
                    # Load the saved meta graph and restore variables
                    saver = tf.train.import_meta_graph("{}.meta".format(checkpoint_file))
                    saver.restore(self.sess, checkpoint_file)
        
                    # Get the placeholders from the graph by name
                    self.input_x = graph.get_operation_by_name("input_x").outputs[0]
                  
                    self.dropout_keep_prob = graph.get_operation_by_name("dropout_keep_prob").outputs[0]
        
                    # Tensors we want to evaluate
                    self.predictions = graph.get_operation_by_name("output/predictions").outputs[0]
                        
            
            def predict(self, text):
            
                x_test = self.deal_data(text, 5)
                predictions = self.sess.run(self.predictions, {self.input_x: x_test, self.dropout_keep_prob: 1.0})
                
                refuse_text = self.refuse_classification_map[predictions[0]]
                return refuse_text
        
        
        if __name__ == "__main__":
            if len(sys.argv) == 2:
                test = RefuseClassification()
                res = test.predict(sys.argv[1])
                print('classify:', res)
        

      3、测试
      python textcnn/predict.py '猪肉饺子'

      输出结果:

        	`classify: 湿垃圾`
      

    整合imagenet分类模型、textcnn映射模型

    • 核心代码:
      rafuse.py
    import numpy as np
    import os, sys
    sys.path.append('textcnn')
    from textcnn.predict import RefuseClassification
    from classify_image import *
    
    
    class RafuseRecognize():
        
        def __init__(self):
            
            self.refuse_classification = RefuseClassification()
            self.init_classify_image_model()
            self.node_lookup = NodeLookup(uid_chinese_lookup_path='./data/imagenet_2012_challenge_label_chinese_map.pbtxt', 
                                    model_dir = '/tmp/imagenet')
            
            
        def init_classify_image_model(self):
            
            create_graph('/tmp/imagenet')
    
            self.sess = tf.Session()
            self.softmax_tensor = self.sess.graph.get_tensor_by_name('softmax:0')
            
            
        def recognize_image(self, image_data):
            
            predictions = self.sess.run(self.softmax_tensor,
                                   {'DecodeJpeg/contents:0': image_data})
            predictions = np.squeeze(predictions)
    
            top_k = predictions.argsort()[-5:][::-1]
            result_list = []
            for node_id in top_k:
                human_string = self.node_lookup.id_to_string(node_id)
                #print(human_string)
                human_string = ''.join(list(set(human_string.replace(',', ',').split(','))))
                #print(human_string)
                classification = self.refuse_classification.predict(human_string)
                result_list.append('%s  =>  %s' % (human_string, classification))
                
            return '\n'.join(result_list)
            
    
    if __name__ == "__main__":
        if len(sys.argv) == 2:
            test = RafuseRecognize()
            image_data = tf.gfile.FastGFile(sys.argv[1], 'rb').read()
            res = test.recognize_image(image_data)
            print('classify:\n%s' %(res))
    
    • 垃圾分类识别

      • 识别
        python rafuse.py img/2.png

        输出结果:

           移动电话手机  =>  可回收垃圾
           iPod  =>  湿垃圾
           笔记本笔记本电脑  =>  可回收垃圾
           调制解调器  =>  湿垃圾
           手持电脑手持微电脑  =>  可回收垃圾
        

      到这里整个垃圾分类识别模型基本完成,可以看到有个别错误,由于训练数据太少了导致的,这里就不在优化了。


    完整工程代码

    完整工程:https://download.csdn.net/download/zengnlp/11290336
    包含:
     1、垃圾分类映射的训练数据、测试数据
     2、完整代码


    参考

    https://github.com/tensorflow/models

    展开全文
  • 分类模型和回归模型

    千次阅读 2018-07-30 15:44:03
    概念:对于分类问题,监督学习从数据中学习一个分类模型或者分类决策函数,称为分类器。分类器对新的输入预测其属于哪一类别,称为分类。 优化过程:找到最优决策面 输出:离散值,如0/1,yes/no 评价指标:一般...
  • 常见的机器学习分类模型

    千次阅读 2019-06-30 17:30:17
    Spark mllib包含的分类模型有:逻辑回归,决策树,随机森林,梯度提升树,多层感知机,线性SVM,朴素贝叶斯。 回归模型有:线性回归,决策树回归,随机森林回归,梯度提升树回归,生存回归,保序回归。 在spark ...
  • 分类模型评价方法

    千次阅读 2019-01-16 22:17:29
    分类模型是输出只有0,1的分类模型。本文介绍二分类模型的评价指标。 from sklearn import metrics y_pred = [0, 1, 0, 0] #模型的预测输出 y_true = [0, 1, 0, 1] #真实值 二分类模型中可能的分类结果如下...
  • 常见分类模型python实现

    万次阅读 2019-09-03 23:17:06
    1.常用分类模型 SVM MLP Bayes GBDT Logistic Regressor 2.python实现 sklearn上已经有现成的包。 SVC: import numpy as np X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]]) y = np.array([1, 1, 2...
  • logistic回归是一个二分类模型

    万次阅读 2021-03-09 16:54:52
    首先给大家强调一点,这是一个分类模型而不是一个回归模型!下文开始将从不同方面讲解logistic回归的原理,随后分别使用梯度上升算法和随机梯度上升算法将logistic回归算法应用到实例中。 一、logistic回归和线性...
  • 分类模型评价指标

    千次阅读 2019-05-20 14:39:49
    在分类型模型评判的指标中,常见的方法有如下三种: ...混淆矩阵就是分别统计分类模型归错类,归对类的观测值个数,然后把结果放在一个表里展示出来。这个表就是混淆矩阵。 ROC是一条线,如果我们选择用...
  • 分类模型的评估方法

    千次阅读 2017-12-14 01:30:19
    在检验集上计算出的准确率或...在训练集上归纳分类模型,在检验集上评估模型的性能。训练集和检验集的划分比例通常根据专家的判断,例如50-50,或者2/3作为训练集,1/3作为检验集。模型的准确率根据模型在检验集上的准
  • 集成分类模型便是综合考量多个分类器的预测结果,从而做出决策。具体分为两种: 一种是利用相同的训练数据同时搭建多个独立的分类模型,然后通过投票的方式,以少数服从多数的原则作出最终的分类决策。代表模型有...
  • 图卷积图像分类模型

    千次阅读 2020-03-26 10:51:21
    本周推荐《Multi-Label Image Recognition with Graph ...旷视研究院提出一种基于图卷积网络(Graph Convolutional Network,GCN)的多标签分类模型。该模型通过 data-driven 方式建立标记间有向图(direct...
  • 在使用sklearn训练完分类模型后,下一步就是要验证一下模型的预测结果,对于分类模型,sklearn中通常提供了predict_proba、predict、decision_function三种方法来展示模型对于输入样本的评判结果。 说明一下,在...
  • 评价分类模型的性能指标

    万次阅读 2018-03-28 22:52:59
    当一个模型构建完成之后,我们可以通过几个不同的性能指标来衡量分类模型的相关性能,常用的分类性能指标有准确率(precision)、召回率(recall)和F1分数(F1-score)。 一、混淆矩阵 混淆矩阵(confusion matrix):是...
  • 7.7 分类模型评估

    千次阅读 2017-06-29 22:09:16
    sklearn库的metrics模块提供各种评估方法,包括分类评估、回归评估、聚类评估和交叉验证等,本节主要介绍分类模型评估方法。 评估分类是判断预测值时否很好的与实际标记值相匹配。正确的鉴别出正样本(True ...
  • 机器学习中的分类模型和回归模型

    千次阅读 2018-06-20 16:34:44
    机器学习中的分类模型 1.KNN 2.感知机 3.朴素贝叶斯法 4.决策树 5.逻辑斯谛回归模型 6.SVM 7.AdaBoost 8.随机森林 9.贝叶斯网络 10.神经网络 机器学习中的回归模型 1.线性回归 2.多项式回归 3.岭...
  • 朴素贝叶斯分类模型(一)

    万次阅读 多人点赞 2019-01-28 17:29:22
    通俗地讲分类算法就是把大量已知特征及类别的样本对象输入计算机,让计算机根据这些已知的类别与特征归纳出类别与特征之间的规律(准确地说应该是分类模型),最终目的是运用得到的分类模型对新输入的对象(该对象...
  • 机器学习—分类模型

    万次阅读 2018-09-25 22:14:03
    第二章 分类模型 给定训练数据 分类任务学习一个输入x到输出y的映射f: //最大后验估计 其中,y为离散值,其值范围为标签空间: 当C=2时,为两类分类问题 贝叶斯公式 先验概率 p(y=c)//根据以往的经验和分析...
  • MATLAB自带分类模型APP——classification learner的使用 MATLAB自带分类模型APP——classification learner的使用MATLAB对常用的机器学习的分类模型做了集合,也就是形成了它自带的classification learner APP,...
  • 怎么将二分类模型应用到多分类问题 二分类模型数量众多,但实际应用中往往待预测类别数量不只有2个,于是有了一些将二分类模型应用到多分类的方法。 常见二分类模型 One-vs-Rest One-vs-One Directed Acyclic ...
  • 基于BERT的超长文本分类模型

    千次阅读 2020-04-11 23:00:29
    基于BERT的超长文本分类模型0.Abstract1.任务介绍数据集评估方法测试集 0.Abstract 本文实现了一个基于BERT+LSTM实现超长文本分类的模型, 评估方法使用准确率和F1 Score. 项目代码github地址: 1.任务介绍 用BERT做...
  • 分类模型的评价及比较

    万次阅读 2018-09-06 08:42:02
    评价和比较分类模型时,关注的是其泛化能力,因此不能仅关注模型在某个验证集上的表现。事实上,如果有足够多的样本作为验证集来测试模型的表现是再好不过的,但即使是这样也存在一个难点,比如难界定多大的样本才能...
  • 提纲:分类模型 与 Loss 函数的定义,为什么不能用 Classification Error,Cross Entropy 的效果对比,为什么不用 Mean Squared Error,定量理解 Cross Entropy,总结,参考资料。分类模型 与 Loss 函数的定义分类和...
  • NLP之BERT分类模型部署提供服务

    千次阅读 热门讨论 2019-06-27 11:09:16
    在我们使用bert预分类模型微调之后(可以参考我前面写的文章),需要对项目进行支持,那就需要分类模型落地提供服务,这篇文章介绍python调用bert模型,提供服务。 参考:...
  • 数据集: 线性模型
  • 基于Tensorflow的LSTM-CNN文本分类模型

    万次阅读 多人点赞 2018-04-26 15:24:47
    题记 前段时间再看QA方面的文章,读了一篇paper(《LSTM-based deep learning model for non-...受此启发,使用这个模型对文本语义信息进行抽取,加上一个softmax函数形成文本分类模型。1.LSTM(Long Short-Ter...
  • 在本篇文章中,我将概述如何使用卷积神经网络构建可靠的图像分类模型,以便从胸部x光图像中检测肺炎的存在。 肺炎是一种常见的感染,它使肺部的气囊发炎,引起呼吸困难和发烧等症状。尽管肺炎并不难治疗,但及时...
  • 分类模型评价及AUC计算详解

    千次阅读 2019-09-05 21:08:36
    1、分类模型评测指标 在使用模型进行分类时,一般使用准确度(Accuracy)、精确率(Precision)、召回率(Recall)作为评测指标对模型的好坏进行评价,今天主要就auc进行介绍。 混淆表 分类器预测类别 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 582,910
精华内容 233,164
关键字:

分类模型