标签: recurrent-neural-network

我正在使用 Keras 计算一个简单的序列分类神经网络。我玩了不同的模块，我发现有两种方法可以创建顺序神经网络。

第一种方法是使用 Sequential API。这是我在很多教程/文档中发现的最常见的方式。这是代码：

# Sequential Neural Network using Sequential()
model = Sequential()
model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu', input_shape=(27 , 300,)))
model.add(MaxPooling1D(pool_size=2))
model.add(LSTM(100))
model.add(Dense(len(7, activation='softmax'))
model.summary()

第二种方法是使用模型 API 从“头”开始构建顺序神经网络。这是代码。

# Sequential neural network using Model()   
inputs = Input(shape=(27 , 300))
x = Conv1D(filters=32, kernel_size=3, padding='same', activation='relu')(inputs)
x = MaxPooling1D(pool_size=2)(x)
x = LSTM(100)(x)
predictions = Dense(7, activation='softmax')(x)
model = Model(inputs=inputs, outputs=predictions)
model.summary()

我用固定种子（np.random.seed（1337））训练它，训练数据相同，我的输出不同......知道总结中唯一的区别是模型API的第一层输入.

有没有人知道为什么这个神经网络不同？如果没有，为什么我得到不同的结果？

谢谢

我知道这个帖子是问到类似的问题，这。

但我只是想澄清一下，最好是指向某种说明差异的 Keras 文档的链接。

在我看来，dropout在神经元之间起作用。并recurrent_dropout在时间步长之间运行每个神经元。但是，我对此毫无根据。

Keras 网站上的文档根本没有帮助。

我对pytorch语言建模中的以下代码有疑问：

print("Training and generating...")
    for epoch in range(1, config.num_epochs + 1): 
        total_loss = 0.0
        model.train()  
        hidden = model.init_hidden(config.batch_size)  

        for ibatch, i in enumerate(range(0, train_len - 1, seq_len)):
            data, targets = get_batch(train_data, i, seq_len)          
            hidden = repackage_hidden(hidden)
            model.zero_grad()

            output, hidden = model(data, hidden)
            loss = criterion(output.view(-1, config.vocab_size), targets)
            loss.backward()  

请检查第 5 行。

init_hidden 函数如下：

def init_hidden(self, bsz):
    weight = next(self.parameters()).data
    if self.rnn_type == 'LSTM':  # lstm?(h0, c0)
        return (Variable(weight.new(self.n_layers, bsz, self.hi_dim).zero_()),
                Variable(weight.new(self.n_layers, bsz, self.hi_dim).zero_()))
    else:  # gru & rnn?h0
        return Variable(weight.new(self.n_layers, …

我知道 __call__ 是什么，但让我困惑的是，像 BasicRNNCell 或 tf.nn.rnn_cell.MultiRNNCell 这样的类有这个 \'call\' 方法而不是 _call__ 。这个简单的调用方法是什么？看起来像是同一件事，如果不是，那么我没有看到它被调用。\n我在没有任何线索的情况下找到了这个解释。你能澄清一下吗？

“调用函数是单元逻辑所在的位置。RNNCell\xe2\x80\x99s __call_ 方法将包装您的调用方法并帮助确定范围和其他后勤工作。”\n示例：

def call(self, inputs, state):\n\n    total_hidden_size = sum(c._h_above_size for c in self._cells)\n\n    # split out the part of the input that stores values of ha\n    raw_inp = inputs[:, :-total_hidden_size]                # [B, I]\n    raw_h_aboves = inputs[:, -total_hidden_size:]           # [B, sum(ha_l)]\n\n    ha_splits = [c._h_above_size for c in self._cells]\n    h_aboves = array_ops.split(value=raw_h_aboves,\n                               num_or_size_splits=ha_splits, axis=1)\n\n    z_below = tf.ones([tf.shape(inputs)[0], 1])             # [B, 1]\n    raw_inp = array_ops.concat([raw_inp, z_below], axis=1) # [B, …

我见过在 Keras 中使用 LSTM 构建编码器-解码器网络的示例，但我想要一个 ConvLSTM 编码器-解码器，并且由于 ConvLSTM2D 不接受任何“initial_state”参数，因此我可以将编码器的初始状态传递给解码器，我尝试在 Keras 中使用 RNN 并尝试将 ConvLSTM2D 作为 RNN 的单元传递，但出现以下错误：

ValueError: ('`cell` should have a `call` method. The RNN was passed:', <tf.Tensor 'encoder_1/TensorArrayReadV3:0' shape=(?, 62, 62, 32) dtype=float32>)

这就是我尝试定义 RNN 单元的方式：

first_input = Input(shape=(None, 62, 62, 12))
encoder_convlstm2d = ConvLSTM2D(filters=32, kernel_size=(3, 3),
                                    padding='same',
                                    name='encoder'+ str(1))(first_input )
encoder_outputs, state_h, state_c = keras.layers.RNN(cell=encoder_convlstm2d, return_sequences=False, return_state=True, go_backwards=False,
                 stateful=False, unroll=False)

前提1：

关于 RNN 层中的神经元 - 我的理解是“在每个时间步长，每个神经元都接收输入向量 x (t) 和来自前一个时间步长 y (t –1) 的输出向量” ^[1]：

前提2：

也是我的理解，在Pytorch的GRU层中，input_size和hidden_​​size的含义如下：

• input_size – 输入 x 中预期特征的数量
• hidden_​​size – 隐藏状态中的特征数 h

所以很自然地，hidden_​​size应该代表 GRU 层中的神经元数量。

我的问题：

给定以下 GRU 层：

# assume that hidden_size = 3

class Encoder(nn.Module):
    def __init__(self, src_dictionary_size, hidden_size):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding(src_dictionary_size, hidden_size)
        self.gru = nn.GRU(input_size = hidden_size, hidden_size = hidden_size)

假设 hidden_​​size 为 3，我的理解是上面的 GRU 层将有 3 个神经元，每个神经元在每个时间步同时接受一个大小为 3 的输入向量。

我的问题是：为什么hidden_​​size和input_size …

我有一个来自 4 个温度传感器的数据集，用于测量建筑物内/周围的不同位置：

我正在训练一个模型，该模型采用形状 (96, 4)、4 个传感器的 96 个时间步长的输入。由此我想为每个传感器预测未来 48 个点，形状 (48, 4)。

到目前为止，我有一个实现只能预测一个传感器。我主要遵循TensorFlow 教程中的这一部分。

我的火车 X 的形状为 (6681, 96, 4)，火车 Y 的形状为 (6681, 48)，因为我仅将其限制为一个传感器。如果我只是在训练时将火车 Y 更改为 (6681, 48, 4) 我当然会得到，ValueError: Dimensions must be equal, but are 48 and 4 for 'loss/dense_loss/sub' (op: 'Sub') with input shapes: [?,48], [?,48,4].因为我的模型不期望这种形状。

我陷入困境的地方是我的 LSTM 层的输入/输出形状。我只是不知道如何以 (BATCH_SIZE, 48, 4) 的形状结束。

这是我目前的图层设置：

tf.keras.backend.clear_session()


print("Input shape", x_train_multi.shape[-2:])

multi_step_model = tf.keras.models.Sequential()
multi_step_model.add(tf.keras.layers.LSTM(32,
                                          return_sequences=True,
                                          input_shape=x_train_multi.shape[-2:]))
multi_step_model.add(tf.keras.layers.Dropout(rate=0.5)) # Dropout layer after each LSTM to reduce …

我正在学习 pytorch，我想知道该padding_idx属性有什么作用torch.nn.Embedding(n1, d1, padding_idx=0)？我到处找，找不到我能得到的东西。你能举个例子来说明这一点吗？

我试图找到类似的问题及其答案，但没有成功。这就是为什么我要问一个以前可能被问过的问题：

我正在研究一个输出多个水井的累积产水量的问题。我的特征是时间序列（水流量和泵速作为时间的函数）和静态特征（井的深度、井的纬度和经度、含水层的厚度等）

我的 #1 井输入数据如下所示。

动态数据：

                water rate   pump speed   total produced water
2000-01-01         10            4                 1120
2000-01-02         20            8                 1140
2000-01-03         10            4                 1150
2000-01-04         10            3                 1160
2000-01-05         10            4                 1170

静态数据：

depth of the well_1 = 100
latitude and longitude of the well_1 = x1, y1
thickness of the water bearing zone of well_1 = 3

我的问题是如何构建一个可以同时采用动态和静态特征的 RNN 模型（LSTM、GRU...）？

我在以一种不寻常的方式将两个模型链接在一起时遇到了一些困难。

我正在尝试复制以下流程图：

为清楚起见，在Model[0]我尝试从IR[i]（中间表示）生成整个时间序列作为使用Model[1]. 该方案的目的是允许从一维输入生成参差不齐的二维时间序列（同时允许在不需要该时间步长的输出时省略第二个模型，并且不需要Model[0]不断地“在接受输入和生成输出之间切换模式）。

我假设需要一个自定义训练循环，并且我已经有一个自定义训练循环来处理第一个模型中的状态（以前的版本在每个时间步只有一个输出）。如图所示，第二个模型应该有相当短的输出（能够限制在少于 10 个时间步长）。

但归根结底，虽然我可以考虑我想做的事情，但我对 Keras 和/或 Tensorflow 还不够熟练，无法实际实现它。（事实上​​，这是我与图书馆的第一个非玩具项目。）

我在文献中搜索了类似的鹦鹉方案或示例代码，但没有成功。我什至不知道这个想法在 TF/Keras 中是否可行。

我已经让这两个模型独立工作。（正如我已经计算出维度，并使用虚拟数据进行了一些训练以获得第二个模型的垃圾输出，第一个模型基于此问题的先前迭代并且已经过全面训练。）如果我有Model[0]和Model[1]作为python变量（让我们称它们为model_a和model_b），那么我将如何将它们链接在一起来做到这一点？

编辑添加：

如果这一切都不清楚，也许拥有每个输入和输出的维度会有所帮助：

每个输入和输出的维度是：

输入：(batch_size, model_a_timesteps, input_size)
红外：(batch_size, model_a_timesteps, ir_size)

IR[i] (复制后): (batch_size, model_b_timesteps, ir_size)
Out[i]: (batch_size, model_b_timesteps, output_size)
Out:(batch_size, model_a_timesteps, model_b_timesteps, output_size)