強化学習（Reinforcement Learning）は機械学習の一分野で、エージェントが環境と相互作用しながら試行錯誤を通じて学習を行う手法です。人間の学習方法に近く、AlphaGoやロボット制御、自動運転、ゲームAIなど様々な分野で用いられています。
強化学習の基本的な考え方は単純です：
しかし、強化学習を始めるには環境構築やインターフェースの実装など、初心者にとってハードルが高い部分があります。
そこで今回は、強化学習の実験を簡単に始められるGymnasiumというライブラリをご紹介します。Gymnasiumは以前OpenAIが開発していた「Gym」の改良版で、現在はFarama Foundationによってメンテナンスされています。このライブラリを使えば、複雑な環境を一から作る必要なく、すぐに強化学習の実装に取り組むことができます！
Gymnasiumは以下の機能を提供する強化学習用のPythonライブラリです：
強化学習では、エージェント（学習するAI）が環境（問題の世界）と対話しながら学習を進めます。Gymnasiumはこの「環境」の部分を簡単に扱えるようにしてくれるツールなのです。
Gymnasiumは「シングルエージェント」の強化学習に焦点を当てており、一つのAIエージェントが環境と対話する設定に適しています。（複数エージェントの場合は姉妹ライブラリの「PettingZoo」が推奨されています）
Gymnasiumはpipを使って簡単にインストールできます：
# 基本パッケージのインストール
pip install gymnasium
# 特定の環境ファミリーのインストール（例：Atari）
pip install "gymnasium[atari]"
# すべての依存関係をインストール
pip install "gymnasium[all]"
Python 3.8, 3.9, 3.10, 3.11, 3.12をサポートしており、LinuxとmacOSで公式にテストされています。Windowsでも動作しますが、一部の環境は依存関係の問題で制限がある場合があります。
環境ファミリーごとに個別にインストールすることもできます：
# Box2D環境（LunarLander, BipedalWalker, CarRacing等）
pip install "gymnasium[box2d]"
# MuJoCo物理エンジン環境
pip install "gymnasium[mujoco]"
# Atariゲーム環境
pip install "gymnasium[atari,accept-rom-license]"
# 開発用（テスト、linting等）
pip install "gymnasium[testing]"
Anaconda/Minicondaを使用している場合は、以下のようにインストールできます：
# 基本パッケージ
conda install -c conda-forge gymnasium
# 追加の依存関係はpipでインストール
pip install "gymnasium[atari]"
インストールが成功したか確認するために、簡単なテストを実行できます：
import gymnasium as gym
# 最もシンプルな環境CartPoleを作成
env = gym.make("CartPole-v1")
# 環境をリセット
observation, info = env.reset()
# いくつかのステップを実行
for _ in range(10):
action = env.action_space.sample()
observation, reward, terminated, truncated, info = env.step(action)
if terminated or truncated:
observation, info = env.reset()
env.close()
print("Gymnasiumのインストールが正常に完了しました！")
この短いコードが問題なく実行されれば、Gymnasiumが正常にインストールされています。
Gymnasiumの基本的な使い方は非常にシンプルです。以下は「CartPole-v1」という、棒をバランスさせる古典的な制御問題環境を使った例です：
import gymnasium as gym
# 環境の作成
env = gym.make("CartPole-v1")
# 環境のリセットと初期観測の取得
observation, info = env.reset(seed=42)
# エピソードのループ
for _ in range(1000):
# ランダムなアクションの選択（実際のAIならここで方策を使用）
action = env.action_space.sample()
# 環境を1ステップ進める
observation, reward, terminated, truncated, info = env.step(action)
# エピソードが終了したら環境をリセット
if terminated or truncated:
observation, info = env.reset()
# 環境を閉じる
env.close()
この例では、以下の手順で環境とやり取りしています：
gym.make("CartPole-v1") で環境のインスタンスを作成env.reset() で環境を初期状態に戻し、最初の観測を取得env.action_space.sample()）env.step(action) で環境を1ステップ進め、結果を取得terminatedまたはtruncatedがTrueなら環境をリセットenv.close() でリソースを解放env.step() は5つの値を返します：
これが強化学習の基本的なループ構造です。実際のAIアルゴリズムでは、このループの中で経験を蓄積し、方策（どの状態でどの行動を取るか）を学習していきます。
Gymnasiumには様々な環境が用意されています。強化学習の初心者から研究者まで、幅広いニーズに対応できるよう設計されています。
古典的な制御問題をシミュレートする環境で、強化学習入門に最適です。
| 環境名 | 説明 | 画像 |
|---|---|---|
| CartPole | 台車の上に立てられた棒をバランスさせる問題 | |
| MountainCar | 谷間に配置された車を山の頂上まで加速させる問題 |  |
| Pendulum | 振り子を上向きに維持する問題 |  |
これらの環境は比較的シンプルですが、強化学習の基本的な概念を学ぶのに最適です。また、計算コストも低いため、ノートPCでも十分に実験できます。
物理エンジンBox2Dを使用した2D環境で、より複雑な制御問題に挑戦できます。
| 環境名 | 説明 | 画像 |
|---|---|---|
| LunarLander | 月面に宇宙船を安全に着陸させる問題 |  |
| BipedalWalker | 2足歩行ロボットを効率よく歩かせる問題 |  |
| CarRacing | レーストラックを速く走り抜ける問題 |  |
これらの環境はClassic Controlよりも複雑で、より高度な強化学習アルゴリズムの評価に適しています。
教育目的の単純な離散環境で、状態空間が小さく理解しやすいのが特徴です。
これらの環境は特に表形式の強化学習（Q学習など）の学習に適しています。
複雑な多関節制御のための高度な物理シミュレーション環境です。
| 環境名 | 説明 | 画像 |
|---|---|---|
| Ant | 4足歩行ロボットの制御 |  |
| Humanoid | 人型ロボットの制御 |  |
| HalfCheetah | チーター型ロボットの制御 |  |
これらの環境は連続的な行動空間を持ち、深層強化学習の研究によく使用されます。
Atari 2600のゲームをシミュレートする環境で、画像ベースの強化学習に最適です。
| 環境名 | 説明 |
|---|---|
| Breakout | ブロック崩し |
| Pong | ピンポン |
| Space Invaders | スペースインベーダー |
これらの環境は画像から直接学習するためのベンチマークとして広く使われています。DeepMindのDQNなど、画期的なアルゴリズムの評価に使用されました。
Gymnasiumの環境は、以下の主要な要素から構成されています。これらを理解することで、どんな環境でも共通のインターフェースで操作できるようになります。
エージェントが環境から受け取る観測（状態）の形式を定義します。
# CartPoleの観測空間を確認
env = gym.make("CartPole-v1")
print(env.observation_space)
# 出力: Box(-3.4028235e+38, 3.4028235e+38, (4,), float32)
主な観測空間の種類：
{"position": [x, y], "velocity": [vx, vy]}
各環境の詳細なドキュメントを見ることで、観測空間の意味を理解できます。
エージェントが取れる行動の集合を定義します。
# CartPoleの行動空間を確認
print(env.action_space)
# 出力: Discrete(2)
主な行動空間の種類：
環境を1ステップ進める関数で、強化学習の核心部分です。
observation, reward, terminated, truncated, info = env.step(action)
返り値の意味：
環境を初期状態に戻す関数です。新しいエピソードを始める際に使用します。
observation, info = env.reset(seed=42)
seedパラメータで乱数シードを指定すると、再現性のある実験が可能になります。これは研究や開発で非常に重要な機能です。
環境の状態を視覚化する機能です。学習の様子を確認するのに役立ちます。
# 環境作成時にrender_modeを指定
env = gym.make("CartPole-v1", render_mode="human")
# または
rgb_array = env.render() # render_mode="rgb_array"の場合
レンダリングモードには主に以下があります：
Gymnasiumの最大の特徴の一つは、自分だけのカスタム環境も簡単に作成できることです。自分の研究テーマやアイデアに合わせた環境を作ることで、特定の問題に対する強化学習アルゴリズムの性能を評価できます。
以下は簡単なグリッドワールド環境の実装例です。青いエージェントが赤い目標に向かって移動する単純なゲームです：
import gymnasium as gym
from gymnasium import spaces
import numpy as np
import pygame # 可視化用
class SimpleGridEnv(gym.Env):
"""
シンプルなグリッドワールド環境
エージェントは2次元グリッド上を移動し、目標位置に到達することが目的
- 観測: エージェントと目標の位置
- 行動: 上下左右の4方向
- 報酬: 目標に到達したら1.0、それ以外は0
"""
metadata = {"render_modes": ["human", "rgb_array"], "render_fps": 4}
def __init__(self, size=5, render_mode=None):
self.size = size # グリッドのサイズ
self.window_size = 512 # 描画ウィンドウのサイズ
self.render_mode = render_mode
# 観測空間: エージェントと目標の位置
self.observation_space = spaces.Dict({
"agent": spaces.Box(0, size - 1, shape=(2,), dtype=int),
"target": spaces.Box(0, size - 1, shape=(2,), dtype=int)
})
# 行動空間: 上下左右の4方向
self.action_space = spaces.Discrete(4)
# 方向のマッピング
self._action_to_direction = {
0: np.array([1, 0]), # 右
1: np.array([0, 1]), # 上
2: np.array([-1, 0]), # 左
3: np.array([0, -1]) # 下
}
# 描画用の変数
self.window = None
self.clock = None
# 状態の初期化（resetで正式に初期化）
self._agent_location = np.zeros(2, dtype=int)
self._target_location = np.zeros(2, dtype=int)
def reset(self, seed=None, options=None):
"""環境を初期状態にリセットする"""
# 乱数生成器の初期化（重要: 再現性のため）
super().reset(seed=seed)
# エージェントの位置をランダムに設定
self._agent_location = self.np_random.integers(0, self.size, size=2, dtype=int)
# 目標位置をエージェントと異なる位置に設定
self._target_location = self._agent_location
while np.array_equal(self._target_location, self._agent_location):
self._target_location = self.np_random.integers(
0, self.size, size=2, dtype=int
)
observation = self._get_obs()
info = self._get_info()
# 描画モードが指定されていれば描画
if self.render_mode == "human":
self._render_frame()
return observation, info
def step(self, action):
"""行動を実行し、環境を1ステップ進める"""
# 行動に対応する方向を取得
direction = self._action_to_direction[action]
# エージェントの位置を更新（グリッド内に収まるようにクリップ）
self._agent_location = np.clip(
self._agent_location + direction, 0, self.size - 1
)
# 終了条件: エージェントが目標に到達
terminated = np.array_equal(self._agent_location, self._target_location)
reward = 1.0 if terminated else 0.0 # シンプルな報酬設計
truncated = False # 時間制限による終了はなし
observation = self._get_obs()
info = self._get_info()
# 描画モードが指定されていれば描画
if self.render_mode == "human":
self._render_frame()
return observation, reward, terminated, truncated, info
def _get_obs(self):
"""現在の観測を取得する"""
return {
"agent": self._agent_location,
"target": self._target_location
}
def _get_info(self):
"""追加情報を取得する（デバッグ用）"""
return {
"distance": np.linalg.norm(
self._agent_location - self._target_location, ord=1
)
}
def render(self):
"""環境を描画する"""
if self.render_mode == "rgb_array":
return self._render_frame()
def _render_frame(self):
"""フレームを1枚描画する"""
if self.window is None and self.render_mode == "human":
pygame.init()
pygame.display.init()
self.window = pygame.display.set_mode(
(self.window_size, self.window_size)
)
if self.clock is None and self.render_mode == "human":
self.clock = pygame.time.Clock()
canvas = pygame.Surface((self.window_size, self.window_size))
canvas.fill((255, 255, 255)) # 白背景
# グリッドのマス目のサイズ（ピクセル）
pix_square_size = self.window_size / self.size
# 目標位置を赤い四角で描画
pygame.draw.rect(
canvas,
(255, 0, 0), # 赤色
pygame.Rect(
pix_square_size * self._target_location,
(pix_square_size, pix_square_size),
),
)
# エージェントを青い円で描画
pygame.draw.circle(
canvas,
(0, 0, 255), # 青色
(self._agent_location + 0.5) * pix_square_size,
pix_square_size / 3,
)
# グリッド線を描画
for x in range(self.size + 1):
pygame.draw.line(
canvas,
(0, 0, 0), # 黒色
(0, pix_square_size * x),
(self.window_size, pix_square_size * x),
width=3,
)
pygame.draw.line(
canvas,
(0, 0, 0), # 黒色
(pix_square_size * x, 0),
(pix_square_size * x, self.window_size),
width=3,
)
if self.render_mode == "human":
# 描画内容をウィンドウに反映
self.window.blit(canvas, canvas.get_rect())
pygame.event.pump()
pygame.display.update()
# フレームレートを安定させる
self.clock.tick(self.metadata["render_fps"])
else: # rgb_array
# RGB配列として返す
return np.transpose(
np.array(pygame.surfarray.pixels3d(canvas)), axes=(1, 0, 2)
)
def close(self):
"""環境のリソースを解放する"""
if self.window is not None:
pygame.display.quit()
pygame.quit()
カスタム環境を作成したら、Gymnasiumに登録することでgym.make()から簡単に呼び出せるようになります：
from gymnasium.envs.registration import register
# 環境の登録
register(
id="SimpleGrid-v0",
entry_point="my_module:SimpleGridEnv",
max_episode_steps=100, # エピソードの最大ステップ数
)
# 登録した環境の使用
import gymnasium as gym
env = gym.make("SimpleGrid-v0", size=10, render_mode="human")
gym.Envクラスを継承しますreset()とstep()は必ず実装する必要がありますobservation_spaceとaction_spaceを定義しますmetadataでレンダリングモードやフレームレートを指定しますreset()内でsuper().reset(seed=seed)を呼び出すことで、乱数の再現性を確保しますカスタム環境を作ることで、特定の問題設定に特化した実験ができるようになります。例えば、ロボット制御、金融取引シミュレーション、ゲームAIなど、あらゆる分野の問題を強化学習で解くための環境を構築できます。
環境を理解したところで、実際に強化学習アルゴリズムを実装してみましょう。ここではQ学習という古典的な手法を使った例を紹介します。
Q学習は表形式の強化学習アルゴリズムで、各状態・行動ペアの価値（Q値）を学習します。直感的には「この状態でこの行動を取るとどれだけ良いか」を数値で表したものです。
FrozenLakeは凍った湖の上を歩いて目標に到達する環境で、穴に落ちないように進む必要があります。
import gymnasium as gym
import numpy as np
import matplotlib.pyplot as plt
# 環境の作成（滑らない設定）
env = gym.make("FrozenLake-v1", is_slippery=False, render_mode="rgb_array")
# Q テーブルの初期化（状態数 × 行動数の表）
q_table = np.zeros([env.observation_space.n, env.action_space.n])
# 学習パラメータ
learning_rate = 0.8 # 学習率 (α): どれだけ新しい情報を取り入れるか
discount_factor = 0.95 # 割引率 (γ): 将来の報酬をどれだけ重視するか
epsilon = 0.1 # 探索率 (ε): ランダム行動を取る確率
episodes = 2000 # 学習エピソード数
# 結果を記録するためのリスト
rewards = []
success_count = 0
# 学習ループ
for episode in range(episodes):
state, _ = env.reset()
total_reward = 0
done = False
# エピソードのループ
while not done:
# 行動選択（ε-greedy方策）
if np.random.uniform(0, 1) epsilon:
action = env.action_space.sample() # 探索（ランダム行動）
else:
action = np.argmax(q_table[state]) # 活用（最適行動）
# 環境を1ステップ進める
next_state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
# Q値の更新（Q学習の核心部分）
# Q(s,a) ← (1-α) · Q(s,a) + α · [r + γ · max_a' Q(s',a')]
old_value = q_table[state, action]
next_max = np.max(q_table[next_state])
new_value = (1 - learning_rate) * old_value + learning_rate * (reward + discount_factor * next_max)
q_table[state, action] = new_value
# 状態の更新と報酬の記録
state = next_state
total_reward += reward
# エピソード終了時の処理
rewards.append(total_reward)
if total_reward > 0:
success_count += 1 # 成功回数をカウント
# 学習の進捗を表示（100エピソードごと）
if (episode + 1) % 100 == 0:
success_rate = success_count / 100
print(f"エピソード {episode + 1}/{episodes}, 成功率: {success_rate:.2f}")
success_count = 0 # カウンターリセット
# 学習結果の可視化
plt.figure(figsize=(10, 5))
# 移動平均を計算して学習曲線を滑らかに
window_size = 50
moving_avg = np.convolve(rewards, np.ones(window_size)/window_size, mode='valid')
plt.plot(range(window_size-1, len(rewards)), moving_avg)
plt.xlabel('エピソード')
plt.ylabel('報酬（移動平均）')
plt.title('Q学習の学習曲線（FrozenLake）')
plt.grid(True)
plt.show()
# 学習済みポリシーの可視化
def visualize_policy(q_table, env_size=4):
"""Q値から導出されたポリシーを矢印で可視化"""
actions = ['→', '↓', '←', '↑'] # 0:右, 1:下, 2:左, 3:上
policy = np.argmax(q_table, axis=1).reshape(env_size, env_size)
for row in range(env_size):
for col in range(env_size):
state_idx = row * env_size + col
print(f"{actions[np.argmax(q_table[state_idx])]}", end=" ")
print()
print("n学習した最適ポリシー:")
visualize_policy(q_table)
# 学習済みエージェントのテスト
def test_agent(env, q_table, episodes=5):
"""学習済みエージェントのテスト"""
for episode in range(episodes):
state, _ = env.reset()
done = False
steps = 0
print(f"nエピソード {episode + 1} テスト:")
while not done and steps 100: # 無限ループ防止
# 最高Q値の行動を選択
action = np.argmax(q_table[state])
# 環境を進める
state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
steps += 1
# 現在位置を表示（FrozenLakeは4x4のグリッド）
grid_pos = [(i // 4, i % 4) for i in range(16)]
for i in range(4):
for j in range(4):
if state == i * 4 + j:
print("X", end=" ") # エージェント位置
else:
print("·", end=" ")
print()
if done:
if reward > 0:
print(f"成功! {steps}ステップで目標達成")
else:
print(f"失敗! {steps}ステップで穴に落ちました")
break
# 表示のための一時停止
import time
time.sleep(0.5)
# テスト実行（コメントアウトを外して実行）
# test_agent(env, q_table)
このスクリプトは、FrozenLake環境でQ学習を実装しています。主なステップは：
gym.make("FrozenLake-v1", is_slippery=False)で環境を作成しますQ学習の核心は以下の更新式です：
$Q(s,a) leftarrow (1-alpha) cdot Q(s,a) + alpha cdot [r + gamma cdot max_{a’} Q(s’,a’)]$
この式を繰り返し適用することで、環境の動作を経験から学習し、最適な行動方針（ポリシー）を獲得します。
Gymnasiumを最大限に活用するために、連携できる主要なライブラリを紹介します。
CleanRLは、強化学習アルゴリズムの教育的実装を提供するライブラリです。特徴は：
# CleanRLを使ったPPOの実行例
!pip install cleanrl
!python -m cleanrl.ppo --env-id CartPole-v1 --total-timesteps 500000
Stable Baselines3は、信頼性の高い強化学習アルゴリズムの実装を提供するライブラリです：
from stable_baselines3 import PPO
import gymnasium as gym
# 環境の作成
env = gym.make("LunarLander-v2")
# モデルの作成と学習
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=100000)
# モデルの保存と読み込み
model.save("ppo_lunar")
model = PPO.load("ppo_lunar")
# 学習したモデルでテスト
obs, _ = env.reset()
for _ in range(1000):
action, _states = model.predict(obs, deterministic=True)
obs, reward, terminated, truncated, info = env.step(action)
if terminated or truncated:
obs, _ = env.reset()
PettingZooはGymnasiumのマルチエージェント版で、複数のエージェントが同時に行動する環境を扱えます：
from pettingzoo.butterfly import pistonball_v6
import supersuit as ss # 環境のラッパーライブラリ
# マルチエージェント環境の作成
env = pistonball_v6.parallel_env(
n_pistons=20,
time_penalty=-0.1,
continuous=True,
random_drop=True,
random_rotate=True,
ball_mass=0.75,
ball_friction=0.3,
ball_elasticity=1.5,
)
# 観測の前処理
env = ss.color_reduction_v0(env, mode='B')
env = ss.resize_v1(env, x_size=84, y_size=84)
env = ss.frame_stack_v1(env, 3)
# 環境のリセット
observations = env.reset()
while env.agents:
# 各エージェントの行動を決定（例：ランダム）
actions = {agent: env.action_space(agent).sample() for agent in env.agents}
# 環境を1ステップ進める
observations, rewards, terminations, truncations, infos = env.step(actions)
Gymnasiumには標準で多数の便利なラッパーが含まれています：
import gymnasium as gym
from gymnasium.wrappers import (
RecordVideo, # 動画記録
NormalizeObservation, # 観測の正規化
TimeLimit, # 時間制限
AtariPreprocessing, # Atari専用前処理
)
# ラッパーを適用した環境
env = gym.make("Breakout-v4")
env = AtariPreprocessing(env) # 画像の前処理
env = NormalizeObservation(env) # 観測の正規化（平均0、分散1）
env = RecordVideo(env, "videos/") # 動画記録
env = TimeLimit(env, max_episode_steps=1000) # 時間制限
# 通常通り環境を使用
observation, info = env.reset()
強化学習の実験を追跡するにはWeights & Biasesとの連携が便利です：
import wandb
from wandb.integration.gymnasium import WandbGym
# W&B の初期化
wandb.init(project="rl-experiments")
# 環境をWandbGymでラップ
env = gym.make("CartPole-v1")
env = WandbGym(env)
# 実験の実行（ログは自動的にW&Bに送信される）
observation, info = env.reset()
for _ in range(1000):
action = env.action_space.sample()
observation, reward, terminated, truncated, info = env.step(action)
if terminated or truncated:
observation, info = env.reset()
これらのライブラリを組み合わせることで、強化学習の実験がより効率的に、そして再現性を持って行えるようになります。
この記事では、強化学習のためのPythonライブラリGymnasiumについて紹介しました。Gymnasiumの主な魅力は以下の点です：
強化学習とGymnasiumをさらに深く理解するためのステップを紹介します：
アルゴリズムの理解:
実践的スキル:
応用分野の探索:
書籍:
オンラインコース:
実装リファレンス:
強化学習は非常に奥が深い分野であり、基本的な概念を理解することから始めて徐々に複雑なアルゴリズムや環境に挑戦していくことが大切です。Gymnasiumは、そんな強化学習の旅を始めるための素晴らしい足がかりとなるでしょう。
今回紹介したコード例をベースに、様々な環境やアルゴリズムを試して、強化学習の可能性を探求してみてください。思いもよらない問題が、強化学習によって解決できるかもしれません！
Happy Reinforcement Learning!
Be the first to comment
