Recurrent layers

class torch.nn.RNN( args, * kwargs)[source]

将一个多层的 Elman RNN，激活函数为tanh或者ReLU，用于输入序列。

对输入序列中每个元素，RNN每层的计算公式为

$$ ht=tanh(w{ih} xt+b{ih}+w_{hh} h{t-1}+b{hh})

$$ $h_t$是时刻$t$的隐状态。 $x_t$是上一层时刻$t$的隐状态，或者是第一层在时刻$t$的输入。如果nonlinearity='relu',那么将使用relu代替tanh作为激活函数。

参数说明:

  • input_size – 输入x的特征数量。
  • hidden_size – 隐层的特征数量。
  • num_layers – RNN的层数。
  • nonlinearity – 指定非线性函数使用tanh还是relu。默认是tanh。
  • bias – 如果是False，那么RNN层就不会使用偏置权重 $b_ih$和$b_hh$,默认是True
  • batch_first – 如果True的话，那么输入Tensor的shape应该是[batch_size, time_step, feature],输出也是这样。
  • dropout – 如果值非零，那么除了最后一层外，其它层的输出都会套上一个dropout层。
  • bidirectional – 如果True，将会变成一个双向RNN，默认为False。

RNN的输入： (input, h_0)

  • input (seq_len, batch, input_size): 保存输入序列特征的tensor。input可以是被填充的变长的序列。细节请看torch.nn.utils.rnn.pack_padded_sequence()
  • h_0 (num_layers * num_directions, batch, hidden_size): 保存着初始隐状态的tensor

RNN的输出： (output, h_n)

  • output (seq_len, batch, hidden_size * num_directions): 保存着RNN最后一层的输出特征。如果输入是被填充过的序列，那么输出也是被填充的序列。
  • h_n (num_layers * num_directions, batch, hidden_size): 保存着最后一个时刻隐状态。

RNN模型参数:

  • weight_ih_l[k] – 第k层的 input-hidden 权重， 可学习，形状是(input_size x hidden_size)。
  • weight_hh_l[k] – 第k层的 hidden-hidden 权重， 可学习，形状是(hidden_size x hidden_size)
  • bias_ih_l[k] – 第k层的 input-hidden 偏置， 可学习，形状是(hidden_size)
  • bias_hh_l[k] – 第k层的 hidden-hidden 偏置， 可学习，形状是(hidden_size)

示例：

rnn = nn.RNN(10, 20, 2)input = Variable(torch.randn(5, 3, 10))h0 = Variable(torch.randn(2, 3, 20))output, hn = rnn(input, h0)

class torch.nn.LSTM( args, * kwargs)[source]

将一个多层的 (LSTM) 应用到输入序列。

对输入序列的每个元素，LSTM的每层都会执行以下计算：

$$ \begin{aligned} it &= sigmoid(W{ii}xt+b{ii}+W{hi}h{t-1}+b{hi}) \ f_t &= sigmoid(W{if}xt+b{if}+W{hf}h{t-1}+b{hf}) \ o_t &= sigmoid(W{io}xt+b{io}+W{ho}h{t-1}+b{ho})\ g_t &= tanh(W{ig}xt+b{ig}+W{hg}h{t-1}+b{hg})\ c_t &= f_t*c{t-1}+i_tg_t\ h_t &= o_ttanh(c_t) \end{aligned}

$$ $h_t$是时刻$t$的隐状态,$c_t$是时刻$t$的细胞状态，$x_t$是上一层的在时刻$t$的隐状态或者是第一层在时刻$t$的输入。$i_t, f_t, g_t, o_t$ 分别代表 输入门，遗忘门，细胞和输出门。

参数说明:

  • input_size – 输入的特征维度
  • hidden_size – 隐状态的特征维度
  • num_layers – 层数（和时序展开要区分开）
  • bias – 如果为False，那么LSTM将不会使用$b{ih},b{hh}$，默认为True。
  • batch_first – 如果为True，那么输入和输出Tensor的形状为(batch, seq, feature)
  • dropout – 如果非零的话，将会在RNN的输出上加个dropout，最后一层除外。
  • bidirectional – 如果为True，将会变成一个双向RNN，默认为False。

LSTM输入: input, (h_0, c_0)

  • input (seq_len, batch, input_size): 包含输入序列特征的Tensor。也可以是packed variable ，详见 pack_padded_sequence
  • h_0 (num_layers * num_directions, batch, hidden_size):保存着batch中每个元素的初始化隐状态的Tensor
  • c_0 (num_layers * num_directions, batch, hidden_size): 保存着batch中每个元素的初始化细胞状态的Tensor

LSTM输出 output, (h_n, c_n)

  • output (seq_len, batch, hidden_size * num_directions): 保存RNN最后一层的输出的Tensor。 如果输入是torch.nn.utils.rnn.PackedSequence，那么输出也是torch.nn.utils.rnn.PackedSequence。
  • h_n (num_layers * num_directions, batch, hidden_size): Tensor，保存着RNN最后一个时间步的隐状态。
  • c_n (num_layers * num_directions, batch, hidden_size): Tensor，保存着RNN最后一个时间步的细胞状态。

LSTM模型参数:

  • weightihl[k] – 第k层可学习的input-hidden权重($W{ii}|W{if}|W{ig}|W{io}$)，形状为(input_size x 4*hidden_size)
  • weighthhl[k] – 第k层可学习的hidden-hidden权重($W{hi}|W{hf}|W{hg}|W{ho}$)，形状为(hidden_size x 4*hidden_size)。
  • biasihl[k] – 第k层可学习的input-hidden偏置($b{ii}|b{if}|b{ig}|b{io}$)，形状为( 4*hidden_size)
  • biashhl[k] – 第k层可学习的hidden-hidden偏置($b{hi}|b{hf}|b{hg}|b{ho}$)，形状为( 4*hidden_size)。 示例:

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

class torch.nn.GRU( args, * kwargs)[source]

将一个多层的GRU用于输入序列。

对输入序列中的每个元素，每层进行了一下计算：

$$ \begin{aligned} rt&=sigmoid(W{ir}xt+b{ir}+W{hr}h{(t-1)}+b{hr})\ it&=sigmoid(W{ii}xt+b{ii}+W{hi}h{(t-1)}+b{hi})\ n_t&=tanh(W{in}xt+b{in}+rt(W{hn}h{(t-1)}+b{hn}))\ h_t&=(1-i_t) nt+i_t*h(t-1) \end{aligned}

$$ $h_t$是是时间$t$的上的隐状态，$x_t$是前一层$t$时刻的隐状态或者是第一层的$t$时刻的输入，$r_t, i_t, n_t$分别是重置门，输入门和新门。

参数说明：

  • input_size – 期望的输入$x$的特征值的维度
  • hidden_size – 隐状态的维度
  • num_layers – RNN的层数。
  • bias – 如果为False，那么RNN层将不会使用bias，默认为True。
  • batch_first – 如果为True的话，那么输入和输出的tensor的形状是(batch, seq, feature)。
  • dropout – 如果非零的话，将会在RNN的输出上加个dropout，最后一层除外。
  • bidirectional – 如果为True，将会变成一个双向RNN，默认为False。

输入： input, h_0

  • input (seq_len, batch, input_size): 包含输入序列特征的Tensor。也可以是packed variable ，详见 pack_padded_sequence。
  • h_0 (num_layers * num_directions, batch, hidden_size):保存着batch中每个元素的初始化隐状态的Tensor

输出： output, h_n

  • output (seq_len, batch, hidden_size * num_directions): ten保存RNN最后一层的输出的Tensor。 如果输入是torch.nn.utils.rnn.PackedSequence，那么输出也是torch.nn.utils.rnn.PackedSequence。
  • h_n (num_layers * num_directions, batch, hidden_size): Tensor，保存着RNN最后一个时间步的隐状态。

变量：

  • weightih_l[k] – 第k层可学习的input-hidden权重($W{ir}|W{ii}|W{in}$)，形状为(input_size x 3*hidden_size)
  • weighthh_l[k] – 第k层可学习的hidden-hidden权重($W{hr}|W{hi}|W{hn}$)，形状为(hidden_size x 3*hidden_size)。
  • biasih_l[k] – 第k层可学习的input-hidden偏置($b{ir}|b{ii}|b{in}$)，形状为( 3*hidden_size)
  • biashh_l[k] – 第k层可学习的hidden-hidden偏置($b{hr}|b{hi}|b{hn}$)，形状为( 3*hidden_size)。

例子：

rnn = nn.GRU(10, 20, 2) input = Variable(torch.randn(5, 3, 10)) h0 = Variable(torch.randn(2, 3, 20)) output, hn = rnn(input, h0)

class torch.nn.RNNCell(input_size, hidden_size, bias=True, nonlinearity='tanh')[source]

一个 Elan RNN cell，激活函数是tanh或ReLU，用于输入序列。 将一个多层的 Elman RNNCell，激活函数为tanh或者ReLU，用于输入序列。

$$ h'=tanh(w{ih} x+b{ih}+w{hh} h+b{hh})

$$ 如果nonlinearity=relu，那么将会使用ReLU来代替tanh。

参数：

  • input_size – 输入$x$，特征的维度。
  • hidden_size – 隐状态特征的维度。
  • bias – 如果为False，RNN cell中将不会加入bias，默认为True。
  • nonlinearity – 用于选择非线性激活函数 [tanh|relu]. 默认值为： tanh

输入： input, hidden

  • input (batch, input_size): 包含输入特征的tensor。
  • hidden (batch, hidden_size): 保存着初始隐状态值的tensor。

输出： h’

  • h’ (batch, hidden_size):下一个时刻的隐状态。

变量：

  • weight_ih – input-hidden 权重， 可学习，形状是(input_size x hidden_size)。
  • weight_hh – hidden-hidden 权重， 可学习，形状是(hidden_size x hidden_size)
  • bias_ih – input-hidden 偏置， 可学习，形状是(hidden_size)
  • bias_hh – hidden-hidden 偏置， 可学习，形状是(hidden_size)

例子：

rnn = nn.RNNCell(10, 20)input = Variable(torch.randn(6, 3, 10))hx = Variable(torch.randn(3, 20))output = []for i in range(6): hx = rnn(input[i], hx) output.append(hx)

class torch.nn.LSTMCell(input_size, hidden_size, bias=True)[source]

LSTM cell。

$$ \begin{aligned} i &= sigmoid(W{ii}x+b{ii}+W{hi}h+b{hi}) \ f &= sigmoid(W{if}x+b{if}+W{hf}h+b{hf}) \ o &= sigmoid(W{io}x+b{io}+W{ho}h+b{ho})\ g &= tanh(W{ig}x+b{ig}+W{hg}h+b{hg})\ c' &= ft*c{t-1}+i_tg_t\ h' &= o_ttanh(c') \end{aligned}

$$

参数：

  • input_size – 输入的特征维度。
  • hidden_size – 隐状态的维度。
  • bias – 如果为False，那么将不会使用bias。默认为True。

LSTM输入: input, (h_0, c_0)

  • input (seq_len, batch, input_size): 包含输入序列特征的Tensor。也可以是packed variable ，详见 pack_padded_sequence
  • h_0 ( batch, hidden_size):保存着batch中每个元素的初始化隐状态的Tensor
  • c_0 (batch, hidden_size): 保存着batch中每个元素的初始化细胞状态的Tensor

输出： h_1, c_1

  • h_1 (batch, hidden_size): 下一个时刻的隐状态。
  • c_1 (batch, hidden_size): 下一个时刻的细胞状态。

LSTM模型参数:

  • weightih – input-hidden权重($W{ii}|W{if}|W{ig}|W_{io}$)，形状为(input_size x 4*hidden_size)
  • weighthh – hidden-hidden权重($W{hi}|W{hf}|W{hg}|W_{ho}$)，形状为(hidden_size x 4*hidden_size)。
  • biasih – input-hidden偏置($b{ii}|b{if}|b{ig}|b_{io}$)，形状为( 4*hidden_size)
  • biashh – hidden-hidden偏置($b{hi}|b{hf}|b{hg}|b_{ho}$)，形状为( 4*hidden_size)。

Examples:

rnn = nn.LSTMCell(10, 20)input = Variable(torch.randn(6, 3, 10))hx = Variable(torch.randn(3, 20))cx = Variable(torch.randn(3, 20))output = []for i in range(6): hx, cx = rnn(input[i], (hx, cx)) output.append(hx)

class torch.nn.GRUCell(input_size, hidden_size, bias=True)[source]

一个GRU cell。

$$ \begin{aligned} r&=sigmoid(W{ir}x+b{ir}+W{hr}h+b{hr})\ i&=sigmoid(W{ii}x+b{ii}+W{hi}h+b{hi})\ n&=tanh(W{in}x+b{in}+r(W{hn}h+b{hn}))\ h'&=(1-i) n+i*h \end{aligned}

$$

参数说明：

  • input_size – 期望的输入$x$的特征值的维度
  • hidden_size – 隐状态的维度
  • bias – 如果为False，那么RNN层将不会使用bias，默认为True。

输入： input, h_0

  • input (batch, input_size): 包含输入特征的Tensor
  • h_0 (batch, hidden_size):保存着batch中每个元素的初始化隐状态的Tensor

输出： h_1

  • h_1 (batch, hidden_size): Tensor，保存着RNN下一个时刻的隐状态。

变量：

  • weightih – input-hidden权重($W{ir}|W{ii}|W{in}$)，形状为(input_size x 3*hidden_size)
  • weighthh – hidden-hidden权重($W{hr}|W{hi}|W{hn}$)，形状为(hidden_size x 3*hidden_size)。
  • biasih – input-hidden偏置($b{ir}|b{ii}|b{in}$)，形状为( 3*hidden_size)
  • biashh – hidden-hidden偏置($b{hr}|b{hi}|b{hn}$)，形状为( 3*hidden_size)。

例子：

rnn = nn.GRUCell(10, 20)input = Variable(torch.randn(6, 3, 10))hx = Variable(torch.randn(3, 20))output = []for i in range(6): hx = rnn(input[i], hx) output.append(hx)

results matching ""

    No results matching ""