2nd/10_Wiki/Topics/Other/Anticipation.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-anticipation	Anticipation	10_Wiki/Topics	verified	self	Predictive Processing Forward Modeling Expectation	none	A	0.9	applied	cognition neuroscience prediction decision-making		2026-05-10	pending	language framework python pytorch-rl

Anticipation

매 한 줄

"매 anticipation 은 매 brain 의 forward model — 매 sensory input 이 도달하기 전에 매 prediction 을 미리 생성". 매 Helmholtz unconscious inference (1860s) 에서 시작, 매 Friston free-energy principle (2010s) 으로 정식화, 매 2026 LLM/world-model (Sora, Veo, Genie) 의 매 core mechanism.

매 핵심

매 핵심 개념

• Predictive coding: 매 brain 매 prediction error 만 propagate — 매 expected signal 의 suppress.
• Forward model: 매 motor command 의 sensory consequence 미리 simulate.
• Bayesian brain: 매 prior + likelihood = posterior — 매 anticipation 매 prior.
• Active inference: 매 action 의 future observation 의 prediction error 최소화.

매 Domain 별

• Motor: 매 reach-to-grasp 매 hand position 미리 simulate (cerebellum).
• Perceptual: 매 illusory contour, 매 phoneme restoration.
• Social: 매 theory of mind — 매 타인 행동 예측.
• Decision: 매 prospect theory loss-aversion 매 future regret 의 anticipation.

매 응용

1. Robotics: 매 model-predictive control (MPC).
2. LLM: 매 next-token prediction = 매 anticipation.
3. Game AI: 매 opponent modeling, 매 MCTS.
4. VR/AR: 매 motion-to-photon latency 매 user prediction 으로 hide.

💻 패턴

Pattern 1: Kalman filter anticipation

import numpy as np
class KalmanFilter1D:
    def __init__(self, q=0.01, r=0.1):
        self.x, self.P, self.q, self.r = 0.0, 1.0, q, r
    def predict(self):
        self.P += self.q
        return self.x  # 매 anticipated value
    def update(self, z):
        K = self.P / (self.P + self.r)
        self.x += K * (z - self.x)
        self.P *= (1 - K)

Pattern 2: 매 Predictive coding loss

import torch, torch.nn as nn
class PredCoder(nn.Module):
    def __init__(self, d):
        super().__init__()
        self.predictor = nn.Linear(d, d)
    def forward(self, x_t, x_tp1):
        pred = self.predictor(x_t)
        err  = x_tp1 - pred           # 매 prediction error
        return err.pow(2).mean(), pred

Pattern 3: 매 Model-predictive control (MPC)

def mpc_step(state, dynamics, cost, horizon=10, n_samples=200):
    actions = sample_actions(n_samples, horizon)
    costs = []
    for a_seq in actions:
        s = state
        c = 0
        for a in a_seq:
            s = dynamics(s, a)        # 매 forward simulation
            c += cost(s, a)
        costs.append(c)
    best = actions[np.argmin(costs)][0]
    return best

Pattern 4: 매 Anticipatory game AI (minimax with depth)

def minimax(state, depth, maximizing):
    if depth == 0 or state.terminal:
        return state.value()
    if maximizing:
        return max(minimax(s, depth-1, False) for s in state.children())
    return min(minimax(s, depth-1, True) for s in state.children())

Pattern 5: 매 LLM next-token (the original anticipation)

logits = model(input_ids)[:, -1, :]
probs  = logits.softmax(-1)
next_tok = probs.argmax(-1)         # 매 anticipated token

Pattern 6: 매 World-model rollout (Dreamer-style)

def imagine(world_model, init_state, policy, horizon=15):
    states, rewards = [init_state], []
    s = init_state
    for _ in range(horizon):
        a = policy(s)
        s, r = world_model.step(s, a)  # 매 latent rollout
        states.append(s); rewards.append(r)
    return states, rewards

매 결정 기준

상황	Anticipation 기법
매 sensor noise + linear dynamics	Kalman filter
매 nonlinear, low-D	particle filter / EKF
매 high-D control	MPC + sampling
매 game tree	minimax / MCTS
매 sequence modeling	transformer next-token
매 long-horizon RL	world model + imagination

기본값: 매 problem 의 dynamics 가 알려져 있으면 model-based (MPC, Kalman). 매 dynamics 학습 필요 → world model (Dreamer, MuZero).

🔗 Graph

• 부모: Decision-Making
• 변형: Predictive Processing · Bayesian-Updating
• 응용: Multi-agent-System · Joint-Optimization
• Adjacent: Inference-Coupled Persistence · Habit-Formation

🤖 LLM 활용

언제: 매 LLM 자체 매 anticipation engine — 매 next-token = 매 prediction. 매 agent planning 에서 매 future state 의 forecast. 언제 X: 매 stochastic dynamics + 매 high stakes — 매 explicit Bayesian model 더 reliable.

❌ 안티패턴

• Open-loop anticipation: 매 prediction 만 하고 매 update 안 하면 매 drift 누적.
• Over-confidence: 매 prior variance 너무 작으면 매 evidence ignore.
• Horizon mismatch: 매 task horizon 보다 매 model horizon 짧으면 매 myopic.
• Single-trajectory rollout: 매 stochastic env 에서 매 ensemble 필요.

🧪 검증 / 중복

• Verified (Friston 2010 Nat Rev Neurosci, Clark Surfing Uncertainty 2016, Hafner et al. DreamerV3 2024).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — predictive coding + 6 control/RL patterns