精华内容
下载资源
问答
  • 今天,我们来介绍一种新的用于多标签文本分类的框架:ALBERT+Denses,即通过多个二分类解决多标签分类问题。搭建这个框架的目的主要还是为了和其它几个不同的框架做一些对比,以及尝试一种新的方法来做多标签文本...

    d031d1af204b400a068a49adef48b9ae.png
    今天,我们来介绍一种新的用于多标签文本分类的框架:ALBERT+Denses,即通过多个二分类解决多标签分类问题。搭建这个框架的目的主要还是为了和其它几个不同的框架做一些对比,以及尝试一种新的方法来做多标签文本分类。

    232506df22543bf1a2aeb06b4af5f009.png
    目的:主要是兴趣,实现自己的想法,以及与其他框架对比下实验效果。
    • 这篇文章和之前写的一篇文章有一定的相似之处。
    HelloNLP:多标签文本分类 [ALBERT](附代码)zhuanlan.zhihu.com
    4f860d8da4aa7b3d525c436f0748c0f8.png

    一、介绍

    1. 此项目是在tensorflow版本1.14.0的基础上做的训练和测试。
    2. 任务类型为中文多标签文本分类,一共有K个标签:
    3. 模型的输入为一个sentence,输出为一个或者多个label。
    由于另外几篇文章有详细的介绍,所以这里就不不多说了。

    二、框架及算法

    1、Placeholder

    3d68f81ffd3ab63daa8c5884284235c1.png

    首先,我们需要设置一些占位符(Placeholder),占位符的作用是在训练和推理的过程中feed模型需要的数据。我们这里需要4个占位符,分别是input_ids、input_masks、segment_ids和label_ids。前面3个是我们了解的BERT输入特征,最后面一个是标签的id。

    2、ALBERT token-vectors

    be8958e10c7b44498669090767b04ad3.png

    从图中红色的框内可以看出,ALBERT需要传入3个参数(input_ids,input_masks、segment_ids),就可以得到我们所需要的一个2维向量output_layer:(batch_size, hidden_size)。

    有人在这里就会好奇,为什么ALBERT输出的是一个2维向量,而不是一个3维向量(batch_size, sequence_length, hidden_size)呢?那我们来看一下源码,弄清楚self.model.get_pooled_output()的来历。

    ad03d14c3226c6549b10e975cbec4f63.png

    其中self.sequence_ouput就是我们所说的那个3维向量(batch_size, sequence_length, hidden_size)。我们对这个3维向量做了一个"pooler"的操作,从而使之变成了一个2维的向量。

    蓝色方框内的解释为:”We "pool" the model by simply taking the hidden state corresponding to the first token. We assume that this has been pre-trained“。这句话怎么理解呢?意思是将整个句子的特征信息投射到句子第一个字的隐藏状态向量上面。并且,认为这个它是通过预训练得到的。

    3、Full connection

    cad10844e05a91b45576c0e10423eff9.png

    我们可以发现,这里使用了很多个全连接层。其中,每一个全连接层服务于一个label,以及每一个全连接层都是一个2分类。在这里,我们使用了tf.nn.softmax_cross_entropy_with_logits的交叉熵计算方式,而非tf.nn.sigmoid_cross_entropy_with_logits。因为对于一个二分类来说,我们要解决的是独占类标签。

    • 在计算损失值时,我们单独计算了每一个标签的损失值。
    • 另外,self.probabilities在这里的维度是一个3维向量(batch_size,hp.num_labels,2),而非一个二维向量,即每一个标签都是一个二分类。

    4、Inference

    7ba45a7a9f2ae4ccb7a384fb0f0d996b.png

    由于损失函数使用的是tf.nn.softmax_cross_entropy_with_logits,所以这里我们使用了tf.argmax来计算出预测值。另外,我们可以看出,在使用tf.argmax时,我们是对第3个维度使用了这个函数,这一点和我们平常使用的会有所区别。

    三、实践及框架图

    1、框架图

    c6aaed504f048554e819d47901cb4d0a.png

    2、模型Loss和Accuracy变化曲线图

    5c767a3ccefe213b1aea34ebe574f81c.png
    • 这个损失函数的收敛图和基于ALBERT框架的非常的类似,主要是由于他们的框架较为相似。
    • 根据上图,可以发现,当loss在0.0001左右时,模型接近收敛。这和常见的文本分类有较大的区别,一般文本分类在0.02和0.01区间模型已经收敛,这个主要是由于多标签文本分类中,有很多0,即空标签,在计算loss时,为空的0也会参与计算。
    疑问:为什么accuracy曲线会这么奇怪呢?
    Accuracy曲线出来后,也让我有一点吃惊。一开始以为是模型随机性导致的,所以又从新训练了一遍,发现还是一样的结果。
    后来想了一下,因为Accuracy的计算方式导致的。

    四、代码链接

    以后开放!

    相关文章:

    HelloNLP:多标签文本分类介绍,以及对比训练
    HelloNLP:多标签文本分类 [ALBERT+TextCNN](附代码)
    HelloNLP:多标签文本分类 [ALBERT](附代码)
    HelloNLP:多标签文本分类 [ALBERT+Seq2Seq+Attention]
    展开全文
  • 该项目主要目的是解决基于深度神经网络的多标签文本分类问题。 因此,根据这种问题特征,数据标签格式类似于[0、1、0,...,1、1]。 要求 Python 3.6 Tensorflow 1.15.0 Tensorboard 1.15.0 斯克莱恩...
  • 我看你在多标签分类中用到了B-CNN,在VehicleDC.py中这样写: “X = torch.bmm(X, torch.transpose(X, 1, 2)) / (1 ** 2) # Bi-linear CNN” 我看了B-CNN代码,并没有看到这样方法。 ...
  • 基于实现多光谱图像的多标签场景分类目的,采用卷积神经网络方法,通过计算数据集中所有样本标签共现矩阵,利用共现矩阵为每个标签分配不同权重,提出了一种新计算损失函数方法。所设计卷积神经网络...
  • 分类: 训练集中每个样本只有一个标签,该标签来自于一个不重合标签集合L,|L| > 1。 当|L|=2 时,这是一个二分类问题。当|L| > 2 时,这是一个多分类...大多数情况下,多标签的方法会涉及到...

    \Chi多分类:

    训练集中每个样本只有一个标签,该标签来自于一个不重合的标签集合L,|L| > 1。

    当|L|=2 时,这是一个二分类问题。当|L| > 2 时,这是一个多分类问题。

     

    单标签与多标签:

    多标签:

    \chi为训练样本集,y=\{1,\cdots,k\}为标签集合,给定一组形式为<x_i,Y_i>的训练样本,x_i \in \chiY_i \in 2^{|y|},目的是学习求出合适的误差低的函数f(x)2^{|y|}中的unique values)。

    大多数情况下,多标签的方法会涉及到一个给定样本可能有的标签的排序问题,因此这个学习算法可以看成函数f:\chi \times y \rightarrow R。并按照f(x,.)来对标签进行排序。

    rank_f(x,l)f规则下样本x所对应的标签l的排序。其中,rank是一个到\{1,\cdots,k\}上的一对一的映射,且如果f(x,l_1) \leq f(x,l_2),那么rank_f(x,l_1) \leq rank_f(x,l_2)

     

    多标签分类的方法:

    多标签分类的方法可以从 Algorithm Independent 和 Algorithm Dependent 的角度讲,也可以从 Problem Transformation Method 和 Algorithm Adaptation Method 的角度讲。Algorithm Dependent 和 Algorithm Adaptation Method 一样,也有很多方法是 Problem Transformation Method 和 Algorithm Adaptation Method 的结合。

    Problem Transformation Method 问题转化

    将多标签问题转化为单标签问题。改变data来适应算法。

    At training time, with D:

    1 Transform the multi-label training data to single-label data

    2 Learn from the single-label transformed data

    At testing time, for \tilde{x}:

    1 Make single-label predictions

    2 Translate these into multi-label predictions

    e.g.

    Binary Relevance (BR): L binary problems (one vs. all)

    缺点:不能model标签的dependency关系;分类不均衡

    改进:Stacked BR (2BR) [Godbole and Sarawagi, 2004],Chain Classifier (CC) [Cheng et al., 2010, Read et al., 2011]

    2 Label Powerset (LP): one multi-class problem of 2^L class-values 二进制

    缺点:类标签多而复杂;不均衡(每个类别标签对应的实例不多);过拟合(预测新值)

    改进:Ensembles of RAndom k-labEL subsets (RAkEL) [Tsoumakas and Vlahavas, 2007],Ensembles of Pruned Sets (EPS) [Read et al., 2008] 二者都通过投票机制进行预测

    3 Pairwise (PW): \frac{L(L-1)}{2} binary problems (all vs. all)

    Each model is trained based on examples annotated by at least one of the labels, but not both.

    缺点:生成的是PW的Rankings,要得到标签集;找过拟合标签的decision boundary无意义;分类器数量大\frac{L(L-1)}{2}

    改进:Calibrated Label Ranking CLR ([Fürnkranz et al., 2008]),

    4 Copy-Weight (CW): one multi-class problem of L class values

    Make a single multi-class problem with L possible class values.Each example duplicated |Y^{(i)})|times, weighted as\frac{1}{|Y^{(i)}|}.

    缺点:同一实例 / 不同标签的decision boundary;标签基数大导致数据集增长大;没有可以直观地对dependency进行model的方法

     

     Algorithm Independent 独立于算法

    分为基于标签和基于实例的两种转化方式。

     

    Label-based Transformation 基于标签的转化

    Instance-based Transformation 基于实例的转化

    Instance Elimination

    去除多标签实例

    Label Creation

    把多个标签变成一个新的标签

    Conversion

    把多标签的实例变成单标签的实例。简化或分解(加、乘)。

    Label Elimination (Simplification)

    保留一个最可能为true的或者随机选择一个标签。

    Labels Decomposition

    Additive

    如下图,分类器数量1+1=2。

    Multiplicative

    如下图,分类器数量2×1×2×1×1×1=4

     Algorithm Independent Method总结

     

    Algorithm Adaptation / Dependent Method 算法适应

    改变单标签算法生成多标签的输出。

    e.g.,

    k-Nearest Neighbours (KNN)

    MLkNN [Zhang and Zhou, 2007] 

    Decision Trees (DT)

    Multi-label C4.5 [Clare and King, 2001]

    基于AdaBoost [Freund Y. & Schapire, R. E., 1995], ADTBoost [Freund Y. & Mason, L. , 1999]的de Comite, F., Gilleron, R. & and Tommasi, M. (2003) Learning Multi-label Alternating Decision Trees from Texts and Data. 和Adaboost.MH and Adaboost.MR (Schapire & Singer, 2000) 

    Support Vector Machines (SVM)

    RankSVM, a Maximum Margin approach [Elisseeff and Weston, 2002]

    Godbole and Sarawagi (2004) 结合PT4

    Aiolli, F. & Sperduti, A. (2005) Multiclass Classification with Multi-Prototype Support Vector Machines.

    Neural Networks (NN)

    BPMLL [Zhang and Zhou, 2006]

    其他方法可参见 A Tutorial on Multi-Label Classification Techniques 和 Multi-Label Classification: An Overview 等文献。

    具体选哪种方法比较好取决于具体问题是什么,效率和速度:Decision Tree-based;灵活性:problem transformation methods, esp. BR-based;预测能力: ensembles (most modern methods)。

     

    An extensive empirical study by [Madjarov et al., 2012] recommends:
                RT-PCT: Random Forest of Predictive Clustering Trees (Algorithm Adaptation, Decision Tree based)
                HOMER: Hierarchy Of Multilabel ClassifiERs (Problem Transformation, LP-based (original presentation))
                CC: Classifier Chains (Problem Transformation, BR-based)

     

    参考资料:
    https://blog.csdn.net/qq_27009517/article/details/80264919

    Multi-label Classification-Part 01, Jesse Read

    André C. P. L. F. de Carvalho, Freitas A A. A Tutorial on Multi-label Classification Techniques[M]// Foundations of Computational Intelligence Volume 5. Springer Berlin Heidelberg, 2009:177-195.

    Li T, Zhang C, Zhu S. Empirical Studies on Multi-label Classification.[C]// IEEE International Conference on TOOLS with Artificial Intelligence. IEEE Computer Society, 2006:86-92.

    Multi-Label Classification: An Overview

    展开全文
  • 点击上方,选择星标或置顶,每天给你送干货!来自:南大NLP01—研究动机多标签文本分类(multi-label text classification, 简称MLTC)的目的是在给定文本...

    点击上方,选择星标置顶,每天给你送干货


    来自:南大NLP

    01

    研究动机

    多标签文本分类(multi-label text classification, 简称MLTC)的目的是在给定文本后要求模型预测其多个非互斥的相关标签。该任务在许多自然语言处理任务上都有体现。如在表1中,需要给该文档打上标签:basketball、NBA、sport。

    1多标签文本分类的例子

    文本

    This article is  about a game between Houston Rockets and Los Angeles Lakers.

    相关标签

    basketball, NBA,  sport

    不相关标签

    football

    一种处理MLTC的简单方法是将其转换为多个独立的二分类问题。该方法被称为BinaryRelevance (BR),由于其简单性而被大规模使用。但该方法的弊端也十分明显,即该方法完全忽略了标签之间的相关信息。直觉上,知道一些标签——如上例中的basketball及NBA——会使得预测其他标签(如sport)更加简单。研究者指出对于多标签分类任务而言,有效利用标签之间的相关性是有益的、甚至是必要的。为此,涌现出许多利用标签关系的算法,其中最知名的就是算法Classifier Chains(CC)。该算法将多个二分类器串联起来,其中每个分类器使用之前分类器的预测结果作为额外的输入。该方法将潜在的标签依赖纳入考虑,但该问题的最大缺陷在于不同的标签顺序会产生天壤之别的性能。同时,CC算法的链式结构使得算法无法并行,在处理大规模数据集时效率低下。

    近年来,也有学者将标签集合视作标签序列,并使用基于神经网络的端到端模型(seq2seq)来处理该任务。相较于CC预测所有标签,这类seq2seq的模型只预测相关标签。因此该类模型的决策链条长度更短,性能更优。但这类模型的性能强烈依赖于标签的顺序。在多标签数据集中,标签本质上是无序的集合,未必可以线性排列。学者们指出不同的标签顺序对于学习和预测有着重大影响。举例来说,对于表1中的例子,如果标签序列以sport开始,则对于预测其他相关标签的帮助不大。

    02

    解决方案

    为了处理上述问题,我们提出了Multi-Label Reasoner(ML-Reasoner),一个基于推理机制的算法。ML-Reasoner的框架如图1所示,我们为每一个标签分配一个二分类器,它们同时预测所有标签以满足标签的无序性质。这样的话,ML-Reasoner可以同时计算每一个标签相关的概率。例如在处理上例时,ML-Reasoner可能认为标签NBA相关的概率为0.9,basketball的为0.7,sport为0.55,football为0.3.这样,ML-Reasoner就完全避免依赖标签顺序。同时为了有效利用标签的相关性,我们设置了一种新颖的迭代推理机制,即将上一轮对所有标签相关的预测作为下一次迭代的额外特征输入。这种方法使得ML-Reasoner可以在每一轮的迭代中完善预测结果。举例来说,考虑到标签NBA与basketball相关的概率较高,模型可以在后续迭代中,将标签sport的概率调高。

    图 1 Multi-Label Reasoner整体框架图

    具体到Reasoner的实现,我们将其划分为五个组件,其相关交互关系见图2。

    2多标签文本分类的Reasoner模块

    - Text Encoder将词语序列转换为稠密的向量表示,主要负责抽取文本特征;

    - Label Encoder将上一轮次所有标签的相关概率转换为相应的标签表示;

    - Attention模块负责计算文本与不同标签之间的相关性;

    - Combiner则将文本的原始特征与标签特征进行整合;

    - 具有相同结构但不同参数的Classifier则预测各个标签的相关性。

    至于损失函数,我们选择了Binary Cross Entropy (BCE)。更具体的设置请参见原文。

    03

    实验

    我们在两个常用的多标签文本分类数据集Arxiv Acadmeic Paper Dataset(AAPD)及Reuters Corpus Volum I (RCV1-V2)上进行了实验。AAPD数据量更少、标签密度更大,分类难度更大。评价指标则选用了hamming loss,micro-precision,micro-recall及micro-F1;其中hamming loss越低越好,其他则越高越好。至于基准模型,我们选用了经典模型如BR、CC、LP,也有性能优越的seq2seq模型如CNN-RNN、SGM,还有其他一些表现卓越的多标签文本分类模型如LSAN,之外也将seq2set纳入进来作为比较。seq2set使用强化学习算法来缓解seq2seq模型对于标签顺序的依赖程度。同时,为了验证ML-Reasoner在不同文本编码器上能带来的性能提升,我们分别使用了CNN、LSTM及BERT作为ML-Reasoner框架中的Text Encoder模块。实验结果如表2所示。

    2 ML-Reasoner及基准模型在两个数据集上的性能

    从表中可以看出,ML-Reasoner在两个数据集上均达到了SOTA水准,且在三种不同文本编码器上都能带来显著提升。

     

    为了验证ML-Reasoner可以完全避免对标签顺序的依赖,我们随机打乱AAPD数据集的标签顺序,并进行了测试;各个模型的性能如表3所示。从表中可以看到,CC及seq2seq模型的性能受标签顺序的剧烈影响;seq2set可以显著缓解seq2seq的问题;而ML-Reasoner则完全不受标签顺序的影响。

    3各模型在标签打乱的AAPD数据集上的性能

    我们也通过烧蚀实验(见图3),确定了推理机制确实是性能提升的关键。

    3 ML-ReasonerT=1,2,5)及CNN-RoundT=1,2,5)在AAPD测试集上的性能雷达图

    我们也探究了迭代次数对模型性能的影响,由图4可知,进行了一次推理就可以带来显著提升;而推理次数的再次提高并不能带来更多的提升。这可能是因为模型及数据集的选择导致的。

    4不同迭代轮数下的ML-ReasonerAAPD测试集上的性能雷达图

    为了进一步理解Reasoner发挥作用的机制,我们从数据集中选取了一些典型示例(见表4)。在第一个例子中,模型通过推理将相关标签math.OC添上;模型处理第二个例子时,则将无关标签cs.LO剔除;有时添加与删除的动作也会同时发生(见第三个例子)。当然,推理偶尔也会使预测结果变差(见第四、第五个例子)。

    4 AAPD测试集中一些由于推理机制预测结果出现变化的实例

    为了验证上述例子的变化确实是因为考虑了标签之间的相关性,我们进一步统计模型在添加或删除某个标签时与其他标签的共现频率。从图5中,可以观察到模型往往在添加某个标签时,其共现频率(第二行)与真实共现频率接近(第一行);而删除某个标签时,其共现频率(第三行)与真实共现频率(第一行)则相差较远。

    5 AAPD标签的共现频率图

    04

    结论

    在本文中,我们提出了算法ML-Reasoner。该算法可以同时预测所有标签进而避免了对标签顺序的依赖;之外,他通过新颖的推理机制利用了标签之间的高阶关系。实验结果表明了ML-Reasoner在捕获标签依赖之间的有效性;进一步的分析验证了其确实未对标签顺序产生依赖。一些经验性试验也揭示了该算法发挥作用的机制。由于ML-Reasoner未显式利用标签之间的关系,如层次结构等,如何将这些信息纳入考虑是值得进一步探索的。

    作者:汪然

    编辑:刘莉,何亮

    说个正事哈

    由于微信平台算法改版,公号内容将不再以时间排序展示,如果大家想第一时间看到我们的推送,强烈建议星标我们和给我们多点点【在看】。星标具体步骤为:

    (1)点击页面最上方深度学习自然语言处理”,进入公众号主页。

    (2)点击右上角的小点点,在弹出页面点击“设为星标”,就可以啦。

    感谢支持,比心

    投稿或交流学习,备注:昵称-学校(公司)-方向,进入DL&NLP交流群。

    方向有很多:机器学习、深度学习,python,情感分析、意见挖掘、句法分析、机器翻译、人机对话、知识图谱、语音识别等

    记得备注呦

    推荐两个专辑给大家:

    专辑 | 李宏毅人类语言处理2020笔记

    专辑 | NLP论文解读

    专辑 | 情感分析

    
    整理不易,还望给个在看!
    
    展开全文
  • 目的: 训练一个分类器来将物品分到不同类别中,比如一件衣服:可以安照服饰...首先讨论多标签分类数据集(以及如何快速构建自己数据集)。 之后简要讨论SmallerVGGNet,我们将实现Keras神经网络架构,并...

    目的:

          训练一个分类器来将物品分到不同的类别中,比如一件衣服:可以安照服饰类别、颜色、质地打上“衬衫”、“蓝色”、“棉”的标签

    服饰类别:衬衫、裙子、裤子、鞋类等

    颜色:红、蓝、黑等

    质地:棉、羊毛、丝、麻等

    整个工程的步骤如下:

    1. 首先讨论多标签分类数据集(以及如何快速构建自己的数据集)。
    2. 之后简要讨论SmallerVGGNet,我们将实现的Keras神经网络架构,并用于多标签分类。
    3. 然后我们将实施SmallerVGGNet并使用我们的多标签分类数据集对其进行训练。
    4. 最后,我们将通过在示例图像上测试我们的网络,并讨论何时适合多标签分类,包括需要注意的一些注意事项。

    这里给出的是项目的文件结构 

    ├── classify.py
    ├── dataset
    │   ├── black_jeans [344 entries
    │   ├── blue_dress [386 entries]
    │   ├── blue_jeans [356 entries]
    │   ├── blue_shirt [369 entries]
    │   ├── red_dress [380 entries]
    │   └── red_shirt [332 entries]
    ├── examples
    │   ├── example_01.jpg
    │   ├── example_02.jpg
    │   ├── example_03.jpg
    │   ├── example_04.jpg
    │   ├── example_05.jpg
    │   ├── example_06.jpg
    │   └── example_07.jpg
    ├── fashion.model
    ├── mlb.pickle
    ├── plot.png
    ├── pyimagesearch
    │   ├── __init__.py
    │   └── smallervggnet.py
    ├── search_bing_api.py
    └── train.py

    我们将用到的重要文件(基于它们本文出现的大致顺序)包括:

    • search_bing_api.py:此脚本使我们能够快速构建深度学习图像数据集。你不需要运行这段脚本因为图片数据集已经囊括在zip文件中。我附上这段脚本仅为保证(代码的)完整性。
    • train.py:一旦我们拥有了数据,我们将应用train.py训练我们的分类器。
    • fashion.model:我们的train.py脚本将会将我们的Keras模型保存到磁盘中。我们将在之后的classify.py脚本中用到它。
    • mlb.pickle:一个由train.py创建的scikit-learn MultiLabelBinarizer pickle文件——该文件以顺序数据结构存储了各类别名称。
    • plot.png:训练脚本会生成一个名为plot.png的图片文件。如果你在你自己的数据集上训练,你便需要查看这张图片以获得正确率/风险函数损失及过拟合情况。
    • classify.py:为了测试我们的分类器,我写了classify.py。在你将模型部署于其他地方(如一个iphone的深度学习app或是树莓派深度学习项目)之前,你应该始终在本地测试你的分类器。

    本项目中的三个文件夹为:

    • dataset:该文件夹包含了我们的图片数据集。每个类别拥有它自己的子文件夹。我们这样做以保证(1)我们的数据在结构上工整有序(2)在给定图片路径后能更容易地提取类别标签名称。
    • pyimagesearch:这是装有我们的Keras神经网络的模块。由于这是一个模块,它包含了固定格式的__init__.py。另外一个文件smallervggnet.py,它包含组装神经网络本身的代码。
    • examples:该文件夹包含了7个样例图片。我们将基于keras,应用classify.py对每一个样例图片执行多标签分类。

    一、数据集准备

    数据集包含六个类别的2,167个图像,包括:

    黑色牛仔裤(344图像)
    蓝色连衣裙(386图像)
    蓝色牛仔裤(356图像)
    蓝色衬衫(369图像)
    红色连衣裙(380图像)
    红色衬衫(332图像)

    6类图像数据可以通过python爬虫在网站上抓取得到。

                                  

            为了方便起见,可以通过使用Bing图像搜索API(Microsoft’s Bing Image Search API)建立图像数据,具体配置过程见这里(需要在线注册获得api key,使用key进行图像搜索),创建图片搜索文件search_bing_api.py,代码:

    # import the necessary packages
    from requests import exceptions
    import argparse
    import requests
    import cv2
    import os
     
    # construct the argument parser and parse the arguments
    ap = argparse.ArgumentParser()
    ap.add_argument("-q", "--query", required=True,
    	help="search query to search Bing Image API for")
    ap.add_argument("-o", "--output", required=True,
    	help="path to output directory of images")
    args = vars(ap.parse_args())
     
    # set your Microsoft Cognitive Services API key along with (1) the
    # maximum number of results for a given search and (2) the group size
    # for results (maximum of 50 per request)
    API_KEY = "YOUR_API_KEY_GOES_HERE"
    MAX_RESULTS = 250
    GROUP_SIZE = 50
     
    # set the endpoint API URL
    URL = "https://api.cognitive.microsoft.com/bing/v7.0/images/search"
     
    # when attempting to download images from the web both the Python
    # programming language and the requests library have a number of
    # exceptions that can be thrown so let's build a list of them now
    # so we can filter on them
    EXCEPTIONS = set([IOError, FileNotFoundError,
    	exceptions.RequestException, exceptions.HTTPError,
    	exceptions.ConnectionError, exceptions.Timeout])
     
    # store the search term in a convenience variable then set the
    # headers and search parameters
    term = args["query"]
    headers = {"Ocp-Apim-Subscription-Key" : API_KEY}
    params = {"q": term, "offset": 0, "count": GROUP_SIZE}
     
    # make the search
    print("[INFO] searching Bing API for '{}'".format(term))
    search = requests.get(URL, headers=headers, params=params)
    search.raise_for_status()
     
    # grab the results from the search, including the total number of
    # estimated results returned by the Bing API
    results = search.json()
    estNumResults = min(results["totalEstimatedMatches"], MAX_RESULTS)
    print("[INFO] {} total results for '{}'".format(estNumResults,
    	term))
     
    # initialize the total number of images downloaded thus far
    total = 0
     
    # loop over the estimated number of results in `GROUP_SIZE` groups
    for offset in range(0, estNumResults, GROUP_SIZE):
    	# update the search parameters using the current offset, then
    	# make the request to fetch the results
    	print("[INFO] making request for group {}-{} of {}...".format(
    		offset, offset + GROUP_SIZE, estNumResults))
    	params["offset"] = offset
    	search = requests.get(URL, headers=headers, params=params)
    	search.raise_for_status()
    	results = search.json()
    	print("[INFO] saving images for group {}-{} of {}...".format(
    		offset, offset + GROUP_SIZE, estNumResults))
     
        # loop over the results
    	for v in results["value"]:
    		# try to download the image
    		try:
    			# make a request to download the image
    			print("[INFO] fetching: {}".format(v["contentUrl"]))
    			r = requests.get(v["contentUrl"], timeout=30)
     
    			# build the path to the output image
    			ext = v["contentUrl"][v["contentUrl"].rfind("."):]
    			p = os.path.sep.join([args["output"], "{}{}".format(
    				str(total).zfill(8), ext)])
     
    			# write the image to disk
    			f = open(p, "wb")
    			f.write(r.content)
    			f.close()
     
    		# catch any errors that would not unable us to download the
    		# image
    		except Exception as e:
    			# check to see if our exception is in our list of
    			# exceptions to check for
    			if type(e) in EXCEPTIONS:
    				print("[INFO] skipping: {}".format(v["contentUrl"]))
    				continue
     
            # try to load the image from disk
    		image = cv2.imread(p)
     
    		# if the image is `None` then we could not properly load the
    		# image from disk (so it should be ignored)
    		if image is None:
    			print("[INFO] deleting: {}".format(p))
    			os.remove(p)
    			continue
     
    		# update the counter
    		total += 1
     
    

    新建一个文件夹dataset:mkdir dataset。然后收集各类图片

    mkdir dataset/charmander #换成待收集的图片名,其它的不变
    python search_bing_api.py --query "charmander" --output dataset/charmander

    [INFO] searching Bing API for 'charmander'
    [INFO] 250 total results for 'charmander'
    [INFO] making request for group 0-50 of 250...
    [INFO] saving images for group 0-50 of 250...
    [INFO] fetching: http://fc06.deviantart.net/fs70/i/2012/355/8/2/0004_c___charmander_by_gaghiel1987-d5oqbts.png
    [INFO] fetching: http://th03.deviantart.net/fs71/PRE/f/2010/067/5/d/Charmander_by_Woodsman819.jpg
    [INFO] fetching: http://fc05.deviantart.net/fs70/f/2011/120/8/6/pokemon___charmander_by_lilnutta10-d2vr4ov.jpg
    ...
    [INFO] making request for group 50-100 of 250...
    [INFO] saving images for group 50-100 of 250...
    ...
    [INFO] fetching: http://38.media.tumblr.com/f0fdd67a86bc3eee31a5fd16a44c07af/tumblr_nbhf2vTtSH1qc9mvbo1_500.gif
    [INFO] deleting: dataset/charmander/00000174.gif
    ...
    

    有几类图片执行几遍上面的操作,然后使用find方法得到下载的图像数据数目

    find . -type d -print0 | while read -d '' -r dir; do
    > files=("$dir"/*)
    > printf "%5d files in directory %s\n" "${#files[@]}" "$dir"
    > done
        2 files in directory .
        5 files in directory ./dataset
      235 files in directory ./dataset/bulbasaur
      245 files in directory ./dataset/charmander
      245 files in directory ./dataset/mewtwo
      238 files in directory ./dataset/pikachu
      230 files in directory ./dataset/squirtle
    

    之后打开下载的数据,进行一些手工剔除不相关的数据。数据制作over。



    二、定义多标签分类网络架构smallervggnet

            多标签分类网络采用smallervggnet,

                                   

             图片2:被我称为“SmallerVGGNet”的类VGGNet神经网络,我们将用它基于Keras训练一个多标签深度学习分类器

          其原理见论文传送门。有关架构/代码的长篇大论转移至我之前的一篇文章《Keras and Convolutional Neural Networks (CNNs)》,如果你有任何关于架构的问题或是想要了解更多细节,请参阅参阅该文章。如果你希望设计你自己的模型,可以看:《Deep Learning for Computer Vision with Python》(ps:SCDN上有该资源)

    在工程目录下创建python文件,命名为smallervggnet.py

    # import the necessary packages
    from keras.models import Sequential
    from keras.layers.normalization import BatchNormalization
    from keras.layers.convolutional import Conv2D
    from keras.layers.convolutional import MaxPooling2D
    from keras.layers.core import Activation
    from keras.layers.core import Flatten
    from keras.layers.core import Dropout
    from keras.layers.core import Dense
    from keras import backend as K
    
    #引入了Keras模块并于此开始建立我们的SmallerVGGNet类 
    class SmallerVGGNet:
    	@staticmethod
    	def build(width, height, depth, classes, finalAct="softmax"): #定义构建函数,用于组装卷积神经网络。
            #width指定一张输入图片的通道(channels)数量,classes是种类(并不是他们所属的标签)数量(整数)。
            #可选参数finalAct(默认值为“softmax”)将会在神经网络底部被应用。将这个值由softmax改为sigmoid将允许我们基于Keras执行多标签分类。
    		# initialize the model along with the input shape to be
    		# "channels last" and the channels dimension itself
    		model = Sequential()
    		inputShape = (height, width, depth)
    		chanDim = -1
     
    		# if we are using "channels first", update the input shape
    		# and channels dimension
    		if K.image_data_format() == "channels_first":
    			inputShape = (depth, height, width)
    			chanDim = 1
     
    		# CONV => RELU => POOL
    		model.add(Conv2D(32, (3, 3), padding="same",
    			input_shape=inputShape))
    		model.add(Activation("relu"))
    		model.add(BatchNormalization(axis=chanDim))
    		model.add(MaxPooling2D(pool_size=(3, 3)))
    		model.add(Dropout(0.25))
     
    		# CONV => RELU => POOL
    		model.add(Conv2D(32, (3, 3), padding="same",
    			input_shape=inputShape))
    		model.add(Activation("relu"))
    		model.add(BatchNormalization(axis=chanDim))
    		model.add(MaxPooling2D(pool_size=(3, 3)))
    		model.add(Dropout(0.25))
     
    	    # (CONV => RELU) * 2 => POOL
    		model.add(Conv2D(64, (3, 3), padding="same"))
    		model.add(Activation("relu"))
    		model.add(BatchNormalization(axis=chanDim))
    		model.add(Conv2D(64, (3, 3), padding="same"))
    		model.add(Activation("relu"))
    		model.add(BatchNormalization(axis=chanDim))
    		model.add(MaxPooling2D(pool_size=(2, 2)))
    		model.add(Dropout(0.25))
     
    		# (CONV => RELU) * 2 => POOL
    		model.add(Conv2D(128, (3, 3), padding="same"))
    		model.add(Activation("relu"))
    		model.add(BatchNormalization(axis=chanDim))
    		model.add(Conv2D(128, (3, 3), padding="same"))
    		model.add(Activation("relu"))
    		model.add(BatchNormalization(axis=chanDim))
    		model.add(MaxPooling2D(pool_size=(2, 2)))
    		model.add(Dropout(0.25))
     
    	    # first (and only) set of FC => RELU layers
    		model.add(Flatten())
    		model.add(Dense(1024))
    		model.add(Activation("relu"))
    		model.add(BatchNormalization())
    		model.add(Dropout(0.5))
     
    		# use a *softmax* activation for single-label classification
    		# and *sigmoid* activation for multi-label classification
    		model.add(Dense(classes))
    		model.add(Activation(finalAct))
     
    		# return the constructed network architecture
    		return model

    代码说明:

    构建第一个CONV ==> RELU ==> POOL模块:

    我们的CONV层拥有32个卷积核大小为3×3的滤波器以及RELU(Rectified Linear Unit)激活函数。我们在这之后使用批标准化,最大池化,以及25%的遗忘率(Dropout)。

                                   

          Dropout是一个随机切断当前神经网络层节点与下一神经网络层节点间链接的过程。这个随机断开的过程自然地帮助神经网络降低了过拟合的可能性,得益于没有任何一个节点会被分配以预测某个特定的类别、对象、边缘或是角落。

    紧接着我们有两组(CONV ==> RELU)*2 ==> POOL模块:

                                    

    请注意本模块中过滤器、卷积核以及池化大小的变化,这些变化将会共同运作从而逐渐减少空间大小但提升深度(depth)。

    这些模块之后是我们唯一的FC ==> RELU层:

                                    
           全连接层被放置在神经网络的最末端(在第57-64行由Dense声明)。

           第65行对于我们的多标签分类非常重要——finalAct指明我们使用的是针对于单标签分类的“softmax”激活函数,还是针对于今天我们提出的多标签分类的sigmoid激活函数。请参考本脚本smallervggnet.py的第14行以及train.py的第95行。

    三、实现多标签分类Keras模型

          既然我们已经实现了SmallerVGGNet,接下来让我们创建train.py,我们用于训练多标签Keras神经网络的脚本。

          我强烈建议你重温一下先前的博文,今天的train.py脚本便是基于该文章。实际上你可能会想要在屏幕上并行查看它们以观测它们之间区别并阅读关于代码的详细解释。今天回顾将简洁明了

    打开train.py并插入下述代码:

                                        

    在第2至第19行,我们导入了该脚本所需要的包和模块。第三行指定了一个matplotlib后端,基于此我们可以在后台保存我们所绘制的图片。

    我将假定你已经安装了Keras,scikit-learn,matplotlib,imutils以及OpenCV。

    如果这是你的深度学习首秀,你有两个选择来确保你拥有正确的库和包:

    • 已配置好的环境(你将在5分钟内准备就绪并执行代码,训练今天的这个神经网络的花费将少于一杯星巴克咖啡的价格)。
    • 建立你自己的环境(需要时间,耐性以及持久性)。

    我更喜欢在云端预先配置好的环境,你能够在云上启动、上传文件、训练+获取数据以及在几分钟之内终止程序。我推荐的两个预先配置好的环境:

    如果你坚持要建立你自己的环境(而且你有时间来调试及问题修复),我建议你遵循下列博文中的一个:

    既然你的环境已经准备就绪,而且你已经导入了相关包,那么让我们解析命令行参数:

                                 

    命令行参数之于脚本犹如参数之于函数——如果你不理解这个类比,你需要参阅命令行参数。

    我们今天将会处理4个命令行参数:

    • --dataset:输入的数据集路径。
    • --model:输出的Keras序列模型路径。
    • --labelbin:输出的多标签二值化对象路径。
    • --plot:输出的训练损失及正确率图像路径。

    如果你需要关于这些参数的结束,请务必参阅之前的博文。

    让我们进一步讨论一些在我们训练过程中起到至关重要的作用的参数:

                                     

    在第35-38行的这些参数定义了:

    • 我们的神经网络将会训练75轮(epoch),通过反向传播不断提升模型表现从而学习数据背后的模式。
    • 我们设置初始学习率为1e-3(Adam优化器的默认值)。
    • Batch size是32。如果你拥有GPU,你应该根据你的GPU能力调整这个值,但我发现设置batch size为32能使这个项目执行的非常好。
    • 如之前所言,我们的图片大小是96×96并包含3个通道。

    之前的博文提供了更多细节。

    紧接着,接下来的两个代码模块用于加载及预处理我们的训练数据:

                                       

    在这里我们获取imagePaths并将它们的顺序随机打乱,随后初始化data和labels数组。

    然后我们将循环遍历imagePaths,预处理图像数据并解析多类标签。

                                     

                                                                             注:该代码的行号出现问题

          首先我们将每张图片加载至内存。其次,我们在第54和第55行代码执行预处理(深度学习流水线中的重要一环)。我们将image添加在data的末尾。

          第60和第61行针对我们的多标签分类问题将图片路径切分为多个标签。在第60的代码执行之后,一个拥有2个元素的数组被创建,随后在第61行中被添加至labels数据中。如下是一个在终端中经过分解的例子,你能从中了解多标签分词的过程:

                                      640?wx_fmt=png

          如你所见,labels数组是一个“包含数组的数组”——labels中的每个元素都是一个包含两个元素的数组。每个数组对应两个标签这种架构是基于输入图片的文件路径构建的。

    继续完成预处理:

                                      640?wx_fmt=png

          我们的data数据由利用Numpy数组存储的图片组成。在每一行代码中,我们将Python数组转换为Numpy数组并将像素值缩放于范围 [0,1] 之中。

    我们也将标签转换为Numpy数组。

    随后,然我们将标签二值化——下述模块对于本周的多类分类概念十分重要:

                                       640?wx_fmt=png

          为了能够针对多类分类将标签二值化,我们需要运用scikit-learn库中的MultiLabelBinarizer类。你不能在多类分类问题上用标准的LabelBinarizer类。

    第72和第73行代码将人可读的标签转换为包含各类对应编码的向量,该向量根据某类是否在图片中出现来决定对应类的具体值。

    这里是一个展现MultiLabelBinarizer如何将(“red”,“dress”)元组转换为一个有6个类别的向量的例子:

                                        

    One-hot编码将分类标签由一个整数转换为一个向量。同样的概念可以应用在第16和第17行代码上,除非这是一个two-hot编码。

          请注意在Python命令行(为了不与train.py中的代码块混淆)中的第17行,有两个分类标签是“hot”(在数组中用一个“1”表示),表明这各个标签的出现。在本例中,“dress”和“red”在数组中是“hot”(第14至第17行)。其他所有标签的值为“0”。

    我们将数据分为训练集和测试集并初始化数据增强器。

                                      

    在机器学习实战中,将数据分为训练和测试集是一种很常见的做法——我把80%的图片分配为训练数据,20%为测试数据。这一过程在第81和82行中由scikit-learn进行处理。

    我们的数据增强器对象在第85至第87中被初始化。当你的没类数据少于1000张图像时,数据增强是一个最好的实践也或许是一个“必须”的实践。

    接下来,让我们建立模型并初始化Adam优化器:

                                     

    在第92至第95行中,我们构建SmallerVGGNet模型,finalAct=”sigmoid”这个参数指明我们将执行多标签分类。

    随后,我们将编译模型并开始训练(取决于你的硬件,这可能会需要一段时间):

                                    640?wx_fmt=png

    在第105行和第106行中,我们编译模型并使用二元交叉熵而不是类别交叉熵。

    对于多标签分类问题,这可能看起来有些违背了直觉;然而,目标是将每个输出标签视作一个独立伯努利分布,而且我们需要独立地惩罚每个输出节点。

    随后我们启动运用了数据增强生成器的训练过程(第110-114行)。

    在完成训练之后我们可以将模型和标签二值化器储存至磁盘:

                                      640?wx_fmt=png

    随后,我们绘制正确率及损失:

                                     640?wx_fmt=png

    训练和验证的准确率+损失在第127-137行代码中绘画。该图片在第138行中被保存为一个图片文件。

    在我看来,训练图像的绘制就跟模型本身一样重要。在我们满意并在博客上与你们分享之前,我通常会执行训练的几个迭代周期并查看图像是否无误。

    在迭代过程中我喜欢讲图片存至硬盘上出于几个原因:

    • 我在一个无界面的后台服务器上运行代码,也并不想依赖于X-forwarding
    • 我不想忘记保存图片(即使我正在使用X-forwarding或是我正使用一个拥有图形化界面的机器)。

    回想我们在上面将脚本的第三行改变了matplotlib的后端,就是为了帮助我们将图片储存至硬盘上。

    train.py

    # set the matplotlib backend so figures can be saved in the background
    import matplotlib
    matplotlib.use("Agg")
     
    # import the necessary packages
    from keras.preprocessing.image import ImageDataGenerator
    from keras.optimizers import Adam
    from keras.preprocessing.image import img_to_array
    from sklearn.preprocessing import MultiLabelBinarizer
    from sklearn.model_selection import train_test_split
    from pyimagesearch.smallervggnet import SmallerVGGNet
    import matplotlib.pyplot as plt
    from imutils import paths
    import numpy as np
    import argparse
    import random
    import pickle
    import cv2
    import os
     
    # construct the argument parse and parse the arguments
    ap = argparse.ArgumentParser()
    ap.add_argument("-d", "--dataset", required=True,
    	help="path to input dataset (i.e., directory of images)")
    ap.add_argument("-m", "--model", required=True,
    	help="path to output model")
    ap.add_argument("-l", "--labelbin", required=True,
    	help="path to output label binarizer")
    ap.add_argument("-p", "--plot", type=str, default="plot.png",
    	help="path to output accuracy/loss plot")
    args = vars(ap.parse_args())
     
    # initialize the number of epochs to train for, initial learning rate,
    # batch size, and image dimensions
    EPOCHS = 75
    INIT_LR = 1e-3
    BS = 32
    IMAGE_DIMS = (96, 96, 3)
     
    # grab the image paths and randomly shuffle them
    print("[INFO] loading images...")
    imagePaths = sorted(list(paths.list_images(args["dataset"])))
    random.seed(42)
    random.shuffle(imagePaths)
     
    # initialize the data and labels
    data = []
    labels = []
     
    # loop over the input images
    for imagePath in imagePaths:
    	# load the image, pre-process it, and store it in the data list
    	image = cv2.imread(imagePath)
    	image = cv2.resize(image, (IMAGE_DIMS[1], IMAGE_DIMS[0]))
    	image = img_to_array(image)
    	data.append(image)
     
    	# extract set of class labels from the image path and update the
    	# labels list
    	l = label = imagePath.split(os.path.sep)[-2].split("_")
    	labels.append(l)
    

    四、训练模型

    打开终端。在那里,打开项目路径并执行如下命令:

    python train.py --dataset dataset --model fashion.model --labelbin mlb.pickle

    出现下图

             

    如你所见,我们将模型训练了75个epoch,实现了:

    • 98.57% 训练集上的多标签分类正确率
    • 98.42% 测试集上的多标签分类正确率

    训练图在图3中展示:

                              640?wx_fmt=png

                                                   图3:Keras深度学习多标签分类在训练集和测试集中的正确率/损失。


    五、使用训练完成的模型预测新的图像 

    创建名为classify.py的文件并加入如下代码

    # import the necessary packages
    from keras.preprocessing.image import img_to_array
    from keras.models import load_model
    import numpy as np
    import argparse
    import imutils
    import pickle
    import cv2
    import os
     
    # construct the argument parse and parse the arguments
    ap = argparse.ArgumentParser()
    ap.add_argument("-m", "--model", required=True,
    	help="path to trained model model")
    ap.add_argument("-l", "--labelbin", required=True,
    	help="path to label binarizer")
    ap.add_argument("-i", "--image", required=True,
    	help="path to input image")
    args = vars(ap.parse_args())
     
    # 加载图片
    image = cv2.imread(args["image"])
    output = imutils.resize(image, width=400)
     
    # 预处理输入图片(使用与训练数据相同的标准)
    image = cv2.resize(image, (96, 96))
    image = image.astype("float") / 255.0
    image = img_to_array(image)
    image = np.expand_dims(image, axis=0)
     
    # 加载模型+多标签二值化器并将图片分类。从磁盘将模型和多标签二值化器加载至内存中。
    print("[INFO] loading network...")
    model = load_model(args["model"])
    mlb = pickle.loads(open(args["labelbin"], "rb").read())
     
    # 分类(经过预处理的)图片并通过
    #(1)基于相关概率将数组索引按降序排序
    #(2)获取前两个类标签的索引,这便是我们的神经网络所作出的最好的两个预测
    #方式解析出相关性最大的前两个类的标签索引:
    #可以通过修改这段代码以返回更多的类标签。我也建议你对概率设置阈值,并且只返回那些置信程度 > N%的标签。
    print("[INFO] classifying image...")
    proba = model.predict(image)[0]
    idxs = np.argsort(proba)[::-1][:2]
     
    # 对每一个输出图像准备类标签+相关的置信值,该for循环将可能性最大的两个多标签预测及相应的置信值绘制在输出图片上
    for (i, j) in enumerate(idxs):
    	# build the label and draw the label on the image
    	label = "{}: {:.2f}%".format(mlb.classes_[j], proba[j] * 100)
    	cv2.putText(output, label, (10, (i * 30) + 25), 
    		cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
     
    #将所有的预测打印在终端上。这对于调试过程非常有用
    for (label, p) in zip(mlb.classes_, proba):
    	print("{}: {:.2f}%".format(label, p * 100))
     
    # 在屏幕上显示输出图片
    cv2.imshow("Output", output)
    cv2.waitKey(0)
     
    

    用命令行运行测试文件,最终显示出预测的分类结果

    python classify.py --model fashion.model --labelbin mlb.pickle --image examples/example_01.jpg

    结果:

                                                     

                                                                                       

                         图片4:这张红色裙子的照片被我们的Keras多标签分类深度学习脚本由分类器正确分为“红色”和“裙子”。


    总结:

    使用Keras执行多标签分类非常简单,包括两个主要步骤:

    • 1.使用sigmoid激活替换网络末端的softmax激活
    • 2.二值交叉熵作为分类交叉熵损失函数

    shortcomings:

            网络无法预测没有在训练集中出现过的数据样品,如果出现的次数过少,预测的效果也不会很好,解决办法是增大数据集,这样可能非常不容易,还有一种用的已经很多的方法用在大的数据集上训练得到的权重数据对网络做初始化,提高模型的泛化能力。
     


    参考:

    【1】Multi-label classification with Keras(原文)

    【2】手把手教你用Keras进行多标签分类(附代码)(原文翻译)

    【3】基于keras实现多标签分类(multi-label classification)(完整代码)

    展开全文
  • 多分类标签基于keras@[zjc20172333086] ...1.首先讨论多标签分类数据集(以及如何快速构建自己数据集)。 2.之后简要讨论SmallerVGGNet,我们将实现Keras神经网络架构,并用于多标签分类。 3.然后我们将实施Smal...
  • 内容的分类标签

    2015-05-04 17:45:00
    后来对分类进行了延伸,允许子类存在,允许一篇文章对应分类标签 标签是网络体系里,对某块信息(网址、图像、文件等)一个非体系关键词或术语。有了这种元数据(描述数据数据)...
  • 写在前面:本文第一次将注意力机制引入了NLP领域,本文提出新型Seq2Seq架构为基于Seq2Seq的多标签学习提供新思路。 摘要 神经机器翻译是近年来提出一种机器翻译方法。与传统统计机器翻译不同,神经机器翻译...
  • 文字分类 该存储库的目的是通过深度学习探索NLP中的文本分类方法。 它包括多标签分类,其中多个标签与一个文档相关联。 到目前为止,使用的基本模型是朴素贝叶斯,使用计数矢量化器创建文档矩阵。
  • 本篇文章参考: Multi-class Sentiment Analysis 部分细节可能会略作改动,代码注释尽数基于自己理解。文章目的仅作个人领悟记录,并不完全是tutorial...这次我们将尝试多分类任务TREC而不是IMDB import torch i...
  • 互联网分类标签

    千次阅读 2018-06-20 09:40:27
    后来对分类进行了延伸,允许子类存在,允许一篇文章对应分类标签标签是网络体系里,对某块信息(网址、图像、文件等)一个非体系关键词或术语。有了这种元数据(描述数据数据)辅助描述,有利于再次...
  • 例如:LDA得到文档主题词为:“音乐 旋律 节奏 乐器“,目的要将该主题打上大类标签”音乐“;再如将”PM2.5,净化,污染,空气“归为”雾霾“标签,,这应该如何实现呢?求教大神!...
  • 逻辑回归的目的,是使训练数据的标签值与预测出来的值之间的误差最小化。 逻辑回归本质上是一个线性回归模型,因为除去sigmoid映射函数关系,其他的步骤都是线性回归的。可以说,逻辑回归是以线性回归为理论支持。...
  • 在本节中,我们介绍Softmax回归模型,该模型是logistic回归模型在多分类问题上的推广,在多分类问题中,类标签 可以取两个以上的值。 Softmax回归模型对于诸如MNIST手写数字分类等问题是很有用的,该问题的目的是...
  • 思路 X(5000,401) 5000个样本,400特征+1偏置...因为逻辑回归是二分类任务,能够识别0或1,那多分类便可次使用逻辑回归达到多分类的目的。 比如本例的10个类别使用十次逻辑回归即可。 for i in range(1, 11):...
  • 好多大型网站尤其是一些政府网站,经常采用一些树状图来做到大数据分类管理的目的。下面说一下,这个网页布局以及树形图的效果图是怎么拼接而成的。 内容 用到的标签: frameset标签: frameset元素可定义一个...
  • 鸢尾花特征数据5.0,3.3,1.4,0.2 ====》多分类算法进行训练====》多分类算法模型=====》进行预测 三、思路 加载数据 将鸢尾花花萼和花瓣长度和宽度作为特征封装到 向量Vector(Array(5.0,3.3,1.4,0.2)) 将...
  • ​ 机器学习神奇之处在于,我们对原理概念和思路理解得越,它就变得越容易。在本文中,我们将研究在图像分类和图像推荐中使用定向梯度直方图方法。 数据集 来源:Kaggle Fashion图像分类数据集(Small) ...
  • Hinton平滑标签

    2019-09-03 09:19:58
    作用:模型过拟合,且在很最新模型中都得到了应用,比如图片分类、机器翻译和语音识别 论文目的标签平滑不仅能够提升模型泛化能力,还能够提升模型修正能力,并进一步提高模型集束搜索能力。但在本文...
  • 它还支持多标签分类,其中多标签与句子或文档相关联。虽然这些模型很多都很简单,可能不会让你在这项文本分类任务中游刃有余,但是这些模型中其中一些是非常经典,因此它们可以说是非常适合作为基准模型。每个...
  • 它还支持多标签分类,其中多标签与句子或文档相关联。 尽管这些模型中许多模型都很简单,但可能无法使您精通任务。 但是其中一些模型非常 经典,因此它们可以用作基准模型。 每个模型在模型类下都有一个测试功能...
  • 数据集来源:Kaggle Fashion图像分类数据集(Small)kaggle/paramaggarwal/fashion-product-images-small数据集有主类别、子类别、性别、季节和每个图像的标签目的是将数据集用于图像分类和推荐。让...
  • Jsoup递归解析html标签

    2019-07-11 10:10:29
    最近遇到一个需求,需要解析...总体思路是通过Jsoup解析html标签文本,递归获取分类分类达到目的; 这里第一次调用递归方法传入参数为id为sssaaDiv元素下所有li,随后分别递归查找下级元素 ...
  • 近期正好在做类目预测多标签分类的项目,因此把相关的模型记录总结一下,便于后续查阅总结一、理论篇:在我们的场景中,文本数据量比较大,因此直接采用深度学习模型来预测文本类目的多标签,而TextCNN向来以速度快...
  • Naturtag是使用iNaturalist分类法和观测元数据标记本地观测照片工具。 这包括命令行界面,图形界面,也可以用作python包。 请在此处查看运行中CLI: 内容 用例 目的是从您自己iNaturalist观察中获取一些有用...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 253
精华内容 101
关键字:

多标签分类的目的