GRU

class torch.ao.nn.quantized.dynamic.GRU(*args, **kwargs) [источник]

Применяет многослойную рекуррентную нейронную сеть (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 >= 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). По умолчанию: False
• dropout – Если значение отлично от нуля, к выходам каждого слоя GRU, кроме последнего, добавляется слой Dropout с вероятностью 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): тензор, содержащий выходные признаки h_t последнего слоя GRU для каждого 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), формы (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}}$

Примечание

Вычисление нового управляющего блока $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)