emergent-temporal-abstraction

概要

このテクニックは、自己回帰モデルが時間的抽象化の発見を通じて階層的な振る舞いを学習することを可能にし、スパース報酬タスクの学習を劇的に加速化します。

コア技術

発見された抽象化による内部 RL:

class HierarchicalARModel:
    def __init__(self):
        self.base_ar_model = PretrainedAutoregressive()
        self.metacontroller = MetacontrollerPolicy()
        self.abstract_controllers = nn.ModuleList()

    def forward_hierarchical(self, state):
        # Metacontroller generates abstract action sequence
        abstract_actions = self.metacontroller.sample_actions(state)

        # Each abstract action is a sequence of residual stream modifications
        output = self.base_ar_model.initial_forward(state)

        for t, abstract_action in enumerate(abstract_actions):
            # Apply abstract action via residual stream modification
            controller_output = self.abstract_controllers[abstract_action](output)
            output = output + controller_output  # Residual addition
            
            # Check switching condition
            if self.should_switch(output, t):
                break  # Move to next abstract action

        return output

スイッチングゲートと時間的パターン:

def switching_gate_mechanism(features, temperature=1.0):
    """
    Binary switching via gating, creating sparse temporal patterns.
    """
    gate_logits = nn.Linear(hidden_dim, 1)(features)
    gate_prob = sigmoid(gate_logits / temperature)
    
    # Gumbel-softmax for differentiable sampling
    gate_sample = gumbel_softmax(gate_prob)
    
    return gate_sample

抽象空間での RL:

def abstract_space_rl(model, env):
    for episode in range(num_episodes):
        state = env.reset()
        abstract_actions = model.metacontroller.sample_actions(state)
        
        # Accumulate token-level transitions
        tokens = []
        for abstract_action in abstract_actions:
            token_sequence = model.forward_with_controller(abstract_action, state)
            tokens.extend(token_sequence)
            state = env.step(tokens)
        
        # RL update on abstract actions, not tokens
        reward = env.get_reward()
        log_prob = model.metacontroller.log_prob(abstract_actions)
        loss = -reward * log_prob
        loss.backward()

使用時機

次の場合に使用します:スパース報酬タスク、トークンレベル RL が遅すぎる場合、階層的構造が明らかな場合。

参考資料

• 抽象行動選択用のメタコントローラー
• コントローラーによる残差ストリーム修正
• 時間的抽象化のためのスイッチングゲート
• 抽象行動空間での RL