RNN レイヤ
RNN レイヤの t 時刻（ time step ）の順伝播は入力として t 時刻の単語 $x_t$ と t-1 時刻の 隠れ状態 $h_{t-1}$ を受け取って t 時刻の隠れ状態 $h_t$ を出力します 。
t-1 時刻の隠れ状態 $h_{t-1}$ は、時刻 0 〜 t-1 までに入力された単語列の情報（文脈）を圧縮して保持したベクトルです（隠れ状態は英語では hidden state です）。
活性化関数に tanh を用いた RNN セル（ 入力 $x_t$ と $h_{t-1}$ から $h_t$ を出力する単位）の順伝播は以下のとおりです。
\(\begin{aligned} h_t = tanh(h_{t-1} \cdot W_h + x_t \cdot W_x + b) \end{aligned}\) 1 データを自然にバッチサイズ $N$ のミニバッチに拡張できます。
- １データ：$\vec{h_t}: (1, H), W_h: (H, H), \vec{x_t}: (1, D), W_x: (D, H)$
- ミニバッチ: $h_t: (N, H), W_h: (H, H), x_t: (N, D), W_x: (D, H)$ 。
逆伝播は Affine 変換用に変数 $a_t$ を定義して 2 段階で考えると分かりやすくなります。
\[\begin{aligned} a_t = h_{t-1} \cdot W_h + x_t \cdot W_x + b \\ h_t = tanh(a_t) \end{aligned}\]記法
本ドキュメントは以下の記法で統一します。
| 記号 | 意味 |
|---|---|
| $\cdot$ | 行列積（ドット積） |
| $\odot$ | 要素積（アダマール積、element-wise product） |
前提
- corpus size： 1000
- V（ vocab_size ）：コーパスから重複を排除した単語 ID の数（語彙数）
- ソースコードは 418
- N：ミニバッチサイズ
- ソースコードは 10
- T：系列長（sequence length）
- ソースコードは 5
- D（ wordvec_size ）：単語の分散表現の次元数（要素数）
- ソースコードは 100
- H（ hidden_size ）： RNNの隠れ状態の次元数（要素数）
- ソースコードは 100
※ ソースコードの D, H はともに 100 ですが異なる値を設定できます。
学習
1 回の学習を Python コードで実装した例です。
順伝播
0. 概要
- コーパスの単語 ID を
corpusに格納 - corpus のシェイプ： $(1000,)$ - 学習データ
corpus[:-1]と 教師データ ` corpus[1:]` を準備 - 学習 / 教師データのシェイプ： $(999,)$ - 学習データからバッチサイズが N, 系列長が T で各要素が単語 ID のミニバッチを作成 - ミニバッチのシェイプ $(N, T)$
- (Time)Embedding レイヤ で単語 ID のミニバッチ $(N, T)$ から単語の分散表現のミニバッチ（ 以下 $x$ ）を出力 - 単語の分散表現ミニバッチのシェイプ： $(N, T, D)$
- (Time)RNN レイヤで t 時刻の単語データ $x_t$ と t-1 時刻の隠れ状態 $h_{t-1}$ から t 時刻の隠れ状態 $h_t$ を出力 - 隠れ状態のミニバッチのシェイプ：$(N, T, H)$
- (Time)Affine レイヤで t 時刻の隠れ状態 $h_t$ から次にくる単語のスコアを出力 - $(N, T, V)$
- Softmax 関数でスコアを確率に正規化
- 教師データと該当する確率から損失（ Cross Entropy Error ）を算出
- 損失の平均を算出（ $L$ ）
詳細を記載しますが分かりやすさ（実装コードの区切り）を優先するので章番号は上の数字と一致しません。
1. 学習データ / 教師データを準備 （ main ）
PTB コーパスを変数 corpus に単語 ID の 1 次元配列として読み込みます。
corpus, word_to_id, id_to_word = ptb.load_data('train')
corpus = corpus[:1000] # (1000,)
xs = corpus[:-1] # 学習データ（ 0 - 998 の 1 次元配列）
ts = corpus[1:] # 教師データ（ 1 - 999 の 1 次元配列）
2. ミニバッチデータを準備（ Trainer.fit / get_batch ）
各要素が単語 ID の 2 次元配列 $(N = 10, T = 5)$ を取得します。
# batch_x
# [[ 0 1 2 3 4]
# [ 42 76 77 64 78]
# [ 26 26 98 56 40]
# [ 24 32 26 175 98]
# [208 209 80 197 32]
# [ 26 79 26 80 32]
# [274 275 276 42 61]
# [ 88 303 26 304 26]
# [ 42 35 72 350 64]
# [339 359 181 328 386]]
#
# batch_t
# [[ 1 2 3 4 5]
# [ 76 77 64 78 79]
# [ 26 98 56 40 128]
# [ 32 26 175 98 61]
# [209 80 197 32 82]
# [ 79 26 80 32 241]
# [275 276 42 61 24]
# [303 26 304 26 32]
# [ 35 72 350 64 27]
# [359 181 328 386 387]]
以降、学習データの順伝播に絞ってデータの流れを説明します。
学習データは SimpleRnnLm.forward(xs, ts) を経由して各レイヤにデータが渡されます。
3. 単語 ID から分散表現ベクトルを取得（ TimeEmbedding / Embedding レイヤ）
- 入力：各要素が t 時刻の単語 ID のミニバッチで２次元配列 $(N = 10, T = 5)$
- ミニバッチ $(N, T)$ を受け取った TimeEmbedding は t 時刻(t 列)の単語 ID（ 1 次元配列： $(10,)$ ）を Embedding に渡してt 時刻の分散表現 $(N, D)$を得る
- 出力：各要素が t 時刻の単語の分散表現のミニバッチで 3 次元配列 $(N = 10, T = 5, D = 100)$
- $t = 1,…,T$ の各 t 時刻の出力をまとめたものです（
for i range(T) out[:, t, :] = layer.forward(xs[:, t])）
- $t = 1,…,T$ の各 t 時刻の出力をまとめたものです（
4. 文脈情報を保持・更新（ TimeRNN / RNN ）
- 入力：各要素が t 時刻の分散表現ベクトルのミニバッチで 3 次元配列 $(N = 10, T = 5, D = 100)$
- TimeRNN は RNN に t 時刻ごとの入力 $x_t$ （ 2 次元配列： $(N = 10, D = 100)$ ）と前回の RNN の出力である隠れ状態 $h_{t-1}$ （ 2 次元配列： $(N = 10, H = 100)$ ）を渡して $h_t = tanh(h_{t-1}W_h + x_tW_x + b)$ を得る
- 初回ステップの $h_{t-1}$ はゼロベクトル $(N = 10, H = 100)$。ただし stateful=True の場合は前回ミニバッチの最終隠れ状態が利用される
- TimeRNN は RNN に t 時刻ごとの入力 $x_t$ （ 2 次元配列： $(N = 10, D = 100)$ ）と前回の RNN の出力である隠れ状態 $h_{t-1}$ （ 2 次元配列： $(N = 10, H = 100)$ ）を渡して $h_t = tanh(h_{t-1}W_h + x_tW_x + b)$ を得る
- 出力：文脈情報を保持・更新した隠れ状態のミニバッチで 3 次元配列 $(N = 10, T = 5, H = 100)$
\[h_t = tanh( h_{t-1} \cdot W_h + x_t \cdot W_x + b )\][!NOTE]
ソースコードの D, H はともに 100 ですが役割は全く異なるので混同しないように注意します。
$\tanh$ に入力される直前の状態（アフィン変換の出力）を $a_t$ として分けると逆伝播を理解しやすくなります。
\[a_t = h_{t-1} \cdot W_h + x_t \cdot W_x + b \\ h_t = \tanh(a_t)\][!NOTE]
書籍『ゼロから作るDeep Learning 2』のコードでは中間変数をt/dtと表記しています。tは時刻を連想させるため若干混乱を招きやすいと考えて本ドキュメントでは数学的に一般的な $a_t$（activation の略）に統一します。 コードを読む際はt= $a_t$、dt= $\frac{\partial L}{\partial a_t}$ と読み替えてください。
各記号の意味
| 記号 | 意味 | 形状（ ミニバッチ数 N ） |
|---|---|---|
| $x_t$ | 時刻 $t$ の入力 | $(N, D)$ |
| $h_{t-1}$ | 一つ前の隠れ状態 | $(N, H)$ |
| $W_x$ | 入力に対する重み行列 | $(D, H)$ |
| $W_h$ | 隠れ状態に対する重み行列 | $(H, H)$ |
| $b$ | バイアス | $(1, H)$ |
| $h_t$ | 現在の隠れ状態（出力） | $(N, H)$ |
- $D$：入力の分散表現の次元数
- $H$：隠れ状態の分散表現の次元数
5. 隠れ状態から語彙サイズの出現スコアを取得（ TimeAffine ）
- 入力：文脈を学習した隠れ状態のミニバッチ：3 次元配列 $(N = 10, T = 5, H = 100)$
- 出力：学習データのミニバッチに対して次に出現する単語 ID の出現スコアを要素とする 3 次元配列 $(N = 10, T = 5, V = 418)$
- 内部では入力を $(N*T, H)$ へ reshape して行列積を計算し、出力を $(N, T, V)$ に戻す
- 50 は（ミニバッチのサイズ $N$ × 系列長 $T$ ）で語彙サイズは 418 。各要素は該当する単語 ID の出現スコア
TimeAffine の出力は $(N, T, V)$ の3次元配列です。
T = 5 の場合、各時刻の出力は「次に出現する単語」の予測スコアを表しています。
| 時刻 | TimeAffine 出力（予測） | 教師データ ts（正解） |
|---|---|---|
| t=0 | 単語0（ xs[:,0]）の文脈 $\rightarrow$ 次単語スコア |
単語1 |
| t=1 | 単語0,1（ xs[:,0], xs[:,1] ）の文脈 $\rightarrow$ 次単語スコア |
単語2 |
| t=2 | 単語0,1,2（ xs[:,0], xs[:,1], xs[:,2] ）の文脈 $\rightarrow$ 次単語スコア |
単語3 |
| t=3 | 単語0〜3（ xs[:,0],......, xs[:,3] ）の文脈 $\rightarrow$ 次単語スコア |
単語4 |
| t=4 | 単語0〜4（ xs[:,0],......, xs[:,4] ）の文脈 $\rightarrow$ 次単語スコア |
単語5 |
xs = corpus[:-1] と ts = corpus[1:] を使用しているため、入力単語列と正解単語列が1単語ずれて対応しています（自己教師あり学習 Self-Supervised Learning ）。
※ 418 はソースコードで読み込まれているコーパスの語彙サイズが 418 のためです。
6 確率化 + 損失計算（ TimeSoftmaxWithLoss ）
- 入力：学習データのミニバッチに対して次に出現する単語 ID の出現スコアを要素とする 3 次元配列 $(N = 10, T = 5, V = 418)$
- 出力： ミニバッチ全体の平均損失を表す損失値（スカラー）
#### 各時刻の勾配
各時刻の RNN セルに届く勾配 $dh_t$ は **2つの経路の和**です。
| 勾配 | 経路 | 意味 |
|------|------|------|
| `dhs[:,t,:]` | 出力層（TimeAffine）から | 時刻 $t$ の予測誤差 |
| `dh_next` | 未来時刻 $t+1$ から | $t+1$ 以降の損失から再帰的に伝播してきた勾配 |
`dh_next` には $t+1$ の損失だけでなく $t+2, t+3, \ldots$ の損失から再帰的に伝播してきた
勾配も含まれています。これが「Through Time」の意味です。
#### TimeRNN.backward() の流れ
```python
dh_next = 0 # t=4 の次時刻からの勾配は 0 で初期化
for t in reversed(range(T)): # t = 4, 3, 2, 1, 0 の順
dh = dhs[:, t, :] + dh_next # 2経路の勾配を加算
dh_next = rnn_layer.backward(dh) # t-1 へ渡す勾配を計算
```
`dh_next` を次のループへ引き渡すことで、勾配が時刻をさかのぼって伝播します。
#### Truncated BPTT
本実装では `time_size = 5` のため、**1回の逆伝播で遡れるのは 5 ステップ分のみ**です。
これを Truncated BPTT（打ち切り BPTT）と呼びます。
| | 順伝播 | 逆伝播 |
|---|---|---|
| `stateful=True` | 前バッチの文脈を引き継ぐ | 勾配は `time_size` ステップのみ遡る |
| `stateful=False` | 毎回ゼロ初期化 | 同上 |
#### なぜ打ち切るのか
全時刻分の勾配を遡ると計算量が膨大になります。
`time_size` で打ち切ることで計算量を一定に保ちながら、
`stateful=True` による隠れ状態の引き継ぎで長期の文脈は順伝播側で保持します。
#### 勾配消失・爆発
BPTT では勾配が時刻を遡るたびに `tanh` の微分（$1 - h_t^2$）が掛け算されます。
```text
t=4 → × (1 - h4²)
t=3 → × (1 - h3²)
t=2 → × (1 - h2²)
...
```
$\tanh$ の微分は最大でも 1 のため、ステップ数が増えるほど勾配が小さくなり
**勾配消失**が起きやすくなります。これが素の RNN の限界であり、
LSTM・GRU が導入された背景です。
## TimeSoftmaxWithLoss の逆伝播
TimeSoftmaxWithLoss.backward の出力（各時刻・各単語に対する softmax+loss の勾配）は、そのレイヤー自身の重みを更新するためのものではなく、連鎖律（ chain rule ）に従って一つ前の層（下流、例えば Affine レイヤーや LSTM/RNN レイヤー）に逆伝播させるための勾配です。
このレイヤー自体には学習可能な重み（パラメータ）が存在しないため、paramsやgradsも持たないのが一般的（ softmax と loss の計算だけで構成される）。
逆伝播では $\text{Softmax} + \text{CrossEntropy}$ をまとめて微分できます。
$$
\frac{\partial L}{\partial s} = p - y
$$
- $p$ ：softmax の出力確率
- $y$ ：one-hot 表現の正解ラベル
例えば予測確率が `[0.23, 0.05, 0.72]` で正解（ one-hot ）が `[0, 0, 1]` なら `[0.23, 0.05, -0.28]` が勾配になります。
### 実装との対応
ゼロから作る Deep Learning 2 の実装は以下のとおりです。
```python
dx = mask.sum()
# ys.shape = (N*T, V)
# ys は次にくる単語のスコア（ logits ）
ts, ys, mask, (N, T, V) = self.cache
# ts.shape = (N*T, ) 教師データの単語 ID
# ys.shape = (N*T, V)
dx = ys
# W := W − η * (∂W / ∂L)
# 正解 <= 0 なので重みは増加
# 不正解 > 0 なので重みは減少
dx[np.arange(N * T), ts] -= 1
dx *= dout
dx /= mask.sum() # /= は「除算代入演算子」で、dx = dx / mask.sum() と同じ意味
dx *= mask[:, np.newaxis] # ignore_labelに該当するデータは勾配を0にする
dx = dx.reshape((N, T, V))
return dx
```
> ![NOTE]
> 実際のコードは汎用性を持たせるために ignore-label の処理をするが上記コードでは
> 簡単にするために無視する（ loss = mask.sum() にしている）
> #ls = np.log(ys[np.arange(N * T), ts])
> ls *= mask # ignore_labelに該当するデータは損失を0にする
> loss = -np.sum(ls)
> loss /= mask.sum()
以下で $p - y$ を算出します。
```python
dx[np.arange(N*T), ts] -= 1
```
- 正解：`p_i -> p_i - 1`
- 正解以外： `p_i`
その後、$dx /= mask.sum()$ によって平均損失に対応する勾配へ変換します。
> [!NOTE]
> dx = np.array([
> [0.23, 0.05, 0.72],
> [0.75, 0.20, 0.05],
> [0.40, 0.50, 0.10]]);
>
> dx[[1,2]] 行に関して抽出
> [[0.75, 0.2 , 0.05],
> [0.4 , 0.5 , 0.1 ]]
>
> 対象の要要を一括で抽出
> dx[[1,2],[0,1]]
> [0.75, 050]
>
> numpy.arange 関数
> numpy.arange(start, stop, step) は等間隔の数値配列を生成する関数です。
>
> np.arange(5) # [0, 1, 2, 3, 4]
> np.arange(1, 5) # [1, 2, 3, 4]
> np.arange(0, 10, 2) # [0, 2, 4, 6, 8]
> np.arange(0, 1, 0.25) # [0, 0.25, 0.5, 0.75]
> stopは含まれない(半開区間)。浮動小数点を使うと誤差が出ることがあるため、その場合はnumpy.linspaceの使用が推奨されます。
例えば予測確率 $p$ が `[0.23, 0.05, 0.72]` で正解が 2 なら $y$ は `[0, 0, 1]` なので $p - y$ は `[0.23, 0.05, -0.28]` になり正解クラスだけ負になります。
SGD の更新式は $W := W - \eta \frac{\partial L}{\partial W}$ です。
#### 正解クラス
勾配が負 `-0.28` なので `W - η(-0.28) = W + η0.28` となり、そのクラスのスコア（ logit ）が上がる方向に更新されます。
結果として次回の予測では正解クラスの確率が高くなります。
#### 不正解クラス
例えばクラス0の勾配は `+0.23` です。
更新すると `W - η(0.23)` となるため、そのクラスのスコアは下がる方向へ更新されます。
結果として不正解クラスの確率は低くなります。
- 正解クラス → 勾配が負 → スコアを上げる方向に更新
- 不正解クラス → 勾配が正 → スコアを下げる方向に更新
そのため `p - y` は「正解クラスの確率を上げ、不正解クラスの確率を下げるための誤差信号」として解釈できます。
### shape の流れ
| 処理 | shape |
|---|---|
| TimeAffine出力 | $(N, T , V)$ |
| reshape後 | $(N * T, V)$ |
| Softmax出力 | $(N * T, V)$ |
| backwardの勾配 | $(N * T, V)$ |
| reshapeして戻す | $(N, T, V)$ |
上記より TimeSoftmaxWithLoss が返す勾配はそのまま TimeAffine.backward() に渡されます。
# クラスの役割
| クラス | 役割 |
|---|---|
| `RNN` | 1ステップ分のRNN計算 |
| `TimeRNN` | T ステップ分をまとめて処理 |
| `Embedding` / `TimeEmbedding` | 単語ID→ベクトル変換 |
| `TimeAffine` | 全結合層（時系列版） |
| `TimeSoftmaxWithLoss` | 損失計算 |
| `SimpleRnnlm` | モデル全体の統括 |
| `RnnlmTrainer` | 学習ループ管理 |
| `SGD` | パラメータ更新 |
# 補足
## stateful=True による文脈の引き継ぎ
この実装では TimeRNN を以下のように生成しています。
```python3
TimeRNN(rnn_Wx, rnn_Wh, rnn_b, stateful=True)
```
`stateful=True` の場合、順伝播は前回のミニバッチの最後の隠れ状態を次回のミニバッチへ引き継ぎます。
コードでは TimeRNN.forward() の冒頭で以下の処理が行われます。
```python
if not self.stateful or self.h is None:
self.h = np.zeros((N, H), dtype='f')
```
`stateful=True` の場合は `self.h` が保持されるため、次回の `forward()` 呼び出し時にも前回の隠れ状態が利用されます。
### ミニバッチ内での状態遷移
1つのミニバッチ（ T = 5 ）の内部では以下のように隠れ状態が伝播します。
通常の RNN と同じく、各時刻の隠れ状態が次時刻へ渡されます。
### ミニバッチ間での状態遷移
さらに `stateful=True` では、最後の隠れ状態 `h_4` が次のミニバッチの初期状態として利用されます。
Batch2 の最初の計算は以下のとおりです。
$$
h_{0}^{(\mathrm{Batch2})} = tanh(h_4^{(\mathrm{Batch1})} \cdot W_h + x_5 \cdot W_x + b)
$$
概念的には以下のようになります。
$$
h_{init}^{(\mathrm{Batch2})} = h_4^{(\mathrm{Batch1})}
$$
### なぜ必要なのか
本サンプルでは `time_size = 5` なので、1 回の順伝播では 5 単語分しか RNN を展開しません。
しかし `stateful=True` によって隠れ状態が保持されるため、実際には前のミニバッチで学習した文脈を次のミニバッチへ引き継げます。
例えば
```text
Batch1
the stock market crashed
Batch2
because investors feared ...
```
のような場合でも、Batch2 は Batch1 の文脈を含んだ隠れ状態から開始できます。
そのため、RNN は `time_size` より長い文脈を利用した言語モデルとして振る舞います。
※ 順伝播では長い文脈を保持できるが、勾配は `time_size` ステップ分しか遡りません。
### stateful=False の場合
`stateful=False` の場合は毎回隠れ状態をゼロ初期化します。 $h_0 = 0$ のため各ミニバッチは独立して扱われて前回の文脈は引き継がれません。