メインコンテンツへスキップ
見出し画像

Gymで強化学習⑱Q学習:実装編

    前回は、オンポリシーのTD学習法としてSARSAを実装しました。今回は、オフポリシーのTD学習法としてQ学習を実装します。

    Q学習の仕組みと実装

    TD学習法で状態価値関数を更新する方法は次のような更新式でした。

    v(st)←v(st)+α[rt+γv(st+1)−v(st)]v(s_t)\leftarrow v(s_t) + \alpha \left[ r_t + \gamma v(s_{t+1}) - v(s_t) \right]

    動的計画法のように環境のモデル(状態遷移の確率)を与えられていないので、モンテカルロ法やTD学習法ではポリシーによる探索を通して経験を集める必要があります。よって何らかのポリシーを使ってエージェントをコントロールしながらさまざまな状態遷移の経験を繰り返し集めていきます。

    その手法として大きく分けてオンポリシーとオフポリシーがあります。TD学習法のオンポリシーの代表として前回はSARSAを実装しました。

    オンポリシーでは、探索するためのポリシーと最適化するポリシーが同じであり、実装が単純であるのが利点です。それに対して、オフポリシーの実装はより複雑になります。

    例えば、モンテカルロ法でのオンポリシーとオフポリシーでは、オフポリシーの方がずっと複雑でした。重点サンプリングの計算をする必要があったのを面倒だと覚えている方もいるかと思います。

    ところが、オフポリシーのTD学習法であるQ学習の実装はオンポリシーのSARSAとほとんど同じです。

    まずは、SARSAの実装の要点をおさらいしましょう。SARSAにおける行動価値関数の更新式は次のようになっていました。

    q(st,at)←q(st,at)+α[rt+γq(st+1,at+1)−q(st,at)]q(s_t, a_t) \leftarrow q(s_t, a_t) + \alpha \left[ r_t + \gamma q(s_{t+1}, a_{t+1}) - q(s_t, a_t) \right]

    ここではブートストラッピングが使われており、q(st+1,at+1)q(s_{t+1}, a_{t+1})が返す次の状態における行動価値の予測を使って現在の行動価値の予測q(st,at)q(s_t, a_t)を更新しています。これを繰り返すことでポリシーが最適化されるわけですが、この時に、次の状態における行動at+1a_{t+1}の選び方が探索をするためのポリシーと同じであるのでオンポリシーと呼ばれています。

    SARSAを実装したコードでは探索における行動を選ぶのと同じファンクション self._choose_action を呼び出して次の行動を決めていました。

    実装では、rt+γq(st+1,at+1)r_t + \gamma q(s_{t+1}, a_{t+1})に相当する部分は以下のようになっていました。

    # オンポリシーなので、行動価値の更新でも同じポリシーを使う
    next_action = self._choose_action(next_state)
    new_q_value = reward + self.gamma * self.Q[next_state, next_action]

    この行動選択では、イプシロン・グリーディによるランダムな行動選択も含まれており、行動価値の更新が現状の予測による最適な行動を必ず選ぶわけではないことが特徴です。つまり、最適化のターゲットとしているポリシー自体にランダム性が含まれていることになります。

    しかし、イプシロンは徐々に低減していくので最終的には行動価値関数もランダム性のない最適なポリシーに従うものへと収束していきます。

    一方、オフポリシーの強化学習では、探索するための挙動ポリシーと最適化するためのターゲットポリシーを分けて考えます。

    挙動ポリシーはあらゆる状態であらゆる行動をとる可能性のあるソフトポリシーを使います。前回のSARSAの実装と同様で、今回もイプシロン・グリーディで実装します。よって、経験を集めるための行動選択のコードは同じになります。

    唯一の違いは、行動価値の更新におけるターゲットとして、行動価値関数が最大の値を返す行動を選ぶポリシーにすることだけです。

    q(st,at)←q(st,at)+α[rt+γmax⁡aq(st+1,a)−q(st,at)]q(s_t, a_t) \leftarrow q(s_t, a_t) + \alpha \left[ r_t + \gamma \max\limits_a q(s_{t+1}, a) - q(s_t, a_t) \right]

    max⁡aq(st+1,a)\max\limits_a q(s_{t+1}, a)となっているのは、次の状態st+1s_{t+1}で選ぶ行動aaは行動価値を最大にするものとしているからです。こうすることでターゲットのポリシーは、常に現状の行動価値の予測で最適となる行動をとることになります。

    オフポリシーの良いところはターゲットとしているのが何であるのかが明確である上、挙動ポリシーをより異なるものできる自由度があります。今回はイプシロン・グリーディを使っていますが、環境によってはもっと異なるソフトポリシーを使う方が良い結果が出る可能性があります。

    以下は、rt+γmax⁡aq(st+1,a)r_t + \gamma \max\limits_a q(s_{t+1}, a)に相当する部分をコード化したものです。

    # オフポリシーなので、ターゲットポリシーに従って最大行動価値を使って更新する
    new_q_value = reward + self.gamma * np.max(self.Q[next_state])

    コード変更としては、あとはエージェントのクラスの名前の変更ぐらいになり、ほぼSARSAのコードと同じです。

    ではソースコードのリストと実行の仕方を解説します。

    ソースコードの実行

    ソースコード

    import argparse
    import gymnasium as gym
    import numpy as np
    
    
    class QLearningAgent:
        def __init__(self, env, alpha, gamma, epsilon, epsilon_decay):
            self.env = env
            self.alpha = alpha
            self.gamma = gamma
            self.epsilon = epsilon
            self.epsilon_decay = epsilon_decay
    
            # 行動価値関数の初期化
            self.Q = np.zeros((env.observation_space.n, env.action_space.n))
    
        def reset(self, observation, info):
            self.state = observation
    
        def act(self):
            self.action = self._choose_action(self.state)
            return self.action
        
        def _choose_action(self, state):
            if np.random.rand() < self.epsilon:
                action = np.random.choice(self.env.action_space.n)
            else:
                # 最大値の行動が複数ある場合はランダムに選択する
                max_q_value = np.max(self.Q[state])
                max_q_value_indices = np.nonzero(self.Q[state] == max_q_value)[0]
                action = np.random.choice(max_q_value_indices)
            return action
    
        def learn(self, observation, reward, terminated, truncated, info):
            # Q学習による行動価値関数の更新
            next_state = observation
    
            if terminated: 
                # エピソードが終了した場合は次の状態と行動は存在しない
                new_q_value = reward
            else:
                # オフポリシーなので、ターゲットポリシーに従って最大行動価値を使って更新する
                new_q_value = reward + self.gamma * np.max(self.Q[next_state])
            
            # TDエラー
            td_error = new_q_value - self.Q[self.state, self.action]
            
            # 行動価値関数を更新する
            self.Q[self.state, self.action] += self.alpha * td_error
    
            # エピソード終了処理
            if terminated or truncated:
                # 行動価値関数を表示する
                print_q_table(self.Q)
                print(f'Epsilon: {self.epsilon:.2f}\n')
    
                # イプシロンを徐々に減らしていく
                self.epsilon *= self.epsilon_decay
    
            # 状態を更新する
            self.state = next_state
                
    
    def print_q_table(Q):
        num_states, num_actions = Q.shape
    
        # 1行目:タイトル
        print("State |", end="")
        for action in range(num_actions):
            print(f"  Action {action} |", end="")
        print()
    
        # 2行目:区切り
        print("-" * (9 + num_actions * 12))
    
        # 3行目以降:状態と行動価値関数
        for state in range(num_states):
            print(f"{state:5} |", end="")
            for action in range(num_actions):
                print(f" {Q[state][action]:8.2f}  |", end="")
            print()
    
    
    def run_episodes(env, agent, max_episodes):
    
        # エピソードのループをmax_episodes回繰り返す
        for episode in range(max_episodes):
            print(f'エピソード: {episode+1}')
    
            # ゲーム環境を初期化してエージェントに初期観測値を渡す
            observation, info = env.reset()
            agent.reset(observation, info)
    
            # 1つのエピソードのループ
            while True:
                # エージェントの行動を決定
                action = agent.act()
    
                # 行動を実行すると、環境の状態が更新される
                observation, reward, terminated, truncated, info = env.step(action)
    
                # エージェントの学習
                agent.learn(observation, reward, terminated, truncated, info)
    
                # ゲームが終了したら、次のエピソードへ
                if terminated or truncated:
                    break
    
        # 環境を閉じる
        env.close()
    
    
    def main():
        # コマンドライン引数を取得
        parser = argparse.ArgumentParser()
        parser.add_argument("--map"          , type=str  , default="4x4")
        parser.add_argument("--slippery"     , action="store_true")
        parser.add_argument("--alpha"        , type=float, default=0.1)
        parser.add_argument("--gamma"        , type=float, default=0.9)
        parser.add_argument("--epsilon"      , type=float, default=1.0)
        parser.add_argument("--epsilon_decay", type=float, default=0.99)
        parser.add_argument("--max_episodes" , type=int  , default=1000)
        parser.add_argument("--no_render"    , action="store_true")
        args = parser.parse_args()
        args.render_mode = "human" if not args.no_render else None
        print(args)
    
        # 環境を作成
        env = gym.make('FrozenLake-v1',
                       map_name=args.map,
                       is_slippery=args.slippery,
                       render_mode=args.render_mode)
        
        # エージェントを作成
        agent = QLearningAgent(env,
                           alpha=args.alpha,
                           gamma=args.gamma,
                           epsilon=args.epsilon,
                           epsilon_decay=args.epsilon_decay)
    
        # エピソードを実行
        run_episodes(env, agent, max_episodes=args.max_episodes)
    
    
    if __name__ == "__main__":
        main()

    実行の仕方

    ソースコードを frozen_lake_ql.py といったファイルにセーブしておきます。

    Python環境は準備編で設定したのと同じです。

    なお、実行する際に幾つかのパラメータを指定できます。

    usage: frozen_lake_ql.py [-h] [--map MAP] [--slippery] [--alpha ALPHA] 
                             [--gamma GAMMA] [--epsilon EPSILON]
                             [--epsilon_decay EPSILON_DECAY] 
                             [--max_episodes MAX_EPISODES] [--no_render]
    
    options:
      -h, --help            show this help message and exit
      --map MAP
      --slippery
      --alpha ALPHA
      --gamma GAMMA
      --epsilon EPSILON
      --epsilon_decay EPSILON_DECAY
      --max_episodes MAX_EPISODES
      --no_render

    例えば、以下のように実行すると is_slippery=True として環境が作成されます。

    python frozen_lake_ql.py --slippery

    画像なしで高速に実行したい場合は、次のように実行します。

    python frozen_lake_ql.py --no_render

    これでもコンソールに状態価値関数がエピソードごとに表示されるので更新される様子がわかります。

    実行結果

    SARSAの実装でも見たように、最初にゴールに到着するまでは行動価値関数は全てゼロのままです。なぜならゴールに到着するまでは報酬はゼロだからです。穴に落ちてもペナルティもありません。なので場合によってはかなり長い間ランダムな行動をしていることもあります。

    一旦ゴールに到着すると、ゴール付近の行動価値関数の値が更新されます。その後のエピソードでエージェントが再びその付近の状態を訪れることで少しずつ行動価値関数の更新が広がっていきます。

    いずれにせよ、Q学習でもSARSAと同じように最適化されたポリシーが出現します。以下は滑らない条件で最適化した様子です。

    画像

    エピソードを1000回繰り返した後の、行動価値関数は以下のようになりました。

    State |  Action 0 |  Action 1 |  Action 2 |  Action 3 |
    ---------------------------------------------------------
        0 |     0.20  |     0.59  |     0.05  |     0.11  |
        1 |     0.24  |     0.00  |     0.00  |     0.00  |
        2 |     0.00  |     0.00  |     0.00  |     0.00  |
        3 |     0.00  |     0.00  |     0.00  |     0.00  |
        4 |     0.22  |     0.66  |     0.00  |     0.19  |
        5 |     0.00  |     0.00  |     0.00  |     0.00  |
        6 |     0.00  |     0.00  |     0.00  |     0.00  |
        7 |     0.00  |     0.00  |     0.00  |     0.00  |
        8 |     0.30  |     0.00  |     0.73  |     0.32  |
        9 |     0.45  |     0.81  |     0.09  |     0.00  |
       10 |     0.01  |     0.53  |     0.00  |     0.00  |
       11 |     0.00  |     0.00  |     0.00  |     0.00  |
       12 |     0.00  |     0.00  |     0.00  |     0.00  |
       13 |     0.00  |     0.45  |     0.90  |     0.20  |
       14 |     0.00  |     0.15  |     1.00  |     0.10  |
       15 |     0.00  |     0.00  |     0.00  |     0.00  |

    実際の値は、毎回異なりますがおおよそ似たような行動価値になります。

    例えば、状態0では行動1(下へ移動)が最大価値になり、状態4へ移動します。そこでも行動1が最大価値なので、さらに下の状態8へ移動します。今度は行動2(右へ移動)が最大価値となり状態9へ移動します。以上のように移動を繰り返しゴールへと到着するようになっています。

    画像

    次のように滑る環境で実行してみます。エピソードの数を増やして、イプシロンの低減率を減らし、長く探索するようにしました。また、ステップサイズも小さくして新しい情報を取り入れるスピードを落としました。

    python frozen_lake_ql.py --no_render --slippery \
                             --max_episodes 10000 --epsilon_decay 0.999 \
                             --alpha 0.05

    結果として、行動関数は次のようになりました。

    State |  Action 0 |  Action 1 |  Action 2 |  Action 3 |
    ---------------------------------------------------------
        0 |     0.07  |     0.05  |     0.05  |     0.05  |
        1 |     0.04  |     0.03  |     0.04  |     0.07  |
        2 |     0.09  |     0.05  |     0.05  |     0.05  |
        3 |     0.02  |     0.02  |     0.02  |     0.04  |
        4 |     0.09  |     0.06  |     0.06  |     0.05  |
        5 |     0.00  |     0.00  |     0.00  |     0.00  |
        6 |     0.12  |     0.05  |     0.05  |     0.02  |
        7 |     0.00  |     0.00  |     0.00  |     0.00  |
        8 |     0.08  |     0.09  |     0.09  |     0.15  |
        9 |     0.14  |     0.28  |     0.17  |     0.13  |
       10 |     0.30  |     0.17  |     0.19  |     0.08  |
       11 |     0.00  |     0.00  |     0.00  |     0.00  |
       12 |     0.00  |     0.00  |     0.00  |     0.00  |
       13 |     0.19  |     0.26  |     0.38  |     0.26  |
       14 |     0.43  |     0.70  |     0.45  |     0.45  |
       15 |     0.00  |     0.00  |     0.00  |     0.00  |

    穴に落ちるのを避けるようにしながらゴールへと到達できるようなポリシーになっています。もちろん、ここでも行動価値の値は毎回異なります。

    次回への展望

    これまで、凍った湖の環境を使ってきました。それは、行動価値関数をテーブルとして表現しやすいグリッドワールドの環境だったからです。

    そこでは、状態の値や行動の選択肢などが限られており、理解しやすくはなっています。しかし、より連続な値の状態を扱う必要のある環境では適用するのが難しくなります。

    よって、次回はテーブル形式の行動価値関数を超えて、状態が連続値になる環境に対応するにはどうすれば良いのかを議論します。

    (続く)

     
     
    「わかりやすく、具体的に」AIとサイエンスの情報を発信中

    あなたへのおすすめ