# coding=UTF-8
import torch
import torch.autograd as autograd  # torch中自動(dòng)計(jì)算梯度模塊
import torch.nn as nn  # 神經(jīng)網(wǎng)絡(luò)模塊
torch.manual_seed(1)
# lstm單元輸入和輸出維度都是3
lstm = nn.LSTM(input_size=3, hidden_size=3)
# 生成一個(gè)長(zhǎng)度為5，每一個(gè)元素為1*3的序列作為輸入，這里的數(shù)字3對(duì)應(yīng)于上句中第一個(gè)3
inputs = [autograd.Variable(torch.randn((1, 3)))
 for _ in range(5)]
# 設(shè)置隱藏層維度，初始化隱藏層的數(shù)據(jù)
hidden = (autograd.Variable(torch.randn(1, 1, 3)),
 autograd.Variable(torch.randn((1, 1, 3))))
for i in inputs:
  out, hidden = lstm(i.view(1, 1, -1), hidden)
  print(out.size())
  print(hidden[0].size())
  print("--------")
print("-----------------------------------------------")
# 下面是一次輸入多個(gè)step的樣子
inputs_stack = torch.stack(inputs)
out,hidden = lstm(inputs_stack,hidden)
print(out.size())
print(hidden[0].size())

import torch
import torch.nn as nn
 
lstm = nn.LSTM(10, 20, 2)
 
# 序列長(zhǎng)度seq_len=5, batch_size=3, 數(shù)據(jù)向量維數(shù)=10
input = torch.randn(5, 3, 10)
 
# 初始化的隱藏元和記憶元,通常它們的維度是一樣的
# 2個(gè)LSTM層，batch_size=3,隱藏元維度20
h0 = torch.randn(2, 3, 20)
c0 = torch.randn(2, 3, 20)
 
# 這里有2層lstm，output是最后一層lstm的每個(gè)詞向量對(duì)應(yīng)隱藏層的輸出,其與層數(shù)無(wú)關(guān)，只與序列長(zhǎng)度相關(guān)
# hn,cn是所有層最后一個(gè)隱藏元和記憶元的輸出
output, (hn, cn) = lstm(input, (h0, c0))
 
print(output.size(),hn.size(),cn.size())
 
# 分別是：
# torch.Size([5, 3, 20])
# torch.Size([2, 3, 20])
# torch.Size([2, 3, 20]))

class LSTM(RNNBase):

 '''參數(shù)Args:
  input_size: 輸入數(shù)據(jù)的特征維度，比如我對(duì)時(shí)間序列建模，特征為1，我對(duì)一個(gè)句子建模，每一個(gè)單詞的嵌入向量為10，則它為10
  
  hidden_size: 即循環(huán)神經(jīng)網(wǎng)絡(luò)中隱藏節(jié)點(diǎn)的個(gè)數(shù)，這個(gè)是自己定義的，多少都可以，后面會(huì)詳說(shuō)
  
  num_layers: 堆疊的LSTM的層數(shù)，默認(rèn)是一層，也可以自己定義 Default: 1
  bias: LSTM層是否使用偏置矩陣 偏置權(quán)值為 `b_ih` and `b_hh`.
Default: ``True``（默認(rèn)是使用的）
  
  batch_first: 如果設(shè)置 ``True``, then the input and output tensors are provided
as (batch, seq, feature). Default: ``False``，(seq,batch,features)
  dropout: 是否使用dropout機(jī)制，默認(rèn)是0，表示不使用dropout，如果提供一個(gè)非0的數(shù)字，則表示在每一個(gè)LSTM層之后默認(rèn)使用dropout，但是最后一個(gè)層的LSTM層不使用dropout。
  
  bidirectional: 是否是雙向RNN，默認(rèn)是否，If ``True``, becomes a bidirectional LSTM. Default: ``False``
#---------------------------------------------------------------------------------------
 類的構(gòu)造函數(shù)的輸入為Inputs: input, (h_0, c_0)
  - **input** of shape `(seq_len, batch, input_size)`: tensor containing the features of the input sequence.
 
  - **h_0** of shape `(num_layers * num_directions, batch, hidden_size)`: tensor
 containing the initial hidden state for each element in the batch.
 If the LSTM is bidirectional, num_directions should be 2, else it should be 1.
  - **c_0** of shape `(num_layers * num_directions, batch, hidden_size)`: tensor
 containing the initial cell state for each element in the batch.
 If `(h_0, c_0)` is not provided, both **h_0** and **c_0** default to zero.
#----------------------------------------------------------------------------------
 輸出是什么：Outputs: output, (h_n, c_n)
  - **output** of shape `(seq_len, batch, num_directions * hidden_size)`: tensor
 containing the output features `(h_t)` from the last layer of the LSTM,
 for each `t`. If a :class:`torch.nn.utils.rnn.PackedSequence` has been
 given as the input, the output will also be a packed sequence.
 For the unpacked case, the directions can be separated
 using ``output.view(seq_len, batch, num_directions, hidden_size)``,
 with forward and backward being direction `0` and `1` respectively.
 Similarly, the directions can be separated in the packed case.
  
  - **h_n** of shape `(num_layers * num_directions, batch, hidden_size)`: tensor
 containing the hidden state for `t = seq_len`.
 Like *output*, the layers can be separated using
 ``h_n.view(num_layers, num_directions, batch, hidden_size)`` and similarly for *c_n*.
  
  - **c_n** of shape `(num_layers * num_directions, batch, hidden_size)`: tensor
 containing the cell state for `t = seq_len`.
#------------------------------------------------------------------------------------------
 類的屬性有Attributes:
  weight_ih_l[k] : the learnable input-hidden weights of the :math:`\text{k}^{th}` layer
`(W_ii|W_if|W_ig|W_io)`, of shape `(4*hidden_size, input_size)` for `k = 0`.
Otherwise, the shape is `(4*hidden_size, num_directions * hidden_size)`
  weight_hh_l[k] : the learnable hidden-hidden weights of the :math:`\text{k}^{th}` layer
`(W_hi|W_hf|W_hg|W_ho)`, of shape `(4*hidden_size, hidden_size)`
  bias_ih_l[k] : the learnable input-hidden bias of the :math:`\text{k}^{th}` layer
`(b_ii|b_if|b_ig|b_io)`, of shape `(4*hidden_size)`
  bias_hh_l[k] : the learnable hidden-hidden bias of the :math:`\text{k}^{th}` layer
`(b_hi|b_hf|b_hg|b_ho)`, of shape `(4*hidden_size)`
 '''

lstm = nn.LSTM(10, 20, 2)

class LSTM(RNNBase):

 '''參數(shù)Args:
  input_size:
  hidden_size:
  num_layers: 
  bias: 
  batch_first: 
  dropout: 
  bidirectional:
 '''

output, (hn, cn) = lstm(input, (h0, c0))

output, hn = rnn(input, h0)  # 普通rnn
output, hn = gru(input, h0)  # gru

output, hn = rnn(input, h0)  # 普通rnn
output, hn = gru(input, h0)  # gru
output, (hn, cn) = lstm(input, (h0, c0)) # lstm

# 首先導(dǎo)入RNN需要的相關(guān)模塊
import torch
import torch.nn as nn
 
# 數(shù)據(jù)向量維數(shù)10, 隱藏元維度20, 2個(gè)RNN層串聯(lián)(如果是1，可以省略，默認(rèn)為1)
rnn = nn.RNN(10, 20, 2)
 
# 序列長(zhǎng)度seq_len=5, batch_size=3, 數(shù)據(jù)向量維數(shù)=10
input = torch.randn(5, 3, 10)
 
# 初始化的隱藏元和記憶元,通常它們的維度是一樣的
# 2個(gè)RNN層，batch_size=3,隱藏元維度20
h0 = torch.randn(2, 3, 20)
 
# 這里有2層RNN，output是最后一層RNN的每個(gè)詞向量對(duì)應(yīng)隱藏層的輸出,其與層數(shù)無(wú)關(guān)，只與序列長(zhǎng)度相關(guān)
# hn,cn是所有層最后一個(gè)隱藏元和記憶元的輸出
output, hn = rnn(input, h0)
 
print(output.size(),hn.size()) # 分別是：torch.Size([5, 3, 20])torch.Size([2, 3, 20])
 
# 查看一下那幾個(gè)重要的屬性：
print("------------輸入--》隱藏------------------------------")
print(rnn.weight_ih_l0.size())  
print(rnn.weight_ih_l1.size())
print(rnn.bias_ih_l0.size())
print(rnn.bias_ih_l1.size())
print("------------隱藏--》隱藏------------------------------")
print(rnn.weight_hh_l0.size())  
print(rnn.weight_hh_l1.size())
print(rnn.bias_hh_l0.size())
print(rnn.bias_hh_l1.size())
 
'''輸出結(jié)果為：
------------輸入--》隱藏------------------------------
torch.Size([20, 10])
torch.Size([20, 20])
torch.Size([20])
torch.Size([20])
------------隱藏--》隱藏------------------------------
torch.Size([20, 20])
torch.Size([20, 20])
torch.Size([20])
torch.Size([20])
'''