标签: recurrent-neural-network

我有一个简单的数据框,由一列组成.在该列中有10320个观测值(数值).我正在通过将数据插入到具有每个200个观测值的窗口的图中来模拟时间序列数据.这是绘图的代码.

import matplotlib.pyplot as plt
from IPython import display
fig_size = plt.rcParams["figure.figsize"]
import time
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
fig, axes = plt.subplots(1,1, figsize=(19,5))
df = dframe.set_index(arange(0,len(dframe)))
std = dframe[0].std() * 6
window = 200
iterations = int(len(dframe)/window)
i = 0
dframe = dframe.set_index(arange(0,len(dframe)))
while i< iterations:
    frm = window*i
    if i == iterations:
        to = len(dframe)
    else:
        to = frm+window
    df = dframe[frm : to]
    if len(df) > 100:
        df = df.set_index(arange(0,len(df)))
        plt.gca().cla() 
        plt.plot(df.index, df[0])
        plt.axhline(y=std, xmin=0, xmax=len(df[0]),c='gray',linestyle='--',lw …

我正在使用 Keras 训练模型。

model = Sequential()
model.add(LSTM(units=300, input_shape=(timestep,103), use_bias=True, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(units=536))
model.add(Activation("sigmoid"))
model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])

while True:
        history = model.fit_generator( 
            generator = data_generator(x_[train_indices],
                    y_[train_indices], batch = batch, timestep=timestep),
                steps_per_epoch=(int)(train_indices.shape[0] / batch), 
                epochs=1, 
                verbose=1, 
                validation_steps=(int)(validation_indices.shape[0] / batch), 
                validation_data=data_generator(
                    x_[validation_indices],y_[validation_indices], batch=batch,timestep=timestep))

这是一个符合 scikit-learn.org 定义的多输出分类：多 输出回归为每个样本分配一组目标值。这可以被认为是预测每个数据点的几个属性，例如某个位置的风向和大小.

因此，这是一个循环神经网络，我尝试了不同的时间步长。但结果/问题大致相同。

后一个时期，我的火车损耗大约为0.0X和我的验证损耗大约为0.6X。并且这个值在接下来的 10 个 epoch 中保持稳定。

数据集大约有 680000 行。训练数据为 9/10，验证数据为 1/10。

我要求背后的直觉..

• 我的模型在仅仅一个 epoch 之后就已经过拟合了吗？
• 0.6xx 甚至是验证损失的好值吗？

高级问题：因此它是一个多输出分类任务（不是多类），我看到使用 sigmoid 和 binary_crossentropy 的唯一方法。你建议另一种方法吗？

我正在尝试使用可用的最新资源开发一些时间序列序列预测。为此，我确实检查了 TensorFlow 时间序列中的示例代码，但我收到了这个错误：

AttributeError: module 'tensorflow.python.pywrap_tensorflow' has no attribute 'TFE_Py_RegisterExceptionClass'

我正在使用蟒蛇。当前环境是 Python 3.5 和 TensorFlow 1.2.1。还尝试了 TensorFlow 1.3，但没有任何改变。

这是我试图运行的代码。我在 Google 上没有找到与该问题相关的任何有用信息。关于如何解决它的任何想法？

以下是我对 RNN 中参数共享点的理解：

在常规的前馈神经网络中，每个输入单元都被分配了一个单独的参数，这意味着输入单元（特征）的数量对应于要学习的参数数量。在处理例如图像数据时，输入单元的数量在所有训练示例中都是相同的（通常是恒定像素大小 * 像素大小 * rgb 帧）。

然而，像句子这样的顺序输入数据的长度可能会有很大差异，这意味着参数的数量不会相同，具体取决于处理哪个例句。这就是为什么参数共享对于有效处理序列数据是必要的：它确保模型始终具有相同的输入大小，而不管序列长度如何，因为它是根据从一种状态到另一种状态的转换来指定的。因此，可以在每个时间步使用具有相同权重（输入到隐藏权重、隐藏到输出权重、隐藏到隐藏权重）的相同转移函数。最大的优点是它允许泛化到没有出现在训练集中的序列长度。

我的问题是：

1. 如上所述，我对 RNN 的理解是否正确？
2. 在 Keras 中的实际代码示例中，我查看了 LSTM，它们首先将句子填充为相等的长度。这样做，这不是抹去了 RNN 中参数共享的全部目的吗？

我使用以下循环创建了一个堆叠的 keras 解码器模型：

# Create the encoder
# Define an input sequence.
encoder_inputs = keras.layers.Input(shape=(None, num_input_features))

# Create a list of RNN Cells, these are then concatenated into a single layer with the RNN layer.
encoder_cells = []
for hidden_neurons in hparams['encoder_hidden_layers']:
    encoder_cells.append(keras.layers.GRUCell(hidden_neurons,
                                              kernel_regularizer=regulariser,
                                              recurrent_regularizer=regulariser,
                                              bias_regularizer=regulariser))

encoder = keras.layers.RNN(encoder_cells, return_state=True)

encoder_outputs_and_states = encoder(encoder_inputs)

# Discard encoder outputs and only keep the states. The outputs are of no interest to us, the encoder's job is to create 
# a state describing …

我正在尝试使用文本数据进行多类分类。我面临的问题是我拥有非结构化的文本数据。我会用一个例子来解释这个问题。以这张图片为例：

我想提取和分类图像中给出的文本信息。问题是当我提取信息时，OCR 引擎会给出如下输出：

18
EURO 46
KEEP AWAY
FROM FIRE
MADE IN CHINA
2226249917581
7412501
DOROTHY
PERKINS

现在这里的目标类是：

18 -> size
EURO 46 -> price
KEEP AWAY FROM FIRE -> usage_instructions
MADE IN CHINA -> manufacturing_location
2226249917581 -> product_id
7412501 -> style_id
DOROTHY PERKINS -> brand_name

我面临的问题是输入文本不可分离，这​​意味着“多行可以属于同一个类”，并且可能存在“单行可以有多个类”的情况。

所以我不知道如何在将行传递给分类模型之前拆分/合并行。
有什么方法可以使用 NLP 我可以根据目标类拆分段落。换句话说，给定输入段落根据目标标签对其进行拆分。

我在这里关注本教程https://cs230-stanford.github.io/pytorch-nlp.html。在那里创建了一个神经模型，使用nn.Module，带有嵌入层，在此处初始化

self.embedding = nn.Embedding(params['vocab_size'], params['embedding_dim'])

vocab_size是训练样本的总数，即 4000。 embedding_dim是 50。该forward方法的相关部分如下

def forward(self, s):
        # apply the embedding layer that maps each token to its embedding
        s = self.embedding(s)   # dim: batch_size x batch_max_len x embedding_dim

将批次传递给模型时，我收到此异常，就像model(train_batch) train_batch维度batch_sizex的 numpy 数组一样 batch_max_len。每个样本是一个句子，每个句子都被填充，使其具有批次中最长句子的长度。

文件 "/Users/liam_adams/Documents/cs512/research_project/custom/model.py", line 34, in forward s = self.embedding(s) # dim: batch_size x batch_max_len x embedding_dim File "/Users/liam_adams/Documents/ cs512/venv_research/lib/python3.7/site-packages/torch/nn/modules/module.py”，第 493 行，通话中 结果 = self.forward(*input, **kwargs) 文件“/Users/liam_adams/Documents/cs512/venv_research/lib/python3.7/site-packages/torch/nn/modules/sparse.py”，第 117 …

我在将 Bert 嵌入层集成到 BiLSTM 模型中以进行词义消歧任务时遇到问题，

Windows 10
Python 3.6.4
TenorFlow 1.12
Keras 2.2.4
No virtual environments were used
PyCharm Professional 2019.2

整个剧本

import os
import yaml
import numpy as np
from argparse import ArgumentParser

import tensorflow as tf
import tensorflow_hub as hub
from tensorflow.keras.layers import (LSTM, Add, Bidirectional, Dense, Input, TimeDistributed, Embedding)

from tensorflow.keras.preprocessing.sequence import pad_sequences

try:
    from bert.tokenization import FullTokenizer
except ModuleNotFoundError:
    os.system('pip install bert-tensorflow')

from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
from tqdm import tqdm …

我遇到过研究出版物和问答讨论需要检查每个反向传播时间 (BPTT) 的 RNN 梯度 - 即每个时间步长的梯度。主要用途是自省：我们如何知道 RNN 是否正在学习长期依赖？一个自己主题的问题，但最重要的见解是梯度流：

• 如果一个非零梯度流经每个时间步，那么每个时间步都有助于学习——即，结果梯度源于对每个输入时间步的考虑，因此整个序列会影响权重更新
• 如上所述，RNN不再忽略长序列的一部分，而是被迫向它们学习

...但是我如何在 Keras / TensorFlow 中实际可视化这些梯度？一些相关的答案是在正确的方向上，但它们似乎对双向 RNN 失败了，并且只展示了如何获得层的梯度，而不是如何有意义地可视化它们（输出是一个 3D 张量 - 我该如何绘制它？）

前提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 …