机器翻译

1. 人为设计许多特征（feature），但永远无法覆盖所有的语言现象；
2. 难以利用全局的特征；
3. 依赖于许多预处理环节，如词语对齐、分词或符号化（tokenization）、规则抽取、句法分析等，而每个环节的错误会逐步累积，对翻译的影响也越来越大。

1. 仍以统计机器翻译系统为框架，只是利用神经网络来改进其中的关键模块，如语言模型、调序模型等（见图1的左半部分）；
2. 不再以统计机器翻译系统为框架，而是直接用神经网络将源语言映射到目标语言，即端到端的神经网络机器翻译（End-to-End Neural Machine Translation, End-to-End NMT）（见图1的右半部分），简称为NMT模型。

这些 是 希望 的 曙光 和 解脱 的 迹象 .

0 -5.36816   These are signs of hope and relief . <e>
1 -6.23177   These are the light of hope and relief . <e>
2 -7.7914  These are the light of hope and the relief of hope . <e>

• 重置门（reset gate）：如果重置门关闭，会忽略掉历史信息，即历史不相干的信息不会影响未来的输出。
• 更新门（update gate）：将LSTM的输入门和遗忘门合并，用于控制历史信息对当前时刻隐层输出的影响。如果更新门接近1，会把历史信息传递下去。

1. one-hot vector表示：将源语言句子 x=\left { x_1,x_2,...,x_T \right } 的每个词\(x_i\)表示成一个列向量 w_i\epsilon \left { 0,1 \right }^{\left | V \right |},i=1,2,...,T。这个向量\(w_i\)的维度与词汇表大小\(\left | V \right |\) 相同，并且只有一个维度上有值1（该位置对应该词在词汇表中的位置），其余全是0。
2. 映射到低维语义空间的词向量：one-hot vector表示存在两个问题：
   1. 生成的向量维度往往很大，容易造成维数灾难；
   2. 难以刻画词与词之间的关系（如语义相似性，也就是无法很好地表达语义）。 因此，需再one-hot vector映射到低维的语义空间，由一个固定维度的稠密向量（称为词向量）表示。记映射矩阵为 \(C\epsilon R^{K\times \left | V \right |}\)，用\(s_i=Cw_i\) 表示第 \(i\) 个词的词向量，\(K\)为向量维度。
3. 用RNN编码源语言词序列：这一过程的计算公式为 \(h_i=\varnothing \theta \left ( h{i-1}, s_i \right )\)，其中\(h_0\)是一个全零的向量，\(\varnothing _\theta\)是一个非线性激活函数，最后得到的 \mathbf{h}=\left { h_1,..., h_T \right } 就是RNN依次读入源语言\(T\)个词的状态编码序列。整句话的向量表示可以采用\(\mathbf{h}\)在最后一个时间步\(T\)的状态编码，或使用时间维上的池化（pooling）结果。

• 每一个时刻，根据源语言句子的编码信息（又叫上下文向量，context vector）$c$、真实目标语言序列的第$i$个词$u_i$和$i$时刻RNN的隐层状态$z_i$，计算出下一个隐层状态$z_{i+1}$。计算公式如下： $ z_{i+1}=\phi _{\theta '}\left ( c,u_i,z_i \right ) $
• 其中$\phi _{\theta '}$是一个非线性激活函数；$c=q\mathbf{h}$是源语言句子的上下文向量，在不使用注意力机制时，如果编码器的输出是源语言句子编码后的最后一个元素，则可以定义$c=h_T$；$u_i$是目标语言序列的第$i$个单词，$u_0$是目标语言序列的开始标记<s>，表示解码开始；$z_i$是$i$时刻解码RNN的隐层状态，$z_0$是一个全零的向量。
• 将$z_{i+1}$通过softmax归一化，得到目标语言序列的第$i+1$个单词的概率分布$p_{i+1}$。概率分布公式如下： $ p\left ( u_{i+1}|u_{<i+1},\mathbf{x} \right )=softmax(W_sz_{i+1}+b_z) $
• 其中$W_sz_{i+1}+b_z$是对每个可能的输出单词进行打分，再用softmax归一化就可以得到第$i+1$个词的概率$p_{i+1}$。
• 根据$p_{i+1}$和$u_{i+1}$计算代价。 重复步骤1~3，直到目标语言序列中的所有词处理完毕。

1. 每一个时刻，根据源语言句子的编码信息$c$、生成的第$i$个目标语言序列单词$u_i$和$i$时刻RNN的隐层状态$z_i$，计算出下一个隐层状态$z_{i+1}$。
2. 将$z_{i+1}$通过softmax归一化，得到目标语言序列的第$i+1$个单词的概率分布$p_{i+1}$。
3. 根据$p_{i+1}$采样出单词$u_{i+1}$。
4. 重复步骤1~3，直到获得句子结束标记<e>或超过句子的最大生成长度为止。

• 将每个源语言到目标语言的平行语料库文件合并为一个文件：
  • 合并每个XXX.src和XXX.trg文件为XXX。
  • XXX中的第$i$行内容为XXX.src中的第$i$行和XXX.trg中的第$i$行连接，用'\t'分隔。
• 创建训练数据的“源字典”和“目标字典”。每个字典都有DICTSIZE 个单词，包括：语料中词频最高的（DICTSIZE - 3）个单词，和3个特殊符号<s>（序列的开始）、<e>（序列的结束）和<unk>（未登录词）。

# 加载 paddle的python包
import sys
import paddle.v2 as paddle
# 配置只使用cpu，并且使用一个cpu进行训练
paddle.init(use_gpu=False, trainer_count=1)
# 训练模式False，生成模式True
is_generating = False

   dict_size = 30000 # 字典维度
   source_dict_dim = dict_size # 源语言字典维度
   target_dict_dim = dict_size # 目标语言字典维度
   word_vector_dim = 512 # 词向量维度
   encoder_size = 512 # 编码器中的GRU隐层大小
   decoder_size = 512 # 解码器中的GRU隐层大小
   beam_size = 3 # 柱宽度
   max_length = 250 # 生成句子的最大长度

• 输入是一个文字序列，被表示成整型的序列。序列中每个元素是文字在字典中的索引。所以，我们定义数据层的数据类型为integer_value_sequence（整型序列），序列中每个元素的范围是[0, source_dict_dim)。

  src_word_id = paddle.layer.data(
          name='source_language_word',
          type=paddle.data_type.integer_value_sequence(source_dict_dim))
  

• 将上述编码映射到低维语言空间的词向量$\mathbf{s}$。

  src_embedding = paddle.layer.embedding(
          input=src_word_id,
          size=word_vector_dim,
          param_attr=paddle.attr.ParamAttr(name='_source_language_embedding'))
  

• 用双向GRU编码源语言序列，拼接两个GRU的编码结果得到$\mathbf{h}$。

  src_forward = paddle.networks.simple_gru(
          input=src_embedding, size=encoder_size)
      src_backward = paddle.networks.simple_gru(
          input=src_embedding, size=encoder_size, reverse=True)
      encoded_vector = paddle.layer.concat(input=[src_forward, src_backward])
  

• 对源语言序列编码后的结果（见2的最后一步），过一个前馈神经网络（Feed Forward Neural Network），得到其映射。

  with paddle.layer.mixed(size=decoder_size) as encoded_proj:
          encoded_proj += paddle.layer.full_matrix_projection(
              input=encoded_vector)
  

• 构造解码器RNN的初始状态。由于解码器需要预测时序目标序列，但在0时刻并没有初始值，所以我们希望对其进行初始化。这里采用的是将源语言序列逆序编码后的最后一个状态进行非线性映射，作为该初始值，即$c_0=h_T$。

  backward_first = paddle.layer.first_seq(input=src_backward)
      with paddle.layer.mixed(
              size=decoder_size, act=paddle.activation.Tanh()) as decoder_boot:
          decoder_boot += paddle.layer.full_matrix_projection(
              input=backward_first)
  

• decoder_mem记录了前一个时间步的隐层状态$z_i$，其初始状态是decoder_boot。
• context通过调用simple_attention函数，实现公式$c_i=\sum {j=1}^{T}a_{ij}h_j$。其中，enc_vec是$h_j$，enc_proj是$h_j$的映射（见3.1），权重$a_{ij}$的计算已经封装在simple_attention函数中。
• decoder_inputs融合了$c_i$和当前目标词current_word（即$u_i$）的表示。
• gru_step通过调用gru_step_layer函数，在decoder_inputs和decoder_mem上做了激活操作，即实现公式$z_{i+1}=\phi _{\theta '}\left ( c_i,u_i,z_i \right )$。
• 最后，使用softmax归一化计算单词的概率，将out结果返回，即实现公式$p\left ( u_i|u_{<i},\mathbf{x} \right )=softmax(W_sz_i+b_z)$。

    def gru_decoder_with_attention(enc_vec, enc_proj, current_word):
        decoder_mem = paddle.layer.memory(
            name='gru_decoder', size=decoder_size, boot_layer=decoder_boot)
        context = paddle.networks.simple_attention(
            encoded_sequence=enc_vec,
            encoded_proj=enc_proj,
            decoder_state=decoder_mem)
        with paddle.layer.mixed(size=decoder_size * 3) as decoder_inputs:
            decoder_inputs += paddle.layer.full_matrix_projection(input=context)
            decoder_inputs += paddle.layer.full_matrix_projection(
                input=current_word)
        gru_step = paddle.layer.gru_step(
            name='gru_decoder',
            input=decoder_inputs,
            output_mem=decoder_mem,
            size=decoder_size)
        with paddle.layer.mixed(
                size=target_dict_dim,
                bias_attr=True,
                act=paddle.activation.Softmax()) as out:
            out += paddle.layer.full_matrix_projection(input=gru_step)
        return out

decoder_group_name = "decoder_group"
group_input1 = paddle.layer.StaticInputV2(input=encoded_vector, is_seq=True)
group_input2 = paddle.layer.StaticInputV2(input=encoded_proj, is_seq=True)
group_inputs = [group_input1, group_input2]

• 首先，将目标语言序列的词向量trg_embedding，直接作为训练模式下的current_word传给gru_decoder_with_attention函数。
• 其次，使用recurrent_group函数循环调用gru_decoder_with_attention函数。
• 接着，使用目标语言的下一个词序列作为标签层lbl，即预测目标词。
• 最后，用多类交叉熵损失函数classification_cost来计算损失值。

   if not is_generating:
       trg_embedding = paddle.layer.embedding(
           input=paddle.layer.data(
               name='target_language_word',  
               type=paddle.data_type.integer_value_sequence(target_dict_dim)),
           size=word_vector_dim,
           param_attr=paddle.attr.ParamAttr(name='_target_language_embedding'))
       group_inputs.append(trg_embedding)
       # For decoder equipped with attention mechanism, in training,
       # target embeding (the groudtruth) is the data input,
       # while encoded source sequence is accessed to as an unbounded memory.
       # Here, the StaticInput defines a read-only memory
       # for the recurrent_group.
       decoder = paddle.layer.recurrent_group(
           name=decoder_group_name,
           step=gru_decoder_with_attention,
           input=group_inputs)
       lbl = paddle.layer.data(
           name='target_language_next_word',
           type=paddle.data_type.integer_value_sequence(target_dict_dim))
       cost = paddle.layer.classification_cost(input=decoder, label=lbl)

• 首先，在序列生成任务中，由于解码阶段的RNN总是引用上一时刻生成出的词的词向量，作为当前时刻的输入，因此，使用GeneratedInput来自动完成这一过程。具体说明可见GeneratedInput文档。
• 其次，使用beam_search函数循环调用gru_decoder_with_attention函数，生成出序列id。

   if is_generating:
       # In generation, the decoder predicts a next target word based on
       # the encoded source sequence and the last generated target word.
       # The encoded source sequence (encoder's output) must be specified by
       # StaticInput, which is a read-only memory.
       # Embedding of the last generated word is automatically gotten by
       # GeneratedInputs, which is initialized by a start mark, such as <s>,
       # and must be included in generation.
       trg_embedding = paddle.layer.GeneratedInputV2(
           size=target_dict_dim,
           embedding_name='_target_language_embedding',
           embedding_size=word_vector_dim)
       group_inputs.append(trg_embedding)
       beam_gen = paddle.layer.beam_search(
           name=decoder_group_name,
           step=gru_decoder_with_attention,
           input=group_inputs,
           bos_id=0,
           eos_id=1,
           beam_size=beam_size,
           max_length=max_length)

if not is_generating:
    parameters = paddle.parameters.create(cost)
    for param in parameters.keys():
        print param

if not is_generating:
    wmt14_reader = paddle.batch(
        paddle.reader.shuffle(
            paddle.dataset.wmt14.train(dict_size=dict_size), buf_size=8192),
        batch_size=5)

if not is_generating:
    optimizer = paddle.optimizer.Adam(
        learning_rate=5e-5,
        regularization=paddle.optimizer.L2Regularization(rate=8e-4))
    trainer = paddle.trainer.SGD(cost=cost,
                                 parameters=parameters,
                                 update_equation=optimizer)

if not is_generating:
    def event_handler(event):
        if isinstance(event, paddle.event.EndIteration):
            if event.batch_id % 2 == 0:
                print "\nPass %d, Batch %d, Cost %f, %s" % (
                    event.pass_id, event.batch_id, event.cost, event.metrics)

if not is_generating:
    trainer.train(
            reader=wmt14_reader, event_handler=event_handler, num_passes=2)

 Pass 0, Batch 0, Cost 148.444983, {'classification_error_evaluator': 1.0}
 .........
 Pass 0, Batch 10, Cost 335.896802, {'classification_error_evaluator': 0.9325153231620789}
 .........

if is_generating:
    parameters = paddle.dataset.wmt14.model()

if is_generating:
    gen_creator = paddle.dataset.wmt14.gen(dict_size)
    gen_data = []
    gen_num = 3
    for item in gen_creator():
        gen_data.append((item[0], ))
        if len(gen_data) == gen_num:
            break

if is_generating:
    beam_result = paddle.infer(
        output_layer=beam_gen,
        parameters=parameters,
        input=gen_data,
        field=['prob', 'id'])

if is_generating:
    # get the dictionary
    src_dict, trg_dict = paddle.dataset.wmt14.get_dict(dict_size)
    # the delimited element of generated sequences is -1,
    # the first element of each generated sequence is the sequence length
    seq_list = []
    seq = []
    for w in beam_result[1]:
        if w != -1:
            seq.append(w)
        else:
            seq_list.append(' '.join([trg_dict.get(w) for w in seq[1:]]))
            seq = []
    prob = beam_result[0]
    for i in xrange(gen_num):
        print "\n*******************************************************\n"
        print "src:", ' '.join(
            [src_dict.get(w) for w in gen_data[i][0]]), "\n"
        for j in xrange(beam_size):
            print "prob = %f:" % (prob[i][j]), seq_list[i * beam_size + j]

  src: <s> Les <unk> se <unk> au sujet de la largeur des sièges alors que de grosses commandes sont en jeu <e>
  prob = -19.019573: The <unk> will be rotated about the width of the seats , while large orders are at stake . <e>
  prob = -19.113066: The <unk> will be rotated about the width of the seats , while large commands are at stake . <e>
  prob = -19.512890: The <unk> will be rotated about the width of the seats , while large commands are at play . <e>