sequence是什么意思,sequence的意思翻译、用法、同义词、(Sequence2Sequence翻译)

大家好，今天小编来为大家解答sequence是什么意思,sequence的意思翻译、用法、同义词、这个问题，Sequence2Sequence翻译很多人还不知道，现在让我们一起来看看吧！

在这个项目中，我们将讲解使用神经网络将法语翻译成英语。

[KEY:>input,=target,<output]\n>ilestentraindepeindreuntableau.\n=heispaintingapicture.\n<heispaintingapicture.\n>pourquoinepasessayercevindelicieux?\n=whynottrythatdeliciouswine?\n<whynottrythatdeliciouswine?\n>ellenestpaspoetemaisromanciere.\n=sheisnotapoetbutanovelist.\n<shenotnotapoetbutanovelist.\n>vousetestropmaigre.\n=youretooskinny.\n<youreallalone.

…取得了不同程度的成功。

这可以通过序列到序列网络来实现，其中两个递归神经网络一起工作以将一个序列转换成另一个序列。编码器网络将输入序列压缩成向量，并且解码器网络将该向量展开成新的序列。

开始本教程前，你已经安装好了PyTorch，并熟悉Python语言，理解“张量”的概念：

https://pytorch.org/PyTorch安装指南

DeepLearningwithPyTorch：A60MinuteBlitz:PyTorch的基本入门教程

LearningPyTorchwithExamples:得到深层而广泛的概述

PyTorchforFormerTorchUsersLuaTorch:如果你曾是一个Lua张量的使用者

事先学习并了解序列到序列网络的工作原理对理解这个例子十分有帮助:

LearningPhraseRepresentationsusingRNNEncoder-DecoderforStatisticalMachineTranslation

SequencetoSequenceLearningwithNeuralNetworks

NeuralMachineTranslationbyJointlyLearningtoAlignandTranslate

您还可以找到之前有关ClassifyingNameswithaCharacter-LevelRNN和GeneratingNameswithaCharacter-LevelRNN的教程，因为这些概念分别与编码器和解码器模型非常相似。

更多信息，请阅读介绍这些主题的论文：

LearningPhraseRepresentationsusingRNNEncoder-DecoderforStatisticalMachineTranslation

SequencetoSequenceLearningwithNeuralNetworks

NeuralMachineTranslationbyJointlyLearningtoAlignandTranslate

from__future__importunicode_literals,print_function,division\nfromioimportopen\nimportunicodedata\nimportstring\nimportre\nimportrandom\nimporttorch\nimporttorch.nnasnn\nfromtorchimportoptim\nimporttorch.nn.functionalasF\ndevice=torch.device("cuda"iftorch.cuda.is_available()else"cpu")2.加载数据文件

该项目的数据是成千上万的英语到法语的翻译对的集合。

关于OpenDataStackExchange的这个问题，开放式翻译网站https://tatoeba.org/给出了指导，该网站的下载位于https://tatoeba.org/eng/downloads

更好的是，有人做了额外的拆分工作，将语言对分成单独的文本文件：https：//www.manythings.org/anki/

英语到法语对因为太大而无法包含在repo中，因此下载到data/eng-fra.txt再继续进行后续步骤。该文件是以制表符分隔的翻译对列表：

注意：从此处下载数据并将其解压缩到当前目录。

与字符级RNN教程中使用的字符编码类似，我们将语言中的每个单词表示为one-hot向量或零的巨向量，除了单个字符（在单词的索引处）。与语言中可能存在的几十个字符相比，还有更多的字，因此编码向量很大。然而，我们投机取巧并修剪数据，每种语言只使用几千个单词。

我们将需要每个单词的唯一索引，以便稍后用作网络的输入和目标。为了跟踪所有这些，我们将使用一个名为Lang的辅助类，它具有word→index（word2index）和index→word（index2word）的字典，以及用于稍后替换稀有单词的每个单词word2count的计数。

SOS_token=0\nEOS_token=1\nclassLang:\ndef__init__(self,name):\nself.name=name\nself.word2index={}\nself.word2count={}\nself.index2word={0:"SOS",1:"EOS"}\nself.n_words=2#CountSOSandEOS\ndefaddSentence(self,sentence):\nforwordinsentence.split(''):\nself.addWord(word)\ndefaddWord(self,word):\nifwordnotinself.word2index:\nself.word2index[word]=self.n_words\nself.word2count[word]=1\nself.index2word[self.n_words]=word\nself.n_words+=1\nelse:\nself.word2count[word]+=1

这些文件都是Unicode格式，为了简化我们将Unicode字符转换为ASCII，使所有内容都小写，并去掉大多数标点符号。

#将Unicode字符串转换为纯ASCII,感谢https://stackoverflow.com/a/518232/2809427\ndefunicodeToAscii(s):\nreturn''.join(\ncforcinunicodedata.normalize('NFD',s)\nifunicodedata.category(c)!='Mn'\n)\n#小写，修剪和删除非字母字符\ndefnormalizeString(s):\ns=unicodeToAscii(s.lower().strip())\ns=re.sub(r"([.!?])",r"\\1",s)\ns=re.sub(r"[^a-zA-Z.!?]+",r"",s)\nreturns2.1读取数据文件

要读取数据文件，我们将文件拆分为行，然后将行拆分成对。这些文件都是英语→其他语言，所以如果我们想翻译其他语言→英语，我添加reverse标志来反转对。

defreadLangs(lang1,lang2,reverse=False):\nprint("Readinglines...")\n#读取文件并分成几行\nlines=open('data/%s-%s.txt'%(lang1,lang2),encoding='utf-8').\\\nread().strip().split('\\n')\n#将每一行拆分成对并进行标准化\npairs=[[normalizeString(s)forsinl.split('\\t')]forlinlines]\n#反向对，使Lang实例\nifreverse:\npairs=[list(reversed(p))forpinpairs]\ninput_lang=Lang(lang2)\noutput_lang=Lang(lang1)\nelse:\ninput_lang=Lang(lang1)\noutput_lang=Lang(lang2)\nreturninput_lang,output_lang,pairs

由于有很多例句，我们想快速训练，我们会将数据集修剪成相对简短的句子。这里最大长度是10个单词（包括结束标点符号），我们将过滤到转换为“我是”或“他是”等形式的句子（考虑先前替换的撇号）。

MAX_LENGTH=10\neng_prefixes=(\n"iam","im",\n"heis","hes",\n"sheis","shes",\n"youare","youre",\n"weare","were",\n"theyare","theyre"\n)\ndeffilterPair(p):\nreturnlen(p[0].split(''))<MAX_LENGTHand\\\nlen(p[1].split(''))<MAX_LENGTHand\\\np[1].startswith(eng_prefixes)\ndeffilterPairs(pairs):\nreturn[pairforpairinpairsiffilterPair(pair)]

准备数据的完整过程是：

读取文本文件并拆分成行，将行拆分成对

规范化文本，按长度和内容进行过滤

defprepareData(lang1,lang2,reverse=False):\ninput_lang,output_lang,pairs=readLangs(lang1,lang2,reverse)\nprint("Read%ssentencepairs"%len(pairs))\npairs=filterPairs(pairs)\nprint("Trimmedto%ssentencepairs"%len(pairs))\nprint("Countingwords...")\nforpairinpairs:\ninput_lang.addSentence(pair[0])\noutput_lang.addSentence(pair[1])\nprint("Countedwords:")\nprint(input_lang.name,input_lang.n_words)\nprint(output_lang.name,output_lang.n_words)\nreturninput_lang,output_lang,pairs\ninput_lang,output_lang,pairs=prepareData('eng','fra',True)\nprint(random.choice(pairs))

输出结果：

Readinglines...\nRead135842sentencepairs\nTrimmedto10599sentencepairs\nCountingwords...\nCountedwords:\nfra4345\neng2803\n['nousnousdeshabillons.','wereundressing.']3.Seq2Seq模型

递归神经网络（RNN）是一种对序列进行操作的网络，它使用自己的输出作为后续步骤的输入。

SequencetoSequencenetwork(seq2seq网络)或[EncoderDecodernetwork(https://arxiv.org/pdf/1406.1078v3.pdf)是由称为编码器和解码器的两个RNN组成的模型。编码器读取输入序列并输出单个向量，并且解码器读取该向量以产生输出序列。

与使用单个RNN的序列预测不同，其中每个输入对应于输出，seq2seq模型使我们从序列长度和顺序中解放出来，这使其成为两种语言之间转换的理想选择。

考虑一句“Jenesuispaslechatnoir”→“我不是黑猫”。输入句子中的大多数单词在输出句子中都有直接翻译，但顺序略有不同，例如“聊天黑色”和“黑猫”。由于“ne/pas”结构，输入句中还有一个单词。直接从输入字序列产生正确的翻译将是困难的。

使用seq2seq模型，编码器创建单个向量，在理想情况下，将输入序列的“含义”编码为单个向量–句子的某些N维空间中的单个点。

seq2seq网络的编码器是RNN，它为输入句子中的每个单词输出一些值。对于每个输入的词，编码器输出向量和隐藏状态，并将隐藏状态用于下一个输入的单词。

classEncoderRNN(nn.Module):\ndef__init__(self,input_size,hidden_size):\nsuper(EncoderRNN,self).__init__()\nself.hidden_size=hidden_size\nself.embedding=nn.Embedding(input_size,hidden_size)\nself.gru=nn.GRU(hidden_size,hidden_size)\ndefforward(self,input,hidden):\nembedded=self.embedding(input).view(1,1,-1)\noutput=embedded\noutput,hidden=self.gru(output,hidden)\nreturnoutput,hidden\ndefinitHidden(self):\nreturntorch.zeros(1,1,self.hidden_size,device=device)3.2解码器

码器是另一个RNN，它接收编码器输出向量并输出一系列字以创建转换。

简单的解码器在最简单的seq2seq解码器中，我们仅使用编码器的最后一个输出。最后一个输出有时称为上下文向量，因为它编码整个序列的上下文。该上下文向量用作解码器的初始隐藏状态。

在解码的每个步骤中，给予解码器输入token和隐藏状态。初始输入token是开始字符串<SOS>标记，第一个隐藏状态是上下文向量（编码器的最后隐藏状态）。

classDecoderRNN(nn.Module):\ndef__init__(self,hidden_size,output_size):\nsuper(DecoderRNN,self).__init__()\nself.hidden_size=hidden_size\nself.embedding=nn.Embedding(output_size,hidden_size)\nself.gru=nn.GRU(hidden_size,hidden_size)\nself.out=nn.Linear(hidden_size,output_size)\nself.softmax=nn.LogSoftmax(dim=1)\ndefforward(self,input,hidden):\noutput=self.embedding(input).view(1,1,-1)\noutput=F.relu(output)\noutput,hidden=self.gru(output,hidden)\noutput=self.softmax(self.out(output[0]))\nreturnoutput,hidden\ndefinitHidden(self):\nreturntorch.zeros(1,1,self.hidden_size,device=device)

我鼓励你训练和观察这个模型的结果，但为了节省空间，我们将直接进入主题并引入注意机制。

如果仅在编码器和解码器之间传递上下文向量，则该单个向量承担编码整个句子的信息。

注意力允许解码器网络针对解码器自身输出的每个步骤“聚焦”编码器输出的不同部分。首先，我们计算一组注意力权重。这些将乘以编码器输出向量以创建加权组合。结果（在代码中称为attn_applied）应包含有关输入序列特定部分的信息，从而帮助解码器选择正确的输出单词。

使用解码器的输入和隐藏状态作为输入，使用另一个前馈层attn来计算注意力权重。因为训练数据中存在所有不同大小的句子，为了实际创建和训练该层，我们必须选择它可以应用的最大句子长度（输入长度?，对于编码器输出）。最大长度的句子将使用所有注意力权重，而较短的句子将仅使用前几个。

classAttnDecoderRNN(nn.Module):\ndef__init__(self,hidden_size,output_size,dropout_p=0.1,max_length=MAX_LENGTH):\nsuper(AttnDecoderRNN,self).__init__()\nself.hidden_size=hidden_size\nself.output_size=output_size\nself.dropout_p=dropout_p\nself.max_length=max_length\nself.embedding=nn.Embedding(self.output_size,self.hidden_size)\nself.attn=nn.Linear(self.hidden_size*2,self.max_length)\nself.attn_combine=nn.Linear(self.hidden_size*2,self.hidden_size)\nself.dropout=nn.Dropout(self.dropout_p)\nself.gru=nn.GRU(self.hidden_size,self.hidden_size)\nself.out=nn.Linear(self.hidden_size,self.output_size)\ndefforward(self,input,hidden,encoder_outputs):\nembedded=self.embedding(input).view(1,1,-1)\nembedded=self.dropout(embedded)\nattn_weights=F.softmax(\nself.attn(torch.cat((embedded[0],hidden[0]),1)),dim=1)\nattn_applied=torch.bmm(attn_weights.unsqueeze(0),\nencoder_outputs.unsqueeze(0))\noutput=torch.cat((embedded[0],attn_applied[0]),1)\noutput=self.attn_combine(output).unsqueeze(0)\noutput=F.relu(output)\noutput,hidden=self.gru(output,hidden)\noutput=F.log_softmax(self.out(output[0]),dim=1)\nreturnoutput,hidden,attn_weights\ndefinitHidden(self):\nreturntorch.zeros(1,1,self.hidden_size,device=device)

注意：

通过使用相对位置方法，还有其他形式的注意力可以解决长度限制问题。阅读[EffectiveApproachestoAttention-basedNeuralMachineTranslation.](https://arxiv.org/abs/1508.04025)的“本地注意”。

为了训练，对于每对翻译对，我们将需要输入张量（输入句子中的单词的索引）和目标张量（目标句子中的单词的索引）。在创建这些向量时，我们会将EOS标记附加到两个序列。

defindexesFromSentence(lang,sentence):\nreturn[lang.word2index[word]forwordinsentence.split('')]\ndeftensorFromSentence(lang,sentence):\nindexes=indexesFromSentence(lang,sentence)\nindexes.append(EOS_token)\nreturntorch.tensor(indexes,dtype=torch.long,device=device).view(-1,1)\ndeftensorsFromPair(pair):\ninput_tensor=tensorFromSentence(input_lang,pair[0])\ntarget_tensor=tensorFromSentence(output_lang,pair[1])\nreturn(input_tensor,target_tensor)4.2训练模型

为了训练我们通过编码器运行的输入句子，并跟踪每个输出和最新的隐藏状态。然后，解码器被赋予标记作为其第一输入，并且编码器的最后隐藏状态作为其第一隐藏状态。

“TeacherForcing”是将真实目标输出用作每个下一个输入的概念，而不是使用解码器的猜测作为下一个输入。使用teacherforcing使模型更快地收敛，但是当利用受过训练的网络时，它可能表现出不稳定性。

您可以观察teacherforcing网络的输出，这些网络使用连贯的语法阅读，但远离正确的翻译–直觉上它已经学会表示输出语法，并且一旦老师告诉它前几个单词就可以“提取”意义，但是它没有正确地学习如何从翻译中创建句子。

由于PyTorch的autograd为我们提供了自由，我们可以随意选择使用teacherforcing或不使用简单的if语句。将teacher_forcing_ratio调高以使用更多。

teacher_forcing_ratio=0.5\ndeftrain(input_tensor,target_tensor,encoder,decoder,encoder_optimizer,decoder_optimizer,criterion,max_length=MAX_LENGTH):\nencoder_hidden=encoder.initHidden()\nencoder_optimizer.zero_grad()\ndecoder_optimizer.zero_grad()\ninput_length=input_tensor.size(0)\ntarget_length=target_tensor.size(0)\nencoder_outputs=torch.zeros(max_length,encoder.hidden_size,device=device)\nloss=0\nforeiinrange(input_length):\nencoder_output,encoder_hidden=encoder(\ninput_tensor[ei],encoder_hidden)\nencoder_outputs[ei]=encoder_output[0,0]\ndecoder_input=torch.tensor([[SOS_token]],device=device)\ndecoder_hidden=encoder_hidden\nuse_teacher_forcing=Trueifrandom.random()<teacher_forcing_ratioelseFalse\nifuse_teacher_forcing:\n#Teacherforcing:Feedthetargetasthenextinput\nfordiinrange(target_length):\ndecoder_output,decoder_hidden,decoder_attention=decoder(\ndecoder_input,decoder_hidden,encoder_outputs)\nloss+=criterion(decoder_output,target_tensor[di])\ndecoder_input=target_tensor[di]#Teacherforcing\nelse:\n#Withoutteacherforcing:useitsownpredictionsasthenextinput\nfordiinrange(target_length):\ndecoder_output,decoder_hidden,decoder_attention=decoder(\ndecoder_input,decoder_hidden,encoder_outputs)\ntopv,topi=decoder_output.topk(1)\ndecoder_input=topi.squeeze().detach()#detachfromhistoryasinput\nloss+=criterion(decoder_output,target_tensor[di])\nifdecoder_input.item()==EOS_token:\nbreak\nloss.backward()\nencoder_optimizer.step()\ndecoder_optimizer.step()\nreturnloss.item()/target_length辅助函数

这是一个辅助函数，用于打印经过的时间和估计的剩余时间给定当前时间和进度％。

importtime\nimportmath\ndefasMinutes(s):\nm=math.floor(s/60)\ns-=m*60\nreturn'%dm%ds'%(m,s)\ndeftimeSince(since,percent):\nnow=time.time()\ns=now-since\nes=s/(percent)\nrs=es-s\nreturn'%s(-%s)'%(asMinutes(s),asMinutes(rs))

整个训练过程如下：

然后我们调用train，偶尔打印进度（例子的百分比，到目前为止的时间，估计的时间）和平均损失。

deftrainIters(encoder,decoder,n_iters,print_every=1000,plot_every=100,learning_rate=0.01):\nstart=time.time()\nplot_losses=[]\nprint_loss_total=0#Reseteveryprint_every\nplot_loss_total=0#Reseteveryplot_every\nencoder_optimizer=optim.SGD(encoder.parameters(),lr=learning_rate)\ndecoder_optimizer=optim.SGD(decoder.parameters(),lr=learning_rate)\ntraining_pairs=[tensorsFromPair(random.choice(pairs))\nforiinrange(n_iters)]\ncriterion=nn.NLLLoss()\nforiterinrange(1,n_iters+1):\ntraining_pair=training_pairs[iter-1]\ninput_tensor=training_pair[0]\ntarget_tensor=training_pair[1]\nloss=train(input_tensor,target_tensor,encoder,\ndecoder,encoder_optimizer,decoder_optimizer,criterion)\nprint_loss_total+=loss\nplot_loss_total+=loss\nifiter%print_every==0:\nprint_loss_avg=print_loss_total/print_every\nprint_loss_total=0\nprint('%s(%d%d%%)%.4f'%(timeSince(start,iter/n_iters),\niter,iter/n_iters*100,print_loss_avg))\nifiter%plot_every==0:\nplot_loss_avg=plot_loss_total/plot_every\nplot_losses.append(plot_loss_avg)\nplot_loss_total=0\nshowPlot(plot_losses)结果绘图函数

绘图使用matplotlib库完成，使用在训练时保存的plot_losses的损失值数组。

importmatplotlib.pyplotasplt\nplt.switch_backend('agg')\nimportmatplotlib.tickerasticker\nimportnumpyasnp\ndefshowPlot(points):\nplt.figure()\nfig,ax=plt.subplots()\n#thislocatorputsticksatregularintervals\nloc=ticker.MultipleLocator(base=0.2)\nax.yaxis.set_major_locator(loc)\nplt.plot(points)评价函数

评估与训练大致相同，但没有目标，因此我们只需将解码器的预测反馈给每个步骤。每次它预测一个单词时我们都会将它添加到输出字符串中，如果它预测了EOS标记，我们就会停在那里。我们还存储解码器的注意力输出以供稍后显示。

defevaluate(encoder,decoder,sentence,max_length=MAX_LENGTH):\nwithtorch.no_grad():\ninput_tensor=tensorFromSentence(input_lang,sentence)\ninput_length=input_tensor.size()[0]\nencoder_hidden=encoder.initHidden()\nencoder_outputs=torch.zeros(max_length,encoder.hidden_size,device=device)\nforeiinrange(input_length):\nencoder_output,encoder_hidden=encoder(input_tensor[ei],\nencoder_hidden)\nencoder_outputs[ei]+=encoder_output[0,0]\ndecoder_input=torch.tensor([[SOS_token]],device=device)#SOS\ndecoder_hidden=encoder_hidden\ndecoded_words=[]\ndecoder_attentions=torch.zeros(max_length,max_length)\nfordiinrange(max_length):\ndecoder_output,decoder_hidden,decoder_attention=decoder(\ndecoder_input,decoder_hidden,encoder_outputs)\ndecoder_attentions[di]=decoder_attention.data\ntopv,topi=decoder_output.data.topk(1)\niftopi.item()==EOS_token:\ndecoded_words.append('<EOS>')\nbreak\nelse:\ndecoded_words.append(output_lang.index2word[topi.item()])\ndecoder_input=topi.squeeze().detach()\nreturndecoded_words,decoder_attentions[:di+1]

我们可以从训练集中评估随机句子并打印输入、目标和输出以做出一些直观质量判断：

defevaluateRandomly(encoder,decoder,n=10):\nforiinrange(n):\npair=random.choice(pairs)\nprint('>',pair[0])\nprint('=',pair[1])\noutput_words,attentions=evaluate(encoder,decoder,pair[0])\noutput_sentence=''.join(output_words)\nprint('<',output_sentence)\nprint('')5.训练和评价

有了所有这些辅助函数（它看起来像是额外的工作，但它使得运行多个实验更容易）我们实际上可以初始化网络并开始训练。

请记住，输入句子被严格过滤。对于这个小数据集，我们可以使用256个隐藏节点和单个GRU层的相对较小的网络。在MacBookCPU上大约40分钟后，我们将得到一些合理的结果。

如果你运行这个笔记，你可以训练、中断内核、评估，并在以后继续训练。注释掉编码器和解码器初始化的行并再次运行trainIters。

hidden_size=256\nencoder1=EncoderRNN(input_lang.n_words,hidden_size).to(device)\nattn_decoder1=AttnDecoderRNN(hidden_size,output_lang.n_words,dropout_p=0.1).to(device)\ntrainIters(encoder1,attn_decoder1,75000,print_every=5000)

输出结果：

1m53s(-26m24s)(50006%)2.8558\n3m42s(-24m3s)(1000013%)2.2832\n5m31s(-22m6s)(1500020%)1.9841\n7m19s(-20m8s)(2000026%)1.7271\n9m7s(-18m15s)(2500033%)1.5487\n10m54s(-16m21s)(3000040%)1.3461\n12m41s(-14m30s)(3500046%)1.2251\n14m30s(-12m41s)(4000053%)1.0956\n16m16s(-10m51s)(4500060%)1.0126\n18m5s(-9m2s)(5000066%)0.9212\n19m52s(-7m13s)(5500073%)0.7952\n21m41s(-5m25s)(6000080%)0.7481\n23m29s(-3m36s)(6500086%)0.6882\n25m17s(-1m48s)(7000093%)0.6190\n27m6s(-0m0s)(75000100%)0.5745\nevaluateRandomly(encoder1,attn_decoder1)

输出结果：

>jeparsenvacancespourquelquesjours.\n=imtakingacoupleofdaysoff.\n<imtakingacoupleofdaysoff.<EOS>\n>jenemepaniquepas.\n=imnotpanicking.\n<imnotpanicking.<EOS>\n>jerechercheunassistant.\n=iamlookingforanassistant.\n<imlookingacall.<EOS>\n>jesuisloindechezmoi.\n=imalongwayfromhome.\n<imalittlefriend.<EOS>\n>vousetesenretard.\n=youreverylate.\n<youarelate.<EOS>\n>jaisoif.\n=iamthirsty.\n<imthirsty.<EOS>\n>jesuisfoudevous.\n=imcrazyaboutyou.\n<imcrazyaboutyou.<EOS>\n>vousetesvilain.\n=youarenaughty.\n<youarenaughty.<EOS>\n>ilestvieuxetlaid.\n=hesoldandugly.\n<hesoldandugly.<EOS>\n>jesuisterrifiee.\n=imterrified.\n<imtouched.<EOS>6.可视化注意力

注意力机制的一个有用特性是其高度可解释的输出。因为它用于对输入序列的特定编码器输出进行加权，所以我们可以想象在每个时间步长看网络最关注的位置。

您可以简单地运行plt.matshow（attention）以将注意力输出显示为矩阵，其中列是输入步骤，行是输出步骤：

output_words,attentions=evaluate(\nencoder1,attn_decoder1,"jesuistropfroid.")\nplt.matshow(attentions.numpy())

为了获得更好的观看体验，我们将额外添加轴和标签：

defshowAttention(input_sentence,output_words,attentions):\n#用colorbar设置图\nfig=plt.figure()\nax=fig.add_subplot(111)\ncax=ax.matshow(attentions.numpy(),cmap='bone')\nfig.colorbar(cax)\n#设置坐标\nax.set_xticklabels(['']+input_sentence.split('')+\n['<EOS>'],rotation=90)\nax.set_yticklabels(['']+output_words)\n#在每个刻度处显示标签\nax.xaxis.set_major_locator(ticker.MultipleLocator(1))\nax.yaxis.set_major_locator(ticker.MultipleLocator(1))\nplt.show()\ndefevaluateAndShowAttention(input_sentence):\noutput_words,attentions=evaluate(\nencoder1,attn_decoder1,input_sentence)\nprint('input=',input_sentence)\nprint('output=',''.join(output_words))\nshowAttention(input_sentence,output_words,attentions)\nevaluateAndShowAttention("elleacinqansdemoinsquemoi.")\nevaluateAndShowAttention("elleesttroppetit.")\nevaluateAndShowAttention("jenecrainspasdemourir.")\nevaluateAndShowAttention("cestunjeunedirecteurpleindetalent.")

输出结果：

input=elleacinqansdemoinsquemoi.\noutput=sheistwoyearsyoungerthanme.<EOS>\ninput=elleesttroppetit.\noutput=shestootrusting.<EOS>\ninput=jenecrainspasdemourir.\noutput=imnotafraidofdying.<EOS>\ninput=cestunjeunedirecteurpleindetalent.\noutput=hesafastperson.<EOS>7.练习

尝试使用其他数据集：

用预先训练过的字嵌入（例如word2vec或GloVe）替换嵌入

尝试使用更多图层，更多隐藏单元和更多句子。比较训练时间和结果。

如果你使用翻译文件，其中对有两个相同的短语（Iamtest\\tIamtes），你可以使用它作为自动编码器。试试这个：

?*从那里训练一个新的解码器进行翻译

文章来源：https://zhiya360.com/docs/pytorchstudy/pytorch-txt/05-sequence2sequence

关于sequence是什么意思,sequence的意思翻译、用法、同义词、的内容到此结束，希望对大家有所帮助。