docs(10_Wiki): 위키 전체 재구성 — Topic_* 폴더를 4개 카테고리로 통합 + 대규모 중복 제거

Topic_Agent/Topic_Blog/Topics/Topics_Biz/Topics_Meeting/Topics_Rag의 마크다운 지식 문서를
Topic_General/Topic_Programming/Topic_Graphic/Topic_Business 4개 카테고리로 재분류.

- 중복 제거: frontmatter의 status:duplicate/merged + duplicate_of/redirect_to 필드로
  자기 자신을 중복으로 선언한 리다이렉트 stub 1032개 제거, 완전 동일 내용 파일 472개 제거,
  동일 파일명·다른 내용 충돌 시 더 큰(완전한) 버전만 유지(162개 제거) — 총 1639개 중복 제거.
- 분류: 폴더 단위로 명확한 항목(AI_and_ML/Coding/Architecture 등 → Programming,
  Comfyui/Visual_Effects → Graphic, Topics_Biz/Topics_Meeting/사업 등 → Business,
  Poetic_Blog_Writing/창의성/Game_Design 등 → General)은 폴더 우선순위로,
  나머지 혼재 폴더(Topic_Agent/Topic_Blog/Topics 루트/Thinking & Reasoning/Other/UI_UX_Assets)는
  title/tags 키워드 스코어링으로 파일 단위 분류(불명확한 경우 General로 폴백).
  원본 폴더명은 "From_*" 서브폴더로 보존해 추적 가능성 유지.
- 최종 배치: Programming 2784 / General 1608 / Graphic 285 / Business 249 = 4926개 문서.
- 에이전트 운영 상태(.astra/.agent/.obsidian/sessions/memory/_company/docs/lessons/_shared/src)는
  지식 콘텐츠가 아니므로 재분류 대상에서 제외하고 원위치 유지.
- Topics/Topic_email(상위 보호 폴더 Topic_email과 파일명 100% 중복) 삭제 — 보호 폴더 자체는 미변경.
- 완전히 비게 된 Topic_Agent/Topic_Blog/Topics_Biz/Topics_Rag 폴더 제거.
This commit is contained in:
Antigravity Agent
2026-07-05 00:33:48 +09:00
parent 1cfd3bbb56
commit 9148c358d0
6455 changed files with 1 additions and 86875 deletions
@@ -0,0 +1,283 @@
---
id: wiki-2026-0508-credit-assignment
title: Credit Assignment Problem
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [credit assignment, temporal credit, structural credit, backpropagation, GAE, PRM, attribution]
duplicate_of: none
source_trust_level: A
confidence_score: 0.93
verification_status: applied
tags: [reinforcement-learning, credit-assignment, backpropagation, gae, prm, attribution, multi-agent, llm]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: PyTorch / JAX / RL libs
---
# Credit Assignment Problem
## 매 한 줄
> **"매 누가 / 매 무엇 의 reward 의 기여?"**. 매 long sequence 의 final reward 의 매 step 별 attribution. 매 RL 의 fundamental + 매 deep learning 의 backprop 의 essence. 매 modern: GAE, PRM, RLHF, multi-agent.
## 매 핵심 type
### Temporal Credit Assignment
- 매 sequence of action → 매 final reward.
- 매 어떤 action 의 결정?
- 매 RL 의 challenge.
### Structural Credit Assignment
- 매 layered NN → 매 error.
- 매 어떤 weight / neuron 의 fix?
- 매 backprop 의 solve.
### Multi-agent Credit
- 매 N agent → 매 collective reward.
- 매 individual contribution.
## 매 solution
### Backpropagation (structural)
- 매 chain rule.
- 매 each layer 의 gradient.
- 매 1986 Rumelhart-Hinton-Williams.
### TD Learning (temporal)
- 매 bootstrap.
- 매 [[Computational-Neuroscience-RL]] 참조.
### Eligibility Trace
- 매 past action 의 trace 유지.
- 매 TD(λ).
### GAE (Generalized Advantage Estimation)
- Schulman 2015.
- 매 bias-variance trade-off.
- 매 PPO 의 standard.
- $A_t = \sum_{l=0}^{\infty} (\gamma\lambda)^l \delta_{t+l}$
### Hindsight Experience Replay (HER)
- 매 fail trajectory 의 매 different goal 의 reuse.
### Reward Shaping
- 매 dense intermediate reward.
- 매 careful: 매 unintended optimal X.
### Process Reward Model (PRM, modern)
- 매 매 step 의 grade.
- 매 OpenAI Math, 매 DeepSeek-Prover.
- 매 outcome reward 보다 매 finer.
### Counterfactual (multi-agent)
- COMA (Counterfactual Multi-Agent Policy Gradient).
- 매 1 agent 의 fix → 매 contribution.
### Attention attribution (LLM)
- 매 attention score 의 attribution.
- 매 SHAP, integrated gradient.
## 매 응용
1. **Game AI**: 매 chess / Go (long horizon).
2. **Robotics**: 매 sparse reward.
3. **LLM RLHF**: 매 token-level reward.
4. **Multi-agent**: 매 cooperative.
5. **Medical**: 매 long-term outcome.
6. **Finance**: 매 portfolio.
## 💻 패턴
### Backpropagation (structural)
```python
import torch
x = torch.tensor([1.0, 2.0], requires_grad=True)
W1 = torch.randn(2, 3, requires_grad=True)
W2 = torch.randn(3, 1, requires_grad=True)
h = torch.relu(x @ W1)
y = h @ W2
loss = (y - target).pow(2).mean()
loss.backward() # 매 W1, W2 의 gradient (credit) 계산.
print(W1.grad) # 매 each weight 의 contribution.
```
### TD(0) (temporal)
```python
def td_update(V, state, reward, next_state, alpha=0.1, gamma=0.95):
td_error = reward + gamma * V[next_state] - V[state]
V[state] += alpha * td_error
return V
```
### TD(λ) with eligibility trace
```python
class TDLambda:
def __init__(self, n_states, alpha=0.1, gamma=0.95, lam=0.9):
self.V = np.zeros(n_states)
self.e = np.zeros(n_states)
self.alpha, self.gamma, self.lam = alpha, gamma, lam
def update(self, state, reward, next_state):
td_error = reward + self.gamma * self.V[next_state] - self.V[state]
self.e *= self.gamma * self.lam
self.e[state] += 1 # 매 visited state 의 trace 증가
self.V += self.alpha * td_error * self.e # 매 trace 비례 update
```
### GAE (PPO standard)
```python
def compute_gae(rewards, values, gamma=0.99, lam=0.95):
"""매 매 step 의 advantage."""
advantages = np.zeros_like(rewards)
last_gae = 0
for t in reversed(range(len(rewards))):
delta = rewards[t] + gamma * values[t+1] - values[t]
advantages[t] = last_gae = delta + gamma * lam * last_gae
return advantages
```
### Hindsight Experience Replay
```python
def her_relabel(trajectory, goal_extractor):
"""매 failure 의 매 goal 의 reach 의 success 로 relabel."""
new_trajectories = [trajectory]
# 매 final state 의 매 goal
final_state = trajectory[-1].state
new_goal = goal_extractor(final_state)
relabeled = []
for t in trajectory:
new_reward = 1.0 if reached(t.next_state, new_goal) else -0.01
relabeled.append(Transition(t.state, t.action, new_reward, t.next_state, new_goal))
new_trajectories.append(relabeled)
return new_trajectories
```
### Reward shaping (caution)
```python
def shaped_reward(state, action, next_state):
base_reward = environment_reward(state, action, next_state)
# 매 distance-based shaping (Ng 1999 — potential-based 안전)
phi = lambda s: -distance_to_goal(s)
shaping = gamma * phi(next_state) - phi(state)
return base_reward + shaping
```
### Process Reward Model (PRM)
```python
def prm_train(model, trajectories):
"""매 각 step 의 quality 의 supervised label."""
for traj in trajectories:
for step in traj.steps:
# 매 human / verifier label
quality = label_step(step.state, step.action, step.reasoning)
loss = model.loss(step, quality)
loss.backward()
optimizer.step()
# 매 inference: 매 each generation step 의 PRM score.
def search_with_prm(prompt, prm, beam=4, depth=10):
candidates = [prompt]
for d in range(depth):
all_candidates = []
for c in candidates:
for cont in generate_n(c, n=beam*2):
score = prm.score(c + cont)
all_candidates.append((c + cont, score))
all_candidates.sort(key=lambda x: -x[1])
candidates = [c for c, _ in all_candidates[:beam]]
return candidates[0]
```
### COMA (multi-agent counterfactual)
```python
def coma_advantage(joint_actions, q_function, agent_idx):
"""매 specific agent 의 contribution = joint Q counterfactual baseline."""
actual_q = q_function(joint_actions)
# 매 agent_idx 의 매 다른 action 의 average
counterfactual_q = 0
for alt_action in action_space:
alt = list(joint_actions)
alt[agent_idx] = alt_action
counterfactual_q += q_function(alt) * policy[agent_idx][alt_action]
return actual_q - counterfactual_q
```
### Attention-based attribution
```python
import torch
def attention_attribution(model, input_ids, target_token_idx):
"""매 매 input token 의 contribution to 매 specific output."""
output = model(input_ids, output_attentions=True)
attentions = output.attentions # 매 N layer × N head × seq × seq
# 매 target token 의 attention to 매 input
avg = torch.stack(attentions).mean(dim=(0, 1, 2)) # 매 reduce
return avg[target_token_idx] # 매 (seq,) — 매 매 input 의 contribution
```
### RLHF token-level credit
```python
def rlhf_token_advantage(generated_tokens, reward_model):
"""매 reward 의 token-level distribute."""
final_reward = reward_model(generated_tokens)
# 매 simple: 매 final 의 모든 token 의 distribute (inefficient)
simple = [final_reward / len(generated_tokens)] * len(generated_tokens)
# 매 better: 매 PRM 의 step-level
prm_scores = process_reward_model.score_each(generated_tokens)
return prm_scores
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Long horizon | TD + GAE |
| Sparse reward | HER + reward shaping |
| Math / multi-step | PRM |
| Deep NN | Backprop |
| Multi-agent | COMA / counterfactual |
| LLM RLHF | PRM > outcome reward |
| Interpretability | SHAP / attention |
**기본값**: 매 GAE (PPO) + 매 PRM (LLM math/code).
## 🔗 Graph
- 부모: [[Reinforcement-Learning]] · [[Optimization]] · [[Deep Learning]]
- 변형: [[데이터 사이언스 및 ML 엔지니어링|Backpropagation]] · [[TD-Learning]] · [[GAE]] · [[HER]] · [[PRM]]
- 응용: [[PPO]] · [[RLHF]] · [[Best-of-N_Sampling]] · [[Multi-agent-System|Multi-Agent-Systems]]
- Adjacent: [[Computational-Neuroscience-RL]] · [[Bayesian-Brain-Hypothesis]] · [[Bias-Correction-Algorithm]] · [[Causal-Inference]]
## 🤖 LLM 활용
**언제**: 매 RL design. 매 RLHF / PRM. 매 multi-agent system. 매 attribution.
**언제 X**: 매 supervised IID (다른 paradigm).
## ❌ 안티패턴
- **Outcome reward 만 (long horizon)**: 매 sparse signal.
- **Reward shaping 의 careless**: 매 unintended optimal.
- **No eligibility trace** (long): 매 slow learning.
- **PRM 의 noisy label**: 매 wrong attribution.
- **Multi-agent 의 individual reward 의 share**: 매 lazy agent.
## 🧪 검증 / 중복
- Verified (Schulman GAE, Andrychowicz HER, OpenAI PRM, Foerster COMA).
- 신뢰도 A.
- Related: [[Reinforcement-Learning]] · [[Computational-Neuroscience-RL]] · [[RLHF]] · [[Causal-Inference]] · [[Best-of-N_Sampling]].
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — temporal/structural/multi-agent + 매 GAE / HER / PRM / COMA code |