AWS DeepRacer 完全ガイド v2.0（2026年最新対応・End-of-Service 反映）

強化学習・自律走行・RL 教育プラットフォーム・2025年8月15日廃止対応

AWS DeepRacer は、「強化学習（Reinforcement Learning）を実践的に学習するための 1/18 スケール自律走行ミニカーと AWS クラウド RL 訓練環境」 である。SageMaker + RoboMaker でモデル訓練、OpenAI Gym 互換のシミュレーター環境でリアルタイム評価、物理デバイスで検証。PPO / SAC アルゴリズムで報酬関数を Python で定義。DeepRacer League でグローバル競技参加が可能。重要: AWS DeepRacer サービスは 2025年8月15日に End-of-Service。以降は SageMaker RL + OpenAI Gym + カスタム Gym 環境での RL 学習継続が推奨。

目次

1. ドキュメントメタデータ
2. 本質・課題・特徴
3. このサービスを選ぶ理由
4. アーキテクチャと設計原則
5. コアコンポーネント
6. 強化学習の仕組み
7. 報酬関数の実装
8. モデルの訓練
9. シミュレーション・評価
10. DeepRacer League
11. 物理デバイス操作
12. End-of-Service 対応・移行パス
13. 類似サービス比較表
14. ベストプラクティス
15. トラブルシューティング
16. 学習リソース・参考文献
17. 実装例・チェックリスト
18. まとめ

ドキュメントメタデータ

• 最終更新: 2026-04-27
• バージョン: v2.0
• 対象者: ML Engineer、AI Student、Researcher、Autonomous Vehicle Developer
• 難易度: 初級～中級（RL 入門）→ 上級（カスタム Gym 環境開発）
• 関連サービス: SageMaker AI、RoboMaker、S3、CloudWatch、EC2
• 重要: AWS DeepRacer は 2025年8月15日に End-of-Service
• 提供開始: 2018年（GA）、2024年 re:Invent で最終チャンピオンシップ、2025年8月15日廃止

本質・課題・特徴

本質

AWS DeepRacer は 「強化学習を実践的に学習する 1/18 スケール自律走行ミニカーと RL 訓練プラットフォーム」（廃止予定）である：

• 3 層構成：DeepRacer コンソール（UI）+ SageMaker（訓練）+ RoboMaker（シミュレーション）+ 物理デバイス（検証）
• 報酬関数設計：Python で カスタム報酬関数を定義（RL の本質的な要素）
• アルゴリズム：PPO（Proximal Policy Optimization）/ SAC（Soft Actor-Critic）
• シミュレーター：RoboMaker Gazebo（3D レーシングトラック）
• 競技プラットフォーム：DeepRacer League（月次オンラインレース + オンサイトイベント）
• End-of-Service: 2025年8月15日：以降は SageMaker RL + OpenAI Gym + カスタム環境で継続学習

End-of-Service の背景

AWS DeepRacer サービス廃止の理由：

1. SageMaker RL の汎用化：SageMaker RL が一般的な RL ライブラリ対応（Ray / Stable Baselines3）
2. OpenAI Gym エコシステムの成熟化：Gymnasium（OpenAI Gym 後継）で自由度の高い環境開発が可能
3. NVIDIA Isaac Sim / Carla Simulator の進化：より高度なシミュレーション環境が一般利用可能
4. コミュニティドリブン開発：オープンソース RL フレームワーク（OpenAI Gym / Stable Baselines3）で十分対応可能

従来の課題と解決

特徴

1. Console UI：ブラウザベース、クリックで訓練ジョブ投入
2. Reward Function：Python で カスタム報酬関数定義
3. Action Space：ステアリング / 速度の連続値制御
4. State Space：カメラ画像（RGB）+ LiDAR（オプション）
5. Training Algorithm：PPO（安定）/ SAC（連続制御向け）
6. Hyperparameter：学習率・エントロピー・クリップ範囲など手動調整
7. Physical Device：1/18 スケール RC カー（$399）、Wi-Fi でモデルをアップロード

このサービスを選ぶ理由（廃止までの期間）

2025年8月15日までに使用する理由

1. 強化学習の入門教育：RL 理論をゲーム形式で実践的に習得
2. AWS RL サービスの実習：SageMaker RL + RoboMaker の統合動作確認
3. コミュニティ競技：DeepRacer League（月次レース）で RL 実力試し
4. デバイス活用：既に購入した物理 DeepRacer カーの活用

具体的なユースケース（廃止まで）

• 企業内 ML エンジニア向けハンズオン：RL 基礎を 1 日で習得
• 大学の機械学習授業：実習課題として RL アルゴリズム実装・評価
• AWS re:Invent / Summit イベント：ハッカソン・競技イベント
• 自動運転・ロボット制御の基礎学習：エッジ推論・リアルタイム制御の理解
• 研究開発：RL アルゴリズムの高速プロトタイピング

アーキテクチャと設計原則

AWS DeepRacer（廃止予定）アーキテクチャ:

┌──────────────────────────────────────────────────────┐
│          DeepRacer コンソール（Web UI）              │
│  ┌──────────────────────────────────────────────────┐│
│  │ 報酬関数エディタ │ ハイパーパラメータ設定 │トラック│
│  │ action_space    │ learning_rate            │選択  │
│  │ sensor_config   │ batch_size                │      │
│  └──────────────────────────────────────────────────┘│
└──────────────────┬───────────────────────────────────┘
                   │ 訓練ジョブ投入
                   ▼
┌──────────────────────────────────────────────────────┐
│  AWS SageMaker（model training）                     │
│  ┌──────────────────────────────────────────────────┐│
│  │ PPO / SAC RL Agent                               ││
│  │ ├─ Policy Network（CNN: 画像 → Action）        ││
│  │ ├─ Value Network（価値関数）                   ││
│  │ ├─ Experience Buffer（経験リプレイ）           ││
│  │ └─ Reward Accumulation                          ││
│  └──────────────────────────────────────────────────┘│
└──────────────────┬───────────────────────────────────┘
                   │ 訓練済みモデル（tar.gz）
                   ▼
┌──────────────────────────────────────────────────────┐
│  AWS RoboMaker（simulation）                         │
│  ┌──────────────────────────────────────────────────┐│
│  │ Gazebo 3D レーシング環境                         ││
│  │ ├─ Summit Raceway（US 全リージョン）             ││
│  │ ├─ re:Invent 2018 Track                          ││
│  │ ├─ Virtual Circuit（複数トラック）              ││
│  │ └─ Custom Track（カスタムトラック）             ││
│  │                                                   ││
│  │ リアルタイムシミュレーション                    ││
│  │ ├─ Physics Engine（Gazebo ODE）                 ││
│  │ ├─ Sensor Simulation（Camera / LiDAR）         ││
│  │ ├─ Reward Calculation                           ││
│  │ └─ CloudWatch ログ記録                          ││
│  └──────────────────────────────────────────────────┘│
└──────────────────┬───────────────────────────────────┘
                   │ シミュレーション結果
                   ▼
┌──────────────────────────────────────────────────────┐
│  評価・分析                                           │
│  ├─ 完走率（%）                                      │
│  ├─ ラップタイム（秒）                               │
│  ├─ 報酬の収束・学習曲線                             │
│  └─ CloudWatch Metrics                              │
└──────────────────┬───────────────────────────────────┘
                   │ 良好 → 本番展開 / 不良 → ハイパー再調整
                   ▼
┌──────────────────────────────────────────────────────┐
│  物理デバイス（1/18 スケール RC カー）                │
│  ┌──────────────────────────────────────────────────┐│
│  │ DeepRacer Vehicle（NVIDIA Jetson Nano）         ││
│  │ ├─ Camera Front（RGB）                          ││
│  │ ├─ Motor Control（PWM Servo）                   ││
│  │ ├─ Inference Engine（TensorFlow Lite / TVM）   ││
│  │ └─ Wi-Fi（モデルアップロード）                  ││
│  │                                                   ││
│  │ トラック上でのリアルタイム走行・検証            ││
│  └──────────────────────────────────────────────────┘│
└──────────────────┬───────────────────────────────────┘
                   │ 結果フィードバック
                   ▼
┌──────────────────────────────────────────────────────┐
│  DeepRacer League（競技プラットフォーム）             │
│  ├─ Virtual Circuit（月次オンラインレース）         │
│  ├─ Global Leaderboard                              │
│  ├─ Achievement / Badge システム                    │
│  └─ Championship への進出機会                        │
└──────────────────────────────────────────────────────┘

強化学習の仕組み

RL フレームワーク（MDP）

# Markov Decision Process（MDP）の構成要素

# 1. State（状態）
state = {
    "image": camera_frame,           # RGB カメラ画像（320x240）
    "lidar": lidar_points,           # LiDAR ポイントクラウド（オプション）
    "x": car_position_x,             # カーの X 座標
    "y": car_position_y,             # カーの Y 座標
    "heading": car_heading_angle,    # カーの進行方向（度）
    "distance_from_center": dist,    # センターラインからの距離
    "speed": current_speed           # 現在の速度（m/s）
}

# 2. Action（行動）
action = {
    "steering_angle": float,  # ステアリング角度（-30 ～ 30 度）
    "speed": float            # 速度（0 ～ 4 m/s）
}

# 3. Reward（報酬）
reward = calculate_reward(state, action, next_state)
# 例: センターラインにいれば高報酬、コースアウトで負の報酬

# 4. Policy（ポリシー / 戦略）
policy = neural_network(state) → action  # CNN で画像 → Action 出力

# RL Loop
for episode in range(num_episodes):
    state = env.reset()
    for step in range(max_steps):
        action = agent.act(state)         # ポリシーから行動選択
        next_state, reward = env.step(action)  # 環境で実行
        agent.remember(state, action, reward)  # 経験を記憶
        agent.learn()                     # 経験から学習
        state = next_state

PPO（Proximal Policy Optimization）vs SAC（Soft Actor-Critic）

報酬関数の実装

基本：センターラインキープ + 速度ボーナス

def reward_function(params):
    """
    DeepRacer 報酬関数（基本型）
    
    params:
        all_wheels_on_track: bool（全タイヤがトラック上か）
        x, y: float（カーの座標）
        distance_from_center: float（センターラインからの距離 m）
        track_width: float（トラック幅 m）
        speed: float（速度 m/s）
        steering_angle: float（ステアリング角度 度）
        waypoints: list（トラック経路点）
        closest_waypoints: list（最も近い経路点のインデックス）
        heading: float（カーの進行方向 度）
        progress: float（トラック完走率 0-100%）
        steps: int（経過ステップ数）
    """
    
    # コースアウトは最低報酬
    if not params['all_wheels_on_track']:
        return 1e-3
    
    # センターラインからの距離による報酬
    distance_from_center = params['distance_from_center']
    track_width = params['track_width']
    
    # 3 段階報酬ゾーン
    marker_1 = 0.1 * track_width    # ゾーン 1: 中心付近
    marker_2 = 0.25 * track_width   # ゾーン 2: 中程度
    marker_3 = 0.5 * track_width    # ゾーン 3: エッジ
    
    if distance_from_center <= marker_1:
        distance_reward = 1.0
    elif distance_from_center <= marker_2:
        distance_reward = 0.5
    elif distance_from_center <= marker_3:
        distance_reward = 0.1
    else:
        # コースアウト（ゾーン外）
        distance_reward = 1e-3
    
    # 速度ボーナス（最大 2.0 m/s）
    speed = params['speed']
    max_speed = 2.0
    speed_reward = (speed / max_speed) ** 2  # 二乗で高速を大きく報酬
    
    # カーブでの急加速ペナルティ
    steering = abs(params['steering_angle'])
    if steering > 15 and speed > 1.5:
        # 急カーブで高速は不安定 → 報酬削減
        speed_reward *= 0.5
    
    # 総報酬 = 距離報酬 × 速度ボーナス
    reward = distance_reward * (1 + speed_reward)
    
    return float(reward)

高度：進路誤差 + ジャーク制御

def reward_function_advanced(params):
    """
    高度な報酬関数（進路誤差・ジャーク制御）
    """
    import math
    
    if not params['all_wheels_on_track']:
        return 1e-3
    
    # 進路誤差（カーの進行方向 vs トラック方向）
    heading = params['heading']
    waypoints = params['waypoints']
    closest = params['closest_waypoints']
    
    # 次の経路点への方向を計算
    next_point = waypoints[closest[1]]
    prev_point = waypoints[closest[0]]
    
    track_direction = math.atan2(
        next_point[1] - prev_point[1],
        next_point[0] - prev_point[0]
    )
    
    # 進路誤差（度）
    direction_diff = abs(track_direction - math.radians(heading))
    if direction_diff > math.pi:
        direction_diff = 2 * math.pi - direction_diff
    
    # 進路誤差による報酬
    heading_reward = 1.0 - (direction_diff / math.pi)
    
    # ジャーク（加速度の変化）制御
    # 急激な操舵・加速を抑制
    steering = params['steering_angle']
    speed = params['speed']
    
    # ステアリング平滑性
    steering_reward = 1.0 - (abs(steering) / 30.0)  # -30～30 度
    
    # 速度平滑性
    speed_reward = (speed / 2.0) ** 2
    
    # 総報酬 = 進路誤差 + ステアリング平滑 + 速度
    reward = (heading_reward * 0.4 + steering_reward * 0.3 + speed_reward * 0.3)
    
    return float(max(1e-3, reward))

モデルの訓練

DeepRacer コンソール経由の訓練

DeepRacer コンソール → Training Job 作成:

1. 報酬関数エディタで Python コード入力
2. ハイパーパラメータ設定:
   - Learning Rate: 0.0003
   - Batch Size: 64
   - Epoch: 3
   - Experience Buffer Size: 100,000
   - Discount Factor: 0.99
   - Loss Type: Huber（ロバスト）
3. Algorithm 選択: PPO or SAC
4. トラック選択: Summit Raceway / re:Invent 2018 等
5. 訓練時間指定: 1～12 時間
6. Training Job 開始 → CloudWatch で進捗監視
7. 訓練完了後、シミュレーターで自動評価

SageMaker RL Notebook（高度）- 後継方法

# 2025年8月15日以降の推奨手法: SageMaker RL Notebook

import sagemaker
from sagemaker.rl import RLEstimator
from sagemaker.instance_types import INSTANCE_TYPES
import gym
from gym import spaces

# カスタム Gym 環境（DeepRacer シミュレーション）
class DeepRacerEnv(gym.Env):
    def __init__(self):
        self.action_space = spaces.Box(
            low=np.array([-30.0, 0.0]),      # [steering, speed]
            high=np.array([30.0, 4.0]),
            dtype=np.float32
        )
        self.observation_space = spaces.Box(
            low=0, high=255,
            shape=(320, 240, 3),             # RGB 画像
            dtype=np.uint8
        )
        self.episode_steps = 0
        self.max_steps = 1000
        self.reset()
    
    def reset(self):
        # 環境初期化
        self.episode_steps = 0
        return self.get_state()
    
    def step(self, action):
        steering, speed = action
        # シミュレーター実行（Gazebo / CARLA）
        next_state, reward, done = self.simulate_step(steering, speed)
        self.episode_steps += 1
        done = done or (self.episode_steps >= self.max_steps)
        return next_state, reward, done, {}
    
    def get_state(self):
        # カメラ画像取得
        return np.random.randint(0, 256, (320, 240, 3), dtype=np.uint8)
    
    def simulate_step(self, steering, speed):
        # Gazebo / CARLA シミュレーション実行
        reward = self.calculate_reward(steering, speed)
        done = False
        return self.get_state(), reward, done
    
    def calculate_reward(self, steering, speed):
        # 報酬関数
        return 1.0 - abs(steering) / 30.0

# SageMaker RL 訓練設定
role = sagemaker.get_execution_role()
job_name = f"deepracer-rl-{time.strftime('%Y%m%d-%H%M%S')}"

estimator = RLEstimator(
    entry_point='training_script.py',
    role=role,
    instance_type='ml.p3.2xlarge',
    instance_count=1,
    framework='tensorflow',
    source_dir='.',
    job_name=job_name,
    hyperparameters={
        'learning_rate': 0.0003,
        'batch_size': 64,
        'algorithm': 'PPO',
        'epochs': 3
    }
)

estimator.fit({'training': training_data_path})

# モデル保存
model_path = estimator.model_data
print(f"Trained model: {model_path}")

シミュレーション・評価

訓練済みモデルの評価

# DeepRacer コンソール内での評価
# 訓練完了後、"Evaluate" タブで:

1. 訓練済みモデル選択
2. トラック選択（訓練と異なるトラックも可）
3. 評価回数（3～5 回推奨）
4. 評価開始

# 結果:
- 完走率（%）
- 平均ラップタイム（秒）
- 最速タイム（秒）
- 報酬の平均値

CloudWatch メトリクス監視

# 訓練の進捗を CloudWatch で確認
aws cloudwatch get-metric-statistics \
  --namespace DeepRacer \
  --metric-name EpisodeReward \
  --dimensions Name=JobName,Value=my-training-job-1 \
  --start-time 2026-04-27T00:00:00Z \
  --end-time 2026-04-28T00:00:00Z \
  --period 60 \
  --statistics Average,Maximum

DeepRacer League（競技）

月次バーチャルレース参加

DeepRacer League 参加手順:

1. コンソール → Leaderboard → Virtual Circuit 選択
2. 訓練済みモデルをシミュレーションで 3 回評価
3. スコアがリーダーボードに記録
4. グローバルランキングで順位確認（月次更新）

賞品:
├─ 月間優勝者: DeepRacer カー（$399）
├─ 月間 Top 10: AWS クレジット / T-shirt
├─ 年間総合優勝: re:Invent 招待（Championship）
└─ Achievement: ビッジ / バッジコレクション

End-of-Service 対応・移行パス

重要: 2025年8月15日 廃止対応

AWS DeepRacer 廃止スケジュール:

• 2025年7月15日: 新規モデル訓練不可
• 2025年7月31日: 新規デバイス購入不可（amazon.com）
• 2025年8月15日: DeepRacer コンソール / API サービス完全終了
• 2025年7月1日～8月15日: モデルエクスポート期間（S3 へのバックアップ推奨）

移行パス 1: SageMaker RL（推奨）

# SageMaker RL での RL モデル訓練（後継方法）

from sagemaker.estimator import Estimator
from sagemaker.tensorflow import TensorFlow

# 訓練スクリプト
training_code = '''
import gym
import numpy as np
from stable_baselines3 import PPO

env = gym.make("CarRacing-v1")
model = PPO("CnnPolicy", env, verbose=1)
model.learn(total_timesteps=100000)
model.save("deepracer_model")
'''

# SageMaker 訓練ジョブ
estimator = Estimator(
    image_uri='246618743249.dkr.ecr.us-west-2.amazonaws.com/sagemaker-rl:latest',
    role=role,
    instance_type='ml.p3.2xlarge',
    instance_count=1
)

estimator.fit(training_code)

移行パス 2: OpenAI Gym + Stable Baselines3（カスタム環境）

# Stable Baselines3 での自由度の高い RL 訓練

import gym
from stable_baselines3 import PPO, SAC
from stable_baselines3.common.vec_env import DummyVecEnv

# DeepRacer 互換の Gym 環境
class DeepRacerGymEnv(gym.Env):
    # （上記参照）
    pass

# 環境 Wrap
env = DummyVecEnv([lambda: DeepRacerGymEnv()])

# PPO で訓練（DeepRacer と同じアルゴリズム）
model = PPO('CnnPolicy', env, verbose=1, learning_rate=3e-4)
model.learn(total_timesteps=100000)

# モデル保存・ロード
model.save('deepracer_ppo_model')
loaded_model = PPO.load('deepracer_ppo_model')

# 推論
obs = env.reset()
action, _ = loaded_model.predict(obs)

移行パス 3: CARLA Simulator / NVIDIA Isaac Sim（高度）

# CARLA シミュレーター での RL 訓練（自動運転フレームワーク）

import carla
import gym

class CarlaRLEnv(gym.Env):
    def __init__(self, town='Town03'):
        self.client = carla.Client('localhost', 2000)
        self.world = self.client.load_world(town)
        self.bp_lib = self.world.get_blueprint_library()
        self.player = self.world.spawn_actor(
            self.bp_lib.filter('vehicle.tesla.model3')[0],
            self.world.get_map().get_spawn_points()[0]
        )
        
        self.action_space = gym.spaces.Box(low=-1, high=1, shape=(2,), dtype=np.float32)
        self.observation_space = gym.spaces.Box(
            low=0, high=255, shape=(224, 224, 3), dtype=np.uint8
        )
    
    def step(self, action):
        steering, throttle = action
        control = carla.VehicleControl(
            throttle=max(0, throttle),
            steer=steering,
            brake=max(0, -throttle)
        )
        self.player.apply_control(control)
        
        # 環境ステップ
        self.world.tick()
        
        # 報酬・状態・終了フラグを返却
        return self.get_observation(), self.get_reward(), self.is_done(), {}
    
    def reset(self):
        # 環境リセット
        return self.get_observation()
    
    def get_observation(self):
        # カメラ画像取得
        return np.zeros((224, 224, 3), dtype=np.uint8)
    
    def get_reward(self):
        # 報酬関数
        return 1.0
    
    def is_done(self):
        return False

# CARLA RL 訓練
env = CarlaRLEnv()
model = PPO('CnnPolicy', env)
model.learn(total_timesteps=100000)

類似サービス比較表

ベストプラクティス

1. 報酬関数の設計テンプレート

# テンプレート: 基本 → 実装 → テスト → 最適化

# Step 1: 基本報酬（50 パーセンタイル レベル）
def reward_basic(params):
    if not params['all_wheels_on_track']:
        return 1e-3
    distance_reward = 1.0 - (params['distance_from_center'] / params['track_width'])
    return distance_reward

# Step 2: 速度要素追加（75 パーセンタイル）
def reward_with_speed(params):
    base_reward = reward_basic(params)
    speed_bonus = (params['speed'] / 2.0) ** 2
    return base_reward * (1 + speed_bonus * 0.5)

# Step 3: 進路・ジャーク制御（90 パーセンタイル）
def reward_advanced(params):
    # センターラインキープ + 進路誤差 + ジャーク制御
    # （上記の "高度な報酬関数" 参照）
    pass

# 推奨: Step 2 から開始、訓練結果で Step 3 検討

2. ハイパーパラメータ チューニング戦略

初期設定（安定性重視）:
├─ Learning Rate: 0.0003（小さめ）
├─ Batch Size: 64
├─ Epoch: 3
├─ Discount Factor: 0.99
└─ Entropy: 0.01

改善サイクル（訓練 8 時間ごと）:
├─ Learning Rate 上げる（0.0005）
├─ Epoch 増加（5）
├─ Batch Size 調整（32 or 128）
└─ 報酬関数チューニング

終盤調整（完走率 > 70%）:
└─ 報酬関数を高度な手法に変更して微調整

3. Sim-to-Real Gap（シミュレーション↔現実の差）対策

問題: シミュレーターでは 99% 完走、実機では 30% 完走

対策 1: Gazebo パラメータ実機に合わせる
├─ 摩擦係数・重心・タイヤ直径
├─ Camera ノイズ・遅延シミュレーション
└─ Motor 応答遅延を導入

対策 2: ドメイン適応化（Domain Randomization）
├─ テクスチャ・照明・トラック色をランダム化
├─ センサーノイズを訓練に組み込む
└─ Physics パラメータをランダム変動

対策 3: 実機テストで段階的検証
├─ 低速（0.5 m/s）テスト
├─ センターラインキープのみ
└─ 段階的に速度・複雑度上げる

トラブルシューティング

学習リソース・参考文献

• AWS DeepRacer 公式ドキュメント
• The end of an era: the final AWS DeepRacer League Championship at re:Invent 2024
• AWS SageMaker RL Documentation
• OpenAI Gymnasium（Gym 後継）
• Stable Baselines3
• CARLA Simulator
• Custom deep reinforcement learning with Amazon SageMaker RL Notebook

実装例・チェックリスト

DeepRacer モデル訓練前チェック

• [ ] AWS アカウント・DeepRacer コンソールアクセス確認
• [ ] 報酬関数の Python 構文・ロジック検証
• [ ] ハイパーパラメータ（Learning Rate / Batch Size）を決定
• [ ] トラック選択（初心者は Summit Raceway 推奨）
• [ ] 訓練時間見積（1～12 時間）
• [ ] 訓練ジョブ開始・CloudWatch で進捗確認

シミュレーション・評価チェック

• [ ] 訓練完了後、評価実行（3～5 回）
• [ ] 完走率 / ラップタイムを記録
• [ ] 報酬関数改善の検討
• [ ] 次の訓練で別トラックテスト

実機展開チェック

• [ ] DeepRacer カーの充電・Wi-Fi 接続確認
• [ ] モデルをカーにアップロード
• [ ] トラック上で低速（0.5 m/s）テスト
• [ ] 段階的に速度 UP・複雑度向上
• [ ] Sim-to-Real Gap による不具合対策

2025年8月15日前の移行準備

• [ ] SageMaker RL での RL 訓練テスト
• [ ] OpenAI Gym カスタム環境開発（オプション）
• [ ] 訓練済みモデル S3 へのバックアップ
• [ ] Stable Baselines3 / Ray RLlib の学習・準備
• [ ] 後継ソリューションへの段階的移行

まとめ

AWS DeepRacer は 「強化学習を 1/18 スケール自律走行ミニカーで実践的に学習するプラットフォーム」（2025年8月15日廃止予定）。SageMaker + RoboMaker で RL モデルを訓練し、報酬関数を Python で定義して PPO / SAC アルゴリズムを適用。DeepRacer League でグローバル競技参加・学習動機付けが可能。廃止に伴い、後継として SageMaker RL + OpenAI Gym（Gymnasium）+ Stable Baselines3 への移行が推奨。 CARLA Simulator での自動運転研究・NVIDIA Isaac Sim での高度なシミュレーションへのステップアップも可能。2025年6月までに移行準備を完了し、8月15日までに後継ソリューションでの RL 訓練環境を構築することが重要。