dev-self 님의 블로그

패스트캠퍼스 환급챌린지 56일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Tue, 29 Apr 2025 01:28:54 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<n-step TD 알고리즘 디버깅 분석>

1. 핵심 수식과 실제 데이터 연관성

n-step 리턴 수식

디버깅 결과에서 이 수식이 실제로 어떻게 작용하는지 확인할 수 있다:

n=1 (TD(0)): 초기 상태의 최종 가치 = 0.473
n=3: 초기 상태의 최종 가치 = 0.704
n=5: 초기 상태의 최종 가치 = 0.750

n이 클수록 가치 함수 값이 높게 나타나는 것은 더 멀리 있는 보상 신호를 직접 고려하기 때문이다. 특히 그래프에서 n=5(파란색)와 n=3(초록색)의 학습 곡선이 n=1(빨간색)보다 훨씬 빠르게 상승하는 현상을 통해 이를 확인할 수 있다.

가치 함수 업데이트 수식

디버깅 출력에서 학습률(α)이 점진적으로 감소하는 것을 볼 수 있다:

alpha: 0.0020
alpha: 0.0016
alpha: 0.0013
alpha: 0.0011
alpha: 0.0010
alpha: 0.0009
alpha: 0.0008

이는 학습률 감소 수식이 작동한 결과이다. 학습률 감소로 인해 그래프에서 모든 n값의 경우 후반부에 학습 곡선이 안정화되는 현상을 확인할 수 있다.

2. n값에 따른 학습 특성 비교

학습 속도

디버깅 결과에서 각 n값에 따른 동일 반복 횟수에서의 가치 함수를 비교해보면:

n=1의 경우 1000번 반복 후에도 가치가 0.473에 그치지만, n=5는 약 50번 반복만에 0.7 이상에 도달한다. 이는 n-step 리턴 수식에서 n이 클수록 더 많은 미래 보상을 직접 고려하기 때문이다. 그래프에서도 초기 상승 속도가 n=5 > n=3 > n=1 순서로 명확하게 나타난다.

안정성과 변동성

그래프에서 n=5(파란색)는 초기에 큰 변동성을 보이며, 심지어 0.8 이상까지 급상승했다가 다시 하락하는 패턴을 보인다. 반면 n=1(빨간색)은 매우 안정적인 곡선을 그린다. 이는 n-step 리턴 수식에서 n이 클수록 더 많은 실제 보상 항 을 포함하고 부트스트래핑 항 의 비중이 줄어들기 때문이다. 실제 보상은 에피소드마다 달라질 수 있어 변동성이 크다. 디버깅 출력의 value_vector 값들도 반복에 따라 n=5가 n=1보다 더 큰 변화를 보인다.

최종 수렴 값

디버깅 결과에서 4x4 그리드의 각 위치별 최종 가치 함수 값을 볼 수 있다:

n=1의 value_table:

[ 0.032  0.061  0.123  0.197]
[ 0.067  0.161  0.396  0.720]
[ 0.151  0.446  1.319  2.894]
[ 0.270  0.932  3.355  0.000]]

n=5의 value_table:

[ 0.546  0.677  0.929  1.134]
[ 0.673  0.919  1.438  1.975]
[ 0.866  1.337  2.523  4.247]
[ 1.066  1.849  4.153  0.000]]

n=5의 경우가 전반적으로 더 높은 가치 함수 값을 보여주며, 특히 목표에서 멀리 떨어진 초기 상태에서 큰 차이가 난다. 이는 n이 클수록 먼 미래의 보상이 현재 상태 가치에 더 직접적으로 반영되기 때문이다.

3. k_min을 통한 에피소드 끝 처리의 영향

에피소드 끝 처리를 위한 k_min 수식:

디버깅 결과에서는 직접적으로 보이지 않지만, n=5의 경우 에피소드 끝에 가까운 상태들은 실제로 5스텝보다 적은 스텝으로 업데이트된다. 이로 인해 목표에 가까운 상태들의 가치가 더 정확하게 계산되며, 그래프에서 n=5가 초기 변동 후 안정적으로 수렴하는 데 기여한다.

4. 편향-분산 트레이드오프

n값이 학습에 미치는 영향은 편향(bias)과 분산(variance)의 트레이드오프로 설명된다:

n=1: 낮은 분산(안정적 학습)이지만 높은 편향(느린 수렴)
n=5: 낮은 편향(빠른 정보 전파)이지만 높은 분산(불안정한 학습)

그래프에서 n=1은 변동 없이 천천히 상승하는 반면, n=5는 큰 변동성과 함께 빠르게 상승한다. 이는 수식에서 예측한 특성과 정확히 일치한다. 또한 디버깅 결과의 value_vector 값들을 보면, n=1은 점진적으로 변화하지만 n=5는 더 급격한 변화를 보이는 것을 확인할 수 있다.

결론

n-step TD 알고리즘의 수식과 디버깅 결과를 종합적으로 분석한 결과, n값 선택이 학습 특성에 미치는 영향을 명확히 확인할 수 있다:

n이 클수록:
- 학습 속도가 빨라짐 (그래프의 초기 급상승)
- 변동성이 커짐 (그래프의 불규칙한 패턴)
- 최종 가치 함수 값이 높아짐 (디버깅 출력의 value_table)
- 편향은 감소하지만 분산이 증가 (그래프의 학습 패턴)
학습률 감소 전략은 모든 n값에서 후반부 안정적 수렴에 기여 (디버깅 출력의 alpha 감소)
k_min을 통한 에피소드 끝 처리는 n이 클수록 더 많은 상태에 영향을 미침

이러한 분석은 실제 강화학습 시스템 설계 시 문제의 특성과 요구사항에 맞는 최적의 n값을 선택하는 데 도움이 된다. 빠른 학습이 중요하다면 큰 n값을, 안정적인 학습이 중요하다면 작은 n값을 선택하는 것이 적절할 것이다.

n-step TD 알고리즘에서 n값에 따른 특성을 비교한 시각적 다이어그램을 만들었다. 이 다이어그램은 n=1, n=3, n=5 각각의 특성을 명확하게 보여준다.

n값에 따른 특성 비교

n=1 (TD(0))

수식: G_t^(1) = R_{t+1} + γV(S_{t+1})
학습 속도: 느림 (V(0,0) = 0.473, 1000회 반복 후)
안정성: 매우 안정적, 부드러운 학습 곡선
편향-분산: 높은 편향, 낮은 분산
특징: 부트스트래핑 의존도가 높음

n=3 (중간값)

수식: G_t^(3) = R_{t+1} + γR_{t+2} + γ²R_{t+3} + γ³V(S_{t+3})
학습 속도: 중간 (V(0,0) = 0.704)
안정성: 적당히 안정적, 약간의 변동성
편향-분산: 균형된 편향과 분산
특징: TD(0)와 몬테카를로 방식의 좋은 절충점

n=5 (몬테카를로에 가까움)

수식: G_t^(5) = R_{t+1} + ... + γ^4R_{t+5} + γ^5V(S_{t+5})
학습 속도: 빠름 (V(0,0) = 0.750)
안정성: 초기 불안정, 큰 변동성
편향-분산: 낮은 편향, 높은 분산
특징: 더 많은 실제 보상을 고려하여 정보 전파가 빠름

학습 곡선 특성

다이어그램 하단의 그래프는 각 n값에 따른 학습 곡선의 특성을 보여준다:

n=1 (빨간색): 부드럽게 천천히 상승하는 곡선
n=3 (초록색): 빠르게 상승 후 안정적으로 유지
n=5 (파란색): 매우 빠르게 상승하나 큰 변동성을 보임

이 시각화를 통해 n값에 따른 학습 특성의 차이를 한눈에 볼 수 있다. n값 선택은 빠른 학습과 안정성 사이의 트레이드오프를 고려해야 하며, 문제의 특성에 맞게 적절한 n값을 선택하는 것이 중요하다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 55일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Mon, 28 Apr 2025 16:10:30 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<n-step TD 강화학습 알고리즘 코드 구조 및 실행 흐름>

코드구조도

환경(Environment) 개요

우선 environment.py는 4x4 그리드 환경을 정의한다:

에이전트는 (0,0)에서 시작하여 (3,3)의 목표 위치에 도달해야 한다.
상태 공간은 4x4 그리드로 표현된다.
행동 공간은 {0: 위, 1: 오른쪽, 2: 아래, 3: 왼쪽}이다.
목표에 도달하면 보상 10을 받는다.

n-step TD 학습 알고리즘 핵심 코드

여기서는 두 가지 버전의 n-step TD가 구현되어 있다:

n_step_td_prediction.py: 일반적인 n-step TD 예측
episodic_n_step_td_prediction.py: 에피소드 기반 n-step TD 예측

핵심 알고리즘 부분

Return 계산 함수:

def calc_return(gamma, rewards):
    n = len(rewards)
    rewards = np.array(rewards)
    gammas = gamma * np.ones([n])
    powers = np.arange(n)
    
    power_of_gammas = np.power(gammas, powers)
    discounted_rewards = rewards * power_of_gammas  # [r, gamma * r, gamma^2 * r, ... ]
    g = np.sum(discounted_rewards)

    return g

이 함수는 n-step 리턴(G_t^(n))을 계산한다. 수식으로 표현하면:

n-step TD 업데이트 핵심 부분:

discounted_rewards = calc_return(gamma, trajectory['rewards'])
td = discounted_rewards + (gamma ** n) * value_vector[i_s_t] - value_vector[i_s_t_sub_n]
value_vector[i_s_t_sub_n] = value_vector[i_s_t_sub_n] + alpha * td

이 코드는 n-step TD 업데이트 규칙을 구현한다. 수식으로 표현하면:

여기서:

는 상태 의 현재 가치 추정값
는 학습률
은 n-step 리턴(아래수식):

알고리즘 실행 흐름도

일반 n-step TD와 에피소드 n-step TD의 차이점

일반 n-step TD:
- 경로(trajectory)를 따라가며 n-step 단위로 업데이트
- 종료 상태에서는 추가 처리를 통해 남은 상태들을 업데이트
에피소드 n-step TD:
- 전체 에피소드를 생성한 후에 각 상태를 업데이트
- 아래 코드가 핵심:

for t in range(step_count):
    alpha = alpha_init / (1 + k_alpha * loop_count)
    k_min = min(n, step_count - t)

    s_t = episode['states'][t]
    i_s_t = get_state_index(env.state_space, s_t)
    s_t_k = episode['states'][t + k_min]
    i_s_t_k = get_state_index(env.state_space, s_t_k)
    discounted_rewards = calc_return(gamma, episode['rewards'][t:t + k_min])
    td = discounted_rewards + (gamma ** k_min) * value_vector[i_s_t_k] - value_vector[i_s_t]
    value_vector[i_s_t] = value_vector[i_s_t] + alpha * td

에피소드 끝에 가까울 때는 남은 스텝 수만큼만 고려

학습률 감소 전략

코드에서는 학습률을 점진적으로 감소시키는 방식을 사용한다:

일반 n-step TD (n_step_td_prediction.py):

# 루프 내에서 학습률 감소
alpha = alpha_init / (1 + k_alpha * loop_count)

에피소드 n-step TD (episodic_n_step_td_prediction.py):

for t in range(step_count):
    alpha = alpha_init / (1 + k_alpha * loop_count)
    # ... 나머지 코드

이 코드는 학습률을 반복 횟수(loop_count)에 따라 점진적으로 감소시키는 전략을 구현한다. 수식으로 표현하면:

= 0.2 (초기 학습률)
= 0.25 (학습률 감소 계수)
는 반복 횟수

이 방식은 초기에는 큰 학습률로 빠르게 학습하다가, 반복 횟수가 증가함에 따라 학습률을 점진적으로 줄여 안정적인 수렴을 돕는 전략이다. 이렇게 학습률을 감소시키는 것은 강화학습에서 흔히 사용되는 기법으로, 초기에는 큰 변화를 허용하고 후반부에는 미세 조정을 가능하게 한다.

실제 변수 할당을 통한 코드 실행 과정

환경 설정 및 경로

시뮬레이션에 사용한 경로는 다음과 같다:

시작 상태: (0,0)
행동 순서: 오른쪽 → 오른쪽 → 아래 → 아래 → 오른쪽 → 아래
목표 도달: (3,3)
최종 경로: (0,0) → (0,1) → (0,2) → (1,2) → (2,2) → (2,3) → (3,3)
보상: 목표 도달 시 +10, 나머지는 0
감가율(γ): 0.9
학습률(α): 0.2

n=1 TD (일반 TD) 수행 과정

TD(0)라고도 하는 n=1 TD는 각 상태에서 한 스텝 앞만 보고 업데이트한다:

초기 상태 (t=0): 모든 상태의 가치 함수 V(s) = 0으로 초기화
각 스텝별 업데이트:
- 스텝 1 (0,0) → (0,1): 보상 0
  - TD 업데이트: V(0,0) = 0 + 0.2 × (0 + 0.9×0 - 0) = 0
- 스텝 2 (0,1) → (0,2): 보상 0
  - TD 업데이트: V(0,1) = 0 + 0.2 × (0 + 0.9×0 - 0) = 0
- 스텝 3 (0,2) → (1,2): 보상 0
  - TD 업데이트: V(0,2) = 0 + 0.2 × (0 + 0.9×0 - 0) = 0
- 스텝 4 (1,2) → (2,2): 보상 0
  - TD 업데이트: V(1,2) = 0 + 0.2 × (0 + 0.9×0 - 0) = 0
- 스텝 5 (2,2) → (2,3): 보상 0
  - TD 업데이트: V(2,2) = 0 + 0.2 × (0 + 0.9×0 - 0) = 0
- 스텝 6 (2,3) → (3,3): 보상 10
  - TD 업데이트: V(2,3) = 0 + 0.2 × (10 + 0.9×0 - 0) = 2.0
최종 가치 함수:
- V(2,3) = 2.0 (목표 직전 상태만 가치가 갱신됨)
- 다른 모든 상태 = 0

n=1 TD의 특징은 한 번의 에피소드에서 목표에 인접한 상태의 가치만 갱신되었다는 점이다. 정보가 한 스텝씩만 거슬러 올라가 전파되므로, 여러 에피소드를 통해 점진적으로 먼 상태들의 가치가 갱신된다.

n=3 TD 수행 과정

n=3 TD는 각 상태에서 세 스텝 앞까지 보고 업데이트한다:

초기 상태 (t=0): 모든 상태의 가치 함수 V(s) = 0으로 초기화
각 스텝별 업데이트:
- 스텝 1~3 (0,0 → 0,1 → 0,2 → 1,2):
  - 이 시점에서 첫 n=3 업데이트 수행
  - 3단계 리턴 계산: G = 0 + 0.9×0 + 0.9²×0 = 0
  - TD 업데이트: V(0,0) = 0 + 0.2 × (0 - 0) = 0
- 스텝 2~4 (0,1 → 0,2 → 1,2 → 2,2):
  - 3단계 리턴 계산: G = 0 + 0.9×0 + 0.9²×0 = 0
  - TD 업데이트: V(0,1) = 0 + 0.2 × (0 - 0) = 0
- 스텝 3~5 (0,2 → 1,2 → 2,2 → 2,3):
  - 3단계 리턴 계산: G = 0 + 0.9×0 + 0.9²×0 = 0
  - TD 업데이트: V(0,2) = 0 + 0.2 × (0 - 0) = 0
- 스텝 4~6 (1,2 → 2,2 → 2,3 → 3,3):
  - 3단계 리턴 계산: G = 0 + 0.9×0 + 0.9²×10 = 8.1
  - TD 업데이트: V(1,2) = 0 + 0.2 × (8.1 - 0) = 1.62
에피소드 종료 후 남은 상태 업데이트 (에피소드 끝 처리):
- k_min = min(3, 6-5) = 1 (상태 2,2의 경우)
  - 1단계 리턴 계산: G = 0 + 0.9×10 = 9.0
  - TD 업데이트: V(2,2) = 0 + 0.2 × (9.0 - 0) = 1.8
- k_min = min(3, 6-6) = 0 (상태 2,3의 경우)
  - 0단계 리턴 계산: G = 10
  - TD 업데이트: V(2,3) = 0 + 0.2 × (10 - 0) = 2.0
최종 가치 함수:
- V(1,2) = 1.62
- V(2,2) = 1.8
- V(2,3) = 2.0
- 다른 상태 = 0

n=3 TD의 특징은 한 번의 에피소드에서도 목표에서 더 멀리 떨어진 상태들의 가치가 갱신된다는 점이다. 이는 더 긴 시퀀스의 보상을 고려하기 때문이다.

특히 주목할 부분은:

가치 전파 범위: n=1에서는 목표와 인접한 상태만 가치가 업데이트되었지만, n=3에서는 목표에서 최대 3단계 떨어진 상태까지 가치가 전파됩니다. V(1,2)까지 값이 갱신된 것을 확인할 수 있다.
에피소드 끝 처리: n=3 방식에서는 에피소드 끝에 가까워지면 k_min = min(n, T-t) 방식으로 남은 단계만큼만 고려한다. 이로 인해 상태 (2,2)는 2단계 리턴으로, 상태 (2,3)은 1단계 리턴으로 업데이트되었다.
감가율 효과: 상태에서 목표까지 거리가 멀수록 감가율(γ)로 인해 가치가 낮아진다. 예를 들어:
- V(2,3) = 2.0 (목표에서 1단계 거리)
- V(2,2) = 1.8 (목표에서 2단계 거리)
- V(1,2) = 1.62 (목표에서 3단계 거리)

n값에 따른 비교 분석

n=1(TD(0))과 n=3의 비교를 통해 다음과 같은 차이점을 관찰할 수 있다:

정보 전파 속도:
- n=1: 한 번의 에피소드에서는 목표와 직접 연결된 상태만 업데이트
- n=3: 한 번의 에피소드로 목표에서 최대 3단계 떨어진 상태까지 업데이트
가치 추정 정확도:
- n=1: 더 작은 시야로 인해 먼 상태의 가치 추정이 부정확할 수 있음
- n=3: 더 긴 시퀀스를 보기 때문에 먼 상태의 가치를 더 정확하게 추정
학습 특성:
- n=1: 편향(bias)은 크지만 분산(variance)은 작음
- n=3: n=1보다 편향은 작지만 분산은 큼
- n이 클수록 몬테카를로 방식에 가까워짐
계산 복잡성:
- n=1: 간단한 계산 (다음 상태와 보상만 고려)
- n=3: 더 복잡한 계산 (여러 단계의 보상을 누적해서 계산)

실제 구현에서의 고려사항

실제 n-step TD 알고리즘 구현 시 다음 사항들을 고려해야 한다:

메모리 사용:
- n이 클수록 더 많은 전이(상태, 행동, 보상)를 메모리에 저장해야 함
- 에피소드 방식은 전체 에피소드를 메모리에 저장해야 함
학습률 감소 전략:
- 코드에서는 alpha = alpha_init / (1 + k_alpha * loop_count) 방식으로 학습률을 감소
- 이를 통해 초기에는 빠르게 학습하고 후반에는 안정적으로 수렴
에피소드 끝 처리:
- 에피소드가 끝날 때는 남은 상태들에 대해 k_min = min(n, T-t) 방식으로 업데이트
- 이를 통해 에피소드 끝에 가까운 상태들도 적절하게 업데이트됨
n값 선택:
- 문제의 특성에 따라 적절한 n값 선택이 중요
- n이 작을수록 편향이 크고, n이 클수록 분산이 커짐
- 실전에서는 여러 n값으로 실험하여 최적의 값 선택

결론

n-step TD 알고리즘은 n값을 조절함으로써 TD(0)와 몬테카를로 방법 사이의 균형점을 찾을 수 있는 유연한 방법이다. 시뮬레이션 결과를 통해 n=3이 n=1보다 한 번의 에피소드에서 더 많은 정보를 전파하고, 더 멀리 있는 상태의 가치를 더 정확하게 추정할 수 있음을 확인했다. 실제 강화학습 시스템을 구현할 때는 편향-분산 트레이드오프, 계산 복잡성, 메모리 요구사항 등을 고려하여 적절한 n값을 선택하는 것이 중요하다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 54일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Sun, 27 Apr 2025 01:10:36 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<다단계 가치 함수(Multi-step Value Function)와 축약 연산자(Contraction Operator)의 핵심 개념>

1. 가치 함수의 정의

이 수식은 n-step TD 업데이트 식과 직접적인 연관이 있다. 특히:

샘플 기반 기대값 추정()이 충분한 샘플 조건에서 실제 기대값()으로 표현된 것이다.
이것은 정책 π를 따랐을 때 상태 의 실제 가치를 n-step 반환값의 기대값으로 정의하고 있다.

2. 연산자 적용

이 표현은 연산자 개념을 직접 나타낸다:

연산자 가 어떤 가치 함수(, )에 적용되어 새로운 가치 함수로 변환되는 과정을 보여준다.
아래의 식과 연관된다.

3. 연산자 차이의 절댓값

이 수식은:

두 가치 함수 과 에 n-step 연산자 를 적용했을 때, 특정 상태 에서의 결과 차이를 절댓값으로 표현한다.
이 차이는 n 스텝 후의 상태에서 두 가치 함수의 차이에 대한 기대값에 비례한다(비례 상수 ).
중요한 점은 이 차이가 원래 가치 함수의 직접적인 차이가 아니라, n 스텝 후 도달하는 상태에서의 가치 차이에 의존한다는 것이다.

4. 수정된 연산자 차이 표현:

3번 수식을 더 발전시켜, 연산자 차이를 에 비례하는 형태로 표현한다.
여기서 은 할인 인자(보통 라고 표기)로, 1보다 작은 값이다.
오른쪽 부등식은 기대값이 최대값보다 항상 작거나 같다는 성질을 이용한 것이다.
이 수식은 연산자 적용 후의 차이가 원래 가치 함수 차이의 배 이하로 줄어든다는 것을 보여준다.

5. 무한대 노름을 이용한 바운드:

이 수식은:

두 가치 함수에 연산자를 적용한 결과의 차이를 모든 상태에 대한 최대값(무한대 노름)으로 측정한다.
이 최대 차이는 원래 가치 함수들의 최대 차이의 배 이하이다.
는 "모든 상태 중 최대 차이"를 의미하는 무한대 노름이다.
이므로, 연산자를 반복 적용할수록 가치 함수 간의 차이가 계속 줄어들게 된다.
이 성질이 바로 수축 매핑(contraction mapping)의 핵심 특성이다.

6. 축약 연산자의 성질:

5번 수식과 본질적으로 동일하지만, 다른 표기법(, 등)을 사용하여 더 일반적인 맥락에서 축약 연산자의 성질을 표현한다.
이는 n-step TD 연산자가 갖는 수축 성질이 더 일반적인 수학적 개념임을 강조한다.
이 성질은 반복 적용 시 항상 고정점으로 수렴함을 보장한다(수학적 고정점 정리의 기반)

7. 모순 발생

이 부분은 n이 무한대로 갈 때 발생할 수 있는 모순을 지적한다:

이미지 3에서 논의된 "n이 클수록 분산이 커진다"는 문제와 연관된다.
n이 무한대로 가면 수축 인자 이 0에 가까워져 이론적으로는 즉시 수렴해야 하지만, 실제로는 높은 분산으로 인해 안정적인 학습이 어려워진다.

이 수식들은 강화 학습에서의 가치 함수, 연산자, 그리고 그들의 수렴 성질을 다루고 있다. 특히, 축약 연산자(contraction operator)의 개념과 무한대 노름(infinity norm)을 사용한 분석이 포함되어 있다. 마지막 부분에서는 n→∞일 때 모순이 발생함을 보여주고 있다.

핵심 개념 설명

다단계 가치 함수(Multi-step Value Function)

다단계 가치 함수는 현재 상태에서 n 스텝 미래까지의 보상과 그 이후 상태의 가치를 고려한 확장된 가치 함수이다:

1-step: 한 단계 미래만 고려
n-step: n 단계 미래까지 고려
∞-step: 모든 미래를 고려(몬테카를로 방법)

다단계 가치 함수는 서로 다른 시간 규모의 보상 신호를 효과적으로 통합할 수 있다.

축약 연산자(Contraction Operator)

축약 연산자는 반복 적용 시 거리가 줄어드는 특성을 가진 연산자이다:

는 이러한 축약 연산자의 한 예이다.
이 연산자의 축약 속도는 으로, n이 클수록 더 빠르게 수축한다.
축약 연산자의 핵심 특성은 반복 적용 시 유일한 고정점으로 수렴한다는 것이다.

결론: 이론과 실제의 균형

이 모든 수식과 개념은 n-step TD 학습의 이론적 토대를 제공한다:

다단계 가치 함수는 단일 단계보다 풍부한 정보를 포함하여 학습 효율성을 높일 수 있다.
축약 연산자 특성은 n-step TD 학습이 이론적으로 정책의 실제 가치 함수로 수렴함을 보장한다.
n이 클수록 이론적 수렴 속도는 빨라지지만(이 작아짐), 실제로는 분산 증가로 인한 한계가 있다.
그래서 여러 n 값을 혼합하는 방법이 효과적인 해결책이 될 수 있다.

이러한 이론적 분석은 실제 n-step TD 알고리즘의 성능과 행동을 이해하고 최적화하는 데 중요한 통찰을 제공한다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 53일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Sat, 26 Apr 2025 15:03:56 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<n-step TD 학습 알고리즘 2>

n-step TD 업데이트 공식

- 기본 업데이트 (t ≥ n일 때)

V(s_{t-n}) = V(s_{t-n}) + α[∑_{k=1}^{n} γ^{k-1}r_{t-n+k} + γ^n V(s_t) - V(s_{t-n})]

이 공식은 다음과 같은 의미를 가진다:

V(s_{t-n}): n 스텝 이전 상태의 가치 함수를 업데이트
α: 학습률(learning rate)
대괄호 안의 표현식: TD 오차
- ∑_{k=1}^{n} γ^{k-1}r_{t-n+k}: n개의 할인된 보상 합계
- γ^n V(s_t): 현재 상태의 할인된 가치 추정값
- -V(s_{t-n}): 이전 상태의 가치 추정값

- 에피소드 종료 시 처리 (done일 때)

k_{min} = min(t, n-1)
for i ∈ 1 : k_{min}
    V(s_{t-i}) = V(s_{t-i}) + α[∑_{k=1}^{i} γ^{k-1}r_{t-i+k} + γ^n V(s_t) - V(s_{t-i})]
V(s_t) = 0  (종료 상태의 가치는 0)

이 부분은 에피소드가 종료되었을 때 남아있는 상태들의 가치를 업데이트하는 방법이다:

k_{min}: 업데이트할 수 있는 최대 스텝 수 결정 (t와 n-1 중 작은 값)
순환문을 통해 최근 k_{min}개의 상태 가치를 업데이트
마지막으로 종료 상태의 가치를 0으로 설정

에피소드 기반 n-step TD 알고리즘

- 완전한 에피소드(episode) 기반 n-step TD 알고리즘이다

Input a policy to be evaluated, π
Initialize α > 0 and V(s) for all s ∈ S
While True
    Generate an episode e = (s_0, a_0, r_1, s_1, ..., s_{T-1}, a_{T-1}, r_T, s_T) using π
    For t ∈ 0 : T-1
        k_{min} = min(n, T-t)
        δ_t^{k_{min}} = ∑_{k=1}^{k_{min}} γ^{k-1}r_{t+k} + γ^{k_{min}}V(s_{t+k_{min}}) - V(s_t)
        V(s_t) = V(s_t) + αδ_t^{k_{min}}

이 알고리즘의 주요 특징:

정책 π를 사용하여 완전한 에피소드를 생성
에피소드의 각 타임스텝 t에 대해:
- k_{min}: 현재 위치에서 가능한 최대 스텝 수 계산 (n과 남은 에피소드 길이 중 작은 값)
- δ_t^{k_{min}}: n-step TD 오차 계산
- 현재 상태의 가치 함수 업데이트

여기서의 접근 방식은 에피소드 전체를 생성한 후 처음부터 끝까지 한 번에 업데이트한다는 점이 이전 알고리즘과 다르다.

이미지 3: n-step TD의 확장 및 이점

세 번째 이미지는 n-step TD 학습의 확장과 이점에 대해 설명한다:

n-step TD에서 n이 크면 수렴 속도가 빠르다는 주장과 단점

있음, 학습동안 value 값이 더 많이 됨 (variance가 큼)
Sample이 많다면 이 문제가 완화됨 (큰 수의 법칙)

다양한 n을 함께 사용하는 방법

G_t^{(n)} = ∑_{k=1}^{n} γ^{k-1}r_{t+k} + γ^n V(s_{t+n})

이라 할 때, 예를 들면:

V(s_t) = Ê[0.3G_t^{(3)} + 0.3G_t^{(5)} + 0.4G_t^{(8)}]

여기서는 서로 다른 n 값(3, 5, 8)의 반환값을 가중 평균하는 방식을 보여준다:

3-step TD의 반환값에 0.3 가중치
5-step TD의 반환값에 0.3 가중치
8-step TD의 반환값에 0.4 가중치

이와 관련된 설명:

가능! 다음 chapter에서 일반적으로 많이 쓰는 방법을 배움
단, 섞어서 쓸 때 각 step에 대한 weight는 양수이며, 합이 1이 되어야 함

n-step TD 학습의 주요 특징 및 고려사항

n 값의 선택과 트레이드오프:
- n이 작을수록: 낮은 분산(variance)이지만 높은 편향(bias)
- n이 클수록: 낮은 편향이지만 높은 분산
- n=1: 일반적인 TD(0) 학습 (낮은 분산, 높은 편향)
- n=∞: 몬테카를로 방법 (높은 분산, 낮은 편향)
다양한 n 사용의 이점:
- 다양한 n 값의 추정치를 혼합하면 편향과 분산 사이의 더 나은 균형을 이룰 수 있음
- 예제에서 본 것처럼 3-step, 5-step, 8-step의 가중 평균을 사용
- 가중치의 합은 1이어야 하고, 모든 가중치는 양수여야 함
실용적 고려사항:
- 메모리 요구 사항: n이 클수록 더 많은 경험을 저장해야 함
- 계산 복잡성: n이 클수록 더 많은 계산이 필요함
- 샘플 효율성: n이 크면 샘플 효율성이 더 높을 수 있음
온라인 vs 오프라인 학습:
- 첫 번째 알고리즘: 온라인 학습 방식 (TD 오차를 즉시 계산하고 업데이트)
- 두 번째 알고리즘: 오프라인/에피소드 단위 학습 방식 (에피소드 완료 후 일괄 업데이트)

n-step TD 학습은 TD 학습과 몬테카를로 방법 사이의 중간 지점을 제공하며, 적절한 n 값 선택 또는 다양한 n 값의 혼합을 통해 학습 성능을 최적화할 수 있다.

그리드 월드로 보는 수식 정의

다음과 같은 4x4 그리드 월드를 가정한다:

+---+---+---+---+
| S | O | O | O |
+---+---+---+---+
| O | O | X | O |
+---+---+---+---+
| O | O | O | O |
+---+---+---+---+
| O | O | O | G |
+---+---+---+---+

여기서:

S: 시작 위치 (0,0)
G: 목표 위치 (3,3), 보상 +1
X: 장애물 (1,2), 진입 불가
O: 빈 공간, 보상 0

n-step TD 수식 적용 (n=3 예시)

1. 초기화

모든 상태 s에 대해 V(s) = 0으로 초기화
학습률 α = 0.1
할인율 γ = 0.9

2. 에피소드 생성

예를 들어, 다음과 같은 에피소드가 생성되었다고 가정합니다:

s₀ = (0,0), a₀ = 오른쪽, r₁ = 0, s₁ = (0,1)
s₁ = (0,1), a₁ = 아래쪽, r₂ = 0, s₂ = (1,1)
s₂ = (1,1), a₂ = 오른쪽, r₃ = 0, s₃ = (1,3) (장애물 우회)
s₃ = (1,3), a₃ = 아래쪽, r₄ = 0, s₄ = (2,3)
s₄ = (2,3), a₄ = 아래쪽, r₅ = 1, s₅ = (3,3) (목표 도달)

3. 3-step TD 업데이트 수식 적용

n=3일 때의 업데이트 공식:

예제 경로에 이 공식을 적용해보자.

첫 번째 가능한 업데이트 (t=3)

상태 s₀에 대해:

수치를 대입하면:

두 번째 업데이트 (t=4)

상태 s₁에 대해:

수치를 대입하면:

세 번째 업데이트 (t=5)

상태 s₂에 대해:

수치를 대입하면:

목표 상태의 가치 V(3,3)은 일반적으로 0으로 설정된다 (종료 상태).

4. 에피소드 종료 후 처리

에피소드가 종료되면 (t=5, done=True), 아직 업데이트되지 않은 상태들을 처리한다:

따라서 i=1,2에 대해:

i=1 (상태 s₄)

i=2 (상태 s₃)

5. 다양한 n 값을 사용한 혼합 방식

이미지 3에서 본 것처럼, 다양한 n 값의 반환값을 혼합하여 사용할 수 있다:

예를 들어, n=3, n=5, n=8을 혼합하면:

위의 예제에서 t=0일 때 이 식을 적용해보면:

G₀^(3) = r₁ + γr₂ + γ²r₃ + γ³V(s₃) = 0 + 0 + 0 + 0.9³×0 = 0
G₀^(5) (에피소드 길이가 5이므로) = r₁ + γr₂ + γ²r₃ + γ³r₄ + γ⁴r₅ + γ⁵V(s₅) = 0 + 0 + 0 + 0 + 0.9⁴×1 + 0 = 0.9⁴ = 0.6561
G₀^(8)는 에피소드 길이(5)를 초과하므로, G₀^(5)와 동일합니다 = 0.6561

따라서:

수렴 특성

n이 큰 경우: 수렴 속도가 빠르지만 분산(variance)이 큼
샘플이 많을수록: 큰 수의 법칙에 의해 분산 문제가 완화됨
혼합 접근법: 여러 n 값을 조합하여 편향(bias)과 분산(variance) 사이의 균형을 이룸

이렇게 n-step TD 학습은 1-step TD 학습과 몬테카를로 방법 사이의 유연한 중간점을 제공하며, 문제와 환경에 맞게 n 값을 조정하거나 여러 n 값을 혼합하여 성능을 최적화할 수 있다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 52일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Fri, 25 Apr 2025 02:31:54 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<n-step TD Prediction>

TD learning은 현재 추정치와 다음 상태에서의 추정치 간의 "차이(difference)"를 통해 학습한다. 기존의 1-step TD 방법은 즉각적인 보상과 다음 상태만을 고려하기 때문에 장기적인 보상 구조를 파악하는 데 시간이 오래 걸린다. n-step 접근법은 더 먼 미래의 보상을 직접적으로 고려함으로써:

학습 속도를 향상시키고
보다 정확한 가치 함수 추정이 가능하다.
지연된 보상이 있는 환경에서 특히 효과적이다.

1-step transition에 대한 value function의 Bellman 방정식

이는 기대값 표기법으로 =Ea,s′π[r+γVπ(s′)]로 간단히 나타낼 수 있다.

다음으로, Bellman 방정식을 2-step transition으로 확장한 식이 제시된다:

이 수식들은 2-step transition으로도 동일한 value function이 성립함을 보여준다.

이 개념을 n-step으로 일반화한다:

이는 다시 다음과 같이 전개된다:

이 과정을 반복하면 결국 원래의 1-step Bellman 방정식으로 돌아오게 되며, 이는 n-step transition으로도 성립함을 보여준다.

TD(Temporal Difference) learning에서의 n-step 적용

TD(Temporal Difference) learning에서의 n-step 적용에 대해 설명:

TD learning은 샘플로 평균을 계산하므로 업데이트 식이 복잡해지지 않음.
그러므로 수렴 속도가 빨라지는 n-step transition을 쓰면 좋다.
n이 크면 나중에 받은 보상이 직접적으로 V(s_t)에 반영되므로 long-term 관계 학습에 좋다.

value function 학습에 대한 설명:

1-step TD를 이용한 value function 학습:

n-step TD를 이용한 value function 학습:

n-step TD에서 n이 무한대로 가능 경우:

이는 Monte-Carlo Prediction과 동일해진다. 오른쪽 그림은 Richard Sutton의 "Reinforcement Learning: An Introduction"에서 가져온 것으로, TD(1-step)부터 n-step, Monte Carlo까지의 스펙트럼을 시각적으로 보여주고 있다.

n-step TD Learning 설명: 실제 예시를 통한 이해

1. 기본 TD Learning 수식

TD Learning의 기본 수식은 다음과 같다:

V(s_t) ← V(s_t) + α[r_t+1 + γV(s_t+1) - V(s_t)]

이 수식을 간단한 그리드월드 예시로 이해해보자.

2. 그리드월드 예시

아래와 같은 4x4 그리드월드가 있다고 가정해보자:

+---+---+---+---+
|   |   |   | G |
+---+---+---+---+
|   | X |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| S |   |   |   |
+---+---+---+---+

S: 시작 지점 (보상: 0)
G: 목표 지점 (보상: +10)
X: 장애물 (보상: -5)
빈 칸: 일반 이동 (보상: -1, 매 스텝마다 소모되는 에너지를 의미)
감마(γ) = 0.9 (할인율)
알파(α) = 0.1 (학습률)

3. 1-step TD Learning 예시

에이전트가 시작지점(S)에서 오른쪽으로 한 칸 이동했다고 가정해보자:

현재 상태(s_t): (3, 0) [S 위치]
현재 상태의 가치 추정치 V(s_t): 0 (초기값)
다음 상태(s_t+1): (3, 1) [S의 오른쪽]
다음 상태의 가치 추정치 V(s_t+1): 0 (초기값)
받은 보상(r_t+1): -1 (일반 이동)

TD 업데이트 공식을 적용하면: V(3, 0) ← 0 + 0.1 × [-1 + 0.9 × 0 - 0] = -0.1

이제 S 위치의 가치는 -0.1로 업데이트된다.

4. n-step TD Learning 예시 (n=3)

이제 에이전트가 다음 경로를 따라 이동했다고 가정해봅시다: S → 오른쪽 → 위로 → 위로

3-step TD에서는 3개의 스텝에서 얻은 보상을 모두 고려한다:

현재 상태(s_t): (3, 0) [S 위치]
보상 시퀀스: r_t+1 = -1, r_t+2 = -1, r_t+3 = -1
3스텝 후 상태(s_t+3): (1, 1)
V(s_t+3) = 0 (초기값)

3-step TD 업데이트 공식: V(s_t) ← V(s_t) + α[r_t+1 + γr_t+2 + γ²r_t+3 + γ³V(s_t+3) - V(s_t)]

적용하면:

V(3, 0) ← 0 + 0.1 × [-1 + 0.9×(-1) + 0.9²×(-1) + 0.9³×0 - 0] = 0 + 0.1 × [-1 - 0.9 - 0.81] = 0 + 0.1 × [-2.71] = -0.271

S 위치의 가치는 -0.271로 업데이트된다. 1-step TD(-0.1)보다 더 낮은 값을 가지는데, 이는 3-step이 더 먼 미래의 부정적 보상(-1)까지 고려했기 때문이다.

5. 영어 학습 컨텍스트 예시

TD Learning을 영어 단어 학습 앱에 적용한다면:

상태(s): 현재 학습 중인 단어 (예: "apple")
행동(a): 복습 방법 선택 (플래시카드, 퀴즈, 문장 만들기 등)
보상(r): 테스트 결과 (+1: 맞음, -1: 틀림)
가치함수 V(s): 해당 단어를 얼마나 잘 기억할지에 대한 예측

예를 들어, "apple" 단어에 대한 학습 시퀀스:

플래시카드 사용 → 퀴즈 틀림(-1) → 문장 만들기 → 퀴즈 맞춤(+1) → 일주일 후 테스트 맞춤(+1)

3-step TD 학습을 적용하면: V("apple") ← V("apple") + α[-1 + γ×0 + γ²×(+1) - V("apple")]

이렇게 각 단어마다 최적의 학습 경로를 찾아나갈 수 있다.

6. n이 무한대일 때 (Monte Carlo)

n이 무한대(에피소드 끝까지)라면, 에이전트가 S에서 시작해 G에 도달하는 최적 경로를 따랐을 때:

보상 시퀀스: -1, -1, -1, -1, -1, -1, +10 (7스텝)
총 할인된 보상(G_t): -1 + 0.9×(-1) + 0.9²×(-1) + ... + 0.9⁶×(+10) ≈ 2.15

Monte Carlo 업데이트: V(S) ← V(S) + α[G_t - V(S)] = 0 + 0.1×[2.15 - 0] = 0.215

이는 목표에 도달하는 경로의 장기적 가치를 직접적으로 반영한다.

이처럼 n-step TD는 즉각적인 1-step TD와 전체 경로를 고려하는 Monte Carlo 사이의 균형점을 제공하며, 문제의 특성에 따라 적절한 n 값을 선택할 수 있다.

1-step transition (파란색 섹션)
- 그리드월드에서 에이전트가 한 칸 이동하는 간단한 예시
- "현재 상태의 가치 = 즉각적인 보상 + 다음 상태의 가치(할인)"라는 직관적 설명
2-step transition (녹색 섹션)
- 에이전트가 두 칸 이동하며 받는 보상들을 고려
- "현재 상태의 가치 = 첫 번째 보상 + (두 번째 보상 + 할인된 미래 가치)"
n-step transition (주황색 섹션)
- 에이전트가 n개의 칸을 이동하며 받는 모든 보상 고려
- 더 긴 시퀀스의 보상을 고려하는 방식 시각화
TD 학습 실제 예시 (보라색 섹션)
- 1-step TD 예시: "실제 보상(+10) + 다음 상태 예측 가치(20) - 현재 예측 가치(25) = 오차(+5)"
- n-step TD 예시: "여러 스텝의 실제 보상(+10,+5,+7) + 미래 상태 예측 가치(15) - 현재 예측 가치(25) = 오차(+12)"
TD에서 Monte Carlo까지의 스펙트럼 (우측 하단)
- 1-step(즉각적인 보상만 고려)부터 Monte Carlo(에피소드 끝까지 모든 보상 고려)까지
- "미래에 대한 고려 범위가 넓어짐"을 화살표로 표시

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 51일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Thu, 24 Apr 2025 18:06:36 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<강화학습 환경 및 Q-학습 코드 분석>

환경(Environment) 분석

이 코드에서 환경은 다음과 같은 특징을 가진다:

4x4 격자: 총 16개의 상태가 있다.
특별한 위치들:
- 직장(workplace): (0, 3) 위치, 값 2로 표시
- 집(home): (3, 3) 위치, 값 3으로 표시
- 공원(park): (1,1), (1,2), (2,1), (2,2) 위치, 값 -1로 표시
- 에이전트: 값 1로 표시, 초기 위치는 (0, 0)
행동(Actions): 4가지 행동 가능
- 0: 위로 이동
- 1: 오른쪽으로 이동
- 2: 아래로 이동
- 3: 왼쪽으로 이동
확률적 환경: 70%의 확률로 선택한 행동을 수행하고, 30%의 확률로 무작위 다른 행동을 수행한다.
보상 시스템:
- 기본 보상: -0.5 (매 스텝마다)
- 직장에 도착: +5
- 집에 도착: +10
- 공원에 위치: -1.0
- 이미 목표 지점(직장이나 집)에 있는 경우: 0
종료 조건: 에이전트가 직장이나 집에 도착하면 에피소드가 종료된다.

Q-learning 핵심 알고리즘 분석: 핵심 수식과 실제 코드 매핑

Q-learning의 핵심 업데이트 규칙은 다음과 같다:

코드에서 이 수식이 구현된 부분을 살펴보자:

# 수식의 각 부분이 코드에서 어떻게 구현되었는지 매핑
td = r + gamma * action_value_matrix[i_s_next].max() - action_value_matrix[i_s][a]
action_value_matrix[i_s][a] = action_value_matrix[i_s][a] + alpha * td

위의 실제 매핑을 표로 정리하면:

코드 내 핵심 Q-learning 구현 부분

다음은 코드에서 Q-learning의 핵심 부분과 수식을 직접 매핑한 것이다:

# 핵심 Q-learning 알고리즘 부분
def sarsa(env):
    # Q(s,a) 초기화: 모든 상태-행동 쌍에 대해 0으로 설정
    action_value_matrix = np.zeros([len(env.state_space), len(env.action_space)])
    
    # ε-greedy 정책에 따라 행동 선택
    def sample_action(eps, action_value):
        a_max = action_value.argmax()  # 최대 Q값을 가진 행동 선택 (greedy)
        pi = np.zeros([len(env.action_space)])
        pi[:] = eps / len(env.action_space)  # 모든 행동에 ε/|A| 확률 부여
        pi[a_max] = pi[a_max] + 1 - eps      # 최적 행동에 추가 확률 부여
        a = np.random.choice(env.action_space, p=pi)  # 확률에 따라 행동 선택
        return a

    # ε 값 계산 함수: 시간에 따라 감소
    def get_eps(total_step_count):
        return 1 / (1 + k_eps * total_step_count)  # k_eps = 1e-4
    
    # 학습 루프
    total_step_count = 0
    for loop_count in range(10000):  # 10000 에피소드 실행
        done = False
        step_count = 0

        # 환경 초기화 (s <- s0)
        s = env.reset()
        i_s = get_state_index(env.state_space, s)

        # 에피소드 실행
        while not done:
            # 현재 상태의 Q값들
            action_value = action_value_matrix[i_s]  # Q(s,·)
            
            # ε 계산 및 행동 선택
            eps = get_eps(total_step_count)
            a = sample_action(eps, action_value)  # a ~ π(·|s)
            
            # 행동 실행 및 결과 관찰
            r, s_next, done = env.step(a)  # r, s' <- Env(s,a)
            
            # TD 학습 (Q-learning)
            i_s_next = get_state_index(env.state_space, s_next)
            alpha = 1 / (1 + k_alpha * loop_count)  # 학습률 계산, k_alpha = 2e-2
            
            # --- 핵심 Q-learning 업데이트 공식 ---
            # TD 오차: δ = r + γ·max_a'Q(s',a') - Q(s,a)
            td = r + gamma * action_value_matrix[i_s_next].max() - action_value_matrix[i_s][a]
            
            # Q값 업데이트: Q(s,a) <- Q(s,a) + α·δ
            action_value_matrix[i_s][a] = action_value_matrix[i_s][a] + alpha * td
            # ---------------------------------
            
            # 종료 상태의 Q값은 0으로 설정
            if done:
                action_value_matrix[i_s_next] = 0
            
            # 카운터 업데이트 및 상태 전이
            step_count += 1
            total_step_count += 1
            
            s = s_next
            i_s = i_s_next

        # 진행 상황 출력
        if (loop_count + 1) % 100 == 0:
            print(
                f"[{loop_count}] action_value_matrix: \n{action_value_matrix} "
                + f"eps: {get_eps(total_step_count):.4f} "
                + f"alpha: {alpha:.4f}"
            )

    # 학습된 Q 함수에서 최적 정책 추출
    policy = np.zeros([len(env.state_space), len(env.action_space)])
    state_indexes = np.arange(len(env.state_space))
    argmax_actions = action_value_matrix.argmax(axis=-1)  # 각 상태에서 최대 Q값을 가진 행동
    policy[state_indexes, argmax_actions] = 1.0  # 최적 행동에 확률 1 부여

    return action_value_matrix, policy

실제 예시 계산

예를 들어, 특정 상황에서의 Q-learning 업데이트를 살펴보자:

상황 가정:

현재 상태 s: (0,0) [그리드의 왼쪽 상단] (인덱스 i_s = 0)
선택한 행동 a: 1 (오른쪽으로 이동)
보상 r: -0.5 (기본 이동 보상)
다음 상태 s': (0,1) [오른쪽으로 한 칸 이동] (인덱스 i_s_next = 1)
loop_count: 100 (100번째 에피소드)
total_step_count: 500 (총 500 스텝 진행)
현재 Q값 action_value_matrix[0][1]: -1.2 (예시 값)
다음 상태의 Q값들 action_value_matrix[1]: [-0.8, -0.5, -1.0, -1.1]

계산 과정:

학습률 계산:

alpha = 1 / (1 + k_alpha * loop_count) = 1 / (1 + 0.02 * 100) = 1/3 ≈ 0.333

ε 계산:

eps = 1 / (1 + k_eps * total_step_count) = 1 / (1 + 0.0001 * 500) = 1/1.05 ≈ 0.952

TD 오차 계산:

max_q_next = action_value_matrix[i_s_next].max() = max([-0.8, -0.5, -1.0, -1.1]) = -0.5
td = r + gamma * max_q_next - action_value_matrix[i_s][a]
td = -0.5 + 0.95 * (-0.5) - (-1.2) = -0.5 - 0.475 + 1.2 = 0.225

Q값 업데이트:

action_value_matrix[i_s][a] = action_value_matrix[i_s][a] + alpha * td
action_value_matrix[0][1] = -1.2 + 0.333 * 0.225 = -1.2 + 0.075 = -1.125

- 이렇게 Q값이 -1.2에서 -1.125로 업데이트되었다. TD 오차가 양수이므로 Q값이 증가했으며, 이는 실제 보상과 다음 상태의 예상 가치를 고려할 때 현재 행동의 가치가 이전보다 높다는 것을 의미한다.

Q-learning 알고리즘 실행 과정

아래 그림은 Q-learning 알고리즘의 내부 실행 과정을 보여준다:

초기화: 모든 상태-행동 쌍의 Q값을 0으로 초기화한다.
에피소드 시작: 에이전트를 초기 상태(0,0)로 리셋한다.
행동 선택: ε-greedy 정책에 따라 행동을 선택한다.
- ε 확률로 무작위 행동 선택
- (1-ε) 확률로 현재 최대 Q값을 가진 행동 선택
- ε는 시간에 따라 감소: ε = 1/(1+k_eps*total_step_count)
행동 실행: 선택된 행동을 실행하지만, 환경이 확률적이기 때문에 30%의 확률로 다른 무작위 행동이 실행된다.
Q값 업데이트: TD(시간차) 학습을 통해 Q값을 업데이트한다.
- 학습률 α 계산: α = 1/(1+k_alpha*loop_count)
- TD 오차 계산: TD = r + γ·max_a'Q(s',a') - Q(s,a)
- Q값 업데이트: Q(s,a) ← Q(s,a) + α·TD
종료 확인: 에이전트가 직장이나 집에 도달했는지 확인한다.
- 종료된 경우: 해당 에피소드를 마치고 다음 에피소드로 넘어간다.
- 종료되지 않은 경우: 상태를 전이(s←s')하고 다시 행동을 선택한다.
정책 추출: 충분한 학습 후, 각 상태에서 최대 Q값을 가진 행동을 선택하는 최적 정책을 추출한다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 50일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Wed, 23 Apr 2025 10:58:57 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<Q-learning 알고리즘 코드 구현 연습>

1. 기본 개념 설명(복습)

강화학습 (Reinforcement Learning): 에이전트(Agent)가 환경(Environment)과 상호작용하며 보상(Reward)을 최대화하는 방향으로 행동(Action)을 학습하는 머신러닝의 한 분야이다. 시행착오(Trial-and-error)를 통해 학습한다.
에이전트 (Agent): 학습하고 행동하는 주체 (이 코드에서는 격자 세계를 돌아다니는 개체).
환경 (Environment): 에이전트가 상호작용하는 외부 세계 (이 코드에서는 4x4 격자).
상태 (State, s): 환경의 현재 상황을 나타내는 정보 (에이전트의 위치).
행동 (Action, a): 에이전트가 특정 상태에서 취할 수 있는 선택지 (상, 하, 좌, 우 이동).
보상 (Reward, r): 에이전트가 특정 행동을 취한 결과로 환경으로부터 받는 피드백 신호 (목표 도달 시 +10, 그 외 0).
정책 (Policy, π): 특정 상태에서 어떤 행동을 할지 결정하는 에이전트의 전략 또는 규칙.
가치 함수 (Value Function): 특정 상태 또는 상태-행동 쌍이 장기적으로 얼마나 좋은지를 나타내는 함수.
- 상태-가치 함수 (State-Value Function, V(s)): 상태 s에서 시작했을 때 앞으로 받을 총 보상의 기댓값.
- 행동-가치 함수 (Action-Value Function, Q(s, a)): 상태 s에서 행동 a를 취했을 때 앞으로 받을 총 보상의 기댓값. Q-러닝은 이 Q함수를 학습한다.
Q-러닝 (Q-Learning): 대표적인 모델-프리(Model-Free), 오프-폴리시(Off-Policy) 강화학습 알고리즘이다.
- 모델-프리: 환경의 작동 방식(상태 전이 확률, 보상 함수)을 미리 알 필요 없이 학습한다.
- 오프-폴리시: 에이전트가 실제로 따르는 행동 정책(탐험 포함)과 학습하려는 목표 정책(최적 정책)이 달라도 학습이 가능하다. Q-러닝은 항상 다음 상태에서 가능한 Q-값 중 최댓값을 사용하여 업데이트하기 때문에 오프-폴리시이다.
- Q-테이블: 상태와 행동 쌍에 대한 Q-값을 저장하는 테이블 (action_value_matrix).
- 시간차 학습 (Temporal Difference, TD): 현재 추정치를 사용하여 다음 추정치를 업데이트하는 방식. Q-러닝은 TD 학습의 일종이다. r + gamma * max_a'(Q(s', a')) 부분이 TD 타겟이다.
Epsilon-Greedy 탐험 (Epsilon-Greedy Exploration): 학습 초반에는 무작위 행동(탐험)을 통해 다양한 경험을 쌓고, 학습이 진행됨에 따라 점차 최적이라고 생각되는 행동(활용)의 비율을 높이는 전략이다. epsilon 값이 이 비율을 조절한다.
학습률 (Learning Rate, α): TD 에러를 얼마나 반영하여 Q-값을 업데이트할지 결정하는 비율. 너무 크면 학습이 불안정하고, 너무 작으면 학습이 느려진다. 이 코드에서는 점차 감소시킨다.
할인율 (Discount Factor, γ): 미래 보상을 현재 가치로 환산할 때 얼마나 할인할지를 결정하는 값 (0~1). 1에 가까울수록 미래 보상을 중요하게 생각한다.

2. 환경 설정 (environment.py)

환경 코드는 4x4 격자 세계(Grid World)를 구현한다.

초기화 함수 (init)

이 코드는 강화학습 에이전트가 상호작용할 환경을 정의한다. 4x4 크기의 격자 세계(Grid World) 환경이다.

def __init__(self):
    '''
    state_space: 4x4 grid info using numpy
    value of the agent location: 1
    value of the goal location: -1

    action_space: {0, 1, 2, 3}
    0: up
    1: right
    2: down
    3: left
    '''
    self.agent_pos = {'y': 0, 'x': 0}
    self.goal_pos = {'y': 3, 'x': 3}
    self.y_min, self.x_min, self.y_max, self.x_max = 0, 0, 3, 3

    # set up state
    self.state = np.zeros([4, 4])
    self.state[self.goal_pos['y'], self.goal_pos['x']] = -1
    self.state[self.agent_pos['y'], self.agent_pos['x']] = 1

    self.state_space = list()
    for y in range(4):
        for x in range(4):
            state = np.zeros([4,4])
            state[self.goal_pos['y'], self.goal_pos['x']] = -1
            state[y, x] = 1
            self.state_space.append(state)

    self.action_space = [0, 1, 2, 3]

에이전트 위치: (0,0)에서 시작
목표 위치: (3,3)에 고정
상태 표현: 4x4 NumPy 배열로, 에이전트 위치는 1, 목표는 -1, 나머지는 0
상태 공간: 에이전트가 있을 수 있는 모든 위치를 미리 계산 (총 16개 상태)
행동 공간: [0(상), 1(우), 2(하), 3(좌)]

환경 리셋 (reset)

def reset(self):
    self.agent_pos = {'y': 0, 'x': 0}
    self.state = np.zeros([4,4])
    self.state[self.goal_pos['y'], self.goal_pos['x']] = -1
    self.state[self.agent_pos['y'], self.agent_pos['x']] = 1
    
    return self.state

에이전트 위치를 (0,0)으로 초기화
상태 배열 재설정 후 반환

환경 진행 (step)

def step(self, action):
    # Update environmental variables 
    if action == 0:
        # 'y' should be decreased by 1 or stay the same when it is at the top row
        self.agent_pos['y'] = max(
            self.agent_pos['y'] - 1, 
            self.y_min
        ) 
    elif action == 1:
        # 'x' should be increased by 1 or stay the same when it is at the most right column
        self.agent_pos['x'] = min(
            self.agent_pos['x'] + 1, 
            self.x_max
        )
    elif action == 2:
        # 'y' should be increased by 1 or stay the same when it is at the bottom row
        self.agent_pos['y'] = min(
            self.agent_pos['y'] + 1, 
            self.y_max
        )
    elif action == 3:
        # 'x' should be decreased by 1 or stay the same when it is at the most left column
        self.agent_pos['x'] = max(
            self.agent_pos['x'] - 1, 
            self.x_min
        )
    else:
        assert False, "Invalid action value was fed to step."

    # Make a next state after transition
    prev_state = self.state
    self.state = np.zeros([4,4])
    self.state[self.goal_pos['y'], self.goal_pos['x']] = -1
    self.state[self.agent_pos['y'], self.agent_pos['x']] = 1

    done = False
    if self.agent_pos == self.goal_pos:
        done = True

    reward = self.reward(prev_state, action, self.state)

    return reward, self.state, done

주어진 행동(action)에 따라 에이전트 위치 업데이트
격자 경계를 벗어나지 않도록 처리 (min, max 함수 사용)
상태 업데이트 후 이전 상태 저장
목표 도달 여부 확인
보상 계산 및 결과 반환 (보상, 다음 상태, 종료 여부)

보상 함수 (reward)

def reward(self, s, a, s_next):
    reward = 0
    y, x = np.where(s == 1)
    y_next, x_next = np.where(s_next == 1)
    if (
            (y_next == self.goal_pos['y'] and x_next == self.goal_pos['x']) and
            (y != self.goal_pos['y'] or x != self.goal_pos['x'])
        ):  # Reached the goal
        reward = 10
        
    return reward

현재 상태와 다음 상태에서 에이전트 위치 추출
목표에 도달했을 때만 보상 10 지급
그 외에는 보상 0 (Sparse reward)

2. Q-learning 구현 (q_learning.py)

하이퍼파라미터 및 유틸리티 함수

gamma = 0.9  # 할인율
k_alpha = 2e-2  # 학습률 감쇠 계수
k_eps = 2e-4  # 탐험률 감쇠 계수

def get_state_index(state_space, state):
    for i_s, s in enumerate(state_space):
        if (s == state).all():
            return i_s
    assert False, "Couldn't find the state from the state space"

gamma: 미래 보상의 가치를 현재 기준으로 할인하는 비율
k_alpha: 학습률을 에피소드가 진행됨에 따라 감소시키는 계수
k_eps: 탐험률을 스텝이 진행됨에 따라 감소시키는 계수
get_state_index: 주어진 상태 배열이 상태 공간 내에서 어떤 인덱스에 해당하는지 찾음

Q-learning 함수

def q_learning(env):
    action_value_matrix = np.zeros([len(env.state_space), len(env.action_space)])

    def sample_action(eps, action_value):
        a_max = action_value.argmax()
        pi = np.zeros([len(env.action_space)])
        pi[:] = eps / len(env.action_space)
        pi[a_max] = pi[a_max] + 1 - eps
        a = np.random.choice(env.action_space, p=pi)
        return a

    def get_eps(total_step_count):
        return 1 / (1 + k_eps * total_step_count)

action_value_matrix: Q-테이블 초기화 (16x4 크기)
sample_action: 입실론-그리디 방식으로 행동 선택
- 확률 eps로 무작위 행동 선택
- 확률 1-eps로 최대 Q-값을 가진 행동 선택
get_eps: 전체 스텝 수에 따라 탐험률 감소

학습 과정 구현

total_step_count = 0
for loop_count in range(2000):
    done = False
    step_count = 0

    s = env.reset()
    i_s = get_state_index(env.state_space, s)

    # Generate an episode
    while not done:
        action_value = action_value_matrix[i_s]
        eps = get_eps(total_step_count)
        a = sample_action(eps, action_value)
        r, s_next, done = env.step(a)

        i_s_next = get_state_index(env.state_space, s_next)
        alpha = 1 / (1 + k_alpha * loop_count)
        td = r + gamma * action_value_matrix[i_s_next].max() - action_value_matrix[i_s][a]
        action_value_matrix[i_s][a] = action_value_matrix[i_s][a] + alpha * td
        
        if done:
            action_value_matrix[i_s_next] = 0

        step_count += 1
        total_step_count += 1
        
        s = s_next
        i_s = i_s_next

2000번의 에피소드를 반복
각 에피소드 내부:
- 환경 초기화 (env.reset())
- 에피소드 완료될 때까지 반복:
  - 현재 상태의 Q-값 가져오기
  - 현재 탐험률 계산
  - 행동 선택
  - 환경과 상호작용 (행동 실행)
  - 학습률 계산 (alpha)
  - TD(Temporal Difference) 에러 계산 및 Q-값 업데이트
  - 종료 상태 처리 (종료 상태의 Q-값은 0으로 설정)
  - 상태 업데이트 및 카운터 증가

정책 추출 및 반환

# Generate optimal policy from the action value function
policy = np.zeros([len(env.state_space), len(env.action_space)])
state_indexes = np.arange(len(env.state_space))
argmax_actions = action_value_matrix.argmax(axis=-1)
policy[state_indexes, argmax_actions] = 1.0

return action_value_matrix, policy

학습된 Q-테이블에서 각 상태별 최적 행동 추출
확정적 정책 생성 (최적 행동에 확률 1.0 부여)

메인 실행 부분

if __name__ == "__main__":
    np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
    env = Env()
    action_value_matrix, policy = q_learning(env)

    argmax_actions = action_value_matrix.argmax(axis=-1)
    value_vector = np.sum(policy * action_value_matrix, axis=-1)

    value_table = value_vector.reshape(4, 4)
    argmax_actions_table = argmax_actions.reshape(4, 4)
    print(
        f"value_table: \n{value_table}\n"
        + f"argmax_actions: \n{argmax_actions.reshape(4, 4)}"
    )

환경 생성
Q-learning 실행
학습된 Q-테이블에서 최적 행동과 가치 계산
결과를 4x4 격자 형태로 출력

3. 코드 구조도

다이어그램은 Q-learning 알고리즘의 실행 흐름을 보여준다. 메인 함수에서 환경을 초기화하고, Q-learning 함수를 호출하며, 내부에서는 에피소드와 스텝을 반복하면서 Q-테이블을 업데이트하고 최종적으로 최적 정책을 추출한다.

실행 및 디버깅

출력으로 보이는 부분은 학습 과정 중 1999번째 에피소드에서의 Q-테이블(action_value_matrix) 값이다. 이 시점에서 epsilon(탐험률)은 0.2128, alpha(학습률)는 0.0257이다.

가치 테이블(value_table):

[[ 5.905  6.561  7.290  8.100]
 [ 6.561  7.290  8.100  9.000]
 [ 7.290  8.100  9.000 10.000]
 [ 8.100  9.000 10.000  0.000]]

각 위치에서의 최적 가치를 보여준다.
목표 위치(3,3)의 가치는 0.000으로 설정되어 있다(종료 상태).
목표에 가까울수록 가치가 높아지는 패턴이 명확하다.

최적 행동(argmax_actions):

[[1 2 1 2]
 [1 1 1 2]
 [1 2 1 2]
 [1 1 1 0]]

각 위치에서 에이전트가 취해야 할 최적 행동을 나타낸다.
0: 위쪽, 1: 오른쪽, 2: 아래쪽, 3: 왼쪽
대부분의 위치에서 오른쪽(1)이나 아래쪽(2)으로 이동하는 것이 최적인데, 이는 목표가 오른쪽 아래(3,3)에 있기 때문이다.
마지막 행의 마지막 열(목표 위치, 3,3)에서는 위쪽(0)으로 이동하는 것이 표시되어 있지만, 이는 사실상 의미가 없다(종료 상태이므로).

해석:

학습이 성공적으로 이루어졌다. 목표 지점(3,3)에 가까울수록 가치가 높게 나타나며, 최적 행동들은 대체로 목표를 향해 움직이도록 설정되었다.
격자의 오른쪽과 아래쪽 경계를 따라 목표로 향하는 경로가 형성되었다. 에이전트는 대부분의 위치에서 오른쪽(1)이나 아래쪽(2)으로 이동하는 것을 선호한다.
가치 테이블에서 목표 상태(3,3)의 가치가 0인 것은 종료 상태 처리 로직(if done: action_value_matrix[i_s_next] = 0) 때문이다.
최적 정책은 에이전트가 어떤 위치에서든 최소한의 스텝으로 목표에 도달할 수 있도록 형성되었다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 49일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Tue, 22 Apr 2025 15:52:14 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<강화 학습: SARSA 알고리즘 코드 구현 연습>

환경 구현(Env 클래스):
- 에이전트가 (0,0)에서 시작하고 목표가 (3,3)인 4x4 그리드 월드
- 위, 오른쪽, 아래, 왼쪽의 네 가지 가능한 행동
- 목표에 도달할 때 +10의 보상, 그 외에는 0
- 환경은 에이전트의 움직임과 경계 확인을 처리함
SARSA 알고리즘 구현:
- 온폴리시(on-policy) 시간차(temporal difference) 학습 알고리즘
- 가상의 최적 행동이 아닌 실제 취한 행동을 기반으로 Q-값 업데이트
- 핵심 업데이트 공식 사용: Q(s,a) ← Q(s,a) + α[r + γQ(s',a') - Q(s,a)]
탐색 전략:
- ε-greedy 정책으로 탐색과 활용의 균형을 맞춤
- ε(탐색률)과 α(학습률) 모두 시간이 지남에 따라 감소
- 탐색은 학습 초기에 환경을 발견하는 데 도움을 줌
- 활용은 학습된 정보를 기반으로 정책을 개선함

실행 구조

프로세스 흐름:

모든 상태-행동 쌍에 대한 Q-값을 0으로 초기화
각 에피소드마다:
- 환경 초기화(에이전트를 시작 위치에 배치)
- ε-greedy 정책을 사용하여 초기 행동 선택
- 에피소드가 끝날 때까지:
  - 행동을 취하고, 보상과 다음 상태 관찰
  - ε-greedy 정책을 사용하여 다음 행동 선택
  - SARSA 규칙을 사용하여 Q-값 업데이트
  - 다음 상태-행동 쌍으로 이동
최종 Q-값에서 최적 정책 추출

최적 정책 성능

이 그리드 월드에서 SARSA가 학습한 최적 정책:

에이전트를 시작 위치에서 목표 위치로 안내
누적 보상을 최대화하기 위해 최단 경로 선택
행동은 결정적(학습된 Q-값에 대해 탐욕적)

두 번째 아티팩트의 시각화는 에이전트가 그리드의 모든 위치에서 목표에 도달하기 위해 어떻게 이동하는지 보여준다. 화살표는 각 상태에서 가장 높은 Q-값을 가진 행동을 나타낸다. 이 구현은 다음과 같은 기본 강화학습 원칙을 보여준다:

가치 함수 근사
시간차 학습
탐색과 활용의 균형
가치 함수에서 정책 도출

핵심 코드 추출 및 설명

1. 환경(Environment) 클래스 핵심 코드

class Env:
    def __init__(self):
        # 에이전트와 목표 위치 초기화
        self.agent_pos = {'y': 0, 'x': 0}
        self.goal_pos = {'y': 3, 'x': 3}
        self.y_min, self.x_min, self.y_max, self.x_max = 0, 0, 3, 3
        
        # 상태 공간 설정
        self.state = np.zeros([4, 4])
        self.state[self.goal_pos['y'], self.goal_pos['x']] = -1
        self.state[self.agent_pos['y'], self.agent_pos['x']] = 1
        
        # 가능한 모든 상태 생성
        self.state_space = list()
        for y in range(4):
            for x in range(4):
                state = np.zeros([4,4])
                state[self.goal_pos['y'], self.goal_pos['x']] = -1
                state[y, x] = 1
                self.state_space.append(state)

        self.action_space = [0, 1, 2, 3]  # 위, 오른쪽, 아래, 왼쪽

    def step(self, action):
        # 행동에 따른 에이전트 위치 업데이트
        if action == 0:  # 위
            self.agent_pos['y'] = max(self.agent_pos['y'] - 1, self.y_min)
        elif action == 1:  # 오른쪽
            self.agent_pos['x'] = min(self.agent_pos['x'] + 1, self.x_max)
        elif action == 2:  # 아래
            self.agent_pos['y'] = min(self.agent_pos['y'] + 1, self.y_max)
        elif action == 3:  # 왼쪽
            self.agent_pos['x'] = max(self.agent_pos['x'] - 1, self.x_min)
        
        # 새로운 상태 생성
        prev_state = self.state
        self.state = np.zeros([4,4])
        self.state[self.goal_pos['y'], self.goal_pos['x']] = -1
        self.state[self.agent_pos['y'], self.agent_pos['x']] = 1

        # 목표 도달 여부 확인
        done = False
        if self.agent_pos == self.goal_pos:
            done = True

        # 보상 계산
        reward = self.reward(prev_state, action, self.state)

        return reward, self.state, done

    def reward(self, s, a, s_next):
        reward = 0
        y, x = np.where(s == 1)
        y_next, x_next = np.where(s_next == 1)
        # 목표에 도달했을 경우 보상 10 제공
        if ((y_next == self.goal_pos['y'] and x_next == self.goal_pos['x']) and
            (y != self.goal_pos['y'] or x != self.goal_pos['x'])):
            reward = 10
        return reward

2. SARSA 알고리즘 핵심 코드

def sarsa(env):
    # Q-값 초기화 (행동 가치 함수)
    action_value_matrix = np.zeros([len(env.state_space), len(env.action_space)])
    
    # ε-greedy 정책을 사용한 행동 선택 함수
    def sample_action(eps, action_value):
        a_max = action_value.argmax()
        pi = np.zeros([len(env.action_space)])
        pi[:] = eps / len(env.action_space)
        pi[a_max] = pi[a_max] + 1 - eps
        a = np.random.choice(env.action_space, p=pi)
        return a
    
    # 탐색률(ε) 계산 함수
    def get_eps(total_step_count):
        return 1 / (1 + k_eps * total_step_count)

    # SARSA 메인 루프
    total_step_count = 0
    for loop_count in range(50000):
        done = False
        s = env.reset()
        i_s = get_state_index(env.state_space, s)
        eps = get_eps(total_step_count)
        a = sample_action(eps, action_value_matrix[i_s])

        # 에피소드 생성
        while not done:
            # 행동 실행 및 다음 상태, 보상 관찰
            r, s_next, done = env.step(a)
            i_s_next = get_state_index(env.state_space, s_next)
            
            # 다음 상태에서 ε-greedy로 다음 행동 선택
            eps = get_eps(total_step_count)
            a_next = sample_action(eps, action_value_matrix[i_s_next])
            
            # 학습률 계산
            alpha = 1 / (1 + k_alpha * loop_count)
            
            # TD 오차 계산 및 Q-값 업데이트
            td = r + gamma * action_value_matrix[i_s_next][a_next] - action_value_matrix[i_s][a]
            action_value_matrix[i_s][a] = action_value_matrix[i_s][a] + alpha * td
            
            # 목표 상태의 경우 Q-값을 0으로 설정
            if done:
                action_value_matrix[i_s_next] = 0
                
            # 다음 상태-행동 쌍으로 이동
            s = s_next
            i_s = i_s_next
            a = a_next
            
            total_step_count += 1

    # 최적 정책 생성
    policy = np.zeros([len(env.state_space), len(env.action_space)])
    state_indexes = np.arange(len(env.state_space))
    argmax_actions = action_value_matrix.argmax(axis=-1)
    policy[state_indexes, argmax_actions] = 1.0
    
    return action_value_matrix, policy

코드 상세 설명

1. 환경(Env) 클래스

초기화 (__init__):
- 4x4 크기의 그리드 월드 생성
- 에이전트는 (0,0)에서 시작, 목표는 (3,3)에 위치
- 상태는 4x4 배열로 표현: 에이전트 위치는 1, 목표 위치는 -1, 나머지는 0
- state_space는 모든 가능한 상태를 저장 (총 16개의 상태)
- action_space는 가능한 모든 행동(0:위, 1:오른쪽, 2:아래, 3:왼쪽)
step 함수:
- 주어진 행동(action)에 따라 에이전트의 위치 업데이트
- 경계 밖으로 나가는 것을 방지하는 로직 포함
- 새로운 상태를 생성하고 목표 도달 여부 확인
- reward 함수를 통해 보상 계산 후 반환
reward 함수:
- 목표에 도달했을 때만 보상 10을 제공, 그 외에는 0
- 단순한 보상 체계로 에이전트가 목표를 찾도록 유도

2. SARSA 알고리즘

초기화:
- 모든 상태-행동 쌍에 대한 Q-값을 0으로 초기화
sample_action 함수:
- ε-greedy 정책을 구현
- 확률 ε으로 무작위 행동 선택
- 확률 1-ε로 Q-값이 가장 높은 행동 선택
- 수식: π(a|s) = ε/|A| + (1-ε) if a = argmax Q(s,a') else ε/|A|
get_eps 함수:
- 시간에 따라 감소하는 탐색률(ε) 계산
- 수식: ε = 1/(1 + k_ε * total_step_count)
- 초기에는 탐색을 많이 하고 시간이 지남에 따라 학습된 정책에 더 의존
메인 루프:
1. 환경 초기화 및 시작 상태에서 ε-greedy로 행동 선택
2. 상태-행동-보상-다음상태-다음행동 샘플 수집
3. TD 오차 계산: δ = r + γQ(s',a') - Q(s,a)
4. Q-값 업데이트: Q(s,a) ← Q(s,a) + α * δ
5. 다음 상태-행동 쌍으로 이동
6. 목표에 도달할 때까지 2-5 반복
7. 50,000번의 에피소드 수행
학습률(α) 감소:
- 수식: α = 1/(1 + k_α * loop_count)
- 시간이 지남에 따라 학습률 감소로 Q-값의 안정화
최적 정책 생성:
- 각 상태에서 Q-값이 가장 높은 행동을 선택하는 결정적 정책
- 모든 상태에 대한 최적 행동을 매핑한 배열 반환

핵심 알고리즘 수식

SARSA의 핵심은 다음 TD 학습 업데이트 규칙이다:

Q(s, a) ← Q(s, a) + α[r + γQ(s', a') - Q(s, a)]

여기서:

Q(s, a): 상태 s에서 행동 a를 취했을 때의 예상 누적 보상
α: 학습률(시간에 따라 감소)
r: 즉각적인 보상
γ: 할인 계수(0.9로 설정됨)
s': 행동 a를 취한 후의 다음 상태
a': 상태 s'에서 ε-greedy 정책에 따라 선택된 다음 행동

이 알고리즘은 실제로 취한 행동(a')의 Q-값을 사용하여 현재 Q-값을 업데이트하는 온폴리시(on-policy) 학습 방법이다. 이는 Q-learning과의 주요 차이점으로, Q-learning은 다음 상태에서 가능한 최대 Q-값을 사용한다.

최종적으로, 충분한 학습 후 각 상태에서 가장 높은 Q-값을 가진 행동을 선택하는 최적 정책이 형성된다. 이 정책은 에이전트를 시작 위치에서 목표까지의 최단 경로로 안내한다.

Policy Iteration과 SARSA 결과값 비교 분석

제공된 두 이미지는 각각 Policy Iteration과 SARSA 알고리즘의 실행 결과를 보여준다. 두 알고리즘의 결과값을 비교해보자.

가치 함수(Value Function) 비교

Policy Iteration 결과 (이미지 1)

초기 결과:

[0.70296524 0.8610546  1.13251421 1.38260723]
[0.8610546  1.13397666 1.66059224 2.25038023]
[1.13251421 1.66059224 2.86659777 4.71086143]
[1.38260723 2.25038023 4.71086143 0.        ]

최종 결과:

[5.9049  6.561  7.29   8.1  ]
[6.561   7.29   8.1    9.   ]
[7.29    8.1    9.     10.  ]
[8.1     9.     10.    0.   ]

SARSA 결과 (이미지 2)

최종 결과:

5.861  6.478  7.246  8.044]
[6.531  7.233  8.076  8.998]
[7.269  8.063  8.989  10.000]
[8.091  8.997  10.000 0.000]

최적 행동(Optimal Actions) 비교

SARSA 결과에서 최적 행동 (argmax_actions)

[2 1 2 2]
[2 1 1 2]
[2 1 2 2]
[1 1 1 0]

여기서 숫자는 각 상태에서의 최적 행동을 나타낸다:

0: 위쪽
1: 오른쪽
2: 아래쪽
3: 왼쪽

핵심 차이점

가치 함수 값:
- Policy Iteration은 더 균일하고 정수에 가까운 값(5.9, 6.56, 7.29, 8.1 등)을 생성했다.
- SARSA는 약간 더 세밀한 값(5.861, 6.478, 7.246 등)을 생성했다.
목표 상태의 가치:
- 두 알고리즘 모두 목표 상태(오른쪽 하단 코너)의 가치는 0이다.
가장 높은 가치:
- 두 알고리즘 모두 목표 바로 옆 상태들에서 10 또는 10에 가까운 가장 높은 가치를 보여준다.
수렴 패턴:
- Policy Iteration은 이론적으로 정확한 값으로 더 빠르게 수렴한다.
- SARSA는 시간에 따라 점진적으로 수렴하며, 일부 탐색으로 인해 약간의 값 변동이 있을 수 있다.
학습 파라미터:
- SARSA 실행 결과에서는 eps(입실론): 0.0154와 alpha(알파): 0.0196 값이 표시된다.
- 이는 학습이 거의 끝나고 탐색(exploration)이 매우 적게 이루어지는 단계를 보여준다.

결론

두 알고리즘 모두 비슷한 가치 함수와 최적 정책을 학습했지만, 접근 방식에는 차이가 있다:

Policy Iteration은 환경 모델을 알고 있으므로 정확한 값으로 더 직접적으로 수렴.
SARSA는 실제 경험을 통해 학습하므로 약간의 노이즈가 있을 수 있지만, 여전히 유사한 최종 결과에 도달.

이 비교는 두 알고리즘이 서로 다른 접근 방식에도 불구하고 같은 문제에 대해 유사한 해결책을 찾을 수 있음을 보여준다. 실제 적용에서는 환경 모델의 가용성, 상태 공간의 크기, 컴퓨팅 리소스 등에 따라 적절한 알고리즘을 선택하는 것이 중요하다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 48일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Mon, 21 Apr 2025 20:05:16 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<Q-러닝(Q-Learning) 알고리즘의 수렴성(Convergence)>

벨만 방정식과 수축 매핑 증명을 기반으로 왜 그리고 어떻게 최적 정책으로 수렴하는지 알아보자.

강화학습(Reinforcement Learning)의 Q-함수와 벨만 연산자(Bellman operator)에 관한 수학적 증명은 두 Q-함수 간의 차이에 대한 상한을 설정하고 벨만 연산자가 수축 매핑(contraction mapping)임을 보여준다.

기본 Q-함수 정의 (이미지 6):벨만 최적 방정식 (Bellman Optimality Equation)

이것은 최적 Q-함수에 대한 벨만 방정식으로, 현재 상태 s에서 행동 a를 취했을 때 얻을 수 있는 기대 보상과 다음 상태 s'에서의 최대 Q-값을 감가율 γ로 할인한 값의 합을 나타낸다.

벨만 연산자와 수축 매핑 증명:

이 부분은 두 Q-함수 Q¹과 Q²에 벨만 연산자 T*를 적용했을 때, 그 차이가 원래 두 함수의 차이에 감가율 γ를 곱한 것보다 작거나 같음을 보여준다. γ < 1이므로 이는 수축 매핑의 정의를 만족한다.

최종 수축 매핑 결론:

설명: 벨만 연산자 T∗는 γ<1일 때 수축 매핑이다. 이는 반복적으로 T∗를 적용하면 가치 함수가 최적 가치 함수 Q∗로 수렴함을 보장한다.

특정 경우의 차이 분석:

설명: 두 가치 함수의 차이는 항상 최대 차이 ∣∣Q1−Q2∣∣∞이하이다.

수렴성 보장의 중요성

이론적 타당성: 알고리즘이 수렴하지 않는다면, 계산 자원을 아무리 투입해도 최적 정책을 찾지 못할 수 있다. 수렴성은 알고리즘의 이론적 완전성을 보장한다.
실용적 신뢰성: 현실 문제에 적용할 때 알고리즘이 언젠가는 최적 해답에 도달할 것이라는 신뢰를 제공한다.
알고리즘 설계: 수렴성 분석을 통해 학습률, 탐색 전략 등 알고리즘의 핵심 파라미터를 설계하는 지침을 얻을 수 있다.
성능 예측: 수렴 속도와 조건에 대한 이해는 알고리즘의 성능을 예측하고 문제에 맞게 조정하는 데 필수적이다.

벨만 방정식을 통한 수렴성 증명

벨만 방정식의 핵심 요소를 통해 Q-학습의 수렴성을 증명하는 방법은 다음과 같다:

벨만 연산자의 수축성(Contraction Mapping):
- 벨만 방정식에서 핵심은 T*(Q)(s,a) = Σ p(s'|s,a)[r + γ max_a' Q(s',a')] 형태의 벨만 연산자가 수축 매핑이라는 점이다.
- 두 Q-함수 Q¹, Q²에 대해 ||T*(Q¹) - T*(Q²)||∞ ≤ γ||Q¹ - Q²||∞가 성립한다.
- 여기서 γ는 1보다 작은 감가율(discount factor)이므로, 벨만 연산자는 Q-함수 간의 거리를 반드시 감소시킨다.
고정점 이론(Fixed Point Theory):
- 바나흐 고정점 정리(Banach Fixed-Point Theorem)에 따르면, 완비 거리 공간에서의 수축 매핑은 유일한 고정점을 가지며, 어떤 시작점에서든 반복적 적용을 통해 그 고정점에 수렴한다.
- 벨만 연산자가 수축 매핑이므로, Q-학습 업데이트를 무한히 반복하면 유일한 최적 Q-함수 Q*에 수렴한다.
확률적 근사 이론:
- 실제 Q-학습은 샘플 기반이므로, 확률적 근사 이론을 통해 추가적인 조건(적절한 학습률 감소, 충분한 탐색 등)을 만족할 때 확률적으로 최적 Q-함수에 수렴함을 증명한다.
- 이는 벨만 연산자의 수축성에 기반한 분석의 확장이다.

벨만 방정식에서 감가율 γ < 1이라는 조건은 수렴성 증명에 결정적이다. 이 조건으로 인해 벨만 연산자가 수축 매핑이 되고, 이를 통해 Q-학습이 최적 정책으로 수렴할 수 있다는 이론적 보장을 얻게 된다. 이러한 수학적 기반이 없다면, Q-학습은 단순한 휴리스틱에 불과할 것이며 신뢰할 수 있는 알고리즘으로 널리 사용되지 못했을 것이다.

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB

패스트캠퍼스 환급챌린지 47일차 : 스크래치부터 시작하는 강화학습의 모든 것 강의 후기

dev-self — Sun, 20 Apr 2025 01:19:17 +0900

*본 포스팅은 패스트캠퍼스 환급 챌린지 참여를 위해 작성하였습니다.

|내용 정리|

<Q-learning: off-policy 학습방법>

주요 Q-learning 공식

1. 벨만 최적성 방정식 (Bellman Optimality Equation)

이 기본 방정식은 최적 행동-가치 함수를 정의합니다. 상태 s에서 행동 a를 취했을 때의 최적 Q값은 즉각적인 보상의 기대값과 모든 가능한 다음 상태에서의 할인된 최대 미래 가치의 합과 같다는 의미이다.

2. 가치 반복 업데이트 (Value Iteration Update)

이 반복적 업데이트 방정식은 반복 적용을 통해 최적 Q-함수에 접근한다. 각 반복마다 최적 정책에 더 가까워진다.

의미:
- 현재 상태 s와 행동 a에 대해, 모든 가능한 다음 상태 s′의 전이 확률 p(s′∣s,a)를 고려.
- 즉시 보상 r과 할인된 최대 미래 가치 γmax⁡a′Qk(s′,a′)의 기댓값을 계산해 Q-value를 업데이트.
특징:
- 모델 기반 (Model-Based): 환경의 전이 확률 p(s′∣s,a)를 알고 있어야 한다.
- 최적성 보장: 반복 적용 시 최적 Q-function Q∗로 수렴.
- 동적 계획법 (DP): 실제 경험 없이도 이론적으로 계산 가능.

3. Argmax 정책에 대한 벨만 방정식

이는 특정 정책(특히 argmax 정책)을 사용할 때 Q-함수가 어떻게 업데이트되는지 보여준다.

의미:
- 특정 정책 π(예: 탐욕 정책) 하에서 Q-value를 업데이트한다.
- 다음 상태 s′에서 정책 π에 따라 행동 a′을 선택할 때의 기대 미래 가치를 반영한다.
Argmax 정책 적용 시:
- 만약 π가 arg max⁡ 정책이면 ∑a′π(a′∣s′)Qk(s′,a′)=max⁡a′Qk(s′,a′)가 되어, 가치 반복 업데이트와 동일해진다.
특징:
- 정책 평가 (Policy Evaluation): 주어진 정책 π의 성능을 평가할 때 사용.
- 온-폴리시 (On-Policy): 정책 π 자체가 업데이트에 관여.

4. Argmax에 대한 정책 정의 (탐욕 정책)

현재 Q-value Qk(s,a)에서 가장 높은 값을 가진 행동 a를 확률 1로 선택하고, 나머지 행동은 0으로 배제하는 결정론적 정책이다.

5. ε-탐욕 정책 (ε-Greedy Policy)

이 정책은 확률 1-ε + ε/|A|로 탐욕적 행동을 선택하고, 다른 행동들은 확률 ε/|A|로 선택함으로써 탐색과 활용 사이의 균형을 맞춘다.

의미:
- 최적 행동 선택 확률: 1−ϵ+ϵ/∣A∣(주로 1−ϵ로 근사).
- 나머지 행동 선택 확률: 균등 분배 ϵ/∣A∣.
특징:
- Exploration-Exploitation 균형: 확률 ϵ으로 무작위 행동을 선택해 탐색을 보장한다.
- Behavior Policy로 사용: Q-learning에서 데이터 수집을 위해 실제로 사용되는 정책이다.

6. Q-learning 업데이트 식

이것은 Q-learning의 실제 구현 공식으로, 경험을 기반으로 Q값이 어떻게 업데이트되는지 보여준다. 대괄호 안의 항은 시간적 차이(TD) 오류이다.

Initialize α > 0, π and Q(s,a) for all s ∈ S and a ∈ A
While True
    Initialize s, done = False
    While not done
        a ~ π(·|s) (e.g., ε-greedy)
        Take action a and observe r, s', done
        Q(s,a) = Q(s,a) + α[r + γ max(Q(s',a')) - Q(s,a)]
        If done
            Q(s',·) = 0
        s = s'

초기화 단계:
- 학습률 α (alpha)는 0보다 큰 값으로 설정.
- 정책 π (pi)를 초기화.
- 모든 상태 s와 행동 a에 대한 Q(s,a) 값을 초기화.
에피소드 반복 (외부 While 루프):
- 각 에피소드마다 초기 상태 s를 설정하고 done 플래그를 False로 초기화.
상태-행동-보상 루프 (내부 While 루프):
- 현재 상태 s에서 정책 π에 따라 행동 a를 선택 (주로 ε-greedy 정책 사용).
- 선택한 행동 a를 환경에 적용하고, 보상 r, 다음 상태 s', 그리고 에피소드 종료 여부(done)를 관찰.
- Q-값을 다음 공식으로 업데이트합니다 -> Q(s,a) = Q(s,a) + α[r + γ max(Q(s',a')) - Q(s,a)]
- α는 학습률
- γ는 할인 계수
- max(Q(s',a'))는 다음 상태에서의 최대 Q-값
- [r + γ max(Q(s',a')) - Q(s,a)]는 TD(Temporal Difference) 오차

종료 조건 처리:
- 에피소드가 종료되면(done = True), 종료 상태의 모든 Q-값을 0으로 설정: Q(s',·) = 0 (이는 종료 상태에서는 더 이상의 미래 보상이 없다는 의미)
상태 업데이트:
- 현재 상태를 다음 상태로 업데이트: s = s'

7. 중요도 샘플링을 사용한 오프-정책 TD 학습

1. 기본 벨만 방정식 (Target Policy π₁ 기준)

의미:
- Target Policy π1 하에서 상태 s의 가치 함수 Vk+1(s)를 계산한다.
- 모든 행동 a와 다음 상태 s′에 대한 기댓값을 고려한다.
용도:
- 정책 π1의 성능을 평가할 때 사용된다 (정책 평가).

2. Importance Sampling 적용 버전 (Behavior Policy π₂ 사용)

의미:
- Behavior Policy π2로 수집된 샘플을 재가중하여 π1의 가치 함수를 추정한다.
- Importance Sampling Ratio

용도:

Off-policy 학습에서 Target Policy와 Behavior Policy가 다를 때 사용된다.

3. 샘플 기반 근사 (Monte Carlo 추정)

의미:
- 실제 경험으로 얻은 샘플 (s,a,r,s′)에 Importance Sampling Ratio를 곱해 평균을 낸다.
- E^는 샘플 평균 연산자이다.
특징:
- 모델 불필요 (Model-Free): 전이 확률 p(s′∣s,a)를 몰라도 적용 가능하다.

이 방정식들은 중요도 샘플링 비율을 사용하여 다른 정책(π₂)을 따르면서 하나의 정책(π₁)에 대한 가치 함수를 학습하는 방법을 보여준다.

구조적 이해

Q-learning은 다음과 같은 특성을 가진 오프-정책 강화학습 알고리즘이다:

탐색을 위해 행동 정책(주로 ε-탐욕 정책)을 사용한다.
목표 정책(최적/탐욕 정책)을 향해 업데이트한다.
이론적 기반으로 벨만 최적성 방정식을 사용한다.
경험한 전이(transition)를 기반으로 Q값을 반복적으로 개선한다.
결국 최적 행동-가치 함수로 수렴한다.

기본 Q-learning 알고리즘은 Q값을 초기화한 후 반복적으로:

ε-탐욕 정책을 사용하여 행동을 선택한다.
보상과 다음 상태를 관찰한다.
시간적 차이 공식을 사용하여 Q값을 업데이트한다.
최적값에 수렴할 때까지 계속한다.

Q-learning 알고리즘 구조도

초기화 단계에서 Q(s,a) 값을 랜덤하게 설정.
현재 상태를 관찰.
ε-greedy 정책을 사용해 행동을 선택:
- 확률 1-ε로 가장 높은 Q값을 가진 행동을 선택 (탐욕적 행동)
- 확률 ε로 무작위 행동을 선택 (탐색)
선택한 행동을 환경에 적용.
행동 후 보상과 다음 상태를 관찰.
Q값을 업데이트합니다: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]
종료 조건을 확인:
- 미달성 시 다시 2단계로 돌아감.
- 수렴 시 다음 단계로 진행함.
최종적으로 최적 정책을 도출: π*(s) = argmax Q(s,a)

|인증|

-------

패스트캠퍼스 링크

https://bit.ly/4hTSJNB