我在Keras中有以下代码(基本上我正在修改此代码以供我使用)并且我收到此错误:

'ValueError:检查目标时出错:预期conv3d_3有5个维度,但得到的数组有形状(10,4096)'

码:

from keras.models import Sequential
from keras.layers.convolutional import Conv3D
from keras.layers.convolutional_recurrent import ConvLSTM2D
from keras.layers.normalization import BatchNormalization
import numpy as np
import pylab as plt
from keras import layers

# We create a layer which take as input movies of shape
# (n_frames, width, height, channels) and returns a movie
# of identical shape.

model = Sequential()
model.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),
                   input_shape=(None, 64, 64, 1),
                   padding='same', return_sequences=True))
model.add(BatchNormalization())

model.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),
                   padding='same', return_sequences=True))
model.add(BatchNormalization())

model.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),
                   padding='same', return_sequences=True)) …

或者,更具体:ConvLSTM2D和之间的区别是ConvLSTM2DCell什么？

SimpleRNN和SimpleRNNCell之间有什么区别？

GRU和GRUCell的问题相同

Keras手册在这里不是很冗长.

我可以从RTFS(阅读那些优秀的资源)看到这些类是不同基类的后代.名称以结尾的那些Cell是子类Layer.

在我的任务中,我需要对视频序列进行分类.也就是说,我的分类器输入是一系列视频帧,输出是单个标签(单热编码矢量).

我应该用什么课？

我是LSTM的新手,经历了理解Keras LSTM,并对Daniel Moller的漂亮答案产生了一些愚蠢的怀疑.

以下是我的一些疑问:

1. 在Achieving one to many 编写的部分下指定了两种方法  ,我们可以使用stateful=True 这些方法循环地获取一步的输出并将其作为下一步的输入(需要output_features == input_features).

   在该One to many with repeat vector图中,重复矢量在所有时间步长中One to many with stateful=True作为输入馈送,而在输出中在下一个时间步骤中作为输入馈送.那么,我们不是通过使用stateful=True？来改变图层的工作方式吗？

   在构建RNN时,应遵循以上哪两种方法(使用重复向量或将前一时间步输出作为下一个输入)？

2. 在该One to many with stateful=True部分下,为了改变one to many预测手动循环代码中的行为,我们将如何知道steps_to_predict变量,因为我们事先并不知道输出序列长度.

   我也不明白整个模型使用last_step output生成方式的方式next_step ouput.它使我对model.predict()功能的工作感到困惑.我的意思是,不是model.predict()同时预测整个输出序列而不是循环通过no. of output sequences(我仍然不知道它的值)生成并做model.predict()预测给定迭代中的特定时间步输出？

3. 我无法理解整个Many to many案例.任何其他链接都会有所帮助.

4. 我知道我们model.reset_states()用来确保新批次独立于前一批次.但是,我们是否手动创建批次序列,以便一个批次跟随另一个批次,或者Keras在stateful=True …

我的问题和问题在两个代码块下面说明.

损失函数

def loss(labels, logits, sequence_lengths, label_lengths, logit_lengths):    
    scores = []
    for i in xrange(runner.batch_size):
        sequence_length = sequence_lengths[i]
        for j in xrange(length):
            label_length = label_lengths[i, j]
            logit_length = logit_lengths[i, j]

             # get top k indices <==> argmax_k(labels[i, j, 0, :], label_length)
            top_labels = np.argpartition(labels[i, j, 0, :], -label_length)[-label_length:]
            top_logits = np.argpartition(logits[i, j, 0, :], -logit_length)[-logit_length:]

            scores.append(edit_distance(top_labels, top_logits))

    return np.mean(scores)

# Levenshtein distance
def edit_distance(s, t):
    n = s.size
    m = t.size
    d = np.zeros((n+1, m+1))
    d[:, 0] = np.arrange(n+1)
    d[0, …

它与此问题的重复如何将最后一个输出y(t-1)作为输入馈送以在张量流RNN中生成y(t)？

我想在时间步长T传递RNN的输出作为时间步长T + 1的输入.input_RNN(T+1) = output_RNN(T) 根据文档,tf.nn.rnn以及tf.nn.dynamic_rnn函数显式地将完整输入应用于所有时间步骤.

我在https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/ops/seq2seq.py检查了seq2seq示例. 它使用循环并调用单元格(输入,状态)函数.细胞可以是lstm或gru或任何其他rnn细胞.我检查了文档以找到cell()的参数的数据类型和形状,但我发现只有表单单元格的构造函数(num_neurons).我想知道将输出传递给输入的正确方法.我不想使用像tensorflow构建的keras之类的其他库/包装器.有什么建议？

我对动态RNN(ie dynamic_rnn)是什么感到困惑.它返回TensorFlow中的输出和状态.这些状态和输出是什么？在TensorFlow中,动态RNN中的动态是什么？

我在Pytorch中使用Sequence to Sequence模型.序列到序列模型包括编码器和解码器.

编码器转换a (batch_size X input_features X num_of_one_hot_encoded_classes) -> (batch_size X input_features X hidden_size)

解码器将采用此输入序列并将其转换为 (batch_size X output_features X num_of_one_hot_encoded_classes)

一个例子是 -

所以在上面的例子中,我需要将22个输入功能转换为10个输出功能.在Keras中,可以使用RepeatVector(10)完成.

一个例子 -

model.add(LSTM(256, input_shape=(22, 98)))
model.add(RepeatVector(10))
model.add(Dropout(0.3))
model.add(LSTM(256, return_sequences=True))

虽然,我不确定它是否是将输入序列转换为输出序列的正确方法.

所以,我的问题是 -

• 将输入序列转换为输出序列的标准方法是什么.例如.转换自(batch_size,22,98) - >(batch_size,10,98)？或者我应该如何准备解码器？

编码器代码片段(用Pytorch编写) -

class EncoderRNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(EncoderRNN, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size,
          num_layers=1, batch_first=True)

    def forward(self, input):
        output, hidden = self.lstm(input)
        return output, hidden

所以我试图训练一个简单的循环网络来检测输入信号中的"突发".下图显示了RNN的输入信号(蓝色)和所需(分类)输出,以红色显示.

因此,无论何时检测到突发,网络的输出都应从1切换到0,并与该输出保持一致.用于训练RNN的输入序列之间唯一变化的是突发发生的时间步长.

按照https://github.com/MorvanZhou/PyTorch-Tutorial/blob/master/tutorial-contents/403_RNN_regressor.py上的教程,我无法获得RNN学习.学习的RNN始终以"无记忆"方式运行,即不使用内存进行预测,如以下示例行为所示:

绿线显示网络的预测输出.在这个例子中我做错了什么,以至于无法正确学习网络？网络任务不是很简单吗？

我正在使用:

1. torch.nn.CrossEntropyLoss作为损失函数
2. 用于学习的Adam Optimizer
3. 具有16个内部/隐藏节点和2个输出节点的RNN.他们使用torch.RNN类的默认激活功能.

实验已经用不同的随机种子重复了几次,但结果几乎没有差异.我使用了以下代码:

import torch
import numpy, math
import matplotlib.pyplot as plt

nofSequences = 5
maxLength = 130

# Generate training data
x_np = numpy.zeros((nofSequences,maxLength,1))
y_np = numpy.zeros((nofSequences,maxLength))
numpy.random.seed(1)
for i in range(0,nofSequences):
    startPos = numpy.random.random()*50
    for j in range(0,maxLength):
        if j>=startPos and j<startPos+10:
            x_np[i,j,0] = math.sin((j-startPos)*math.pi/10)
        else:
            x_np[i,j,0] = 0.0
        if j<startPos+10:
            y_np[i,j] = 1
        else:
            y_np[i,j] = 0


# Define the neural network
INPUT_SIZE = 1
class …

内容：

我目前正在使用带有Tensorflow后端的Keras进行时间序列预测，因此研究了此处提供的教程。

在学习完本教程之后，我开始fit_generator()描述该方法的生成器。该生成器生成的输出如下（左侧示例，右侧目标）：

[[[10. 15.]
  [20. 25.]]] => [[30. 35.]]     -> Batch no. 1: 2 Samples | 1 Target
  ---------------------------------------------
[[[20. 25.]
  [30. 35.]]] => [[40. 45.]]     -> Batch no. 2: 2 Samples | 1 Target
  ---------------------------------------------
[[[30. 35.]
  [40. 45.]]] => [[50. 55.]]     -> Batch no. 3: 2 Samples | 1 Target
  ---------------------------------------------
[[[40. 45.]
  [50. 55.]]] => [[60. 65.]]     -> Batch no. 4: 2 Samples | 1 Target
  ---------------------------------------------
[[[50. 55.]
  [60. 65.]]] => …

Tensorflow提供了一个不错的LSTM包装器.

rnn_cell.BasicLSTM(num_units, forget_bias=1.0, input_size=None,
           state_is_tuple=False, activation=tanh)

我想使用正则化,比如L2正则化.但是,我没有直接访问LSTM单元格中使用的不同权重矩阵,所以我不能明确地做一些像

loss = something + beta * tf.reduce_sum(tf.nn.l2_loss(weights))

有没有办法访问矩阵或使用LSTM以某种方式使用正则化？