pytorch lstm gru rnn 에서 모든 state 출력 을 얻 는 작업

기본 값 은 마지막 state 만 되 돌아 가기 때문에 한 번 에 step 의 input 를 입력 합 니 다.

# coding=UTF-8
import torch
import torch.autograd as autograd  # torch         
import torch.nn as nn  #       
torch.manual_seed(1)
# lstm           3
lstm = nn.LSTM(input_size=3, hidden_size=3)
#        5，      1*3       ，     3         3
inputs = [autograd.Variable(torch.randn((1, 3)))
          for _ in range(5)]
#        ，         
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("-----------------------------------------------")
#          step   
inputs_stack = torch.stack(inputs)
out,hidden = lstm(inputs_stack,hidden)
print(out.size())
print(hidden[0].size())

print 결과:
(1L, 1L, 3L)
(1L, 1L, 3L)
--------
(1L, 1L, 3L)
(1L, 1L, 3L)
--------
(1L, 1L, 3L)
(1L, 1L, 3L)
--------
(1L, 1L, 3L)
(1L, 1L, 3L)
--------
(1L, 1L, 3L)
(1L, 1L, 3L)
--------
----------------------------------------------
(5L, 1L, 3L)
(1L, 1L, 3L)
이 를 통 해 알 수 있 듯 이 LSTM 의 정 의 는 변 하지 않 습 니 다.input 의 step 수 에 따라 한 번 에 step 를 입력 하 는 만큼 한 번 에 출력 하 는 만큼 output 이지 만 마지막 state 만 출력 합 니 다.
보충:pytorch 에서 순환 신경 망 을 실현 하 는 기본 유닛 RNN,LSTM,GRU 의 입 출력,파라미터 에 대한 상세 한 이해
앞에서 말 했 듯 이 이 글 은 RNN,LSTM,GRU 의 수학 원리 와 연산 과정 을 비교적 깊이 이해 한 사람 에 게 있어 서 그의 기본 사상 과 과정 을 이해 하지 못 하면 이해 하기 가 쉽 지 않 을 것 이다.
첫째,실례 부터 본다
홈 페이지 위의 한 예 로,이번 LSTM 를 예 로 들 면 실제로 GRU,LSTM,RNN 의 연산 과정 은 매우 유사 하 다.

import torch
import torch.nn as nn
 
lstm = nn.LSTM(10, 20, 2)
 
#     seq_len=5, batch_size=3,       =10
input = torch.randn(5, 3, 10)
 
#            ,           
# 2 LSTM ，batch_size=3,     20
h0 = torch.randn(2, 3, 20)
c0 = torch.randn(2, 3, 20)
 
#    2 lstm，output     lstm              ,      ，        
# hn,cn                  
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]))

뒤에 나 는 위의 연산 과정 을 상세 하 게 설명 할 것 이다.우 리 는 먼저 LSTM 의 정 의 를 살 펴 보 자.그것 은 하나의 유형 이다.
2.LSTM 류 의 정의

class LSTM(RNNBase):
   
    '''  Args:
        input_size:          ，          ，   1，        ，           10，   10
        
        hidden_size:                ，        ，     ，     
        
        num_layers:    LSTM   ，     ，        Default: 1
        bias: LSTM                `b_ih` and `b_hh`.
            Default: ``True``（      ）
        
        batch_first:      ``True``, then the input and output tensors are provided
            as (batch, seq, feature). Default: ``False``，(seq,batch,features)
        dropout:     dropout  ，   0，     dropout，       0   ，       LSTM       dropout，        LSTM    dropout。
        
        bidirectional:      RNN，    ，If ``True``, becomes a bidirectional LSTM. Default: ``False``
#---------------------------------------------------------------------------------------
              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)`
    '''

위의 매개 변수 가 좀 많 기 때문에 나 는 하나하나 번역 하지 않 았 다.사실은 이해 하기 쉽 고 하나하나 가 비교적 뚜렷 하 다.
3.필수 매개 변수 에 대한 깊이 있 는 이해
1.RNN,GRU,LSTM 의 구조 함수 의 세 가지 필수 매개 변수 이해―첫 번 째 단계:구조 순환 층 대상
순환 층 을 만 들 때 첫 번 째 단 계 는 구조 순환 층 입 니 다.다음 과 같 습 니 다.

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

구조 함수 의 매개 변수 목록 은 다음 과 같 습 니 다.

class LSTM(RNNBase):
   
    '''  Args:
        input_size:
        hidden_size:         
        num_layers: 
        bias:       
        batch_first: 
        dropout: 
        bidirectional:
    '''

（1）input_size:모든 단어의 특징 차원 을 말 합 니 다.예 를 들 어 저 는 문장 이 있 습 니 다.문장의 모든 단 어 는 10 차원 벡터 로 표시 하면 inputsize 는 10;
（2）hidden_size:순환 층 의 모든 LSTM 내부 단원 의 숨겨 진 노드 수 를 말 합 니 다.이것 은 자신 이 정의 한 것 이 므 로 마음대로 설정 해도 됩 니 다.
（3）num_layers:순환 층 의 층수,기본 값 은 1 층 입 니 다.이것 은 자신의 상황 에 따라 결 정 됩 니 다.
예 를 들 어 아래:


왼쪽 은 한 층 의 순환 층 만 있 고 오른쪽 은 두 층 의 순환 층 이 있다.
2.첫 번 째 구조의 대상 구 조 를 통 해 전 파 된 과정-두 번 째 단계:순환 층 대상 을 호출 하여 파 라 메 터 를 전달 하고 반환 값 을 얻는다.
일반적으로 다음 작업:

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

여 기 는 LSTM 를 예 로 들 면,
(1)입력 매개 변수
input:이러한 형식(seq,batch,feature)이 어야 합 니 다.첫 번 째 seq 는 서열 의 길 이 를 말 합 니 다.이것 은 자신의 데이터 에 따라 정 한 것 입 니 다.예 를 들 어 제 문장의 가장 큰 길 이 는 20 개의 단어 로 구성 되 는데 여기 가 20 입 니 다.위의 예 는 문장의 길 이 를 5 로 가정 하 는 것 입 니 다.두 번 째 는 batch 입 니 다.이것 은 이해 하기 쉽 습 니 다.바로 한 번 에 몇 개의 견본 을 사용 하 는 것 입 니 다.예 를 들 어 3 조 의 견본 입 니 다.세 번 째 features 는 모든 단어의 벡터 차원 을 말 합 니 다.주의해 야 할 것 은 구조 함수 의 첫 번 째 매개 변수 inputsize 는 같은 것 을 유지 합 니 다.위의 예 는 10 입 니 다.
(h0,c0):모든 순환 층 의 초기 상 태 를 말 합 니 다.지정 하지 않 고 모두 0 으로 초기 화 할 수 있 습 니 다.여 기 는 LSTM 이 므 로 전달 해 야 할 두 가지 상태 가 있 습 니 다.일반적인 RNN 과 GRU 는 한 가지 상태 만 전달 하고 h 상태 만 전달 하면 됩 니 다.다음 과 같 습 니 다.

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

여기 서 주의해 야 할 것 은 들 어 오 는 상태 매개 변수의 차원 입 니 다.LSTM 로 말 하면:
h0 과 c0 의 데이터 차원 은 모두(numlayers * num_directions, batch, hidden_size),이게 무슨 뜻 이 죠?
첫번째 numlayer 는 기층 순환 층 이 있 는 지 이해 하기 쉽 고 몇 층 에 몇 개의 초기 상태 가 있어 야 합 니 다.
두 번 째 numdirections 는 이 순환 층 이 양 방향 인지(구조 함수 에서 bidirectional 매개 변 수 를 통 해 지정 합 니 다)를 말 합 니 다.양 방향 이 아니라면 값 을 1 로 하고 양 방향 이면 값 을 2 로 합 니 다.
세 번 째 batch 는 매번 데이터 의 batch 를 말 하 며 앞의 batch 와 일치 하면 됩 니 다.
마지막 hiddensize 는 순환 층 의 모든 노드 내부 에 숨겨 진 노드 수 를 말 하 는데 이것 은 순환 신경 망 의 전체 연산 절 차 를 잘 이해 해 야 합 니 다!
(2)출력 결과
사실 출력 결과 와 입력 은 일치 합 니 다.각각 다음 과 같 습 니 다.

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

여 기 는 여전히 lstm 로 말 하면:
output 의 출력 차원:(seqlen, batch, num_directions * hidden_size),위의 예 에서(5,3,20)이 어야 합 니 다.우 리 는 검증 을 통 해 확실히 이와 같 습 니 다.주의해 야 할 것 은 첫 번 째 차원 은 seq 입 니 다.len,즉 모든 시간 대의 출력 은 출력 결과 로 서 숨겨 진 층 과 다르다.
hn,cn 의 출력 차원:(numlayers * num_directions, batch, hidden_size),위의 예 에서(2,3,20)로 검증 되 었 습 니 다.우 리 는 이 순서 길이 seq 를 발 견 했 습 니 다.len 은 괜 찮 습 니 다.왜 일 까요?출력 상 태 는 마지막 순환 층 노드 출력 상 태 를 말 합 니 다.
다음 그림 에서 보 듯 이:
아래 의 예 는 일반적인 RNN 으로 그 렸 기 때문에 하나의 상태 h 만 있 고 상태 c 가 없다.

3.몇 가지 중요 한 속성 이해
RNN 이 든 GRU 든 lstm 이 든 내부 에서 배 울 수 있 는 매개 변 수 는 몇 개의 가중치 행렬 이 고 편향 행렬 을 포함 합 니 다.그러면 배 운 매개 변 수 를 어떻게 봅 니까?바로 이 몇 개의 행렬 을 통 해 이 루어 진 것 이다.
（1）weight_ih_l[k]:이것 은 숨겨 진 층 사이 에 입력 한 값 행렬 을 나타 내 는데 그 중에서 K 가 표시 하 는 몇 번 째 순환 층 을 나타 낸다.
K=0 이면 맨 아래 입력 층 에서 첫 번 째 순환 층 사이 의 행렬 을 나타 내 고 차원 은(hiddensize, input_size),만약 k>0 은 첫 번 째 순환 층 에서 두 번 째 순환 층,두 번 째 순환 층 에서 세 번 째 순환 층 을 나타 낸다.이런 식 으로 유추 하면 사이 의 가중치 행렬,모양 은(hiddensize, num_directions * hidden_size)。
（2）weight_hh_l[k]:순환 층 내부 간 의 가중치 행렬 을 나타 내 는데 여기 K 가 나타 내 는 몇 번 째 순환 층 은 0,1,2,3,4......................................................형태:(hiddensize, hidden_size)
주의:순환 층 의 층수 수 수 치 는 0 에서 시작 되 고 0 은 첫 번 째 순환 층 을 대표 하 며 1 은 두 번 째 순환 층 을 대표 하여 유추 합 니 다.
（3）bias_ih_l[k]:K 번 째 순환 층 의 편향 항목 은 순환 층 사이 에 입력 한 편향,차원(hiddensize)
（4）bias_hh_l[k]:K 번 째 순환 층 의 편향 항 은 순환 층 에서 순환 층 내부 사이 의 편향 을 나타 내 고 차원 은(hiddensize)。

#     RNN       
import torch
import torch.nn as nn
 
#       10,      20, 2 RNN   (   1，    ，   1)
rnn = nn.RNN(10, 20, 2)
 
#     seq_len=5, batch_size=3,       =10
input = torch.randn(5, 3, 10)
 
#            ,           
# 2 RNN ，batch_size=3,     20
h0 = torch.randn(2, 3, 20)
 
#    2 RNN，output     RNN              ,      ，        
# hn,cn                  
output, hn = rnn(input, h0)
 
print(output.size(),hn.size()) #    ：torch.Size([5, 3, 20])   torch.Size([2, 3, 20])
 
#             ：
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())
 
'''     ：
------------  --》  ------------------------------
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])
'''

위의 연산 을 통 해 결과 와 묘사 가 똑 같은 것 을 발견 하 였 다.
이상 은 개인 적 인 경험 이 므 로 여러분 에 게 참고 가 되 기 를 바 랍 니 다.여러분 들 도 저 희 를 많이 응원 해 주시 기 바 랍 니 다.