AWS DeepRacer

強化学習・自律走行・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 学習継続が推奨。

ドキュメントメタデータ

• 最終更新: 2026-04-27
• 対象者: 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 訓練環境を構築することが重要。