HYE_bang.log

[바닥부터 배우는 강화학습] - Chapter 9. 정책 기반 에이전트 2 (Actor-Critic)

Fri, 06 Mar 2026 11:16:58 GMT

딥러닝과 정책 함수가 결합하면 강력한 정책 네트워크를 만들어 냅니다. 이번 챕터에서는 보상 및 밸류 네트워크를 이용해 직접적으로 정책 네트워크를 학습하는 방법에 대해 알아보겠습니다. 이는 수많은 최신 강화학습 알고리즘의 뿌리가 되는 방법론입니다.

9.3 액터-크리틱

Actor-Critic : 정책 네트워크와 밸류 네트워크를 함께 학습하는 이론

Q 액터-크리틱

$\nabla_\theta J(\theta)=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * Q{\pi_\theta}(s,a)]$
- REINFORCE 알고리즘은 여기서 $Q_{\pi_\theta}(s,a)$ 자리에 그 샘플의 리턴 $G_t$를 사용함
- $Q_{\pi_\theta}(s,a)$를 리턴 $G_t$로 대체하지 않고 그대로 사용한것이 Q 액터-크리틱임
- $Q_{\pi_\theta}(s,a)$는 미지의 함수이기 때문에, w로 파라미터화된 뉴럴넷 $Q_w(s,a) \approx Q_{\pi_\theta}(s,a)$를 도입함
  - 즉, $\theta$로 파라미터화된 정책 네트워크 $\pi_\theta$와 w로 파라미터화된 밸류 네트워크 $Q_w$ 이렇게 2개의 뉴럴넷을 함께 학습함

$\pi_\theta$는 실행할 액션 a를 선택하는, 즉 행동하는 액터(actor) 역할이고, $Q_w$는 선택된 액션 a의 밸류를 평가하는 크리틱(critic) 역할임
에이전트의 학습 과정에서 정책 $\pi_\theta$와 밸류 Q를 모두 학습하는 방식을 액터-크리틱이라고 함

Q Actor-Critic pseudo code

정책, 액션-밸류 네트워크의 파라미터 $\theta$와 w를 초기화

상태 s를 초기화

액션 $a \sim \pi_\theta(a|s)$를 샘플링

스텝마다 다음(A~E)을 반복

A. a를 실행하여 보상 r과 다음 상태 s'을 얻음
B. $\theta$ 업데이트: $\theta \leftarrow \theta + \alpha \nabla_\theta \log \pi_\theta(s,a) * Q_w(s,a)$
C. 액션 $a' \sim \pi_\theta(a'|s')$를 샘플링
D. w 업데이트: $w \leftarrow w + \beta (r + \gamma Q_w(s',a') - Q_w(s,a))\nabla_w Q_w(s,a)$
E. $a \leftarrow a', ; s \leftarrow s'$

정책 네트워크 $\pi_\theta$와 밸류 네트워크 $Q_w$가 함께 학습됨
핵심은 $\theta$를 업데이트할 때 실제 보상 값이 전혀 쓰이지 않고 오로지 크리틱 $Q_w$에 의존하여 학습이 이루어지는 점임

어드밴티지 액터-크리틱

$\nabla_\theta J(\theta)=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * Q{\pi_\theta}(s,a)]$
- $\nabla_\theta \log \pi_\theta(s,a)$은 벡터이고, $Q_{\pi_\theta}(s,a)$는 스칼라 값임 (상태 s에서 액션 a를 하고 얻게 되는 리턴의 기대값)
여기서 문제가 애초에 s'이 매우 좋은 상태일경우, s'에서 어떤 액션을 택하든 이후에 얻게 되는 리턴이 높은 상황이됨
- ex) $Q(s', a_0)=1000$, $Q(s', a_1)=1050$ 인 상황
- 이때 policy gradient 식을 이용해 업데이트하면 둘 다 비슷하게 강화됨.
  - $a_1$이 근소하게 크기 때문에 확률차이가 발생하긴하는데 그러기 위해서는 수많은 샘플을 필요
  - 샘플을 무한히 많이 모아서 계산하면 해결할 수 있긴 하지만 “효율적인가”하는 부분에서는 고민을 해야함
- 즉, s'에서는 $a_0$보다 $a_1$이 더 좋은 액션인데 둘 다 강화됨
$\nabla_\theta J(\theta) = \mathbb{E}{\pi_\theta}\left[\nabla_\theta \log \pi_\theta(s,a) * \left{Q{\pi_\theta}(s,a) - V_{\pi_\theta}(s)\right}\right]$
- 위와 같이 모든 상태에서 업데이트할 때, 각 상태의 밸류인 $V_{\pi_\theta}(s)$를 빼서 해결함
- $Q_{\pi_\theta}(s,a)-V_{\pi_\theta}(s)$는 상태 s에 있는 것보다 액션 a를 실행함으로써 “추가”로 얼마의 가치를 더 얻게 되는 것인지를 의미함 → 이 값을 어드밴티지(advantage) $A_{\pi_\theta}(s,a)$라고 함
$A_{\pi_\theta}(s,a)\equiv Q_{\pi_\theta}(s,a)-V_{\pi_\theta}(s)$
- $V_{\pi_\theta}(s)$를 기저(baseline) 라고 함
- 상태 s에 도착하는 사건은 이미 벌어진 일이기 때문에 주어진 것으로 받아들이고, 거기서 액션 a를 했을 때 현재보다 미래가 어떻게 변화하는 가를 통해 액션의 확률을 수정하는 것

$V_{\pi_\theta}(s)$를 빼도 되는가?
- 기존 수식에서 $V_{\pi_\theta}(s)$를 뺄 수 있으려면 다음이 성립해야함

$\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * Q{\pi_\theta}(s,a)]$
$= \mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * {Q{\pi_\theta}(s,a)-V_{\pi_\theta}(s)}]$
$= \mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi _\theta(s,a) * Q{\pi_\theta}(s,a)] - \mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * V{\pi_\theta}(s)]$
즉, $\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * V{\pi_\theta}(s)]=0$

증명

사실 $V_{\pi_\theta}(s)$를 빼도 괜찮을 뿐만 아니라 상태 s에 대한 그 임의의 함수를 빼도됨
- 어떤 함수가 액션 a에 대한 함수가 아니기만하면 됨
상태 s에 대한 임의의 함수를 B(s)라고 할때, B(s)는 상태 s를 넣었을때 숫자 값 하나를 리턴하는 함수임
- $V_{\pi_\theta}(s)$는 B(s)의 특별한 경우
상태 s에 관한 임의의 함수 B(s)에 대해 다음이 성립함
- $\mathbb{E}_{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * B(s)] = 0$
먼저 상태 분포(state distribution) $d_\pi(s)$를 정의
- 상태 분포는 정책 $\pi$를 따라서 움직이는 에이전트가 각 상태에 평균적으로 머무는 비율을 나타내는 분포 → 즉, 정책 $\pi$가 정해져야 정의될 수 있는 분포임
- 어떤 정책 $\pi$를 이용해 움직이는 에이전트를 출발점에 놓고 종료 상태에 도착할 때까지 그 경로를 총 3번 그린것 → 상태별 방문 빈도를 나타낸 것이 $d_\pi(s)$임
- 이 상태 분포 $d_{\pi_\theta}(s)$를 이용해 기존에 구했던 기댓값을 풀어 쓸 수 있음
  - 이 $d_{\pi}(s)$는 1-스텝 MDP의 d(s)와 같음 → 1-스텝에서는 시작하는 상태에서 바로 종료 상태로 가기 때문에 시작하는 상태의 분포가 곧 $d_{\pi}(s)$이기 때문
$\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * B(s)] = \sum{s\in S} d_{\pi_\theta}(s)\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta \log \pi_\theta(s,a) * B(s)$
- 존재하는 모든 상태에 대해 각 상태에 있을 확률과 각 상태에서 어떤 액션을 선택할 확률을 곱하여 더해줌 (기대값의 정의)

증명

$\sum_{s\in S} d_{\pi_\theta}(s)\sum_{a\in A}\pi_\theta(s,a)\nabla_\theta \log \pi_\theta(s,a) * B(s)$
$= \sum_{s\in S} d_{\pi_\theta}(s)\sum_{a\in A}\pi_\theta(s,a)\frac{\nabla_\theta \pi_\theta(s,a)}{\pi_\theta(s,a)} * B(s)$
$= \sum_{s\in S} d_{\pi_\theta}(s)\sum_{a\in A}\nabla_\theta \pi_\theta(s,a) * B(s)$
$= \sum_{s\in S} d_{\pi_\theta}(s)B(s)\sum_{a\in A}\nabla_\theta \pi_\theta(s,a)$
$= \sum_{s\in S} d_{\pi_\theta}(s)B(s)\nabla_\theta \sum_{a\in A}\pi_\theta(s,a)$
$= \sum_{s\in S} d_{\pi_\theta}(s)B(s)\nabla_\theta 1$
= 0
$\therefore; \mathbb{E}_{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * B(s)]=0$

어드밴티지 액터-크리틱의 Policy gradient는 다음과 같게 됨
- $\nabla_\theta J(\theta)=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * A{\pi_\theta}(s,a)]$
  - $A_{\pi_\theta}(s,a)=Q_{\pi_\theta}(s,a)-V_{\pi_\theta}(s)$
어드밴티지를 사용하여 policy gradient를 계산하면 분산이 줄어들어 훨씬 안정적인 학습이 가능함
- $Q_{\pi_\theta} \approx Q_w$ , $V_{\pi_\theta} \approx V_\phi(s)$
- 실제 가치 함수를 알 수 없기 때문에 뉴럴넷을 이용하여 근사함
즉, 학습을 위해선 3개의 뉴럴넷을 필요함
- 정책 함수 $\pi_\theta(s,a)$의 뉴럴넷 $\theta$
- 액션-가치 함수 $Q_w(s,a)$의 뉴럴넷 w
- 가치 함수 $V_\phi(s)$의 뉴럴넷 $\phi$

Advantage Actor-Critic pseudo code

3쌍의 네트워크 파라미터 $\theta$, w, $\phi$를 초기화

상태 s를 초기화

액션 $a \sim \pi_\theta(a|s)$를 샘플링

스텝마다 다음(A~F)을 반복 A. a를 실행하여 보상 r과 다음 상태 s'을 얻음
B. \theta 업데이트 : $\theta \leftarrow \theta + \alpha_1 \nabla_\theta \log \pi_\theta(s,a) * {Q_w(s,a)-V_\phi(s)}$
C. 액션 $a' \sim \pi_\theta(a'|s')$를 샘플링
D. w 업데이트: $w \leftarrow w + \alpha_2 (r + \gamma Q_w(s',a') - Q_w(s,a))\nabla_w Q_w(s,a)$
E. $\phi$ 업데이트: $\phi \leftarrow \phi + \alpha_3 (r + \gamma V_\phi(s') - V_\phi(s))\nabla_\phi V_\phi(s)$
F. $a \leftarrow a',; s \leftarrow s'$

즉, 정책 네트워크와 밸류 네트워크, 액션-밸류 네트워크가 함께 학습함
- 밸류 네트워크는 모두 TD방식으로 학습

TD 액터-크리틱

Q 액터-크리틱에 비해 어드밴티지 액터-크리틱은 그라디언트 추정치의 변동성을 줄여줌으로써 학습 효율에 이점이 있지만, $\pi_\theta,$ $V_\phi$, $Q_w$ 이렇게 3쌍의 뉴럴넷을 필요로 하기 때문에 구현이 복잡하고 학습이 오래걸리는 단점이 존재함
V(s)의 TD 에러 $\delta$는 다음과 같음
- $\delta = r + \gamma V(s') - V(s)$
여기서 상태 s에서 어떤 액션 a를 실행했을 때 $\delta$의 기댓값을 계산하면
- $\mathbb{E}_\pi[\delta|s,a] = \mathbb{E}_\pi[r + \gamma V(s') - V(s)|s,a]$ $= \mathbb{E}_\pi[r + \gamma V(s')|s,a] - V(s)$ $= Q(s,a) - V(s) = A(s,a)$
즉, TD 에러인 $\delta$의 기댓값이 어드밴티지 A(s,a)와 동일함
- $\delta$는 A(s,a)의 불편 추정량(unbiased estimate)임
- $\delta$ 값은 같은 상태 s에서 같은 액션 a를 선택해도 상태 전이 확률에 따라 매번 다른 값을 얻는데, 이 값을 모아서 평균내면 그 값이 A(s,a)로 수렴한다는 뜻임
$\nabla_\theta J(\theta)=\mathbb{E}_{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * \delta]$
- $\delta$는 상태 가치 함수 V만 있으면 계산할 수 있는 값이기 때문에 Q가 없어도 계산이 가능함

TD Actor-Critic pseudo code

정책, 밸류 네트워크의 파라미터 $\theta$와 $\phi$를 초기화

액션 $a \sim \pi_\theta(a|s)$를 샘플링

스텝마다 다음(A~E)을 반복 A. a를 실행하여 보상 r과 다음 상태 s'을 얻음
B. $\delta$를 계산: $\delta \leftarrow r + \gamma V_\phi(s') - V_\phi(s)$
C. $\theta$ 업데이트: $\theta \leftarrow \theta + \alpha_1 \nabla_\theta \log \pi_\theta(s,a) * \delta$
D. $\phi$ 업데이트: $\phi \leftarrow \phi + \alpha_2 \delta \nabla_\phi V_\phi(s)$
E. $a \leftarrow a',; s \leftarrow s'$

TD Actor-Critic 구현

Summary

$\nabla_\theta J(\theta)$
$=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * Q{\pi_\theta}(s,a)] \quad #\ \text{Policy Gradient Theorem}$
$=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * G_t] \quad\quad\quad#\ \text{REINFORCE}$
$=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * Q_w(s,a)] \quad #\ \text{Q Actor Critic}$
$=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * A_w(s,a)] \quad #\ \text{Advantage Actor Critic}$
$=\mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * \delta] \quad\quad\quad\quad #\ \text{TD Actor Critic}$

앞의 $\nabla_\theta \log \pi_\theta(s,a)$까지는 같고 뒤에 어떤 값이 곱해지느냐에 따라 차이가 생김

policy gradient : 실제 가치 함수인 $Q_{\pi_\theta}$를 사용하여 계산하면 그것이 곧 목적 함수 $J(\theta)$의 그라디언트와 같음을 이용
REINFORCE : 리턴 $G_t$가 $Q_{\pi_\theta}$의 샘플이었기 때문에 $G_t$를 대신 사용
Q Actor-Critic : $Q_{\pi_\theta}$ 자리에 뉴럴넷을 이용해 학습한 $Q_w$를 사용
Advantage Actor-Critic : Q Actor-Critic에서 그라디언트 추정치의 분산을 줄이고자 Advantage($A_w$)를 사용
TD Actor Critic : $\delta$가 Advantage의 샘플임을 이용하여 $\delta$를 대신 사용

1단계. 자동 apt 개입 막기

백그라운드 apt가 또 끼어들면 다시 꼬입니다.

sudo systemctl stop apt-daily.service apt-daily-upgrade.service
sudo systemctl mask apt-daily.service apt-daily-upgrade.service

확인:

systemctl is-active apt-daily.service apt-daily-upgrade.service

둘 다 inactive 또는 unknown 비슷하게 나오면 됩니다.

2단계. 문제 서비스 막기

지금 사진상 핵심은 binfmt-support.service 쪽입니다.

sudo systemctl stop binfmt-support.service
sudo systemctl disable binfmt-support.service
sudo systemctl mask binfmt-support.service

확인:

systemctl status binfmt-support.service

masked이면 됩니다.

3단계. dpkg 꼬인 상태 복구

먼저 현재 상태 점검:

sudo dpkg -C
sudo dpkg --audit

그다음 복구:

sudo dpkg --configure -a

이게 또 중간에 멈추면, 로그 저장 방식으로 다시 돌리세요.

sudo dpkg --configure -a > ~/dpkg-configure.log 2>&1
tail -n 100 ~/dpkg-configure.log

4단계. 깨진 의존성 복구

sudo apt-get check
sudo apt-get -f install

멈추면 이것도 로그로:

sudo apt-get -f install > ~/apt-fix.log 2>&1
tail -n 100 ~/apt-fix.log

5단계. binfmt-support 패키지 상태 확인

dpkg -l | grep binfmt

여기서 ii가 아니고 iU, iF, rc 같이 이상한 상태면 정리해야 합니다.

재설치 시도

sudo apt-get install --reinstall binfmt-support

이게 또 멈추거나 실패하면 제거 후 복구:

sudo apt-get remove --purge binfmt-support
sudo dpkg --configure -a
sudo apt-get -f install

6단계. ROS 관련 패키지 설치 상태 확인

지금 ros-melodic-desktop-full 설치 도중 멈춘 거라 상태를 봐야 합니다.

dpkg -l | grep ros-melodic

패키지가 반쯤 걸쳐 있으면 우선 전체 configure부터 끝내는 게 맞습니다. 그래서 보통은 ROS를 바로 다시 설치하지 말고, 위 3~5단계를 먼저 끝내야 합니다.

7단계. ROS 설치 다시 시도

위 복구가 끝난 뒤에만 다시:

sudo apt update
sudo apt install ros-melodic-desktop-full

설치 중 화면이 멈추는지 보려면 그냥 실행해도 되지만, 지금 환경은 불안정하니 로그로 남기는 걸 추천합니다.

sudo apt install ros-melodic-desktop-full > ~/ros-melodic-install.log 2>&1
tail -n 100 ~/ros-melodic-install.log

8단계. 설치 끝나면 환경설정

설치가 끝났다면:

echo "source /opt/ros/melodic/setup.bash" >> ~/.bashrc
source ~/.bashrc

확인:

roscore --version

또는

which roscore

9단계. 자동 apt 다시 풀기

복구와 설치가 다 끝났을 때만:

sudo systemctl unmask apt-daily.service apt-daily-upgrade.service

한 번에 복붙용

아래는 핵심 복구 묶음입니다.

sudo systemctl stop apt-daily.service apt-daily-upgrade.service
sudo systemctl mask apt-daily.service apt-daily-upgrade.service

sudo systemctl stop binfmt-support.service
sudo systemctl disable binfmt-support.service
sudo systemctl mask binfmt-support.service

sudo dpkg -C
sudo dpkg --audit
sudo dpkg --configure -a
sudo apt-get check
sudo apt-get -f install

dpkg -l | grep binfmt
dpkg -l | grep ros-melodic

[바닥부터 배우는 강화학습] - Chapter 9. 정책 기반 에이전트 1 (Policy Gradient)

Fri, 06 Mar 2026 11:15:49 GMT

9.1 Policy Gradient

가치 기반 에이전트가 액션을 선택하는 방식은 결정론적(deterministic)임
- 즉, 모든 상태 s에 대해 각 상태에서 선택하는 액션이 변하지 않음
- 학습이 끝나면 Q(s,a)의 값이 고정되기 때문임
정책 기반 에이전트는 확률적 정책(stochastic policy)을 취할 수 있음
- 정책 함수의 정의가 $\pi(s,a) = \mathbb{P}[a \mid s]$ 임으로 즉, 상태 s에서 할 수 있는 액션에 대한 확률 분포를 가리키기 때문임
만약 액션 공간(action space)이 연속적(continuous)인 경우 즉, 0에서 1 사이의 모든 실수값이 액션으로 선택될 수 있는 상황일때
- 가치 기반 에이전트가 작동하려면 모든 $a \in [0,1]$에 대해 Q(s,a)의 값을 최대로 하는 입력 a를 찾아야함 → 이 자체로 하나의 최적화 문제가 되기 때문에 연속적 액션 공간에서는 Q(s,a) 기반 에이전트가 작동하기 힘듬
- 정책 기반 에이전트는 $\pi(s)$가 주어져 있다면 바로 액션을 뽑아줄 수 있기 때문에 문제없음
- 또한 정책 기반 방법론이 가치 기반 방법론에 비해 환경에 숨겨진 정보가 있거나, 환경 자체가 변하는 경우에도 더 유연하게 대처할 수 있음

목적 함수 정하기

(정책 네트워크를 $\pi_\theta(s,a)$로, $\theta$는 정책 네트워크의 파라미터로 표현)
목표는 환경에 $\pi_\theta(s,a)$로 움직이는 에이전트를 가져다 놓아 경험을 쌓게 하고, 그 경험으로부터 $\pi_\theta(s,a)$를 계속해서 강화하는 것임
- $\pi_\theta(s,a)$를 업데이트 한다는 것은 결국 뉴럴넷의 파라미터를 업데이트 하는 것이니 그라디언트 디센트 방법론을 사용함 → 손실 함수를 정의 해야 사용 가능

$\pi_\theta(s,a)$의 손실 함수를 어떻게 정의하지...?

손실 함수가 정의되어야 이를 줄이는 방향으로 파라미터를 업데이트있는데, 손실 함수를 정의하려면 먼저 정답지가 정의되어야 됨 (뉴럴넷의 예측값과 실제 정답 사이의 차이기 때문)
정책 함수의 정답이란 것이 곧 최적 정책인데, 최적 정책를 알면 강화학습을 하는 이유가 없음
- 즉, 손실 함수를 줄이는 방향이 아니라, 정책을 평가하는 기준을 세워서 그 값을 증가시키도록 하는 방향으로 그라디언트 업데이트를 함 → 그라디언트 어센트(gradient ascent)

목표는 주어진 정책 네트워크 $\pi_\theta(s,a)$에 대해 이 정책이 얼마나 좋은 정책인지 평가하는 방법을 찾는 것 → 이때 평가 함수를 $J(\theta)$라고 함
- $\pi$를 인풋으로 받아 점수를 리턴하는 함수이고, $\pi$가 곧 $\theta$에 의해서 표현되기 때문에 $\theta$만 인풋으로 들어감
- 이 함수를 알 수 있다면 이 함수의 값을 증가시키는 방향으로 그라디언트 어센트를 진행 할 수 있음
하지만, $\pi$가 고정되어도 에피소드마다 서로 다른 상태를 방문하고 서로 다른 보상를 받기 때문에 정책을 평가하기 위해서는 기대값 연산자가 필요함
- $J(\theta)=\mathbb{E}_{\pi_\theta}\left[\sum_t r_t\right]$
- 보상의 합에 기댓값을 취한 것이 곧 $J(\theta)$임
이는 시작하는 상태가 $s_0$로 항상 고정되어 있다면 $s_0$의 가치로 볼 수 있음
- $J(\theta)=\mathbb{E}{\pi_\theta}[\sum_t r_t]=v{\pi_\theta}(s_0)$
- 즉, $J(\theta)$는 $s_0$의 밸류로 표현 가능함
만약 시작하는 상태가 $s_0$로 고정된 것이 아니라 매번 다른 상태에서 출발한다고 가정할 경우, 시작 상태 s의 확률 분포 d(s)가 정의되어야함
- $J(\theta)=\sum_{s\in S} d(s),v_{\pi_\theta}(s)$
- 모든 상태 s에 대하여 해당 상태에서 출발했을 때 얻을 가치를 해당 상태에서 출발할 확률과 곱하여 가중 합을 해준 것

$\nabla_\theta J(\theta)$를 구하여 “$\theta' \leftarrow \theta + \alpha * \nabla_\theta J(\theta)$” 를 실행하면 $J(\theta')$의 값은 $J(\theta)$보다 증가하게 됨
- 이 과정을 반복하면 최적 정책의 파라미터 $\theta^*$를 찾을 수 있음 → 이를 그라디언트 어센트라고함
- 그라디언트 디센트가 손실 함수를 최소화하기 위해 그라디언트를 계산하여 그 반대 방향으로 파라미터를 업데이트 했다면, 그라디언트 어센트는 목적 함수를 최대화하기 위해 그라디언트를 계산하여 그라디언트 방향으로 파라미터를 업데이트함

1-Step MDP

1-Step MDP : 한 스텝만 진행하고 바로 에피소드가 끝나는 MDP
- 처음 상태 $s_0$에서 액션 a를 선택하고 보상 $R_{s,a}$를 받고 끝나는 것
- 처음 상태 $s_0$는 확률분포 d(s)를 통해 정해짐 → $s_0 \sim d(s)$
$J(\theta)=\sum_{s\in S} d(s),v_{\pi_\theta}(s) =\sum_{s\in S} d(s)\sum_{a\in A}\pi_\theta(s,a),R_{s,a}$
- d(s) : 존재하는 모든 상태 s에 대해 s가 첫 상태가 될 확률
- $v_{\pi_\theta}(s)$는 s에서 모든 액션 a에 대해 a를 선택할 확률과 그 때 발생하는 보상을 곱해서 더해주면 됨
$\nabla_\theta J(\theta)=\nabla_\theta \sum_{s\in S} d(s)\sum_{a\in A}\pi_\theta(s,a),R_{s,a}$
- 양변에 그라디언트 취한것
- 하지만 $R_{s,a}$를 모르기 때문에 계산할 수 없음 (사실 알아도 continuous action space라 못함)

샘플 기반 방법론을 활용하여 계산 진행

$\nabla_\theta J(\theta) = \nabla_\theta \sum_{s\in S} d(s)\sum_{a\in A}\pi_\theta(s,a),R_{s,a}$
$= \sum_{s\in S} d(s)\sum_{a\in A}\nabla_\theta \pi_\theta(s,a),R_{s,a}$
$= \sum_{s\in S} d(s)\sum_{a\in A}\frac{\pi_\theta(s,a)}{\pi_\theta(s,a)},\nabla_\theta \pi_\theta(s,a),R_{s,a}$
$= \sum_{s\in S} d(s)\sum_{a\in A}\pi_\theta(s,a),\frac{\nabla_\theta \pi_\theta(s,a)}{\pi_\theta(s,a)},R_{s,a}$
$= \sum_{s\in S} d(s)\sum_{a\in A}\pi_\theta(s,a),\nabla_\theta \log \pi_\theta(s,a),R_{s,a}$
$= \mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a),R{s,a}]$

기대값 연산자 $\mathbb{E}_{\pi_\theta}$ 덕분에 “샘플 기반 방법론”을 활용해 계산 할 수 있음
- $\pi_\theta(s,a)$에 대한 기댓값이기 때문에 $\pi_\theta(s,a)$로 움직이는 에이전트를 환경에 가져다 놓고, $\nabla_\theta \log \pi_\theta(s,a) * R_{s,a}$의 값을 여러 개 모으면 됨
$\nabla_\theta \log \pi_\theta(s,a)$는 뉴럴넷의 그라디언트이기 때문에 쉽게 계산할 수 있으며, $R_{s,a}$는 s에서 a를 선택하고 얻는 보상을 관측하기만 하면 됨
- 상태전이마다 1개의 $\nabla_\theta \log \pi_\theta(s,a) * R_{s,a}$ 값을 계산할 수 있고, 이 값을 모아서 평균을 내면, 그 평균이 곧 $\nabla_\theta J(\theta)$와 같음
이게 가능한 이유는 $\nabla_\theta \log \pi_\theta(s,a),R_{s,a}$을 기댓값 연산자 형태로 바꿨기 때문임
- 수식 앞에 $\sum \pi_\theta(s,a)$가 곱해진 형태이기 때문
  - $\sum \pi_\theta(s,a)$가 곱해져 있으면 이는 곧 그 뒤에 나올 값에 $\pi_\theta(s,a)$만큼의 가중치를 곱해서 더해주라는 뜻이고, 이는 곧 기댓값 연산자 $\mathbb{E}_{\pi_\theta}$의 정의이며, 이 부분이 policy gradient의 핵심임

일반적 MDP에서의 Policy Gradient

1 step MDP : $\nabla_\theta J(\theta) = \mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * R{s,a}]$

MDP : $\nabla_\theta J(\theta) = \mathbb{E}{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * Q{\pi_\theta}(s,a)]$ → “Policy Gradient Theorem”
$R_{s,a}$가 $Q_{\pi_\theta}(s,a)$로 바뀜. s에서 a를 할 때 받는 보상 대신, s에서 a를 할 때 얻는 리턴의 기댓값으로 바꾼 것 → 한 스텝만 진행하고 MDP가 끝나는 것이 아닌 이후 여러 스텝이 존재하기 때문
이 식을 Policy Gradient Theorem이라고 함
- Policy gradient : 목적함수 $J(\theta)$에 대한 그라디언트를 $\pi_\theta(s,a)$가 경험한 데이터를 기반으로 계산할 수 있게 해주는 방법론

9.2 REINFORCE 알고리즘

이론적 배경

$\nabla_\theta J(\theta)=\mathbb{E}_{\pi_\theta}[\nabla_\theta \log \pi_\theta(s,a) * G_t]$
- 기존 수식의 $Q_{\pi_\theta}(s,a)$ 자리에 그 샘플의 리턴 $G_t$가 들어감
  - $G_t$는 $Q_{\pi_\theta}(s,a)$의 정의 때문에 편향되지 않은 샘플임
  - $Q_\pi(s,a)=\mathbb{E}[G_t \mid s_t=s, a_t=a]$이기 때문에, $G_t$의 샘플을 여러 개 모아서 평균을 내면 그 식이 실제 $Q_{\pi_\theta}(s,a)$에 근사해지기 때문

REINFORCE pseudo code

$\pi_\theta(s,a)$의 파라미터 $\theta$를 랜덤으로 초기화

다음(A~C)을 반복

A. 에이전트의 상태를 초기화: $s \leftarrow s_0$
B. $\pi_\theta$를 이용하여 에피소드 끝까지 진행, ${s_0, a_0, r_0, s_1, a_1, r_1, \ldots, s_T, a_T, r_T}$을 얻음
C. $t = 0 \sim T$에 대해 다음을 반복
- $G_t \leftarrow \sum_{i=t}^{T} r_i * \gamma^{i-t}$
- $\theta \leftarrow \theta + \alpha * \nabla_\theta \log \pi_\theta(s_t, a_t) * G_t$

$\pi_\theta$로 에피소드 하나에 해당하는 데이터를 얻고, 해당 데이터로 $\theta$를 업데이트하고, 업데이트된 $\pi_\theta$를 이용해 또 다음 에피소드의 경험을 얻고, 그 데이터로 또 강화하고, 이 과정을 계속해서 반복
$\nabla_\theta \log \pi_\theta(s,a) * G_t$
- 리턴이 음수일 경우, 그 리턴을 반환하는 액션의 확률은 감소시키도록 업데이트됨
- 만약 양수만 존재할 경우, 더 큰 값을 더 크게 업데이트 함 → $\pi_{\theta}(s,a)$의 아웃풋은 확률이기 때문에 값을 모두 더하면 1인데 즉, 리턴이 더 좋았던 쪽의 액션이 더 많이 강화되어 더 확률이 올라감

Q : $\nabla_\theta \log \pi_\theta(s,a)$ 대신 $\nabla_\theta \pi_\theta(s,a)$를 사용해도 될까요?

$\nabla_\theta J(\theta) \ne \mathbb{E}_{\pi_\theta}[\nabla_\theta \pi_\theta(s,a) * G_t]$이기 때문에 안됨
- 아까 말한 샘플 기반 방법론 기반 변환 수식을 보면
  
  $\nabla_\theta J(\theta) = \sum_{s\in S} d(s)\sum_{a\in A}\nabla_\theta \pi_\theta(s,a),R_{s,a}$ $\nabla_\theta J(\theta) \ne \sum_{s\in S} d(s)\sum_{a\in A}\pi_\theta(s,a),\nabla_\theta \pi_\theta(s,a),R_{s,a}$
- 임으로 사실 그냥 다른 식임

REINFORCE 구현

$\nabla_\theta J(\theta) \approx G_t * \nabla_\theta \log \pi_\theta(s_t, a_t)$
- 데이터를 이용하여 계산해야 하는 gradient 식
- 식은 $G_t$라는 상수에 $\log \pi_\theta(s_t, a_t)$의 그라디언트가 곱해져있지만, 파이토치나 텐서플로같은 라이브러리는 미분된 형태의 수식을 사용하지 않음
DQN에서 구현할 땐 아래처럼 $\nabla_\theta L(\theta)$에 대한 수식이 아니라 $L(\theta)$에 대한 수식을 사용함
- $L(\theta)=(r+\gamma \max_{a'} Q_\theta(s',a')-Q_\theta(s,a))^2$
- $\nabla_\theta L(\theta)\approx-\left(r+\gamma \max_{a'} Q_\theta(s',a')-Q_\theta(s,a)\right)\nabla_\theta Q_\theta(s,a)$
$G_t * \log \pi_\theta(s_t, a_t)$
- $\theta$에 대한 항이 $\pi_\theta(s_t,a_t)$뿐이기 때문에 그냥 $\nabla_\theta$ 연산자를 지워버리면 $L(\theta)$가 됨
라이브러리의 optimizer는 손실 함수를 자동으로 minimize하는 방향으로 업데이트 하지만 REINFORCE 알고리즘은 gradient ascent를 사용하기 때문에 maximize하는 방향으로 업데이트 해야함
- $-G_t * \log \pi_\theta(s_t, a_t)$
  - 즉, 위 값을 minimize하는 것은 곧 $G_t * \log \pi_\theta(s_t,a_t)$를 maximize하는 것

[바닥부터 배우는 강화학습] - Chapter 8. 가치 기반 에이전트

Sun, 22 Feb 2026 18:37:48 GMT

신경망을 이용해 액션 밸류 네트워크를 학습하면 그게 곧 하나의 애이전트가 될 수 있습니다. 아타리 게임을 플레이 하던 DQN이 바로 이 방식입니다. 이번 챕터에서는 가치 함수만을 가지고 움직이는 에이전트, 즉 가치 기반 에이전트에 대해 알아보겠습니다.

이번 문제는 더이상 제약 조건이 없는 상황임
- 여전히 Model-free이며
- 상태공간(state space)과 액션 공간(ation space)이 매우 커서 밸류를 테이블에 담지 못하는 상황 → 신경망 사용
강화학습에 신경망을 사용하는 대표적인 2가지 방법론
- $v_{\pi}(s)$나 $q_{\pi}(s, a)$를 신경망으로 표현 하는 방식
- 함수 $\pi(a|s)$ 자체를 신경망으로 표현하는 방식

가치 기반(value-based) : 에이전트가 가치 함수에 근거하여 액션을 선택함
- 즉, q(s, a)의 값을 통해 액션을 선택하는 것
- 가치 기반 에이전트는 액션을 선택할 때 가치 함수만 있으면 되므로, 정책 함수를 따로 정의 하지않음
  - ex) SARSA, Q-Learning
정책 기반(policy-based) : 에이전트가 정책함수 $\pi(a|s)$를 보고 직접 액션을 선택함
- 밸류를 통해서 액션을 선택하지 않으며, 가치 함수를 따로 정의하지 않음
- $\pi$만을 통해 MDP에서 경험을 쌓고 활용하며, 학습 과정에서 $\pi$를 강화함
액터-크리틱(actor-critic) : 가치 함수와 정책 함수를 모두 사용함
- actor는 “행동하는 주체”, 즉 정책 $\pi$를 의미하며, critic은 “비평가”, 즉 v(s) 또는 q(s,a)를 의미함
- 이름 그대로 행동하는 $\pi$와 평가하는 v(혹은 q)가 함께 존재함

8.1 밸류 네트워크의 학습

밸류 네트워크(value-network) : 뉴럴넷으로 이루어진 가치 함수 $v_{\theta}(s)$
- $\theta$ : 뉴럴넷의 파라미터. 만약 뉴럴넷에 포함된 파라미터가 100개 라면 세타는 길이가 100인 벡터임 (처음엔 랜덤으로 초기화 되어있음)
상태별 별류의 값을 $v_{\text{true}}(s)$라고 가정했을 때 손실함수를 다음과 같이 표현 할 수 있다
- $L(\theta) = (v_{\text{true}}(s) - v_\theta(s))^2$
- 이는 어떤 s에 대해 위 값을 계산할 것인지에 대해 정의를 하지 않았기 때문에 엄밀한 정의는 아님
모든 상태 s에 대해서 $L(\theta)$를 최소화하기 매우 어렵기 때문에 다음과 같이 정의함
- $L(\theta) = \mathbb{E}\pi[(v{\text{true}}(s) - v_\theta(s))^2]$
- 여기서 기댓값 연산자 $\mathbb{E}\pi$*는 정책 함수 $\pi$를 이용해 방문했던 상태 s에 대해 $(v{\text{true}}(s) - v_\theta(s))^2$*를 계산하라는 뜻
$\pi$를 이용해 데이터를 모으고 그 데이터를 이용해 학습하면, 손실 함수에서 $\pi$가 자주 방문하는 상태의 가중치는 더 높아지고, $\pi$가 거의 방문하지 않는 상태의 가중치는 낮아지는 성질이 추가됨

$\nabla_\theta L(\theta) = - \mathbb{E}\pi[(v{\text{true}}(s) - v_\theta(s))\nabla_\theta v_\theta(s)]$
- $v_{\text{true}}(s)$는 상수이기 때문에 체인 룰(chain rule)을 사용하여 얻을 수 있는 식인 $\frac{d}{dx}{c - f(x)}^2 = -2{c - f(x)}\cdot \frac{d}{dx}f(x)$임을 이용
  - (앞에 곱해지는 상수 2는 생략) → 상수값은 나중에 $\alpha$를 이용해 조절 가능
$\mathbb{E}\pi[(v{\text{true}}(s) - v_\theta(s))\nabla_\theta v_\theta(s)]$의 값을 실제로 계산하려면 $\pi$를 이용하여 움직이는 에이전트를 통해 샘플을 뽑아야함
- $\nabla_\theta L(\theta) \approx -(v_{\text{true}}(s) - v_\theta(s)),\nabla_\theta v_\theta(s)$
  - $\pi$가 상태 s를 방문했다고 가정하고, 이 과정을 여러 번 반복하면 우변이 좌변으로 수렴함
이후 $\theta$ 업데이트 진행
- $\theta' = \theta - \alpha \nabla_\theta L(\theta) = \theta + \alpha (v_{\text{true}}(s) - v_\theta(s)),\nabla_\theta v_\theta(s)$
- $v_{\text{true}}(s)$가 없으면 손실 함수를 정의할 수 없어 그라디언트 계산이 불가능함 → MC, TD 활용하여 해결

첫 번째 대안 : 몬테카를로 리턴

MC : 시점 t에서 시작하여 에피소드가 끝날 때까지 얻은 감쇠된 누적 보상을 리턴 $G_t$를 이용하여 업데이트하는 방식
$V(s_t) \leftarrow V(s_t) + \alpha\big(G_t - V(s_t)\big)$
- 실제 가치 함수의 정의가 곧 $G_t$의 기대값이기 때문에 $v_{\text{true}}(s)$대신 사용 가능
$L(\theta) = \mathbb{E}_\pi\left[\left(G_t - v_\theta(s_t)\right)^2\right]$
- 뉴럴넷을 업데이트하려면 손실 함수를 정의해야함 → $v_{\text{true}}(s)$대신 $G_t$사용
$\theta' = \theta + \alpha\big(G_t - v_\theta(s_t)\big)\nabla_\theta v_\theta(s_t)$
- 이후 $\theta$ 업데이트 진행

두 번쨰 대안 : TD 타깃

TD : 한 스텝 더 진행해서 추측한 값을 이용하여 현재의 추측치를 업데이트하는 방식
$L(\theta)=\mathbb{E}\pi[(r{t+1}+\gamma v_\theta(s_{t+1})-v_\theta(s_t))^2]$
- TD 타깃인 $r_{t+1} + \gamma v_\theta(s_{t+1})$ 활용
$\theta'=\theta+\alpha\left(r_{t+1}+\gamma v_\theta(s_{t+1})-v_\theta(s_t)\right)\nabla_\theta v_\theta(s_t)$
- 이후 $\theta$ 업데이트 진행
여기서 $r_{t+1} + \gamma v_\theta(s_{t+1})$ 값은 변수가 아닌 상수임 (MC도 동일)
- $v_\theta(s_{t+1})$ 항이 포함되어 있지만, 업데이트 시점의 $\theta$를 이용하여 $r_{t+1} + \gamma v_\theta(s_{t+1})$의 값을 계산할 경우 상수로 취급됨 → 편미분 값 : 0
- 만약, 상수로 취급하지 않을 경우 업데이트 되는 값과 목표가 함께 움직이기 때문에 학습이 매우 불안정해짐

8.2 딥 Q러닝

가치 기반 에이전트는 명시적 정책(explicit policy)이 따로 존재하지 않음
- $\pi$를 사용하지 않고, q(s, a)를 활용하여 액션을 선택하기 때문
  - 즉, 정책은 암묵적 정책(implicit policy)임

이론적 배경 - Q러닝

Q러닝 : 벨만 최적방정식을 이용해 최적의 $Q_*(s,a)$를 학습함

$Q_(s,a)=\mathbb{E}{s'}[r+\gamma \max{a'} Q_(s',a')]$ $Q(s,a)\leftarrow Q(s,a)+\alpha(r+\gamma \max_{a'} Q(s',a')-Q(s,a))$

딥 Q러닝은 Q러닝에 뉴럴넷으로 환장한것
- 즉, Q(s,a)가 아닌 $Q_{\theta}(s,a)$로 표기
$L(\theta)=\mathbb{E}[(r+\gamma \max_{a'} Q_\theta(s',a')-Q_\theta(s,a))^2]$
- $r+\gamma \max_{a'} Q(s',a')$를 정답으로, 이것과 $Q_\theta(s,a)$ 사이 차이의 제곱을 손실 함수로 정의함
- 손실 함수를 정의할 때에는 기댓값 연산자($\mathbb{E}$)가 반드시 필요
  - 같은 s에서 같은 a를 선택한다 하더라도 매번 다른 상태에 도달할 수 있기 때문
$\theta'=\theta+\alpha(r+\gamma \max_{a'} Q_\theta(s',a')-Q_\theta(s,a))\nabla_\theta Q_\theta(s,a)$
- 실제 뉴럴넷을 업데이트할 때는 샘플 기반 방법론으로 $\mathbb{E}$를 무시하고 계산함
- 이 식을 통해 $\theta$를 계속해서 업데이트해 나가면 $Q_\theta(s,a)$는 $Q_*(s,a)$에 가까워짐

기댓값 연산자를 없애기 위해 여러 개의 샘플을 뽑아서 그 평균을 이용해 업데이트를 진행하는데, 이처럼 복수의 데이터를 모아 놓은 것을 미니 배치(mini-batch)라고 함
- 미니 배치 업데이트 : 미니 배치를 이용해 업데이트 하는 방식
“하나의 미니 배치를 구성하는 데 몇 개의 데이터를 사용할 것인가”를 미니 배치 사이즈(mini-batch size)라고 함
- 미니 배치의 크기가 커질수록 더 정확한 그라디언트를 계산할 수 있지만, 한 번에 소모해버리는 데이터가 많아짐

딥 Q러닝 pseudo code

$Q_\theta$의 파라미터 $\theta$를 초기화

에이전트의 상태 s를 초기화 $(s \leftarrow s_0)$

에피소드가 끝날 때까지 다음(A~E)를 반복 A. $Q_\theta$에 대한 $\varepsilon$-greedy를 이용하여 액션 a를 선택 B. a를 실행하여 r과 s'을 관측 C. s'에서 $Q_\theta$에 대한 greedy를 이용하여 액션 a'을 선택 D. $\theta$ 업데이트: $\theta \leftarrow \theta + \alpha(r + \gamma Q_\theta(s', a') - Q_\theta(s,a))\nabla_\theta Q_\theta(s,a)$ E. $s \leftarrow s'$

에피소드가 끝나면 다시 2번으로 돌아가서 $\theta$가 수렴할 때까지 반복

환경에서 실제로 액션을 선택하는 부분 : 3-A
TD 타깃의 값을 계산하기 위한 액션을 선택하는 부분 : 3-C
- 실제로 실행되지 않고, 업데이트를 위한 계산에만 사용
- 행동 정책($\varepsilon$-greedy $Q_{\theta}$)과 타깃 정책(greedy $Q_{\theta}$)는 서로 다름
손실함수에서 한 번 미분된 형태 : 3-D
- 라이브러리를 사용할 경우 계산할 필요없이, 손실함수만 정의함
  - $L(\theta)=\left(r+\gamma \max_{a'} Q_\theta(s',a')-Q_\theta(s,a)\right)^2$

익스피리언스 리플레이와 타깃 네트워크

DQN(Deep Q-Network)
- DQN paper (nature)
- 본질은 뉴럴넷을 활용하여 Q함수를 강화하는것
- 논문에서는 학습을 안정화하고 성능을 끌어 올리기 위해 2가지 방법을 사용함
  - 익스피리언스 리플레이(Experience Replay)와 타깃 네트워크(Target Network)

익스피리언스 리플레이(Experience Replay)

Experience Replay는 과거의 겪었던 경험을 재사용하는것
- 경험은 여러 개의 에피소드로 이루어져 있고, 에피소드는 여러 개의 상태 전이(transition 또는 트랜지션)로 이루어져있음
하나의 상태 전이 $e_t$는 ($s_t, a_t, r_t, s_{t+1}$)로 표현 가능
- “상태 $s_t$에서 액션 $a_t$를 했더니 보상 $r_t$을 받고 다음 상태 $s_{t+1}$에 도착 하였다” → 하나의 상태 전이가 곧 하나의 데이터임
낱개의 데이터를 재사용하기 위해 리플레이 버퍼(replay buffer)사용
- 버퍼에 가장 최근 데이터 n개를 저장하는 것
- 학습할 때는 이 버퍼에서 임의의 데이터를 뽑아서 사용함 → 랜덤하게 뽑다 보면 각각의 데이터가 여러 번 재사용될 수 있음 (데이터 효율성 증가)
- 또한 랜덤하게 데이터를 뽑다 보면 하나의 미니 배치 안에서 서로 다른 데이터들이 섞이게됨
  - 연속된 데이터를 사용할 때 보다 각각의 데이터 사이 상관성(correalation)이 작아서, 더 효율적으로 학습할 수 있음

별도의 타깃 네트워크(Target Network)

손실 함수 $L(\theta)$의 직관적 의미는 정답과 추측 사이의 차이이며, 이 차이를 줄이는 방향으로 $\theta$가 업데이트 됨
하지만, Q러닝에서는 $R + \gamma \max_{A'} Q_\theta(S', A')$이 정답으로 사용되기 때문에 정답이 $\theta$에 의존적임
- $\theta$가 업데이트 될 때마다 정답에 해당하는 값이 계속해서 변함
- 뉴럴넷을 학습할 때 정답지가 자주 변하는 것은 학습의 안정성을 매우 떨어뜨림

타겟 네트워크의 아이디어 : 정답을 계산할 때 사용하는 네트워크인 타깃 네트워크와 학습을 받고 있는 Q 네트워크, 이렇게 두 개의 네트워크를 준비하고, 정답지를 계산할 때 사용하는 네트워크의 파라미터를 잠시 얼려두는 것
- 변하지 않도록 얼린 파라미터 $\theta_i^{-}$를 고정해놓고 정답지를 계산하면 정답이 안정적인 분포를 가지게 됨
- 그 사이 학습을 받고 있는 네트워크의 파라미터는 $\theta_{i+1}, \theta_{i+2}, \cdots$ 이렇게 계속해서 업데이트 됨
- 그리고 일정 주기마다 얼려 놓았던 $\theta_i^{-}$를 최신 파라미터로 교체함
즉, 학습 도중에는 똑같이 생긴 두 쌍의 파라미터가 사용됨
- 학습 대상이 되는 Q네트워크의 파라미터 $\theta_t$와 정답지 계산에 쓰이는 파라미터 $\theta_i^{-}$가 공존하게됨

DQN 구현

OpenAI Gym 카트폴 구현
- 오른쪽, 왼쪽 항상 2가지의 액션
- 스텝마다 +1의 보상을 받으며, 막대를 넘어뜨리지 않고 오래 균형을 잡아야 보상이 최대가 됨
- 막대가 수직으로 부터 15도 이상 기울어지거나, 카트가 화면 끝으로 나가면 종료
- 카트의 상태 s는 길이 4의 벡터
  - s = (카트의 위치, 카트의 속도, 막대의 각도, 막대의 각속도)

forward 함수의 뉴럴넷 구조
- 상태 s를 의미하는 길이 4의 인풋 벡터가 들어가며, 모든 액션에 대한 각 액션의 밸류인 Q(s,a)를 리턴함
- 카트폴에서 선택할 수 있는 액션은 2개이기 때문에 아웃풋의 차원은 2임
Q함수 구현하는 방식
1. s와 a를 한번에 인풋으로 받아 그 밸류를 리턴하는 형태
2. s만 인풋으로 받아 모든 액션에 대한 밸류값들을 한 번에 리턴하는 형태 → 원래 DQN 논문의 구현 방식

결과

[바닥부터 배우는 강화학습] - Chapter 7. Deep RL 첫걸음

Sun, 22 Feb 2026 18:34:31 GMT

커다란 MDP의 세계를 항해하기 위해서 우리에게는 또 다른 무기가 하나 필요합니다. 바로 “딥러닝”입니다. 딥러닝과 강화 학습이 만나 Deep RL이라는 유연하고도 범용적인 방법론이 탄생합니다. 이번 챕터에서는 먼저 딥러닝에 대한 이야기부터 시작합니다.

7.1 함수를 활용한 근사

테이블 기반 방법론으로 학습을 하려면 상태 s마다 그에 해당하는 밸류를 적어 놓기 위해, 총 상태의 개수만큼 테이블이 커져야함
- ex) 체스 : $10^{47}$, 바둑 : $10^{170}$ → 10의 170승만큼의 상태가 존재
- 상태의 개수가 무한해지는 경우도 있음 (ex- 속도)
연속적인 상태 공간(continuous state space) : 상태값이 바둑이나 체스처럼 이산적(discrete)일 수도 있지만, 실수 범위 내에서 연속적인 값을 가질 수도 있음
- 상태 공간이 연속적이면 테이블을 만들기 불가능함

함수의 등장

함수 $f(x) = ax + b$ 에 v(s)나 q(s, a)를 저장한다고 가정했을때, (100, 1), (200, -10)은
- $f(s_0) = f(100) = 1, f(s_1) = f(200) = -10$ 로 표현 가능함
- 이를 통해 a와 b의 값을 추정하면 a = -0.11, b = 12임
s와 v(s)의 쌍의 데이터를 통해서 파라미터 a,b의 값을 조정하는 것임
즉, $f$는 상태 값을 인풋으로 받아 가치 값을 내놓는 함수가 되므로, 이를 실제 가치 함수의 근사 함수(function approximator)라고 할 수 있음
- $f(s) = \hat{v_{\pi}}(s)$

데이터가 많아지면 모든 선을 지나는 직선을 그릴 수 없음 → 모든 점들을 가장 “가깝게” 지나는 선으로 표현함
최소제곱법(least squares) : 각각의 데이터를 $(x_1, y_1), (x_2, y_2), \ldots, (x_{30}, y_{30})$이라고 표현한다면
- $(f(x_1)-y_1)^2 + (f(x_2)-y_2)^2 + \cdots + (f(x_{30})-y_{30})^2$
- 위의 식(=오차의 제곱의 합)을 최소화하는 a와 b를 찾는 방법론
  - 데이터의 개수와 무관하게 표현한다면 각 오차의 제곱 합을 평균내고, MSE(Mean Squared Error(평균제곱오차))를 최소화하는 것
$\mathrm{MSE}= \frac{1}{30}\left( (f(x_1)-y_1)^2 + (f(x_2)-y_2)^2 + \cdots + (f(x_{30})-y_{30})^2 \right)$ $= \frac{1}{30}\left( (ax_1+b-y_1)^2 + (ax_2+b-y_2)^2 + \cdots + (ax_{30}+b-y_{30})^2 \right)$
MSE를 최소화하는 a와 b를 구하여 그린 $f(x)$
함수의 곡선이 데이터에 가깝게 지나도록 피팅(fitting)해야함 → 선형식 만이 최선은 아님

함수의 복잡도에 따른 차이

$f(x) = a_0 + a_1 x$ $f(x) = a_0 + a_1 x + a_2 x^2$ $\cdots$ $f(x) = a_0 + a_1 x + a_2 x^2 + \cdots + a_n x^n$

1차 함수에서 n차 함수로 차수가 점점 올라갈수록 함수는 더 유연해지고, 더 복잡한 데이터에도 피팅할 수 있음
“함수를 피팅한다”의 의미
- 함수에 데이터를 기록한
- 데이터 점들을 가장 가깝게 지나도록 함수를 그려본다
- 함수 $f$의 파라미터 $(a_0 \sim a_n)$의 값을 찾는다.
- 함수 $f$를 학습한다

1차, 4차, 16차 함수를 이용한 피팅 결과의 평균 에러(MSE)는 각각 0.3, 0.03, 0.00000002임
- 하지만, 데이터에는 노이즈(noise)가 섞여있기 때문에 무조건 차수가 높은 함수가 좋은 것은아님

오버 피팅과 언더 피팅

오버 피팅(over fitting) : $f$를 정할 때, 너무 유연한 함수를 사용하여 $f$가 노이즈에 피팅해버리는 것
언더 피팅(under fitting) : 실제 모델을 담기에 함수 $f$의 유연성이 부족하여 주어진 데이터와의 에러가 큰 상황
MDP에서도 똑같은 정책 $\pi$로 똑같은 상태 s에서 출발하여도 매번 다른 리턴을 받음 → 노이즈
데이터를 생성하는 함수 F를 찾는것이 목표임
- 상태에 따른 리턴의 쌍이 모두 데이터가 되며 여기서 데이터를 생성해준 함수 F는 가치함수 $v_{\pi}(s)$가 됨
임의의 F에 대한 식
- $F(x) = cos(1.5\pi * x) + x$
실제 데이터를 생성하는 함수 $F_{real}(x)$도 F에 노이즈 $\varepsilon$을 추가하여 정의함
- $F_{\text{real}}(x) = F(x) + \varepsilon = \cos(1.5\pi x) + x + \varepsilon$, ($\varepsilon \sim N(0,1)\cdot \frac{1}{10}$)
  - $\varepsilon$은 표준 정규 분포에서 샘플링된다고 가정

30개의 쌍$(x, F_{real}(x))$를 통해 표현함
- 빨간색 선 : 1차~16차함수까지의 f를 설정하여 학습시킴
- 초록색 선 : $F(x)$
- 파란색 점 : $F_{real}(x)$로부터 샘플링된 값
목표 :초록색 선과 가장 가까워지도록 하는 빨간 선을 찾는것
- 1차 함수는 프리 파라미터(free-parameter)가 적기 때문에 유연하지 못함 → 언더 피팅
- 16차 함수는 모든 데이터를 가장 에러 없이 학습했지만, 과하게 유연하여 $F_{real}$이 가지고 있는 노이즈까지 모두 정확하게 학습하게됨 → 오버 피팅

함수의 장점 - 일반화

문제가 커질 경우, 테이블에 모든 v(s)나 q(s,a)를 저장할 수 없음
- 그렇기 때문에 실제 v(s)를 모방하는 함수 $f$를 학습 시킨것
즉, 함수를 통해 일반화(generalization)를 잘 해야함
새로운 데이터가 추가된 경우, 테이블 기반 방법론을 사용하면 새로운 상태에 대한 값이 비어있기 때문에 어떤 밸류를 갖게 될지 알 수 없음
- 하지만 함수를 통해 일반화를 진행할 경우(일반화가 잘 된 경우) 처음 보는 데이터에 대해서도 예측을 통해 알 수 있음

언더 피팅된 1차 함수와 오버 피팅된 16차 함수 모두 새로운 데이터를 일반화하여 표현하는 성능이 매우 부족함
- 여기서 빨간 선을 그리는 데에 노란색 데이터는 아예 사용되지 않음

7.2 인공 신경망의 도입

신경망

인공 신경망(Artificial Neural Network) : 신경망의 본질은 매우 유연한 함수인 것 → 매우 유연하기 때문에 세상의 어떤 복잡한 관계에도 피팅할 수 있음
- 함수에 포함된 프리 파라미터의 개수를 통해 함수의 유연성을 표현할 수 있는데, 신경망의 경우 100만 개가 넘음
  - (Large Model의 경우 1000억 개 이상)
이러한 인공 신경망을 통해 상태별 가치 값을 담는 것이 Deep RL 학습임

크기가 3인 벡터를 인풋으로 받아 값 하나를 리턴하는 신경망
$y = f(x_1, x_2, x_3)$ 형태로 표현 가능
- 히든 레이어(hidden layer)가 두 층이 쌓여 있고, 각각의 히든 레이어는 여러 개의 노드(node)로 구성됨
- 즉, 노드가 신경망의 기본 구성 단위임

노드는 해당 노드로 들어오는 값들을 선형 결합(linear combination)한 후에 비선형 함수(non-linear activation)를 적용함
해당 노드로 들어오는 3개의 값($x_1, x_2, x_3$)을 선형결합 하여 $w_1x_1 + w_2x_2 + w_3x_3 + b$의 값으로 만든 후 비선형 함수 g(x)를 통과 시킴
- 대표적인 비선형 함수 : RELU(rectified linear unit)
  - RELU : $g(x) = (max(0,x))$
선형 결합 : 새로운 피쳐(feature)를 만드는 과정. 이 피쳐는 인풋 벡터의 피쳐보다 한층 더 추상화(abstract)된 피처임
- 학습에 필요한 피쳐가 있다면 신경망의 파라미터들이 알맞은 값으로 학습됨
비선형 함수 : 인풋과 아웃풋의 관계가 비선형 관계일 수 있기 때문에 사용됨
- 선형 관계만 학습하게 되면 신경망의 표현력이 실제 자연의 많은 문제를 표현하기 어려움
즉, 신경망을 학습 한다는 것은 신경망을 구성하는 파라미터들인 w와 b의 값을 찾는 과정임

신경망의 학습 - 그레디언트 디센트

빨간 곡선 : 랜덤하게 초기화된 $f$
- 현재 w로는 $f_w(3) = 1$을 만족하지 않음
신경망의 $f_w(3)$ 값과 실제 값의 차이를 계산하기 위해, w에 대한 함수를 L(w)로 표현 할 수 있음
- $L(w) = (1 - f_w(3))^2$
- L(w)는 신경망의 아웃풋이 주어진 데이터로부터 틀린 정도를 나타내기 때문에 손실 함수(loss function)이라고 함
L(w)를 계산하기 위해선 w의 영향력을 알아야함
- w를 조금 증가시키거나 감소시켰을 때 함수 L(w)의 값이 어떻게 바뀌는지 확인하는 것 → 미분(derivative)
- L(w)를 w로 미분한것이 곧 w가 L(w)에 미치는 영향력임
신경망에는 여려 개의 w가 존재 하기 때문에 영향력을 평가하기 위해서는 L(w)를 각각의 파라미터에 대해 미분해야함 → 이를 편미분(partial derivative)이라고 함

$\nabla_w L(w) = (\frac{\partial L(w)}{\partial w_1}, \frac{\partial L(w)}{\partial w_2}, \cdots, \frac{\partial L(w)}{\partial w_{100}})$

그라디언트(gradient) : $f$를 $w_1$부터 $w_{100}$까지 각각의 파라미터에 대해 편미분하여 벡터를 만든것
- w를 그라디언트 방향으로 아주 조금씩 이동 시킴
w를 얼만큼 이동시킬지는 $\alpha$라는 상수를 통해 정해짐
$\alpha$는 업데이트 크기를 결정하는 상수로, 러닝 레이트(learning rate) 혹은 스텝 사이즈(step size)라고 부름
- 목적 함수를 최소화하기 위해서 그라디언트에 $\alpha$라는 상수를 곱하여 원래 값에서 빼 줌

$w_1' = w_1 - \alpha \frac{\partial L(w)}{\partial w_1}$ $w_2' = w_2 - \alpha \frac{\partial L(w)}{\partial w_2}$ $\cdots$ $w_{100}' = w_{100} - \alpha \frac{\partial L(w)}{\partial w_{100}}$

위 100개의 식을 벡터를 이용해 한 줄로 표현
- $\mathbf{w}' = \mathbf{w} - \alpha \nabla_w L(w)$
그라디언트 디센트(gradient descent(경사 하강법)) : 그라디언트를 계산하여 파라미터를 업데이트하는 방식으로 목적함수를 최소화 해나가는 과정

간단한 확인

모델(함수) 정의

$f_w(x_1,x_2)=w_1x_1-w_2x_2+1$

초기값, 데이터, 목표 설정

초기 파라미터: $w_1=0.5, w_2=1.2$
데이터 한 개: $(x_1,x_2,y)=(1,2,1)$
목표: $f_w(1,2)$가 y=1에 가까워지게 만들기
1. 현재 예측값 계산
$f_w(1,2)=0.5\cdot1-1.2\cdot2+1=0.5-2.4+1=-0.9$
목표와 차이가 큼
1. 손실 함수 정의 (제곱오차)
“정답”과 “예측값”의 차이를 제곱
- $L(w)=(1-f_w(1,2))^2$
여기서 $f_w(1,2)=w_1-2w_2+1$ 이니까
- $L(w) = (1-(w_1-2w_2+1))^2 = (-w_1+2w_2)^2$
전개하면
- $L(w)=w_1^2-4w_1w_2+4w_2^2$
  1. 그라디언트(편미분) 구하기
  - $\frac{\partial L}{\partial w_1}=2w_1-4w_2, \qquad \frac{\partial L}{\partial w_2}=-4w_1+8w_2$
초기값 $w_1=0.5, w_2=1.2$ 대입
- $\frac{\partial L}{\partial w_1}=2(0.5)-4(1.2)=1-4.8=-3.8$
- $\frac{\partial L}{\partial w_2}=-4(0.5)+8(1.2)=-2+9.6=7.6$
그래서
- $\nabla_w L(w)=(-3.8,7.6)$
  1. 경사하강법 업데이트
학습률 $\alpha=0.01$
업데이트 규칙
- $w' = w - \alpha \nabla_w L(w)$
각 파라미터에 적용
- $w_1' = w_1 - \alpha\frac{\partial L}{\partial w_1}=0.5-0.01(-3.8)=0.538$
- $w_2' = w_2 - \alpha\frac{\partial L}{\partial w_2}=1.2-0.01(7.6)=1.124$
  1. 업데이트 후 예측값이 좋아졌는지 확인
  - $f_{w'}(1,2)=0.538\cdot1-1.124\cdot2+1=0.538-2.248+1=-0.71$

이전: -0.9
이후: -0.71
즉, 목표값인 1 방향으로(증가 방향으로) 조금 이동함.

파이토치를 이용한 신경망의 학습 구현

그라디언트 기반 방법론을 쓰려면 $f_w$를 미분 가능한 함수로 정의해야함
- 하지만, 신경망은 매우 복잡하기 때문에 직접 미분할 수가 없음 → 컴퓨터 활용
텐서플로우(Tensorflow), 파이토치(PyTorch) 같은 다양한 자동 미분(auto diff) 라이브러리를 사용해야함
- 이 라이브러리는 역전파(back propagation) 알고리즘을 통해 아주 복잡한 함수여도 그라디언트를 효율적이고 빠르게 구함
- 파이토치 공식 홈페이지 : PyTorch Foundation
사전 정의
- $F(x) = \cos(1.5\pi x) + x + \varepsilon, \qquad \varepsilon \sim U(-0.2, 0.2)$
  - 앞 예제에서 다룬 함수에서 노이즈를 균등 분표로 변형함
- 이 함수는 실제론 알 수 없다고 가정하며, 함수가 만들어 내는 데이터만 관찰 가능함 → 근사가 목표
- 임의로 정한 신경망 구조 ($f_w$)
  - 총 3개의 히든 레이어 + 128개의 노드
  - 각 레이어에 ReLU라는 활성화 함수(activation function) 사용

[청강] 딥러닝 20 - RAG Advanced, LoRA Fine-tuning (끝)

Fri, 06 Feb 2026 04:44:53 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Retrieval Augmented Generation (RAG)

LoRA Code - GitHub

Enhancing RAG with Post-Retrieval Processing

Retriever가 가져온 문서들을 그대로 LLM에 넣지 않고, 한 번 더 가공해서 품질을 올리는 단계
Reranking(정확도 높은 순으로 재정렬), 필터링(중복·무관 문서 제거), chunk 병합/분할, 요약·하이라이트 생성 등을 통해 LLM이 볼 context를 더 짧고, 관련성 높고, 정보 밀도 높은 형태로 만들어 주는 것

Reranking (i.e., Relevance Estimator) (RE-RAG, EMNLP 2024)

RE-RAG Paper

Knowledge Refinement using Summarization and Reranking (RankCoT, ACL 2025)

RankCoT Paper

Advanced Reranker (DynamicRAG, Neurips 2025)

DynamicRAG Paper

Enhancing RAG with Pre-Retrieval Processing

사용자의 raw query를 바로 검색하지 않고, retriever가 이해·매칭하기 좋은 형태로 사전 가공하는 단계
- Query normalization: 소문자 변환, 불용어 제거, 토큰 정규화 등
- Query rewriting / expansion: LLM으로 질문을 풀어서 쓰기, 동의어·관련 키워드 추가, 애매한 표현 명확화
- Query decomposition / routing: 복잡한 질문을 여러 sub-question으로 나누거나, 알맞은 index·도메인으로 라우팅
이런 pre-retrieval processing을 통해 retriever가 더 관련성 높은 문서들을 찾을 수 있게 만들어 RAG 전체 성능을 향상시킴.

Enhancing the Generator in RAG → Generator자체를 향상시키는것도 방법임

Reflection-based RAG (Self-RAG, ICLR 2024)

Self-RAG Paper

Noisy Robustness of RAG LLMs (ACL 2024)

Noisy Robustness of RAG Paper

PA-RAG (NAACL 2025)

PA-RAG Paper

RAG for Specialized Domains (RAG-Studio EMNLP findings 2024)

RAG-Studio Paper

Low Rank Adaptation (LoRA)

Zero Inference Latency
- 기존엔 input 마다 추가로 계산해야함
- W1이 설정된 이후엔 Only one-time addition이 가능
전체 weights를 Full Fine-tuning하는 대신, 적은 수의 파라미터만 학습하고도 동일한 효과를 보임

Adapter Layer

Foundation Model's Original Weights
- pre-trained model의 원래 weight metrics $W_0$
- LoRA fine-tuning 과정에서 이 weight metrics은 Frozen 상태로 유지되며, 업데이트되지 않음
LoRA Weight Changes
- 특정 작업을 학습하며 얻은 weights의 변화량 $\Delta W$
Specialized Model's Fine-tuned Weights
- 원래 가중치($W_0$)와 학습된 변화량($\Delta W$)을 더하여 만들어진 Output weight metrics(W)

Low Rank Adaptation (LoRA)

LoRA의 핵심은 weight metrics를 그대로 학습하는 대신, multiple weight metrics로 decomposition하여 학습 파라미터 수를 줄이는 것임.

LoRA : Rank

Rank(r)는 분해된 두 행렬 사이의 중간 차원을 의미함
rank를 8에서 256 사이로 설정할 때 Approximation 성능에 유의미한 차이가 없음
- 즉, 모델의 특징을 학습하는 데 Low Intrinsic Rank만으로도 충분함

끝!

[청강] 딥러닝 19 - Retrieval Augmented Generation (RAG)

Mon, 19 Jan 2026 03:18:31 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Retrieval Augmented Generation (RAG)

RAG Code - GitHub

RAG(Llama) Code - GitHub

Retrieval Augmented Generation(RAG) : 검색을 증강해서 대답하는 것
- 추가적인 데이터에 대한 fine-tuning없이 LLM이 외부 지식(Website, PDF, 외부 문서 등)을 검색 시스템이 관련 있는 문서/링크만 골라서 리스트업함 → 이후 관련 정보를 모아서 요약·재구성해서 답변 생성

Custom Data to Vector Format

OpenAI Platform guides

Embedding Leaderboard huggingface
AG with Open Source HuggingFace Library (Embedding Model)
- Open AI의 RAG모델이 제일 좋음 (유료)
- Huggingface에서 무료로 사용가능 (Qwen model)

RAG using LangChain

Build a RAG agent with LangChain - Docs by LangChain

DataLoader

Document loaders - Docs by LangChain

TextSplitters

LangChain overview - Docs by LangChain

Store

Local DB such as FAISS by Meta

Faiss - Docs by LangChain
- Cloud DB쓴다면
  - ElasticSearch, Weaviate, Pinecone (보안 조심해야함)

직접 LLM을 구성할때는 Chat History를 Maintaining해야한다 → GPT는 기본적으로 되지만, 직접 만들경우 memory를 기억하는 부분을 넣어줘야함

Retriever

query와 문서를 vector로 embedding해서, dot product / cosine similarity 같은 방법으로 가장 유사한 문서들을 찾아오는 검색 모듈
RAG에서 외부 knowledge(Website, PDF 등)를 LLM에게 가져다주는 역할을 담당함

Contrastive Learning

아이디어 : 기준이 되는 샘플을 anchor라고 두고, anchor와 비슷한 샘플(positive), 다른 샘플(negative)을 구성한다.
학습 목표 : embedding / feature space에서 anchor–positive 쌍은 가깝게 위치하도록 만들고 anchor–negative 쌍은 멀어지도록 만드는 loss를 최소화한다.
직관 : “비슷한 것끼리는 모으고(끌어당기고), 다른 것끼리는 떼어놓는(밀어내는) 방식으로 representation을 학습하는 방법”이 바로 contrastive learning

참고자료

General Usage of LLMs (Reference)

[청강] 딥러닝 18 - Prompting

Mon, 19 Jan 2026 03:13:00 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Prompting

Tips for prompting

ChatGPT Prompt Engineering for Developers - DeepLearning.AI
specific instructions
Specify the steps to complete a task
Use delimiters to clearly separate parts of the input
Consider to use few-shot prompting

System Prompts

LLM에 들어가는 최상위 prompt → query로 input을 넣는것이 아니라 System Prompts로 고정으로 적어 두는 것
- 요즘은 굳이 Special token을 추가해서 System Prompt를 구성하진 않음
  - System Prompts 예시

Few-Shot Learning (Few-Shot Learning Paper)

Post-Processing, Few-shot Prompting 예시

Role Prompting Role Prompting GitHub

Role playing Prompting이 LLM 보안을 뚫을때 악용되기도함

Chain of Thoughts (CoT) Chain-of-Thought Prompting Paper

[청강] 딥러닝 17 - Instruct GPT

Mon, 19 Jan 2026 03:11:36 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Instruct GPT

InstructGPT Code - GitHub

(*참고 : openAI API 없으면 작동 안함)

State-of-the-art Large Language Models

Language Models are Few-Shot Learners
- Prompting : instruction과 input을 어떻게 쓸 지를 설계해서 원하는 output을 유도하는 방법
  - Zero-shot Prompting : 아무런 instruction없이 input만 주는것
  - Few-shot prompting : Prompt 안에 (input, output) 예시들을 추가해주는 것
  - Prompting도 Learning으로 봄
- In-context learning : context안에 있는 설명만으로 새로운 task를 수행할 수 있게 하는것

ChatGPT는 여러 training을 추가하여 사용됨
- GPT-3 + (SFT, RLHF) = InstructGPT
왜 추가적인 작업이 필요한가? → LLM이 misalignment되어있기 때문에
- LLM은 generate하지 않거나, unhelpful하거나, untruthful 혹은 toxic한 생성을 하면 안되는데, 추가적인 training이 없으면 “follow the user’s instructions helpfully and safely”라는 목표에 적합하지 않게됨
- 핵심은 misalignment → alignment로 바꾸는 작업 (ex- hallucination)

Labelers-based data와 User-based data를 모두 사용하여 Dataset을 Construction함

SFT : 특정 query에 대한 answer를 잘 generative하게끔 training하는 것

RLHF (Reinforcement Learning Human Feedback Paper)

크게 PPO vs DPO로 나뉨
PPO (Proximal Policy Optimization)
- PPO는 policy(여기선 language model)를 fine-tuning하는 trainer(optimizer) 역할을 하며, Reward Model(RM)이 높게 점수 주는 출력을 더 잘 만들어 내도록 모델을 조정함.
- RM이 준 reward와 현재 language model의 출력을 받아서, 이 reward를 극대화하는 방향으로 모델 파라미터를 iterative하게 업데이트함.
- 안정성 (KL penalty)
  - fine-tuned 모델과 원래 pretrained 모델 사이의 분포 차이를 KL-divergence term으로 측정해서, 너무 멀리 벗어나지 않도록(regression 방지) regularization을 걸어줌.

PPO-PTX (PPO with Pretrained Transformer Cross-Entropy)
- KL-divergence만으로는 pretrained 모델과의 거리를 충분히 통제하지 못할 수 있음.
- 현재 모델과 original pretrained 모델 사이에 cross-entropy loss를 추가로 걸어서, fine-tuning 동안 언어 모델이 원래 pretrained LM의 분포에서 너무 멀어지지 않도록 한 번 더 강하게 regularization 하는 방식.
PPO-PTX = PPO(RLHF) + “pretrained LM와 비슷하게 말하게 만드는 CE loss” 를 더한 버전.

RLHF를 쓰지않고 SFT만 쓰게 되면 overfitting됨

Reward Model을 어떻게 학습하는가가 매우 중요함 → 너무 어렵고 오래걸림

Evaluation metrics for InstructGPT
- 모델의 유용성(helpful or Appropriateness)
- 모델의 진실성(Truthfulness)
- 모델의 유해성(Toxicity)

참고) hugging face에서 LLM을 불러올땐 미리 신청하고 토큰을 발급받아야함

참고자료

HFRL Optimization

Proximal Policy Optimization Algorithms
- PPO
Direct Preference Optimization: Your Language Model is Secretly a Reward Model
- DPO → PPO가 하던걸 RL없이 loss로 구현한 방법
ARES: Alternating Reinforcement Learning and Supervised Fine-Tuning for Enhanced Multi-Modal Chain-of-Thought Reasoning Through Diverse AI Feedback
- ARES → PPO에 검수하는 teacher를 추가한 방법
  - 선행 연구
    - Multimodal Chain-of-Thought Reasoning in Language Models
DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models
- GRPO → PPO를 Group별로 묶은 방법
Perception-Aware Policy Optimization for Multimodal Reasoning
- PAPO → Visual Feature를 더 잘 이해할 수 있게 하기 위해 PPO에 LOSS term을 추가한 방법

[청강] 딥러닝 16 - GPT, BERT , BART

Mon, 19 Jan 2026 03:08:24 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

GPT, BERT, BART

BERT Code - GitHub

GPT_2 Code - GitHub

+ 오늘의 연구 코멘트

See What You Are Told: Visual Attention Sink in Large Multimodal Models
- Attention Sink 문제를 어떻게 해결할 것인가에 대한 paper
Zebra-CoT: A Dataset for Interleaved Vision Language Reasoning
- visual Reasoning을 가능하게하는 dataset을 만들겠다는 paper

Transformer based Pre-trained Language Models: GPT (GPT Paper)

transformer의 decoder만 사용한 모델
- Autoregressive Language Modeling으로 이전 token만 확인하여다음 token을 prediction하도록 학습됨
- GPT는 unidirectional(단방향)으로 동작해서, 왼쪽에서 오른쪽 방향만 고려하여 prediction함

Transformer based Pre-trained Language Models: BERT (BERT Paper)

transformer의 incoder만 사용한 모델
- Masked Language Modeling : input token을 무작위로 mask하고 context기반으로 prediction하도록 학습됨
- Next Sentence Prediction : 주어진 두개의 sentences가 original text에서 연속되는지 prediction하도록 학습됨
- BERT는 bidirectional(양방향)으로 동작해서, context의 양쪽을 모두 보고 prediction함

Transformer based Pre-trained Language Models: BART BART Paepr

transformer의 incoder와 decoder를 모두 사용한 모델
- 목표는 손상된 input sequences를 재구성 하는것 (seq2seq)
- ex) Token Masking, Token Deletion, Text Infilling, Sentence Permutation, Document Rotation
비슷한 구조로 T5 model도 있음
- 둘다 Seq2Seq(incoder-decoder) model
- 하지만, 각 model마다 architecture나 data processing에서 요구하는 것이 다르기 때문에 task에 맞게 잘 선택해야함

BART로 machine translation을 진행할경우 encoder를 하나더 추가하는 것이 좋음

Pre-trained model : 이미 학습된(Pre-trained) 모델
Fine-tuning : Pre-trained model을 dataset을 추가하여 미세조정(Fine-tuning)하는 것
Transfer Learning : task에 대한 정의가 달라질 경우 task가 전이(Transfer)되었기 때문에 Transfer Learning이라고 함.
- task간의 전이가 일어날때, Catastrophic Forgetting이 자주 발생함

Summary

참고자료

Transformers

Rowan/hellaswag · Datasets at Hugging Face

allenai/swag · Datasets at Hugging Face 다음 sentence에 뭐가 와야되는지 prediction하는 방법으로 학습하는 데이터셋

[청강] 딥러닝 15 - Attention, Transformer

Mon, 19 Jan 2026 02:59:09 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Attention, Transformer

transformer Code - GitHub

+ 오늘의 연구 코멘트

NeurIPS Poster Nested Learning: The Illusion of Deep Learning Architectures
Introducing Nested Learning: A new ML paradigm for continual learning
- catastrophic forgetting issue를 해결하기 위한 continual learning을 재정의한 paper
  - 비슷한 keyword : unknown learning

Neural Machine Translation by Jointly Learning to Align and Translate
기존에 Seq2Seq model은 Encoder step별로 계산하고, 하나의 lest hidden state가 output으로 나오게 되는데, 각각의 hidden state를 모두 사용할 수 없을까를 고안하기위해 Attention이라는 이론이 등장함
- 모든 time-step의 hidden state를 보기때문에 context를 좀 더 정교하게 볼 수 있다 → context vector라고 함
- context vector가 decoder의 input으로 추가됨
이렇게 한 step의 decoder의 hidden state을 업데이트함
- 이때, 알파가 decoder의 time-step마다 새롭게 다시 계산하는 것이 핵심

weight matrix를 Random Initialization하고, 모든 time-step의 hidden state를 붙인것을 dot-product로 계산함 → 이후 softmax를 적용해서 각 time-step에 대한 attention weight T개를 만듬

왜 Attention이 좋은가

model이 어디에 집중(Attention)해야하는지 스스로 배움 → network가 ‘context’를 배워간다

RNN 계열 Seq2Seq에 attention을 붙이면 성능은 좋아지지만, 여전히 sequential processing에 의존하기 때문에 parallelization과 efficiency에 한계가 있음
하지만, self-attention은 한 문장 안의 각 토큰이 자기와 같은 문장에 있는 모든 토큰을 attention으로 볼수 있기 때문에 모든 token이 스스로 source이자 target이 되어 각자 안에서 네트워크가 스스로 배울 수 있음

Attention Is All You Need
Self-Attention의 핵심은 Query, Key, Value임
1. 각 word에 대한 embedding vector를 생성함
2. Query, Key, Value를 각각 담당하는 weight matrix를 생성함 (처음엔 Random Initialization) → $W_Q$, $W_K$, $W_V$
3. 각 word embedding vector와 $W_Q$, $W_K$, $W_V$를 곱해서 각 word에 해당하는 Query, Key, Value의 vector를 구함

각 Query vector마다 문장 안의 모든 Key vector와 dot-product를 해서 score들을 계산함
각 score들을 Key dimension의 제곱근(√d_k)으로 나눔 (실험적으로 이렇게 나누는 것이 학습이 가장 안정적이고 잘 됨)
scale된 score에 softmax를 씌워서 T개의 probability distribution(= attention weight)를 계산함
이 weight들을 각 Value vector에 곱해서, 그 Query에 대한 final output vector를 구함
모든 time-step 대해 위 과정을 수행하고, 이들을 모아서 self-attention layer의 출력 sequence로 사용됨

Self-Attention의 과정은 parallel하게 한번에 진행됨
Multi-head Self-Attention은 Q/K/V weight matrix 세트를 여러 개 두고, 여러 개의 self-attention을 병렬로 돌리는 구조임
- 각 head는 문장 안에서 서로 다른 관계에 집중해서 여러 “관점”을 동시에 보게 해서 더 풍부한 문맥 표현과 성능 향상을 얻는 것이 목적

sequential processing을 하지않고 한번에 계산해서 한번에 사용함 → 굉장히 빠름
- 하지만 순서에 대한 정보를 잃어버림 → 이를 해결하기 위해 Positional Encoding을 추가함

transformer encoder architecture

Self-Attention은 기본적으로 Parallel Processing이기 때문에 현재 token이 미래의 token을 보는 것을 방지하기 위해 오른쪽에 있는 토큰들에 대한 score를 mask해서 softmax 이후 probability가 0이 되도록 만들고, attention을 진행함

Add & Norm

Multi-Head Attention의 input으로 들어갔던 시점의 각 word에 대한 embedding vector를 Multi-Head Attention의 Output에 더 해줌
- 그렇기 때문에 Multi-head Attention의 output의 weight matrix를 곱해 dimension을 맞춰줌
왜 더하는가?
- embedding vector을 그대로 더해 gradient가 shortcut 경로로 흘러 vanishing gradient 문제를 완화함
- attention에서 많이 변형되더라도 원래 input이 더해져 있기 때문에 정보 소실을 줄이고 원래 token 정보가 보존됨
하지만, 단순히 더하는 경우 model이 너무 많은 Feature Space를 handling해야해서 오히려 normalization이 안될 수도 있음 → layer normalization을 적용함
- 그래서 Add & Norm라고 함

여러번의 과정을 거쳐서 나온 최종 encoder의 output이 decoder의 Multi-Head Attention의 input으로 들어감
- encoder의 output은 Key와 Value로, decoder의 output은 Query로 들어가짐
여기서 층이 깊어질수록 (N값) model의 크기가 커짐 (LLM)

Positional Encoding

평범하게 각 Word마다 순서대로 특정 값을 더하게 될 경우, word의 수가 굉장히 많아 지면 word embedding vector의 크기가 매우 커져서 network가 제대로 작동을 안할 수도 있음
그렇기 때문에 주기함수를 사용하여 추가되는 vector의 크기를 크지 않은 값으로 고정시킴

결국 각 word embedding vector마다 순서가 다르다는 것을 의미하게 하고 싶은것이지만 주기함수 특성상 같은 같이 반복됨
- 짝수와 홀수를 각 다른 주기함수로 나누고, 각 dimension별로 상수를 추가하여 주기를 다르게 해서 순서의 차이를 표현함 (d-model은 fixed 값)
Positional Encoding덕분에 transformer based model들은 매우 긴 context들도 처리를 할 수 있게 됨

참고자료

The Illustrated Transformer

Attention in transformers, step-by-step | Deep Learning Chapter 6

[청강] 딥러닝 14 - Text Generation

Mon, 19 Jan 2026 02:56:34 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Text Generation

MachineTranslation Code - GitHub

+ 오늘의 연구 코멘트

Emergent Introspective Awareness in Large Language Models
- language model이 무엇을 알고있는지를 확인하는 paper
  - 그냥 훈련 데이터에서 배운 연기인지, 아니면 진짜 자기 내부 상태를 읽어서 말하는지
Multi-Agent Evolve: LLM Self-Improve through Co-evolution
- 어떻게 하면 LLM이 더 잘 지식을 받아드릴 수 있을까에 대한 paper
RA-DIT: Retrieval-Augmented Dual Instruction Tuning
- instruction tuning에 대한 paper
  - Scaling Instruction-Finetuned Language Models
    - instruction tuning의 시작인 paper

How can we implement a neural language model training framework?

data construction을 진행할 때 주의해야함 (many-to-one)
- pytorch의 경우 내부에서 이미 구현되어있음 → vector의 크기를 맞춰줘야함

ex) RNN

embedding weight matrix를 무조건 구성해야함 → hidden layer의 input으로 들어가서 n-step hidden state로 나옴
이후, Fully connected layer로 들어가 vocab distribution만큼 출력
이후, Ture와 값이 비슷하게 되게끔 Loss를 계산한 뒤, Backpropagation진행 → 이 과정 반복

data construction을 이렇게 진행하는 이유는 sequential processing 하기위함
- 사실 Many-to-Many로 줘도 내부적으로 알아서 처리함
  - 하지만 many-to-one이 좀 더 효율적임

training을 구성했으면 testing도 구성해야함
decoding을 어떻게 할건지에 대한건 매우 많은 알고리즘들이 있음 (ex - greedy decoding)

Text Generation (e.g., Machine Translation)

Machine Translation에서 궁극적인 목표는 sequence x가 주어졌을때 target sequence y를 생성하는 probability를 최대화 하는 것 → Increase the conditional probability

Seq2Seq Model for Text Generation (e.g., Machine Translation) 구조

special token은 필수로 들어가야함 → 문장의 시작과 끝을 명확하게 하기 위함

Greedy decoding

Greedy decoding은 굉장히 단순하고 빠르지만, 항상 optimal한 output이 나오지는 않음

Beam search

top-k의 후보를 두고 계속적으로 확장해나가는 방법 (greedy의 확장판)
- 각 후보는 현재 token과 이전 token들의 누적 probability를 기반으로 결정됨

Top-k Sampling

top-k개의 후보를 선택하여 probability Normaliztion를 진행함 → 정규화된 probability를 기반으로 sampling 함 (greedy가 아니기 때문에 무조건 높은값을 선택하지 않음)

Top-p Sampling

누적 probability가 p 이상이 될 때까지 상위 후보들을 모아 동적으로 후보 집합을 만든 뒤, 그 안에서 probability를 정규화해서 sampling함 (그래서 top-k처럼 후보 개수가 고정돼 있지 않음)

요즘엔 Top-k와 Top-p를 섞어서 같이 쓰기도함

summary

[청강] 딥러닝 13 - Language Model

Mon, 19 Jan 2026 02:55:13 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Language Model

Language_Model Code - GitHub

+ 오늘의 연구 코멘트

Sketch-of-Thought paper

prompting 관련 연구
- VLM 오픈소스 중 대표적인 모델 llama, Qwen이 있는데 Qwen이 좀더 성능이 좋음
- 대형 모델을 학습시켜야 할때 클라우드 서비스 이용하는 것도 방법임
  - Runpod | The cloud built for AI

Language Model

language modeling은 우리가 살고있는 세계의 언어 지식을 model에게 encodeing하는 것 → 자주보이는 sentence Probability를 그렇지 않은 Probability보다 높여가는 것
- probability theory를 적용 → sentence를 하나의 unit으로 보는것이 아닌 timestep별로 쪼개서 Conditional Probability로 적용

(Neural) Language Modeling

핵심은 현실 세계에서 자주 등장하는 sentence의 Probability를 높이는것
- 즉, sequence에 대한 Conditional Probability를 높이는 것이 목표

(Left-to-Right) Language Models

autoregressive language model : 이전 token이 주어졌을때 다음 token의 probability 높이는 방법
- ex) GPT series

(Masked) Language Models

Masked Language Model : sequence 안의 일부 token 위치를 랜덤하게 [MASK]로 가린 뒤, 주변 context를 보고 mask자리의 정답 probability를 prediction하도록 학습하는 방법
- 양방향의 context를 모두 보고 prediction하도록 학습되기 때문에, text generation에 적합하지 않음
- ex) BERT

참고자료

BART Paper

Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer Paper

대표적인 trasformer기반 Text Generation model
- BERT는 Text Classification model (혹은 RoBERTa)

[청강] 딥러닝 12 - Evaluation Metric

Mon, 19 Jan 2026 02:51:07 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Evaluation Metric

Evaluation_Metric Code - GitHub

+ 오늘의 연구 코멘트

최근 연구 동향

Evaluation Metric

perplexity(혼잡도) : text generation에서 next word를 prediction할 때, 몇 개의 word 사이에서 헷갈리는지 → 자주 쓰임
BLEU,ROGUE는 특정 task에서만 쓰임
- BLEU : 내가 번역한 문장 안에, 정답 번역에 있는 “짧은 구(단어 묶음)”가 얼마나 많이/정확히 겹치는지
- ROUGE : 내가 쓴 요약·문장 안에, 정답 요약에 있는 중요 단어/구를 얼마나 빠짐없이 담았는지
최근엔 BLEU,ROGUE을 안쓰고 exact match score를 사용함
- BERGEN: A Benchmarking Library for Retrieval-Augmented Generation
- GitHub - naver/bergen: Benchmarking library for RAG

Recall : 실제 정답 중에 몇개 맞췄는지 (실제 정답 중에서 맞춘 비율)
Precision : 모델이 Prediction한 것 중에 몇개가 정답인지 (예측한 것들 중에서 진짜인 비율)
굳이 외울 필요 없음 → 의미가 중요

dataset이 balance되어서 public하게 공개된 것이 아니라면 Accuracy와 Recall, Precision을 모두 봐야함

제일 대표적으로 Macro F1을 사용함

model이 prediction한 confidence랑, 실제로 맞은 비율이 얼마나 차이 나는지를 측정하는 Evaluation Metric
- Calibration Error을 수치화 한것이 Expected Calibration Error임
- model이 prediction을 과신하기 때문에 생김
  - 즉, model이 prediction한 확률(confidence)과 실제 정답 비율(accuracy) 사이의 간극을 측정하는 것

ECE Example

ROC Curve가 y축에 가까울수록 (혹은 ROC Curve의 아래쪽 넓이가 클수록) 좋은 모델임

Text Generation Evaluation Metric : Perplexity

Sentence의 Perplexity를 구하는것
- output prediction값을 통해서 문장을 구성 → chain-rule
- 어떤 language probability을 구할 때, model이 Produce한 모든 probability를 모두 곱해서 계산함
최종 결과값인 Perplexity값을 통해 model이 몇개의 단어 사이에서 혼동이 왔는지를 알 수 있음

Text Generation Evaluation Metric : BLEU, ROGUE

machine translation task에서 제일 많이 쓰임
- reference : 정답
- hypothesis : model의 prediction값
- 단어들을 보고, hypothesis와 reference을 비교해서 매칭되는 것들을 찾는다

BLEU (Precision based scoring）

BLEU Paper

Precision based로 hypothesis(prediction)를 기준으로(분모로) 계산함
- prediction문장이 짧은 경우 penalty을 추가함

ROGUE (Recall based scoring)

ROGUE Paper

Recall based로 reference(True)를 기준으로(분모로) 계산함
- ROUGE-F1 score : Precision과 Recall을 구한뒤 조화평균을 계산하는것
  - ROGUE는 Recall based인데 이경우 결국 Precision도 계산하는 것이라 ROGUE의 의미가 줄어듬

Text Generation analysis Technique : T-SNE Visualization

BERT 기반으로, word vector(768 dimension)을 2d space로 축소해서 각 단어/문장을 점으로 표현해 visualization하는 방법
- 의미가 비슷한 단어·문장이 실제로 가까이 모이는지, generated text의 분포가 reference와 얼마나 비슷한지 확인 할 수 있음

Overfitting/Underfitting : K-fold Cross-validation

이론적으로는 K-fold cross-validation을 쓸 수도 있지만, 요즘은 benchmark dataset이 미리 정해진 train/validation/test split을 같이 공개해두기 때문에, 제공된 split에 맞춰 training하고 Evaluation을 진행하는 것이 일반적임 → custom dataset이 아닐 경우 쓸일이 없음

[청강] 딥러닝 11 - Normalization, Optimization

Mon, 19 Jan 2026 01:44:15 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Normalization, Optimization

Normalization & Optimization Code - GitHub

+ 오늘의 연구 코멘트

GitHub - ndb796/Deep-Learning-Paper-Review-and-Practice: 꼼꼼한 딥러닝 논문 리뷰와 코드 실습

A Definition of AGI Paper

paper는 Introduction이 제일 중요함
- Introduction : 개념들 정의, 저자들의 관심있어하는 기술들 소개, 이전의 연구들에 대한 한계점 및 저자들의 해결 방안
- 즉, 논리적인 흐름이 중요함
- 논문 읽을때나 무언가를 공부할때는 항상 how(어떻게 했는가)을 공부한 뒤에 why(왜 그렇게 했는가)를 공부하는 것이 좋음

zero-centered가 아닌 문제 해결하는 방법
- zero-centered한 activation function 사용
- input이 항상 positive하지 않게 해주면 됨 → Batch Normalization
Normalization : 베타와 감마를 통해 Flexibility하게 만드는 것

Batch Normalization

Batch Normalization
- input vector가 zero mean이고 unit variance을 가지도록 range를 조정하는 방법
- test Phase때는 train data에서 기록되어진 mean과 variance를 가지고 test input을 Normalization함 (test data 자체를 가지고 Normalization 하는 것이 아님)

Layer Normalization

sequential data processing(texts processing)할 때는 Batch Normalization이 아니라 Layer Normalization을 진행해야함
- Batch Normalization은 data의 sample이 0을 평균으로 가지고, variance가 1을 가지는 distribution에서 뽑아졌다고 가정함. 즉, sample들이 independent하다고 가정하는 것)
  - texts processing에서는 문장안에 각 word가 서로 매우 dependent하기 때문에 사용할 수 없음
Layer Normalization : feature dimension을 따라서 Normalization을 진행하는 방법
- Batch Normalization은 Batch dimension을 따라 진행해서 각 vector들의 dependent한 feature을 무시하게 되지만, Layer Normalization은 feature dimension을 따라 Normalization을 진행하기 때문에 의미 정보가 소실되지 않음

Optimization : Stochastic Gradient Descent

기본적인 Gradient Descent 방법은 모든 data sample을 보고 각각의 step별로 Gradient를 다 계산한 후, 그 Gradient들을 가지고 한번에 update를 하는것

Stochastic Gradient Descent는 모든 Gradient를 다보고 한번에 update를 하는 것이 아니라, Gradient가 계산될 때마다 update을 하는 방법
- problem 1 : 모든 Gradient를 보고 update를 하는 것이 아니기 때문에(batch processing 하기 때문에) Gradient Noise가 누적되어, 학습이 제대로 되지 않을 수도 있음
- problem 2 : Poor Conditioning
  - weight가 어떻게 변하는지에 따라서 Gradient가 너무 많이 변함 → Gradient가 예민하기 때문에 zigzagging behavior이 발생하여 매애애애애우 느려지는 현상이 발생함
    - problem 3 : Local Minima, Saddle Points
    - 결국 Gradient를 통해 update하는것 이기 때문에, gradient=0인 지점이 여러 개 존재할 경우, local minima나 saddle point에 수렴할 수 있음

Optimization: SGD + Momentum

zigzagging behavior와 Local Minima의 문제를 해결하기 위해서 Momentum이라는 velocity를 추가해서 빠져나올 수 있도록함 → 즉, Gradient에 memory가 생기는 것
- problem 1 → velocity 덕분에 gradient estimate에 섞인 noise가 평균화가 되어 해결됨
- problem 2 → velocity가 step을 가속시켜 줘서, gradient 방향이 자꾸 바뀌며 생기는 zigzagging behavior를 줄임
- problem 3 → gradient가 0이어서 local minima나 saddle points에 갇혀 있어도, 이제는 velocity가 있어 그 지점을 빠져 나올 수 있음

AdaGrad : Momentum은 velocity을 update할 때 gradient하나만 가지고 진행했다면, squared gradients로 velocity를 update하는 방법
RMSProp : AdaGrad방법론에서 얼만큼 update할건지 베타를 사용하여 정하는 방법

Adam : Momentum에서 계산하는 방식과 AdaGrad에서 계산하는 방식에서의 benefit들을 가지고와서 합친 방법
AdamW : Adam에서 Weight Decay을 추가한 방법

Monitoring a Learning Procedure

train loss을 확인하고 learning rate조절 (국룰 learning rate : 1e-3, 1e-5)

eval accuracy을 확인하고 갑자기 좋아진 순간 Early Stopping하는 것도 좋음

Hyperparameter Optimization

loss을 확인하기

다른 reference 참고 하기

핵심은 많이 학습해서 많이 확인하기 (노가다)

Learning rate을 크게 바꿔봐야 Learning rate문제인지 code문제인지 알 수 있음
underfitting이 된경우 : Network의 Complexity을 높이는 쪽으로 접근할 수도 있음
제일 중요한것은 data가 얼마나 많은지, 질이 좋은지 확인하는것

[청강] 딥러닝 10 - Regularization

Mon, 19 Jan 2026 01:43:25 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Regularization

Regularization통해 generalization을 잘해야 overfitting을 방지할 수 있음
- model training의 목표는 generalization된 model을 만드는것 → Regularization를 통해 train data를 외워버리는 overfitting issue를 방지해야함
사실 데이터를 많이 모으는것이 제일 좋음

idea : 너무 많은 neuron들이 불필요하게 학습이 되고있기 때문에 몇몇 neuron을 껏다 켰다하자
각 neuron들을 random하게 sampling해서 value를 확인하고, activate할지 deactivate할지 정한다

Training Loss와 eval Loss을 관측하고 특정순간 이후로 지속적으로 eval Loss가 계속 증가하면 중간에 training을 멈춤
너무 성급하게 Early Stopping을 하는것 보다 Loss을 분석하고 learning rate을 조절하는것이 더 옳바른 방법임

Weight Decay는 Weight가 엄청 큰 경우에만 작용하는 regularization technique이다 → 항상 잘 적용되지는 않음
Weight의 크기를 측정하여 loss을 작게 만드는것이 목표
- 즉, Weight가 크지 않으면 Weight Decay가 잘 작동하지 않을 수가 있음

L1 : sparse model에서 유용함
- 중요하지 않은 weight를 0으로 보내서 feature selection 효과를 내고, parameter를 자연스럽게 sparse하게 만들기 때문
L2 : deep learning에서 유용함
- 모든 weight를 부드럽게 shrink시켜서 gradient가 항상 well-define되다보니, backpropagation과 optimization이 안정적이고 generalization을 개선하기 때문

[청강] 딥러닝 9 - Activation Functions

Mon, 19 Jan 2026 01:42:22 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Activation Functions

Activation_Function Code - GitHub

Activation Functions

Basics Activation Functions : Sigmoid, Tanh, ReLU

Sigmoid

neuron이 포화되었는지 확인하는 Activation Function
neuron이 어떤 input이 들어왔을때 반응이 없으면 포화되었다고 함
즉, gradients 정보가 소실됨

Problem 1

neuron이 포화되었는지 빠르게 확인 할 수 있는 benefit이 있지만, 반대로 Sigmoid를 사용했기때문에 neuron이 포화되는 현상이 생김
- ex) input = -6이면 gradient가 0이되버림 → Vanishing Gradient
  
  Problem 2
Sigmoid outputs are not zero-centered
- 모든 input이 다 양수일때, 모든 gradient가 다 양수이거나 음수가 되버릴 수 있음 (not always)
  - gradient의 의미가 없어짐 → 한방향으로만 update됨
- Batch Normalization : 이를 해결하기위해 다 양수이거나 음수가 아니게 변경해주는 것

tanh

Sigmoid의 Problem 2를 해결하기위한 zero-centered 형태인 Activation Function
- 하지만, neuron이 포화되었을때 Still kills the gradients 됨 (Vanishing Gradient)

ReLU

Sigmoid나 tanh의 neuron saturated 이슈를 해결하기 위한 형태의 Activation Function
- negative Value에 대해선 여전하지만, positive 부분에서는 Vanishing Gradient 문제를 해결함

Leaky ReLU

negative Value에 대해서도 해결하기 위한 형태의 Activation Function

ELU (ELU Paper)

모든 이슈들을 해결하기 위한 형태의 Activation Function

그외의 현대의 Activation Function들 → 최근 동향은 여러 Activation Function을 융합하는 형태임
그래서 random하게 Weight Initialization하는것이 중요함

[청강] 딥러닝 8 - Data Exploration, Data Processing

Mon, 19 Jan 2026 01:41:08 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

오늘의 TMI

최근 동향 : 처음부터 Data Exploration & Processing을 진행하는 것이 아닌 pre-trained model을 가져와서 추가적으로 data를 학습함
- BERT: encoder만 쓰는 양방향 masked language model로, 문장 이해·분류용에 특화된 모델
- BART: BERT식 encoder + GPT식 decoder를 합친 seq2seq generation model로, 문장 복원·생성용에 특화된 모델
pre-trained model을 가져와서 fine-tuning할때 사용한 모델에 special tokens의 형식이 어떻게 되어있는지 잘 확인해야함

mixup: Beyond Empirical Risk Minimization

text classification에서 Noiseless Level을 해결하기위한 방법론
- LLM을 이용하여 datasets을 collecting할때, reasoning을 필요로 한 datasets일 경우 noise가 발생함
  
  dblp: computer science bibliography
computer science 분야의 대부분의 논문들 모아둔 사이트
- ICLR : 이론적인 학문을 연구하는 학회
- CVPR, ICCV, ECCV : CV 학회 ACL Anthology
- 저명한 NLP 분야 학회 모아둔 사이트
  - ex) ACL

Data Exploration, Data Processing

Data_Processing Code - GitHub

1. Data Collection

제일 먼저 task를 정의해야함 최대한 논문으로 publish된 dataset을 사용하는 것이 좋음
만약 dataset이 없을 경우 → data scraping

2. Data Pre-Processing

Lowercasing
Special characters, Stopwords remove
- 제거하지 않는것이 최근 트랜드 (transformer 이후 모델)

3. Data Collection: Split into Train/Val/Test sets

dataset을 적절하게 분할 해야함
- 각 class별로 묶은 다음 각 class별로 Train/Val/Test 분할

4. Data Processing: Tokenization

Word Tokenization의 경우 Vocabulary에 없으면 처리하지 못함
→ Character Tokenization : 각 알파벳별로 쪼개서 학습. 하지만, 범위가 너무 커지는 issue가 생김
→ Subwords 단위로 쪼갬
- Subword의 정의는 방법마다 약간씩 다름
- 하지만, Subword 단위로 나뉘게 되면 기존의 단어의 의미를 잘못 예측하거나, 소실될 수도 있음

5. Data Processing: Construct Vocabulary for Encoding

각 Token를 통해 Vocabulary를 만듬
- unique한 word의 index mapping하는 과정

6. Data Processing: Encoding, padding

input_ids을 통해 Vocabulary의 모든 token들을 정수로 변환함
Padding을 통해 모든 sample의 크기를 일관되게 만듬
- 모든 sample의 크기가 다른경우 각각 계산을 해야하지만, 같은 경우 각 Encoding된 vector들을 하나의 Matrix로 만들어서 한번에 처리할 수 있음 (GPU 병렬 연산)
어떤 부분을 집중적으로 봐야하는지 attention mask를 통해 학습전에 표시함

Special Tokens

Language Models이 좀 더 잘 training하기 위해 special toekn을 사용함
- [SEP]: 하나의 입력 안에서 sentences를 구분할 때 쓰는 분리 토큰
- [SOS] / [BOS]: sequence 생성 시작을 알리는 토큰
- [EOS] / <|endoftext|> / : sequence가 여기서 끝났다는 것을 표시하는 토큰
- [UNK]: Vocabulary에 없거나 인식할 수 없는 word를 대신 나타내는토큰
- [CLS]: 전체 문장의 정보를 요약해서 classification 등의 task에 쓰기 위한 특수 토큰
- [MASK] / : 가려진 위치의 word를 모델이 맞추도록 하는 masking 토큰
- [PAD] / : 길이를 맞추려고 빈 자리를 채울 때 쓰는 토큰 → Padding

Pre-trained Language Models leverage special tokens example

매번 이 모든 과정을 거치지 않아도 됨 (ex - AutoTokenizer)

Batch Processing can be done by leveraging DataLoader

data preprocessing을 진행한 후, 이 data를 모델에 사용하기 위해 Chunk 별로 분할함 → batch 단위

summary

GLUE Benchmark

꼭 torch.utils.data.Dataset Class안에서 Encoding을 진행해야함

참고자료

stanfordnlp/sst2 · Datasets at Hugging Face

allenai/swag · Datasets at Hugging Face

GitHub - abisee/cnn-dailymail: Code to obtain the CNN / Daily Mail dataset (non-anonymized) for summarization

GitHub - emorynlp/MRL-2021: English-Korean Parallel Dataset

GitHub - hendrycks/test: Measuring Massive Multitask Language Understanding | ICLR 2021

[청강] 딥러닝 7 - Long Short Term Memory (LSTM), Gated Recurrent Unit (GRU)

Sun, 18 Jan 2026 20:39:52 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Long Short Term Memory (LSTM), Gated Recurrent Unit (GRU)

LSTM&GRU Code - Github

RNN

Gradient를 통해 update를 진행해야 하는데, flow상 Gradient가 폭발하거나 없어져서 Gradient 소실이 발생함
- W_hh가 지속적으로 곱해지기 때문에 무한히 작아지거나, 무한이 커짐
Solution 1 : Gradient Clipping
- Gradient의 범위를 정해서 소실을 최소화함 → task마다 너무 다름
Solution 2 : Change RNN architecture → Long Short Term Memory (LSTM)

Long Short Term Memory (LSTM)

정보를 얼마나 저장할지 정해서 해결함
- 장기기억력이 좋다 : 필요한정보와 버릴정보를 적절히 조절함 → Cell

Sigmoid를 사용하여 weighting 매커니즘을 구현
Tanh는 Non-linearity를 표현하기 위한 activation function

Input gate : 입력을 얼마나 받는지
Forget gate : 이전 time step의 cell memory를 얼마나 잊는지
Output gate : 현재 cell memory를 얼마나 출력하는지
Cell state gate : 입력과 이전 은닉 상태를 얼마나 드러내는지

Element wise multiplication이기 때문에 multiplication의 수가 매우 적어, Backpropagation이 굉장히 빠르고 계산이 안정적임

GRU

LSTM을 gate가 너무 많아 복잡함 → 이를 단순화 한게 GRU
- hidden state 자체의 얼마만큼의 Information flowrk 있어야하는지 관리함

GRU flow에 대한 수식정리

[청강] 딥러닝 6 - Recurrent Neural Network (RNN)

Sun, 18 Jan 2026 18:57:07 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Recurrent Neural Network (RNN)

RNN Code - GitHub

RNN의 issue : Gradient 소실문제 > LSTM
RNN, LSTM, GRU > 어떤 모델을 썼느냐에 따른 차이

FFNN : 일반적인 Deep Learning Model 구조
RNN : 입력이 한방향으로 흐르는것이 아닌 자기자신을 스스로 update하는 과정이 생김
- Time-series data 대한 Processing이 가능
- 이전에 가지고 있던 time step에 대한 상황을 update할 수 있음 → 순차적으로 들어오는 data에 대한 개념을 적용할 수 있게됨

각 time step에 대해 Weight Matrix가 들어감
- 각 step에 대한 Gradient를 구하고 저장해 둠 → 다음 time step의 Weight Matrix를 계산할 때 사용함
- Many-to-Many : 각 time step별로 Loss를 구한 후 마지막에 Final Loss를 계산함

Many-to-One

각 state 별 output Prediction을 계산하는것이 아닌 끝까지 처리 후 마지막 time step에서만 Prediction을 진행함

One-to-Many :

하나의 input이 주어지고 각 time step별로 output이 나오게도 가능함

Many-to-Many

Many-to-Many는 Many-to-One와 One-to-Many를 합쳐서 사용할 수 있음
이런 구조를 Sequence to Sequence라고함
Many-to-One를 Encoder, One-to-Many를 Decoder로 부름
- transformer 이전 Text generation에서 가장 많이 쓰였던 구조

output은 vocabulary size와 동일하게 Scoring해야함
각 W_hh, W_hy, W_xh는 동일함 → sharing됨
Output Matrix에서 가장 큰 값(argmax)을 next word로 Prediction함
- 여기선 greedy하게 고르지만, 다양한 방법론이 존재

기존의 Backpropagation과정은 한 sample마다 진행함
- 전체 sequence를 전달하여 Loss를 계산한 후의 전체 sequence에 대한 Backpropagation를 진행하면 매우 느리고, 메모리를 많이 잡아먹게됨 → Truncated Backpropagation (즉, 잘라서 진행)
기존의 Backpropagation은 1번만 진행하지만, Truncated Backpropagation는 나눈 만큼 진행하게됨

[청강] 딥러닝 5 - Convolutional Neural Network (CNN)

Sun, 18 Jan 2026 18:55:28 GMT

한양대학교 박서연 교수님 - github.io

(한양대학교 박서연 교수님의 딥러닝 수업을 청강 하면서 정리한 내용을 바탕으로 교수님의 허락을 받고 작성하였습니다.)

Convolutional Neural Network (CNN)

CNN Code - GitHub

Fully Connected Neural Network

이전 layer에 있는 모든 피쳐가 다음 layer의 모든 피쳐들에 영향을 준다
한계점 : Weight Matrix가 여러개여도 Stretch input vectors into column이 한 개임
이미지의 경우 공간 정보가 없어져버리는 issue가 생김 -> CNN 등장 이유

Convolutional Neural Network (CNN)

filter를 적용하여 공간 정보를 보존함
- 보통 Image의 depth와 filter의 마지막 Dimension의 크기를 같게함

filter를 적용하여 나온 값들을 activation map이라고함
- filter size만큼 생성됨 (각 activation map마다 정보가 다름)
filter를 적용했을 때 output dimension의 크기 계산
filter를 계속 진행할 경우 dimension이 점점 작아짐
- 정보의 소실이 계속 이러나게됨 -> Padding

Pooling

Padding를 통해 Convolutional layer를 진행하게 되면 정보의 소실은 줄였지만, 너무 dimension이 커짐 → 최소한의 정보의 소실을 통해 핵심 의미 정보만 추출
Benefits of leveraging Pooling Layer
makes a model to be robust to small translations
- context를 배울 수 있음 → 노이즈를 어느정도 해결할 수 있음
the model to be more generalizable → It can prevent overfitting

Convolutional Neural Network for Natural Language Processing

Convolutional Neural Network for Natural Language Processing Paper

CNN은 sequence of words를 image처럼 처리함
- 단어간의 관계를 파악할땐 유용하지만, long-term dependency를 파악할때는 적절하지 않음
- text는 순서가 중요하지만, CNN은 순서를 구분하지 않음

참고자료

What is Convolutional Neural Network — CNN (Deep Learning)

Conv2d — PyTorch 2.9 documentation

MaxPool2d — PyTorch 2.9 documentation

AvgPool2d — PyTorch 2.9 documentation