원인

• Python에서 global debug flag를 가져다 쓰고싶었음..
• 찾아보니 __debug__라는 flag를 지원한다.
  • 동작 방식
    • -O 또는 -OO flag를 주면 False가 된다.
    • 안주면 True!
  • 위의 플래그는 optimize flag인데, 릴리즈 전에는 optimize를 한다는 가정하에 쓴 것 같다..
• 좀 불편해보여서 다른 방식이 있나 찾아보았다.
• sys.flags.debug를 가지고도 알 수 있다.
  • -d옵션을 주면 sys.flags.debug 가 켜진다.

예시

root@brain-dev-gpu1:~# python -OO test.py
sys.flags.debug = 0
sys.flags.optimize = 2
__debug__ = False

root@brain-dev-gpu1:~# python -O test.py
sys.flags.debug = 0
sys.flags.optimize = 1
__debug__ = False

root@brain-dev-gpu1:~# python -d test.py
sys.flags.debug = 1
sys.flags.optimize = 0
__debug__ = True

root@brain-dev-gpu1:~# python  test.py
sys.flags.debug = 0
sys.flags.optimize = 0
__debug__ = True

Deep SARSA -> DQN

deep sarsa에서 DQN으로 넘어갈 때 추가된 것들을 정리…

• Experience replay
• target-network

Experience replay memory

• 
• s,a,r,s'를 저장해놓고, 학습 시 임의로 셔플링해서 쓰는 방식
• 이걸 쓰지 않으면 한 시나리오에 대해서 많은 학습 데이터가 들어오는데, 문제가 생김
  • ex> 마리오 게임 2탄을 깨는 것을 학습하다가 1탄 깨는 것을 까먹음…
  • iid한 data를 얻기위해…
• Deep sarsa는 on-policy니까 못쓰겠지…?

target-network

• DQN 수식
  • $$Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha(R_{t+1} + \gamma \cdot {max}_{a'}Q(S_{t+1}, a') - Q(S_t, A_t) )$$
• Q(S,A)가 network로부터 나옴
• 정답이 계속 변하면 부트스트랩 문제가 더 심해짐
• target-network를 똑같이 만들어서 일정기간 유지시키자!

Actor-critic

• $\theta_{t+1} = \theta_t + \alpha \cdot [\nabla_\theta log\pi_\theta(a \vert s) \cdot q_\pi(s, a)]$
• PG review
  • 위에서 $q_\pi(s, a)]$를 시나리오에서 받는 보상으로…
  • $\theta_{t+1} = \theta_t + \alpha \cdot [\nabla_\theta log\pi_\theta(a \vert s) \cdot G_t]$
• $q_\pi(s, a)]$도 네트워크로 근사시키면 됨! <– critic network
• 기존의 action 내보내는 네트워크 <– actor
• 그래서 actor-critic

Baseline ( Advantage Actor-critic A2C)

• $\theta_{t+1} = \theta_t + \alpha \cdot [\nabla_\theta log\pi_\theta(a \vert s) \cdot Q_w(s, a)]$
  • 큐함수가 그대로 쓰이면 분산이 큼
  • 베이스라인($V_v$) 사용
    • $A(S_t, A_t) = Q_w(S_t,A_t) - V_v(S_t)$
    • 이러면 $Q_w$와 $V_v$ 둘 다 근사함수를 만들어야함…
  • $\delta_v = R_{t+1}+\gamma V_v(S_{t+1}) - V_v(S_t)$
    • 요러면 해결!
• $\theta_{t+1} = \theta_t + \alpha \cdot [\nabla_\theta log\pi_\theta(a \vert s) \cdot \delta_v]$

• 단점
  • 현재 sample에 초점이 맞춰짐
    • DQN보다 수렴이 느림
• critic update시 sarsa 방식을 사용
  • off-plicy 학습 불가능…
  • A3C

강화학습 심화 1: Gridworld & Neural network approximation

• 책과 제목을 좀 바꿨는데… 근사함수보다는 NN을 쓰는 것을 강조하고싶었음..
• 현재까지 문제는
  • state, action이 작고 변하지 않음
  • 그래서 table로 저장해서 풀기 수월함
• 
• 만약에 state, action space가 크거나, 변한다면?
  • table에 저장해놓고 푸는것은 힘들다.
• 근사함수
  • state -> value 또는
  • state -> policy 함수를 만들면 환경이 변해도 학습이 가능!

근사 함수

• review
  • prediction
    • MC: scenario sampling을 통해 학습
    • TD: scenario의 중간 node들을 통해 학습
  • control
    • Sarsa: on-policy로 학습
    • Q-learning: off-policy로 학습
• 위에 것 모두 model-free
  • 즉, 환경에 대한 완벽한 정보가 필요하지 않음
• 모두 table기반의 강화학습
  • 모든 state에 대해서 값을 저장
• state나 action이 많아지면 저장할 것도 많고… 이래저래 힘듬
• 그래서 근사함수가 필요!

딥살사

• SARSA
  • $Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha(R_{t+1} + \gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t) )$
• 위의 수식을 구하는데, $q(s,a)$를 NN을 사용해서 근사시켜보자!
  • 
  • 모든 action에 대해서 q(s,a)가 뽑힌다.

    전체 구조

• 노란색이 현 step, 초록색이 다음 step을 의미한다.
• 

Policy Gradient

• 여태까지 배운 알고리즘은 Value-based RL.
  • 가치를 배우는 것이고, 가치 기반으로 행동을 선택
• PG는 Policy-based RL
  • 정책을 바로 학습시킴
• 
• $J(\theta) = v_{\pi_\theta}(s_0)$ 를 maximize
  • 처음 상태 $s_0$에서의 Value func.를 최대화시키는 policy
• $$\begin{matrix} \nabla_\theta J(\theta) & = & \nabla_\theta v_{\pi_\theta}(s_0) \\ & = & \sum_s d_{\pi_\theta}(s)\sum_a\nabla_\theta \pi_\theta(a \vert s) \cdot q_\pi(s, a) \\ & = & \sum_s d_{\pi_\theta}(s)\sum_a \pi_\theta(a \vert s) \cdot \frac{\nabla_\theta \pi_\theta(a \vert s) }{\pi_\theta(a \vert s)} \cdot q_\pi(s, a) \\ & = & \sum_s d_{\pi_\theta}(s)\sum_a \pi_\theta(a \vert s) \cdot \nabla_\theta[ log\pi_\theta(a \vert s)] \cdot q_\pi(s, a) \\ & = & E_{\pi_\theta}[\nabla_\theta[ log\pi_\theta(a \vert s)] \cdot q_\pi(s, a)]\end{matrix}$$
• $$\begin{matrix} \theta_{t+1} & = & \theta_t + \alpha \cdot [\nabla_\theta log\pi_\theta(a \vert s) \cdot q_\pi(s, a)]\\ & = & \theta_t + \alpha \cdot [\nabla_\theta log\pi_\theta(a \vert s) \cdot G_t] \leftarrow Reinforce\ algorithm\end{matrix}$$
  • 보상이 마이너스면, 해당 정책을 낼 확률이 줄어들고,
  • 보상이 플러스면 늘어남
• 

강화학습 기초 3: Grid world & Q-learning

• RL은 환경의 모델을 몰라도 상호작용을 통해 학습이 가능

• DP는 환경의 모델을 알아야함

• 예측: policy가 주어졌을 때, Value func.를 계산하는 것(evaluation)
  • 몬테카를로 예측
  • 시간차 예측
• 제어: Value func.를 토대로 agent의 optimal policy를 찾는 것(Improvement)
  • Sarsa (시간차 제어)
  • Q-learning (off-policy)

강화학습과 정책 평가 1: Monte-carlo prediction(MC)

ST: terminal state, Gi: i번째 episode의 return

• DP에서는 모든 state에 대해서 동시에 update를 함
• review (B.E.E.)
  • $v_\pi(s) = E_\pi[R_{t+1} + \gamma v_\pi(s’)]$
• Sampling을 통해서 $v_\pi$를 구해보자!
  • $$\begin{matrix} v_\pi(s) & = & E[ R_{t+1}+\gamma R_{t+2}+\gamma^2 R_{t+3}... \vert S_t=s] \\ & = & E[G_t \vert S_t=s] \end{matrix}$$
  • 끝까지 episode를 진행시켜서 $G_t$를 얻어냄
  • 그 $G_t$들을 평균내서 쓰겠다
  • $$v_\pi(s) = \frac{1}{N(s)}\underset{i=1}{\overset{N(s)}{\Sigma}}G_i(s)$$
• sample update(n개의 sample이 있을 때, n+1번째 sample이 들어옴)
  • $$\begin{matrix}V_{n+1} & = & \frac{1}{n}\Sigma_i^{n}G_i\\ & = & \frac{1}{n}(G_{n}+\Sigma_i^{n-1}G_i) \\ & = & \frac{1}{n}(G_{n} + (n-1) * \frac{1}{n-1}\Sigma_i^{n-1}G_i) \\ & = & \frac{1}{n}(G_{n} + (n-1)V_n) \\ & = & V_n + \frac{1}{n}(G_{n}-V_{n})\end{matrix}$$
• 일반 업데이트 식
  • $V(s) \leftarrow V(s) + \alpha(G(s) - V(s))$
  • $G(s)$에 다가가도록 step-size($\alpha$)만큼 update
• 장점
  • 각 state에 independent하다
    • DP에서는 인접 state에 대해서 구했는데…
    • $V(s) \leftarrow V(s) + \alpha(G(s) - V(s))$로 끝남
  • 전체 state가 아닌 특정 state에 대해서만 구해도 된다.
• 단점
  • 모든 state를 가보지 못했는데, guarantee할 수 있나?
    • 주어진 정책대로 간다면 갈 확률이 거의 없으니 괜찮음…
  • episode가 끝나야지 update를 할 수 있네????
    • episode가 끝나지 않는 문제에는 적용 못함 ㅠ
    • temporal diff로 가자!

강화학습과 정책 평가 2: Temporal difference(TD)

• Monte-carlo의 수식을 다시 살펴보자
  • $V(S_t) \leftarrow V(S_t) + \alpha(G_t - V(S_t))$
  • $G_t$는 episode가 끝나야 알 수 있다.
• $G_t = R_{t+1} + \gamma v_\pi(s’)$
• episode의 중간 상태에서(s) 액션(a)를 취하면 다음 상태(s’)과 보상 $R_{t+1}$을 알 수 있다.
• 현재의 보상 $R_{t+1}$에 예측한 value func. $V(s’)$을 $G_t$대신 쓰는 것이 Temporal difference!!

비교

• MC : high variance, zero bias
• TD : low variance, some bias
  • 하지만 MC보다 효율적이고, 더 빨리 수렴한다.
  • 초기값에 sensitive(bootstrap)

사실 위의 TD는 TD(0)며, TD(n)의 경우 n스텝을 더 본 이후 $G_t$를 예측한다.

강화학습 알고리즘 1: Sarsa

• GPI(Generalized Policy Iteration)
  • policy iteration인데, evaluation / improvement를 한번씩 번갈아가며 진행
  • 이렇게 해도 수렴이 된다네…
• Sarsa
  • policy evaluation: Temporal difference
  • policy improvement
    • Greedy policy
      • $Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha(R_{t+1} + \gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t) )$
      • 
      • $(S_t, A_t, R_{t+1}, S_{t+1}, A_{t+1})$가 학습에 필요!
    • $\epsilon$-greedy
      • 위 식에서 action들은 greedy policy를 따른다면, Q-func의 초기값에 지배됨!
      • 그래서 어느정도는 탐험이 필요함
      • $$\pi(s) = \left\{\begin{matrix}a^*=\underset{a\in A}{argmax}Q(s,a), & 1-\epsilon\\ a \neq a^* & \epsilon \end{matrix}\right.$$
  • 정리
    • $\epsilon$-greedy 방식으로 sample $(S_t, A_t, R_{t+1}, S_{t+1}, A_{t+1})$ 를 얻어냄
    • 이 샘플로 $Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha(R_{t+1} + \gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t) )$를 계산하고 update

강화학습 알고리즘 2: Q-learning

• Sarsa의 한계
  • 
  • 다음 state의 action이 탐험에 의해서 잘못된 선택을 할 경우, 좋은 action이 penalty를 받는다.
  • $Q(s’,a’)$가 작기 때문에…
  • on-policy temporal difference control
    • 자신이 행동하는대로 학습하는 시간차 제어
• Q-learning
  • off-policy TD control
    • 행동하는 정책
    • 학습하는 정책
    • 을 따로 가져가자!
  • $Q(S_t, A_t) \leftarrow Q(S_t, A_t) + \alpha(R_{t+1} + \gamma \underset{a’}{max}Q(S_{t+1}, a’) - Q(S_t, A_t) )$
    • 다음 state의 action을 greedy로
      • 학습할 것은 $\epsilon$-greedy지만,
      • 그 안에서 가져오는 것은 greedy로 가정
    • $(S_t, A_t, R_{t+1}, S_{t+1})$ 가 필요

3장 - 강화학습 기초 2: Grid world & Dynamic programming

• 앞서서 MDP를 정의하고, Bellman 방정식들을 봤음
• dynamic programming을 통해서 최적 가치함수와, 최적 정책을 구하는 것이 이 장의 목적
• 다음 두가지 방법을 배움
  • Policy iteration
    • Bellman expectation eq. 을 사용
  • Value iteration
    • Bellman optimality eq.를 사용
• 쉽게 설명하기 위해 Grid world 예제를 사용하고, state transition probability는 무시한다.

Policy iteration

• 다음 세단계로 이루어짐
  • policy 초기화
  • policy evaluation
    • review
      • BEE: $v_\pi(s) = \underset{a \in A}{\Sigma}\pi(a \vert s)(R_{t+1} + \gamma v_\pi(s’))$
    • 위 수식을 iteration을 돌면서 구해본다
    • $v_{k+1}(s) = \underset{a \in A}{\Sigma}\pi(a \vert s)(R_{t+1} + \gamma v_k(s’))$
    • 
    • 이걸 모든 상태 s에 대해 수행
  • policy improvement
    • 여러가지 가능하나 Greedy Improvement를 소개한다.
    • review
      • q-func: $q_\pi(s,a) = E_\pi[R_{t+1} + \gamma v_\pi(S_{t+1}) \vert S_t=s, A_t=a]$
    • $q_\pi(s,a) = R_{s}^a + \gamma v_\pi(s’)$ 로 고침
    • 위 식을 최대화하는 action a를 반환하는 정책
• policy와 value-function이 분리되어있음
  • 확률적 policy도 가능하다.

Value iteration

• value function에 대해서 최적의 value func.만 뽑는 정책을 가정함
• 이러면 val. func.에 policy그 내재됨
• v(s)만 잘 업데이트하면 되겠다!
• review
  • BOE: $v^*(s) = \underset{a}{max} E[R_{t+1}+\gamma v^*(S_{t+1}) \vert S_t=s, A_t=a]$
• 요걸 똑같이 update하는 식으로 만들면
  • $v_{k+1}(s) = \underset{a \in A}{max}[R_s^a+\gamma v_k(s’)]$
• 

DP의 한계

• 계산 복잡도 및 curse of Dim.
• 환경에 대한 완벽한 정보가 필요!!