【強化学習】R2D2を実装/解説してみたリベンジ 解説編（Keras-RL）


[以前実装したR2D2](https://qiita.com/pocokhc/items/3b64d747a2f36da559c3)ですが、ミニバッチ学習の実装が出来ていませんでした。
その後試行錯誤し今回何とか実装しました。

以前の記事よりだいぶ間が開いてしまったので全体の流れに関してもざっくり説明していきます。
また、以前の実装で間違った箇所も修正していきます。。。
※ネット上の情報をかき集めて自分なりに実装しているので正確ではないところがある点はご了承ください。

また、本記事は解説編とハイパーパラメータ設定編の２部構成です。
ハイパーパラメータについては以下にて
[【強化学習】R2D2を実装/解説してみたリベンジ ハイパーパラメータ解説編（Keras-RL）](https://qiita.com/pocokhc/items/bc498a1dc720dcf075d6)

追記：R2D3も実装しました。
[【強化学習】R2D3を実装/解説してみた（Keras-RL）](https://qiita.com/pocokhc/items/2e000df3fddddd3d0854)

追記2：Agent57も記事をあげました。
[【強化学習】ついに人間を超えた！？Agent57を解説/実装してみた（Keras-RL）](https://qiita.com/pocokhc/items/8684c6c96d3d2963e284)

# コード全体
本記事で作成したコードは以下です。
今回は github のみです。

+ [github](https://github.com/pocokhc/r2d2)


# 目次
+ DQN(Rainbow)の実装解説
+ R2D2の実装解説
+ その他
  + ImageModelの拡張
  + Policy(方策)の拡張


# DQN(Rainbow)の実装解説
復習となりますが、DQN(Rainbow)の実装についてイメージを改めて説明します。
詳細な解説に関しては以前投稿した記事を参照してください。

+ [Q学習(TD誤差)について](https://qiita.com/pocokhc/items/8ed40be84a144b28180d)
+ [DQNについて](https://qiita.com/pocokhc/items/125479c9ae0df1de4234)
+ [Rainbowについて](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297)
+ [Multi-Step learning について](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#multi-step-learning)
+ [Priority Experience Reply(priority)について](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#priority-experience-reply%E5%84%AA%E5%85%88%E9%A0%86%E4%BD%8D%E4%BB%98%E3%81%8D%E7%B5%8C%E9%A8%93%E5%86%8D%E7%94%9F)

DQN(Rainbow)での学習のイメージをまとめると以下になります。

![zu1.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/e3d7a3bd-d903-9043-162e-47d436516679.png)

![zu2.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/77151081-09be-9aa7-b145-b997b0142b25.png)

DQNは経験データ（経験）を以下として memory に保存します。

$$e_{t} = (s_{t},a_{t},r_{t},s_{t+1})$$

Multi-step learning の step が1の場合は次の状態が $t+1$ になりますが、
3steps だと $t+3$ になります。

||数式|図|
|---|---|---|
|前の状態|$s_{t}$|observation: t(n-6) ～ t(n-3)|
|次の状態|$s_{t+1}$|observation: t(n-3) ～ t(n)|
|アクション|$a_{t}$|action: t(n-3)|
|報酬|$r_{t}$|reward: t(n)|


また、各変数の内部で保持するサイズは以下となります。

||保持する長さ|memoryに保存する長さ|
|---|---|---|
|rewards|multisteps|0(計算のみに使用)|
|計算済みrewards|1|1(現在の状態)|
|actions|multisteps + 1|1(前の状態)|
|observations|input_sequence + multisteps|input_sequence + multisteps|


## Multi-Step learning で参照する action の間違い
以前の記事の[Multi-Step learning](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#multi-step-learning)ですが、action の参照を $t_n$ で参照していましたが間違いですね…
前の状態の action を参照するので $t_{n-multisteps}$ が正解でした。


## 重要度サンプリングの間違い
以前の記事は以下です。

+ [重要度サンプリング(IS: Importance Sampling)](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#%E9%87%8D%E8%A6%81%E5%BA%A6%E3%82%B5%E3%83%B3%E3%83%97%E3%83%AA%E3%83%B3%E3%82%B0is-importance-sampling)

重要度サンプリングを簡単に言うと、Priority Experience Reply(優先順位付き経験再生)により経験を取り出す際に優先度がつきました。
すると取得する経験の回数に偏りが生じます。
そうするとその偏りで学習に bias がかかってしまうのでこれを修正するのが重要度サンプリングになります。

具体的には、高い確率で選ばれる経験はQ値の更新への反映率を低くし、低い確率で選ばれる経験はQ値の更新への反映率を高くするというものです。

以前は、微妙に実装がおかしいようでうまく学習しない状況でした。
以前は更新後のQ値そのものにかけていましたが、td_error 自体にかけるべきでした。(変数の命名が良くなかったですね)
また、Q値の更新に反映させるものなので priority には適用しないようにしています。


・以前の実装(疑似コード)

``` python:IS
def train():

    # PER から確率に従って経験を取得
    batchs, batch_weight = memory.sample(batch_size)

    # modelから前の状態のQ値を取得
    # state0_qvals は action 毎のQ値が入っている
    state0_qvals = model.predict(state0_batch)
    
    for batch_i in range(batch_size):
        reward = batchs[batch_i]の報酬
        action = batchs[batch_i]のアクション
        q0 = state0_qvals[batch_i][action]  # 更新前のQ値

        # modelとtarget_modelを使い、現在の状態の最大Q値を取得
        # (DQNとDDQNで取得方法が異なります)
        maxq = modelとtarget_modelから取得

        td_error = reward + (gamma ** reward_multisteps) * maxq
        td_error *= batch_weight

        priority = abs(td_error - q0)
        
        # 対象アクションのQ値のみを変更することで学習させる
        state0_qvals[batch_i][action] = td_error

    # train
    model.train_on_batch(state0_qvals)
```

・変更後の実装(疑似コード)
※ が変更箇所となります

``` python:IS
def train():

    # PER から確率に従って経験を取得
    batchs, batch_weight = memory.sample(batch_size)

    # modelから前の状態のQ値を取得
    # state0_qvals は action 毎のQ値が入っている
    state0_qvals = model.predict(state0_batch)
    
    for batch_i in range(batch_size):
        reward = batchs[batch_i]の報酬
        action = batchs[batch_i]のアクション
        q0 = state0_qvals[batch_i][action]  # 更新前のQ値

        # modelとtarget_modelを使い、現在の状態の最大Q値を取得
        # (DQNとDDQNで取得方法が異なります)
        maxq = modelとtarget_modelから取得

        #※ - q0 を追加し、ちゃんと td_error を出す
        #※　また、batch_weight の適用をここではなしにする
        td_error = reward + (gamma ** reward_multisteps) * maxq - q0

        #※ td_errorの絶対値がそのまま priority になる
        priority = abs(td_error)
        
        # 対象アクションのQ値のみを変更することで学習させる
        #※ td_error が差分になったので、そこにweightを適用し、差分でQ値を更新する
        state0_qvals[batch_i][action] += td_error * batch_weight

    # train
    model.train_on_batch(state0_qvals)
```


# R2D2 の実装解説
## ミニバッチ学習
以前ミニバチ学習が実装できなかったのは Keras のステートフルLSTMの理解が浅かったからです。
以前の調査記事は以下になります。

+ [KerasのステートレスLSTMとステートフルLSTMの違いについて](https://qiita.com/pocokhc/items/c94512e5536ddd5b1bba)
+ [Keras のステートフルLSTMと hidden state の関係を調査してみた](https://qiita.com/pocokhc/items/da7039a7ea8b46b5a812)

![zu3.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/b8a72596-b1be-39a1-5ac9-a479d64d1e86.png)

どうやら hidden_states の中に batch_size 分状態があり指定できるようです。
これで sequence 間の学習を複数同時に進めることができました。


## DRQN(R2D2)
話を分かりやすくするために並列処理部分をはぶいたR2D2で説明します。
以前の記事は以下です。

+ [【強化学習】2018年度最強と噂のR2D2を実装/解説してみた](https://qiita.com/pocokhc/items/3b64d747a2f36da559c3)

DQNと同様にイメージ図です。

![zu4.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/f9f01dc6-b36a-c924-3196-4113441f551a.png)

![zu5.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/13d32a95-4ad8-05d9-ad1b-b7a31b5b22db.png)

かなり複雑になりました…。
この図を書いたのも実装してるときに自分が混乱したからですね…。

Q値の更新及び Priority の出し方は DQN と同様なので図からは省略しています。

ポイントは input sequence と input length です。
前回はこれを意識していませんでした。
(input sequence=1と仮定し、input length を input sequence と表現していた)

input sequence は model に入力する状態の長さで、それを入力する数が input length となります。
input length 毎にQ値を更新し、Priorityも計算します。
（この解釈は少し自信がないですが、R2D2の論文2.3節で　Priority の新しい出し方を提案しており、上記のように1つの経験から複数の Priority が出ると考えると筋が通ります）

各変数の内部で保持するサイズは以下となります。

||保持する長さ|memoryに保存する長さ|
|---|---|---|
|rewards|multisteps + input_length - 1|0(計算のみに使用)|
|計算済みrewards|input_length|input_length|
|actions|multisteps + input_length|input_length(前の状態から)|
|hidden states|burnin + multisteps + input_length + 1|1(一番古い状態)|
|observations|burnin + input_sequence + multisteps + input_length - 1|0(下でまとめる用)|
|まとめたobservations|burnin + multisteps + input_length|同じ長さ|


## rescaling 関数

$$h(x) = sign(x)(\sqrt{|x|+1}-1)+\epsilon x$$

![rescaling2.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/ebe70bd2-87d2-d3f8-5ee7-224c5cf84b66.png)


rescaling 関数はR2D2で導入された関数で、報酬のクリッピング(-1～1)の代わりに用いるという事でした。
以前は逆関数で悩んでいましたがちょっと強引に不要にしました。

rescaling 関数を使ってTD誤差を導出する式は以下です。($y_t$がTD誤差です)

$$y_{t} = h \Bigl(r_{t} + \gamma h^{-1}(\max_pQ_{target}(s_{t+1},a_{t}))\Bigr)$$

上記式の $h()$ を展開?します。

$$y_{t} = h (r_{t}) + h \Bigl(\gamma h^{-1}(\max_pQ_{target}(s_{t+1},a_{t}))\Bigr)$$

ある関数に対して逆関数を適用すると元の値に戻ります。※ $h(h^{-1}(x)) = x$ 
ですので右辺は相殺できます($\gamma$は誤差として無視しています…)

すると以下になります。

$$y_{t} = h (r_{t}) + \gamma (\max_pQ_{target}(s_{t+1},a_{t}))$$

rescaling 関数の適用先が報酬（$r_{t}$）だけになりました。
グラフを見ると報酬がいい感じに丸められてるのが分かります。(100の報酬が10ぐらいになる)
クリッピングの代わりというのも納得です。


## 並列処理(プロセス間通信)
以前の記事は以下です。

+ [【強化学習】Keras-rlでApe-Xを実装/解説（並列プログラミング）](https://qiita.com/pocokhc/items/980640c6a7b5dc9d524e)
+ [【強化学習】2018年度最強と噂のR2D2を実装/解説してみた](https://qiita.com/pocokhc/items/3b64d747a2f36da559c3)

参考：[Pythonのthreadingとmultiprocessingを完全理解](https://qiita.com/kaitolucifer/items/e4ace07bd8e112388c75)


最初は Queue を使っていたのですが、weights のデータ量が多くボトルネックになってそうだったので、各プロセス間通信に関して調査してみました。
調査結果は以下の記事です。

+ [python3のmultiprocessingにおけるプロセス間通信の各種手法を計測してみた](https://qiita.com/pocokhc/items/836a3596df5facd00824)

これより、以下のような通信にしました。（結果としてはQueueをそのまま使っています）

![zu10.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/62b443cb-3212-ecdf-8d53-803b55946be5.png)

![zu11.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/71a8aeaa-26cc-ceac-2d25-b455b31cef92.png)

![zu12.PNG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/396150/d7d29f65-d828-afa1-dbc4-e5d38ef1376d.png)

プロセス間の情報のやりとりは共有メモリで実装しています。
書き込む人と読む人が明確に分かれているためロックも特にしていません。


## Callbacks

プロセス間通信に結構コストがかかることが分かったのと、
ActorとLeanerにまたがる処理があったので実装しました。

主に save/load とログのために作成しています。
実装したCallbackの基底クラスは以下です。


``` python:R2D2Callback
import rl.callbacks
class R2D2Callback(rl.callbacks.Callback):
    def __init__(self):
        pass

    #--- train ---

    def on_r2d2_train_begin(self):
        pass

    def on_r2d2_train_end(self):
        pass

    #--- learner ---

    def on_r2d2_learner_begin(self, learner):
        pass
    
    def on_r2d2_learner_end(self, learner):
        pass

    def on_r2d2_learner_train_begin(self, learner):
        pass

    def on_r2d2_learner_train_end(self, learner):
        pass

    #--- actor ---
    # 下記および rl.callbacks.Callback の継承メソッド

    def on_r2d2_actor_begin(self, actor_index, runner):
        pass

    def on_r2d2_actor_end(self, actor_index, runner):
        pass

```

見てわかる通り、Keras-rl の Callback を継承しています。
これは Agent でそのまま使われます。

注意点として、train、learner、actor が別のプロセスから呼ばれる事を想定している点です。
なのでこれらをまたがる処理を書いてもプロセスが違うので値は保持されません。

これらを使った save/load と log についてはパラメータ編で説明します。


## GPU

tensorflow 2.1.0 でそのままGPU実行すると以下のようなエラーがでました。

``` python
tensorflow.python.framework.errors_impl.InternalError:  Blas GEMM launch failed : a.shape=(32, 12), b.shape=(12, 128), m=32, n=128, k=12     
```

どうやら複数のプロセスでGPUを使うと出るエラーらしいです。
下記を参考に複数のプロセスでGPUを使用する設定をしています。

+ [tensorflow2.0 + kerasでGPUメモリの使用量を抑える方法](https://qiita.com/studio_haneya/items/4dfaf2fb2ac44818e7e0)
+ [InternalError: Blas GEMM launch failed #11812](https://github.com/tensorflow/tensorflow/issues/11812)

``` python
# 全プロセスに設定してほしいでの、グローバルに記載
for device in tf.config.experimental.list_physical_devices('GPU'):
    tf.config.experimental.set_memory_growth(device, True)
```

また、R2D2Managerの内部でCPUかGPUかを自動で判別する処理を書いています。

``` python
import tensorflow as tf

def train(self):
    (省略)
    if len(tf.config.experimental.list_physical_devices('GPU')) > 0:
        self.enable_GPU = True
    else:
        self.enable_GPU = False
    (省略)
```


# その他の実装
## ImageModel の拡張

NN(ニューラルネットワーク)における画像の処理層は DQN から変化がありません。
ですのでここを変更できるように拡張しました。

DQN におけるNN層は以下のような階層です。

|   |層       |概要|
|---|---------|---|
|1  |入力層    |   |
|2  |入力変換層|入力の形式を一般化する層|
|3  |画像処理層|画像処理の場合|
|4  |LSTM層   |LSTMを使用する場合|
|5  |dueling network層|dueling networkを使用する場合|
|6  |Dense層|dueling networkを使用する場合は包含される|
|7  |(出力層)|実際にはdueling network層に含まれる|


### 入力変換層の一般化

入力変換層は入力形式に対して1次元の出力(Flatten)にする層です。
以下の4種類の入力を想定して作成しています。

``` python:InputType
import enum
class InputType(enum.Enum):
    VALUES = 1    # 画像無し
    GRAY_2ch = 3  # (width, height)
    GRAY_3ch = 4  # (width, height, 1)
    COLOR = 5     # (width, height, ch)
```

#### 画像無しの入力層(VALUES)(LSTMなし)

そのまま Flatten するだけです。

``` python
input_sequence = 4
input_shape = 3

c = Input(shape=(input_sequence,) + input_shape)
# output_shape == (None, 4, 3)

c = Flatten()(c)
# output_shape == (None, 12)
```

#### 画像無しの入力層(VALUES)(LSTMあり)

同じくそのまま Flatten するだけです。
timestepsを保持するために TimeDistributed でラップしています。

``` python
batch_size = 16
input_sequence = 4
input_shape = 3

c = Input(batch_shape=(batch_size, input_sequence,) + input_shape)
# output_shape == (16, 4, 3)

c = TimeDistributed(Flatten())(c)
# output_shape == (16, 4, 3)
```


#### グレー画像（チャンネル無し）の入力層(GRAY_2ch)(LSTMなし)

DQN で使われている変換ですね。
チャンネルを input_sequence(入力サイズ)に置き換えます。

``` python
input_sequence = 4
input_shape = (84, 84)  #(widht, height)

c = Input(shape=(input_sequence,) + input_shape)
# output_shape == (None, 4, 84, 84)

c = Permute((2, 3, 1))(c)  # 順序を入れかえる層
# output_shape == (None, 84, 84, 4)

c = 画像処理層(c)
```


#### グレー画像（チャンネル無し）の入力層(GRAY_2ch)(LSTMあり)

LSTMが有効の場合は sequence 情報を timesteps で補う事が出来るので、
チャンネル層を増やしています。

``` python
batch_size = 16
input_sequence = 4
input_shape = (84, 84)  #(widht, height)

c = Input(batch_shape=(batch_size, input_sequence,) + input_shape)
# output_shape == (16, 4, 84, 84)

c = Reshape((input_sequence, ) + input_shape + (1,) )(c)  # チャンネル層を追加
# output_shape == (16, 4, 84, 84, 1)

c = 画像処理層(c)
```


#### 画像（チャンネルあり）の入力層(GRAY_3ch、COLOR)(LSTMなし)

そのまま画像処理層に渡します。
ただ、input_sequenceの情報は表現できません。

``` python
input_sequence = 4
input_shape = (84, 84, 3)  #(widht, height, channel)

c = Input(shape=input_shape)
# output_shape == (None, 84, 84, 3)

c = 画像処理層(c)
```


#### 画像（チャンネルあり）の入力層(GRAY_3ch、COLOR)(LSTMあり)

違いはありません。

``` python
batch_size = 16
input_sequence = 4
input_shape = (84, 84, 3)  #(widht, height, channel)

c = Input(batch_shape=(batch_size, input_sequence,) + input_shape)
# output_shape == (16, 4, 84, 84, 3)

c = 画像処理層(c)
```


### 画像処理層の一般化

ImageModel クラスを定義して層を変更できるようにしています。

create_image_model の引数cは以下の形式で渡されます。

```
LSTMなし：shape(batch_size, width, height, channel) 
LSTMあり：shape(batch_size, timesteps, width, height, channel)
```

戻り値は以下の形式にする必要があります。

```
LSTMなし：shape(batch_size, dim) 
LSTMあり：shape(batch_size, timesteps, dim)
```

以下は DQN 形式の例です。

``` python:DQNImageModel
class DQNImageModel(ImageModel):
    """ native dqn image model
    https://arxiv.org/abs/1312.5602
    """

    def create_image_model(self, c, enable_lstm):
        """
        c shape(batch_size, width, height, channel)
        return shape(batch_size, dim)
        """

        if enable_lstm:
            c = TimeDistributed(Conv2D(32, (8, 8), strides=(4, 4), padding="same"), name="c1")(c)
            c = Activation("relu")(c)
            
            c = TimeDistributed(Conv2D(64, (4, 4), strides=(2, 2), padding="same"), name="c2")(c)
            c = Activation("relu")(c)
            
            c = TimeDistributed(Conv2D(64, (3, 3), strides=(1, 1), padding="same"), name="c3")(c)
            c = Activation("relu")(c)
            
            c = TimeDistributed(Flatten())(c)

        else:
                
            c = Conv2D(32, (8, 8), strides=(4, 4), padding="same", name="c1")(c)
            c = Activation("relu")(c)

            c = Conv2D(64, (4, 4), strides=(2, 2), padding="same", name="c2")(c)
            c = Activation("relu")(c)

            c = Conv2D(64, (3, 3), strides=(1, 1), padding="same", name="c3")(c)
            c = Activation("relu")(c)

            c = Flatten()(c)
        return c
```


## Policy(方策)の拡張
以前の解説記事は以下です。

+ [【強化学習】複数の探索ポリシーを実装/解説して比較してみた(多腕バンディット問題)](https://qiita.com/pocokhc/items/fd133053fa309bdb58e6)

DQNでは ε-greedy 法の探索ポリシーしか使われませんが、上記記事でいくつか紹介したポリシーがあります。
一応それらも使えるように実装しましたが…、 ε-greedy だけあれば十分なような…。
詳細はパラメータ編で説明予定です。


# あとがき
とりあえず実装させました。
次回は各パラメータについてどう設定すればいいのかサンプルを記事にしたいと思います。


# 論文リンク集
+ [DQN (Playing Atari with Deep Reinforcement Learning)](http://arxiv.org/pdf/1312.5602.pdf)
+ [Double DQN (Deep Reinforcement Learning with Double Q-learning](https://arxiv.org/abs/1509.06461)
+ [Prioritized Experience Replay](https://arxiv.org/abs/1511.05952)
+ [Dueling Network (Dueling Network Architectures for Deep Reinforcement Learning)](https://arxiv.org/pdf/1511.06581.pdf)
+ [Multi-Step learning (Multi-Step Reinforcement Learning: A Unifying Algorithm)](https://arxiv.org/pdf/1703.01327.pdf)
+ [Noisy Network (Noisy Networks for Exploration)](https://arxiv.org/abs/1706.10295)
+ [Categorical DQN (A Distributional Perspective on Reinforcement Learning)](https://arxiv.org/abs/1707.06887)
+ [Rainbow (Rainbow: Combining Improvements in Deep Reinforcement Learning)](https://arxiv.org/pdf/1710.02298.pdf)
+ [Ape-X (DISTRIBUTED PRIORITIZED EXPERIENCE REPLAY)](https://openreview.net/pdf?id=H1Dy---0Z)
+ [DRQN (Deep Recurrent Q-Learning for Partially Observable MDPs)](https://arxiv.org/abs/1507.06527)
+ [R2D2 (Recurrent Experience Replay in Distributed Reinforcement Learning)](https://openreview.net/forum?id=r1lyTjAqYX)