标签: recurrent-neural-network

我正在尝试用 C 语言实现循环神经网络，但它不起作用。我在网上阅读了一些文档，但我不明白复杂的数学。所以我采用了多层感知器的计算。

在学习的几个步骤中，我的网络的输出是一个数字，但输出很快就变成“不是数字”（-1，#IND00）。

1.计算。

我的第一个问题是计算值、误差和重量变化。

N1->N2我通过以下方式计算两个神经元之间的前向链接：

• 前向传球：(value of N2) += (value of N1) * (weight of link N1->N2)
• 向后传递：(error of N1) += (error of N2) * (weight of link N1->N2)对于输出神经元(error) = (value of neuron) - (target output)
• 体重变化：(new weight) = (old weight) - derivative(value of N2) * (error of N2) * (value of N1) * learning_rate

在每个神经元中，我存储在先前的前向和后向传递期间计算的神经元的先前值以及神经元的先前误差，因为在与前向链接相同的传递期间无法计算循环链接。

我N2->N1通过以下方式计算两个神经元之间的循环链接：

• 前向传递：(value of N1) += (previous value of N2) * (weight of link …

我使用循环神经网络 (RNN) 进行预测，但由于某些奇怪的原因，它总是输出 1。这里我用一个玩具示例对此进行解释：

示例 考虑一个M维度为 (360, 5) 的矩阵和一个Y包含 rowsum 的向量M。现在，使用 RNN，我想Y从进行预测M。使用rnn R包，我将模型训练为

   library(rnn) 
    M <- matrix(c(1:1800),ncol=5,byrow = TRUE) # Matrix (say features) 
    Y <- apply(M,1,sum) # Output equls to row sum of M
    mt <- array(c(M),dim=c(NROW(M),1,NCOL(M))) # matrix formatting as [samples, timesteps, features]
    yt <- array(c(Y),dim=c(NROW(M),1,NCOL(Y))) # formatting
    model <- trainr(X=mt,Y=yt,learningrate=0.5,hidden_dim=10,numepochs=1000) # training

我在训练时观察到的一件奇怪的事情是，纪元误差始终是 4501。理想情况下，纪元误差应该随着纪元的增加而减少。

接下来，我创建了一个与上述结构相同的测试数据集，如下所示：

M2 <- matrix(c(1:15),nrow=3,byrow = TRUE)
mt2 <- array(c(M2),dim=c(NROW(M2),1,NCOL(M2)))
predictr(model,mt2)

通过预测，我总是得到输出 1。持续纪元误差和相同输出的原因是什么？ …

我有一个序列正在尝试使用带有 return_sequences=True 的 Keras LSTM 进行分类。我有“数据”和“标签”数据集，它们的形状相同 - 二维矩阵，行按位置排列，列按时间间隔排列（单元格值是我的“信号”特征）。因此，带有 return_sequences=True 的 RNN 似乎是一种直观的方法。

将我的数据(X)和标签重塑(Y)为 shape 的 3D 张量后(rows, cols, 1)，我调用model.fit(X, Y)但收到以下错误：

ValueError('y 的形状无效')

它向我指出了类 KerasClassifier() 的 fit 方法的代码，该方法检查len(y.shape)==2.

好吧，也许我应该将我的 2D 重塑'X'为形状（行、列、1）的 3D 张量，但将我的标签保留为 sklearn 界面的 2D？但当我尝试时，我收到另一个 Keras 错误：

ValueError：检查模型目标时出错：预期 lstm_17 有 3 个维度，但得到形状为 (500, 2880) 的数组

...那么如何使用 Sklearn 风格的 Keras RNN 来返回序列呢？Keras 的不同部分似乎要求我的目标是 2D 和 3D。或者（更有可能）我误解了一些东西。

...这是一个可重现的代码示例：

from keras.layers import LSTM
from keras.wrappers.scikit_learn import KerasClassifier

# Raw Data/Targets    
X …

我正在用张量流编写我的第一个神经机器翻译器。我正在注意使用编码器/解码器机制。我的编码器和解码器是具有残差连接的 lstm 堆栈，但编码器具有初始双向层。解码器没有。

我所看到的代码中的常见做法是使用编码器单元的最后状态来初始化解码器单元的状态。然而，如果您的编码器和解码器架构相同，这只是一个干净的解决方案，就像许多 seq2seq 教程中的情况一样。在许多其他系统中，例如谷歌的这个模型 ，编码器和解码器的架构有所不同。

在这些情况下用于初始化解码器状态的替代策略有哪些？

我见过这样的情况：编码器的最后一个隐藏状态通过经过训练的权重向量传递，为所有解码器层创建初始解码器状态。我还看到了更多创造性的想法，例如这里提出的想法，但我想对人们为什么选择某些策略产生一种直觉。

尝试实现论文《Ensemble Application of Convolutional and Recurrent Neural Networks for Multi-label Text Categorization in keras》中的模型

该模型如下所示（摘自论文）

我的代码为

document_input = Input(shape=(None,), dtype='int32')
embedding_layer = Embedding(vocab_size, WORD_EMB_SIZE, weights=[initial_embeddings], 
                                input_length=DOC_SEQ_LEN, trainable=True)
convs = []
filter_sizes = [2,3,4,5]

doc_embedding = embedding_layer(document_input)
for filter_size in filter_sizes:
    l_conv = Conv1D(filters=256, kernel_size=filter_size, padding='same', activation='relu')(doc_embedding)
    l_pool = MaxPooling1D(filter_size)(l_conv)
    convs.append(l_pool)

l_merge = Concatenate(axis=1)(convs)
l_flat = Flatten()(l_merge)
l_dense = Dense(100, activation='relu')(l_flat)
l_dense_3d = Reshape((1,int(l_dense.shape[1])))(l_dense)

gene_variation_input = Input(shape=(None,), dtype='int32')
gene_variation_embedding = embedding_layer(gene_variation_input)
rnn_layer = LSTM(100, return_sequences=False, stateful=True)(gene_variation_embedding,initial_state=[l_dense_3d])

l_flat = Flatten()(rnn_layer)
output_layer …

我一直在研究字符级文本生成的示例：https://keras.rstudio.com/articles/examples/lstm_text_ Generation.html

我无法将此示例扩展到单词级模型。请参阅下面的代表

library(keras)
library(readr)
library(stringr)
library(purrr)
library(tokenizers)

# Parameters

maxlen <- 40

# Data Preparation

# Retrieve text
path <- get_file(
  'nietzsche.txt', 
  origin='https://s3.amazonaws.com/text-datasets/nietzsche.txt'
  )

# Load, collapse, and tokenize text
text <- read_lines(path) %>%
  str_to_lower() %>%
  str_c(collapse = "\n") %>%
  tokenize_words( simplify = TRUE)

print(sprintf("corpus length: %d", length(text)))

words <- text %>%
  unique() %>%
  sort()

print(sprintf("total words: %d", length(words)))  

这使：

[1] "corpus length: 101345"
[1] "total words: 10283"

当我继续下一步时，我遇到了问题：

# Cut the text in semi-redundant sequences of maxlen …

我对 Keras 和深度学习有点陌生。我目前正在尝试复制这篇论文，但是当我编译第二个模型（使用 LSTM）时，出现以下错误：

"TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'"

该模型的描述是这样的：

1. 输入（长度T是设备特定的窗口尺寸）
2. size分别使用滤波器3、5 和 7 的并行一维卷积， stride=1, number of filters=32, activation type=linear,border mode=same
3. 连接并行一维卷积输出的合并层
4. 双向LSTM由前向LSTM和后向LSTM组成，output_dim=128
5. 双向LSTM由前向LSTM和后向LSTM组成，output_dim=128
6. 致密层, output_dim=128,activation type=ReLU
7. 致密层, output_dim= T,activation type=linear

我的代码是这样的：

from keras import layers, Input
from keras.models import Model

def lstm_net(T):
    input_layer = Input(shape=(T,1))
    branch_a = layers.Conv1D(32, 3, activation='linear', padding='same', strides=1)(input_layer)
    branch_b = layers.Conv1D(32, 5, activation='linear', padding='same', strides=1)(input_layer) …

我正在尝试使用双向 GRU 在 Keras 中实现编码器-解码器类型网络。

下面的代码似乎可以工作

src_input = Input(shape=(5,))
ref_input = Input(shape=(5,))

src_embedding = Embedding(output_dim=300, input_dim=vocab_size)(src_input)
ref_embedding = Embedding(output_dim=300, input_dim=vocab_size)(ref_input)

encoder = Bidirectional(
                GRU(2, return_sequences=True, return_state=True)
        )(src_embedding)

decoder = GRU(2, return_sequences=True)(ref_embedding, initial_state=encoder[1])

但是，当我将解码更改为使用Bidirectional包装器时，它会停止显示encoder并src_input在model.summary(). 新的解码器如下所示：

decoder = Bidirectional(
                GRU(2, return_sequences=True)
        )(ref_embedding, initial_state=encoder[1:])

model.summary()双向解码器的输出。

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_2 (InputLayer)         (None, 5)                 0         
_________________________________________________________________
embedding_2 (Embedding)      (None, 5, 300)            6610500   
_________________________________________________________________
bidirectional_2 (Bidirection (None, 5, 4)              3636      
=================================================================
Total …

我正在尝试使用 R 中的 keras 在 LSTM 中使用批量归一化。在我的数据集中，目标/输出变量是列Sales，数据集中的每一行记录Sales一年中的每一天（2008-2017）。数据集如下所示：

我的目标是基于这样的数据集构建一个 LSTM 模型，该模型应该能够在训练结束时提供预测。我正在使用 2008-2016 年的数据训练这个模型，并使用 2017 年数据的一半作为验证，其余作为测试集。

之前，我尝试使用 dropout 和提前停止创建模型。如下所示：

mdl1 <- keras_model_sequential()
mdl1 %>%
  layer_lstm(units = 512, input_shape = c(1, 3), return_sequences = T ) %>%  
  layer_dropout(rate = 0.3) %>%
  layer_lstm(units = 512, return_sequences = FALSE) %>%
  layer_dropout(rate = 0.2) %>%
  layer_dense(units = 1, activation = "linear")

mdl1 %>% compile(loss = 'mse', optimizer = 'rmsprop')

模型如下

___________________________________________________________
Layer (type)               Output Shape         Param #    
===========================================================
lstm_25 (LSTM)             (None, 1, …

目标是预测 87601 个时间步长（10 年）和 9 个目标的时间序列 Y。输入特征 X（外源输入）是 87600 个时间步长的 11 个时间序列。输出还有一个时间步长，因为这是初始值。时间步 t 处的输出 Yt 取决于输入 Xt 和先前的输出 Yt-1。

因此，模型应如下所示：模型布局

我只能找到这个线程：LSTM: How to feed the output back to the input? 第4068章 我尝试使用 Keras 实现此功能，如下所示：

def build_model():
    # Input layers
    input_x = layers.Input(shape=(features,), name='input_x')
    input_y = layers.Input(shape=(targets,), name='input_y-1')

    # Merge two inputs
    merge = layers.concatenate([input_x,input_y], name='merge')

    # Normalise input
    norm = layers.Lambda(normalise, name='scale')(merge)

    # Hidden layers
    x = layers.Dense(128, input_shape=(features,))(norm)

    # Output layer
    output = layers.Dense(targets, activation='relu', name='output')(x) …