E2E NLG Challenge: Neural Models vs. Templates 论文笔记（附模型代码）

原文链接：http://www.macs.hw.ac.uk/InteractionLab/E2E/final_papers/E2E-UKP_TUDA.pdf

Abstract

E2E NLG Challenge是一项共享任务，用于根据键值对生成餐馆描述。 本文描述了我们参与挑战的结果。 我们开发了一种简单而有效的神经编码器 - 解码器模型，可以产生流畅的餐厅描述并且优于强大的基线。 我们进一步分析组织者提供的数据，并得出结论，也可以在几个小时内开发出基于模板的模型来处理任务。

1.Introduction

自然语言生成（NLG）是从结构化数据表示生成自然语言发音的任务。 后者可以是句法树，一组抽象逻辑形式，键值属性对，向量空间嵌入，多变量时间序列，传感器测量。

E2E NLG Challenge2是一项共享任务，专注于端到端数据驱动的NLG方法。 这些方法引起了很多关注，因为它们从非对齐数据执行文本结构和表面实现模式的联合学习，这允许显着减少NLG语料库创建所需的人类注释工作量。

我们的工作总结如下：

•我们展示了如何利用数据属性来设计更精确的神经架构。 •我们开发了一个简单的基于模板的系统，该系统实现了与神经方法相当的性能。

本节进一步描述了组织者提供的任务，数据集和基线。 第2节介绍了我们开发的两个系统。 第3节描述了基于度量的评估结果，然后是系统预测的错误分析。 为了证实我们的研究结果，我们仔细研究了数据集，并在第4节中提出了我们的观察结果。最后，我们以讨论部分结束，总结了获得的结果（第6节）。

1.1 Task Defiition

共享任务的组织者在餐馆域中提供了50k实例的众包数据集。 每个培训实例都包含一个基于对话行为的意义表示（MR）和最多16个自然语言的参考（见图1）：

使用图形表示作为刺激收集数据，旨在创建比文本输入可能产生的更自然，信息量和多样化的人类参考。

任务是从给定的MR产生话语，该话语既与人类生成的参考文本类似，又由人类高度评价。 使用标准评估指标评估相似性：BLEU，NIST，METEOR，ROUGE-L，CIDEr。 然而，最终评估是通过使用众包和专家注释的混合获得的人类评级来完成的。

E2E NLG Challenge数据集分为76.5:8.5:15比例的训练，验证和测试集，确保不同组中的MR不同。 开发集输入与多个参考配对，以促进更可靠的模型选择程序; 测试数据仅包含输入MR。 目标是开发和训练NLG系统并提交每个测试实例的餐馆描述预测。

为了更好地评估所提出的方法，组织团队使用最近的E2E数据驱动系统之一TGen作为基线。 它是一个具有注意力的序列序列（seq2seq）神经系统。 除了标准的seq2seq模块之外，TGen还使用波束搜索进行解码，在前k个输出上包含一个reranker，惩罚那些不会从输入MR语言化所有属性的候选者。 TGen还包括一个delexicalization模块，它通过在预处理输入数据时将这些值映射到占位符标记，并用实际值替换占位符作为后处理步骤来处理稀疏出现的MR属性（name,near）。

2.Our Approach

本节描述了我们处理这个任务的两种不同方法。

第一种（Model-D, for 'data-driven'）是一种和TGen相似的编码解码器神经网络，但是它使用了一种更有效的编码模块。给定一组MR键值对，TGen通过将键值相连接将其线性转化成tokens的序列。将得到的序列进一步送入递归神经网络（RNN）。 RNN具有能够处理可变大小输入的优点。但是，它们还会学习序列项之间的依赖关系，这在某些情况下可能并不理想。我们决定研究利用数据属性的方法，以便处理不同大小的输入，同时避免在构成MR属性之间施加任何依赖性，因为每个输入MR是一组项，而不是序列（第2.1节）。

2.2节介绍了第二种方法，它是一种简单的基于模板的模型（Model-T，for 'template-based'），我们根据探索性数据分析的结果开发了该模型。 我们认为这样的系统是比较的必要候选者，因为E2E NLG挑战数据旨在学习能够产生“更自然，更多样且更少模板的系统话语”的模型。

2.1 Model-D

Model-D受到E2E NLG Challenge数据的两个重要属性的推动：

• 固定数量的唯一MR属性

• MR属性值的词汇实例的低多样性

每个输入MR包含固定数量的唯一属性（在3和8之间），这允许我们将位置id与每个属性相关联，并从编码过程中省略相应的属性名称（或键）。这使得编码序列长度缩短，从而使得编码器的学习过程更加容易。这也统一了输入MR的长度，因此允许我们使用更简单和更有效的神经网络，这些神经网络不是顺序的，而是在一个步骤中处理输入序列（例如：多层感知器（MLP）网络）。

有人可能会争辩说，使用MLP会因为活性的（非空值）输入MR键的数量和构成相应值的令牌数量都不固定这一事实而变得复杂。比如说，一个MR键price可能会有一个单一标记值‘low’，或者一个更长的标记值'less than $10'。然而，MR属性值的实现表现出低可变性：八个键中的6个加起来只有少于7个唯一值，而剩下的两个键（name, near）表示命名实体，因此易于进行去词汇化。这允许我们将每个值视为单个标记，即使它由多个单词组成（比如：'more than $30', 'Fast food'）。

数据处理部分代码：

def process_e2e_mr(self, mr_string):
    """
    Processing E2E NLG Challenge meaning representation
    Represent each MR as a list of 8 attributes, specified in MR_KEYMAP.
​
    :param mr_string:'name[The Vaults], eatType[pub], priceRange[more than £30], customer rating[5 out of 5], near[Café Adriatic]'
    :return:
    mr_data: ['<name>', 0, 'pub', 0, 'more than £30', '<near>', 0, '5 out of 5']
    lex: ['The Vaults', 'Café Adriatic']
    """
    items = mr_string.split(", ")
    mr_data = [PAD_ID] * MR_KEY_NUM
    lex = [None, None]  # holds lexicalized variants of NAME and NEAR
​
    for idx, item in enumerate(items):
        key, raw_val = item.split("[")
        key_idx = MR_KEYMAP[key]
​
        # Delexicalization of the 'name' field
        if key == 'name':
            mr_val = NAME_TOKEN
            lex[0] = raw_val[:-1]
​
        # Delexicalization of the 'near' field
        elif key == 'near':
            mr_val = NEAR_TOKEN
            lex[1] = raw_val[:-1]
​
        else:
            mr_val = raw_val[:-1]
​
        mr_data[key_idx] = mr_val
​
    return mr_data, lex

def tokenize(self, s, lex_list=None):
    """
    A simple procedure to tokenize a string.
​
    :param s: string to be tokenized. 
    'The Vaults pub near Café Adriatic has a 5 star rating.  Prices start at £30.'
    :param lex_list: list of lexicalizations
    ['The Vaults', 'Café Adriatic']
    :return: list of tokens from sting s
    ['<name>', 'pub', 'near', '<near>', 'has', 'a', '5', 'star', 'rating', '.', 'Prices', 'start', 'at', '£30', '.']
    """
​
    words = []
​
    # Delexicalize target side
    if lex_list:
        for l, t in zip(lex_list, (NAME_TOKEN, NEAR_TOKEN)):
            if l:
                s = s.replace(l, t)
​
    # Process target side text
    for fragment in s.strip().split():
        fragment_tokens = _WORD_SPLIT.split(fragment)
        words.extend(fragment_tokens)
​
    tokens = [w for w in words if w]
​
    return tokens

每个句子都这么处理，然后得到raw_data_x(mr_data),raw_data_y(tokens),lexications(lex)。

然后构建词典，以一种很简单的方式

for x in raw_data:
    for tok in x:
        if self.lower:
            tok = tok.lower()
​
        if tok not in vocablist:
            vocablist.append(tok)

然后将训练集和测试集的数据都转为id(长度超过50的截断，不足的补pad)。

每个预测输出是餐馆的一个文字描述。 图3显示了训练数据中参考文本长度分布的直方图。 参考长度测量为包含参考的令牌数量（包括标点符号）.我们使用值50作为截止阈值，过滤出具有长餐厅描述的训练实例。

我们模型的整体架构如图二所示。这个系统是一个典型的编码器解码器结构，包含三个模块：embedding矩阵， 一个深度隐藏层作为编码器，一个GRU作为解码器。

 

我们首先描述模型的输入规范。 我们将使用以下MR实例作为运行示例：

name[Wrestlers] customerRating[high] familyFriendly[yes]

按照MR键名称的字母序，我们可以为键分配位置ID，如表1所示。其余五个键分配虚拟PAD值。

考虑到符号的表示，让我们将组件总数表示为N = 9（包括EOS）。每个组件都被表示为d维的嵌入矩阵​。这个包含了所有这样的向量的嵌入矩阵被表示为​，V是在训练数据中观察到的独特标记的词汇表。每个embedding向量在之后都会通过仿射变换+Relu映射到密集隐层表示：

模型部分代码：

encoder:一个简单的全连接层

class EncoderMLP(nn.Module):
    def __init__(self, config):
        super(EncoderMLP, self).__init__()

        self.config = config
        self.input_size = self.config['input_size']
        self.hidden_size = self.config['hidden_size']
        self.W = nn.Linear(self.input_size, self.hidden_size)
        self.relu = nn.ReLU()

    def forward(self, input_embedded):
        seq_len, batch_size, emb_dim = input_embedded.size()

        # f(Wx), where f(x) is a non-linear function, e.g. ReLU
        outputs = self.relu(self.W(input_embedded.view(-1, emb_dim)))

        # Reshape outputs:  # SL x B x H
        outputs = outputs.view(seq_len, batch_size, -1)
        # hidden: B x H
        dec_hidden = torch.sum(outputs, 0)
        return outputs, dec_hidden.unsqueeze(0)  # SL x B x H, 1 x B x H

attention模块计算系数部分代码：

def forward(self, prev_h_batch, enc_outputs):
    """

    :param prev_h_batch: 1 x B x dec_dim
    :param enc_outputs: SL x B x (num_directions * enc_dim)

    :return: attn weights: # B x SL

    """

    src_seq_len, batch_size, enc_dim = enc_outputs.size()

    # Compute U*h over length and batch (batch, source_l, attn_dim)
    uh = self.U(
        enc_outputs.view(-1, self.h_dim)).view(src_seq_len, batch_size, self.a_dim)  # SL x B x self.attn_dim

    # Compute W*s over the batch (batch, attn_dim)
    wq = self.W(prev_h_batch.view(-1, self.s_dim)).unsqueeze(0)  # 1 x B x self.a_dim

    # tanh( Wh*hj + Ws s_{i-1} )     (batch, source_l, dim)
    wq3d = wq.expand_as(uh)
    wquh = self.tanh(wq3d + uh)

    # v^T*wquh over length and batch
    attn_unnorm_scores = self.v(wquh.view(-1, self.a_dim)).view(batch_size, src_seq_len)

    attn_weights = self.softmax(attn_unnorm_scores)  # B x SL

    return attn_weights

decoder:一个带attention的GRU

class DecoderRNNAttnBahd(DecoderRNNAttnBase):
    def __init__(self, rnn_config, output_size, prev_y_dim, enc_dim, enc_num_directions):
        super(DecoderRNNAttnBahd, self).__init__()

        self.rnn = get_GRU_unit(rnn_config)

        # Setting attention
        dec_dim = rnn_config["hidden_size"]
        self.attn_module = AttnBahd(enc_dim, dec_dim, enc_num_directions)
        self.W_combine = nn.Linear(prev_y_dim + enc_dim * enc_num_directions, dec_dim)
        self.W_out = nn.Linear(dec_dim, output_size)
        self.log_softmax = nn.LogSoftmax()  # works with NLL loss

    def combine_context_run_rnn_step(self, prev_y_batch, prev_h_batch, context):
        """

        :param prev_y_batch: B x prev_y_dim
        :param prev_h_batch: 1 x B x dec_dim
        :param context: # B x 1 x MLP_H
        :return:
        """
        y_ctx = torch.cat((prev_y_batch, context.squeeze(1)), 1)  # B x (prev_y_dim+(enc_dim * num_enc_directions))
        rnn_input = self.W_combine(y_ctx)  # B x H
        output, decoder_hidden = self.rnn(rnn_input.unsqueeze(0), prev_h_batch)  # 1 x B x H, 1 x B x H

        return output, decoder_hidden

    def compute_output(self, rnn_output):
        """

        :param rnn_output: 1 x B x H
        :return:
        """
        unnormalized_logits = self.W_out(rnn_output[0])  # B x TV
        logits = self.log_softmax(unnormalized_logits)  # B x TV

        return logits

class DecoderRNNAttnBase(nn.Module):
    """
    To be implemented for each Decoder:
    self.rnn
    self.attn_module
    self.combine_context_run_rnn
    self.compute_output
    """

    def forward(self, prev_y_batch, prev_h_batch, encoder_outputs_batch):
        """
        A forward step of the Decoder.
        The step operates on one step-slice of the target sequence.

        :param prev_y_batch: embedded previous predictions: B x E
        :param prev_h_batch: current decoder state: 1 x B x dec_dim
        :param encoder_outputs_batch: SL x B x MLP_H
        :return:
        """
        # Calculate attention from current RNN state and all encoder outputs;
        attn_weights = self.attn_module(prev_h_batch, encoder_outputs_batch)  # B x SL

        # Apply attention weights to encoder outputs to get weighted average
        context = torch.bmm(attn_weights.unsqueeze(1), encoder_outputs_batch.transpose(0, 1))  # B x 1 x MLP_H

        # Combine embedded input word and attended context, run through RNN
        dec_rnn_output, dec_hidden = self.combine_context_run_rnn_step(prev_y_batch, prev_h_batch,context)  # 1xBxH, 1xBxH
        dec_output = self.compute_output(dec_rnn_output)  # logits (Softmax(), not LogSoftmax())

        # Return final output, hidden state, and attention weights (for visualization)
        # B x TV(output_size), 1 x B x H,  B x SL
        return dec_output, dec_hidden, attn_weights

我们训练系统30轮，保存每轮的预测值和表现分数。等训练阶段结束后，我们选择在验证集上测量得分最高的模型。

由于我们有五个评估指标，并且不清楚哪个更好地反映了文本质量，因此我们决定使用指标的简单平均值作为模型选择标准。 在计算平均值之前，根据以下公式对每个度量标准的得分进行标准化：

我们没有进行广泛的超参数优化，所有的值都是根据我们认为合理的该领域的常识来设定的。 我们在评估第3节中详细说明了这一决定的原因。

2.2 Model-T

考虑到MR属性值的低词汇变化，人们可能对是否有可能设计确定性NLG系统来解决任务感兴趣。 我们检查了MR属性键和值在训练数据中的语言表达方式，并发现大多数文本描述遵循MR属性语言化的类似顺序：

[name] is a [familyFriendly] [eatType] which serves [food] food in the [price] price range. It has a [customerRating] customer rating. It is located in the [area] area, near [near].

[X]代表MR键X的值。这种模式成为Model-T的核心模板。并不是所有的MR属性语言都适合此模式。例如，一个键值对是这样的：customerRating[3 out of 5]会被解读为'... has a 3 out of 5 customer rating'，这不是最好的措辞。一个更好的描述它的方法是'... has a customer rating of 3 out of 5'。我们用一组简单的规则将这些变体合并到Model-T中，这些规则根据MR属性的特定值修改一般模板。

如2.1节所述，每个实例的输入最多可包含8个MR属性。 为了解释这一事实，我们将通用模板分解为更小的组件，每个组件对应于输入中提到的特定MR属性。更进一步，我们开发了一组规则，根据MR属性是否是输入的一部分来激活每个组件。比如说，如果price不在输入的MR属性中，那么通用模板就会变成：

[name] is a [familyFriendly] [eatType] which serves [food] food. It has a [customerRating] customer rating. It is located in the [area] area, near [near].

最后我们还添加了一个简单的后处理步骤来处理特定的标点符号和文章选择。

在设计模板时，我们观察到所提供的数据包含的伪像不能归因于组织者偶尔发出的噪声或注释指南决策。比如，输入属性为food[Japanese]的5996个训练实例中有33个将“中国餐馆”作为参考输出。这可能是由输入MR的错误解释引起的——正如我们在1.1节中提到的，数据最初是图片化的，因此一些人群工作者可能选择了错误的标签来表示日本料理。

另一个例子是价格范围(priceRange[cheap]—>'the cheap price of $10.50')或客户评级(customer Rating[high]—>'a 9 on a scale of 10')的无动机规范。 这些案例很可能是一些注释者尝试创造性的结果。

3.Evaluation

3.1 Metric Evaluation

在竞赛建立之后，我们使用在提供的脚本中实现的五个自动度量来分析在开发集上提出的方法的性能（表2）。

在我们的比较中，我们依赖于共享任务的组织者报告的TGen的性能（Novikova等，2017b）。 由于我们只提供了一个TGen预测文件和单个性能分数，因此基于神经网络和随机训练程序的方法具有非确定性，因此无法比较得分分布并且统计显着性检验无意义。 Gurevych，2017）。 为了便于与其他竞争系统进行公平比较，我们报告了每个自动度量的Model-D的平均发展得分（在不同随机种子的20次运行中平均）和性能方差。 我们的代码库中提供了相应的二十个预测。 Model-T是一个确定性系统，因此报告单次运行的结果就足够了。

 

结果表明，尽管性能方差非常大，但模型D的性能优于所有五个指标所测量的TGen。 Model-T明显低于TGen和Model-D。 这是预期的，因为Model-T不是数据驱动的，因此它生成的文本可能与参考输出不同。

但是，这并不意味着模型D更好 ——基于度量的评估只是文本质量的大致估计。以前的研究表明，广泛使用的自动指标（包括我们竞争中使用的指标）与人类判断缺乏强烈的相关性。这些指标中的大多数来自机器翻译和自动文档摘要的领域，并评估参考文本和生成的输出之间的内容重叠。 它们不能衡量候选输出的流畅性或话语结构。 此外，如果模型在生成文本时忽略了部分输入或生成输入中未给出的内容时，则这些指标完全依赖于评估候选者的参考质量。 为了得出更可靠的结论，我们对比较系统的预测进行了手动误差分析。

3.2 Error Analysis

我们从开发集中随机抽取100个输入实例，并从组织者提供的官方基线预测文件中检索相应的输出。

我们专注于一般错误，这在许多NLG场景中都很有意义。 表3显示了每个预测文件中的错误类型和错误数。 错误类型应该是不言自明的（样本预测在附录A.2中给出）。

就（主观）手动分析而言，Model-T输出具有最佳语言质量的描述。 表3显示基于模板的系统的预测不包含任何错误 - 这是因为我们将语法概念纳入模板的定义，这使得Model-T能够避免在其他两种方法的预测中发现的错误。

请注意，虽然Model-T能够产生流利和语法正确的餐馆描述，但它不可避免地受到低输出变化的影响。 它的优势在于我们可以轻松调整它以生成更多用户特定的文本。

Model-D产生的大多数错误都是输入MR值的错误语言表达或标点符号错误。 后者仅限于在条文之间缺少逗号或没有完整句子的情况。 解决此问题的一个简单方法是添加一个后处理步骤，在输出文本之前修复标点符号错误。 TGen在这方面具有优势，因为它使用一组纠正标点符号错误的规则，而Model-D纯粹是数据驱动的（正如我们在下一节中所示，标点符号错误在提供的数据中很常见）。

我们的模型丢弃或修改某些MR属性值的情况会带来更有趣的挑战。 根据组织者的说法，40％的设计数据包含输出方面的额外信息或遗漏信息（Novikova等，2017b）：允许数据采集者不要将他们认为不重要的属性值词汇化。考虑到这一点，我们可以得出结论，我们的模型优于TGen，因为Model-D生成的文本更类似于训练数据中遇到的文本。 不幸的是，我们不知道用于注释的重要性的确切定义，这就是为什么我们无法评估模型-D在特定情况下的行为的有效性。（评判指标还是不合适，这也是文本生成这块领域目前最大的缺陷）

为了证实这一假设，我们决定检查训练数据，看看D的差异是否是从数据中学习到的。

4.Training Data Analysis

E2E NLG挑战基于真实，嘈杂的数据。 与小型但高度策划的数据集相比，组织者提供了多个实例来解释这种噪音。 为了更好地理解Model-D的行为并确定它是否利用了每个训练实例的多个引用，我们随机抽样了100个训练实例并手动检查了它们的语言质量。 表4显示了我们遇到的最常见错误。

大部分错误都是来自不合语法的结构，比如：错误的短语添加方式（“The price of the food is high and is located . . . ”），错误的标签使用方式(“located in riverside”)，重复的结构(“Cotto, an Indian coffee shop located in . . . , is an Indian coffee shop . . . ”)。一些餐馆描述遵循一种推特风格的叙述模式，这种模式是可以理解的，但却是不合语法的(“The Golden Palace Italian riverside coffee shop price range moderate and customer rating 1 out of 5”)。

相当多的实例具有餐馆描述，其包含不完全遵循给定输入MR的信息。 这些是输入内容元素被修改或删除的情况，这与我们在Model-D的输出中观察到的一致。

一些实例（10％）包含我们标记为可疑的描述。 它们是语法上正确的，但是由于语用和/或风格的考虑，我们宁愿避免使用它们。 例如，作为输入MR的一部分具有famliyFriendly[no]的餐馆通常被数据收集者描述为“仅限成人”的场所，其具有不期望的内涵。 最后，有必要提到一些数据收集者遵循不一致的拼写和标点符号规则。 前者最常见的情况是连字复合修改 (“family friendly restaurant”, “the restaurant is family friendly”), 大写MR attributes(“Riverside”, “Fast food”)和各种错字(“neat” instead of “near”, “rage” instead of “range”)。标点符号错误主要限于在餐馆描述结束时没用句号或未能用逗号分隔句子。

手动数据分析的结果表明，Model-D确实生成了与提供的数据集中的餐馆描述类似的文本。 不幸的是，我们的数据驱动方法不够灵活，无法利用多个参考信息； 它无法抵消某些训练实例中出现的噪音。 缓解该问题的一种方法可以是重新设计损失函数以向系统通知存在产生良好餐馆描述的多种方式。 给定训练实例，Model-D将生成相应的候选文本，该文本可以与所有人类参考进行比较。 每次比较都会导致计算一定的成本; 然后可以在所有比较中以最小成本计算梯度。

通过添加修复标点符号和/或偶尔拼写错误的后处理步骤，可以进一步改进该方法。

5.Final Evaluation

略。

6.Discussion

分享一些重要的结论：

6.1 Evaluation Criteria

度量评估结果给我们的印象是Model-D比TGen和Model-T都要好得多。 然而，人工检查显示所有系统都有其强弱侧面。 基于模板的系统产生最正确的语法结果，但输出变化性和灵活性太低。Model-D和TGen产生更多可变输出，但偶尔也会包含语法错误。TGen和Model-T都尝试用语言表达每个输入的MR值，但组织者期望系统执行一些内容过滤。 那么，应该选择哪种模型来解决手头的任务？

不同的NLG任务有不同的要求。 例如，生成的候选者的低多样性可能是聊天机器人应用程序要重点解决的问题，但事实检索系统对此并不考虑。我们将生成餐馆描述的任务视为纯粹寻求信息的现实场景。这可能不是该任务的设计目标，因为后者鼓励更多样化和更少模板化的系统话语。然而，我们决定遵循通用NLG要求（语法）并提交Model-T的预测，这些预测产生语法输出，同时将所有输入信息保留在生成文本中。

6.2 Development Costs vs. Quality Trade-off

这一点与前一点有关。 我们承认开发用于解决复杂问题的数据驱动模型的重要性。 然而，考虑到系统构建成本和输出质量之间的权衡，我们决定开发一个简单的基于模板的模型，并将其与神经架构进行比较。 我们花了大约三个小时来设计和调试模板模型。 它提供了一致，合理和流畅的输出，可以通过调整模板的内容轻松地为特定用户定制。 另一方面，Model-D花了我们大约一个月的时间来开发和几天的时间优化。 当然，这两种模型都产生了具有可观语言质量的文本。 E2E NLG挑战侧重于端到端数据驱动的NLG方法，这就是为什么像Model-T这样的系统可能不完全适合任务设置的原因。 尽管如此，我们希望我们的观察和发现有助于更好地理解各种NLG方法的优缺点。

6.3 Crowd-sourcing and Business Sensitivity

考虑以下假设预测候选语句：

• “The Bakers is a restaurant serving English food.” • “The Bakers is a restaurant at the riverside, near The Wrestlers.”

这两个预测在内容上是互补的，在语言质量方面是相同的。那么哪一个更好呢？第一句提到了餐厅提供的食物，但是漏掉了餐厅的地理位置，第二句相反。但是，人工评估员可能会在当前任务设置中对两个输出进行相同的评级，即使我们不知道哪些内容可以丢弃以及哪些内容应保持不变。

这里我们关注的问题不在于是否将内容选择与表面实现分开。 问题是NLG系统的最佳输出是上下文敏感的。 手头的任务是产生餐馆描述，这意味着一定程度的特定领域的“商业敏感性”，并非所有人群工人都关心。 寻找家庭友好型餐馆的用户可能只对家庭友好型餐厅感兴趣。 如果餐馆推荐应用程序决定省略此信息，则用户将非常不满意，这对业务有直接影响。

7.Conclusion

在本文中，我们介绍了我们参加E2E NLG挑战赛的结果。 我们开发了两种概念上不同的方法，并分析了它们在数量和质量上的表现。 我们的观察和结论揭示了现代NLG方法的局限性以及克服这些方法的可能方法