hubsche德语？在PyTorch中使用Seq2Seq构建的神经机器翻译模型

这篇文章给大家聊聊关于hubsche德语，以及在PyTorch中使用Seq2Seq构建的神经机器翻译模型对应的知识点，希望对各位有所帮助，不要忘了收藏本站哦。

在这篇文章中，我们将构建一个基于LSTM的Seq2Seq模型，使用编码器-解码器架构进行机器翻译。

1.Seq2Seq(编码器+解码器)代码实现

神经机器翻译(NMT)是一种机器翻译方法，它使用人工神经网络来预测一个单词序列的可能性，通常在一个单一的集成模型中建模整个句子。

对于计算机来说，用一个简单的基于规则的系统从一种语言转换成另一种语言是最困难的问题之一，因为它们无法捕捉到过程中的细微差别。不久之后，我们开始使用统计模型，但在进入深度学习之后，这个领域被统称为神经机器翻译，现在已经取得了最先进的成果。

这篇文章是针对于初学者的，所以一个特定类型的架构(Seq2Seq)显示了一个好的开始，这就是我们要在这里实现的。

因此，本文中的序列对序列(seq2seq)模型使用了一种编码器-解码器架构，它使用一种名为LSTM(长短期记忆)的RNN，其中编码器神经网络将输入的语言序列编码为单个向量，也称为上下文向量。

这个上下文向量被称为包含输入语言序列的抽象表示。

然后将这个向量传递到解码器神经网络中，用解码器神经网络一个词一个词地输出相应的输出语言翻译句子。

这里我正在做一个德语到英语的神经机器翻译。但同样的概念可以扩展到其他问题，如命名实体识别(NER)，文本摘要，甚至其他语言模型，等等。

为了以我们想要的最佳方式获取数据，我使用了SpaCy(词汇构建)、TorchText(文本预处理)库和multi30kdataset，其中包含英语、德语和法语的翻译序列

1.训练/验证/测试分割:将数据分割到指定的训练/验证/测试集。

1.文件加载:加载各种格式(.txt、.json、.csv)的文本语料库。

1.从文本语料库生成一个词汇表列表。

1.单词编码:将单词映射为整个语料库的整数，反之亦然。

1.字向量:将字从高维转换为低维(字嵌入)。

因此，一旦我们了解了torch文本可以做什么，让我们谈谈如何在torchtext模块中实现它。在这里，我们将利用torchtext下的3个类。

Fields:这是torchtext下的一个类，在这里我们指定如何在我们的数据库里进行预处理。

TabularDataset:我们实际上可以定义以CSV、TSV或JSON格式存储的列数据集，并将它们映射为整数。

BucketIterator:我们可以填充我们的数据以获得近似，并使用我们的数据批量进行模型训练。

这里我们的源语言(SRC-Input)是德语，目标语言(TRG-Output)是英语。为了有效的模型训练，我们还额外增加了两个令牌"序列开始"和"序列结束"。

!pipinstalltorchtext==0.6.0--quiet\nimporttorch\nimporttorch.nnasnn\nimporttorch.optimasoptim\nfromtorchtext.datasetsimportMulti30k\nfromtorchtext.dataimportField,BucketIterator\nimportnumpyasnp\nimportpandasaspd\nimportspacy,random\n\n##LoadingtheSpaCy'svocabularyforourdesiredlanguages.\n!python-mspacydownloaden--quiet\n!python-mspacydownloadde--quiet\n\nspacy_german=spacy.load("de")\nspacy_english=spacy.load("en")\n\ndeftokenize_german(text):\nreturn[token.textfortokeninspacy_german.tokenizer(text)]\n\ndeftokenize_english(text):\nreturn[token.textfortokeninspacy_english.tokenizer(text)]\n\ngerman=Field(tokenize=tokenize_german,lower=True,\ninit_token="<sos>",eos_token="<eos>")\n\nenglish=Field(tokenize=tokenize_english,lower=True,\ninit_token="<sos>",eos_token="<eos>")\n\ntrain_data,valid_data,test_data=Multi30k.splits(exts=(".de",".en"),\nfields=(german,english))\n\ngerman.build_vocab(train_data,max_size=10000,min_freq=3)\nenglish.build_vocab(train_data,max_size=10000,min_freq=3)\n\nprint(f"Uniquetokensinsource(de)vocabulary:{len(german.vocab)}")\nprint(f"Uniquetokensintarget(en)vocabulary:{len(english.vocab)}")\n\n*******************************OUTPUT*******************************\n\nUniquetokensinsource(de)vocabulary:5376\nUniquetokensintarget(en)vocabulary:4556

在设置了语言预处理标准之后，下一步是使用迭代器创建成批的训练、测试和验证数据。

创建批是一个详尽的过程，幸运的是我们可以利用TorchText的迭代器库。

这里我们使用BucketIterator来有效填充源句和目标句。我们可以使用.src属性访问源(德语)批数据，使用.trg属性访问对应的(英语)批数据。同样，我们可以在标记之前看到数据。

device=torch.device('cuda'iftorch.cuda.is_available()else'cpu')\nBATCH_SIZE=32\n\ntrain_iterator,valid_iterator,test_iterator=BucketIterator.splits((train_data,valid_data,test_data),\nbatch_size=BATCH_SIZE,\nsort_within_batch=True,\nsort_key=lambdax:len(x.src),\ndevice=device)\n#DatasetSneekpeekbeforetokenizing\nfordataintrain_data:\nmax_len_ger.append(len(data.src))\nmax_len_eng.append(len(data.trg))\nifcount<10:\nprint("German-",*data.src,"Length-",len(data.src))\nprint("English-",*data.trg,"Length-",len(data.trg))\nprint()\ncount+=1\n\nprint("MaximumLengthofEnglishSentence{}andGermanSentence{}inthedataset".format(max(max_len_eng),max(max_len_ger)))\nprint("MinimumLengthofEnglishSentence{}andGermanSentence{}inthedataset".format(min(max_len_eng),min(max_len_ger)))\n\n**************************************************************OUTPUT**************************************************************\n\nGerman-zweijungewei?em?nnersindimfreienindern?hevielerbüsche.Length-13\nEnglish-twoyoung,whitemalesareoutsidenearmanybushes.Length-11\n\nGerman-einmanningrünh?lteinegitarre,w?hrendderanderemannseinhemdansieht.Length-16\nEnglish-amaningreenholdsaguitarwhiletheothermanobserveshisshirt.Length-15\n\nGerman-einmannl?chelteinenausgestopftenl?wenan.Length-8\nEnglish-amanissmilingatastuffedlionLength-8\n\nGerman-einschickesm?dchensprichtmitdemhandyw?hrendsielangsamdiestra?eentlangschwebt.Length-14\nEnglish-atrendygirltalkingonhercellphonewhileglidingslowlydownthestreet.Length-14\n\nGerman-einefraumiteinergro?engeldb?rsegehtaneinemtorvorbei.Length-12\nEnglish-awomanwithalargepurseiswalkingbyagate.Length-12\n\nGerman-jungentanzenmittenindernachtaufpfosten.Length-9\nEnglish-boysdancingonpolesinthemiddleofthenight.Length-11\n\nMaximumLengthofEnglishSentence41andGermanSentence44inthedataset\nMinimumLengthofEnglishSentence4andGermanSentence1inthedataset

我刚刚试验了一批大小为32和样本批如下所示。这些句子被标记成一个单词列表，并根据词汇索引。"pad"标记的索引值为1。

每一列对应一个句子，用数字索引，在单个目标批处理中有32个这样的句子，行数对应于句子的最大长度。短句用1来填充以弥补其长度。

下表包含批处理的数字索引，这些索引稍后被输入到嵌入的单词中，并转换为密集表示，以便进行Seq2Seq处理。

下表包含与批处理的数字索引映射的对应单词。

上面的图片显示了在单个LSTM单元下的计算。在最后一篇文章中，我将添加一些参考资料来学习更多关于LSTM的知识，以及为什么它适用于长序列。

但简单地说,传统RNN和门控(GRU)是无法捕捉的长期依赖性因其自然消失的梯度设计和遭受严重的问题,这使得权重和偏置值的变化率可以忽略不计,导致器泛化性的降低。

但是LSTM有一些特殊的单元称为门(记忆门，忘记门，更新门)，这有助于克服前面提到的问题。

在LSTM细胞内，我们有一堆小型神经网络，在最后一层有sigmoid和TanH激活和少量矢量加法，连接，乘法操作。

SigmoidNN→压缩0到1之间的值。说接近0的值表示忘记，而接近1的值表示记住。

EmbeddingNN→将输入的单词索引转换为单词嵌入。

TanHNN→压缩-1和1之间的值。有助于调节矢量值，使其免于爆炸至最大值或缩小至最小值。

隐藏状态和单元状态在此称为上下文向量，它们是LSTM单元的输出。输入则是输入到嵌入NN中的句子的数字索引。

在开始构建seq2seq模型之前，我们需要创建一个Encoder，Decoder，并在seq2seq模型中创建它们之间的接口。

让我们通过德语输入序列"IchLiebeTiefLernen"，该序列翻译成英语"Ilovedeeplearning"。

LSTM编码器体系结构。X轴对应于时间步长，Y轴对应于批量大小

为了便于说明，让我们解释上图中的过程。Seq2Seq模型的编码器一次只接受一个输入。我们输入的德语单词序列为"ichLiebeTiefLernen"。

另外，我们在输入句子的开头和结尾处附加序列"SOS"的开头和句子"EOS"标记的结尾。

·在时间步0，发送"SOS"

·在时间步1，发送"ich"

·在时间步2，发送"Liebe"

·在时间步3，发送"Tief"

·在时间步4，发送"Lernen"

·在时间步5，发送"EOS"

编码器体系结构中的第一个块是单词嵌入层（以绿色块显示），该层将输入的索引词转换为被称为词嵌入的密集向量表示（大小为100/200/300）。

然后我们的词嵌入向量被发送到LSTM单元，在这里它与隐藏状态（hs）组合，并且前一个时间步的单元状态（cs）组合，编码器块输出新的hs和cs到下一个LSTM单元。可以理解，到目前为止，hs和cs捕获了该句子的某些矢量表示。

在时间步0，隐藏状态和单元状态被完全初始化为零或随机数。

然后，在我们发送完所有输入的德语单词序列之后，最终获得上下文向量[以黄色块显示]（hs，cs），该上下文向量是单词序列的密集表示形式，可以发送到解码器的第一个LSTM（hs，cs）进行相应的英语翻译。

在上图中，我们使用2层LSTM体系结构，其中将第一个LSTM连接到第二个LSTM，然后获得2个上下文向量，这些向量堆叠在顶部作为最终输出。

我们必须在seq2seq模型中设计相同的编码器和解码器模块。

以上可视化适用于批处理中的单个句子。

假设我们的批处理大小为5，然后一次将5个句子（每个句子带有一个单词）传递给编码器，如下图所示。

LSTM编码器的批处理大小为5。X轴对应于时间步长，Y轴对应于批处理大小。

classEncoderLSTM(nn.Module):\ndef__init__(self,input_size,embedding_size,hidden_size,num_layers,p):\nsuper(EncoderLSTM,self).__init__()\n\n#Sizeoftheonehotvectorsthatwillbetheinputtotheencoder\nself.input_size=input_size\n\n#OutputsizeofthewordembeddingNN\nself.embedding_size=embedding_size\n\n#DimensionoftheNN'sinsidethelstmcell/(hs,cs)'sdimension.\nself.hidden_size=hidden_size\n\n#Numberoflayersinthelstm\nself.num_layers=num_layers\n\n#Regularizationparameter\nself.dropout=nn.Dropout(p)\nself.tag=True\n\n#Shape-------------------->(5376,300)[inputsize,embeddingdims]\nself.embedding=nn.Embedding(self.input_size,self.embedding_size)\n\n#Shape----------->(300,2,1024)[embeddingdims,hiddensize,numlayers]\nself.LSTM=nn.LSTM(self.embedding_size,hidden_size,num_layers,dropout=p)\n\n#Shapeofx(26,32)[Sequence_length,batch_size]\ndefforward(self,x):\n\n#Shape----------->(26,32,300)[Sequence_length,batch_size,embeddingdims]\nembedding=self.dropout(self.embedding(x))\n\n#Shape-->outputs(26,32,1024)[Sequence_length,batch_size,hidden_size]\n#Shape-->(hs,cs)(2,32,1024),(2,32,1024)[num_layers,batch_sizesize,hidden_size]\noutputs,(hidden_state,cell_state)=self.LSTM(embedding)\n\nreturnhidden_state,cell_state\n\ninput_size_encoder=len(german.vocab)\nencoder_embedding_size=300\nhidden_size=1024\nnum_layers=2\nencoder_dropout=float(0.5)\n\nencoder_lstm=EncoderLSTM(input_size_encoder,encoder_embedding_size,\nhidden_size,num_layers,encoder_dropout).to(device)\nprint(encoder_lstm)\n\n\n************************************************OUTPUT************************************************\n\n\nEncoderLSTM(\n(dropout):Dropout(p=0.5,inplace=False)\n(embedding):Embedding(5376,300)\n(LSTM):LSTM(300,1024,num_layers=2,dropout=0.5)\n)6.解码器模型架构（Seq2Seq）

解码器一次也执行单个步骤。

提供来自编码器块的上下文向量，作为解码器的第一个LSTM块的隐藏状态（hs）和单元状态（cs）。

句子"SOS"令牌的开头被传递到嵌入的NN，然后传递到解码器的第一个LSTM单元，最后，它经过一个线性层[以粉红色显示]，该层提供输出的英语令牌预测概率（4556个概率）[4556—如英语的总词汇量一样]，隐藏状态（hs），单元状态（cs）。

选择4556个值中概率最高的输出单词，将隐藏状态（hs）和单元状态（cs）作为输入传递到下一个LSTM单元，并执行此过程，直到到达句子"EOS"的结尾"。

后续层将使用先前时间步骤中的隐藏状态和单元状态。

除其他块外，您还将在Seq2Seq架构的解码器中看到以下所示的块。

在进行模型训练时，我们发送输入（德语序列）和目标（英语序列）。从编码器获得上下文向量后，我们将它们和目标发送给解码器进行翻译。

但是在模型推断期间，目标是根据训练数据的一般性从解码器生成的。因此，将输出的预测单词作为下一个输入单词发送到解码器，直到获得令牌。

因此，在模型训练本身中，我们可以使用teachforceratio（暂译教力比）控制输入字到解码器的流向。

我们可以在训练时将实际的目标词发送到解码器部分（以绿色显示）。

我们还可以发送预测的目标词，作为解码器的输入（以红色显示）。

发送单词（实际目标单词或预测目标单词）的可能性可以控制为50％，因此在任何时间步长，在训练过程中都会通过其中一个。

此方法的作用类似于正则化。因此，在此过程中，模型可以快速有效地进行训练。

以上可视化适用于批处理中的单个句子。假设我们的批处理大小为4，然后一次将4个句子传递给编码器，该编码器提供4组上下文向量，它们都被传递到解码器中，如下图所示。

classDecoderLSTM(nn.Module):\ndef__init__(self,input_size,embedding_size,hidden_size,num_layers,p,output_size):\nsuper(DecoderLSTM,self).__init__()\n\n#Sizeoftheonehotvectorsthatwillbetheinputtotheencoder\nself.input_size=input_size\n\n#OutputsizeofthewordembeddingNN\nself.embedding_size=embedding_size\n\n#DimensionoftheNN'sinsidethelstmcell/(hs,cs)'sdimension.\nself.hidden_size=hidden_size\n\n#Numberoflayersinthelstm\nself.num_layers=num_layers\n\n#Sizeoftheonehotvectorsthatwillbetheoutputtotheencoder(EnglishVocabSize)\nself.output_size=output_size\n\n#Regularizationparameter\nself.dropout=nn.Dropout(p)\nself.tag=True\n\n#Shape-------------------->(5376,300)[inputsize,embeddingdims]\nself.embedding=nn.Embedding(self.input_size,self.embedding_size)\n\n#Shape----------->(300,2,1024)[embeddingdims,hiddensize,numlayers]\nself.LSTM=nn.LSTM(self.embedding_size,hidden_size,num_layers,dropout=p)\n\n#Shape----------->(1024,4556)[embeddingdims,hiddensize,numlayers]\nself.fc=nn.Linear(self.hidden_size,self.output_size)\n\n#Shapeofx(32)[batch_size]\ndefforward(self,x,hidden_state,cell_state):\n\n#Shapeofx(1,32)[1,batch_size]\nx=x.unsqueeze(0)\n\n#Shape----------->(1,32,300)[1,batch_size,embeddingdims]\nembedding=self.dropout(self.embedding(x))\n\n#Shape-->outputs(1,32,1024)[1,batch_size,hidden_size]\n#Shape-->(hs,cs)(2,32,1024),(2,32,1024)[num_layers,batch_sizesize,hidden_size](passingencoder'shs,cs-contextvectors)\noutputs,(hidden_state,cell_state)=self.LSTM(embedding,(hidden_state,cell_state))\n\n#Shape-->predictions(1,32,4556)[1,batch_size,output_size]\npredictions=self.fc(outputs)\n\n#Shape-->predictions(32,4556)[batch_size,output_size]\npredictions=predictions.squeeze(0)\n\nreturnpredictions,hidden_state,cell_state\n\ninput_size_decoder=len(english.vocab)\ndecoder_embedding_size=300\nhidden_size=1024\nnum_layers=2\ndecoder_dropout=float(0.5)\noutput_size=len(english.vocab)\n\ndecoder_lstm=DecoderLSTM(input_size_decoder,decoder_embedding_size,\nhidden_size,num_layers,decoder_dropout,output_size).to(device)\nprint(decoder_lstm)\n\n************************************************OUTPUT************************************************\n\nDecoderLSTM(\n(dropout):Dropout(p=0.5,inplace=False)\n(embedding):Embedding(4556,300)\n(LSTM):LSTM(300,1024,num_layers=2,dropout=0.5)\n(fc):Linear(in_features=1024,out_features=4556,bias=True)\n)8.Seq2Seq（编码器+解码器）接口

单个输入语句的最终seq2seq实现如下图所示。

·提供输入（德语）和输出（英语）句子

·将输入序列传递给编码器并提取上下文向量

·将输出序列传递给解码器，以及来自编码器的上下文向量，以生成预测的输出序列

以上可视化适用于批处理中的单个句子。假设我们的批处理大小为4，然后一次将4个句子传递给编码器，该编码器提供4组上下文向量，它们都被传递到解码器中，如下图所示。

classSeq2Seq(nn.Module):\ndef__init__(self,Encoder_LSTM,Decoder_LSTM):\nsuper(Seq2Seq,self).__init__()\nself.Encoder_LSTM=Encoder_LSTM\nself.Decoder_LSTM=Decoder_LSTM\n\ndefforward(self,source,target,tfr=0.5):\n#Shape-Source:(10,32)[(SentencelengthGerman+somepadding),NumberofSentences]\nbatch_size=source.shape[1]\n\n#Shape-Source:(14,32)[(SentencelengthEnglish+somepadding),NumberofSentences]\ntarget_len=target.shape[0]\ntarget_vocab_size=len(english.vocab)\n\n#Shape-->outputs(14,32,5766)\noutputs=torch.zeros(target_len,batch_size,target_vocab_size).to(device)\n\n#Shape-->(hs,cs)(2,32,1024),(2,32,1024)[num_layers,batch_sizesize,hidden_size](containsencoder'shs,cs-contextvectors)\nhidden_state_encoder,cell_state_encoder=self.Encoder_LSTM(source)\n\n#Shapeofx(32elements)\nx=target[0]#Triggertoken<SOS>\n\nforiinrange(1,target_len):\n#Shape-->output(32,5766)\noutput,hidden_state_decoder,cell_state_decoder=self.Decoder_LSTM(x,hidden_state_encoder,cell_state_encoder)\noutputs[i]=output\nbest_guess=output.argmax(1)#0thdimensionisbatchsize,1stdimensioniswordembedding\nx=target[i]ifrandom.random()<tfrelsebest_guess#Eitherpassthenextwordcorrectlyfromthedatasetorusetheearlierpredictedword\n\n#Shape-->outputs(14,32,5766)\nreturnoutputs\n\nprint(model)\n\n************************************************OUTPUT************************************************\n\nSeq2Seq(\n(Encoder_LSTM):EncoderLSTM(\n(dropout):Dropout(p=0.5,inplace=False)\n(embedding):Embedding(5376,300)\n(LSTM):LSTM(300,1024,num_layers=2,dropout=0.5)\n)\n(Decoder_LSTM):DecoderLSTM(\n(dropout):Dropout(p=0.5,inplace=False)\n(embedding):Embedding(4556,300)\n(LSTM):LSTM(300,1024,num_layers=2,dropout=0.5)\n(fc):Linear(in_features=1024,out_features=4556,bias=True)\n)\n)10.Seq2Seq模型训练

epoch_loss=0.0\nnum_epochs=100\nbest_loss=999999\nbest_epoch=-1\nsentence1="einmannineinemblauenhemdstehtaufeinerleiterundputzteinfenster"\nts1=[]\n\nforepochinrange(num_epochs):\nprint("Epoch-{}/{}".format(epoch+1,num_epochs))\nmodel.eval()\ntranslated_sentence1=translate_sentence(model,sentence1,german,english,device,max_length=50)\nprint(f"Translatedexamplesentence1:\\n{translated_sentence1}")\nts1.append(translated_sentence1)\n\nmodel.train(True)\nforbatch_idx,batchinenumerate(train_iterator):\ninput=batch.src.to(device)\ntarget=batch.trg.to(device)\n\n#Passtheinputandtargetformodel'sforwardmethod\noutput=model(input,target)\noutput=output[1:].reshape(-1,output.shape[2])\ntarget=target[1:].reshape(-1)\n\n#Cleartheaccumulatinggradients\noptimizer.zero_grad()\n\n#Calculatethelossvalueforeveryepoch\nloss=criterion(output,target)\n\n#Calculatethegradientsforweights&biasesusingback-propagation\nloss.backward()\n\n#Clipthegradientvalueisitexceeds>1\ntorch.nn.utils.clip_grad_norm_(model.parameters(),max_norm=1)\n\n#Updatetheweightsvaluesusingthegradientswecalculatedusingbp\noptimizer.step()\nstep+=1\nepoch_loss+=loss.item()\nwriter.add_scalar("Trainingloss",loss,global_step=step)\n\nifepoch_loss<best_loss:\nbest_loss=epoch_loss\nbest_epoch=epoch\ncheckpoint_and_save(model,best_loss,epoch,optimizer,epoch_loss)\nif((epoch-best_epoch)>=10):\nprint("noimprovementin10epochs,break")\nbreak\nprint("Epoch_Loss-{}".format(loss.item()))\nprint()\n\nprint(epoch_loss/len(train_iterator))\n\nscore=bleu(test_data[1:100],model,german,english,device)\nprint(f"Bleuscore{score*100:.2f}")\n\n************************************************OUTPUT************************************************\n\nBleuscore15.62

例句训练进度：

现在，让我们将我们训练有素的模型与SOTAGoogleTranslate的模型进行比较。

model.eval()\ntest_sentences=["ZweiM?nnergehendieStra?eentlang","KinderspielenimPark.",\n"DieseStadtverdienteinebessereKlassevonVerbrechern.DerSpa?vogel"]\n\nactual_sentences=["Twomenarewalkingdownthestreet","Childrenplayinthepark",\n"Thiscitydeservesabetterclassofcriminals.Thejoker"]\npred_sentences=[]\n\nforidx,iinenumerate(test_sentences):\nmodel.eval()\ntranslated_sentence=translate_sentence(model,i,german,english,device,max_length=50)\nprogress.append(TreebankWordDetokenizer().detokenize(translated_sentence))\nprint("German:{}".format(i))\nprint("ActualSentenceinEnglish:{}".format(actual_sentences[idx]))\nprint("PredictedSentenceinEnglish:{}".format(progress[-1]))\nprint()\n\n*******************************************OUTPUT*******************************************\n\nGerman:"ZweiM?nnergehendieStra?eentlang"\nActualSentenceinEnglish:"Twomenarewalkingdownthestreet"\nPredictedSentenceinEnglish:"twomenarewalkingonthestreet.<eos>"\n\nGerman:"KinderspielenimPark."\nActualSentenceinEnglish:"Childrenplayinthepark"\nPredictedSentenceinEnglish:"childrenplayinginthepark.<eos>"\n\nGerman:"DieseStadtverdienteinebessereKlassevonVerbrechern.DerSpa?vogel"\nActualSentenceinEnglish:"Thiscitydeservesabetterclassofcriminals.Thejoker"\nPredictedSentenceinEnglish:"this<unk>'s<unk>froma<unk>greenteam<unk>bythesidelines.<eos>"

不错，但是很明显，该模型不能理解复杂的句子。因此，在接下来的系列文章中，我将通过更改模型的体系结构来提高上述模型的性能，例如使用双向LSTM，添加注意力机制或将LSTM替换为Transformers模型来克服这些明显的缺点。

希望我能够对Seq2Seq模型如何处理数据有一些直观的了解，在评论部分告诉我您的想法。

本文代码：github/bala-codes/Natural-Language-Processing-NLP/blob/master/Neural%20Machine%20Translation/1.%20Seq2Seq%20%5BEnc%20%2B%20Dec%5D%20Model%20for%20Neural%20Machine%20Translation%20%28Without%20Attention%20Mechanism%29.ipynb

hubsche德语的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于在PyTorch中使用Seq2Seq构建的神经机器翻译模型、hubsche德语的信息别忘了在本站进行查找哦。