몬테카를로법으로 정책 제어

최적 정책을 Q값으로 표현한 식

최적 정책에 관한 식. 이 식을 통하여 탐욕화를 진행한다. ( 최적 정책에 대한 벨만 방정식 )

 

정책 반복법 policy iteration , 가치 반복법 에서 정책을 평가하는 방법에 대해서 알아보았었다. 

최적의 정책은 평가 -> 개선 -> 평가 -> 개선 ....의 과정을 반복적으로 거친다.

하지만 위의 식은 제약이 존재한다...

• 제약: 일반적인 강화학습 모델에서는 환경모델을 알수없다. 즉, p( s' | s , a )와 r( s , a , s' )을 알수없다.
  • ==> 그래서 우리는 일반적인 강화학습 문제에서는 argmax Q( s, a )를 사용하야한다. 
    • argmax Q( s , a )는 단순히 이 값을 최대로 만들어주는 action인 a만 찾으면 된다. 그러니 환경 모델이 필요없다.
  • Q함수를 대상으로 개선을 하려면 Q함수를 평가해야한다. 앞의 포스팅에서 몬테카를로법으로 정책 평가 에 대해서 해보았다. 여기서 수행한 평가대상을 Q함수로 바꾸면 된다.( 아래식 참고)
    • G(n)은 n번째 에피소드에서 얻을수 있는 수익이다.
    • V n (s)는 n번째 에피소드가 끝난 시점에서의 상태가치 함수 추정치다.
    • Q n ( s, a )도 n번째 episode가 끝난 시점의 Q함수 추정치이다.

일반적인 방식에 대한 평가 방법. 각각 상태가치 함수 평가 , Q함수 평가이다.

증분 방식에 대한 평가 방법

 

 

---

탐욕 정책으로 정책 개선 하기

• 탐욕화를 하면 해당 state에서는 1가지의 action만 하도록 고정된다. 이러면 agent의 state전이도 항상 동일하다. 그러면 모든 state와 action의 조합에 대한 sample data를 얻지 못한다.
  • ==> 그래서 이를 해결하기 위해서, 탐욕 정책을 사용할때는 agent가 '탐색'을 할 수 있게 해야한다.
• ε-greedy policy
  • 위의 문제 해결을 위해  ε - greey 정책을 사용할것이다.  ε의 확률로 agent가 모험을 하게하는 방법이다.(무작위성)
    • 이렇게 하면, 정해진 행동만 수행하는 것을 방지하는 것이 가능하다.

class McAgent:
    def __init__( self ):
        self.gamma = 0.9
        self.epsilon = 0.1
        self.alpha = 0.1 # 알파 값은 비정상 문제로 수행하기 위함이다. ( 지수 평균 이동 , 시간이 지남에 따라서 확률 분포는 바뀌기 때문 )
        self.action_size = 4
        random_actions = { 0:0.25 , 1:0.25 , 2:0.25 , 3:0.25 }
        self.pi = defaultdict( lambda: random_actions )
        self.Q = defaultdict( lambda: 0 )
        self.cnts = defaultdict( lambda: 0 )
        self.memory = []

    def get_action( self , state ):
        action_probabilities = self.pi[ state ]
        actions = list( action_probabilities.keys() )
        probabilities = list( action_probabilities.values() )
        return np.random.choice( actions , p=probabilities )

    def add( self , state , actiom , reward ):
        data = ( state , action , reward )
        self.memory.append( data )

    def reset( self ):
        self.memory.clear()
    # memory를 기반으로 해서 Q값을 업데이트 하고 정책도 갱신한다.
    def update( self ):
        G = 0
        print(f'my memory is {self.memory}')
        for data in reversed( self.memory ): # 메모리를 역순으로 반복한다.
            state , action , reward = data # memory에서 state , action , reward를 뽑아낸다.
            #print(f'before G {G} ' , end='')
            G = self.gamma * G + reward # 할인된 미래 보상을 계산
            #print(f' after G {G}')
            key = (state , action ) # 상태 , 행동 쌍이다 변하지않게 튜플로 해줌
            self.Q[ key ] += ( G - self.Q[ key ] ) * self.alpha  # 행동가치함수인 Q함수의 값을 갱신
           # print(f'self.Q is {self.Q}')
            self.pi[ state ] = greedy_probabilities( self.Q , state , self.epsilon )

# 탐욕적으로 정책을 조정하게 하는 함수
# 즉, 행동가치함수인 Q함수의 값이 가장 큰 챌동만 하게 확률 분포를 만들어 준다.
def greedy_probabilities( Q , state , epsilon=0 , action_size=4 ):
    qs = [ Q [ (state , action) ] for action in range ( action_size ) ]
    max_action = np.argmax( qs )
    base_probabilities = epsilon / action_size
    action_probabilities = { action: base_probabilities for action in range ( action_size ) }
    action_probabilities[ max_action ] += ( 1 - epsilon )
    return action_probabilities

env = GridWorld()
agent = McAgent()
print(f'agent를 초기화..\npi is {agent.pi}\nQ is {agent.Q}\ncnts is {agent.cnts}\nmemory is {agent.memory}\n')
episodes = 10000
for episode in range( episodes ):
    state = env.reset() # env의 start위치를 리셋 합니다.
    agent.reset()# 에이전트의 memory도 리셋합니다.
    while True: # 총 10000번의 episode를 구할거임
        action = agent.get_action( state ) # 현재 state에서 수행할 있는 action을 가져옵니다. ( random.choice에 따른 확률적으로 1가지의 action을 가져옴)
        next_state , reward , done = env.step( action ) # actuon에 따라서 얻는 전이 state , reward를 구합니다.
        agent.add( state , action , reward ) # 현재 state에서 어떠한 action을 취하는 경우 얻는 reward를 agent에 저장합니다.
        if done:# 도착.
            print('done')
            agent.update() # 정책 업데이트 후 break.
            break
        state = next_state # 목적지에 도달 못한 경우며, 다음 state에서의 action을 취한다.