GRU

class torch.nn.GRU(self, input_size, hidden_size, num_layers=1, bias=True, batch_first=False, dropout=0.0, bidirectional=False, device=None, dtype=None) [source]

Применяет многослойный рекуррентный блок 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 * (W_{hn} h_{(t-1)}+ b_{hn})) \\ h_t = (1 - z_t) * n_t + z_t * h_{(t-1)} \end{array}$$

где $h_t$ — скрытое состояние в момент времени t, $x_t$ — входной сигнал в момент времени t, $h_{(t-1)}$ — скрытое состояние слоя в момент времени t-1 или начальное скрытое состояние в момент времени 0, а $r_t$, $z_t$, $n_t$ — соответственно, ворота сброса, обновления и нового состояния. $\sigma$ — сигмоидальная функция, а $*$ — произведение Адамара.

В многослойном блоке GRU вход $x^{(l)}_t$ $l$-го слоя ($l \ge 2$) представляет собой скрытое состояние $h^{(l-1)}_t$ предыдущего слоя, умноженного на вероятность отбрасывания $\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. По умолчанию: 0
• bidirectional – Если True, становится двунаправленным блоком GRU. По умолчанию: False

Входные данные: вход, h_0

• вход: тензор формы $(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}$$

Выходные данные: вывод, h_n

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

$$\begin{aligned} n_t = \tanh(W_{in} x_t + b_{in} + W_{hn} ( r_t * 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 * (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)