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

Gymで強化学習㊸Actor-Critic:実践編

    前回は、ActorCriticの理論的な面を解説しました。今回は、前々回と同様にマウンテン・カー(連続値)の環境を使い実験を行います。

    コード上での変更部分は、それほど多くはなく主に訓練ループの部分が変わります。ただし、ActorCriticでは、毎ステップでポリシーのパラメータを更新するために過学習になりやすく学習が不安定となる問題があります。今回は、どのように対処したのかについても解説します。

    なお、マウンテン・カーの連続値版の環境の詳細は、前々回の記事を参照してください。

    それでは、さっそく始めましょう。

    ポリシーの定義

    今回のポリシーは次のように定義しました。

    # ポリシーの定義
    class PolicyNetwork(nn.Module):
        def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
            super().__init__()
    
            # 特徴量抽出部分
            self.feature = nn.Sequential(
                nn.Linear(input_dim, hidden_dim),
                nn.ReLU(),
            )
    
            # 行動平均予測部分
            self.action_mean = nn.Sequential(
                nn.Linear(hidden_dim, output_dim)
            )
    
            # 状態価値予測部分
            self.state_value = nn.Sequential(
                nn.Linear(hidden_dim, 1)
            )
    
        def forward(self, x) -> Tuple[torch.Tensor, torch.Tensor]:
            # 特徴量抽出
            x = self.feature(x)
    
            # 行動平均予測
            action_mean = self.action_mean(x)
    
            # 状態価値予測
            state_value = self.state_value(x)
    
            # 行動の平均予測と状態価値予測を返す
            return action_mean, state_value

    気づいた方もいるかもしれません。実は、この実装はREINFORCEの実践で行ったものと全く同じです。よって、REINFORCEとActorCriticでは、主に訓練の仕方が異なります。そのため、ポリシーのクラスの実装は、わざとそのままにしてあります。

    もちろん、self.action_mean を self.actor と呼んだり、self.state_value を self.critic と呼ぶこともできますが、やっていることは以前のものと同じです。

    また、そのほかの部分の実装も同じものを使用しています。今回異なるのは、訓練を行う部分とメインのみです。

    訓練の実装

    trainの定義

    それでは、train から解説します。

    def train(env: gym.Env,
              max_episodes: int,
              policy: PolicyNetwork,
              device: torch.device,
              optimizer: optim.Optimizer,
              gamma: float):

    この定義も前回とほぼ同じですが、一つだけ違いがあります。それはベースラインを使うかどうかのフラグがないことです。ActorCriticはCriticが計算する状態価値の予測を必ず使うので、自然とREINFORCEでベースラインがあるのと同じだからです。

    訓練ループの始まり

    訓練ループの始まる部分も基本的には前回と同じです。ただし、前回に報酬や損失値を集めるリストを初期化していたのに対し、今回は報酬や損失値の合計を計算する変数を定義しています。

        # 訓練ループ
        total_rewards = [] # グラフ描画用に報酬の合計を保存するリスト
        for episode in range(max_episodes):
            # 環境の初期化
            state, info = env.reset(seed=episode)
    
            # 総報酬などを記録する変数
            total_reward = 0
            total_train_reward = 0
            total_policy_loss = 0
            total_value_loss = 0
            
            # 標準偏差を徐々に小さくする
            action_std = 1.0 - episode / max_episodes
    

    また、行動の値を選ぶ際の標準偏差の設定をしているところは前回と同じです。

    行動の選択

    行動の選択も前回と同じです。ポリシーが状態から予測した行動の平均値(action_mean)とエピソードごとに設定した行動の標準偏差(action_std)を使って正規分布(Normal)から行動の値のサンプルを取得します。

    # エピソード実行
    while True:
        # 状態をテンソルに変換
        state = torch.as_tensor(state, dtype=torch.float).to(device)
    
        # ポリシーで行動平均と状態価値を予測
        action_mean, state_value = policy(state)
    
        # 行動を確率的に選択(標準偏差固定で探索)
        action_dist = torch.distributions.Normal(action_mean, scale=action_std)
        action = action_dist.sample()
    
        # 対数確率を計算
        log_prob = action_dist.log_prob(action)

    また、行動のサンプル値の確率の対数(log_prob)を計算しています。これも以前と同様です。

    行動の実行

    環境に行動の値を渡して、次の状態、報酬、終了のフラグなどを受け取ります。これも以前と同じです。

        # 行動を実行
        state, reward, terminated, truncated, info = env.step(action.cpu().numpy())
        total_reward += reward

    訓練用の報酬

    訓練用の報酬も以前と同じものとしました。なぜなら、こうすることで以前の実装との比較がしやすいくなるからです。

        # 訓練用報酬を計算
        position_bonus = state[0] - env.observation_space.low[0] # 位置の値を報酬に追加
        velocity_bonus = np.abs(state[1]) # 速度の絶対値を報酬に加える
        train_reward = reward + position_bonus + velocity_bonus
        total_train_reward += train_reward

    また、これがベストな報酬構造であるかは検討の余地がありますが、前回うまくいったのでその点安心でもあります。

    次の状態の価値予測

    ここから、ActorCritic独自のロジックが始まります。ActorCriticでは、TDエラーを使うので、終了状態でなければ、次の状態の価値の予測が必要となります。

        # 次の状態の状態価値を計算
        next_state_value = 0
        if not terminated: # 終了状態でなければ、次の状態の状態価値を計算する
            next_state = torch.as_tensor(state, dtype=torch.float).to(device)
            _, next_state_value = policy(next_state)

    よって、環境から返された状態を使って、その状態価値を予測します。これは、ポリシーの中の self.state_value(Critic)が予測した値です。

    TDエラー(デルタ)

    理論編で解説したように以下のデルタ(δ\delta)を計算します。

    δ=rt+γvπθ(st+1)−vπθ(st)\delta = r_t + \gamma v_{\pi_\theta}(s_{t+1}) - v_{\pi_\theta}(s_t)

    γ\gammaは割引率です。rt+γvπθ(st+1)r_t + \gamma v_{\pi_\theta}(s_{t+1})は、新しい情報(報酬rtr_t)を取り入れた現在状態の価値予測で、vπθ(st)v_{\pi_\theta}(s_t)は、以前の情報のみによる現在状態の価値予測です。この差がデルタです。

        # TDエラー(デルタ)を計算
        delta = train_reward + gamma * next_state_value - state_value

    これは前回では、エピソードの終了後に報酬のリストを過去へと遡りながら計算した部分に相当します。ただし、ActorCriticではステップごとに学習するので、このようにブートストラッピングをしながらデルタの計算をしています。

    なお、デルタの値は二つの損失値の計算に使われます。

    Actorの損失値

    一つは、ポリシー勾配を計算するためです。これにはActorが予測した行動確率の対数とデルタを含んでいます。つまり、デルタは行動の評価値です。評価の高い行動に対しての確率が高くなるように、損失値としては、行動確率の対数とデルタの積のマイナスを使います。

        # アクターによる損失値を計算
        policy_loss = -log_prob * delta.detach()
        policy_loss = 0.1 * policy_loss # 重み付けして調整
        total_policy_loss += policy_loss.item()

    なお、このでのデルタは評価のための値なので、delta.detach() で勾配の計算からは除外されています。ここでは、あくまで行動選択の確率の良し悪しを評価しているからです。

    また、Actorの損失値に重みをつけてもう一つの損失値(Criticの損失値)とのバランスをとっています。これは、幾つか異なる値を試して学習の進展具合を見ながら調節しました。損失値のバランスが悪いと、ActorとCriticの学習の進呈具合に差ができてしまい、学習が不安定となるからです。これについては、前回も同様な(値は違いますが)重み付けを行いました。

    Criticの損失値

    これも考え方は前回と同じですが、報酬のリストを使わずに、デルタの値の2乗をCriticの損失値としています。

        # クリティックによる損失値を計算
        value_loss = delta ** 2
        total_value_loss += value_loss.item()

    ここでのデルタは勾配の値に影響するべきなので detach() を使いません。

    パラメータの更新

    パラメータの更新も基本的には前回と同じですが、勾配の大きさを制限するコード(clip_grad_norm_)を追加しています。毎ステップの更新だと、勾配の大小も大きく異なる可能性があるので、勾配が大きくなりすぎないようにしています。実際、これを追加しないと学習が安定しません。

        # ポリシーを更新
        optimizer.zero_grad()
        (policy_loss + value_loss).backward()
    
        # 勾配の大きさを制限する
        torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0) 
        
        optimizer.step()

    エピソード終了

    これはいつも同じですね。

    
        # 終了ならエピソードのループを抜け出す
        if terminated or truncated:
            break

    メインの引数

    このプログラムのデフォルトの引数は以下になっています。以前との違いがわかりますか。

    def main():
        # 引数の解析
        parser = argparse.ArgumentParser()
        parser.add_argument('--max_episodes', type=int,   default=10)
        parser.add_argument('--hidden_dim',   type=int,   default=16)
        parser.add_argument('--device',       type=str,   default=None)
        parser.add_argument('--lr',           type=float, default=1e-2) # 学習率
        parser.add_argument('--gamma',        type=float, default=0.99) # 割引率
        parser.add_argument('--seed',         type=int,   default=123)
        parser.add_argument('--test',         action='store_true')
        parser.add_argument('--render',       action='store_true')
        args = parser.parse_args()
    

    今回は、エピソードの数を10にしています。これ以下だと学習が十分でなく、これ以上だと学習が安定しません。毎ステップでのパラメータ更新により、過学習が起きていると考えられます。以前は、エピソードの数が500と比べると学習の速さがうかがえます。

    また、ニューロンの数(hidden_dim)を16としています。これも過学習を防ぐために大幅に減少させました。以前は、128だったのと比べると大きな差があります。

    実は、これらの設定が学習を安定させるのに大きく影響しました。バッチ処理も経験再生メモリーもないので不安定になりがちなのは致し方がありませんが、程よいハイパーパラメータを探すのは試行錯誤を必要とします。

    また、ベースラインのオプションは必要ないので無くなっています。

    以上で、ActorCriticの実装とREINFORCEの実装との違いの解説になります。

    ソースコードの実行

    ソースコード

    今回の全体のソースコードです。

    import argparse
    import gymnasium as gym
    import matplotlib.pyplot as plt
    import numpy as np
    import random
    import torch
    import torch.nn as nn
    import torch.optim as optim
    from typing import Tuple, List
    
    
    # ポリシーの定義
    class PolicyNetwork(nn.Module):
        def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
            super().__init__()
    
            # 特徴量抽出部分
            self.feature = nn.Sequential(
                nn.Linear(input_dim, hidden_dim),
                nn.ReLU(),
            )
    
            # 行動平均予測部分
            self.action_mean = nn.Sequential(
                nn.Linear(hidden_dim, output_dim)
            )
    
            # 状態価値予測部分
            self.state_value = nn.Sequential(
                nn.Linear(hidden_dim, 1)
            )
    
        def forward(self, x) -> Tuple[torch.Tensor, torch.Tensor]:
            # 特徴量抽出
            x = self.feature(x)
    
            # 行動平均予測
            action_mean = self.action_mean(x)
    
            # 状態価値予測
            state_value = self.state_value(x)
    
            # 行動の平均予測と状態価値予測を返す
            return action_mean, state_value
    
    
    # ポリシーの作成
    def make_policy_network(env: gym.Env, hidden_dim: int) -> PolicyNetwork:
        # ポリシーの初期化
        input_dim = env.observation_space.shape[0] # 2 (位置、速度)
        output_dim = env.action_space.shape[0] # 1 (-1.0 ~ 1.0)
    
        return PolicyNetwork(input_dim, hidden_dim, output_dim)
    
    
    # デバイスの作成
    def make_device(device: str = None) -> torch.device:
        # 引数で指定されたデバイスがあればそれを使う
        if device is not None:
            return torch.device(device)
        
        # 引数で指定されていない場合は、以下の優先順位でデバイスを選択する
        if torch.cuda.is_available(): 
            # CUDA(NVIDIA GPU)が使えるならそれを使う
            device = torch.device("cuda")
        elif torch.backends.mps.is_available():
            # MPS(アップル・シリコン)が使えるならそれを使う
            device = torch.device("mps")
        else:
            # それ以外はCPUを使う
            device = torch.device("cpu")
        
        return device
    
    
    # シードの設定
    def set_seed(env: gym.Env, seed: int, device: torch.device):
        # 環境のシードを設定する
        env.action_space.seed(seed)
    
        # NumPyなどのシードを設定する
        random.seed(seed)
        np.random.seed(seed)
    
        # PyTorchのシードを設定する
        torch.manual_seed(seed)
    
        if device.type == 'cuda':
            # CUDAのシードを設定する
            torch.cuda.manual_seed(seed)
            torch.backends.cudnn.deterministic = True
            torch.backends.cudnn.benchmark = False
        elif device.type == 'mps':
            # MPSのシードを設定する
            torch.mps.manual_seed(seed)
    
    
    def train(env: gym.Env,
              max_episodes: int,
              policy: PolicyNetwork,
              device: torch.device,
              optimizer: optim.Optimizer,
              gamma: float):
    
        # 訓練ループ
        total_rewards = [] # グラフ描画用に報酬の合計を保存するリスト
        for episode in range(max_episodes):
            # 環境の初期化
            state, info = env.reset(seed=episode)
    
            # 総報酬などを記録する変数
            total_reward = 0
            total_train_reward = 0
            total_policy_loss = 0
            total_value_loss = 0
            
            # 標準偏差を徐々に小さくする
            action_std = 1.0 - episode / max_episodes
    
            # エピソード実行
            while True:
                # 状態をテンソルに変換
                state = torch.as_tensor(state, dtype=torch.float).to(device)
    
                # ポリシーで行動平均と状態価値を予測
                action_mean, state_value = policy(state)
    
                # 行動を確率的に選択(標準偏差固定で探索)
                action_dist = torch.distributions.Normal(action_mean, scale=action_std)
                action = action_dist.sample()
    
                # 対数確率を計算
                log_prob = action_dist.log_prob(action)
    
                # 行動を実行
                state, reward, terminated, truncated, info = env.step(action.cpu().numpy())
                total_reward += reward
    
                # 訓練用報酬を計算
                position_bonus = state[0] - env.observation_space.low[0] # 位置の値を報酬に加える
                velocity_bonus = np.abs(state[1]) # 速度の絶対値を報酬に加える
                train_reward = reward + position_bonus + velocity_bonus
                total_train_reward += train_reward
    
                # 次の状態の状態価値を計算
                next_state_value = 0
                if not terminated: # 終了状態でなければ、次の状態の状態価値を計算する
                    next_state = torch.as_tensor(state, dtype=torch.float).to(device)
                    _, next_state_value = policy(next_state)
    
                # TDエラー(デルタ)を計算
                delta = train_reward + gamma * next_state_value - state_value
                
                # アクターによる損失値を計算
                policy_loss = -log_prob * delta.detach()
                policy_loss = 0.1 * policy_loss # 重み付けして調整
                total_policy_loss += policy_loss.item()
    
                # クリティックによる損失値を計算
                value_loss = delta ** 2
                total_value_loss += value_loss.item()
    
                # ポリシーを更新
                optimizer.zero_grad()
                (policy_loss + value_loss).backward()
                torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0) # 勾配の大きさを制限する
                optimizer.step()
    
                if terminated or truncated:
                    break
    
            # 報酬の合計を保存
            total_rewards.append(total_reward)
    
            # ログの出力
            print(f"Episode {episode+1:4d}, Total Reward: {total_reward:8.2f}, " +
                  f"Train Reward: {total_train_reward:8.2f}, " +
                  f"Loss: {total_policy_loss + total_value_loss:8.2f}, " +
                  f"P_Loss: {total_policy_loss:8.2f}, V_Loss: {total_value_loss:8.2f}, " +
                  f"Noise: {action_std:8.2f}, Goal: {terminated}")
    
        # 結果の描画を保存
        plt.plot(total_rewards)
        plt.xlabel('Episode')
        plt.ylabel('Reward')
        plt.ylim(-100, 100)
        fig_path = 'mcar-actor-critic.png'
        plt.savefig(fig_path)
    
    
    def save_policy(policy: PolicyNetwork, save_path: str):
        # ポリシーの保存
        state_dict = policy.cpu().state_dict() # CPUに移動してから保存する
        torch.save(state_dict, save_path)
    
    
    def load_policy(policy: PolicyNetwork, load_path: str, device: torch.device):
        # ポリシーの読み込み
        state_dict = torch.load(load_path, map_location=device)
        policy.load_state_dict(state_dict)
    
    
    def test(env: gym.Env,
             policy: PolicyNetwork,
             device: torch.device):
        
        # テストループ
        for episode in range(5):
            # 環境の初期化
            state, info = env.reset(seed=episode)
    
            # 報酬の保存用リスト
            rewards = []
    
            while True:
                # 状態をテンソルに変換
                state = torch.as_tensor(state, dtype=torch.float).to(device)
    
                # 行動の確率を計算
                with torch.no_grad():
                    action_mean, _ = policy(state)
    
                # 行動を実行
                state, reward, terminated, truncated, info = env.step(action_mean.cpu().numpy())
                
                # 報酬を保存
                rewards.append(reward)
                
                if terminated or truncated:
                    break
            
            print(f"Episode {episode+1}, Total Reward: {sum(rewards):6.2f} Goal: {terminated}")
    
    
    def main():
        # 引数の解析
        parser = argparse.ArgumentParser()
        parser.add_argument('--max_episodes', type=int,   default=10)
        parser.add_argument('--hidden_dim',   type=int,   default=16)
        parser.add_argument('--device',       type=str,   default=None)
        parser.add_argument('--lr',           type=float, default=1e-2) # 学習率
        parser.add_argument('--gamma',        type=float, default=0.99) # 割引率
        parser.add_argument('--seed',         type=int,   default=123)
        parser.add_argument('--test',         action='store_true')
        parser.add_argument('--render',       action='store_true')
        args = parser.parse_args()
    
        # 環境の初期化
        render_mode = 'human' if args.test or args.render else None
        env = gym.make('MountainCarContinuous-v0', render_mode=render_mode)
    
        # デバイスの設定
        device = make_device(args.device)
    
        # シードの設定(再現性の確保)
        set_seed(env, args.seed, device)
    
        # ポリシーの初期化
        policy = make_policy_network(env, args.hidden_dim)
        policy.to(device)
    
        # ポリシーの保存先/読み込み先
        model_path = 'mcar-actor-critic.pth' 
    
        if not args.test:
            # ポリシーの訓練
            optimizer = optim.AdamW(policy.parameters(), lr=args.lr) # オプティマイザの初期化
            train(env, args.max_episodes, policy, device, optimizer, args.gamma)
    
            # ポリシーの保存
            save_policy(policy, model_path)
        else:
            # ポリシーの読み込み
            load_policy(policy, model_path, device)
    
            # ポリシーのテスト
            test(env, policy, device)
    
        # 環境の終了
        env.close()
    
    
    if __name__ == '__main__':
        main()
    

    Python環境の設定

    Python環境の設定と実行の仕方は以前と同じです。
    ただし、上記のソースコードを ac-mountaincar.py に保存してください。

    訓練結果

    訓練は次のように実行します。

    python ac-mountaincar.py

    10エピソードのみなのでわりとはやく訓練が終了します。

    各エピソードからの総報酬は以下のグラフになります。

    画像
    訓練中の報酬

    訓練中は、行動の標準偏差が1から0.1へと変化しており、ランダム性があるので総報酬としては上下していますが、10回中の6回がゴールに到着しています。

    テストは次のように実行します。

    python ac-mountaincar.py --test

    結果は次のようになりました。

    Episode 1, Total Reward:  69.87 Goal: True
    Episode 2, Total Reward:  76.44 Goal: True
    Episode 3, Total Reward:  82.35 Goal: True
    Episode 4, Total Reward:  80.83 Goal: True
    Episode 5, Total Reward:  58.91 Goal: True

    毎回ゴールに到達しています。また、総報酬の値も前回と比べると倍ほどになっています。つまり、ゴールに到着するだけでなく、あまり大きな行動の値を使わずにゴールに達しているからです。それだけペナルティが少ないからです。

    画像

    次回予告

    ActorCriticがとても強力な手法であることが実験からわかりました。しかし、学習を安定させるためのパイパーパラメータを手探りで探すのは骨が折れます。実は、ActorCriticの流れを汲む強化学習では、学習を安定化させることに努力が向けられました。

    その例として、A3C(Asynchronous Advantage Actor-Critic)があります。次回は、その仕組みを解説します。

    お楽しみに!

    (続く)

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

    あなたへのおすすめ