REINFORCE

작성자

익명

작성일

2026.08.17

조회수

버전

일반 문서

REINFORCE (Monte Carlo Policy Gradient)

개요

REINFORCE는 강화학습의 정책 경사(Policy Gradient) 방법론 중 가장 기본적인 알고리즘으로, 가치 함수(Value Function)를 추정하지 않고 정책 파라미터를 직접 최적화하여 기대 보상을 최대화하는 몬테카를로(Monte Carlo) 방식의 알고리즘이다.

강화학습은 크게 가치 기반(Value-based), 정책 기반(Policy-based), 그리고 이 둘을 결합한 Actor-Critic 방식으로 나뉜다. REINFORCE는 대표적인 정책 기반 방법론으로, 상태 $s$에서 행동 $a$를 취할 확률인 정책 $\pi_\theta(a|s)$를 신경망으로 모델링하고, 에피소드가 종료된 후 얻은 전체 보상을 바탕으로 확률 분포를 업데이트한다.

작동 원리 및 수학적 배경

정책 경사 정리 (Policy Gradient Theorem)

REINFORCE의 핵심 목적은 에피소드 전체에서 얻는 누적 보상의 기대값 $J(\theta)$를 최대화하는 파라미터 $\theta$를 찾는 것이다. 이를 위해 목적 함수 $J(\theta)$의 기울기(Gradient)를 계산하여 경사 상승법(Gradient Ascent)으로 업데이트를 수행한다.

정책 경사 정리에 따라 목적 함수의 기울기는 다음과 같이 정의된다. $$\nabla_\theta J(\theta) = \mathbb{E}_{\pi} [ \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) G_t ]$$

여기서 각 용어의 의미는 다음과 같다. - $\pi_\theta(a|s)$: 파라미터 $\theta$에 의해 결정되는 상태 $s$에서 행동 $a$를 선택할 확률 (정책) - $\log \pi_\theta(a|s)$: 확률 값에 로그를 취한 것으로, 계산의 편의성과 수치적 안정성을 위해 사용된다. - $G_t$: 시점 $t$ 이후부터 에피소드 종료 시점까지 얻은 누적 보상의 합, 즉 리턴(Return)을 의미한다. ($G_t = \sum_{k=t}^{T-1} \gamma^{k-t} r_{k+1}$)

업데이트 원리

REINFORCE는 "상대적으로 더 높은 보상을 가져온 행동의 선택 확률을 높인다"는 원리를 따른다. - $G_t$가 평균적인 보상보다 크거나 상대적으로 높은 값을 가질 경우: $\nabla_\theta \log \pi_\theta(a_t|s_t)$ 방향으로 $\theta$를 업데이트하여 해당 행동의 발생 확률을 높인다. - $G_t$가 상대적으로 낮은 값을 가질 경우: 업데이트 강도가 약해지거나, 베이스라인 도입 시 확률이 낮아지는 방향으로 작동한다.

단순히 $G_t$의 부호만으로 판단할 경우, 모든 보상이 양수인 환경(예: CartPole)에서는 모든 행동의 확률이 일괄적으로 상승하는 문제가 발생할 수 있다. 따라서 실제로는 보상의 상대적인 크기가 업데이트의 강도를 결정하게 된다.

알고리즘 프로세스

REINFORCE는 에피소드가 완전히 종료되어야만 리턴 $G_t$를 계산할 수 있는 몬테카를로(Monte Carlo) 방식을 사용한다. 따라서 매 스텝 업데이트하는 것이 아니라, 하나의 에피소드가 끝난 후 일괄적으로 업데이트를 수행한다.

단계별 워크플로우

에피소드 생성: 현재 정책 $\pi_\theta$를 사용하여 시작 상태부터 종료 상태까지 행동을 취하며 궤적(Trajectory) $\tau = (s_0, a_0, r_1, s_1, a_1, r_2, \dots, s_{T-1}, a_{T-1}, r_T)$을 생성한다.
리턴 계산: 감쇠 요인 $\gamma$를 적용하여 시점 $t$ 이후의 보상 합계인 $G_t = \sum_{k=t}^{T-1} \gamma^{k-t} r_{k+1}$를 계산한다.
경사 계산: 각 시점의 $\nabla_\theta \log \pi_\theta(a_t|s_t) G_t$를 계산한다.
파라미터 업데이트: 계산된 기울기의 합을 이용하여 $\theta$를 업데이트한다. $$\theta \leftarrow \theta + \alpha \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) G_t$$

알고리즘 요약 표

항목	내용	비고
입력값	상태 $s$, 행동 $a$, 보상 $r$	에피소드 전체 궤적
출력값	행동 확률 분포 $\pi_\theta(a \vert s)$	신경망의 Softmax 출력
업데이트 시점	에피소드 종료 후 (Episode-end)	Monte Carlo 방식
업데이트 규칙	$\theta \leftarrow \theta + \alpha \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t \vert s_t) G_t$	보상에 비례한 확률 조정

구현 예시

다음은 PyTorch를 사용하여 CartPole 환경에서 REINFORCE 알고리즘을 구현할 때의 핵심 구조이다.

정책 네트워크 정의

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

class PolicyNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(PolicyNetwork, self).__init__()
        self.fc = nn.Linear(state_dim, 128)
        self.out = nn.Linear(128, action_dim)

    def forward(self, x):
        x = F.relu(self.fc(x))
        return F.softmax(self.out(x), dim=-1)

학습 루프 및 손실 함수

def compute_returns(rewards, gamma):
    """리스트를 입력받아 역순으로 누적 보상(G_t)을 계산하는 헬퍼 함수"""
    returns = []
    R = 0
    for r in reversed(rewards):
        R = r + gamma * R
        returns.insert(0, R)
    return returns

# 하이퍼파라미터 및 초기화
gamma = 0.99
optimizer = torch.optim.Adam(policy_net.parameters(), lr=1e-2)

# 학습 루프
for episode in range(num_episodes):
    state = env.reset()
    log_probs = []
    rewards = []
    done = False
    
    # 1. 에피소드 수행 (Trajectory 생성)
    while not done:
        state_tensor = torch.from_numpy(state).float().unsqueeze(0)
        probs = policy_net(state_tensor)
        
        m = torch.distributions.Categorical(probs)
        action = m.sample()
        
        log_probs.append(m.log_prob(action))
        
        state, reward, done, _ = env.step(action.item())
        rewards.append(reward)

    # 2. 리턴 G_t 계산 및 업데이트
    discounted_rewards = compute_returns(rewards, gamma)
    
    # 분산 감소를 위한 정규화 (간이 베이스라인 역할)
    discounted_rewards = np.array(discounted_rewards)
    discounted_rewards = (discounted_rewards - np.mean(discounted_rewards)) / (np.std(discounted_rewards) + 1e-8)
    
    policy_loss = []
    for log_prob, Gt in zip(log_probs, discounted_rewards):
        # Loss = -log(prob) * Gt (G_t가 클수록 loss를 낮추어 확률을 높임)
        policy_loss.append(-log_prob * Gt)

    optimizer.zero_grad()
    sum(policy_loss).backward()
    optimizer.step()

장점과 한계점

장점

모델 프리(Model-free): 환경의 전이 확률(Transition Probability)을 알 필요 없이 샘플링만으로 학습이 가능하다.
연속적 행동 공간 처리: 가치 기반 방식(Q-Learning 등)과 달리, 확률 분포를 직접 출력하므로 연속적인 행동 공간(Continuous Action Space)으로의 확장이 용이하다.
수렴성: 적절한 학습률을 사용할 경우, 지역 최적점(Local Optima)으로의 수렴이 이론적으로 보장된다.

한계점

높은 분산(High Variance): 몬테카를로 방식의 특성상, 에피소드마다 보상이 크게 달라질 수 있다. 특히 에피소드 길이가 길수록 $G_t$의 변동성이 누적되어 기울기 추정치의 분산이 매우 커지며, 이는 학습의 불안정성과 느린 수렴 속도로 이어진다.
데이터 효율성 저하: 한 번의 업데이트를 위해 전체 에피소드를 수행해야 하며, 사용한 궤적 데이터는 업데이트 후 버려지는 On-policy 방식이므로 샘플 효율성이 낮다.
지연된 보상 문제: 에피소드 끝에서만 보상이 주어지는 경우, 어떤 행동이 결정적인 영향을 주었는지 판단하기 어렵다(Credit Assignment Problem).

발전 방향 및 관련 알고리즘

REINFORCE의 치명적인 단점인 높은 분산을 해결하기 위해 다음과 같은 기법과 알고리즘들이 등장하였다.

베이스라인(Baseline) 도입을 통한 분산 감소

리턴 $G_t$에서 상태 가치 함수 $V(s)$와 같은 기준점(Baseline)을 빼주어 $\nabla_\theta \log \pi_\theta(a|s) (G_t - b(s))$ 형태로 업데이트한다. - 원리: $G_t$의 절대적인 값 대신, 기대했던 보상($b(s)$)보다 얼마나 더 좋았는지를 나타내는 어드밴티지(Advantage) 개념을 사용한다. - 효과: 기대값(Expectation)은 유지하면서 $G_t$의 변동폭을 줄여 분산을 획기적으로 감소시킨다.

관련 알고리즘

Actor-Critic: 정책을 결정하는 Actor와 상태 가치를 평가하는 Critic을 동시에 학습시킨다. 몬테카를로 방식 대신 TD(Temporal Difference) 학습을 도입하여 에피소드가 끝나기 전에도 매 스텝 업데이트가 가능하게 하여 학습 속도를 높였다.
PPO (Proximal Policy Optimization): 정책 업데이트 시 파라미터가 너무 급격하게 변하는 것을 방지하기 위해 Clipping 기법을 도입한 알고리즘으로, 현재 가장 널리 쓰이는 정책 경사 기반 알고리즘 중 하나이다.

📝 마크다운 원본

이 문서의 마크다운 원본 내용입니다.

# REINFORCE (Monte Carlo Policy Gradient)

## 개요
**REINFORCE**는 강화학습의 정책 경사(Policy Gradient) 방법론 중 가장 기본적인 알고리즘으로, 가치 함수(Value Function)를 추정하지 않고 정책 파라미터를 직접 최적화하여 기대 보상을 최대화하는 몬테카를로(Monte Carlo) 방식의 알고리즘이다.

강화학습은 크게 가치 기반(Value-based), 정책 기반(Policy-based), 그리고 이 둘을 결합한 Actor-Critic 방식으로 나뉜다. REINFORCE는 대표적인 정책 기반 방법론으로, 상태 $s$에서 행동 $a$를 취할 확률인 정책 $\pi_\theta(a|s)$를 신경망으로 모델링하고, 에피소드가 종료된 후 얻은 전체 보상을 바탕으로 확률 분포를 업데이트한다.

## 작동 원리 및 수학적 배경

### 정책 경사 정리 (Policy Gradient Theorem)
REINFORCE의 핵심 목적은 에피소드 전체에서 얻는 누적 보상의 기대값 $J(\theta)$를 최대화하는 파라미터 $\theta$를 찾는 것이다. 이를 위해 목적 함수 $J(\theta)$의 기울기(Gradient)를 계산하여 경사 상승법(Gradient Ascent)으로 업데이트를 수행한다.

정책 경사 정리에 따라 목적 함수의 기울기는 다음과 같이 정의된다.
$$\nabla_\theta J(\theta) = \mathbb{E}_{\pi} [ \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) G_t ]$$

여기서 각 용어의 의미는 다음과 같다.
- $\pi_\theta(a|s)$: 파라미터 $\theta$에 의해 결정되는 상태 $s$에서 행동 $a$를 선택할 확률 (정책)
- $\log \pi_\theta(a|s)$: 확률 값에 로그를 취한 것으로, 계산의 편의성과 수치적 안정성을 위해 사용된다.
- $G_t$: 시점 $t$ 이후부터 에피소드 종료 시점까지 얻은 누적 보상의 합, 즉 **리턴(Return)**을 의미한다. ($G_t = \sum_{k=t}^{T-1} \gamma^{k-t} r_{k+1}$)

### 업데이트 원리
REINFORCE는 **"상대적으로 더 높은 보상을 가져온 행동의 선택 확률을 높인다"**는 원리를 따른다.
- $G_t$가 평균적인 보상보다 크거나 상대적으로 높은 값을 가질 경우: $\nabla_\theta \log \pi_\theta(a_t|s_t)$ 방향으로 $\theta$를 업데이트하여 해당 행동의 발생 확률을 높인다.
- $G_t$가 상대적으로 낮은 값을 가질 경우: 업데이트 강도가 약해지거나, 베이스라인 도입 시 확률이 낮아지는 방향으로 작동한다.

단순히 $G_t$의 부호만으로 판단할 경우, 모든 보상이 양수인 환경(예: CartPole)에서는 모든 행동의 확률이 일괄적으로 상승하는 문제가 발생할 수 있다. 따라서 실제로는 보상의 상대적인 크기가 업데이트의 강도를 결정하게 된다.

## 알고리즘 프로세스

REINFORCE는 에피소드가 완전히 종료되어야만 리턴 $G_t$를 계산할 수 있는 **몬테카를로(Monte Carlo)** 방식을 사용한다. 따라서 매 스텝 업데이트하는 것이 아니라, 하나의 에피소드가 끝난 후 일괄적으로 업데이트를 수행한다.

### 단계별 워크플로우
1. **에피소드 생성**: 현재 정책 $\pi_\theta$를 사용하여 시작 상태부터 종료 상태까지 행동을 취하며 궤적(Trajectory) $\tau = (s_0, a_0, r_1, s_1, a_1, r_2, \dots, s_{T-1}, a_{T-1}, r_T)$을 생성한다.
2. **리턴 계산**: 감쇠 요인 $\gamma$를 적용하여 시점 $t$ 이후의 보상 합계인 $G_t = \sum_{k=t}^{T-1} \gamma^{k-t} r_{k+1}$를 계산한다.
3. **경사 계산**: 각 시점의 $\nabla_\theta \log \pi_\theta(a_t|s_t) G_t$를 계산한다.
4. **파라미터 업데이트**: 계산된 기울기의 합을 이용하여 $\theta$를 업데이트한다.
   $$\theta \leftarrow \theta + \alpha \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) G_t$$

### 알고리즘 요약 표
| 항목 | 내용 | 비고 |
| :--- | :--- | :--- |
| **입력값** | 상태 $s$, 행동 $a$, 보상 $r$ | 에피소드 전체 궤적 |
| **출력값** | 행동 확률 분포 $\pi_\theta(a \vert s)$ | 신경망의 Softmax 출력 |
| **업데이트 시점** | 에피소드 종료 후 (Episode-end) | Monte Carlo 방식 |
| **업데이트 규칙** | $\theta \leftarrow \theta + \alpha \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t \vert s_t) G_t$ | 보상에 비례한 확률 조정 |

## 구현 예시

다음은 PyTorch를 사용하여 `CartPole` 환경에서 REINFORCE 알고리즘을 구현할 때의 핵심 구조이다.

### 정책 네트워크 정의
```python
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

class PolicyNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(PolicyNetwork, self).__init__()
        self.fc = nn.Linear(state_dim, 128)
        self.out = nn.Linear(128, action_dim)

    def forward(self, x):
        x = F.relu(self.fc(x))
        return F.softmax(self.out(x), dim=-1)
```

### 학습 루프 및 손실 함수
```python
def compute_returns(rewards, gamma):
    """리스트를 입력받아 역순으로 누적 보상(G_t)을 계산하는 헬퍼 함수"""
    returns = []
    R = 0
    for r in reversed(rewards):
        R = r + gamma * R
        returns.insert(0, R)
    return returns

# 하이퍼파라미터 및 초기화
gamma = 0.99
optimizer = torch.optim.Adam(policy_net.parameters(), lr=1e-2)

# 학습 루프
for episode in range(num_episodes):
    state = env.reset()
    log_probs = []
    rewards = []
    done = False
    
    # 1. 에피소드 수행 (Trajectory 생성)
    while not done:
        state_tensor = torch.from_numpy(state).float().unsqueeze(0)
        probs = policy_net(state_tensor)
        
        m = torch.distributions.Categorical(probs)
        action = m.sample()
        
        log_probs.append(m.log_prob(action))
        
        state, reward, done, _ = env.step(action.item())
        rewards.append(reward)

    # 2. 리턴 G_t 계산 및 업데이트
    discounted_rewards = compute_returns(rewards, gamma)
    
    # 분산 감소를 위한 정규화 (간이 베이스라인 역할)
    discounted_rewards = np.array(discounted_rewards)
    discounted_rewards = (discounted_rewards - np.mean(discounted_rewards)) / (np.std(discounted_rewards) + 1e-8)
    
    policy_loss = []
    for log_prob, Gt in zip(log_probs, discounted_rewards):
        # Loss = -log(prob) * Gt (G_t가 클수록 loss를 낮추어 확률을 높임)
        policy_loss.append(-log_prob * Gt)

    optimizer.zero_grad()
    sum(policy_loss).backward()
    optimizer.step()
```

## 장점과 한계점

### 장점
- **모델 프리(Model-free)**: 환경의 전이 확률(Transition Probability)을 알 필요 없이 샘플링만으로 학습이 가능하다.
- **연속적 행동 공간 처리**: 가치 기반 방식(Q-Learning 등)과 달리, 확률 분포를 직접 출력하므로 연속적인 행동 공간(Continuous Action Space)으로의 확장이 용이하다.
- **수렴성**: 적절한 학습률을 사용할 경우, 지역 최적점(Local Optima)으로의 수렴이 이론적으로 보장된다.

### 한계점
- **높은 분산(High Variance)**: 몬테카를로 방식의 특성상, 에피소드마다 보상이 크게 달라질 수 있다. 특히 에피소드 길이가 길수록 $G_t$의 변동성이 누적되어 기울기 추정치의 분산이 매우 커지며, 이는 학습의 불안정성과 느린 수렴 속도로 이어진다.
- **데이터 효율성 저하**: 한 번의 업데이트를 위해 전체 에피소드를 수행해야 하며, 사용한 궤적 데이터는 업데이트 후 버려지는 On-policy 방식이므로 샘플 효율성이 낮다.
- **지연된 보상 문제**: 에피소드 끝에서만 보상이 주어지는 경우, 어떤 행동이 결정적인 영향을 주었는지 판단하기 어렵다(Credit Assignment Problem).

## 발전 방향 및 관련 알고리즘

REINFORCE의 치명적인 단점인 **높은 분산**을 해결하기 위해 다음과 같은 기법과 알고리즘들이 등장하였다.

### 베이스라인(Baseline) 도입을 통한 분산 감소
리턴 $G_t$에서 상태 가치 함수 $V(s)$와 같은 기준점(Baseline)을 빼주어 $\nabla_\theta \log \pi_\theta(a|s) (G_t - b(s))$ 형태로 업데이트한다. 
- **원리**: $G_t$의 절대적인 값 대신, 기대했던 보상($b(s)$)보다 얼마나 더 좋았는지를 나타내는 **어드밴티지(Advantage)** 개념을 사용한다.
- **효과**: 기대값(Expectation)은 유지하면서 $G_t$의 변동폭을 줄여 분산을 획기적으로 감소시킨다.

### 관련 알고리즘
1. **Actor-Critic**: 정책을 결정하는 **Actor**와 상태 가치를 평가하는 **Critic**을 동시에 학습시킨다. 몬테카를로 방식 대신 TD(Temporal Difference) 학습을 도입하여 에피소드가 끝나기 전에도 매 스텝 업데이트가 가능하게 하여 학습 속도를 높였다.
2. **PPO (Proximal Policy Optimization)**: 정책 업데이트 시 파라미터가 너무 급격하게 변하는 것을 방지하기 위해 Clipping 기법을 도입한 알고리즘으로, 현재 가장 널리 쓰이는 정책 경사 기반 알고리즘 중 하나이다.

AI 생성 콘텐츠 안내

이 문서는 AI 모델(gemma-4-31b)에 의해 생성된 콘텐츠입니다.

주의사항: AI가 생성한 내용은 부정확하거나 편향된 정보를 포함할 수 있습니다. 중요한 결정을 내리기 전에 반드시 신뢰할 수 있는 출처를 통해 정보를 확인하시기 바랍니다.

위키너와나