2025년 강화학습 트렌드와 최신 기술

2024년 강화학습의 선구자인 Richard Sutton과 David Silver가 튜링상을 수상했습니다. 2025년 현재, 강화학습은 LLM 추론, 로보틱스, 멀티모달 AI 등 다양한 분야에서 핵심 기술로 자리잡았습니다. 이 글에서는 최신 연구 동향과 새로운 알고리즘들을 살펴봅니다.

---

1. 강화학습 시장 현황

강화학습은 AI 분야에서 빠르게 성장하는 영역으로, 게임, 로보틱스, LLM 정렬 등 다양한 산업에서 활용이 확대되고 있습니다.

주요 적용 분야

---

2. 추론 모델과 강화학습

DeepSeek-R1 (2025)

DeepSeek-R1은 강화학습만으로 추론 능력을 학습한 모델입니다.

핵심 특징:

• SFT 없이 순수 RL로 학습
• GRPO (Group Relative Policy Optimization) 사용
• 수학, 코딩에서 OpenAI o1 수준 달성

# GRPO 개념 코드
def grpo_update(model, prompt, group_size=8):
    """
    Group Relative Policy Optimization
    그룹 내 상대 비교로 학습
    """
    # 같은 프롬프트에 여러 응답 생성
    responses = [model.generate(prompt) for _ in range(group_size)]

    # 각 응답 검증 (수학: 정답 체크, 코드: 테스트 통과)
    scores = [verify_response(r) for r in responses]

    # 그룹 평균 대비 상대 점수
    mean_score = sum(scores) / len(scores)
    advantages = [s - mean_score for s in scores]

    # 상대적으로 좋은 응답 강화
    for response, advantage in zip(responses, advantages):
        if advantage > 0:
            model.reinforce(response, weight=advantage)

OpenAI o1/o3 시리즈

"Chain of Thought"를 RL로 학습:

• 긴 추론 과정을 거쳐 답변
• 문제 해결 과정에서 자체 검증
• 수학/과학 벤치마크에서 인간 전문가 수준

Test-Time Compute

학습 시간 대신 추론 시간에 계산 집중:

def test_time_scaling(model, problem, compute_budget):
    """
    추론 시간에 더 많은 계산을 투자
    """
    candidates = []

    while compute_used < compute_budget:
        # 여러 추론 경로 생성
        reasoning_path = model.generate_with_cot(problem)
        answer = extract_answer(reasoning_path)

        # 자체 검증
        verification = model.verify(problem, answer)

        candidates.append({
            'answer': answer,
            'confidence': verification['confidence'],
            'path': reasoning_path
        })

        compute_used += 1

    # 가장 신뢰도 높은 답변 선택
    return max(candidates, key=lambda x: x['confidence'])

---

3. RLVR: 검증 가능한 보상

기존 RLHF의 한계

• 인간 레이블링 비용이 높음
• 보상 모델의 편향 문제
• 주관적 선호도의 불일관성

RLVR (Reinforcement Learning with Verifiable Rewards)

자동으로 검증 가능한 태스크에서 강화학습:

class VerifiableReward:
    """검증 가능한 보상 함수들"""

    @staticmethod
    def math_reward(response, ground_truth):
        """수학 문제: 정답 비교"""
        extracted = extract_final_answer(response)
        return 1.0 if extracted == ground_truth else 0.0

    @staticmethod
    def code_reward(code, test_cases):
        """코드 문제: 테스트 케이스 통과율"""
        passed = 0
        for test in test_cases:
            try:
                result = execute_code(code, test['input'])
                if result == test['expected']:
                    passed += 1
            except:
                pass
        return passed / len(test_cases)

    @staticmethod
    def logic_reward(proof, theorem):
        """논리 증명: 형식 검증기로 확인"""
        return formal_verifier.check(proof, theorem)

적용 분야

---

4. Offline RL과 Decision Transformer

Offline RL

기존 데이터만으로 학습 (환경 상호작용 없이):

# Online RL: 환경과 상호작용하며 학습
for step in range(total_steps):
    action = agent.select_action(state)
    next_state, reward = env.step(action)
    agent.learn(state, action, reward, next_state)

# Offline RL: 수집된 데이터셋으로만 학습
dataset = load_offline_dataset()  # 사전 수집된 데이터
for batch in dataset:
    agent.learn_offline(batch)

장점:

• 비용이 적음 (새 데이터 수집 불필요)
• 안전함 (위험한 탐험 없음)
• 기존 로그 데이터 활용 가능

도전 과제:

• Distribution shift: 학습 데이터와 다른 상태 처리
• 보수적 학습 필요: 데이터에 없는 행동 과대평가 방지

Decision Transformer

강화학습을 시퀀스 모델링으로 재정의:

class DecisionTransformer(nn.Module):
    """
    RL을 sequence modeling으로 변환
    조건: 목표 return → 예측: 행동
    """

    def __init__(self, state_dim, action_dim, hidden_dim=128, max_length=20):
        super().__init__()

        self.state_embed = nn.Linear(state_dim, hidden_dim)
        self.action_embed = nn.Linear(action_dim, hidden_dim)
        self.return_embed = nn.Linear(1, hidden_dim)
        self.timestep_embed = nn.Embedding(max_length, hidden_dim)

        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(hidden_dim, nhead=4, dim_feedforward=hidden_dim*4),
            num_layers=4
        )

        self.action_head = nn.Linear(hidden_dim, action_dim)

    def forward(self, returns_to_go, states, actions, timesteps):
        """
        입력: (R_t, s_t, a_t, R_{t+1}, s_{t+1}, a_{t+1}, ...)
        출력: 예측된 행동
        """
        batch_size, seq_len = states.shape[:2]

        # 각 요소 임베딩
        return_embeddings = self.return_embed(returns_to_go.unsqueeze(-1))
        state_embeddings = self.state_embed(states)
        action_embeddings = self.action_embed(actions)
        time_embeddings = self.timestep_embed(timesteps)

        # 토큰 순서: R, s, a, R, s, a, ...
        stacked = torch.stack([
            return_embeddings + time_embeddings,
            state_embeddings + time_embeddings,
            action_embeddings + time_embeddings
        ], dim=2).reshape(batch_size, seq_len * 3, -1)

        # Transformer
        transformer_output = self.transformer(stacked)

        # 상태 위치에서 행동 예측
        state_positions = torch.arange(1, seq_len * 3, 3)
        action_preds = self.action_head(transformer_output[:, state_positions])

        return action_preds


def inference_with_dt(model, env, target_return):
    """
    목표 return을 조건으로 행동 생성
    """
    state = env.reset()
    returns_to_go = target_return
    states = [state]
    actions = []
    timesteps = [0]

    for t in range(max_steps):
        # 지금까지의 시퀀스로 다음 행동 예측
        action = model.get_action(
            returns_to_go=returns_to_go,
            states=states,
            actions=actions,
            timesteps=timesteps
        )

        next_state, reward, done = env.step(action)

        # 시퀀스 업데이트
        states.append(next_state)
        actions.append(action)
        timesteps.append(t + 1)
        returns_to_go -= reward  # 남은 목표 return 감소

        if done:
            break

    return sum(rewards)

장점

• Transformer의 확장성 활용
• 목표 return 조건화로 다양한 성능 수준 달성
• Offline 데이터만으로 학습

---

5. Vision-Language-Action (VLA) 모델

로보틱스의 Foundation Model

멀티모달 입력 (이미지 + 언어 지시) → 로봇 행동:

class VLAModel(nn.Module):
    """Vision-Language-Action 모델"""

    def __init__(self, vision_encoder, language_encoder, action_dim):
        super().__init__()
        self.vision_encoder = vision_encoder  # ViT 등
        self.language_encoder = language_encoder  # BERT 등

        self.fusion = nn.TransformerEncoder(...)
        self.action_head = nn.Linear(hidden_dim, action_dim)

    def forward(self, image, instruction):
        """
        입력: 카메라 이미지 + 자연어 지시
        출력: 로봇 행동 (관절 각도, 그리퍼 등)
        """
        vision_features = self.vision_encoder(image)
        language_features = self.language_encoder(instruction)

        # 멀티모달 퓨전
        combined = torch.cat([vision_features, language_features], dim=1)
        fused = self.fusion(combined)

        action = self.action_head(fused[:, 0])  # CLS 토큰
        return action

대표 모델들

---

6. World Models

개념

환경의 내부 모델을 학습하여 "상상" 속에서 계획:

class WorldModel(nn.Module):
    """
    환경 역학 모델
    MuZero의 일반화
    """

    def __init__(self, state_dim, action_dim, latent_dim=256):
        super().__init__()

        # 관측 → 잠재 상태
        self.encoder = nn.Sequential(
            nn.Linear(state_dim, 256),
            nn.ReLU(),
            nn.Linear(256, latent_dim)
        )

        # 잠재 상태 전이
        self.dynamics = nn.GRU(action_dim, latent_dim, batch_first=True)

        # 잠재 상태 → 관측
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(),
            nn.Linear(256, state_dim)
        )

        # 보상 예측
        self.reward_predictor = nn.Linear(latent_dim, 1)

    def imagine(self, initial_state, action_sequence):
        """
        행동 시퀀스에 따른 미래 상상
        실제 환경 없이 시뮬레이션
        """
        latent = self.encoder(initial_state)
        imagined_states = []
        imagined_rewards = []

        for action in action_sequence:
            latent, _ = self.dynamics(action.unsqueeze(1), latent.unsqueeze(0))
            latent = latent.squeeze(0)

            state = self.decoder(latent)
            reward = self.reward_predictor(latent)

            imagined_states.append(state)
            imagined_rewards.append(reward)

        return imagined_states, imagined_rewards

    def plan(self, current_state, planning_horizon=10, num_candidates=100):
        """
        World model로 계획
        """
        best_reward = float('-inf')
        best_actions = None

        for _ in range(num_candidates):
            # 무작위 행동 시퀀스
            actions = [random_action() for _ in range(planning_horizon)]

            # 상상 속에서 시뮬레이션
            _, rewards = self.imagine(current_state, actions)
            total_reward = sum(rewards)

            if total_reward > best_reward:
                best_reward = total_reward
                best_actions = actions

        return best_actions[0]  # 첫 행동 반환

Dreamer 시리즈

Danijar Hafner 등의 World Model 기반 RL:

• Dreamer v1 (2019): 이미지 관측에서 잠재 상태 학습
• Dreamer v2 (2020): 이산 잠재 공간
• DreamerV3 (2023): 다양한 도메인에서 범용 적용

---

7. 다중 에이전트 강화학습

협력적/경쟁적 학습

class MultiAgentEnvironment:
    def step(self, actions):
        """
        모든 에이전트의 행동을 동시에 처리
        """
        next_states = []
        rewards = []

        for i, action in enumerate(actions):
            # 다른 에이전트의 행동도 영향
            next_state, reward = self.process_agent(i, action, actions)
            next_states.append(next_state)
            rewards.append(reward)

        return next_states, rewards


class IndependentLearner:
    """각 에이전트가 독립적으로 학습"""
    def __init__(self, num_agents, state_dim, action_dim):
        self.agents = [PPOAgent(state_dim, action_dim) for _ in range(num_agents)]

    def act(self, states):
        return [agent.act(state) for agent, state in zip(self.agents, states)]


class CentralizedCritic:
    """
    중앙 집중형 Critic, 분산 Actor (CTDE)
    학습 시: 글로벌 정보로 가치 평가
    실행 시: 로컬 정보만으로 행동
    """
    def __init__(self, num_agents, local_obs_dim, global_state_dim, action_dim):
        self.actors = [Actor(local_obs_dim, action_dim) for _ in range(num_agents)]
        self.critic = Critic(global_state_dim)  # 전체 상태 접근

---

8. 핵심 라이브러리 및 도구

2025년 추천 스택

CleanRL 예시

# CleanRL로 PPO 실행 (단일 파일, 이해하기 쉬움)
python cleanrl/ppo.py --env-id CartPole-v1 --total-timesteps 100000

Stable-Baselines3 예시

from stable_baselines3 import PPO, SAC, TD3
from stable_baselines3.common.env_util import make_vec_env

# 병렬 환경
env = make_vec_env("Pendulum-v1", n_envs=4)

# 연속 행동용 알고리즘
model = SAC("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=100000)

---

9. 미래 전망

단기 (2025-2026)

1. 추론 모델 발전: o1/R1 계열 확산
2. RLVR 확대: 더 많은 검증 가능한 태스크
3. 로보틱스 Foundation Model: VLA 모델 상용화

중기 (2027-2030)

1. 범용 에이전트: 다양한 태스크를 하나의 정책으로
2. 안전한 RL: 보장 가능한 안전 제약
3. 실세계 적용 확대: 자율주행, 의료 등

연구 방향

• 샘플 효율성: 더 적은 데이터로 학습
• 일반화: 새로운 환경에 적응
• 안전성: 제약 조건 하 최적화
• 설명 가능성: RL 에이전트의 행동 해석

---

10. 학습 로드맵 요약

기초
├── Q-Learning, SARSA
└── DQN, Double DQN, Dueling DQN

Policy 기반
├── REINFORCE, Actor-Critic
├── A2C/A3C
└── PPO (가장 중요)

Model 기반
├── MCTS
├── AlphaGo/AlphaZero
└── MuZero

LLM 적용
├── RLHF
├── DPO
└── RLVR, GRPO

최신
├── Decision Transformer
├── Offline RL
├── World Models
└── Multi-Agent RL

참고 자료:

• The State of Reinforcement Learning in 2025 - DataRoot Labs
• Reinforcement Learning Meets LLMs - arXiv
• MiniZero: AlphaZero and MuZero Analysis
• RLHF 101 - CMU ML Blog