语义角色标注

背景介绍

自然语言分析技术大致分为三个层面：词法分析、句法分析和语义分析。语义角色标注是实现浅层语义分析的一种方式。在一个句子中，谓词是对主语的陈述或说明，指出“做什么”、“是什么”或“怎么样，代表了一个事件的核心，跟谓词搭配的名词称为论元。语义角色是指论元在动词所指事件中担任的角色。主要有：施事者（Agent）、受事者（Patient）、客体（Theme）、经验者（Experiencer）、受益者（Beneficiary）、工具（Instrument）、处所（Location）、目标（Goal）和来源（Source）等。

请看下面的例子，“遇到” 是谓词（Predicate，通常简写为“Pred”），“小明”是施事者（Agent），“小红”是受事者（Patient），“昨天” 是事件发生的时间（Time），“公园”是事情发生的地点（Location）。

[小明]Agent[昨天]Time[晚上]Time在[公园]Location[遇到]Predicate了[小红]Patient。[小明]Agent[昨天]Time[晚上]Time在[公园]Location[遇到]Predicate了[小红]Patient。

语义角色标注（Semantic Role Labeling，SRL）以句子的谓词为中心，不对句子所包含的语义信息进行深入分析，只分析句子中各成分与谓词之间的关系，即句子的谓词（Predicate）- 论元（Argument）结构，并用语义角色来描述这些结构关系，是许多自然语言理解任务（如信息抽取，篇章分析，深度问答等）的一个重要中间步骤。在研究中一般都假定谓词是给定的，所要做的就是找出给定谓词的各个论元和它们的语义角色。

传统的SRL系统大多建立在句法分析基础之上，通常包括5个流程：

  1. 构建一棵句法分析树，例如，图1是对上面例子进行依存句法分析得到的一棵句法树。
  2. 从句法树上识别出给定谓词的候选论元。
  3. 候选论元剪除；一个句子中的候选论元可能很多，候选论元剪除就是从大量的候选项中剪除那些最不可能成为论元的候选项。
  4. 论元识别：这个过程是从上一步剪除之后的候选中判断哪些是真正的论元，通常当做一个二分类问题来解决。
  5. 对第4步的结果，通过多分类得到论元的语义角色标签。可以看到，句法分析是基础，并且后续步骤常常会构造的一些人工特征，这些特征往往也来自句法分析。

图1. 依存句法分析句法树示例

然而，完全句法分析需要确定句子所包含的全部句法信息，并确定句子各成分之间的关系，是一个非常困难的任务，目前技术下的句法分析准确率并不高，句法分析的细微错误都会导致SRL的错误。为了降低问题的复杂度，同时获得一定的句法结构信息，“浅层句法分析”的思想应运而生。浅层句法分析也称为部分句法分析（partial parsing）或语块划分（chunking）。和完全句法分析得到一颗完整的句法树不同，浅层句法分析只需要识别句子中某些结构相对简单的独立成分，例如：动词短语，这些被识别出来的结构称为语块。为了回避 “无法获得准确率较高的句法树” 所带来的困难，一些研究[1]也提出了基于语块（chunk）的SRL方法。
基于语块的SRL方法将SRL作为一个序列标注问题来解决。序列标注任务一般都会采用BIO表示方式来定义序列标注的标签集，我们先来介绍这种表示方法。在BIO表示法中，B代表语块的开始，I代表语块的中间，O代表语块结束。通过B、I、O 三种标记将不同的语块赋予不同的标签，例如：对于一个角色为A的论元，将它所包含的第一个语块赋予标签B-A，将它所包含的其它语块赋予标签I-A，不属于任何论元的语块赋予标签O。

我们继续以上面的这句话为例，图1展示了BIO表示方法。


图2. BIO标注方法示例

从上面的例子可以看到，根据序列标注结果可以直接得到论元的语义角色标注结果，是一个相对简单的过程。这种简单性体现在：（1）依赖浅层句法分析，降低了句法分析的要求和难度；（2）没有了候选论元剪除这一步骤；（3）论元的识别和论元标注是同时实现的。这种一体化处理论元识别和论元标注的方法，简化了流程，降低了错误累积的风险，往往能够取得更好的结果。

与基于语块的SRL方法类似，在本教程中我们也将SRL看作一个序列标注问题，不同的是，我们只依赖输入文本序列，不依赖任何额外的语法解析结果或是复杂的人造特征，利用深度神经网络构建一个端到端学习的SRL系统。我们以CoNLL-2004 and CoNLL-2005 Shared Tasks任务中SRL任务的公开数据集为例，实践下面的任务：给定一句话和这句话里的一个谓词，通过序列标注的方式，从句子中找到谓词对应的论元，同时标注它们的语义角色。

模型概览

循环神经网络（Recurrent Neural Network）是一种对序列建模的重要模型，在自然语言处理任务中有着广泛地应用。不同于前馈神经网络（Feed-forward Neural Network），RNN能够处理输入之间前后关联的问题。LSTM是RNN的一种重要变种，常用来学习长序列中蕴含的长程依赖关系，我们在情感分析一篇中已经介绍过，这一篇中我们依然利用LSTM来解决SRL问题。

栈式循环神经网络（Stacked Recurrent Neural Network）

深层网络有助于形成层次化特征，网络上层在下层已经学习到的初级特征基础上，形成更复杂的高级特征。尽管LSTM沿时间轴展开后等价于一个非常“深”的前馈网络，但由于LSTM各个时间步参数共享，t−1t−1时刻的输入，帮助我们构建起一个深层网络，我们把它称为第一个版本的栈式循环神经网络。深层网络提高了模型拟合复杂模式的能力，能够更好地建模跨不同时间步的模式[2]。

然而，训练一个深层LSTM网络并非易事。纵向堆叠多个LSTM单元可能遇到梯度在纵向深度上传播受阻的问题。通常，堆叠4层LSTM单元可以正常训练，当层数达到4~8层时，会出现性能衰减，这时必须考虑一些新的结构以保证梯度纵向顺畅传播，这是训练深层LSTM网络必须解决的问题。我们可以借鉴LSTM解决 “梯度消失梯度爆炸” 问题的智慧之一：在记忆单元（Memory Cell）这条信息传播的路线上没有非线性映射，当梯度反向传播时既不会衰减、也不会爆炸。因此，深层LSTM模型也可以在纵向上添加一条保证梯度顺畅传播的路径。

一个LSTM单元完成的运算可以被分为三部分：（1）输入到隐层的映射（input-to-hidden） ：每个时间步输入信息xx会首先经过一个矩阵映射，再作为遗忘门，输入门，记忆单元，输出门的输入，注意，这一次映射没有引入非线性激活；（2）隐层到隐层的映射（hidden-to-hidden）：这一步是LSTM计算的主体，包括遗忘门，输入门，记忆单元更新，输出门的计算；（3）隐层到输出的映射（hidden-to-output）：通常是简单的对隐层向量进行激活。我们在第一个版本的栈式网络的基础上，加入一条新的路径：除上一层LSTM输出之外，将前层LSTM的输入到隐层的映射作为的一个新的输入，同时加入一个线性映射去学习一个新的变换。

图3是最终得到的栈式循环神经网络结构示意图。


图3. 基于LSTM的栈式循环神经网络结构示意图

双向循环神经网络（Bidirectional Recurrent Neural Network）

在LSTM中，tt时刻的LSTM可以看到历史，却无法看到未来。在绝大多数自然语言处理任务中，我们几乎总是能拿到整个句子。这种情况下，如果能够像获取历史信息一样，得到未来的信息，对序列学习任务会有很大的帮助。

为了克服这一缺陷，我们可以设计一种双向循环网络单元，它的思想简单且直接：对上一节的栈式循环神经网络进行一个小小的修改，堆叠多个LSTM单元，让每一层LSTM单元分别以：正向、反向、正向 …… 的顺序学习上一层的输出序列。于是，从第2层开始，tt时刻我们的LSTM单元便总是可以看到历史和未来的信息。图4是基于LSTM的双向循环神经网络结构示意图。


图4. 基于LSTM的双向循环神经网络结构示意图

需要说明的是，这种双向RNN结构和Bengio等人在机器翻译任务中使用的双向RNN结构[3, 4] 并不相同，我们会在后续机器翻译任务中，介绍另一种双向循环神经网络。

条件随机场 (Conditional Random Field)

使用神经网络模型解决问题的思路通常是：前层网络学习输入的特征表示，网络的最后一层在特征基础上完成最终的任务。在SRL任务中，深层LSTM网络学习输入的特征表示，条件随机场（Conditional Random Filed， CRF）在特征的基础上完成序列标注，处于整个网络的末端。

CRF是一种概率化结构模型，可以看作是一个概率无向图模型，结点表示随机变量，边表示随机变量之间的概率依赖关系。简单来讲，CRF学习条件概率P(X|Y)P(X|Y)。

序列标注任务只需要考虑输入和输出都是一个线性序列，并且由于我们只是将输入序列作为条件，不做任何条件独立假设，因此输入序列的元素之间并不存在图结构。综上，在序列标注任务中使用的是如图5所示的定义在链式图上的CRF，称之为线性链条件随机场（Linear Chain Conditional Random Field）。


图5. 序列标注任务中使用的线性链条件随机场

根据线性链条件随机场上的因子分解定理[5]，在给定观测序列XX的概率可以定义为：

p(Y|X)=1Z(X)exp(∑i=1n(∑jλjtj(yi−1,yi,X,i)+∑kμksk(yi,X,i)))p(Y|X)=1Z(X)exp(∑i=1n(∑jλjtj(yi−1,yi,X,i)+∑kμksk(yi,X,i)))

其中Z(X)Z(X)可表示为：

p(Y|X,W)=1Z(X)exp∑kωkfk(Y,X)p(Y|X,W)=1Z(X)exp∑kωkfk(Y,X)

ωω ，通过正则化的极大似然估计，求解如下优化目标：

L(λ,D)=−log(∏m=1Np(Ym|Xm,W))+C12∥W∥2L(λ,D)=−log(∏m=1Np(Ym|Xm,W))+C12‖W‖2

这个优化目标可以通过反向传播算法和整个神经网络一起求解。解码时，对于给定的输入序列XX。

深度双向LSTM（DB-LSTM）SRL模型

在SRL任务中，输入是 “谓词” 和 “一句话”，目标是从这句话中找到谓词的论元，并标注论元的语义角色。如果一个句子含有nn次。一个最为直接的模型是下面这样

  1. 构造输入；
    • 输入1是谓词，输入2是句子
    • 将输入1扩展成和输入2一样长的序列，用one-hot方式表示；
  2. one-hot方式的谓词序列和句子序列通过词表，转换为实向量表示的词向量序列；
  3. 将步骤2中的2个词向量序列作为双向LSTM的输入，学习输入序列的特征表示；
  4. CRF以步骤3中模型学习到的特征为输入，以标记序列为监督信号，实现序列标注；

大家可以尝试上面这种方法。这里，我们提出一些改进，引入两个简单但对提高系统性能非常有效的特征：

  • 谓词上下文：上面的方法中，只用到了谓词的词向量表达谓词相关的所有信息，这种方法始终是非常弱的，特别是如果谓词在句子中出现多次，有可能引起一定的歧义。从经验出发，谓词前后若干个词的一个小片段，能够提供更丰富的信息，帮助消解歧义。于是，我们把这样的经验也添加到模型中，为每个谓词同时抽取一个“谓词上下文” 片段，也就是从这个谓词前后各取nn个词构成的一个窗口片段；
  • 谓词上下文区域标记：为句子中的每一个词引入一个0-1二值变量，表示它们是否在“谓词上下文”片段中；

修改后的模型如下（图6是一个深度为4的模型结构示意图）：


[图6. SRL任务上的深层双向LSTM模型]

  1. 构造输入
    • 输入1是句子序列，输入2是谓词序列，输入3是谓词上下文，从句子中抽取这个谓词前后各nn个词，构成谓词上下文，用one-hot方式表示，输入4是谓词上下文区域标记，标记了句子中每一个词是否在谓词上下文中；
    • 将输入2~3均扩展为和输入1一样长的序列；
  2. 输入1~4均通过词表取词向量转换为实向量表示的词向量序列；其中输入1、3共享同一个词表，输入2和4各自独有词表；
  3. 第2步的4个词向量序列作为双向LSTM模型的输入；LSTM模型学习输入序列的特征表示，得到新的特性表示序列；
  4. CRF以第3步中LSTM学习到的特征为输入，以标记序列为监督信号，完成序列标注；

总结

语义角色标注是许多自然语言理解任务的重要中间步骤。这篇教程中我们以语义角色标注任务为例，介绍如何利用PaddlePaddle进行序列标注任务。教程中所介绍的模型来自我们发表的论文[10]。由于 CoNLL 2005 SRL任务的训练数据目前并非完全开放，教程中只使用测试数据作为示例。在这个过程中，我们希望减少对其它自然语言处理工具的依赖，利用神经网络数据驱动、端到端学习的能力，得到一个和传统方法可比、甚至更好的模型。在论文中我们证实了这种可能性。关于模型更多的信息和讨论可以在论文中找到。

参考文献

  1. Sun W, Sui Z, Wang M, et al. Chinese semantic role labeling with shallow parsing[C]//Proceedings of the 2009 Conference on Empirical Methods in Natural Language Processing: Volume 3-Volume 3. Association for Computational Linguistics, 2009: 1475-1483.
  2. Pascanu R, Gulcehre C, Cho K, et al. How to construct deep recurrent neural networks[J]. arXiv preprint arXiv:1312.6026, 2013.
  3. Cho K, Van Merriënboer B, Gulcehre C, et al. Learning phrase representations using RNN encoder-decoder for statistical machine translation[J]. arXiv preprint arXiv:1406.1078, 2014.
  4. Bahdanau D, Cho K, Bengio Y. Neural machine translation by jointly learning to align and translate[J]. arXiv preprint arXiv:1409.0473, 2014.
  5. Lafferty J, McCallum A, Pereira F. Conditional random fields: Probabilistic models for segmenting and labeling sequence data[C]//Proceedings of the eighteenth international conference on machine learning, ICML. 2001, 1: 282-289.
  6. 李航. 统计学习方法[J]. 清华大学出版社, 北京, 2012.
  7. Marcus M P, Marcinkiewicz M A, Santorini B. Building a large annotated corpus of English: The Penn Treebank[J]. Computational linguistics, 1993, 19(2): 313-330.
  8. Palmer M, Gildea D, Kingsbury P. The proposition bank: An annotated corpus of semantic roles[J]. Computational linguistics, 2005, 31(1): 71-106.
  9. Carreras X, Màrquez L. Introduction to the CoNLL-2005 shared task: Semantic role labeling[C]//Proceedings of the Ninth Conference on Computational Natural Language Learning. Association for Computational Linguistics, 2005: 152-164.
  10. Zhou J, Xu W. End-to-end learning of semantic role labeling using recurrent neural networks[C]//Proceedings of the Annual Meeting of the Association for Computational Linguistics. 2015.

Paddle代码

训练

import math
import numpy as np
import paddle.v2 as paddle
import paddle.v2.dataset.conll05 as conll05
import paddle.v2.evaluator as evaluator

word_dict, verb_dict, label_dict = conll05.get_dict()
word_dict_len = len(word_dict)
label_dict_len = len(label_dict)
pred_len = len(verb_dict)

mark_dict_len = 2
word_dim = 32
mark_dim = 5
hidden_dim = 512
depth = 8
default_std = 1 / math.sqrt(hidden_dim) / 3.0
mix_hidden_lr = 1e-3


def d_type(size):
    return paddle.data_type.integer_value_sequence(size)


def db_lstm():
    #8 features
    word = paddle.layer.data(name='word_data', type=d_type(word_dict_len))
    predicate = paddle.layer.data(name='verb_data', type=d_type(pred_len))

    ctx_n2 = paddle.layer.data(name='ctx_n2_data', type=d_type(word_dict_len))
    ctx_n1 = paddle.layer.data(name='ctx_n1_data', type=d_type(word_dict_len))
    ctx_0 = paddle.layer.data(name='ctx_0_data', type=d_type(word_dict_len))
    ctx_p1 = paddle.layer.data(name='ctx_p1_data', type=d_type(word_dict_len))
    ctx_p2 = paddle.layer.data(name='ctx_p2_data', type=d_type(word_dict_len))
    mark = paddle.layer.data(name='mark_data', type=d_type(mark_dict_len))

    emb_para = paddle.attr.Param(name='emb', initial_std=0., is_static=True)
    std_0 = paddle.attr.Param(initial_std=0.)
    std_default = paddle.attr.Param(initial_std=default_std)

    predicate_embedding = paddle.layer.embedding(
        size=word_dim,
        input=predicate,
        param_attr=paddle.attr.Param(name='vemb', initial_std=default_std))
    mark_embedding = paddle.layer.embedding(
        size=mark_dim, input=mark, param_attr=std_0)

    word_input = [word, ctx_n2, ctx_n1, ctx_0, ctx_p1, ctx_p2]
    emb_layers = [
        paddle.layer.embedding(size=word_dim, input=x, param_attr=emb_para)
        for x in word_input
    ]
    emb_layers.append(predicate_embedding)
    emb_layers.append(mark_embedding)

    hidden_0 = paddle.layer.mixed(
        size=hidden_dim,
        bias_attr=std_default,
        input=[
            paddle.layer.full_matrix_projection(
                input=emb, param_attr=std_default) for emb in emb_layers
        ])

    lstm_para_attr = paddle.attr.Param(initial_std=0.0, learning_rate=1.0)
    hidden_para_attr = paddle.attr.Param(
        initial_std=default_std, learning_rate=mix_hidden_lr)

    lstm_0 = paddle.layer.lstmemory(
        input=hidden_0,
        act=paddle.activation.Relu(),
        gate_act=paddle.activation.Sigmoid(),
        state_act=paddle.activation.Sigmoid(),
        bias_attr=std_0,
        param_attr=lstm_para_attr)

    #stack L-LSTM and R-LSTM with direct edges
    input_tmp = [hidden_0, lstm_0]

    for i in range(1, depth):
        mix_hidden = paddle.layer.mixed(
            size=hidden_dim,
            bias_attr=std_default,
            input=[
                paddle.layer.full_matrix_projection(
                    input=input_tmp[0], param_attr=hidden_para_attr),
                paddle.layer.full_matrix_projection(
                    input=input_tmp[1], param_attr=lstm_para_attr)
            ])

        lstm = paddle.layer.lstmemory(
            input=mix_hidden,
            act=paddle.activation.Relu(),
            gate_act=paddle.activation.Sigmoid(),
            state_act=paddle.activation.Sigmoid(),
            reverse=((i % 2) == 1),
            bias_attr=std_0,
            param_attr=lstm_para_attr)

        input_tmp = [mix_hidden, lstm]

    feature_out = paddle.layer.mixed(
        size=label_dict_len,
        bias_attr=std_default,
        input=[
            paddle.layer.full_matrix_projection(
                input=input_tmp[0], param_attr=hidden_para_attr),
            paddle.layer.full_matrix_projection(
                input=input_tmp[1], param_attr=lstm_para_attr)
        ], )

    return feature_out


def load_parameter(file_name, h, w):
    with open(file_name, 'rb') as f:
        f.read(16)  # skip header.
        return np.fromfile(f, dtype=np.float32).reshape(h, w)


def main():
    paddle.init(use_gpu=False, trainer_count=1)

    # define network topology
    feature_out = db_lstm()
    target = paddle.layer.data(name='target', type=d_type(label_dict_len))
    crf_cost = paddle.layer.crf(
        size=label_dict_len,
        input=feature_out,
        label=target,
        param_attr=paddle.attr.Param(
            name='crfw', initial_std=default_std, learning_rate=mix_hidden_lr))

    crf_dec = paddle.layer.crf_decoding(
        size=label_dict_len,
        input=feature_out,
        label=target,
        param_attr=paddle.attr.Param(name='crfw'))
    evaluator.sum(input=crf_dec)

    # create parameters
    parameters = paddle.parameters.create(crf_cost)
    parameters.set('emb', load_parameter(conll05.get_embedding(), 44068, 32))

    # create optimizer
    optimizer = paddle.optimizer.Momentum(
        momentum=0,
        learning_rate=2e-2,
        regularization=paddle.optimizer.L2Regularization(rate=8e-4),
        model_average=paddle.optimizer.ModelAverage(
            average_window=0.5, max_average_window=10000), )

    trainer = paddle.trainer.SGD(
        cost=crf_cost,
        parameters=parameters,
        update_equation=optimizer,
        extra_layers=crf_dec)

    reader = paddle.batch(
        paddle.reader.shuffle(conll05.test(), buf_size=8192), batch_size=10)

    feeding = {
        'word_data': 0,
        'ctx_n2_data': 1,
        'ctx_n1_data': 2,
        'ctx_0_data': 3,
        'ctx_p1_data': 4,
        'ctx_p2_data': 5,
        'verb_data': 6,
        'mark_data': 7,
        'target': 8
    }

    def event_handler(event):
        if isinstance(event, paddle.event.EndIteration):
            if event.batch_id % 100 == 0:
                print "Pass %d, Batch %d, Cost %f, %s" % (
                    event.pass_id, event.batch_id, event.cost, event.metrics)
            if event.batch_id % 1000 == 0:
                result = trainer.test(reader=reader, feeding=feeding)
                print "\nTest with Pass %d, Batch %d, %s" % (
                    event.pass_id, event.batch_id, result.metrics)

        if isinstance(event, paddle.event.EndPass):
            # save parameters
            with open('params_pass_%d.tar' % event.pass_id, 'w') as f:
                parameters.to_tar(f)

            result = trainer.test(reader=reader, feeding=feeding)
            print "\nTest with Pass %d, %s" % (event.pass_id, result.metrics)

    trainer.train(
        reader=reader,
        event_handler=event_handler,
        num_passes=1,
        feeding=feeding)

    test_creator = paddle.dataset.conll05.test()
    test_data = []
    for item in test_creator():
        test_data.append(item[0:8])
        if len(test_data) == 1:
            break

    predict = paddle.layer.crf_decoding(
        size=label_dict_len,
        input=feature_out,
        param_attr=paddle.attr.Param(name='crfw'))
    probs = paddle.infer(
        output_layer=predict,
        parameters=parameters,
        input=test_data,
        field='id')
    assert len(probs) == len(test_data[0][0])
    labels_reverse = {}
    for (k, v) in label_dict.items():
        labels_reverse[v] = k
    pre_lab = [labels_reverse[i] for i in probs]
    print pre_lab


if __name__ == '__main__':
    main()


 
    
  
  • 1
  
  • 2
  
  • 3
  
  • 4
  
  • 5
  
  • 6
  
  • 7
  
  • 8
  
  • 9
  
  • 10
  
  • 11
  
  • 12
  
  • 13
  
  • 14
  
  • 15
  
  • 16
  
  • 17
  
  • 18
  
  • 19
  
  • 20
  
  • 21
  
  • 22
  
  • 23
  
  • 24
  
  • 25
  
  • 26
  
  • 27
  
  • 28
  
  • 29
  
  • 30
  
  • 31
  
  • 32
  
  • 33
  
  • 34
  
  • 35
  
  • 36
  
  • 37
  
  • 38
  
  • 39
  
  • 40
  
  • 41
  
  • 42
  
  • 43
  
  • 44
  
  • 45
  
  • 46
  
  • 47
  
  • 48
  
  • 49
  
  • 50
  
  • 51
  
  • 52
  
  • 53
  
  • 54
  
  • 55
  
  • 56
  
  • 57
  
  • 58
  
  • 59
  
  • 60
  
  • 61
  
  • 62
  
  • 63
  
  • 64
  
  • 65
  
  • 66
  
  • 67
  
  • 68
  
  • 69
  
  • 70
  
  • 71
  
  • 72
  
  • 73
  
  • 74
  
  • 75
  
  • 76
  
  • 77
  
  • 78
  
  • 79
  
  • 80
  
  • 81
  
  • 82
  
  • 83
  
  • 84
  
  • 85
  
  • 86
  
  • 87
  
  • 88
  
  • 89
  
  • 90
  
  • 91
  
  • 92
  
  • 93
  
  • 94
  
  • 95
  
  • 96
  
  • 97
  
  • 98
  
  • 99
  
  • 100
  
  • 101
  
  • 102
  
  • 103
  
  • 104
  
  • 105
  
  • 106
  
  • 107
  
  • 108
  
  • 109
  
  • 110
  
  • 111
  
  • 112
  
  • 113
  
  • 114
  
  • 115
  
  • 116
  
  • 117
  
  • 118
  
  • 119
  
  • 120
  
  • 121
  
  • 122
  
  • 123
  
  • 124
  
  • 125
  
  • 126
  
  • 127
  
  • 128
  
  • 129
  
  • 130
  
  • 131
  
  • 132
  
  • 133
  
  • 134
  
  • 135
  
  • 136
  
  • 137
  
  • 138
  
  • 139
  
  • 140
  
  • 141
  
  • 142
  
  • 143
  
  • 144
  
  • 145
  
  • 146
  
  • 147
  
  • 148
  
  • 149
  
  • 150
  
  • 151
  
  • 152
  
  • 153
  
  • 154
  
  • 155
  
  • 156
  
  • 157
  
  • 158
  
  • 159
  
  • 160
  
  • 161
  
  • 162
  
  • 163
  
  • 164
  
  • 165
  
  • 166
  
  • 167
  
  • 168
  
  • 169
  
  • 170
  
  • 171
  
  • 172
  
  • 173
  
  • 174
  
  • 175
  
  • 176
  
  • 177
  
  • 178
  
  • 179
  
  • 180
  
  • 181
  
  • 182
  
  • 183
  
  • 184
  
  • 185
  
  • 186
  
  • 187
  
  • 188
  
  • 189
  
  • 190
  
  • 191
  
  • 192
  
  • 193
  
  • 194
  
  • 195
  
  • 196
  
  • 197
  
  • 198
  
  • 199
  
  • 200
  
  • 201
  
  • 202
  
  • 203
  
  • 204
  
  • 205
  
  • 206
  
  • 207
  
  • 208
  
  • 209
  
  • 210
  
  • 211
  
  • 212
  
  • 213
  
  • 214
  
  • 215
  
  • 216
  
  • 217
  
  • 218
  
  • 219
  
  • 220
  
  • 221
  
  • 222
  
  • 223
  
  • 224

应用

训练完成之后，需要依据某个我们关心的性能指标选择最优的模型进行预测，可以简单的选择测试集上标记错误最少的那个模型。预测时使用 paddle.layer.crf_decoding，和训练不同的是，该层没有正确的标签层作为输入。如下所示：

predict = paddle.layer.crf_decoding(
    size=label_dict_len,
    input=feature_out,
    param_attr=paddle.attr.Param(name='crfw'))

# 选用测试集的一条数据作为示例
test_creator = paddle.dataset.conll05.test()
test_data = []
for item in test_creator():
    test_data.append(item[0:8])
    if len(test_data) == 1:
        break

# 推断接口paddle.infer返回标签的索引，并查询词典labels_reverse，打印出标记的结果
labs = paddle.infer(
    output_layer=predict, parameters=parameters, input=test_data, field='id')
assert len(labs) == len(test_data[0][0])
labels_reverse={}
for (k,v) in label_dict.items():
    labels_reverse[v]=k
pre_lab = [labels_reverse[i] for i in labs]
print pre_lab
 
    
  
  • 1
  
  • 2
  
  • 3
  
  • 4
  
  • 5
  
  • 6
  
  • 7
  
  • 8
  
  • 9
  
  • 10
  
  • 11
  
  • 12
  
  • 13
  
  • 14
  
  • 15
  
  • 16
  
  • 17
  
  • 18
  
  • 19
  
  • 20
  
  • 21
  
  • 22
 
					<link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-778f64ae39.css" rel="stylesheet">
            </div>
全部评论
流程图可以借鉴吗
点赞 回复 分享
发布于 2023-11-08 21:00 山东

相关推荐

11-21 15:10
华南农业大学 运营
点赞 评论 收藏
分享
昨天 15:37
已编辑
北京邮电大学 银行其它
本科别学ai
坐标北邮ai,大四上学校硬排了五门专业课……大四上学期，我要上多模态，三维重建，情感计算，智能医学，专业实习，人工智能创新（这课很逆天，论文or三个月以上实习or竞赛）两周的小学期智能医学，没一点用，竟然还爆改八周，每周一次代码作业，还要出去实习，考研人的绝望时刻。学的多且杂，本科期间要学cv,nlp,语音，多模态，大模型，rag,数据库，计网，计原c++,vue,js,python……。注，大四这些课，只能在第七学期学，无法提前上。不然谁会大四留给自己一堆课。最后，一句话让你知道有多卷，保研最低89分。北邮其它专业还行啊，并且ai有三个方向，我仅在此吐槽ai人工智能方向排课不合理。以后如果有...
想去夏威夷的小哥哥在度假：更重要的是学ai只有本科学历是找不到工作的，建议取消本科ai专业
选完offer后，你后悔学本专业吗
点赞 评论 收藏
分享
10-17 10:05
已编辑
北华大学 全栈开发
早上好呀
牛客872465272号：掉头发了哥
点赞 评论 收藏
分享
11-12 21:11
浙江横店影视职业学院 运营
点赞 评论 收藏
分享
头像
11-22 13:56
已编辑
莆田学院 产品经理
点赞 评论 收藏
分享
点赞 收藏 评论
分享

全站热榜

正在热议
# 25届秋招总结 #
303172次浏览 2692人参与
# 如果不工作真的会快乐吗 #
59473次浏览 519人参与
# 百度开奖 #
163929次浏览 981人参与
# 地方国企笔面经互助 #
3896次浏览 11人参与
# 美团求职进展汇总 #
1328215次浏览 12453人参与
# 选完offer后，你后悔学本专业吗 #
20169次浏览 144人参与
# 阿里云管培生offer #
17831次浏览 297人参与
# 正在实习的你，几点下班 #
52124次浏览 391人参与
# 国央企薪资爆料 #
8657次浏览 69人参与
# 如何一边实习一边秋招 #
992556次浏览 12640人参与
# 提前批简历挂麻了怎么办 #
146576次浏览 1948人参与
# 学历or实习经历，哪个更重要 #
51300次浏览 402人参与
# 海康威视求职进展汇总 #
399087次浏览 3406人参与
# 米哈游求职进展汇总 #
176125次浏览 1458人参与
# 求职遇到的搞笑事件 #
70903次浏览 577人参与
# 投递实习岗位前的准备 #
1179795次浏览 18397人参与
# 面试体验感最好的是哪家？ #
85164次浏览 846人参与
# 实习生应该准时下班吗 #
167495次浏览 1159人参与
# 得物求职进展汇总 #
66374次浏览 682人参与
# 网申一定要掌握的小技巧 #
5354次浏览 53人参与
# 招聘要求与实际实习内容不符怎么办 #
10315次浏览 273人参与
# 0offer是寒冬太冷还是我太菜 #
898979次浏览 8015人参与
牛客网
牛客企业服务