GRU

class torch.ao.nn.quantized.dynamic.GRU(*args, **kwargs)

將多層門控迴圈單元 (GRU) RNN 應用於輸入序列。

對於輸入序列中的每個元素，每一層計算以下函式

$$\begin{array}{ll} r_t = \sigma(W_{ir} x_t + b_{ir} + W_{hr} h_{(t-1)} + b_{hr}) \\ z_t = \sigma(W_{iz} x_t + b_{iz} + W_{hz} h_{(t-1)} + b_{hz}) \\ n_t = \tanh(W_{in} x_t + b_{in} + r_t \odot (W_{hn} h_{(t-1)}+ b_{hn})) \\ h_t = (1 - z_t) \odot n_t + z_t \odot h_{(t-1)} \end{array}$$

其中 $h_t$ 是時刻 t 的隱藏狀態，$x_t$ 是時刻 t 的輸入，$h_{(t-1)}$ 是時刻 t-1 的層的隱藏狀態或時刻 0 的初始隱藏狀態，$r_t$、$z_t$、$n_t$ 分別是重置門、更新門和新門。$\sigma$ 是 sigmoid 函式，$\odot$ 是 Hadamard 積。

在多層 GRU 中，第 $l$ 層 ($l >= 2$) 的輸入 $x^{(l)}_t$ 是前一層的隱藏狀態 $h^{(l-1)}_t$ 乘以 dropout $\delta^{(l-1)}_t$，其中每個 $\delta^{(l-1)}_t$ 都是一個伯努利隨機變數，其為 $0$ 的機率等於 dropout 值。

引數

• input_size – 輸入 x 中預期特徵的數量

• hidden_size – 隱藏狀態 h 中的特徵數量

• num_layers – 迴圈層數。例如，設定 num_layers=2 意味著將兩個 GRU 堆疊在一起形成一個堆疊 GRU，其中第二個 GRU 接收第一個 GRU 的輸出並計算最終結果。預設值：1

• bias – 如果為 False，則該層不使用偏置權重 b_ih 和 b_hh。預設值：True

• batch_first – 如果為 True，則輸入和輸出張量的維度順序為 (batch, seq, feature)。預設值：False

• dropout – 如果非零，則在除最後一層外的每個 GRU 層的輸出上引入一個 Dropout 層，其丟棄機率等於 dropout。預設值：0

• bidirectional – 如果為 True，則成為一個雙向 GRU。預設值：False

輸入：input, h_0

• input 形狀為 (seq_len, batch, input_size)：包含輸入序列特徵的張量。輸入也可以是打包的變長序列。詳情請參見 torch.nn.utils.rnn.pack_padded_sequence()。

• h_0 形狀為 (num_layers * num_directions, batch, hidden_size)：包含批次中每個元素的初始隱藏狀態的張量。如果未提供，預設為零。如果 RNN 是雙向的，則 num_directions 應為 2，否則應為 1。

輸出：output, h_n

• output 形狀為 (seq_len, batch, num_directions * hidden_size)：包含 GRU 最後一層在每個時間步 t 的輸出特徵 h_t 的張量。如果輸入是 torch.nn.utils.rnn.PackedSequence，則輸出也將是打包序列。對於未打包的情況，可以使用 output.view(seq_len, batch, num_directions, hidden_size) 分離方向，其中前向是方向 0，後向是方向 1。

  類似地，在打包的情況下也可以分離方向。

• h_n 形狀為 (num_layers * num_directions, batch, hidden_size)：包含時間步 t = seq_len 時的隱藏狀態的張量。

  類似於 output，可以使用 h_n.view(num_layers, num_directions, batch, hidden_size) 分離層。

形狀

• 輸入 1: $(L, N, H_{in})$ 包含輸入特徵的張量，其中 $H_{in}=\text{input\_size}$ 且 L 表示序列長度。

• 輸入 2: $(S, N, H_{out})$ 包含批次中每個元素的初始隱藏狀態的張量。$H_{out}=\text{hidden\_size}$ 如果未提供，預設為零。其中 $S=\text{num\_layers} * \text{num\_directions}$。如果 RNN 是雙向的，則 num_directions 應為 2，否則應為 1。

• 輸出 1: $(L, N, H_{all})$ 其中 $H_{all}=\text{num\_directions} * \text{hidden\_size}$

• 輸出 2: $(S, N, H_{out})$ 包含批次中每個元素的下一個隱藏狀態的張量。

變數

• weight_ih_l[k] – 第 $\text{k}^{th}$ 層的可學習的輸入到隱藏層的權重 (W_ir|W_iz|W_in)，當 k = 0 時形狀為 (3*hidden_size, input_size)。否則，形狀為 (3*hidden_size, num_directions * hidden_size)。

• weight_hh_l[k] – 第 $\text{k}^{th}$ 層的可學習的隱藏層到隱藏層的權重 (W_hr|W_hz|W_hn)，形狀為 (3*hidden_size, hidden_size)。

• bias_ih_l[k] – 第 $\text{k}^{th}$ 層的可學習的輸入到隱藏層的偏置 (b_ir|b_iz|b_in)，形狀為 (3*hidden_size)。

• bias_hh_l[k] – 第 $\text{k}^{th}$ 層的可學習的隱藏層到隱藏層的偏置 (b_hr|b_hz|b_hn)，形狀為 (3*hidden_size)。

注意

所有權重和偏置均初始化自 $\mathcal{U}(-\sqrt{k}, \sqrt{k})$，其中 $k = \frac{1}{\text{hidden\_size}}$

注意

新門 $n_t$ 的計算與原始論文及其他框架略有不同。在原始實現中，$r_t$ 與前一隱藏狀態 $h_{(t-1)}$ 之間的哈達瑪積 $(\odot)$ 是在與權重矩陣 W 相乘和新增偏置之前進行的。

$$\begin{aligned} n_t = \tanh(W_{in} x_t + b_{in} + W_{hn} ( r_t \odot h_{(t-1)} ) + b_{hn}) \end{aligned}$$

這與 PyTorch 實現形成對比，後者的計算是在 $W_{hn} h_{(t-1)}$ 之後進行的。

$$\begin{aligned} n_t = \tanh(W_{in} x_t + b_{in} + r_t \odot (W_{hn} h_{(t-1)}+ b_{hn})) \end{aligned}$$

此實現為了效率而有意設計得不同。

注意

如果滿足以下條件：1) cudnn 已啟用，2) 輸入資料位於 GPU 上，3) 輸入資料的資料型別為 torch.float16，4) 使用 V100 GPU，5) 輸入資料不是 PackedSequence 格式，則可以選擇持久演算法以提高效能。

示例

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