标签: attention-model

我目前正在研究transformer的代码，但我无法理解解码器的屏蔽多头。论文上说是为了不让你看到生成词，但是我无法理解生成词后的词如果没有生成，怎么能看到呢？

我尝试阅读变压器的代码（链接：https : //github.com/Kyubyong/transformer）。代码实现掩码如下所示。它使用下三角矩阵来屏蔽，我不明白为什么。

padding_num = -2 ** 32 + 1
diag_vals = tf.ones_like(inputs[0, :, :])  # (T_q, T_k)
tril = tf.linalg.LinearOperatorLowerTriangular(diag_vals).to_dense()  # (T_q, T_k)
masks = tf.tile(tf.expand_dims(tril, 0), [tf.shape(inputs)[0], 1, 1])  # (N, T_q, T_k)
paddings = tf.ones_like(masks) * padding_num
outputs = tf.where(tf.equal(masks, 0), paddings, inputs)

我正在按照本教程:http://nlp.seas.harvard.edu/2018/04/03/attention.html 从"注意力都是你需要的"论文中实现Transformer模型.

但是我收到以下错误:RuntimeError:"for"未实现'torch.LongTensor'

这是PositionalEnconding类中导致错误的行:

div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))

在这里建造时:

pe = PositionalEncoding(20, 0)

有任何想法吗？？我已经尝试将其转换为Tensor Float类型,但这没有用.

我甚至用随附的文件下载了整个笔记本,错误似乎在原始教程中持续存在.

可能导致此错误的任何想法？

谢谢!

在自动编码器的上下文中，我正在努力解决注意力的概念。我相信我理解注意力在 seq2seq 翻译方面的用法——在训练组合编码器和解码器后，我们可以同时使用编码器和解码器来创建（例如）语言翻译器。因为我们仍在生产中使用解码器，所以我们可以利用注意力机制。

但是，如果自编码器的主要目标主要是生成输入向量的潜在压缩表示呢？我说的是在训练后我们基本上可以处理模型的解码器部分的情况。

例如，如果我在没有注意的情况下使用 LSTM，“经典”方法是使用最后一个隐藏状态作为上下文向量——它应该代表我输入序列的主要特征。如果我要注意使用 LSTM，我的潜在表示必须是每个时间步长的所有隐藏状态。这似乎不符合输入压缩和保留主要功能的概念。维度甚至可能更高。

此外，如果我需要使用所有隐藏状态作为我的潜在表示（就像在注意力情况下一样） - 为什么要使用注意力？我可以使用所有隐藏状态来初始化解码器。

我正在学习变形金刚。这是MultiheadAttention的 pytorch 文档。在他们的实现中，我发现有一个限制：

 assert self.head_dim * num_heads == self.embed_dim, "embed_dim must be divisible by num_heads"\n

为什么需要约束：embed_dim must be divisible by num_heads? 如果我们回到方程

假设：\n Q, K,V是n x emded_dim矩阵；所有权重矩阵W是emded_dim x head_dim

那么，concat[head_i, ..., head_h]将是一个n x (num_heads*head_dim)矩阵；

W^O有尺寸(num_heads*head_dim) x embed_dim

[head_i, ..., head_h] * W^O将成为n x embed_dim输出

我不知道为什么我们需要embed_dim must be divisible …

我正在尝试理解注意力模型并自己构建一个。经过多次搜索，我发现了这个网站，它有一个用 keras 编码的注意力模型，而且看起来也很简单。但是当我试图在我的机器上构建相同的模型时，它给出了多个参数错误。错误是由于传入 class 的参数不匹配Attention。在网站的注意力类中，它要求一个参数，但它用两个参数启动注意力对象。

import tensorflow as tf

max_len = 200
rnn_cell_size = 128
vocab_size=250

class Attention(tf.keras.Model):
    def __init__(self, units):
        super(Attention, self).__init__()
        self.W1 = tf.keras.layers.Dense(units)
        self.W2 = tf.keras.layers.Dense(units)
        self.V = tf.keras.layers.Dense(1)
    def call(self, features, hidden):
        hidden_with_time_axis = tf.expand_dims(hidden, 1)
        score = tf.nn.tanh(self.W1(features) + self.W2(hidden_with_time_axis))
        attention_weights = tf.nn.softmax(self.V(score), axis=1)
        context_vector = attention_weights * features
        context_vector = tf.reduce_sum(context_vector, axis=1)
        return context_vector, attention_weights

sequence_input = tf.keras.layers.Input(shape=(max_len,), dtype='int32')

embedded_sequences = tf.keras.layers.Embedding(vocab_size, 128, input_length=max_len)(sequence_input)

lstm = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM
                                     (rnn_cell_size,
                                      dropout=0.3,
                                      return_sequences=True, …

我有一个由一个 LSTM 和两个 Dense 层组成的简单网络，如下所示：

model = tf.keras.Sequential()
model.add(layers.LSTM(20, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(layers.Dense(20, activation='sigmoid'))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(loss='mean_squared_error')

为了分类，它对具有 3 个输入（归一化 0 到 1.0）和 1 个输出（二进制）的数据进行训练。数据是时间序列数据，其中时间步长之间存在关系。

    var1(t)   var2(t)   var3(t)  var4(t)
0  0.448850  0.503847  0.498571      0.0
1  0.450992  0.503480  0.501215      0.0
2  0.451011  0.506655  0.503049      0.0

模型训练如下：

history = model.fit(train_X, train_y, epochs=2800, batch_size=40, validation_data=(test_X, test_y), verbose=2, shuffle=False)
model.summary()

给出模型总结：

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
lstm (LSTM)                  (None, 20)                1920      
_________________________________________________________________
dense (Dense)                (None, 20)                420       
_________________________________________________________________
dense_1 (Dense) …

有没有办法在TensorFlow的seq2seq模型中可视化某些输入上的注意权重,如上面链接中的图(来自Bahdanau等,2014)？我已经找到了TensorFlow的github问题,但我无法找到如何在会话期间获取注意掩码.

我一直关注这篇文章,以便在我的LSTM模型上实现关注层.

代码attention layer:

INPUT_DIM = 2
TIME_STEPS = 20
SINGLE_ATTENTION_VECTOR = False
APPLY_ATTENTION_BEFORE_LSTM = False

def attention_3d_block(inputs):
    input_dim = int(inputs.shape[2])
    a = Permute((2, 1))(inputs)
    a = Reshape((input_dim, TIME_STEPS))(a)
    a = Dense(TIME_STEPS, activation='softmax')(a)
    if SINGLE_ATTENTION_VECTOR:
        a = Lambda(lambda x: K.mean(x, axis=1), name='dim_reduction')(a)
        a = RepeatVector(input_dim)(a)
    a_probs = Permute((2, 1), name='attention_vec')(a)
    output_attention_mul = merge(
        [inputs, a_probs],
        name='attention_mul',
        mode='mul'
    )
    return output_attention_mul

我得到的错误:

文件"main_copy.py",第244行,在model = create_model(X_vocab_len,X_max_len,y_vocab_len,y_max_len,HIDDEN_DIM,LAYER_NUM)文件"main_copy.py",第189行,在create_model中attention_mul = attention_3d_block(temp)文件"main_copy.py" ",第124行,注意事项_3d_block a = Permute((2,1))(输入)文件"/root/.virtualenvs/keras_tf/lib/python3.5/site-packages/keras/engine/topology.py",行597,在调用 output_mask = self.compute_mask(inputs,previous_mask)文件"/root/.virtualenvs/keras_tf/lib/python3.5/site-packages/keras/engine/topology.py",第744行,在compute_mask str中( …

我正在努力掩盖 MultiHeadAttention 层的输入。我正在使用 Keras 文档中的 Transformer Block 进行自我关注。到目前为止，我在网上找不到任何示例代码，如果有人能给我一个代码片段，我将不胜感激。

本页的变压器块：

class TransformerBlock(layers.Layer):
    def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1):
        super(TransformerBlock, self).__init__()
        self.att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)
        self.ffn = keras.Sequential(
            [layers.Dense(ff_dim, activation="relu"), layers.Dense(embed_dim),]
        )
        self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)
        self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = layers.Dropout(rate)
        self.dropout2 = layers.Dropout(rate)

    def call(self, inputs, training):
        attn_output = self.att(inputs, inputs)
        attn_output = self.dropout1(attn_output, training=training)
        out1 = self.layernorm1(inputs + attn_output)
        ffn_output = self.ffn(out1)
        ffn_output = self.dropout2(ffn_output, training=training)
        return self.layernorm2(out1 + ffn_output)

屏蔽的文档可以在此链接下找到：

focus_mask：形状为 [B, T, S] 的布尔掩码，可防止对某些位置的关注。布尔掩码指定哪些查询元素可以关注哪些关键元素，1表示关注，0表示不关注。对于缺少的批次尺寸和头部尺寸，可能会发生广播。

我唯一可以运行的是在图层类外部创建的掩码作为 …

我有n需要相互影响的向量和n具有相同维度的输出向量d。我相信这就是它的torch.nn.MultiheadAttention作用。但前向函数需要查询、键和值作为输入。根据这篇博客，我需要(d x d)为每个初始化一个形状的随机权重矩阵q，k并将v每个向量与这些权重矩阵相乘，得到 3 个(n x d)矩阵。现在q,k和是这三个矩阵v所期望的torch.nn.MultiheadAttention，还是我弄错了？