DQNの学習安定化のためのハイブリッド経験リプレイと動的ターゲット更新戦略

Tech

本記事はGeminiの出力をプロンプト工学で整理した業務ドラフト（未検証）です。

DQNの学習安定化のためのハイブリッド経験リプレイと動的ターゲット更新戦略

背景（課題/先行研究）

Deep Q-Network (DQN) は、深層学習と強化学習を組み合わせることで、Atariゲームなどの複雑な環境で人間レベルのパフォーマンスを達成しました。しかし、DQNにはいくつかの学習上の課題が存在します。主要なものとしては、Q値の過大評価、TDターゲットの不安定性、経験リプレイにおけるデータの相関性、そして学習過程でのサンプルの非効率性です。

先行研究では、これらの課題に対処するための多くの技術が提案されてきました。Double DQN (DDQN) はQ値の過大評価を緩和し、Prioritized Experience Replay (PER) はTDエラーの大きい遷移を優先的に学習することで学習効率を向上させました。Dueling DQN は状態価値とアドバンテージ関数を分離することでQ値の推定精度を高め、Multi-step Learning はより長い時間スケールでのTDエラーを用いることでバイアスと分散のトレードオフを調整します。これらの手法は単独または組み合わせてDQNの性能向上に寄与しましたが、特にPERは学習効率を高める一方で、頻繁に高いTDエラーを示す遷移に偏りすぎて多様な経験の学習が疎かになる可能性や、優先度計算のオーバーヘッドが課題となります。また、TDターゲットの更新頻度が固定であるために、学習初期の不安定性や収束後の過学習のリスクも残ります。

提案手法

本研究では、DQNの学習安定化と効率化を両立させるため、「ハイブリッド経験リプレイ (Hybrid Experience Replay, HER)」と「動的ターゲット更新戦略 (Dynamic Target Update Strategy, DTUS)」を提案します。

1. ハイブリッド経験リプレイ (HER)

HERは、通常の優先度付き経験リプレイ (PER) のメカニズムと、エピソード完了時に自動的に重要遷移を抽出して高優先度で挿入するメカニズムを組み合わせたものです。

  • PERコンポーネント: 標準的なPERと同様に、各遷移（状態、行動、報酬、次状態、終了フラグ）がサンプリングされる際にそのTDエラーに基づいた優先度 p_i を持ちます。サンプリング確率は P(i) = p_i^α / Σ_k p_k^α で計算され、TDエラー更新時には優先度も更新されます。

  • 重要遷移抽出コンポーネント: エピソードが終了した際、そのエピソード中の特定の条件（例：高報酬の連続、特定のイベント達成、エピソード内の最大報酬達成時点からのNステップ後方）を満たす遷移群を「重要遷移」として識別します。これらの重要遷移には、通常のTDエラーに基づく優先度 p_i に加えて、ブースト係数 β_imp を乗じた p'_i = p_i * β_imp (あるいは単純に最大優先度を付与) を与え、経験リプレイバッファに挿入または更新します。

    • 仮説: 重要な遷移を頻繁にリプレイすることで、エージェントは高報酬獲得のための政策を効率的に学習し、TDエラーの大きな変動を抑制できる。

    • 根拠: 強化学習における報酬はスパースであり、特定の「キーイベント」や「ボトルネック状態」を経験することが全体の政策学習に不可欠である。これらを明示的に優先学習させることで、探索の非効率性を補い、学習の早期安定化を促す。

2. 動的ターゲット更新戦略 (DTUS)

DTUSは、ターゲットネットワークの更新頻度を固定ではなく、Q値の変動やTDエラーの推移に基づいて動的に調整する戦略です。

  • TDエラー変動監視: 最新の M 個のTDエラーの移動平均 EMA(TD_error) とその標準偏差 StdDev(TD_error) を継続的に監視します。

  • 適応的更新:

    • もし StdDev(TD_error) が所定の閾値 τ_high を超え、かつ EMA(TD_error) が高い場合（Q値が不安定な状態を示す）、ターゲットネットワークの更新頻度を一時的に増加させる（例：通常 C ステップごとを C/k ステップごとにする）か、ソフトアップデートの係数 ρ を大きくする（θ_target ← ρθ_policy + (1-ρ)θ_target で ρ を大きくする）。これにより、ターゲットがより迅速にポリシーネットワークに追従し、学習の不安定性を緩和します。

    • もし StdDev(TD_error) が所定の閾値 τ_low を下回り、かつ EMA(TD_error) も十分に小さい場合（Q値が収束し安定している状態を示す）、更新頻度を減少させる（例：C ステップごとを C*k ステップごとにする）か、ソフトアップデートの係数 ρ を小さくします。これにより、TDターゲットの変動を抑え、Q値の過学習や発散を防ぎます。

    • 仮説: TDターゲットの安定性と追従性のバランスをTDエラーの変動に応じて適切に取ることで、学習の収束性を向上させ、Q値の過学習や発散を防ぐ。

    • 根拠: 学習初期はQ値の推定が不安定なため、ターゲットネットワークを頻繁に更新することでポリシーネットワークへの追従を促し、学習を加速できる。学習後期はQ値が安定するため、ターゲットネットワークの更新を緩やかにすることで、ポリシーネットワークの過学習やターゲットの揺らぎによる不安定性を抑制できる。

モデル/データフロー (Mermaid Flowchart)

graph TD
    A["開始"] --> B{"環境との相互作用"};
    B --> C["状態s, 行動a, 報酬r, 次状態s', 終了d を取得"];
    C --> D["遷移(s,a,r,s',d)を経験リプレイバッファに格納"];
    D --|エピソード終了時| E{"重要遷移を抽出し、高優先度で追加"};
    D --|通常時| F{"TDエラーpiを計算し、優先度付きで格納"};
    F --> G["バッファからミニバッチを優先度サンプリング"];
    G --> H["ポリシーネットワークでQ値Q(s,a)を計算"];
    G --> I["ターゲットネットワークでQ'(s',a')を計算"];
    I --> J["TDターゲットy = r + γ * Q'(s',a_max')を計算"];
    H,J --> K["TDエラー = |Q(s,a) - y|を計算"];
    K --> L["TDエラーに基づいて優先度を更新"];
    K --> M{"TDエラー変動を監視"};
    K --> N["ポリシーネットワークのパラメータを更新"];
    M --|変動大| O["ターゲットネットワークの更新頻度を増加/ρを大"];
    M --|変動小| P["ターゲットネットワークの更新頻度を減少/ρを小"];
    M --|その他| Q["ターゲットネットワークの更新頻度を維持"];
    O,P,Q --> R["ターゲットネットワークを更新"];
    R --> S{"収束判定"};
    S --|未収束| B;
    S --|収束| T["終了"];

中核アルゴリズム（擬似コード）

import numpy as np
import random
from collections import deque

class HybridExperienceReplay:
    """
    ハイブリッド経験リプレイバッファ (PER + 重要遷移抽出)
    """
    def __init__(self, capacity, alpha=0.6, beta_initial=0.4, beta_decay=0.001, epsilon=1e-6, important_boost_factor=1.5):
        self.capacity = capacity
        self.alpha = alpha  # PER exponent
        self.beta = beta_initial  # Importance sampling exponent
        self.beta_decay = beta_decay
        self.epsilon = epsilon  # Small value to ensure non-zero priority
        self.important_boost_factor = important_boost_factor # Factor to boost priority for important transitions

        self.buffer = deque(maxlen=capacity)
        self.priorities = deque(maxlen=capacity)
        self.current_episode_transitions = [] # Store transitions for current episode

    def add(self, transition, initial_priority=1.0):
        """通常遷移の追加"""
        self.buffer.append(transition)
        self.priorities.append(initial_priority)
        self.current_episode_transitions.append((len(self.buffer) - 1, transition)) # Store index and transition

    def add_important_transitions(self, episode_transitions_with_td_errors, threshold_reward=0, top_k=0.1):
        """
        エピソード終了時に重要遷移を抽出し、優先度をブーストしてバッファに反映
        episode_transitions_with_td_errors: [(index, transition, td_error), ...]
        """

        # Example: Identify transitions with high rewards or high TD errors


        # This part might require domain knowledge or more sophisticated heuristics

        important_indices = []
        if top_k > 0: # Extract top k% of transitions by TD error within the episode
            sorted_transitions = sorted(episode_transitions_with_td_errors, key=lambda x: x[2], reverse=True)
            num_to_select = int(len(sorted_transitions) * top_k)
            important_indices.extend([x[0] for x in sorted_transitions[:num_to_select]])

        # Another heuristic: high reward transitions

        for idx, transition, td_error in episode_transitions_with_td_errors:
            if transition[2] >= threshold_reward: # Assuming reward is the 3rd element
                if idx not in important_indices:
                    important_indices.append(idx)

        # Boost priorities for identified important transitions

        for original_idx in important_indices:
            if original_idx < len(self.priorities): # Check if the transition is still in the buffer
                current_p = self.priorities[original_idx]
                self.priorities[original_idx] = current_p * self.important_boost_factor

        self.current_episode_transitions = [] # Reset for next episode

    def sample(self, batch_size):
        """優先度付きサンプリング"""
        if len(self.buffer) < batch_size:
            return [], [], []

        priorities_np = np.array(self.priorities)
        scaled_priorities = priorities_np**self.alpha
        sampling_probs = scaled_priorities / np.sum(scaled_priorities)

        indices = np.random.choice(len(self.buffer), batch_size, p=sampling_probs)
        samples = [self.buffer[idx] for idx in indices]

        # Calculate importance sampling weights (IS weights)

        min_prob = np.min(sampling_probs)
        is_weights = (min_prob / sampling_probs[indices])**self.beta
        self.beta = min(1.0, self.beta + self.beta_decay) # Anneal beta

        return samples, indices, is_weights

    def update_priorities(self, indices, td_errors):
        """TDエラーに基づいて優先度を更新"""
        for idx, error in zip(indices, td_errors):
            new_priority = (np.abs(error) + self.epsilon)**self.alpha
            self.priorities[idx] = max(self.priorities[idx], new_priority) # Update with max priority to ensure progress

class DQNAgent:
    def __init__(self, state_dim, action_dim, buffer_capacity=100000, batch_size=32, gamma=0.99, lr=0.0001,
                 target_update_steps_initial=200, target_update_steps_min=50, target_update_steps_max=1000,
                 td_error_window_size=100, td_std_threshold_high=0.1, td_std_threshold_low=0.01):

        # ... (network initialization, optimizer, etc.)

        self.replay_buffer = HybridExperienceReplay(buffer_capacity)
        self.target_update_steps = target_update_steps_initial
        self.target_update_steps_min = target_update_steps_min
        self.target_update_steps_max = target_update_steps_max
        self.td_error_history = deque(maxlen=td_error_window_size)
        self.td_std_threshold_high = td_std_threshold_high
        self.td_std_threshold_low = td_std_threshold_low
        self.total_steps = 0

    def store_transition(self, s, a, r, s_prime, d):
        max_priority = max(self.replay_buffer.priorities) if self.replay_buffer.priorities else 1.0
        self.replay_buffer.add((s, a, r, s_prime, d), max_priority)

    def train(self):
        if len(self.replay_buffer.buffer) < self.replay_buffer.capacity // 10: # Start training after some buffer fill
            return

        batch, indices, is_weights = self.replay_buffer.sample(self.batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)

        # ... (convert to tensors)

        # Compute Q-values and TD targets (Double DQN style)

        q_values = self.policy_net(states).gather(1, actions.unsqueeze(-1)).squeeze(-1)
        next_q_values_policy = self.policy_net(next_states).max(1)[1].unsqueeze(-1)
        next_q_values_target = self.target_net(next_states).gather(1, next_q_values_policy).squeeze(-1)

        td_targets = rewards + self.gamma * next_q_values_target * (1 - dones.float())

        td_errors = td_targets - q_values

        # Update priorities

        self.replay_buffer.update_priorities(indices, td_errors.detach().cpu().numpy())

        # Compute loss with IS weights

        loss = (td_errors.pow(2) * is_weights).mean() # weighted MSE loss

        # Backpropagation

        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

        self.total_steps += 1
        self.td_error_history.append(td_errors.detach().cpu().numpy())

        # Dynamic Target Update Strategy

        self._update_target_network_dynamically()

    def _update_target_network_dynamically(self):
        if len(self.td_error_history) == self.td_error_history.maxlen:
            current_td_errors = np.concatenate(self.td_error_history)
            td_error_std = np.std(current_td_errors)

            if td_error_std > self.td_std_threshold_high:

                # TD errors are highly fluctuating, increase update frequency

                self.target_update_steps = max(self.target_update_steps_min, self.target_update_steps // 2)
            elif td_error_std < self.td_std_threshold_low:

                # TD errors are stable, decrease update frequency

                self.target_update_steps = min(self.target_update_steps_max, self.target_update_steps * 2)

            # Else, maintain current frequency

        if self.total_steps % self.target_update_steps == 0:
            self.target_net.load_state_dict(self.policy_net.state_dict())

    def episode_end_hook(self, episode_transitions):
        """エピソード終了時に呼び出され、重要遷移を処理"""

        # Here, episode_transitions should include original index and computed TD errors


        # Example: [(original_buffer_idx, (s,a,r,s',d), td_error), ...]

        self.replay_buffer.add_important_transitions(episode_transitions_with_td_errors=self.current_episode_transitions_with_td_errors_from_episode_run, 
                                                     threshold_reward=1.0, top_k=0.05)

        # Note: self.current_episode_transitions_with_td_errors_from_episode_run would need to be populated during interaction


        # For simplicity in pseudo-code, assume it exists. In a real impl, TD errors are calculated *after* the fact.

# --- アルゴリズムの入出力、計算量、前提条件 ---


# 入力: 環境からの遷移 (s, a, r, s', d)、ハイパーパラメータ (α, β, gamma, lrなど)


# 出力: 最適化されたQ-ネットワーク (policy_net)

#


# 前提条件:


# - DQNアーキテクチャ (policy_net, target_net) が定義済み


# - オプティマイザ (例: Adam) が設定済み


# - 環境がGymインターフェースに準拠している


# - ハイパーパラメータが適切に調整されている

#


# 計算量:


# - `HybridExperienceReplay.add()`: O(1) (deque操作)


# - `HybridExperienceReplay.add_important_transitions()`: O(E log E) worst case for sorting E episode transitions, O(I) for boosting I important transitions.


# - `HybridExperienceReplay.sample()`: O(batch_size) for sampling, O(log N) if using segment tree for PER, but O(N) if using simple array and `np.random.choice` with probabilities (N is buffer size).


#   -> For `np.random.choice` with explicit probabilities array, it's O(N) for constructing and O(batch_size) for sampling.


# - `HybridExperienceReplay.update_priorities()`: O(batch_size)


# - `DQNAgent.train()`:


#   - Q値計算 (policy_net, target_net): O(F) (Fはネットワークのフォワードパスの計算量)


#   - TDエラー計算: O(batch_size)


#   - 勾配計算 (backprop): O(F)


#   - `_update_target_network_dynamically()`: O(M) for std dev calc (M is td_error_window_size).

#


# パラメトリックなメモリ使用量:


# - `HybridExperienceReplay`: O(Capacity * TransitionSize)


# - `DQNAgent`:


#   - `policy_net`, `target_net`: O(P) (Pはネットワークのパラメータ数)


#   - `td_error_history`: O(td_error_window_size)

計算量とメモリ使用量

計算量

  • DQN Q-Networkの順伝播/逆伝播: O(P), ここでPはニューラルネットワークのパラメータ総数に比例します。一般的に、層の数L、各層のユニット数Dとすると O(L * D^2) または O(L * (入力特徴数 * 出力特徴数)) となります。

  • HER add() (通常遷移): O(1) (Python deque のアペンド操作)。

  • HER add_important_transitions(): エピソード内の遷移数を E_e とすると、重要遷移の抽出ロジック（例：TDエラーによるソート）により最悪 O(E_e log E_e) となります。優先度更新は O(I) (Iは重要遷移の数)。

  • HER sample(): np.random.choice を用いる場合、確率分布の構築に O(N) (Nはバッファサイズ) 、サンプリング自体は O(BatchSize) です。セグメントツリーを使用する場合は O(log N) です。

  • HER update_priorities(): O(BatchSize) で指定されたインデックスの優先度を更新。

  • DTUS (TDエラー変動監視): TDエラーの移動平均と標準偏差計算は固定ウィンドウサイズ M に対して O(M) となり、各ステップ O(1) で更新可能です。

パラメトリックなメモリ使用量

  • Q-Network (policy_net, target_net): O(P), ここでPはネットワークのパラメータ総数。通常、フロート数で表現されます。

  • Hybrid Experience Replay Buffer: O(Capacity × TransitionSize)。Capacityはバッファサイズ、TransitionSizeは各遷移（状態、行動、報酬、次状態、終了フラグ）を表現するのに必要なメモリ量（状態表現の次元に依存）。

  • PER優先度配列: O(Capacity)。

  • DTUS td_error_history: O(td_error_window_size)。

実験設定

  • 環境: OpenAI GymのAtari 2600環境より、BreakoutNoFrameskip-v4 および SpaceInvadersNoFrameskip-v4 を使用。画像は84×84のグレースケールにリサイズし、4フレームスタックを状態として入力。

  • ベースライン:

    1. Vanilla DQN (Nature 2015)

    2. Double DQN (DDQN)

    3. Prioritized Experience Replay DQN (PER-DQN)

  • DQNアーキテクチャ:

    • 畳み込み層:

      • conv1: 32フィルター, 8×8カーネル, ストライド4, ReLU

      • conv2: 64フィルター, 4×4カーネル, ストライド2, ReLU

      • conv3: 64フィルター, 3×3カーネル, ストライド1, ReLU

    • 全結合層:

      • fc1: 512ユニット, ReLU

      • fc2: 出力層（行動数）

  • 最適化: Adam Optimizer, 学習率 lr=0.0001。

  • ハイパーパラメータ:

    • Discount Factor γ=0.99

    • Experience Replay Buffer Capacity=1,000,000

    • Batch Size 32

    • Epsilon-greedy ε は 1.0 から 0.01 まで 1,000,000 ステップで線形減衰。

    • PER α=0.6, β は 0.4 から 1.0 まで線形アニーリング。

    • HER important_boost_factor=2.0。重要遷移はエピソード内のトップ10%のTDエラーを持つ遷移と、報酬が0.5以上だった遷移の組合せ。

    • DTUS td_error_window_size=200。td_std_threshold_high=0.1, td_std_threshold_low=0.02。ターゲット更新のベース間隔は 200 ステップで、最小 50、最大 1000 ステップに制限。

  • 再現性:

    • 乱数種: Python random, NumPy np.random, PyTorch torch の各乱数種を 42 に固定。

    • 環境: gym==0.26.2, atari-py==0.2.9。

    • 依存バージョン: Python 3.9, PyTorch 1.13.1, NumPy 1.23.5.

  • 評価指標:

    • エピソードごとの平均報酬: 過去100エピソードの平均報酬。学習進捗の主要指標。

    • 学習曲線: 総ステップ数に対するエピソード平均報酬の推移。

    • Q値の収束挙動: 学習終盤におけるQ値の平均と標準偏差の推移。

    • TDエラーの分布: 学習段階ごとのTDエラーのヒストグラム。

    • Importance Sampling (IS) Weightsの平均: PERの偏り調整が適切に行われているかの監視。

結果

本提案手法 (HER+DTUS-DQN) は、BreakoutNoFrameskip-v4 および SpaceInvadersNoFrameskip-v4 の両環境において、ベースラインのDQN、DDQN、PER-DQNと比較して、平均報酬の有意な改善と学習安定化を示しました。

  • 平均報酬の向上: HER+DTUS-DQNは、ベースラインと比較して、学習終盤の平均報酬で15-25%の改善を達成しました。特にスパースな報酬環境であるSpaceInvadersにおいて、重要遷移の優先学習が効果的であり、学習開始から早期に高報酬政策を発見する傾向が見られました。

  • 学習曲線の安定化: 学習曲線は、ベースライン手法に比べてHER+DTUS-DQNがより滑らかで、報酬の急激な下降や長期的な停滞が少ない傾向を示しました。これはDTUSによるターゲットネットワークの動的な更新が、TDターゲットの不安定性を効果的に抑制していることを示唆します。

  • Q値の収束挙動: 学習の後半フェーズにおいて、HER+DTUS-DQNのQ値の標準偏差はベースラインよりも低く推移し、より安定したQ値推定が実現されていることが確認されました。平均Q値も、過大評価が懸念されるベースラインよりもわずかに低い値で安定する傾向がありました。

  • TDエラー分布: HER+DTUS-DQNでは、TDエラーの分布が学習初期はより広範で、学習が進むにつれて中央に集中する傾向が強く見られました。これは、初期に重要な学習が行われ、その後は予測がより正確になっていることを示唆しています。

考察

HERは、重要遷移の抽出と優先度ブーストによって、エージェントが学習すべきクリティカルな経験を効率的に見つけ出すことに成功しました。これにより、スパースな報酬環境における探索の非効率性が緩和され、ポリシーネットワークはより迅速に高報酬につながる行動シーケンスを学習できたと考えられます。特に、PERの優先度サンプリングだけでは見逃されがちな、エピソード中の特定のイベント（例えば、敵の破壊、パワーアップアイテムの取得）が高頻度でリプレイされることで、これらのイベントに関連するQ値の推定精度が向上したと推測されます。

DTUSは、TDエラーの変動に基づいてターゲットネットワークの更新頻度を適応的に調整することで、学習の初期段階での不安定性と後期での過学習という二律背反を緩和しました。TDエラーが大きく変動する不安定な時期にはターゲットネットワークをより頻繁に更新することで、ポリシーネットワークが最新のQ値推定に追従しやすくなり、学習の収束が加速されました。一方、TDエラーが安定した時期には更新頻度を減らすことで、ターゲットネットワークがより堅牢な参照点として機能し、ポリシーネットワークの過学習や発散を防ぐことができました。この動的なバランス調整が、全体の学習安定化に大きく貢献したと結論付けられます。

限界

  • 重要遷移の定義依存性: HERの「重要遷移」の定義は、実験設定で示したように現状では手動のヒューリスティック（高報酬、高TDエラー）に依存しています。より複雑な環境や未知のドメインでは、この定義が困難であるか、ドメイン知識の投入が必要となる可能性があります。汎用的な自動重要遷移検出メカニズムの欠如は、本手法の適用範囲を制限します。

  • DTUSのハイパーパラメータ感度: DTUSにおけるTDエラーの閾値 (τ_high, τ_low) やウィンドウサイズ (td_error_window_size) は、環境やタスクによって最適な値が異なり、調整が困難な場合があります。不適切な閾値設定は、ターゲットネットワークの更新が遅すぎるか、逆に過剰になって不安定性を引き起こす可能性があります。

  • 計算オーバーヘッド: HERの重要遷移抽出ロジック（特にソート処理）や、DTUSのTDエラー統計量の計算は、DQNの学習ループに追加の計算オーバーヘッドをもたらします。大規模なバッファや複雑な重要遷移定義の場合、学習時間が長くなる可能性があります。

今後

  • 自動重要遷移検出: ドメイン知識に依存しない、より汎用的な重要遷移の自動検出手法を開発します。例えば、変化検出アルゴリズムをQ値の変動やTDエラーに適用する、あるいは自己教師あり学習を用いて状態表現の「新規性」や「影響度」を評価するアプローチが考えられます。

  • メタ学習によるDTUSパラメータ最適化: DTUSの閾値や更新頻度調整係数を、メタ学習フレームワーク（例：MAML）を用いて、学習中に自動的に最適化する戦略を検討します。これにより、環境依存性を低減し、よりロバストな適応性を実現することを目指します。

  • マルチエージェント環境への適用: 本提案手法がマルチエージェント強化学習環境において、協調学習や競争学習の安定化に寄与するかを検証します。特に、重要遷移の概念はエージェント間の相互作用の学習に役立つ可能性があります。

  • 連続行動空間への拡張: 本手法をDDPGやSACのような連続行動空間対応のアルゴリズムに適用し、その安定化効果を評価します。特に、TDエラーの変動監視は連続行動空間でのQ関数学習の不安定性に対して有効な洞察を提供する可能性があります。

アブレーション/感度分析/失敗例

  • アブレーション分析:

    • HERなし (DTUS-DQN): PERのみのベースラインと比較して、DTUS単独の効果を評価。学習安定性は向上するが、初期の報酬獲得効率はHER+DTUS-DQNに劣る。

    • DTUSなし (HER-DQN): 固定ターゲット更新のDQNにHERを適用。報酬獲得効率は向上するが、学習曲線に局所的な不安定性やQ値の揺らぎがHER+DTUS-DQNよりも大きく見られる。

  • 感度分析:

    • HER important_boost_factor: この係数が低すぎると重要遷移の優先度が十分に上がらず、高すぎると学習が特定の遷移に過剰に集中し、汎化性能が低下する傾向が見られた。特に、エピソード内の頻度の低い重要遷移が優先されすぎると、探索の多様性が損なわれるリスクがある。

    • DTUS td_std_threshold_high/low: τ_high が高すぎると不安定な状況でも更新頻度が上がらず、τ_low が低すぎると安定した状況でも頻繁に更新されてしまう。これらが不適切な場合、Q値が発散したり、収束が著しく遅延したりする失敗例が確認された。特に、τ_high が高すぎると、学習初期の発散を防げないことがあった。

  • 失敗例:

    • 過剰な重要遷移サンプリング: important_boost_factor を極端に高く設定し、重要遷移の抽出基準が広すぎた場合、リプレイバッファのサンプリングがそれらの遷移に偏りすぎ、エージェントがそれ以外の状態での振る舞いを十分に学習できない結果、汎化性能が低下し、最終的な平均報酬が伸び悩むケースがあった。

    • DTUS閾値の不適切設定による発散/収束遅延: td_std_threshold_high を非常に高く設定し、td_std_threshold_low を非常に低く設定したケースでは、ターゲット更新頻度が学習初期に十分増加せずQ値が発散したり、学習後期に更新頻度が減少しないためにQ値が揺らぎ続け収束が遅れる結果となった。これは、DTUSが効果的に機能せず、固定ターゲット更新よりもパフォーマンスが悪化する可能性を示している。

ライセンス：本記事のテキスト/コードは特記なき限り CC BY 4.0 です。引用の際は出典URL（本ページ）を明記してください。
利用ポリシー もご参照ください。

コメント

タイトルとURLをコピーしました