dnn文本分类

简介

文本分类任务根据给定一条文本的内容，判断该文本所属的类别，是自然语言处理领域的一项重要的基础任务。具体的，本任务是对文本quey进行分类，任务流程如下：

收集用户query数据。
清洗，标记。
模型设计。
模型学习效果评估。

运行

训练： sh ＋x train.sh

预测： python infer.py

输入／输出

输入样本：

label text（分词后）

0 龙脉温泉住宿 1 龙马机场飞机 2 龙里旅游其中，label 0，1和2分别代表：酒店，票务和住宿。

预估样本：

2 0.0002 0.0001 0.9997 港澳 7 日自助游 label prob text 其中，label为概率最大的类别，即2旅游，中间三个数值为每个类别的概率。

DNN 模型

DNN 模型结构入下图所示：

图1. 本例中的 DNN 文本分类模型

在 PaddlePaddle 实现该 DNN 结构的代码见 network_conf.py 中的 fc_net 函数，模型主要分为如下几个部分：

词向量层：为了更好地表示不同词之间语义上的关系，首先将词语转化为固定维度的向量。训练完成后，词与词语义上的相似程度可以用它们的词向量之间的距离来表示，语义上越相似，距离越近。关于词向量的更多信息请参考PaddleBook中的词向量一节。
最大池化层：最大池化在时间序列上进行，池化过程消除了不同语料样本在单词数量多少上的差异，并提炼出词向量中每一下标位置上的最大值。经过池化后，词向量层输出的向量序列被转化为一条固定维度的向量。例如，假设最大池化前向量的序列为[[2,3,5],[7,3,6],[1,4,0]]，则最大池化的结果为：[7,4,6]。
全连接隐层：经过最大池化后的向量被送入两个连续的隐层，隐层之间为全连接结构。
输出层：输出层的神经元数量和样本的类别数一致，例如在二分类问题中，输出层会有2个神经元。通过Softmax激活函数，输出结果是一个归一化的概率分布，和为1，因此第$i$个神经元的输出就可以认为是样本属于第$i$类的预测概率。

　　该 DNN 模型默认对输入的语料进行二分类（class_dim=3），embedding（词向量）维度默认为28（emd_dim=28），两个隐层均使用Tanh激活函数（act=paddle.activation.Tanh()）。需要注意的是，该模型的输入数据为整数序列，而不是原始的单词序列。事实上，为了处理方便，我们一般会事先将单词根据词频顺序进行 id 化，即将词语转化成在字典中的序号。

源码：

import sys

import math

import gzip

from paddle.v2.layer import parse_network

import paddle.v2 as paddle

__all__ = ["fc_net", "convolution_net"]

def fc_net(dict_dim,

           class_num,

           emb_dim=,

           hidden_layer_sizes=[, ],

           is_infer=False):

    """

    define the topology of the dnn network

    :param dict_dim: size of word dictionary

    :type input_dim: int

    :params class_num: number of instance class

    :type class_num: int

    :params emb_dim: embedding vector dimension

    :type emb_dim: int

    """

    # define the input layers

    data = paddle.layer.data("word",

                             paddle.data_type.integer_value_sequence(dict_dim))

    if not is_infer:

        lbl = paddle.layer.data("label",

                                paddle.data_type.integer_value(class_num))

    # define the embedding layer

    emb = paddle.layer.embedding(input=data, size=emb_dim)

    # max pooling to reduce the input sequence into a vector (non-sequence)

    seq_pool = paddle.layer.pooling(

        input=emb, pooling_type=paddle.pooling.Max())

    for idx, hidden_size in enumerate(hidden_layer_sizes):

        hidden_init_std = 1.0 / math.sqrt(hidden_size)

        hidden = paddle.layer.fc(

            input=hidden if idx else seq_pool,

            size=hidden_size,

            act=paddle.activation.Tanh(),

            param_attr=paddle.attr.Param(initial_std=hidden_init_std))

    prob = paddle.layer.fc(

        input=hidden,

        size=class_num,

        act=paddle.activation.Softmax(),

        param_attr=paddle.attr.Param(initial_std=1.0 / math.sqrt(class_num)))

    if is_infer:

        return prob

    else:

        return paddle.layer.classification_cost(

            input=prob, label=lbl), prob, lbl

def convolution_net(dict_dim,

                    class_dim=,

                    emb_dim=,

                    hid_dim=,

                    is_infer=False):

    """

    cnn network definition

    :param dict_dim: size of word dictionary

    :type input_dim: int

    :params class_dim: number of instance class

    :type class_dim: int

    :params emb_dim: embedding vector dimension

    :type emb_dim: int

    :params hid_dim: number of same size convolution kernels

    :type hid_dim: int

    """

    # input layers

    data = paddle.layer.data("word",

                             paddle.data_type.integer_value_sequence(dict_dim))

    lbl = paddle.layer.data("label", paddle.data_type.integer_value(class_dim))

    # embedding layer

    emb = paddle.layer.embedding(input=data, size=emb_dim)

    # convolution layers with max pooling

    conv_3 = paddle.networks.sequence_conv_pool(

        input=emb, context_len=, hidden_size=hid_dim)

    conv_4 = paddle.networks.sequence_conv_pool(

        input=emb, context_len=, hidden_size=hid_dim)

    # fc and output layer

    prob = paddle.layer.fc(

        input=[conv_3, conv_4], size=class_dim, act=paddle.activation.Softmax())

    if is_infer:

        return prob

    else:

        cost = paddle.layer.classification_cost(input=prob, label=lbl)

return cost, prob, lbl

训练结果如下图：

预估结果：