目標

這個階段會給cute-dl添加回圈層，使之能夠支持RNN--回圈神經網路. 具體目標包括:

添加激活函式sigmoid, tanh.
添加GRU(Gate Recurrent Unit)實作.
添加LSTM(Long Short-term Memory)實作.
使用基于GRU和LSTM的RNN模型擬合一個正余弦疊加函式.

RNN原理

原始的RNN

RNN模型用來捕捉序列資料的特征. 給定一個長度為T的輸入系列\(X=(x_1, x_2, .., X_T)\), RNN層輸出一個長度為T的序列\(H=(h_1, h_2, ..., H_T)\), 對于任意時間步t, 可以表示為:

\[H_t = δ(X_tW_x + H_{t-1}W_h + b), \quad t = 2, 3, .., T \]

函式δ是sigmoid函式:

\[δ = \frac{1}{1 + e^{-x}} \]

\(H_t\)包含了前面第1到t-1步的所有資訊，和CNN層類似, CNN層在空間上共享引數， RNN層在時間步上共享引數\(W_x, W_h, b\).

RNN層中隱藏層的數量為T-2, 如果T較大(超過10), 反向傳播是很容易出現梯度爆炸. GRU和LSTM就是為了解決這個問題而誕生, 這兩種模型，可以讓RNN能夠支持長度超過1000的輸入序列，

GRU

GRU使用了不同功能的門控單元, 分別捕捉序列上不同時間跨度的的依賴關系，每個門控單元都會都有獨立的引數, 這些引數在時間步上共享，

GRU的門控單元有:

\(R_t = δ(X_tW^r_x + H_{t-1}W^r_h + b^r)\), 重置門用于捕捉短期依賴關系.

\(U_t = δ(X_tW^u_x + H_{t-1}W^u_h + b^u)\), 更新門用于捕捉長期依賴關系

\(\bar{H}_t = tanh(X_t\bar{W}_x + (R_t * H_{t-1})\bar{W}_h + \bar{b})\)

除此之外, 還有一個輸出單元:

\(H_t = U_t * H_{t-1} + (1-U_t)*\bar{H}_t\)

LSTM

LSTM的設計思路和GRU類似, 同樣使用了多個門控單元:

\(I_t = δ(X_tW^i_x + H_{t-1}W^i_h + b^i)\), 輸入門，過濾記憶門的輸出.

\(F_t = δ(X_tW^f_x + H_{t-1}W^f_h + b^f)\), 遺忘門, 過濾前面時間步的記憶.

\(O_t = δ(X_tW^o_x + H_{t-1}W^o_h + b^o)\), 輸出門, 過濾當前時間步的記憶.

\(M_t = tanh(X_tW^m_x + H_{t-1}W^m_h + b^m)\), 記憶門.

它還有自己獨有的記憶單元和輸出單元:

\(\bar{M}_t = F_t * \bar{M}_{t-1} + I_t * M_t\)

\(H_t = O_t * tanh(\bar{M}_t)\)

RNN實作

設計要求:

RNN層中的隱藏層的數量是基于序列長度的，輸入序列有多長, RNN層應生成對應數量的隱藏層，
RNN層在時間步上共享引數, 從前面的描述可以看出, 只有門控單元有引數，因此門控單元應獨立實作，
任意一個時間步上的層都依賴上一個時間步的輸出，在正向傳播和反向傳播程序中都需要上一個時間步的輸出, 每個門控單元都使用堆疊保存上一個時間步的輸出.
默認情況下RNN層輸出所有時間步的輸出，但有時只需要最后一個時間步的輸出, 這種情況下使用過濾層, 只向下一層傳播最后一個時間步的輸出，
使用門控單元實作GRU和LSTM

RNN基礎類的實作

RNN類

檔案: cutedl/rnn_layers.py, 類名: RNN

這個類是RNN層基類, 它主要功能是控制向前傳播和向后傳播的主流程.

初始化引數:

  '''
  out_units 輸出單元數
  in_units 輸入單元數
  stateful 保留當前批次的最后一個時間步的狀態作為下一個批次的輸入狀態, 默認False不保留

  RNN 的輸入形狀是(m, t, in_units)
  m: batch_size
  t: 輸入系列的長度
  in_units: 輸入單元數頁是輸入向量的維數

  輸出形狀是(m, t, out_units)
  '''
  def __init__(self, out_units, in_units=None, stateful=False, activation='linear'):

向前傳播

def forward(self, in_batch, training):
    m, T, n = in_batch.shape
    out_units = self.__out_units
    #所有時間步的輸出
    hstatus = np.zeros((m, T, out_units))
    #上一步的輸出
    pre_hs = self.__pre_hs
    if pre_hs is None:
        pre_hs = np.zeros((m, out_units))

    #隱藏層回圈程序, 沿時間步執行
    for t in range(T):
        hstatus[:, t, :] = self.hiden_forward(in_batch[:,t,:], pre_hs, training)
        pre_hs = hstatus[:, t, :]

    self.__pre_hs = pre_hs
    #pdb.set_trace()
    if not self.stateful:
        self.__pre_hs = None

    return hstatus

反向傳播

def backward(self, gradient):
      m, T, n = gradient.shape

      in_units = self.__in_units
      grad_x = np.zeros((m, T, in_units))
      #pdb.set_trace()
      #從最后一個梯度開始反向執行.
      for t in range(T-1, -1, -1):
          grad_x[:,t,:], grad_hs = self.hiden_backward(gradient[:,t,:])
          #pdb.set_trace()
          if t - 1 >= 0:
              gradient[:,t-1,:] = gradient[:,t-1,:] + grad_hs

      #pdb.set_trace()
      return grad_x

sigmoid和tanh激活函式

sigmoid及其導數

\[sigmoid = \frac{1}{1+e^{-x}} \]

\[\frac{d}{dx}sigmoid = sigmoid(1-sigmoid) \]

tanh及其導數

\[tanh = \frac{e^x - e^{-x}}{e^x + e^{-x}} \]

\[\frac{d}{dx}tanh = 1 - tanh^2 \]

門控單元實作

檔案: cutedl/rnn_layers.py, 類名: GateUint

門控單元是RNN層基礎的引數單元. 和Dense層類似，它是Layer的子類，負責學習和使用引數，但在學習和使用引數的方式上有很大的不同:

Dense有兩個引數矩陣, GateUnit有3個引數矩陣.
Dense在一次反向傳播程序中只使用當前的梯度學習引數，而GateUnit會累積每個時間步的梯度，

下面我們會主要看一下GateUnit特別之處的代碼.

在__ init__方法中定義引數和堆疊:

    #3個引數
    self.__W = None #當前時間步in_batch權重引數
    self.__Wh = None #上一步輸出的權重引數
    self.__b = None #偏置量引數

    #輸入堆疊
    self.__hs = []  #上一步輸出
    self.__in_batchs = [] #當前時間步的in_batch

正向傳播：

  def forward(self, in_batch, hs, training):
      W = self.__W.value
      b = self.__b.value
      Wh = self.__Wh.value

      out = in_batch @ W + hs @ Wh + b

      if training:
          #向前傳播訓練時把上一個時間步的輸出和當前時間步的in_batch壓堆疊
          self.__hs.append(hs)
          self.__in_batchs.append(in_batch)

          #確保反向傳播開始時引數的梯度為空
          self.__W.gradient = None
          self.__Wh.gradient = None
          self.__b.gradient = None

      return self.activation(out)

反向傳播:

def backward(self, gradient):
    grad = self.activation.grad(gradient)

    W = self.__W.value
    Wh = self.__Wh.value
    pre_hs = self.__hs.pop()
    in_batch = self.__in_batchs.pop()

    grad_in_batch = grad @ W.T
    grad_W = in_batch.T @ grad
    grad_hs = grad @ Wh.T
    grad_Wh = pre_hs.T @ grad
    grad_b = grad.sum(axis=0)

    #反向傳播計算
    if self.__W.gradient is None:
        #當前批次第一次
        self.__W.gradient = grad_W
    else:
        #累積當前批次的所有梯度
        self.__W.gradient = self.__W.gradient + grad_W

    if self.__Wh.gradient is None:
        self.__Wh.gradient = grad_Wh
    else:
        self.__Wh.gradient = self.__Wh.gradient +  grad_Wh

    if self.__b.gradient is None:
        self.__b.gradient = grad_b
    else:
        self.__b.gradient = self.__b.gradient + grad_b

    return grad_in_batch, grad_hs

GRU實作

檔案: cutedl/rnn_layers.py, 類名: GRU

隱藏單初始化:

def set_parent(self, parent):
    super().set_parent(parent)

    out_units = self.out_units
    in_units = self.in_units

    #pdb.set_trace()
    #重置門
    self.__g_reset = GateUnit(out_units, in_units)
    #更新門
    self.__g_update = GateUnit(out_units, in_units)
    #候選輸出門
    self.__g_cddout = GateUnit(out_units, in_units, activation='tanh')

    self.__g_reset.set_parent(self)
    self.__g_update.set_parent(self)
    self.__g_cddout.set_parent(self)

    #重置門乘法單元
    self.__u_gr = MultiplyUnit()
    #輸出單元
    self.__u_out = GRUOutUnit()

向前傳播:

  def hiden_forward(self, in_batch, pre_hs, training):
      gr = self.__g_reset.forward(in_batch, pre_hs, training)
      gu = self.__g_update.forward(in_batch, pre_hs, training)
      ugr = self.__u_gr.forward(gr, pre_hs, training)
      cddo = self.__g_cddout.forward(in_batch, ugr, training)

      hs = self.__u_out.forward(gu, pre_hs, cddo, training)

      return hs

反向傳播:

def hiden_backward(self, gradient):

    grad_gu, grad_pre_hs, grad_cddo = self.__u_out.backward(gradient)
    #pdb.set_trace()
    grad_in_batch, grad_ugr = self.__g_cddout.backward(grad_cddo)

    #計算梯度的程序中需要累積上一層輸出的梯度
    grad_gr, g_pre_hs = self.__u_gr.backward(grad_ugr)
    grad_pre_hs = grad_pre_hs + g_pre_hs

    g_in_batch, g_pre_hs = self.__g_update.backward(grad_gu)
    grad_in_batch = grad_in_batch + g_in_batch
    grad_pre_hs = grad_pre_hs + g_pre_hs

    g_in_batch, g_pre_hs = self.__g_reset.backward(grad_gr)
    grad_in_batch = grad_in_batch + g_in_batch
    grad_pre_hs = grad_pre_hs + g_pre_hs

    #pdb.set_trace()
    return grad_in_batch, grad_pre_hs

LSTM實作

檔案: cutedl/rnn_layers.py, 類名: LSTM

隱藏單元初始化:

def set_parent(self, layer):
    super().set_parent(layer)

    in_units = self.in_units
    out_units = self.out_units

    #輸入門
    self.__g_in = GateUnit(out_units, in_units)
    #遺忘門
    self.__g_forget = GateUnit(out_units, in_units)
    #輸出門
    self.__g_out = GateUnit(out_units, in_units)
    #記憶門
    self.__g_memory = GateUnit(out_units, in_units, activation='tanh')

    self.__g_in.set_parent(self)
    self.__g_forget.set_parent(self)
    self.__g_out.set_parent(self)
    self.__g_memory.set_parent(self)

    #記憶單元
    self.__memory_unit =LSTMMemoryUnit()
    #輸出單元
    self.__out_unit = LSTMOutUnit()

向前傳播:

def hiden_forward(self, in_batch, hs, training):
    g_in = self.__g_in.forward(in_batch, hs, training)
    #pdb.set_trace()
    g_forget = self.__g_forget.forward(in_batch, hs, training)
    g_out = self.__g_out.forward(in_batch, hs, training)
    g_memory = self.__g_memory.forward(in_batch, hs, training)

    memory = self.__memory_unit.forward(g_forget, g_in, g_memory, training)
    cur_hs = self.__out_unit.forward(g_out, memory, training)

    return cur_hs

反向傳播:

def hiden_backward(self, gradient):
    #pdb.set_trace()
    grad_out, grad_memory = self.__out_unit.backward(gradient)
    grad_forget, grad_in, grad_gm = self.__memory_unit.backward(grad_memory)

    grad_in_batch, grad_hs = self.__g_memory.backward(grad_gm)
    tmp1, tmp2 = self.__g_out.backward(grad_out)
    grad_in_batch += tmp1
    grad_hs += tmp2

    tmp1, tmp2 = self.__g_forget.backward(grad_forget)
    grad_in_batch += tmp1
    grad_hs += tmp2

    tmp1, tmp2 = self.__g_in.backward(grad_in)
    grad_in_batch += tmp1
    grad_hs += tmp2

    return grad_in_batch, grad_hs

驗證

接下來, 驗證示例將會構建一個簡單的RNN模型, 使用該模型擬合一個正余弦疊加函式:

#采樣函式
def sample_function(x):
    y = 3*np.sin(2 * x * np.pi) + np.cos(x * np.pi) + np.random.uniform(-0.05,0.05,len(x))
    return y

訓練資料集和測驗資料集在這個函式的不同定義域區間內樣. 訓練資料集的采樣區間為[1, 200.01), 測驗資料集的采樣區間為[200.02, 240.002). 模型任務是預測這個函式值的序列.

示例代碼在examples/rnn/fit_function.py檔案中.

使用GRU構建的模型

def fit_gru():
    model = Model([
                rnn.GRU(32, 1),
                nn.Filter(),
                nn.Dense(32),
                nn.Dense(1, activation='linear')
            ])
    model.assemble()
    fit('gru', model)

訓練報告:

使用LSTM構建的模型

def fit_lstm():
    model = Model([
                rnn.LSTM(32, 1),
                nn.Filter(),
                nn.Dense(2),
                nn.Dense(1, activation='linear')
            ])
    model.assemble()
    fit('lstm', model)

訓練報告:

總結

這個階段，框架新增了RNN的兩個最常見的實作:GRU和LSTM, 相應地增加了它需要的激活函式. cute-dl已經具備了構建最基礎RNN模型的能力，通過驗證發現, GRU模型和LSTM模型在簡單任務上都表現出了很好的性能，會添加嵌入層，使框架能夠構建文本分類任務的模型，然后在imdb-review(電影評價)資料集上進行驗證.

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/21543.html

標籤：其他

上一篇：“Failed to get convolution algorithm. This is probably because cuDNN failed to initialize”錯誤的解決辦法

下一篇：python通過wsgi實作web服務

自己動手實作深度學習框架-7 RNN層--GRU, LSTM

目標

RNN原理

原始的RNN

GRU

LSTM

RNN實作

RNN基礎類的實作

RNN類

sigmoid和tanh激活函式

sigmoid及其導數

tanh及其導數

門控單元實作

GRU實作

LSTM實作

驗證

使用GRU構建的模型

使用LSTM構建的模型

總結