标签: seq2seq

我正在尝试学习 seq2seq 模型。嵌入层位于编码器中，有时在一些迭代后输出 nan 值。我无法确定原因。我该如何解决这个问题？问题出在下面代码中的forward函数中的第一个emb_layer。

class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, hidden_size=1024, num_layers=6, dropout=0.2, input_pad=1, batch_first=False, embedder=None, init_weight=0.1):
        super(TransformerEncoder, self).__init__()
        self.input_pad = input_pad
        self.vocab_size = vocab_size
        self.num_layers = num_layers
        self.embedder = embedder

        if embedder is not None:
            self.emb_layer = embedder
        else:
            self.emb_layer = nn.Embedding(vocab_size, hidden_size, padding_idx=1)

        self.positional_encoder = PositionalEncoder()
        self.transformer_layers = nn.ModuleList()
        for _ in range(num_layers):
            self.transformer_layers.append(
                    TransformerEncoderBlock(num_heads=8, embedding_dim=1024, dropout=dropout))

    def set_mask(self, inputs):
        self.input_mask = (inputs == self.input_pad).unsqueeze(1)

    def forward(self, inputs):
        x = self.emb_layer(inputs)
        x = self.positional_encoder(x)

我试图了解如何使用tf.keras.layers.Attention此处显示的内容：

张量流注意力层

我正在尝试将它与编码器解码器 seq2seq 模型一起使用。下面是我的代码：

encoder_inputs = Input(shape=(max_len_text,)) 
enc_emb = Embedding(x_voc_size, latent_dim,trainable=True)(encoder_inputs) 
encoder_lstm=LSTM(latent_dim, return_state=True, return_sequences=True) 
encoder_outputs, state_h, state_c= encoder_lstm(enc_emb) 

decoder_inputs = Input(shape=(max_len_summary,)) 
dec_emb_layer = Embedding(y_voc_size, latent_dim,trainable=True) 
dec_emb = dec_emb_layer(decoder_inputs) 

decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True) 
decoder_outputs,decoder_fwd_state, decoder_back_state = decoder_lstm(dec_emb,initial_state=[state_h, state_c]) 

我的问题是，如何在这个模型中使用 keras 中给定的注意力层？我无法理解他们的文件。

所以我正在尝试制作一个 seq to seq 模型，用于在 Kaggle Notebook 和 google colab 等在线笔记本上使用 pytorch 将德语翻译成英语

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIterator
import numpy as np
import spacy
import random
from torch.utils.tensorboard import SummaryWriter  # to print to tensorboard

导入的库，当我使用 spacy 函数加载数据集时，如下所示，

spacy_ger = spacy.load("de")
spacy_eng = spacy.load("en")

这个错误就来了。: OSError: [E050] 找不到型号“de”。它似乎不是快捷方式链接、Python 包或数据目录的有效路径。

到处都有对“en”的解释，但没有对“de”的解释。如果有人可以帮忙解决这个问题。

规格：

封装：版本

• 斯帕西：2.3.1

• pytorch-crf：0.7.0

• 火炬：1.5.1

• 火炬nlp：0.0.0.1

• 火炬文本：0.4.0

• 火炬视觉：0.6.1

• jupyter-张量板：0.2.0

• 张量板：2.2.2

• 张量板插件机智：1.7.0

预先感谢您的帮助。

当我在这里阅读 seq2seq 教程时，我无法理解 function 的输出tf.contrib.seq2seq.dynamic_docode。

本教程访问用于训练sample_id = outputs.sample_id和logits = self.output_layer(outputs.rnn_output)推理时使用的解码器的输出，logits = outputs.rnn_output以及sample_id = outputs.sample_id。什么是logits和sample_id这里代表什么？final_outputs函数的内容是什么tf.contrib.seq2seq.dynamic_docode？

我正在尝试使用 Keras 实现一个 seq2seq 编码器-解码器，在编码器上使用双向 lstm，如下所示：

from keras.layers import LSTM,Bidirectional,Input,Concatenate
from keras.models import Model

n_units = 8
n_input = 1
n_output = 1

# encoder
encoder_inputs = Input(shape=(None, n_input))
encoder = Bidirectional(LSTM(n_units, return_state=True))
encoder_outputs, forward_h, forward_c, backward_h, backward_c = encoder(encoder_inputs)
state_h = Concatenate()([forward_h, backward_h])
state_c = Concatenate()([forward_c, backward_c])
encoder_states = [state_h, state_c]

# decoder
decoder_inputs = Input(shape=(None, n_output))    
decoder_lstm = LSTM(n_units*2, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=encoder_states)

这是我在最后一行遇到的以下错误：

ValueError: Dimensions must be equal, but are 8 and 16 …

鉴于下面的代码

encoder_inputs = Input(shape=(16, 70))
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]

# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(59, 93))
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
decoder_lstm = …

我目前正在尝试扩展基于 FairSeq/PyTorch的模型。在训练期间，我需要训练两个编码器：一个使用目标样本，另一个使用源样本。

所以当前的 forward 函数是这样的：

def forward(self, src_tokens=None, src_lengths=None, prev_output_tokens=None, **kwargs):
    encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs)
    decoder_out = self.decoder(prev_output_tokens, encoder_out=encoder_out, **kwargs)
    return decoder_out

基于这个想法，我想要这样的东西：

def forward_test(self, src_tokens=None, src_lengths=None, prev_output_tokens=None, **kwargs):
    encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs)
    decoder_out = self.decoder(prev_output_tokens, encoder_out=encoder_out, **kwargs)
    return decoder_out

def forward_train(self, src_tokens=None, src_lengths=None, prev_output_tokens=None, **kwargs):
    encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs)
    autoencoder_out = self.encoder(tgt_tokens, src_lengths=src_lengths, **kwargs)
    concat = some_concatination_func(encoder_out, autoencoder_out)
    decoder_out = self.decoder(prev_output_tokens, encoder_out=concat, **kwargs)
    return decoder_out

有没有办法做到这一点？

编辑：这些是我的约束，因为我需要扩展FairseqEncoderDecoderModel：

@register_model('transformer_mass')
class TransformerMASSModel(FairseqEncoderDecoderModel): …

我理解应用于图像时的卷积滤波器（例如，具有 3 个输入通道的 224x224 图像由 56 个 5x5 转换的总共 56 个滤波器转换为具有 56 个输出通道的 224x224 图像）。关键是有 56 个不同的滤波器，每个滤波器的权重为 5x5x3，最终生成输出图像 224x224, 56（逗号后面的术语是输出通道）。

但我似乎无法理解conv1d过滤器在字符序列的 seq2seq 模型中如何工作。我正在查看的模型之一https://arxiv.org/pdf/1712.05884.pdf有一个“ post-net 层由 512 个形状为 5\xc3\x971 的滤波器组成”，在频谱图帧 80-d 上运行（意味着帧中有80个不同的浮点值），过滤的结果是512维的帧。

\n

• 我不明白in_channels, out_channelspytorch conv1d 定义中的含义，就像在图像中一样，我可以轻松理解通道内/通道外的含义，但对于 80 个浮点值帧的序列，我不知所措。在上面这样的 seq2seq 模型的上下文中它们意味着什么？

\n

• 对 80 个浮点值进行 512、5x1 过滤器如何生成 512 个浮点值？**

\n

• 当对 80 个浮点值进行操作时，5x1 过滤器是否只会产生 80 个浮点值（通过在这 80 个值中一次取 5 个连续值）？这 512 个过滤器总共有多少权重？**

\n

在 pytorch 中打印时的图层显示为：

(conv): Conv1d(80, 512, kernel_size=(5,), …

我正在关注Pytorch seq2seq教程，其使用torch.bmm方法如下：

attn_applied = torch.bmm(attn_weights.unsqueeze(0),
                         encoder_outputs.unsqueeze(0))

我了解为什么我们需要将注意力权重和编码器输出相乘。

我不太明白的是我们bmm在这里需要方法的原因。 torch.bmm文件说

对批处理1和批处理2中存储的矩阵执行批处理矩阵矩阵乘积。

batch1和batch2必须是每个都包含相同数量矩阵的3-D张量。

如果batch1是（b×n×m）张量，batch2是（b×m×p）张量，out将是（b×n×p）张量。

我使用 keras 来训练 seq2seq 模型（keras.models.Model）。模型的 X 和 y 是 [X_encoder, X_decoder] ， y 即编码器和解码器输入和标签的列表（请注意，解码器输入 X_decoder 是 \xe2\x80\x98y\xe2\x80\x99 ，前面有一个位置比实际的 y 基本上是老师强迫的）。

所以我现在的问题是在训练之后，当涉及到实际预测时，我没有任何标签，如何为我的输入提供 \xe2\x80\x98X_decoder\xe2\x80\x99 ？还是我要训练别的东西？

这是模型定义的片段（如果有帮助的话）：）

# Encoder\nencoder_inputs = Input(batch_shape=(batch_size, max_len,), dtype='int32')\nencoder_embedding = embedding_layer(encoder_inputs)\nencoder_LSTM = CuDNNLSTM(hidden_dim, return_state=True, stateful=True)\nencoder_outputs, state_h, state_c = encoder_LSTM(encoder_embedding)\n\n# Decoder\ndecoder_inputs = Input(shape=(max_len,), dtype='int32')\ndecoder_embedding = embedding_layer(decoder_inputs)\ndecoder_LSTM = CuDNNLSTM(hidden_dim, return_state=True, return_sequences=True)\ndecoder_outputs, _, _ = decoder_LSTM(decoder_embedding, initial_state=[state_h, state_c])\n\n# Output\noutputs = TimeDistributed(Dense(vocab_size, activation='softmax'))(decoder_outputs)\nmodel = Model([encoder_inputs, decoder_inputs], outputs)\n\n# model fitting:\nmodel.fit([X_encoder, X_decoder], y, steps_per_epoch=int(number_of_train_samples/batch_size),\nepochs=epochs)\n

我想将解码器的embedding层和预测层的权重联系起来。next_word嵌入维度设置为 300，解码器的隐藏大小设置为 600。NMT 中目标语言的词汇量为 50000，因此嵌入权重维度为 ，50000 x 300预测下一个单词的线性层权重为50000 x 600。

那么，我怎样才能把它们绑起来呢？在这种情况下实现重量绑定的最佳方法是什么？