MC(Monte Carlo)/TD(temporal difference) Prediction 구현

MC(Monte Carlo)/TD(temporal difference) Prediction 구현¶

• 4가지 요소를 구현하여야 함
  1. 환경: 에이전트의 액션을 받아 상태변이를 일으키고, 보상을 줌
  2. 에이전트: 4방향 랜덤 정책을 이용해 움직임
  3. 경험 쌓는 부분: 에이전트가 환경과 상호작용하며 데이터를 축적
  4. 학습하는 부분: 쌓인 경험을 통해 테이블을 업데이트

In [1]:

import random
import numpy as np

class GridWorld():
    def __init__(self):
        self.x=0
        self.y=0
    
    def step(self, a):
        # 0번 액션: 왼쪽, 1번 액션: 위, 2번 액션: 오른쪽, 3번 액션: 아래쪽
        if a==0:
            self.move_left()
        elif a==1:
            self.move_up()
        elif a==2:
            self.move_right()
        elif a==3:
            self.move_down()

        reward = -1 # 보상은 항상 -1로 고정
        done = self.is_done()
        return (self.x, self.y), reward, done

    def move_right(self):
        self.y += 1  
        if self.y > 3:
            self.y = 3
      
    def move_left(self):
        self.y -= 1
        if self.y < 0:
            self.y = 0
      
    def move_up(self):
        self.x -= 1
        if self.x < 0:
            self.x = 0
  
    def move_down(self):
        self.x += 1
        if self.x > 3:
            self.x = 3

    def is_done(self):
        if self.x == 3 and self.y == 3:
            return True
        else :
            return False

    def get_state(self):
        return (self.x, self.y)
      
    def reset(self):
        self.x = 0
        self.y = 0
        return (self.x, self.y)

In [2]:

class Agent():
    def __init__(self):
        pass        

    def select_action(self):
        coin = random.random()
        if coin < 0.25:
            action = 0
        elif coin < 0.5:
            action = 1
        elif coin < 0.75:
            action = 2
        else:
            action = 3
        return action

MC(Monte Carlo) 방법론¶

In [3]:

def main():
    env = GridWorld()
    agent = Agent()
    data = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] # 테이블 초기화
    gamma = 1.0
    alpha = 0.0001
    
    for i in range(50000): # 에피소드 5만번
        done = False
        history = []
        while not done:
            action = agent.select_action()
            (x, y), reward, done = env.step(action)
            history.append((x, y, reward))
        env.reset()
        
        # 매 에피소드가 끝나고 바로 해당 데이터를 이용해 테이블 업데이트
        cum_reward = 0
        for trainsition in history[::-1]:
            # 방문했던 상태들을 뒤에서부터 보며 차례차례 리턴을 계산함
            x, y, reward = trainsition
            data[x][y] = data[x][y] + alpha*(cum_reward-data[x][y])
            cum_reward = reward + gamma*cum_reward
            
    # 학습이 끝나고 난 후 데이터를 출력하기 위한 코드
    for row in data:
        print(row)

In [4]:

main()

[-59.46203345870075, -58.27267323931862, -56.57322147461619, -54.019766484706786]
[-57.461499862018236, -55.62478278500724, -51.83807568105412, -47.6008304965466]
[-55.28836700473425, -50.95999468307372, -41.925831656556944, -30.65572002482628]
[-53.21932168944625, -45.95375877217534, -31.05538812878471, 0.0]

TD(temporal difference) 방법론¶

In [5]:

def main():
    env = GridWorld()
    agent = Agent()
    data = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] # 테이블 초기화
    gamma = 1.0
    alpha = 0.01 # MC보다 큰 값 사용
    
    for k in range(50000):
        done = False
        while not done:
            x, y = env.get_state()
            action = agent.select_action()
            (x_prime, y_prime), reward, done = env.step(action)
            x_prime, y_prime = env.get_state()
            
            # 한 step이 진행되자 마자 바로 테이블의 데이터를 업데이트 해줌
            data[x][y] = data[x][y] + alpha*(reward+gamma*data[x_prime][y_prime]-data[x][y])
        env.reset()
        
    # 학습이 끝나고 난 후 데이터 출력
    for row in data:
        print(row)

In [6]:

main()

[-59.710270135304725, -57.77850099152185, -54.35556226639967, -52.028381291749426]
[-57.478770718794195, -55.17588493092115, -50.164844867713164, -46.73749110634664]
[-54.39304349455736, -48.968118429618585, -39.99881944062712, -29.648138978620565]
[-52.13861220048326, -44.26924314161078, -31.246609035521228, 0]

In [ ]: