标签: rnn

import torch,ipdb
import torch.autograd as autograd
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable

rnn = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
input = Variable(torch.randn(5, 3, 10))
h0 = Variable(torch.randn(2, 3, 20))
c0 = Variable(torch.randn(2, 3, 20))
output, hn = rnn(input, (h0, c0))

这是文档中的LSTM示例.我不明白以下事项:

1. 什么是输出大小,为什么没有在任何地方指定？
2. 为什么输入有3个维度.5和3代表什么？
3. h0和c0中的2和3是什么,这些代表什么？

编辑:

import torch,ipdb
import torch.autograd as autograd
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
import torch.nn.functional as F

num_layers=3 …

我使用Python 3.6运行以下像素递归神经网络(RNN)代码

import os
import logging

import numpy as np
from tqdm import trange
import tensorflow as tf

from utils import *
from network import Network
from statistic import Statistic

但是,有一个错误:

ModuleNotFoundError: No module named 'tqdm'

有谁知道如何解决它？

我目前的LSTM网络看起来像这样.

rnn_cell = tf.contrib.rnn.BasicRNNCell(num_units=CELL_SIZE)
init_s = rnn_cell.zero_state(batch_size=1, dtype=tf.float32)  # very first hidden state
outputs, final_s = tf.nn.dynamic_rnn(
    rnn_cell,              # cell you have chosen
    tf_x,                  # input
    initial_state=init_s,  # the initial hidden state
    time_major=False,      # False: (batch, time step, input); True: (time step, batch, input)
)

# reshape 3D output to 2D for fully connected layer
outs2D = tf.reshape(outputs, [-1, CELL_SIZE])
net_outs2D = tf.layers.dense(outs2D, INPUT_SIZE)

# reshape back to 3D
outs = tf.reshape(net_outs2D, [-1, TIME_STEP, INPUT_SIZE])

通常,我申请tf.layers.batch_normalization批量标准化.但我不确定这是否适用于LSTM网络.

b1 = …

受本文的启发,我正在尝试构建一个条件GAN,它将使用LSTM生成MNIST数字.我希望我使用与图像波纹相同的架构(除了本文中的鉴别器中的双向RNN ):

当我运行这个模型时,我得到了非常奇怪的结果.此图显示了我的模型在每个纪元后生成3号.看起来应该更像这样.这真的很糟糕.

我的鉴别器网络的丢失真的快速下降到接近零.然而,我的发电机网络的损失在一些固定点附近振荡(可能缓慢地发散).我真的不知道发生了什么.这是我的代码中最重要的部分(完整代码在这里):

timesteps = 28
X_dim = 28
Z_dim = 100
y_dim = 10

X = tf.placeholder(tf.float32, [None, timesteps, X_dim]) # reshaped MNIST image to 28x28
y = tf.placeholder(tf.float32, [None, y_dim]) # one-hot label
Z = tf.placeholder(tf.float32, [None, timesteps, Z_dim]) # numpy.random.uniform noise in range [-1; 1]

y_timesteps = tf.tile(tf.expand_dims(y, axis=1), [1, timesteps, 1]) # [None, timesteps, y_dim] - replicate y along axis=1

def discriminator(x, y): …

我正在尝试用pytorch中的手动定义参数填充GRU/LSTM.

我有numpy数组用于参数的形状,如文档中所定义(https://pytorch.org/docs/stable/nn.html#torch.nn.GRU).

它似乎工作,但我不确定返回的值是否正确.

这是用numpy参数填充GRU/LSTM的正确方法吗？

gru = nn.GRU(input_size, hidden_size, num_layers,
              bias=True, batch_first=False, dropout=dropout, bidirectional=bidirectional)

def set_nn_wih(layer, parameter_name, w, l0=True):
    param = getattr(layer, parameter_name)
    if l0:
        for i in range(3*hidden_size):
            param.data[i] = w[i*input_size:(i+1)*input_size]
    else:
        for i in range(3*hidden_size):
            param.data[i] = w[i*num_directions*hidden_size:(i+1)*num_directions*hidden_size]

def set_nn_whh(layer, parameter_name, w):
    param = getattr(layer, parameter_name)
    for i in range(3*hidden_size):
        param.data[i] = w[i*hidden_size:(i+1)*hidden_size]

l0=True

for i in range(num_directions):
    for j in range(num_layers):
        if j == 0:
            wih = w0[i, :, :3*input_size]
            whh = w0[i, :, 3*input_size:]  # …

我正在penn treebank上实施语言模型培训.

我为每个时间步增加了损失然后计算困惑.

即使经过一段时间的训练,这也让我感到非常困难,数千亿.

损失本身会减少,但最多只能减少到20左右.(我需要一位数的损失以获得合理的困惑).

这让我想知道我的困惑计算是否被误导了.

它应该基于每个时间步的损失,然后平均而不是将它们全部添加？

我的batch_size是20,num_steps是35.

def perplexity(loss):
    perplexity = np.exp(loss)
    return perplexity

...
loss = 0
x = nn.Variable((batch_size, num_steps))
t = nn.Variable((batch_size, num_steps))
e_list = [PF.embed(x_elm, num_words, state_size, name="embed") for x_elm in F.split(x, axis=1)]
t_list = F.split(t, axis=1)

for i, (e_t, t_t) in enumerate(zip(e_list, t_list)):
    h1 = l1(F.dropout(e_t,0.5))
    h2 = l2(F.dropout(h1,0.5))
    y = PF.affine(F.dropout(h2,0.5), num_words, name="pred")
    t_t = F.reshape(t_t,[batch_size,1])
    loss += F.mean(F.softmax_cross_entropy(y, t_t))

for epoch in range(max_epoch):
    ....
    for i in range(iter_per_epoch):
        x.d, t.d = get_words(train_data, …

我正试图用numpy实现递归神经网络.

我目前的输入和输出设计如下:

x 形状:(序列长度,批量大小,输入维度)

h :(层数,方向数,批量大小,隐藏大小)

initial weight:(方向数,2*隐藏大小,输入大小+隐藏大小)

weight:(层数-1,方向数,隐藏大小,方向*隐藏大小+隐藏大小)

bias:(层数,方向数,隐藏大小)

我已经查找了RNN的pytorch API作为参考(https://pytorch.org/docs/stable/nn.html?highlight=rnn#torch.nn.RNN),但略微改变它以包括初始权重作为输入.(输出形状与pytorch中的相同)

当它正在运行时,我无法确定它是否表现正常,因为我输入随机生成的数字作为输入.

特别是,我不确定我的输入形状是否设计正确.

有专家可以给我一个指导吗？

def rnn(xs, h, w0, w=None, b=None, num_layers=2, nonlinearity='tanh', dropout=0.0, bidirectional=False, training=True):
    num_directions = 2 if bidirectional else 1
    batch_size = xs.shape[1]
    input_size = xs.shape[2]
    hidden_size = h.shape[3]
    hn = []
    y = [None]*len(xs)

    for l in range(num_layers):
        for d in range(num_directions):
            if l==0 and d==0:
                wi = w0[d, :hidden_size,  :input_size].T
                wh = w0[d, hidden_size:,  input_size:].T
                wi = np.reshape(wi, (1,)+wi.shape)
                wh …

我正在尝试使用本文https://arxiv.org/abs/1712.01815中描述的方法来使算法学习新游戏。

只有一个问题不能直接适合这种方法。我尝试学习的游戏没有固定的棋盘尺寸。因此，当前输入张量的尺寸为m*n*11，其中m和n是游戏板的尺寸，并且每次玩游戏时都可以变化。因此，首先，我需要一个能够利用这种变化的输入大小的神经网络。

输出的大小也是电路板大小的函数，因为它具有一个向量，其中包含电路板上每个可能移动的条目，因此，如果电路板大小增加，输出向量将更大。

我已经读过递归和递归神经网络，但是它们似乎都与NLP有关，我不确定如何将其转化为我的问题。

任何能够处理我的案例的关于NN体系结构的想法都将受到欢迎。

我正在建立一个RNN LSTM网络,根据作者的年龄(二进制分类 - 年轻/成人)对文本进行分类.

似乎网络没有学习,突然开始过度拟合:

红色:火车
蓝:验证

一种可能性是数据表示不够好.我只是根据频率对单词进行排序并给出了索引.例如:

unknown -> 0
the     -> 1
a       -> 2
.       -> 3
to      -> 4

所以我试图用word嵌入替换它.我看了几个例子,但是我无法在我的代码中实现它.大多数示例如下所示:

embedding = tf.Variable(tf.random_uniform([vocab_size, hidden_size], -1, 1))
inputs = tf.nn.embedding_lookup(embedding, input_data)

这是否意味着我们正在构建一个学习嵌入的层？我认为应该下载一些Word2Vec或Glove并使用它.

无论如何,让我说我想构建这个嵌入层...
如果我在我的代码中使用这两行,我会收到一个错误:

TypeError:传递给参数'indices'的值的DataType float32不在允许值列表中:int32,int64

所以我想我必须改变input_data类型int32.所以我这样做(毕竟这是所有指数),我得到了这个:

TypeError:输入必须是序列

我尝试用一个列表包装inputs(参数tf.contrib.rnn.static_rnn):[inputs]如本答案中所建议的那样,但是产生了另一个错误:

ValueError:输入大小(输入的维度0)必须可通过形状推理访问,但锯值为None.

更新:

x在传递它之前,我正在将张量取消堆叠embedding_lookup.嵌入后我移动了拆散.

更新的代码:

MIN_TOKENS = 10
MAX_TOKENS = 30
x = tf.placeholder("int32", [None, MAX_TOKENS, 1])
y = tf.placeholder("float", [None, N_CLASSES]) …

在 Andrew Ng 的深度学习 Coursera 课程中，有一个关于触发词检测的作业（例如，不是我的：jupyter notebook）。

在作业中，他们只是提供了经过训练的模型，因为他们声称使用带有 GPU 的 4000 多个训练示例进行训练需要几个小时。

我没有使用提供的模型，而是尝试使用它们的函数创建自己的训练示例，然后从头开始训练模型。原始音频文件保持不变。有 2 个背景文件，所以我确保每个背景都有 2000 个训练示例：

n_train_per_bg = 2000
n_train = len(backgrounds)*n_train_per_bg
orig_X_train = np.empty((n_train, Tx, n_freq))
orig_Y_train = np.empty((n_train, Ty , 1))

for bg in range(len(backgrounds)):
    for n in range(n_train_per_bg):
        print("bg: {}, n: {}".format(bg, n))
        x, y = create_training_example(backgrounds[bg], activates, negatives)
        orig_X_train[bg*n_train_per_bg + n, :, :] = x.T
        orig_Y_train[bg*n_train_per_bg + n, :, :] = y.T

np.save('./XY_train/orig_X_train.npy', orig_X_train)
np.save('./XY_train/orig_Y_train.npy', orig_Y_train)

然而，跑了一个小时后，得到的结果却相当令人失望。同一个练习中后面的一个例子显示了他们正常运行的模型，当在 x 轴上的 400 标记附近检测到触发词“激活”时，显示概率峰值：

这是我的，它不仅没有检测到任何东西，而且只是扁平化！：

我所做的唯一修改是： …