GRU

class torch.nn.modules.rnn.GRU(input_size, hidden_size, num_layers=1, bias=True, batch_first=False, dropout=0.0, bidirectional=False, device=None, dtype=None) [исходный код]

Применяет многослойную рекуррентную нейронную сеть (RNN) с управляемыми рекуррентными блоками (GRU) к входной последовательности. Для каждого элемента входной последовательности каждый слой вычисляет следующую функцию:

$$\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$ — сигмоидальная функция, а $\odot$ — произведение Адамара.

В многослойной GRU вход $x^{(l)}_t$ для $l$-го слоя ($l \ge 2$) — это скрытое состояние $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 будут объединены в стек, образуя stacked GRU, при этом вторая GRU получает выходы первой GRU и вычисляет итоговые результаты. По умолчанию: 1
• bias – Если False, слой не использует смещения b_ih и b_hh. По умолчанию: True
• batch_first – Если True, входные и выходные тензоры представлены в формате (batch, seq, feature) вместо (seq, batch, feature). Обратите внимание, что это не относится к скрытым состояниям или состояниям ячеек. Подробности см. в разделах «Входы/выходы» ниже. По умолчанию: False
• dropout – Если значение ненулевое, добавляет слой Dropout к выходам каждого слоя GRU, кроме последнего, с вероятностью dropout, равной dropout. По умолчанию: 0
• bidirectional – Если True, становится двунаправленной GRU. По умолчанию: False

Входы: input, h_0

• input: тензор формы $(L, H_{in})$ для входа без пакетирования, $(L, N, H_{in})$ при batch_first=False или $(N, L, H_{in})$ при batch_first=True, содержащий признаки входной последовательности. Вход также может представлять собой упакованную последовательность переменной длины. Подробности см. в torch.nn.utils.rnn.pack_padded_sequence() или torch.nn.utils.rnn.pack_sequence().
• h_0: тензор формы $(D * \text{num\_layers}, H_{out})$ или $(D * \text{num\_layers}, N, H_{out})$, содержащий начальное скрытое состояние входной последовательности. Если значение не задано, по умолчанию используется нулевой тензор.

где:

$$\begin{aligned} N ={} & \text{batch size} \\ L ={} & \text{sequence length} \\ D ={} & 2 \text{ if bidirectional=True otherwise } 1 \\ H_{in} ={} & \text{input\_size} \\ H_{out} ={} & \text{hidden\_size} \end{aligned}$$

Выходы: output, h_n

• output: тензор формы $(L, D * H_{out})$ для входа без пакетирования, $(L, N, D * H_{out})$ при batch_first=False или $(N, L, D * H_{out})$ при batch_first=True, содержащий признаки выходных данных (h_t) последнего слоя GRU для каждого t. Если на вход подан объект torch.nn.utils.rnn.PackedSequence, выход также будет упакованной последовательностью.
• h_n: тензор формы $(D * \text{num\_layers}, H_{out})$ или $(D * \text{num\_layers}, N, H_{out})$, содержащий конечное скрытое состояние входной последовательности.

Переменные:

• weight_ih_l[k] – обучаемые веса от входа к скрытому состоянию для $\text{k}^{th}$ слоя (W_ir|W_iz|W_in), формы (3*hidden_size, input_size) для k = 0. В противном случае форма равна (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}}$

Примечание

Для двунаправленных GRU прямое и обратное направления обозначаются соответственно 0 и 1. Пример разделения выходных слоёв при batch_first=False: output.view(seq_len, batch, num_directions, hidden_size).

Примечание

Аргумент batch_first игнорируется для входов без пакетирования.

Примечание

Вычисление нового вентиля $n_t$ немного отличается от описанного в исходной статье и других фреймворках. В исходной реализации произведение Адамара $(\odot)$ между $r_t$ и предыдущим скрытым состоянием $h_{(t-1)}$ вычисляется до умножения на матрицу весов 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) используется GPU V100, 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)