标签: recurrent-neural-network

我的输入时间序列数据的形状为 (nb_samples, 75, 32)。
75 是时间步长，32 是输入维度。

model = Sequential()
model.add(LSTM(4, input_shape=(75, 32)))
model.summary()

LSTM 权重向量[W_i, W_c, W_f, W_o]都是 32 维，但输出只是一个值。上述模型的输出形状为(1,4)。但在 LSTM 中，输出也是一个向量，所以对于上面的多对一实现来说，它不应该是 (32,4) 吗？为什么它也为多维输入提供单个值？

在 RNN 世界中，填充词向量的哪一端以使它们具有相同的长度重要吗？

例子

pad_left = [0, 0, 0, 0, 5, 4, 3, 2] 
pad_right = [5, 4, 3, 2, 0, 0, 0, 0]

我在尝试使用 LSTM (RNN) 构建多类文本分类网络时遇到此错误。该代码似乎在代码的训练部分运行良好，而在验证部分抛出错误。下面是网络架构和训练代码。感谢这里的任何帮助。

我尝试采用使用 RNN 预测情绪的现有代码，并最终将 sigmoid 替换为 softmax 函数，并将损失函数从 BCE Loss 替换为 NLLLoss()

  def forward(self, x, hidden):
    """
    Perform a forward pass of our model on some input and hidden state.
    """
    batch_size = x.size(0)
    embeds = self.embedding(x)
    lstm_out,hidden= self.lstm(embeds,hidden)

     # stack up lstm outputs
    lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)

    # dropout and fully-connected layer
    out = self.dropout(lstm_out)
    out = self.fc(out)

    # softmax function
    soft_out = self.sof(out)

    # reshape to be batch_size first
    soft_out = soft_out.view(batch_size, -1)
#         soft_out …

我试图了解 RNN Transducer 如何使用地面实况标签进行训练。就 CTC 而言，我知道该模型是使用损失函数进行训练的，该函数总结了地面真实标签所有可能对齐的所有分数。

但在 RNN-T 中，预测网络必须接收最后一步的输入才能产生类似于“教师强制”方法的输出。但我的疑问是，地面实况标签是否应该转换为所有可能的带有空白标签的对齐方式，并通过“教师强制”方法将每个对齐方式馈送到网络？

我遇到过研究出版物和问答讨论检查 RNN 权重的必要性；一些相关的答案是在正确的方向，建议get_weights()- 但我如何真正有意义地可视化权重？也就是说，LSTM 和 GRU 都有门，并且所有RNN 都有用作独立特征提取器的通道- 那么我如何（1）获取每个门的权重，以及（2）以信息丰富的方式绘制它们？

我想在 LSTM 中编码一个时间步。我的重点是理解遗忘门层、输入门层、候选值、现在和未来的 细胞状态的功能。

让我们假设我在 t-1 和 xt 的隐藏状态如下。为简单起见，我们假设权重矩阵是单位矩阵，并且所有偏差都为零。

htminus1 = np.array( [0, 0.5, 0.1, 0.2, 0.6] )
xt = np.array( [-0.1, 0.3, 0.1, -0.25, 0.1] )

我知道忘记状态是 sigmoidhtminus1和xt

那么，是吗？

ft = 1 / ( 1 + np.exp( -( htminus1 + xt ) ) )

>> ft = array([0.47502081, 0.68997448, 0.549834  , 0.4875026 , 0.66818777])

我指的是这个链接来实现一个块 LSTM 的一次迭代。链接说ft应该是 0 或 1。我在这里遗漏了什么吗？

如何根据下面提到的图片中给出的模式获得遗忘门层？一个例子对我来说是说明性的。

同样， …

我目前有一个用于时间序列预测的 RNN 模型。它使用最后 96 个时间步长的 3 个输入特征“值”、“温度”和“一天中的小时”来预测特征“值”的接下来 96 个时间步长。

在这里您可以看到它的架构：

这里有当前的代码：

#Import modules
import pandas as pd
import numpy as np
import tensorflow as tf
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error
from tensorflow import keras

# Define the parameters of the RNN and the training
epochs = 1
batch_size = 50
steps_backwards = 96
steps_forward = 96
split_fraction_trainingData = 0.70
split_fraction_validatinData = 0.90
randomSeedNumber = 50

#Read dataset
df = pd.read_csv('C:/Users/Desktop/TestData.csv', sep=';', header=0, low_memory=False, infer_datetime_format=True, parse_dates={'datetime':[0]}, index_col=['datetime'])

# …

似乎tensorflow不支持双向RNN的可变批量大小.在这个例子中,sequence_length它绑定到batch_size,这是一个Python整数:

  _seq_len = tf.fill([batch_size], tf.constant(n_steps, dtype=tf.int64))
  outputs, state1,state2 = rnn.bidirectional_rnn(rnn_fw_cell, rnn_bw_cell, input,
                                    dtype="float",
                                    sequence_length=_seq_len)

如何使用不同的批量大小进行培训和测试？

我刚开始在tensorflow(r1.0)中使用ctc loss layer并且与"标签"输入有点混淆

在tensorflow的API文档中,它说

labels:一个int32 SparseTensor.labels.indices [i,:] == [b,t]表示labels.values [i]存储(批处理b,时间t)的id.labels.values [i]必须采用[0,num_labels]中的值

1. [b,t]和值[i]是否意味着批次中序列"b"的"t"处有一个标签"values [i]"？
2. 它表示值必须在[0,num_labels]中,但是对于稀疏张量,对于某些指定的位置几乎所有地方都是0,所以我真的不知道ctc的稀疏张量应该怎么样
3. 例如,如果我有一个简短的手势视频,并且它有一个标签"1",我应该将所有时间步的输出标记为"1",或者只将最后一个时间步标签为"1"并取其他为"空白"？

谢谢!

我想创建一个使用注意机制的多层动态RNN解码器.为此,我首先创建一个注意机制:

attention_mechanism = BahdanauAttention(num_units=ATTENTION_UNITS,
                                        memory=encoder_outputs,
                                        normalize=True)

然后我用AttentionWrapper注意机制包装一个LSTM单元格:

attention_wrapper = AttentionWrapper(cell=self._create_lstm_cell(DECODER_SIZE),
                                             attention_mechanism=attention_mechanism,
                                             output_attention=False,
                                             alignment_history=True,
                                             attention_layer_size=ATTENTION_LAYER_SIZE)

其中self._create_lstm_cell定义如下:

@staticmethod
def _create_lstm_cell(cell_size):
    return BasicLSTMCell(cell_size)

然后我做一些簿记(例如创建我的MultiRNNCell,创建初始状态,创建一个TrainingHelper等)

        attention_zero = attention_wrapper.zero_state(batch_size=tf.flags.FLAGS.batch_size, dtype=tf.float32)

        # define initial state
        initial_state = attention_zero.clone(cell_state=encoder_final_states[0])

        training_helper = TrainingHelper(inputs=self.y,  # feed in ground truth
                                         sequence_length=self.y_lengths)  # feed in sequence lengths

        layered_cell = MultiRNNCell(
            [attention_wrapper] + [ResidualWrapper(self._create_lstm_cell(cell_size=DECODER_SIZE))
                                   for _ in range(NUMBER_OF_DECODER_LAYERS - 1)])

        decoder = BasicDecoder(cell=layered_cell,
                               helper=training_helper,
                               initial_state=initial_state)

        decoder_outputs, decoder_final_state, decoder_final_sequence_lengths = dynamic_decode(decoder=decoder,
                                                                                              maximum_iterations=tf.flags.FLAGS.max_number_of_scans // 12,
                                                                                              impute_finished=True) …