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

Gymで強化学習㊴REINFORCE:実践編①

    前回は、REINFORCEの理論的な側面を解説しました。今回は、REINFORCEの実装をし、Gym環境であるCartPoleを使って実験します。

    また、単純なベースラインを導入して、ベースラインがある無しで訓練の安定性やテスト結果にどのような差が出るかを確認します。

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

    ポリシーの作成

    ポリシーの定義

    ポリシーの定義は以下になります。なるべく単純になるようにしました。

    # ポリシーの定義
    class PolicyNetwork(nn.Module):
        def __init__(self, input_dim, hidden_dim, output_dim):
            super().__init__()
    
            self.network = nn.Sequential(
                nn.Linear(input_dim, hidden_dim),
                nn.ReLU(),
                nn.Linear(hidden_dim, output_dim),
                nn.Softmax(dim=-1)
            )
            
        def forward(self, x) -> torch.Tensor:
            x = self.network(x)
            return x

    ポリシーの初期化では、線形層、活性化関数(ReLU)、線形層で入力状態から特徴量を抽出し、最後にソフトマックスで行動選択の確率へと変換しています。

    nn.Sequential を使って次のようにまとめて設定しました。

            self.network = nn.Sequential(
                nn.Linear(input_dim, hidden_dim),
                nn.ReLU(),
                nn.Linear(hidden_dim, output_dim),
                nn.Softmax(dim=-1)
            )

    後で見るように、入力値の次元(input_dim)は4です。これには、以下の情報が含まれます。

    • カートの位置

    • 速度

    • 棒の角度

    • 角速度

    また、出力値の次元(output_dim)は2です。これは、次の2つの行動に対する確率を計算するためのものです。

    • 0:カートを左へ押す

    • 1:カートを右へ押す

    なお、カートポールの環境に関しては、こちらでも詳しく解説しています。

    よって、我々が指定する必要があるのは隠れ層で使う次元数(hidden_dim)のみとなります。

    ポリシーの作成

    ポリシーの作成では、環境から必要な次元数を計算します。また、隠れそうで使う次元数(hidden_dim)は引数として渡されます。

    # ポリシーの作成
    def make_policy_network(env: gym.Env, hidden_dim: int) -> PolicyNetwork:
        # ポリシーの初期化
        input_dim = env.observation_space.shape[0] # 4 (カートの位置、速度、棒の角度、角速度)
        output_dim = env.action_space.n # 2 (左、右)
    
        return PolicyNetwork(input_dim, hidden_dim, output_dim)

    デバイスの作成

    今回のポリシーネットワークでは、GPUを使う必要はあまりないですが、それでも使えるデバイスがあるならば、使ったほうが多少は処理が速くなります。

    # デバイスの作成
    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

    指定されたデバイスがあれば、それを使います。さもなければ自動的に使えるデバイスを判定して使います。

    乱数シードの固定

    実験の再現性を確保するために乱数シードを固定します。これまでに何度も登場していますが、単純に使われろうな乱数のシードを固定しています。例えば、NumPyやPyTorchで使われる乱数シードを固定し、また、指定されたデバイスに対しても乱数シードを固定しています。

    # シードの設定
    def set_seed(env: gym.Env, seed: int, device: torch.device):
        # 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)

    後で、env.reset(seed=seed) を使って環境のリセットの際にも乱数シードを固定します。

    ポリシーの訓練

    訓練ループ

    訓練ループでは、REINFORCEを実装しているので順を追って解説します。

    def train(env: gym.Env,
              max_episodes: int,
              policy: PolicyNetwork,
              device: torch.device,
              optimizer: optim.Optimizer,
              gamma: float,
              no_baseline: bool):
        
        # 訓練ループ
        total_rewards = []
        for episode in range(max_episodes):
            # 環境の初期化
            state, info = env.reset(seed=episode)
    
            # 対数確率と報酬の保存用リスト
            log_probs = []
            rewards = []
    
            while True:
                # 状態をテンソルに変換
                state = torch.as_tensor(state, dtype=torch.float).to(device)
    
                # 行動の確率を計算
                action_prob = policy(state)
    
                # 行動をサンプリング
                p = action_prob.detach().cpu().numpy()
                action = np.random.choice(len(p), p=p)
    
                # 行動の対数確率を保存
                log_prob = torch.log(action_prob[action])
                log_probs.append(log_prob)
    
                # 行動を実行
                state, reward, terminated, truncated, info = env.step(action)
                
                # 報酬を保存
                rewards.append(reward)
                
                if terminated or truncated:
                    break
    
            # 損失値を計算
            loss = calculate_loss(rewards, log_probs, gamma, no_baseline)
    
            # ポリシーを更新
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
            # 報酬の合計を保存
            total_reward = sum(rewards)
            total_rewards.append(total_reward)
            
            print(f"Episode {episode+1}, Total Reward: {total_reward}")
    
        # 結果の描画を保存
        plt.plot(total_rewards)
        plt.xlabel('Episode')
        plt.ylabel('Reward')
        fig_path = 'reinforce-no-baseline.png' if no_baseline else \
                   'reinforce-with-baseline.png'
        plt.savefig(fig_path)

    まずは、全体像として、エージェントがエピソードを終了したら、ポリシー・ネットワークのパラメータを更新します。よって、エピソード内では、単に行動の対数確率と報酬を集めるのみとなります。

    まず、環境を初期化し、必要な情報を集めるための空リストを作成します。

    def train(......):
        
        # 訓練ループ
        total_rewards = []
        for episode in range(max_episodes):
            # 環境の初期化
            state, info = env.reset(seed=episode)
    
            # 対数確率と報酬の保存用リスト
            log_probs = []
            rewards = []
    
            # エピソード実行
            while True:
    
                ... 行動の対数確率と報酬を集める ...

    エピソード内では、まず観測値を状態テンソルへと変換します。

            # エピソード実行
            while True:
                # 状態をテンソルに変換
                state = torch.as_tensor(state, dtype=torch.float).to(device)

    その状態を使ってポリシーが行動確率を返します。

                # 行動の確率を計算
                action_prob = policy(state)

    この確率に従って実行する行動を選択します。

                # 行動をサンプリング
                p = action_prob.detach().cpu().numpy()
                action = np.random.choice(len(p), p=p)

    最初のうちは、この確率はデタラメなのでランダムに行動を実行しているのと同じです。学習が進むにつれて、より最適な行動に対しての確率が大きくなっていきます。振る舞いとしては、以前に見たイプシロン・グリーディに似ていますが、ランダムな行動が減る具合は、ポリシーの学習に影響されます。

    次に、行動確率の対数を計算します。これがなぜ必要なのかは、前回に解説しましたが、ポリシー勾配定理から来ています。

                # 行動の対数確率を保存
                log_prob = torch.log(action_prob[action])
                log_probs.append(log_prob)

    あとは、報酬もリストに保存しておきます。

                # 報酬を保存
                rewards.append(reward)

    以上をエピソードが終了するまで続けます。

                if terminated or truncated:
                    break

    損失値の計算

    エピソードが終了後に損失値を計算します。

            # 損失値を計算
            loss = calculate_loss(rewards, log_probs, gamma, no_baseline)

    この関数 calculate_loss はREINFORCEの目的関数を実現したものとなります。その中身は次のようになっています。

    def calculate_loss(
        rewards: list,l
        og_probs: list,
        gamma: float,
        no_baseline: bool) -> torch.Tensor:
    
        # 割引報酬和を計算
        reward_sum = 0
        reward_sums = []
        for reward in reversed(rewards):
            # 割引報酬和を計算
            reward_sum = reward + reward_sum * gamma
            reward_sums.insert(0, reward_sum)
    
        # ベースラインを計算
        baseline = 0 if no_baseline else np.mean(reward_sums)
    
        # 損失値を計算
        loss = 0
        for log_prob, reward_sum in zip(log_probs, reward_sums):
            # 報酬の和からベースラインを引いた値を損失値とする
            loss += -log_prob * (reward_sum - baseline)
    
        return loss

    順を追って解説します。

    まず、報酬の歴史を逆にたどって(最後から最初へと)割引率を適用しながら総報酬を計算していきます。

        # 割引報酬和を計算
        reward_sum = 0
        reward_sums = []
        for reward in reversed(rewards):
            # 割引報酬和を計算
            reward_sum = reward + reward_sum * gamma
            reward_sums.insert(0, reward_sum)

    逆にたどっているので、reward_sums.insert(0, reward_sum) でリストの先頭に追加していることに注意してください。

    次に必要ならばベースラインを計算します。今回は状態価値の予測ではなく、単純に書く時点で受け取った総報酬の平均を使っています。行動に依存しないのでベースラインとしての条件は満たしていますが、効果はどの程度あるのでしょうか。後で実験し比較します。必要のない場合のベースラインは0となります。

        # ベースラインを計算
        baseline = 0 if no_baseline else np.mean(reward_sums)

    あとは、REINFORCEの手法通りに行動選択確率の対数とその時点からの(割引)総報酬の積の総和を計算します。注意点としては、-log_prob とマイナスがついていることです。

    REINFORCEの目的関数を最大化するためには、計算した値をマイナスにしたものを最小化するのと同等なので、これを損失値としているからです。

        # 損失値を計算
        loss = 0
        for log_prob, reward_sum in zip(log_probs, reward_sums):
            # 報酬の和からベースラインを引いた値を損失値とする
            loss += -log_prob * (reward_sum - baseline)
    
        return loss

    以上で損失値の計算ができました。

    あとは、この損失値を使ってポリシーのパラメータを更新すれば、各時点でより総報酬が高くなるような行動を取るようになるように学習することが期待されます。

            # 損失値を計算
            loss = calculate_loss(rewards, log_probs, gamma, no_baseline)
    
            # ポリシーを更新
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

    あとは、得られた報酬の単純総和を計算してログとして表示します。

            # 報酬の合計を保存
            total_reward = sum(rewards)
            total_rewards.append(total_reward)
            
            print(f"Episode {episode+1}, Total Reward: {total_reward}")

    全てのエピソードが終了したら、エピソードごとの総報酬を描画して .png ファイルとして保存します。

        # 結果の描画を保存
        plt.plot(total_rewards)
        plt.xlabel('Episode')
        plt.ylabel('Reward')
        fig_path = 'reinforce-no-baseline.png' if no_baseline else \
                   'reinforce-with-baseline.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)

    評価ループ

    テストをする評価ループは、訓練ループと大差はありませんが、行動選択の部分は、確率の高いものを常に選ぶようになっています。

                # 最適な行動を選択
                action = torch.argmax(action_prob).item()

    五回ループしながら結果をコンソールに出力します。

    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)
    
                # 行動の確率を計算
                action_prob = policy(state)
    
                # 最適な行動を選択
                action = torch.argmax(action_prob).item()
    
                # 行動を実行
                state, reward, terminated, truncated, info = env.step(action)
                
                # 報酬を保存
                rewards.append(reward)
                
                if terminated or truncated:
                    break
            
            print(f"Episode {episode+1}, Total Reward: {sum(rewards)}")

    メイン

    メインでは、次のような引数を指定できるようにしています。

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

    続いて、環境の初期化を行います。テストの場合のみ、ゲーム画面を描画します。

        # 環境の初期化
        render_mode = 'human' if args.test else None
        env = gym.make('CartPole-v1', 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 = 'policy-no-baseline.pth' if args.no_baseline else \
                     'policy-with-baseline.pth' 

    このあとは、訓練かテストかで枝分かれします。

    訓練の場合は、オプティマイザを準備して、訓練ループがある train を呼び出します。最後に、学習済みのポリシーのパラメータを保存します。

        if not args.test:
            # ポリシーの訓練
            optimizer = optim.Adam(policy.parameters(), lr=args.lr) # オプティマイザの初期化
            train(env, args.max_episodes, policy, device, optimizer, args.gamma, args.no_baseline)
    
            # ポリシーの保存
            save_policy(policy, model_path)

    テストの場合は、ポリシーのパラメータを読み込み、テストを行うために test を呼び出します。

        else:
            # ポリシーの読み込み
            load_policy(policy, model_path, device)
    
            # ポリシーのテスト
            test(env, policy, device)

    最後に、環境を閉じて終了します。

        # 環境の終了
        env.close()

    ソースコードの実行

    ソースコード

    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
    
    
    # ポリシーの定義
    class PolicyNetwork(nn.Module):
        def __init__(self, input_dim, hidden_dim, output_dim):
            super().__init__()
    
            self.network = nn.Sequential(
                nn.Linear(input_dim, hidden_dim),
                nn.ReLU(),
                nn.Linear(hidden_dim, output_dim),
                nn.Softmax(dim=-1)
            )
            
        def forward(self, x) -> torch.Tensor:
            x = self.network(x)
            return x
    
    
    # ポリシーの作成
    def make_policy_network(env: gym.Env, hidden_dim: int) -> PolicyNetwork:
        # ポリシーの初期化
        input_dim = env.observation_space.shape[0] # 4 (カートの位置、速度、棒の角度、角速度)
        output_dim = env.action_space.n # 2 (左、右)
    
        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,
              no_baseline: bool):
        
        # 訓練ループ
        total_rewards = []
        for episode in range(max_episodes):
            # 環境の初期化
            state, info = env.reset(seed=episode)
    
            # 対数確率と報酬の保存用リスト
            log_probs = []
            rewards = []
    
            # エピソード実行
            while True:
                # 状態をテンソルに変換
                state = torch.as_tensor(state, dtype=torch.float).to(device)
    
                # 行動の確率を計算
                action_prob = policy(state)
    
                # 行動をサンプリング
                p = action_prob.detach().cpu().numpy()
                action = np.random.choice(len(p), p=p)
    
                # 行動の対数確率を保存
                log_prob = torch.log(action_prob[action])
                log_probs.append(log_prob)
    
                # 行動を実行
                state, reward, terminated, truncated, info = env.step(action)
                
                # 報酬を保存
                rewards.append(reward)
                
                if terminated or truncated:
                    break
    
            # 損失値を計算
            loss = calculate_loss(rewards, log_probs, gamma, no_baseline)
    
            # ポリシーを更新
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
            # 報酬の合計を保存
            total_reward = sum(rewards)
            total_rewards.append(total_reward)
            
            print(f"Episode {episode+1}, Total Reward: {total_reward}")
    
        # 結果の描画を保存
        plt.plot(total_rewards)
        plt.xlabel('Episode')
        plt.ylabel('Reward')
        fig_path = 'reinforce-no-baseline.png' if no_baseline else 'reinforce-with-baseline.png'
        plt.savefig(fig_path)
    
    
    def calculate_loss(rewards: list, log_probs: list, gamma: float, no_baseline: bool) -> torch.Tensor:
        # 割引報酬和を計算
        reward_sum = 0
        reward_sums = []
        for reward in reversed(rewards):
            # 割引報酬和を計算
            reward_sum = reward + reward_sum * gamma
            reward_sums.insert(0, reward_sum)
    
        # ベースラインを計算
        baseline = 0 if no_baseline else np.mean(reward_sums)
    
        # 損失値を計算
        loss = 0
        for log_prob, reward_sum in zip(log_probs, reward_sums):
            # 報酬の和からベースラインを引いた値を損失値とする
            loss += -log_prob * (reward_sum - baseline)
    
        return loss
    
    
    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)
    
                # 行動の確率を計算
                action_prob = policy(state)
    
                # 最適な行動を選択
                action = torch.argmax(action_prob).item()
    
                # 行動を実行
                state, reward, terminated, truncated, info = env.step(action)
                
                # 報酬を保存
                rewards.append(reward)
                
                if terminated or truncated:
                    break
            
            print(f"Episode {episode+1}, Total Reward: {sum(rewards)}")
    
    
    def main():
        # 引数の解析
        parser = argparse.ArgumentParser()
        parser.add_argument('--max_episodes', type=int,   default=500)
        parser.add_argument('--hidden_dim',   type=int,   default=256)
        parser.add_argument('--device',       type=str,   default=None)
        parser.add_argument('--lr',           type=float, default=1e-3) # 学習率
        parser.add_argument('--gamma',        type=float, default=0.99) # 割引率
        parser.add_argument('--seed',         type=int,   default=123)
        parser.add_argument('--no_baseline',  action='store_true')
        parser.add_argument('--test',         action='store_true')
        args = parser.parse_args()
    
        # 環境の初期化
        render_mode = 'human' if args.test else None
        env = gym.make('CartPole-v1', 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 = 'policy-no-baseline.pth' if args.no_baseline else 'policy-with-baseline.pth' 
    
        if not args.test:
            # ポリシーの訓練
            optimizer = optim.Adam(policy.parameters(), lr=args.lr) # オプティマイザの初期化
            train(env, args.max_episodes, policy, device, optimizer, args.gamma, args.no_baseline)
    
            # ポリシーの保存
            save_policy(policy, model_path)
        else:
            # ポリシーの読み込み
            load_policy(policy, model_path, device)
    
            # ポリシーのテスト
            test(env, policy, device)
    
        # 環境の終了
        env.close()
    
    
    if __name__ == '__main__':
        main()
    

    Python環境の設定

    また、以下の依存関係を requirements.txt ファイルにセーブしてください。

    gymnasium[classic-control]==0.29.1
    matplotlib==3.7.3
    numpy==1.24.4
    torch==2.0.1

    そして、次のようにPythonの環境を有効にしてください。

    # フォルダを作る
    mkdir reinforce
    cd reinforce
    
    #Pythonの環境を作る
    python3 -m venv venv
    source venv/bin/activate
    
    # Pipを最新のものにしておく
    pip install --upgrade pip
    
    # 依存関係をインストールする
    pip install -r requirements.txt

    Python環境の準備は以上となります。

    あとは、上述のソースコードを rf-cartpole.py に保存してください。プログラムの引数は、以下になります。

    (venv) > python rf-cartpole.py -h
    usage: rf-cartpole.py [-h] [--max_episodes MAX_EPISODES]
                               [--hidden_dim HIDDEN_DIM] [--device DEVICE]
                               [--lr LR] [--gamma GAMMA] [--seed SEED]
                               [--no_baseline] [--test]
    
    options:
      -h, --help            show this help message and exit
      --max_episodes MAX_EPISODES
      --hidden_dim HIDDEN_DIM
      --device DEVICE
      --lr LR
      --gamma GAMMA
      --seed SEED
      --no_baseline
      --test

    ベースライン有り

    ベースラインありで訓練を実行するには次のようにします。

    python rf-cartpole.py

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

    画像
    ベースライン有り訓練結果

    最高得点は500までなので、500を達成した時点でエピソードは終了します。訓練中は行動選択にランダム性があるのですが、それでも500に達しないことが多くなっているので、学習があまり安定していないように見えます。

    ベースライン有りの訓練済モデルでテストを行うには次のように実行します。

    python rf-cartpole.py --test

    次の結果となりました。

    Episode 1, Total Reward: 500.0
    Episode 2, Total Reward: 500.0
    Episode 3, Total Reward: 373.0
    Episode 4, Total Reward: 500.0
    Episode 5, Total Reward: 311.0

    テストでは、行動選択は、常に確率の高いものを選ぶので、まあまあの成績ですが、完全に安定してはいないようです。

    ベースライン無し

    ベースライン無しで訓練を実行するには次のようにします。

    python rf-cartpole.py --no_baseline

    訓練結果は次のようになりました。全体的にベースライン無しの方が訓練が安定しているように見えます。

    画像
    ベースラインなし訓練結果

    ベースライン無しの訓練済モデルでテストを行うには次のように実行します。

    python rf-cartpole.py --no_baseline --test

    次の結果となりました。

    Episode 1, Total Reward: 500.0
    Episode 2, Total Reward: 500.0
    Episode 3, Total Reward: 500.0
    Episode 4, Total Reward: 500.0
    Episode 5, Total Reward: 500.0

    ここでも、ベースラインがないほうが成績が安定しているように見えます。

    以上より、今回のベースラインでは、訓練がむしろ不安定で成績が悪くなりました。よって、ベースラインの設定には注意が必要であり、実験を通して有無による効果を確認するべきです。

    次回予告

    今回は、REINFORCEを実装することで理論の理解を深めました。

    同時に、ベースラインが常に良い効果を与えるとは限らないことも確認しました。今回は、割引報酬総和の平均を使いました。行動選択に依存しないので、ベースラインとしての条件は満たしていますが、効果はなくむしろ逆効果でした。

    次回は、ベースラインをポリシーによる状態価値の予測に置き換えてその効果の違いを確認します。

    お楽しみに!

    (続く)

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

    あなたへのおすすめ