
Gymで強化学習㊻A2C:実践編
前回は、A2Cの理論的な側面を解説しました。今回は、A2Cを実装してGymの環境で実験を行います。
これまで同様、マウンテン・カー(連続値)の環境を使い実験を行うので以前の結果と比較することができます。A2Cでは、REINFORCEやActor-Criticよりも良い成績が出るでしょうか。
なお実装する際に、A3CとA2Cでは、エントロピーによる正則化を効果的に使うことが重要です。この辺りを詳しく解説します。
それではさっそく始めましょう。
ポリシーの定義
今回のポリシーは次のように定義しました。
# ポリシーの定義
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.action_log_std = 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)
# 行動標準偏差を計算
action_std = torch.exp(self.action_log_std(x))
# 状態価値予測
state_value = self.state_value(x)
# 行動の平均予測と標準偏差、状態価値予測を返す
return action_mean, action_std, state_value行動の標準偏差を予測
これまでの実装(REINFORCE、Actor-Criticなど)での定義とほぼ同じですが、今回は行動の分布に関する標準偏差(action_std)を予測するコードを追加しました。
# 行動標準偏差予測部分
self.action_log_std = nn.Sequential(
nn.Linear(hidden_dim, output_dim)
)これによって、入力状態に対して行動を選ぶ際のランダム性に影響します。実際に予測するのは、標準偏差の対数(action_log_std)となっています。これは、標準偏差が0以上の数値であるからです。線形層を使うと負の値が発生する可能性があり、そのままでは標準偏差として使えません。
これに対し、「標準偏差の対数を計算している」とすること、全ての実数の範囲が対象となるので問題がありません。よって、線形層を使って計算することができます。
ただし、最終的に必要なのは行動の標準偏差なのでフィードフォワード(forward)を行う際に指数関数に通すことで標準偏差の対数から標準偏差へと変換しています。
# 行動標準偏差を計算
action_std = torch.exp(self.action_log_std(x))エントロピーの正則化との関係
なぜ、行動の標準偏差を出力するのかというと、損失値にエントロピーを正則化のために加えるからです。
A3Cの記事で解説しましたが、Actor-Criticの問題として、Actorが学習していくと探索をしなくなることがあります。これは、Criticによる評価が良い行動を取るだけだと他の行動を試さなくなるからです。まだ十分な経験から学んでいないうちに行動が固まってしまうと学習不足(未学習
、Underfitting)が生じます。
エントロピーは、Actorの行動確率に対して計算します。よって、Actorの行動確率が一様な分布(よりランダム)になるほど、エントロピーは高くなります。
そこで、エントロピーの正則化は、損失値からエントロピーを差し引くことで、よりランダムな行動を選ぶことが推奨しています。さらに、行動の標準偏差をエージェントに計算させることで、入力状態に応じて探索の度合いを調節できるようにしています。
つまり、学習が進んでいないうちは、ポリシーが選ぶ行動は最善になっておらず総報酬も低い可能性が高いです。その際はエントロピーの正則化の影響が強く、探索が促進されます。学習が進んでポリシーが最善な行動を選ぶようになるとエントロピーの正則化による影響が比較的小さくなるので探索の度合いが減少します。このように探索の度合いを状態に対する学習・経験の進展具合に依存する形で調節できるわけです。
つまり、以前のようにエピソードが進むごとに行動の標準偏差を減らしていくようなことが必要となくなります。ポリシーの学習が進んでいけば、最善な行動(行動の平均値)をより確実に選ぶことができるので標準偏差は小さくなります。
以上より、フィードフォワードからは、行動の平均値と標準偏差の予測と状態価値の3つの値を返しています。
def forward(self, x) -> Tuple[torch.Tensor, torch.Tensor]:
....
# 行動の平均予測と標準偏差、状態価値予測を返す
return action_mean, action_std, state_value訓練の実装
訓練情報
訓練に関する情報を一箇所にまとめるために TrainInfo を定義しました。
class TrainInfo:
def __init__(self, max_episodes: int, train_steps: int):
...
# 対数確率と報酬などを保存
def append(self,
action_std: torch.Tensor,
state_value: torch.Tensor,
log_prob: torch.Tensor,
entropy: torch.Tensor,
reward: float,
train_reward: float):
...
@property
def action_std(self) -> float:
...
def has_enough_train_rewards(self) -> bool:
...
def clear_lists(self):
...
def add_losses(self,
loss: float,
policy_loss: float,
value_loss: float,
entropy_loss: float):
...
def clear_totals(self):
...これによって訓練のコードが乱雑になるのを防ぐのが目的です。TrainInfo の中には、環境から受け取った報酬や計算された行動の対数確率、エントロピー、損失値などをリストにして格納しています。単純なコードなのでここでは詳しく解説しません。詳細は、最後に載せるソースコードを参照してください。次に説明する訓練ループで使われるので、その存在をここで言及しました。
trainの宣言
train は訓練のためのファンクションです。次のような入力値を受け入れます。
def train(
env: gym.Env,
max_episodes: int,
train_steps: int,
policy: PolicyNetwork,
device: torch.device,
optimizer: optim.Optimizer,
gamma: float,
policy_weight: float,
value_weight: float,
entropy_weight: float,
):env:Gymの環境オブジェクト
max_episodes:最大エピソード数
train_steps:訓練をするために必要なステップ数
policy:ポリシーオブジェクト
device:デバイス(CPU、GPU、MPS)
optimizer:最適化のためのオプティマイザ
gamma:割引率(ガンマ、)
policy_weight:ポリシー損失の重み
value_weight:バリュー損失の重み
entropy_weight:エントロピー損失(正則化)の重み
まず、前述した TrainInfo のオブジェクトが作られます。
# 訓練情報の初期化
train_info = TrainInfo(max_episodes, train_steps)上述の入力値や train_info は、それぞれ以下の解説の各所で登場します。
訓練ループ
訓練ループのコードは長いので分割したものを順を追って解説します。
いつものようにエピソードの最大数に達するまで訓練ループは繰り返されます。まず、環境の初期化が行われます。ランダムシードを渡して制限性を確保しています。
# 訓練ループ
for episode in range(max_episodes):
# 環境の初期化
state, info = env.reset(seed=episode)
# エピソード実行
while True:
# 状態をテンソルに変換
state = torch.as_tensor(state, dtype=torch.float).to(device)
# ポリシーで行動の平均と標準偏差、そして状態価値を予測
action_mean, action_std, state_value = policy(state)エピソードの実行は、ゴールに到達するか、ステップ数が1000に達するまで続きます。
エピソード内では、環境からの観測値をPyTorchのテンソルに変換し、ポリシー(policy)に渡すことで、行動の平均値・標準偏差と状態価値の予測を受けとります。
次に、行動の選択をするための分布のオブジェクトを作り、行動の値をサンプルします。
# 行動を確率的に選択(標準偏差固定で探索)
action_dist = torch.distributions.Normal(action_mean,
scale=action_std)
action = action_dist.sample()前述したように、ここで使われている行動の標準偏差は、ポリシーによって計算されたものです。以前のようにエピソードごとに低減されるものではありません。
次に、行動の対数確率とエントロピーを計算しておきます。後で、train_info に格納します。
# 対数確率を計算
log_prob = action_dist.log_prob(action)
# エントロピーを計算
entropy = action_dist.entropy()次に、行動を実行し環境から報酬などを受け取ります。
# 行動を実行
state, reward, terminated, truncated, info = env.step(
action.cpu().numpy())以前と同様に訓練用の報酬を計算します。マウンテンカーの位置や速度を報酬として与えることで学習がしやすくなります。
# 訓練用報酬を計算
position_bonus = state[0] - env.observation_space.low[0] # 位置の値を報酬に加える
velocity_bonus = np.abs(state[1]) # 速度の絶対値を報酬に加える
train_reward = reward + position_bonus + velocity_bonus以上より集めた経験を train_info に格納します。後で訓練やログの出力で使うためです。
# 訓練情報に保存
train_info.append(action_std,
state_value,
log_prob,
entropy,
reward,t
rain_reward)あとは、訓練用の情報が一定数集まるか、エピソードが終了したら訓練を実行します。
# 訓練用報酬が一定数溜まったら訓練を行う
if train_info.has_enough_train_rewards() or terminated or truncated:
... 訓練を行うREINFORCEと違って、エピソードの終了を待つ必要はありません。ある程度のステップ数を経験したら訓練を行います。ただし、Actor-Criticのようにステップ毎に訓練を行うわけでもありません。よって学習がより安定化します。
訓練の実行
訓練を実行するときは、ゴールに到達した(terminated が True)かどうかで処理が異なります。
# 次の状態の状態価値を計算
if terminated:
# 終了状態ならば、次の状態の状態価値は0
next_state_value = 0
else:
# 終了状態でなければ、次の状態の状態価値を計算する
next_state = torch.as_tensor(state, dtype=torch.float).to(device)
_, _, next_state_value = policy(next_state)ゴールに到達した場合は次の状態がないので、次の状態の価値は0となります。ゴールに到達していない場合は、次の状態の価値をポリシーのオブジェクトを使って計算します。
次に、calculate_lossを呼び出して損失値を計算します。ここで train_info に格納された情報が役に立ちます。また、次の状態の価値(next_state_value)も渡されます。
# 損失値を計算
policy_loss, value_loss, entropy_loss = calculate_loss(
train_info.train_rewards,
train_info.log_probs,
gamma,
train_info.state_values,
next_state_value,
train_info.entropies)損失値の計算の詳細は後述します。ここでは、エピソードを流れを続いて追っていきます。
次に、得られた損失値(ポリシー損失、価値損失、エントロピー損失)に重み付けを行い、損失値の総和を計算します。
# 重み付けして調整
policy_loss = policy_weight * policy_loss
value_loss = value_weight * value_loss
entropy_loss = entropy_weight * entropy_loss
loss = policy_loss + value_loss + entropy_loss次に、損失値を使ってポリシーのパラメータを更新します。
# ポリシーを更新
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0) # 勾配の大きさを制限する
optimizer.step()なお、得られた損失値も train_info に格納します。これはログ出力のためです。
# 損失値を保存
train_info.add_losses(
loss.item(),
policy_loss.item(),
value_loss.item(),
entropy_loss.item())訓練で使われた経験(報酬、行動の対数確率、エントロピー、状態価値など)は、もう必要がないので消去します。
# リストを初期化
train_info.clear_lists()こうすることで、再び訓練に必要なステップ数が集まるか、エピソードが終了するのを待つことになります。
なお、この時点でエピソードが終了しているのならば、ループを抜け出して次のエピソードへと移ります。
if terminated or truncated:
break損失値の計算
損失値の計算は前回に解説した通りで、基本的にはREINFORCEによる損失値の計算と似ています。つまり、最後の経験(報酬など)から遡って損失値を計算していきます。
ただし、A2Cでは最後の経験からの価値はポリシーが次の状態の価値として予測したものを使います。これによって、エピソードの終了を待つ必要がありません。また、最初の経験は、集められた経験のリストからくるので、エピソードの最初まで遡ることもありません。
損失値を計算するファンクションである calculate_loss は次のように定義されています。
def calculate_loss(
rewards: List[float],
log_probs: List[torch.Tensor],
gamma: float,
state_values: List[torch.Tensor],
next_state_value: torch.Tensor,
entropies: List[torch.Tensor]
) -> Tuple[torch.Tensor, torch.Tensor]:これらの多くは、前述したようにほとんど train_info からのリストになっています。ただし、train_info をそのままここに渡すとコードが乱雑になるので、このファンクションは train_info の定義に依存しない形になっています。
ちなみに、train_rewards でなく rewards という名前の変数を使っていますが、実際に渡されるのは train_rewards の方です。訓練用の報酬を使うかどうかは、このファンクションが呼び出す側が決めることなのでこのようにしています。もしかしたら、混乱するかもしれないので言及しました。
まず、REINFORCEの実装と同様に報酬の標準化を行います。
# 報酬の標準化
rewards = np.array(rewards, dtype=np.float32)
rewards = (rewards - rewards.mean())/(rewards.std() + 1e-10) # 報酬の標準化報酬の値が大きすぎたり、大きく変化する(分散が大きい)とパラメータの値が乱高下して学習が安定しないのでこのように標準化をしています。
次に、アドバンテージを計算するのに必要な行動価値を最後の報酬から遡って計算していきます。
action_values = []
for reward in reversed(rewards):
# 割引報酬和を計算して、行動価値の予測として保存
action_value = reward + gamma * next_state_value
action_values.insert(0, action_value)
next_state_value = action_value # 次の状態の状態価値を更新これもREINFORCEの実装と似ていますが、next_state_value は、ポリシーが予測したものに初期化されていることに注意してください。それを割引したものに報酬を加えることで行動価値を計算しています。
action_value = reward + gamma * next_state_valueこれを行動価値リストの最初に追加します。歴史を逆に追っているのでリストに加えるときは常に最初に追加するわけです。
action_values.insert(0, action_value)そして、一歩前のステップの行動価値を計算するために、次の状態価値を現在の行動価値へと更新します。
next_state_value = action_value # 次の状態の状態価値を更新あとは、全ての報酬を処理するまで繰り返すだけです。
次に、行動対数確率、報酬、行動価値、状態価値のリストを使ってポリシーの損失値と価値の損失値の総和を計算します。
policy_loss = 0
value_loss = 0
for log_prob, reward, action_value, state_value in zip(
log_probs, rewards, action_values, state_values):
# アドバンテージを計算
advantage = action_value - state_value
# アクターによる損失値を計算
policy_loss += -log_prob * advantage.detach()
# クリティックによる損失値を計算
value_loss += advantage ** 2前回の記事で解説した通り、アドバンテージと呼んではいますが、TDエラーを読みかえても同じです。このアドバンテージを計算し行動の評価値として使うので、そのマイナス値と行動の対数確率を掛けたものがポリシー(アクター)の損失値となります。
また、価値(クリティック)の損失値は、アドバンテージの二乗となっています。これは、実際の行動による報酬を含んだ行動価値と現在の状態から予測される状態価値の差の二乗なので、状態価値の予測が実際に起きたことと近くなれば、損失値も小さくなります。
次に、ポリシー損失と価値損失の平均を計算します。
# 損失値を平均化
policy_loss = policy_loss / len(log_probs)
value_loss = value_loss / len(state_values)あとは、エントロピーの平均値のマイナスをエントロピー損失とします。
# エントロピーの平均の負の値を損失値とする
entropy_loss = -torch.stack(entropies).mean()
return policy_loss, value_loss, entropy_loss最後に、3つの損失しを返します。
ソースコードの実行
ソースコード
今回の全体のソースコードです。
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.action_log_std = 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)
# 行動標準偏差を計算
action_std = torch.exp(self.action_log_std(x))
# 状態価値予測
state_value = self.state_value(x)
# 行動の平均予測と標準偏差、状態価値予測を返す
return action_mean, action_std, 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)
class TrainInfo:
def __init__(self, max_episodes: int, train_steps: int):
self.max_episodes = max_episodes
self.train_steps = train_steps
# グラフ描画用に報酬の合計を保存するリスト
self.total_rewards = []
# リストと総報酬などを初期化
self.clear_lists()
self.clear_totals()
# 対数確率と報酬などを保存
def append(self,
action_std: torch.Tensor,
state_value: torch.Tensor,
log_prob: torch.Tensor,
entropy: torch.Tensor,
reward: float,
train_reward: float):
self.action_stds.append(action_std.item())
self.state_values.append(state_value)
self.log_probs.append(log_prob)
self.entropies.append(entropy)
self.rewards.append(reward)
self.train_rewards.append(train_reward)
# 総報酬などの合計を更新
self.total_reward += reward
self.total_train_reward += train_reward
@property
def action_std(self) -> float:
# 標準偏差の平均を返す
return np.mean(self.action_stds)
def has_enough_train_rewards(self) -> bool:
# 訓練用報酬が一定数溜まったら訓練を行う
return len(self.train_rewards) >= self.train_steps
def clear_lists(self):
# リストを初期化
self.state_values = []
self.log_probs = []
self.entropies = []
self.rewards = []
self.train_rewards = []
def add_losses(self,
loss: float,
policy_loss: float,
value_loss: float,
entropy_loss: float):
# 損失値を保存
self.total_loss += loss
self.total_policy_loss += policy_loss
self.total_value_loss += value_loss
self.total_entropy_loss += entropy_loss
def clear_totals(self):
# 総報酬がある場合は保存(グラフ描画用)
if hasattr(self, 'total_reward'):
self.total_rewards.append(self.total_reward)
# 総報酬などを記録する変数を初期化
self.action_stds = []
self.total_reward = 0
self.total_train_reward = 0
self.total_loss = 0
self.total_policy_loss = 0
self.total_value_loss = 0
self.total_entropy_loss = 0
def train(
env: gym.Env,
max_episodes: int,
train_steps: int,
policy: PolicyNetwork,
device: torch.device,
optimizer: optim.Optimizer,
gamma: float,
policy_weight: float,
value_weight: float,
entropy_weight: float,
):
# 訓練情報の初期化
train_info = TrainInfo(max_episodes, train_steps)
# 訓練ループ
for episode in range(max_episodes):
# 環境の初期化
state, info = env.reset(seed=episode)
# エピソード実行
while True:
# 状態をテンソルに変換
state = torch.as_tensor(state, dtype=torch.float).to(device)
# ポリシーで行動の平均と標準偏差、そして状態価値を予測
action_mean, action_std, 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)
# エントロピーを計算
entropy = action_dist.entropy()
# 行動を実行
state, reward, terminated, truncated, info = env.step(action.cpu().numpy())
# 訓練用報酬を計算
position_bonus = state[0] - env.observation_space.low[0] # 位置の値を報酬に加える
velocity_bonus = np.abs(state[1]) # 速度の絶対値を報酬に加える
train_reward = reward + position_bonus + velocity_bonus
# 訓練情報に保存
train_info.append(action_std, state_value, log_prob, entropy, reward, train_reward)
# 訓練用報酬が一定数溜まったら訓練を行う
if train_info.has_enough_train_rewards() or terminated or truncated:
# 次の状態の状態価値を計算
if terminated:
# 終了状態ならば、次の状態の状態価値は0
next_state_value = 0
else:
# 終了状態でなければ、次の状態の状態価値を計算する
next_state = torch.as_tensor(state, dtype=torch.float).to(device)
_, _, next_state_value = policy(next_state)
# 損失値を計算
policy_loss, value_loss, entropy_loss = calculate_loss(
train_info.train_rewards,
train_info.log_probs,
gamma,
train_info.state_values,
next_state_value,
train_info.entropies)
# 重み付けして調整
policy_loss = policy_weight * policy_loss
value_loss = value_weight * value_loss
entropy_loss = entropy_weight * entropy_loss
loss = policy_loss + value_loss + entropy_loss
# ポリシーを更新
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0) # 勾配の大きさを制限する
optimizer.step()
# 損失値を保存
train_info.add_losses(
loss.item(),
policy_loss.item(),
value_loss.item(),
entropy_loss.item())
# リストを初期化
train_info.clear_lists()
if terminated or truncated:
break
# ログの出力
print(f"Episode {episode+1:4d}, " +
f"Total Reward: {train_info.total_reward:8.2f}, " +
f"Train Reward: {train_info.total_train_reward:8.2f}, " +
f"Loss: {train_info.total_loss:8.2f}, " +
f"P_Loss: {train_info.total_policy_loss:8.2f}, " +
f"V_Loss: {train_info.total_value_loss:8.2f}, " +
f"E_Loss: {train_info.total_entropy_loss:8.2f}, " +
f"Noise: {train_info.action_std:8.2f}, Goal: {terminated}")
# 報酬の合計を保存してから、総報酬などを初期化
train_info.clear_totals()
# 結果の描画を保存
plt.plot(train_info.total_rewards)
plt.xlabel('Episode')
plt.ylabel('Reward')
plt.ylim(-100, 100)
fig_path = 'mcar-a2c.png'
plt.savefig(fig_path)
def calculate_loss(
rewards: List[float],
log_probs: List[torch.Tensor],
gamma: float,
state_values: List[torch.Tensor],
next_state_value: torch.Tensor,
entropies: List[torch.Tensor]
) -> Tuple[torch.Tensor, torch.Tensor]:
# 報酬の標準化
rewards = np.array(rewards, dtype=np.float32)
rewards = (rewards - rewards.mean())/(rewards.std() + 1e-10) # 報酬の標準化
action_values = []
for reward in reversed(rewards):
# 割引報酬和を計算して、行動価値の予測として保存
action_value = reward + gamma * next_state_value
action_values.insert(0, action_value)
next_state_value = action_value # 次の状態の状態価値を更新
policy_loss = 0
value_loss = 0
for log_prob, reward, action_value, state_value in zip(
log_probs, rewards, action_values, state_values):
# アドバンテージを計算
advantage = action_value - state_value
# アクターによる損失値を計算
policy_loss += -log_prob * advantage.detach()
# クリティックによる損失値を計算
value_loss += advantage ** 2
# 損失値を平均化
policy_loss = policy_loss / len(log_probs)
value_loss = value_loss / len(state_values)
# エントロピーの平均の負の値を損失値とする
entropy_loss = -torch.stack(entropies).mean()
return policy_loss, value_loss, entropy_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)
# 行動の確率を計算
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():
# 成功事例
# max_episodes=50, train_steps=50, hidden_dim=16 ; 少ない隠れ層のユニット数でも学習できる
# ; ActorCriticよりもエピソードを要するが成績は良い
# max_episodes=80, train_steps=50, hidden_dim=128 ; 多い隠れ層のユニット数でも学習できる
# ; しかし、成績が良くなるわけではない
# max_episodes=60, train_steps=25, hidden_dim=128 ; 訓練ステップ数を減すと最大エピソード数を抑えられる
# ; ただし、訓練ステップ数が少ないと学習が不安定になりやすい
parser = argparse.ArgumentParser()
parser.add_argument('--max_episodes', type=int, default=50)
parser.add_argument('--train_steps', type=int, default=50)
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('--policy_weight', type=float, default=1.0) # ポリシー予測損失の重み
parser.add_argument('--value_weight', type=float, default=0.1) # 状態価値予測損失の重み
parser.add_argument('--entropy_weight', type=float, default=0.5) # エントロピー損失の重み
parser.add_argument('--seed', type=int, default=123)
parser.add_argument('--model_path', type=str, default='mcar-a2c.pth')
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)
if not args.test:
# ポリシーの訓練
optimizer = optim.AdamW(policy.parameters(), lr=args.lr) # オプティマイザの初期化
train(env,
args.max_episodes,
args.train_steps,
policy,
device,
optimizer,
args.gamma,
args.policy_weight,
args.value_weight,
args.entropy_weight)
# ポリシーの保存
save_policy(policy, args.model_path)
else:
# ポリシーの読み込み
load_policy(policy, args.model_path, device)
# ポリシーのテスト
test(env, policy, device)
# 環境の終了
env.close()
if __name__ == '__main__':
main()Python環境の設定
Python環境の設定と実行の仕方は以前と同じです。
ただし、上記のソースコードを a2c-mountaincar.py に保存してください。
デフォルトの学習結果
デフォルトの値による訓練は次のように実行します。
python a2c-mountaincar.pyActor-Criticのときは10エピソードでしたが、今回は50エピソードぐらいを必要になりました。それでもREINFORCEよりもずっとはやく訓練が終了します。
テストは次のように実行します。
python a2c-mountaincar.py --test結果は以下になります。Actor-Criticと比べてよりスコアが高く、また安定しています。
Episode 1, Total Reward: 90.75 Goal: True
Episode 2, Total Reward: 93.09 Goal: True
Episode 3, Total Reward: 94.36 Goal: True
Episode 4, Total Reward: 95.19 Goal: True
Episode 5, Total Reward: 93.46 Goal: True実際の動きを見ると、力に頼ることなくうまく揺れを利用して左右に振りを大きくしていくのがわかります。

初期位置は谷底だと振れ幅を増加させるのにちょっと時間がかかりますが、それでもスコアは90以上なので高得点を達成しています。
なお、いつものように色々と条件を変更して実験することが可能です。
usage: a2c-mountaincar.py [-h] [--max_episodes MAX_EPISODES]
[--train_steps TRAIN_STEPS]
[--hidden_dim HIDDEN_DIM]
[--device DEVICE]
[--lr LR]
[--gamma GAMMA]
[--policy_weight POLICY_WEIGHT]
[--value_weight VALUE_WEIGHT]
[--entropy_weight ENTROPY_WEIGHT]
[--seed SEED]
[--model_path MODEL_PATH]
[--test]
[--render]
options:
-h, --help show this help message and exit
--max_episodes MAX_EPISODES
--train_steps TRAIN_STEPS
--hidden_dim HIDDEN_DIM
--device DEVICE
--lr LR
--gamma GAMMA
--policy_weight POLICY_WEIGHT
--value_weight VALUE_WEIGHT
--entropy_weight ENTROPY_WEIGHT
--seed SEED
--model_path MODEL_PATH
--test
--renderモデルはデフォルトでは、mcar-a2c.pth という名前のファイルに保存され、そのファイルから読み込まれます。これを変更したい場合は、--model_path で指定してください。この記事では、常にデフォルトのファイル名を使っている毎回上書きされています。
パラメータ数を増やしても安定
なお、以下のようにモデルのパラメータ数(--hidden_dim)を増やしても、エピソードの最大数を増やすことで学習が可能でした。
python a2c-mountaincar.py --max_episodes 80 --hidden_dim 128テストは次のように実行します。
python a2c-mountaincar.py --hidden_dim 128 --testテスト結果は以下になりました。
Episode 1, Total Reward: 89.94 Goal: True
Episode 2, Total Reward: 89.29 Goal: True
Episode 3, Total Reward: 92.32 Goal: True
Episode 4, Total Reward: 93.20 Goal: True
Episode 5, Total Reward: 91.20 Goal: TrueActor-Criticの時には、パラメータ数が大きいと学習が不安定となっていました。おそらく過学習だったと考えられますが、A2Cではその問題も起きませんでした。
ただし、パラメータ数が16でも十分に学習できているし、むしろ成績が良いのでパラメータを必要以上に増やなくともよいです。パラメータ数が少ない方が訓練の時間も短縮できます。
訓練ステップを短くしてみる
訓練の時間を少しでも減らすために、訓練ステップを短くして実験しました。
python a2c-mountaincar.py --max_episode 60 --train_steps=25 --hidden_dim=128訓練に必要なステップ数を少なくすると、エピソード内のパラメータの更新回数が増えるので訓練を少し早く終えることができました。
テストは次のように実行します。
python a2c-mountaincar.py --hidden_dim=128 --test結果はこうなりました。
Episode 1, Total Reward: 87.40 Goal: True
Episode 2, Total Reward: 88.79 Goal: True
Episode 3, Total Reward: 92.87 Goal: True
Episode 4, Total Reward: 91.15 Goal: True
Episode 5, Total Reward: 89.06 Goal: True悪くないですね。ただし、訓練ステップ数を減らしすぎると学習が不安定となります。
エントロピーの重みを小さくする
エントロピーの重みを0.5から0.1へと減らしてみます。
python a2c-mountaincar.py --entropy_weight 0.1次のように、テストを実行します。
python a2c-mountaincar.py --testテスト結果は以下になりました。
Episode 1, Total Reward: -6.16 Goal: False
Episode 2, Total Reward: -6.19 Goal: False
Episode 3, Total Reward: -6.36 Goal: False
Episode 4, Total Reward: -6.86 Goal: False
Episode 5, Total Reward: -6.41 Goal: Falseさんざんですね。探索が十分でなくためゴールに到達できるポリシーにさえなっていません。
なお、他の損失値とのバランスもあるので、--policy_weight や --value_weight を変更すると結果も異なってきます。
エントロピーの重みを大きくする
今度は、エントロピーの重みを大きくして実験します。
python a2c-mountaincar.py --entropy_weight 0.7次のように、テストを実行します。
python a2c-mountaincar.py --testテスト結果は以下になりました。
Episode 1, Total Reward: -0.88 Goal: False
Episode 2, Total Reward: -0.88 Goal: False
Episode 3, Total Reward: -0.88 Goal: False
Episode 4, Total Reward: -0.88 Goal: False
Episode 5, Total Reward: -0.89 Goal: Falseこれもさんざんですね。エントロピーの重みを少し増やしただけですが、エントロピー正則化による圧力が強くなり、行動がランダムになり過ぎた結果として、ポリシーが定まらなかったと考えられます。
連続した一連の行動の結果として最適なポリシーを実現するためには、探索のやり過ぎは逆効果となりました。
以上、パラメータ数、訓練サイズ、エントロピーの影響を実験しました。また、強化学習ではハイパーパラメータが本当に重要なのが再確認できました。
次回予告
Actor-Criticにおける学習の不安定性の改善は、A3CやA2Cに限ったことではありません。OpenAIが2015年に開発したTRPO(Trust Region Policy Optimization)もActor-Criticの学習を異なる手法で安定化させることに成功しています。
よって次回は、TRPOについて解説します。
お楽しみに!
(続く)