0
0

【自然语言处理（NLP）】基于序列到序列的中-英机器翻译

【自然语言处理（NLP）】基于序列到序列的中-英机器翻译

在这里插入图片描述

作者简介：在校大学生一枚，华为云享专家，阿里云专家博主，腾云先锋（TDP）成员，云曦智划项目总负责人，全国高等学校计算机教学与产业实践资源建设专家委员会（TIPCC）志愿者，以及编程爱好者，期待和大家一起学习，一起进步~
.
博客主页：ぃ灵彧が的学习日志
.
本文专栏：人工智能
.
专栏寄语：若你决定灿烂，山无遮，海无拦
.
在这里插入图片描述

文章目录

前言

(一)、任务描述

本示例教程介绍如何使用飞桨完成一个机器翻译任务。

我们将会使用飞桨提供的LSTM的API，组建一个sequence to sequence with attention的机器翻译的模型，并在示例的数据集上完成从英文翻译成中文的机器翻译。

(二)、环境配置

本示例基于飞桨开源框架2.0版本。

  1. import paddle
  2. import paddle.nn.functional as F
  3. import re
  4. import numpy as np
  6. print(paddle.__version__)# cpu/gpu环境选择，在 paddle.set_device() 输入对应运行设备。# device = paddle.set_device('gpu')

输出结果如下图1所示：
在这里插入图片描述

一、数据准备

(一)、数据集下载

我们将使用 http://www.manythings.org/anki/ 提供的中英文的英汉句对作为数据集，来完成本任务。该数据集含有23610个中英文双语的句对。

  1. !wget -c https://www.manythings.org/anki/cmn-eng.zip&& unzip cmn-eng.zip
  1. !wc -l cmn.txt

输出结果如下图2所示：

在这里插入图片描述

(二)、构建双语句对的数据结构

接下来我们通过处理下载下来的双语句对的文本文件，将双语句对读入到python的数据结构中。这里做了如下的处理。
​

  • 对于英文，会把全部英文都变成小写，并只保留英文的单词。 ​
  • 对于中文，为了简便起见，未做分词，按照字做了切分。 ​
  • 为了后续的程序运行的更快，我们通过限制句子长度，和只保留部分英文单词开头的句子的方式，得到了一个较小的数据集。这样得到了一个有5508个句对的数据集。
  1. MAX_LEN =10
  1. lines =open('cmn.txt', encoding='utf-8').read().strip().split('\n')
  2. words_re = re.compile(r'\w+')
  4. pairs =[]for l in lines:
  5.     en_sent, cn_sent, _ = l.split('\t')
  6.     pairs.append((words_re.findall(en_sent.lower()),list(cn_sent)))# create a smaller dataset to make the demo process faster
  7. filtered_pairs =[]for x in pairs:iflen(x[0])< MAX_LEN andlen(x[1])< MAX_LEN and \
  8.     x[0][0]in('i','you','he','she','we','they'):
  9.         filtered_pairs.append(x)print(len(filtered_pairs))for x in filtered_pairs[:10]:print(x)

输出结果如下图3所示：

在这里插入图片描述

(三)、创建词表

接下来我们分别创建中英文的词表，这两份词表会用来将英文和中文的句子转换为词的ID构成的序列。词表中还加入了如下三个特殊的词： - : 用来对较短的句子进行填充。 - : “begin of sentence”， 表示句子的开始的特殊词。 - : “end of sentence”， 表示句子的结束的特殊词。

Note: 在实际的任务中，可能还需要通过（或者）特殊词来表示未在词表中出现的词。

  1. en_vocab ={}
  2. cn_vocab ={}# create special token for pad, begin of sentence, end of sentence
  3. en_vocab['<pad>'], en_vocab['<bos>'], en_vocab['<eos>']=0,1,2
  4. cn_vocab['<pad>'], cn_vocab['<bos>'], cn_vocab['<eos>']=0,1,2
  6. en_idx, cn_idx =3,3for en, cn in filtered_pairs:for w in en:if w notin en_vocab:
  7.             en_vocab[w]= en_idx
  8.             en_idx +=1for w in cn:if w notin cn_vocab:
  9.             cn_vocab[w]= cn_idx
  10.             cn_idx +=1print(len(list(en_vocab)))print(len(list(cn_vocab)))

输出结果如下图4所示：

在这里插入图片描述

(四)、创建padding过的数据集

接下来根据词表，我们将会创建一份实际的用于训练的用numpy array组织起来的数据集。 - 所有的句子都通过补充成为了长度相同的句子。 - 对于英文句子（源语言），我们将其反转了过来，这会带来更好的翻译的效果。 - 所创建的padded_cn_label_sents是训练过程中的预测的目标，即，每个中文的当前词去预测下一个词是什么词。

  1. padded_en_sents =[]
  2. padded_cn_sents =[]
  3. padded_cn_label_sents =[]for en, cn in filtered_pairs:# reverse source sentence
  4.     padded_en_sent = en +['<eos>']+['<pad>']*(MAX_LEN -len(en))
  5.     padded_en_sent.reverse()
  6.     padded_cn_sent =['<bos>']+ cn +['<eos>']+['<pad>']*(MAX_LEN -len(cn))
  7.     padded_cn_label_sent = cn +['<eos>']+['<pad>']*(MAX_LEN -len(cn)+1)
  9.     padded_en_sents.append([en_vocab[w]for w in padded_en_sent])
  10.     padded_cn_sents.append([cn_vocab[w]for w in padded_cn_sent])
  11.     padded_cn_label_sents.append([cn_vocab[w]for w in padded_cn_label_sent])
  13. train_en_sents = np.array(padded_en_sents)
  14. train_cn_sents = np.array(padded_cn_sents)
  15. train_cn_label_sents = np.array(padded_cn_label_sents)print(train_en_sents.shape)print(train_cn_sents.shape)print(train_cn_label_sents.shape)

输出结果如下图5所示：

在这里插入图片描述

二、网络构建

我们将会创建一个Encoder-AttentionDecoder架构的模型结构用来完成机器翻译任务。 首先我们将设置一些必要的网络结构中用到的参数。

  1. embedding_size =128
  2. hidden_size =256
  3. num_encoder_lstm_layers =1
  4. en_vocab_size =len(list(en_vocab))
  5. cn_vocab_size =len(list(cn_vocab))
  6. epochs =20
  7. batch_size =16

(一)、Encoder部分

在编码器的部分，我们通过查找完Embedding之后接一个LSTM的方式构建一个对源语言编码的网络。飞桨的RNN系列的API，除了LSTM之外，还提供了SimleRNN, GRU供使用，同时，还可以使用反向RNN，双向RNN，多层RNN等形式。也可以通过dropout参数设置是否对多层RNN的中间层进行dropout处理，来防止过拟合。

除了使用序列到序列的RNN操作之外，也可以通过SimpleRNN, GRUCell, LSTMCell等API更灵活的创建单步的RNN计算，甚至通过继承RNNCellBase来实现自己的RNN计算单元。

  1. # encoder: simply learn representation of source sentenceclassEncoder(paddle.nn.Layer):def__init__(self):super(Encoder, self).__init__()
  2.         self.emb = paddle.nn.Embedding(en_vocab_size, embedding_size,)
  3.         self.lstm = paddle.nn.LSTM(input_size=embedding_size,
  4.                                    hidden_size=hidden_size,
  5.                                    num_layers=num_encoder_lstm_layers)defforward(self, x):
  6.         x = self.emb(x)
  7.         x,(_, _)= self.lstm(x)return x

(二)、Decoder部分

在解码器部分，我们通过一个去除注意力机制的LSTM来完成解码，也就是一个最简单的encoder-decoder模型架构。

  • 单步的LSTM：在解码器的实现的部分，我们同样使用LSTM，与Encoder部分不同的是，下面的代码，每次只让LSTM往前计算一次。整体的recurrent部分，是在训练循环内完成的。
  • 对于第一次接触这样的网络结构来说，下面的代码在理解起来可能稍微有些复杂，你可以通过插入打印每个tensor在不同步骤时的形状的方式来更好的理解。
  1. # only move one step of LSTM,# the recurrent loop is implemented inside training loopclassDecoder(paddle.nn.Layer):def__init__(self):super(Decoder, self).__init__()
  2.         self.emb = paddle.nn.Embedding(cn_vocab_size, embedding_size)
  3.         self.lstm = paddle.nn.LSTM(input_size=embedding_size + hidden_size,
  4.                                    hidden_size=hidden_size)# for computing output logits
  5.         self.outlinear =paddle.nn.Linear(hidden_size, cn_vocab_size)defforward(self, x, previous_hidden, previous_cell, encoder_outputs):
  6.         x = self.emb(x)#encoder_outputs 16*11*256
  7.         context_vector = paddle.sum(encoder_outputs,1)#context_vector 16*1*256
  8.         context_vector = paddle.unsqueeze(context_vector,1)#lstm_input 16*1*384
  9.         lstm_input = paddle.concat((x, context_vector), axis=-1)# LSTM requirement to previous hidden/state:# (number_of_layers * direction, batch, hidden)
  10.         previous_hidden = paddle.transpose(previous_hidden,[1,0,2])
  11.         previous_cell = paddle.transpose(previous_cell,[1,0,2])
  13.         x,(hidden, cell)= self.lstm(lstm_input,(previous_hidden, previous_cell))# change the return to (batch, number_of_layers * direction, hidden)
  14.         hidden = paddle.transpose(hidden,[1,0,2])
  15.         cell = paddle.transpose(cell,[1,0,2])
  17.         output = self.outlinear(hidden)
  18.         output = paddle.squeeze(output)return output,(hidden, cell)

三、模型训练

接下来我们开始训练模型。

  • 在每个epoch开始之前，我们对训练数据进行了随机打乱。
  • 我们通过多次调用atten_decoder，在这里实现了解码时的recurrent循环。
  • teacher forcing策略: 在每次解码下一个词时，我们给定了训练数据当中的真实词作为了预测下一个词时的输入。相应的，你也可以尝试用模型预测的结果作为下一个词的输入。（或者混合使用）
  1. encoder = Encoder()
  2. decoder = Decoder()
  4. opt = paddle.optimizer.Adam(learning_rate=0.001,
  5.                             parameters=encoder.parameters()+decoder.parameters())for epoch inrange(epochs):print("epoch:{}".format(epoch))# shuffle training data
  6.     perm = np.random.permutation(len(train_en_sents))
  7.     train_en_sents_shuffled = train_en_sents[perm]
  8.     train_cn_sents_shuffled = train_cn_sents[perm]
  9.     train_cn_label_sents_shuffled = train_cn_label_sents[perm]for iteration inrange(train_en_sents_shuffled.shape[0]// batch_size):
  10.         x_data = train_en_sents_shuffled[(batch_size*iteration):(batch_size*(iteration+1))]
  11.         sent = paddle.to_tensor(x_data)
  12.         en_repr = encoder(sent)
  14.         x_cn_data = train_cn_sents_shuffled[(batch_size*iteration):(batch_size*(iteration+1))]
  15.         x_cn_label_data = train_cn_label_sents_shuffled[(batch_size*iteration):(batch_size*(iteration+1))]# shape: (batch,  num_layer(=1 here) * num_of_direction(=1 here), hidden_size)
  16.         hidden = paddle.zeros([batch_size,1, hidden_size])
  17.         cell = paddle.zeros([batch_size,1, hidden_size])
  19.         loss = paddle.zeros([1])# the decoder recurrent loop mentioned abovefor i inrange(MAX_LEN +2):
  20.             cn_word = paddle.to_tensor(x_cn_data[:,i:i+1])
  21.             cn_word_label = paddle.to_tensor(x_cn_label_data[:,i])
  23.             logits,(hidden, cell)= decoder(cn_word, hidden, cell, en_repr)
  24.             step_loss = F.cross_entropy(logits, cn_word_label)
  25.             loss += step_loss
  26.         loss = loss /(MAX_LEN +2)if(iteration %200==0):print("iter {}, loss:{}".format(iteration, loss.numpy()))
  28.         loss.backward()
  29.         opt.step()
  30.         opt.clear_grad()

输出结果如下图6所示：

在这里插入图片描述

四、使用模型进行机器翻译

根据你所使用的计算设备的不同，上面的训练过程可能需要不等的时间。（在一台Mac笔记本上，大约耗时15~20分钟） 完成上面的模型训练之后，我们可以得到一个能够从英文翻译成中文的机器翻译模型。接下来我们通过一个greedy search来实现使用该模型完成实际的机器翻译。（实际的任务中，你可能需要用beam search算法来提升效果）

  1. encoder.eval()
  2. decoder.eval()
  4. num_of_exampels_to_evaluate =10
  6. indices = np.random.choice(len(train_en_sents),  num_of_exampels_to_evaluate, replace=False)
  7. x_data = train_en_sents[indices]
  8. sent = paddle.to_tensor(x_data)
  9. en_repr = encoder(sent)
  11. word = np.array([[cn_vocab['<bos>']]]* num_of_exampels_to_evaluate
  12. )
  13. word = paddle.to_tensor(word)
  15. hidden = paddle.zeros([num_of_exampels_to_evaluate,1, hidden_size])
  16. cell = paddle.zeros([num_of_exampels_to_evaluate,1, hidden_size])
  18. decoded_sent =[]for i inrange(MAX_LEN +2):
  19.     logits,(hidden, cell)= decoder(word, hidden, cell, en_repr)
  20.     word = paddle.argmax(logits, axis=1)
  21.     decoded_sent.append(word.numpy())
  22.     word = paddle.unsqueeze(word, axis=-1)
  24. results = np.stack(decoded_sent, axis=1)for i inrange(num_of_exampels_to_evaluate):
  25.     en_input =" ".join(filtered_pairs[indices[i]][0])
  26.     ground_truth_translate ="".join(filtered_pairs[indices[i]][1])
  27.     model_translate =""for k in results[i]:
  28.         w =list(cn_vocab)[k]if w !='<pad>'and w !='<eos>':
  29.             model_translate += w
  30.     print(en_input)print("true: {}".format(ground_truth_translate))print("pred: {}".format(model_translate))

输出结果如下图7所示：

在这里插入图片描述

总结

本系列文章内容为根据清华社出版的《自然语言处理实践》所作的相关笔记和感悟，其中代码均为基于百度飞桨开发，若有任何侵权和不妥之处，请私信于我，定积极配合处理，看到必回！！！

最后，引用本次活动的一句话，来作为文章的结语～(￣▽￣～)~：

【学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。】

ps：更多精彩内容还请进入本文专栏：人工智能，进行查看，欢迎大家支持与指教啊～(￣▽￣～)~

在这里插入图片描述

标签： 自然语言处理 机器翻译 人工智能
本文转载自: https://blog.csdn.net/m0_54754302/article/details/127344359
版权归原作者 ぃ灵彧が 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【自然语言处理（NLP）】基于序列到序列的中-英机器翻译”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？