python基础学习（7）

1. nn.LSTM：
   1. 可以直接构建若干层的LSTM，构造时传入的三个参数和nn.RNN一样，依次是：[feature_len,hidden_len,num_layers]，其中hidden_len既用于隐藏状态h_t的尺寸，也用于记忆单元C_t的尺寸。实际上，两者的shape是一样的，都是[num_layers,batch,hidden_len]。
   2. nn.LSTM的forward函数（相比rnn，需要多提供初始的c_0,并最终多得到一个c_t）：

      out,(h_t ,C_t)=lstm(x,(h_0 ,C_0))

       
      1. x仍然是一次性将当前batch所有seq_len个时刻的样本都输入，其shape是[seq_len,batch,feature_len]。
      2. 在任意t时刻的h_t和C_t两类Memory其shape都是[num_layers,batch,hidden_len]。
      3. 最终的输出out同样是在所有时刻最后一层上的输出（特别注意，LSTM中的输出是h不是C），因此是将feature_len规约成了hidden_len那么长，所以其shape是[seq_len,batch,hidden_len]。
   3. 例子：

      # 如可以解释成:4层的LSTM,输入的每个词用100维向量表示,隐藏单元和记忆单元的尺寸是20
      lstm = nn.LSTM(input_size=100, hidden_size=20, num_layers=4)
      # 前向计算过程,这里不传入h_0和C_0则会默认初始化
      out, (h, c) = lstm(x)

2. nn.LSTMCell：
   1. 该模块构建LSTM中的一个Cell，同一层会共享这一个Cell，但要手动处理每个时刻的迭代计算过程。如果要建立多层的LSTM，就要建立多个nn.LSTMCell。
   2. 构造方法：和nn.LSTM类似，依次传入feature_len和hidden_len，因为这只是一个计算单元，所以不涉及层数。
   3. forward函数：

      h_t ,C_t=lstmcell(x_t ,(h_(t−1) ,C_(t−1)))

       
      1. 输入x_t只是t时刻的输入，不涉及seq_len，所以其shape是[batch,feature_len]。
      2. h_t和C_t在这里只是t时刻本层的隐藏单元和记忆单元，不涉及num_layers，所以其shape是[batch,hidden_len]。
   4. 构建：
      1. 一层：

         # 一层的LSTM计算单元,输入的feature_len=100,隐藏单元和记忆单元hidden_len=20
         cell = nn.LSTMCell(input_size=100, hidden_size=20)
         
         # 初始化隐藏单元h和记忆单元C,取batch=3
         h = torch.zeros(3, 20)
         C = torch.zeros(3, 20)
         
         # 这里是seq_len=10个时刻的输入,每个时刻shape都是[batch,feature_len]
         xs = [torch.randn(3, 100) for _ in range(10)]
         
         # 对每个时刻,传入输入x_t和上个时刻的h_{t-1}和C_{t-1}
         for xt in xs:
             h, C = cell(xt, (h, C))

      2. 两层：

         # 输入的feature_len=100,变到该层隐藏单元和记忆单元hidden_len=30
         cell_l0 = nn.LSTMCell(input_size=100, hidden_size=30)
         # hidden_len从l0层的30变到这一层的20
         cell_l1 = nn.LSTMCell(input_size=30, hidden_size=20)
         
         # 分别初始化l0层和l1层的隐藏单元h和记忆单元C,取batch=3
         # 注意l0层的hidden_len=30
         h_l0 = torch.zeros(3, 30)
         C_l0 = torch.zeros(3, 30)
         # 而到l1层之后hidden_len=20
         h_l1 = torch.zeros(3, 20)
         C_l1 = torch.zeros(3, 20)
         
         # 这里是seq_len=10个时刻的输入,每个时刻shape都是[batch,feature_len]
         xs = [torch.randn(3, 100) for _ in range(10)]
         
         # 对每个时刻,从下到上计算本时刻的所有层
         for xt in xs:
             h_l0, C_l0 = cell_l0(xt, (h_l0, C_l0))  # l0层直接接受xt输入
             h_l1, C_l1 = cell_l1(h_l0, (h_l1, C_l1))  # l1层接受l0层的输出h为输入