标签: lstm

tensorflow配置dropout包装器具有三种不同的 dropout概率可以设置：input_keep_prob, output_keep_prob, state_keep_prob.

我想通过将variational_recurrent参数设置为 true 来为我的 LSTM 单元使用变分 dropout 。但是，我不知道必须使用三个 dropout 概率中的哪一个才能使变分 dropout 正常运行。

有人可以提供帮助吗？

import tensorflow as tf
import tensorflow.contrib.eager as tfe

tfe.enable_eager_execution()

x = tf.range(1, 11, dtype=tf.float32)
x = tf.reshape(x, (5, 1, 2))

cell = tf.contrib.rnn.LSTMCell(10)
initial_state = cell.zero_state(5, dtype=tf.float32)

y1, _ = tf.nn.dynamic_rnn(cell, x, dtype=tf.float32, initial_state=initial_state)

y2, _ = tf.nn.dynamic_rnn(
    tf.contrib.rnn.DropoutWrapper(cell, input_keep_prob=1.0, output_keep_prob=0.5, state_keep_prob=1.0),
    x,
    dtype=tf.float32,
    initial_state=initial_state)

我正在使用 Tensorflow 1.8.0。

我期望的输出y2与y1因为y2使用相同的 LSTM 单元相似，y1除了它也通过一个 dropout 层。由于 dropout 仅应用于 LSTM 单元的输出，我认为除了这里和那里的几个 0 之外，的值y2将相同y1。但这就是我得到的y1：

<tf.Tensor: id=5540, shape=(5, 1, 10), dtype=float32, numpy= …

我想开发一种用于二元分类的时间序列方法，在 Keras 中使用有状态的 LSTM

这是我的数据的外观。我得到了很多，比如说N，录音。每个记录包含 22 个长度的时间序列M_i(i=1,...N)。我想在 Keras 中使用有状态模型，但我不知道如何重塑我的数据，尤其是我应该如何定义我的batch_size.

这是我如何进行statelessLSTM。我look_back为所有录音创建了长度序列，以便我拥有大小数据(N*(M_i-look_back), look_back, 22=n_features)

这是我为此目的使用的功能：

def create_dataset(feat,targ, look_back=1):
    dataX, dataY = [], []
#     print (len(targ)-look_back-1)
    for i in range(len(targ)-look_back):
        a = feat[i:(i+look_back), :]
        dataX.append(a)
        dataY.append(targ[i + look_back-1])
    return np.array(dataX), np.array(dataY)

其中feat是大小的二维数据数组(n_samples, n_features)（对于每个记录），targ是目标向量。

所以，我的问题是，根据上面解释的数据，如何为有状态模型重塑数据并考虑批处理概念？有什么预防措施吗？

我想要做的是能够将每个录音的每个 time_step 分类为癫痫发作/非癫痫发作。

编辑：我想到的另一个问题是：我的录音包含不同长度的序列。我的有状态模型可以学习每个记录的长期依赖关系，这意味着 batch_size 从一个记录到另一个记录不同......如何处理？在完全不同的序列（test_set）上进行测试时会不会导致泛化问题？

谢谢

我正在 Python 中使用 Tensorflow/Keras 进行时间序列分析。整个 LSTM 模型看起来像，

model = keras.models.Sequential()
model.add(keras.layers.LSTM(25, input_shape = (1,1), activation =    'relu', dropout = 0.2, return_sequences = False))
model.add(keras.layers.Dense(1))
model.compile(optimizer = 'adam', loss = 'mean_squared_error', metrics=['acc'])
tensorboard = keras.callbacks.TensorBoard(log_dir="logs/{}".format(time()))
es = keras.callbacks.EarlyStopping(monitor='val_acc', mode='max', verbose=1, patience=50)
mc = keras.callbacks.ModelCheckpoint('/home/sukriti/best_model.h5',   monitor='val_loss', mode='min', save_best_only=True)
history = model.fit(trainX_3d, trainY_1d, epochs=50, batch_size=10, verbose=2, validation_data = (testX_3d, testY_1d), callbacks=[mc, es, tensorboard])

我有以下结果，

Train on 14015 samples, validate on 3503 samples
Epoch 1/50
- 3s - loss: 0.0222 - acc: 7.1352e-05 - …

我最近从https://github.com/Hvass-Labs/TensorFlow-Tutorials/blob/master/23_Time-Series-Prediction.ipynb学习了用于时间序列预测的 LSTM

在他的教程中，他说：我们将使用以下函数创建一批从训练数据中随机选取的较短子序列，而不是在近 30 万个观察的完整序列上训练循环神经网络。

def batch_generator(batch_size, sequence_length):
"""
Generator function for creating random batches of training-data.
"""

# Infinite loop.
while True:
    # Allocate a new array for the batch of input-signals.
    x_shape = (batch_size, sequence_length, num_x_signals)
    x_batch = np.zeros(shape=x_shape, dtype=np.float16)

    # Allocate a new array for the batch of output-signals.
    y_shape = (batch_size, sequence_length, num_y_signals)
    y_batch = np.zeros(shape=y_shape, dtype=np.float16)

    # Fill the batch with random sequences of data.
    for i in range(batch_size):
        # Get a random …

我在理解堆叠 LSTM 网络中层的输入-输出流时遇到了一些困难。假设我创建了一个堆叠的 LSTM 网络，如下所示：

# parameters
time_steps = 10
features = 2
input_shape = [time_steps, features]
batch_size = 32

# model
model = Sequential()
model.add(LSTM(64, input_shape=input_shape,  return_sequences=True))
model.add(LSTM(32,input_shape=input_shape))

我们的堆叠 LSTM 网络由 2 个 LSTM 层组成，分别具有 64 个和 32 个隐藏单元。在这种情况下，我们希望在每个时间步长中，第 1 个 LSTM 层 -LSTM(64)- 将作为输入传递给第 2 个 LSTM 层 -LSTM(32)- 一个大小为 的向量[batch_size, time-step, hidden_unit_length]，它表示隐藏状态当前时间步长的第 1 个 LSTM 层。让我困惑的是：

1. 第二个 LSTM 层 -LSTM(32)- 是否接收X(t)（作为输入）第一层的隐藏状态 -LSTM(64)- 具有大小[batch_size, time-step, hidden_unit_length]并通过它自己的隐藏网络 - 在这种情况下由 32 个节点组成-？
2. 如果第一个是真的，为什么input_shape …

我试图找到一种在 Keras 序列模型中添加注意力层的简单方法。但是，我在实现这一目标时遇到了很多问题。

我是深度学习的新手，所以我选择 Keras 作为我的开始。我的任务是构建一个带有注意力模型的 Bi-LSTM。在 IMDB 数据集上，我建立了一个 Bi-LSTM 模型。我找到了一个名为“keras-self-attention”的包？https://pypi.org/project/keras-self-attention/？? 但是在 keras Sequential 模型中添加注意力层时遇到了一些问题。

from keras.datasets import imdb
from keras.preprocessing import sequence
from keras_self_attention import SeqSelfAttention

max_features = 10000
maxlen = 500
batch_size = 32

# data
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
x_train = sequence.pad_sequences(x_train, maxlen= maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)

# model 
from keras import models
from keras import layers
from keras.layers import Dense, Embedding, LSTM


model = models.Sequential()
model.add( Embedding(max_features, 32) )
model.add( Bidirectional( …

我知道 LSTM 单元内部有许多 ANN。

但是在为同一问题定义隐藏层时，我看到有些人只使用 1 个 LSTM 单元，而其他人则使用 2、3 个 LSTM 单元，如下所示 -

model = Sequential()
model.add(LSTM(256, input_shape=(n_prev, 1), return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(128, input_shape=(n_prev, 1), return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(64, input_shape=(n_prev, 1), return_sequences=False))
model.add(Dropout(0.3))
model.add(Dense(1))
model.add(Activation('linear'))

1. 关于您应该使用多少个 LSTM 单元，是否有任何规则？或者它只是手动实验？
2. 紧随其后的另一个问题是，您应该在 LSTM 单元中使用多少个单元。对于同样的问题，有些人需要 256，有些人需要 64。

我有一个基本的 PyTorch LSTM：

import torch.nn as nn
import torch.nn.functional as F

class BaselineLSTM(nn.Module):
    def __init__(self):
        super(BaselineLSTM, self).__init__()

        self.lstm = nn.LSTM(input_size=13, hidden_size=13)

    def forward(self, x):
        x = self.lstm(x)

        return x

对于我的数据，我有：

train_set = CorruptedAudioDataset(corrupted_path, train_set=True)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=128, shuffle=True, **kwargs)

我的 CorruptedAudioDataset有：

    def __getitem__(self, index):
        corrupted_sound_file = SoundFile(self.file_paths[index])
        corrupted_samplerate = corrupted_sound_file.samplerate
        corrupted_signal_audio_array = corrupted_sound_file.read()

        clean_path = self.file_paths[index].split('/')
        # print(self.file_paths[index], clean_path)
        clean_sound_file = SoundFile(self.file_paths[index])
        clean_samplerate = clean_sound_file.samplerate
        clean_signal_audio_array = clean_sound_file.read()


        corrupted_mfcc = mfcc(corrupted_signal_audio_array, samplerate=corrupted_samplerate)
        clean_mfcc = mfcc(clean_signal_audio_array, samplerate=clean_samplerate)


        print('return', corrupted_mfcc.shape, …

我有一个时间序列预测问题，正在构建一个如下所示的 LSTM：

def create_model():
    model = Sequential()
    model.add(LSTM(50,kernel_regularizer=l2(0.01), recurrent_regularizer=l2(0.01), bias_regularizer=l2(0.01), input_shape=(train_X.shape[1], train_X.shape[2])))
    model.add(Dropout(0.591))
    model.add(Dense(1))
    model.compile(loss='mean_squared_error', optimizer='adam')
    return model

当我在 5 个分割上训练模型时，如下所示：

tss = TimeSeriesSplit(n_splits = 5)
X = data.drop(labels=['target_prediction'], axis=1)
y = data['target_prediction'] 
for train_index, test_index in tss.split(X):
   train_X, test_X = X.iloc[train_index, :].values, X.iloc[test_index,:].values
   train_y, test_y = y.iloc[train_index].values, y.iloc[test_index].values
   model=create_model()
   history = model.fit(train_X, train_y, epochs=10, batch_size=64,validation_data=(test_X, test_y), verbose=0, shuffle=False)

我遇到过拟合问题。附上损失图

我不确定为什么在我的 Keras 模型中使用正则化器时会出现过度拟合。任何帮助表示赞赏。

编辑： 尝试架构

def create_model():
    model = Sequential()
    model.add(LSTM(20, input_shape=(train_X.shape[1], train_X.shape[2])))
    model.add(Dense(1))
    model.compile(loss='mean_squared_error', optimizer='adam')
    return model


def create_model(x,y): …