DDQN(Dual Deep Q-Network) 파이토치로 구현하기

signer do·2024년 1월 12일

강화학습

목록 보기
2/11
post-thumbnail

2. DDQN 코드 구현

2.1 라이브러리 포함하기

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import gym

# key-value 쌍 형태로 값을 저장 가능
# key를 field명으로 값에 접근할 수 있어 편리
from collections import namedtuple

import random
import torch

from torch import nn
from torch import optim
import torch.nn.functional as F

2.2 state 변수 설정

# 상태변수 값
Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward'))

2.3 상수 정의

# 상수 정의
ENV = 'CartPole-v1' # task
GAMMA = 0.99 # 시간할인율
MAX_STEPS = 200 # 한 episode당 최대 step 수
NUM_EPISODES = 500 # 최대 episode 수

BATCH_SIZE = 32
CAPACITY = 10000

2.4 ReplayMemory 구현

class ReplayMemory:
    def __init__(self, CAPACITY):
        self.capacity = CAPACITY # Memeory에 최대 저장 건수
        self.memory = [] # 실제 transition을 저장할 Memory
        self.index = 0 # 저장 위치를 가리킬 index

    def push(self, state, action, state_next, reward):
        '''transition = (state, action, state_next, reward) Memory에 저장'''
        # 1. 메모리가 가득 차지 않은 경우
        if len(self.memory) < self.capacity:
            self.memory.append(None) 
        
        # 2. Transition 키-값 쌍의 형태로 값 저장
        self.memory[self.index] = Transition(state, action, state_next, reward)

        # push 했으니깐 다음 칸으로 index 옮기기.
        self.index = (self.index + 1) % self.capacity 
	
    def sample(self, batch_size):
        '''Memory에서 batch_size만큼 sampleing 하기'''
        return random.sample(self.memory, batch_size)

    def __len__(self):
        '''len 함수로 현재 저장된 transition 개수 return'''
        return len(self.memory)

2.5 DDQN 알고리즘 구현

# 신경망 구성
class Brain:
    def __init__(self, num_states, num_actions):
        self.num_actions = num_actions # 행동 수(왼쪽, 오른쪽)를 구함

        # transition을 기억하기 위한 Memory 객체 10000개 생성
        self.memory = ReplayMemory(CAPACITY)

        # Linear(4,32) -> ReLU() -> Linear(32, 32) -> ReLU() -> Linear(32,2)
        # 다음 상태 s_{t+1}에서 Q 값이 최대가 되는 행동 a_m은 Main Q-Network에서 구함.
        self.main_q_network = nn.Sequential()
        self.main_q_network.add_module('fc1', nn.Linear(num_states,32))
        self.main_q_network.add_module('relu1', nn.ReLU())
        self.main_q_network.add_module('fc2', nn.Linear(32,32))
        self.main_q_network.add_module('relu2', nn.ReLU())
        self.main_q_network.add_module('fc3', nn.Linear(32, num_actions))

        # 그때의 Q 값은 Target Q-Network를 참조에서 구하기
        self.target_q_network = nn.Sequential()
        self.target_q_network.add_module('fc1', nn.Linear(num_states,32))
        self.target_q_network.add_module('relu1', nn.ReLU())
        self.target_q_network.add_module('fc2', nn.Linear(32,32))
        self.target_q_network.add_module('relu2', nn.ReLU())
        self.target_q_network.add_module('fc3', nn.Linear(32, num_actions))


        #  Main, Target Network 둘 다 같은 최적화 기법
        self.optimizer = optim.Adam(self.main_q_network.parameters(), lr=0.0001)

    def replay(self):
        '''Exprience Replay로 NN의 weight 학습'''

        # 1. 저장된 transition 수 확인
        if len(self.memory) < BATCH_SIZE:
            return

        # 2. 미니배치 생성
        self.batch, self.state_batch, self.action_batch, self.reward_batch, self.non_final_next_states = self.make_minibatch()

        # 3. 정답신호로 사용할 Q(s_t, a_t) 를 계산
        self.expected_state_action_values = self.get_expected_state_action_values()
        
        # 4. weight 수정
        self.update_main_q_network()

    def decide_action(self, state, episode):
        '''현재 state에 따라 action 결정'''
        # e-greedy 알고리즘에서 서서히 optimal action 비중 늘리기
        epsilon = 0.5 * (1 / (episode+1))

        if epsilon <= np.random.uniform(0,1):
            self.main_q_network.eval() # 추론 모드
            with torch.no_grad():
                # 열 방향의 최댓값의 index 구하기
                action = self.main_q_network(state).max(1)[1].view(1,1) # 1 -> 1*1로 torch.LongTensor
        else:
            # 행동(0,1)을 무작위로
            action = torch.LongTensor([[random.randrange(self.num_actions)]]) # 1*1로 torch.LongTensor
        
        return action
            
    def make_minibatch(self):
        '''2. 미니배치 생성'''

        # 2.1 Memory 객체에서 미니 배치 추출
        transitions = self.memory.sample(BATCH_SIZE)
        
        # 2.2 transition를 미니 배치에 맞는 형태로 변형
        # transitions는 각 step 별로 (state, action, state_next, reward) 형태가 BATCH_SIZE만큼 저장됨.
        # (state, action, state_next, reward) * BATCH_SIZE --->
        # (state*BATCH_SIZE, action*BATCH_SIZE, state_next*BATCH_SIZE, reward*BATCH_SIZE) 형태로 변환
        # 예시 zip(*[(1,'hello'),(1,2)]) -> [(1,1),('hello',2)]
        batch = Transition(*zip(*transitions))

        # 2.3 state의 요소들을 미니 배치에 맞게 변형 후 신경망으로 다룰 수 있는 변수로 변형.
        # state를 예로 들면, [torch.FloatTensor of size 1*4] 형태의 요소가 BATCH_SIZE 개수만큼 있는 형태
        # 이를 torch.FloatTensor of size BATCH_SIZE*4 형태로 변형
        # state, action, reward, 최종이 아닌 state로 된 미니배치를 나타내는 변수 생성
        state_batch = torch.cat(batch.state)   # [BATCH_SIZE * 4]
        action_batch = torch.cat(batch.action) # [BATCH_SIZE * 1]
        reward_batch = torch.cat(batch.reward) # [BATCH_SIZE]
        non_final_next_states = torch.cat([s for s in batch.next_state
                                           if s is not None])

        return batch, state_batch, action_batch, reward_batch, non_final_next_states

    def get_expected_state_action_values(self):
        '''정답신호로 사용할 Q(s_t, a_t) 계산'''

        # 3.1 추론모드로 전환
        self.main_q_network.eval()
        self.target_q_network.eval()

        # 3.2 신경망으로 Q(s_t, a_t) 계산
        # self.model(state_batch)은 각 action에 대한 Q 값 출력
        # [BATCH_SIZE * 2] 형태. type은 FloatTensor
        # 여기서부터 실행한 행동 a_t에 대한 Q 값을 계산하므로 action_batch에서 취한 행동
        # action_batch에서 a_t가 0,1인지 index를 state별로 모아서 model의 output 값을 모으기.
        # axis=1 방향
        self.state_action_values = self.main_q_network(self.state_batch).gather(1, self.action_batch) # [BATCH_SIZE * 1]
        # self.model(state.batch)를 통과한 output 값을, action_batch의 action index에 맞춰서 선택함.

        # 3.3 max{(Q(s_t+1,a) 값 계산
        # 다음 state 존재 확인 필요. None 상태가 아니고 next_state 존재 확인하는 index 마스크 만들기
        # batch.next_state에 None에 따라서 tuple(map()) -> (False, False, False, True, False, ...)
        # (False, False, False, True, False, ...) dtype=torch.bool
        non_final_mask = torch.tensor(list(map(lambda s: s is not None, self.batch.next_state)), dtype=torch.bool) # [BATCH_SIZE * 1]

        # 정답 신호 계산에 쓰일 next_state
        # 먼저 전체를 0으로 초기화
        next_state_values = torch.zeros(BATCH_SIZE)
        a_m = torch.zeros(BATCH_SIZE).type(torch.LongTensor)

        # 다음 state에서 Q 값이 최대가 되는 행동 a_m을 Main Q-Network에서 계산
        # action 선택이므로 1로 index 넣기
        a_m[non_final_mask] = self.main_q_network(self.non_final_next_states).detach().max(1)[1]

        # next_state가 있는 것만 걸러내기. BATCH_SIZE -> BATCH_SIZE*1
        a_m_non_final_next_states = a_m[non_final_mask].view(-1,1)

        # next_state가 있는 index에 대해 main_network 행동 a_m의 Q값을 target Q-Network로 계산
        # gather의 output은 [BATCH_SIZE * 1] 고로, max의 output도 
        next_state_values[non_final_mask] = self.target_q_network(self.non_final_next_states
                                                                 ).gather(1, a_m_non_final_next_states).max(1)[0].detach().squeeze()


        # 3.4 정답신호로 사용할 Q(s_t, a_t) 값을 Q러닝 식으로 계산
        expected_state_action_values = self.reward_batch + GAMMA * next_state_values

        return expected_state_action_values


    def update_main_q_network(self):
        '''4. 결합 가중치 수정'''
    
        # 4.1 Train 모드로 전환
        self.main_q_network.train()
    
        # 4.2 Loss 함수를 계산(smooth_l1_loss는 Huber 함수)
        # expected_state_action_values은
        # size가 [minibatch]이므로 unsqueeze해서 [minibatch*1]로 만듬
        loss = F.smooth_l1_loss(self.state_action_values, 
                                self.expected_state_action_values.unsqueeze(1)) # axis=1에 새로운 차원 추가
    
        # 4.3 weight를 update
        self.optimizer.zero_grad() # gradient 초기화
        loss.backward()            # backpropagation
        self.optimizer.step()      # weight update

    def update_target_q_network(self):
        '''주기적으로 Target Q-Network의 weight를 Main Q-Network와 맞추기'''
        # 2 에피소드 마다 Main Q-Network 값을 Target Q-Network에
        self.target_q_network.load_state_dict(self.main_q_network.state_dict())
        

2.6 Agent 정의

class Agent:
    def __init__(self, num_states, num_actions):
        '''task의 state 및 action 수를 설정'''
        self.brain = Brain(num_states, num_actions) # Agent의 action을 결정할 Brain 객체 생성

    def update_q_function(self):
        '''Q 함수를 수정'''
        self.brain.replay()

    def get_action(self, state, episode):
        '''action 결정'''
        action = self.brain.decide_action(state, episode)
        return action

    def memorize(self, state, action, state_next, reward):
        ''' memory 객체에 state, action, state_next, reward 내용 저장'''
        self.brain.memory.push(state, action, state_next, reward)
        
    def update_target_q_function(self):
        '''Target Q-Network를 Main Q-network와 맞추기'''
        self.brain.update_target_q_network()

2.7 Environment 정의

# CartPole을 실행하는 환경 역할
class Environment:
    def __init__(self):
        self.env = gym.make(ENV, render_mode='human') # task 설정
        num_states = self.env.observation_space.shape[0] # task 상태 변수 수 4
        num_actions = self.env.action_space.n # task action 수 2
        self.agent = Agent(num_states, num_actions) # agent 객체 생성
        self.episodes = []

    def run(self):
        '''실행'''
        episode_10_list = np.zeros(10) # 최근 10 episode 동안 버틴 단계 수를 저장
                                       # (평균 step 수 출력)
        complete_episodes = 0 # 현재까지 195단계를 버틴 episode 수
        episode_final = False # 마지막 episode 여부

        for episode in range(NUM_EPISODES):
            observation = self.env.reset()[0] # 환경 초기화

            state = observation # 관측을 변환 없이 그대로 state s로 사용\
            state = torch.from_numpy(state).type(torch.FloatTensor) # NumPy 변수 - Pytorch Tensor로 변환
            state = torch.unsqueeze(state, 0) # size 4를 size 1*4로 변환

            for step in range(MAX_STEPS): # 1 episode
                action = self.agent.get_action(state, episode) # 다음 행동 결정

                # 행동 a_t를 실행해 다음상태 s_{t+1}과 done 플래그 값 결정
                # action에 .item()을 호출해 행동 내용을 구함
                observation_next, _, done, _, _ = self.env.step(action.item()) # reward와 info는 사용하지 않음
                
                # 보상을 부여하고 episode의 종료 판정 및 state_next를 설정
                if done: # step > 200, 봉이 일정 각도 이상 기울면
                    state_next = None

                    # 최근 10 episdoe에서 버틴 step 수를 list에 저장
                    # horizontal stack
                    episode_10_list = np.hstack( (episode_10_list[1:], step+1) ) # 버틴 단계 수(step+1) 추가

                    if step < 195:
                        reward = torch.FloatTensor([-1.0])
                        complete_episodes = 0
                    else:
                        reward = torch.FloatTensor([1.0])
                        complete_episodes = complete_episodes+1
                else:
                    reward = torch.FloatTensor([0.0])
                    state_next = observation_next
                    state_next = torch.from_numpy(state_next).type(torch.FloatTensor)
                    state_next = torch.unsqueeze(state_next, 0) # [1 * 4]

                # memory에 경험 저장
                self.agent.memorize(state, action, state_next, reward)

                # Experience Replay로 Q 함수 수정
                self.agent.update_q_function()

                # 관측 결과를 update
                state = state_next

                # episdoe 종료 처리
                if done:
                    print('%d Episode: Finished after %d steps: 최근 10 Episode의 평균 단계 수 = %.1lf' % (episode, step+1, episode_10_list.mean()))
                    self.episodes.append(step+1)
                    if(episode % 2 ==0):
                        self.agent.update_target_q_function()
                    break
                    
                if len(self.episodes) > 200:
                    episode_final = True
                
                if episode_final is True:
                    # anmiation 생성 및 저장
                    break

                # 10 episode 연속으로 200단계 버티면 task 성공
                if complete_episodes >=10:
                    print('10 episode 연속 성공')
                    episode_final = True # 종료 생성
                    
cartpole_env = Environment()
cartpole_env.run()
0 Episode: Finished after 35 steps: 최근 10 Episode의 평균 단계 수 = 3.5
1 Episode: Finished after 37 steps: 최근 10 Episode의 평균 단계 수 = 7.2
2 Episode: Finished after 45 steps: 최근 10 Episode의 평균 단계 수 = 11.7
3 Episode: Finished after 29 steps: 최근 10 Episode의 평균 단계 수 = 14.6
4 Episode: Finished after 34 steps: 최근 10 Episode의 평균 단계 수 = 18.0
5 Episode: Finished after 38 steps: 최근 10 Episode의 평균 단계 수 = 21.8
6 Episode: Finished after 30 steps: 최근 10 Episode의 평균 단계 수 = 24.8
7 Episode: Finished after 42 steps: 최근 10 Episode의 평균 단계 수 = 29.0
8 Episode: Finished after 26 steps: 최근 10 Episode의 평균 단계 수 = 31.6
9 Episode: Finished after 20 steps: 최근 10 Episode의 평균 단계 수 = 33.6
10 Episode: Finished after 32 steps: 최근 10 Episode의 평균 단계 수 = 33.3
11 Episode: Finished after 29 steps: 최근 10 Episode의 평균 단계 수 = 32.5
12 Episode: Finished after 32 steps: 최근 10 Episode의 평균 단계 수 = 31.2
13 Episode: Finished after 48 steps: 최근 10 Episode의 평균 단계 수 = 33.1
14 Episode: Finished after 36 steps: 최근 10 Episode의 평균 단계 수 = 33.3
15 Episode: Finished after 35 steps: 최근 10 Episode의 평균 단계 수 = 33.0
16 Episode: Finished after 27 steps: 최근 10 Episode의 평균 단계 수 = 32.7
17 Episode: Finished after 43 steps: 최근 10 Episode의 평균 단계 수 = 32.8
18 Episode: Finished after 26 steps: 최근 10 Episode의 평균 단계 수 = 32.8
19 Episode: Finished after 27 steps: 최근 10 Episode의 평균 단계 수 = 33.5
20 Episode: Finished after 56 steps: 최근 10 Episode의 평균 단계 수 = 35.9
21 Episode: Finished after 29 steps: 최근 10 Episode의 평균 단계 수 = 35.9
22 Episode: Finished after 60 steps: 최근 10 Episode의 평균 단계 수 = 38.7
23 Episode: Finished after 67 steps: 최근 10 Episode의 평균 단계 수 = 40.6
24 Episode: Finished after 22 steps: 최근 10 Episode의 평균 단계 수 = 39.2
25 Episode: Finished after 20 steps: 최근 10 Episode의 평균 단계 수 = 37.7
26 Episode: Finished after 31 steps: 최근 10 Episode의 평균 단계 수 = 38.1
27 Episode: Finished after 30 steps: 최근 10 Episode의 평균 단계 수 = 36.8
28 Episode: Finished after 15 steps: 최근 10 Episode의 평균 단계 수 = 35.7
29 Episode: Finished after 41 steps: 최근 10 Episode의 평균 단계 수 = 37.1
30 Episode: Finished after 25 steps: 최근 10 Episode의 평균 단계 수 = 34.0
31 Episode: Finished after 49 steps: 최근 10 Episode의 평균 단계 수 = 36.0
32 Episode: Finished after 47 steps: 최근 10 Episode의 평균 단계 수 = 34.7
33 Episode: Finished after 28 steps: 최근 10 Episode의 평균 단계 수 = 30.8
34 Episode: Finished after 36 steps: 최근 10 Episode의 평균 단계 수 = 32.2
35 Episode: Finished after 28 steps: 최근 10 Episode의 평균 단계 수 = 33.0
36 Episode: Finished after 35 steps: 최근 10 Episode의 평균 단계 수 = 33.4
37 Episode: Finished after 23 steps: 최근 10 Episode의 평균 단계 수 = 32.7
38 Episode: Finished after 58 steps: 최근 10 Episode의 평균 단계 수 = 37.0
39 Episode: Finished after 60 steps: 최근 10 Episode의 평균 단계 수 = 38.9
40 Episode: Finished after 34 steps: 최근 10 Episode의 평균 단계 수 = 39.8
41 Episode: Finished after 30 steps: 최근 10 Episode의 평균 단계 수 = 37.9
42 Episode: Finished after 52 steps: 최근 10 Episode의 평균 단계 수 = 38.4
43 Episode: Finished after 33 steps: 최근 10 Episode의 평균 단계 수 = 38.9
44 Episode: Finished after 28 steps: 최근 10 Episode의 평균 단계 수 = 38.1
45 Episode: Finished after 72 steps: 최근 10 Episode의 평균 단계 수 = 42.5
46 Episode: Finished after 56 steps: 최근 10 Episode의 평균 단계 수 = 44.6
47 Episode: Finished after 39 steps: 최근 10 Episode의 평균 단계 수 = 46.2
48 Episode: Finished after 32 steps: 최근 10 Episode의 평균 단계 수 = 43.6
49 Episode: Finished after 44 steps: 최근 10 Episode의 평균 단계 수 = 42.0
50 Episode: Finished after 40 steps: 최근 10 Episode의 평균 단계 수 = 42.6
51 Episode: Finished after 77 steps: 최근 10 Episode의 평균 단계 수 = 47.3
52 Episode: Finished after 84 steps: 최근 10 Episode의 평균 단계 수 = 50.5
53 Episode: Finished after 44 steps: 최근 10 Episode의 평균 단계 수 = 51.6
54 Episode: Finished after 128 steps: 최근 10 Episode의 평균 단계 수 = 61.6
55 Episode: Finished after 44 steps: 최근 10 Episode의 평균 단계 수 = 58.8
56 Episode: Finished after 96 steps: 최근 10 Episode의 평균 단계 수 = 62.8
57 Episode: Finished after 124 steps: 최근 10 Episode의 평균 단계 수 = 71.3
58 Episode: Finished after 44 steps: 최근 10 Episode의 평균 단계 수 = 72.5
59 Episode: Finished after 53 steps: 최근 10 Episode의 평균 단계 수 = 73.4
60 Episode: Finished after 64 steps: 최근 10 Episode의 평균 단계 수 = 75.8
61 Episode: Finished after 55 steps: 최근 10 Episode의 평균 단계 수 = 73.6
62 Episode: Finished after 48 steps: 최근 10 Episode의 평균 단계 수 = 70.0
63 Episode: Finished after 130 steps: 최근 10 Episode의 평균 단계 수 = 78.6
64 Episode: Finished after 50 steps: 최근 10 Episode의 평균 단계 수 = 70.8
65 Episode: Finished after 84 steps: 최근 10 Episode의 평균 단계 수 = 74.8
66 Episode: Finished after 58 steps: 최근 10 Episode의 평균 단계 수 = 71.0
67 Episode: Finished after 93 steps: 최근 10 Episode의 평균 단계 수 = 67.9
68 Episode: Finished after 52 steps: 최근 10 Episode의 평균 단계 수 = 68.7
69 Episode: Finished after 64 steps: 최근 10 Episode의 평균 단계 수 = 69.8
70 Episode: Finished after 48 steps: 최근 10 Episode의 평균 단계 수 = 68.2
71 Episode: Finished after 70 steps: 최근 10 Episode의 평균 단계 수 = 69.7
72 Episode: Finished after 67 steps: 최근 10 Episode의 평균 단계 수 = 71.6
73 Episode: Finished after 81 steps: 최근 10 Episode의 평균 단계 수 = 66.7
74 Episode: Finished after 95 steps: 최근 10 Episode의 평균 단계 수 = 71.2
75 Episode: Finished after 74 steps: 최근 10 Episode의 평균 단계 수 = 70.2
76 Episode: Finished after 85 steps: 최근 10 Episode의 평균 단계 수 = 72.9
77 Episode: Finished after 59 steps: 최근 10 Episode의 평균 단계 수 = 69.5
78 Episode: Finished after 65 steps: 최근 10 Episode의 평균 단계 수 = 70.8
79 Episode: Finished after 62 steps: 최근 10 Episode의 평균 단계 수 = 70.6
80 Episode: Finished after 73 steps: 최근 10 Episode의 평균 단계 수 = 73.1
81 Episode: Finished after 72 steps: 최근 10 Episode의 평균 단계 수 = 73.3
82 Episode: Finished after 74 steps: 최근 10 Episode의 평균 단계 수 = 74.0
83 Episode: Finished after 125 steps: 최근 10 Episode의 평균 단계 수 = 78.4
84 Episode: Finished after 87 steps: 최근 10 Episode의 평균 단계 수 = 77.6
85 Episode: Finished after 80 steps: 최근 10 Episode의 평균 단계 수 = 78.2
86 Episode: Finished after 74 steps: 최근 10 Episode의 평균 단계 수 = 77.1
87 Episode: Finished after 131 steps: 최근 10 Episode의 평균 단계 수 = 84.3
88 Episode: Finished after 99 steps: 최근 10 Episode의 평균 단계 수 = 87.7
89 Episode: Finished after 94 steps: 최근 10 Episode의 평균 단계 수 = 90.9
90 Episode: Finished after 72 steps: 최근 10 Episode의 평균 단계 수 = 90.8
91 Episode: Finished after 76 steps: 최근 10 Episode의 평균 단계 수 = 91.2
93 Episode: Finished after 83 steps: 최근 10 Episode의 평균 단계 수 = 92.1
95 Episode: Finished after 77 steps: 최근 10 Episode의 평균 단계 수 = 87.3
97 Episode: Finished after 100 steps: 최근 10 Episode의 평균 단계 수 = 88.6
98 Episode: Finished after 84 steps: 최근 10 Episode의 평균 단계 수 = 89.0
99 Episode: Finished after 134 steps: 최근 10 Episode의 평균 단계 수 = 95.0
100 Episode: Finished after 87 steps: 최근 10 Episode의 평균 단계 수 = 90.6
101 Episode: Finished after 89 steps: 최근 10 Episode의 평균 단계 수 = 89.6
102 Episode: Finished after 98 steps: 최근 10 Episode의 평균 단계 수 = 90.0
103 Episode: Finished after 90 steps: 최근 10 Episode의 평균 단계 수 = 91.8
105 Episode: Finished after 92 steps: 최근 10 Episode의 평균 단계 수 = 93.4
106 Episode: Finished after 94 steps: 최근 10 Episode의 평균 단계 수 = 94.5
108 Episode: Finished after 73 steps: 최근 10 Episode의 평균 단계 수 = 94.1
110 Episode: Finished after 128 steps: 최근 10 Episode의 평균 단계 수 = 96.9
112 Episode: Finished after 55 steps: 최근 10 Episode의 평균 단계 수 = 94.0
113 Episode: Finished after 83 steps: 최근 10 Episode의 평균 단계 수 = 88.9
114 Episode: Finished after 92 steps: 최근 10 Episode의 평균 단계 수 = 89.4
115 Episode: Finished after 96 steps: 최근 10 Episode의 평균 단계 수 = 90.1
116 Episode: Finished after 64 steps: 최근 10 Episode의 평균 단계 수 = 86.7
117 Episode: Finished after 88 steps: 최근 10 Episode의 평균 단계 수 = 86.5
118 Episode: Finished after 117 steps: 최근 10 Episode의 평균 단계 수 = 89.0
119 Episode: Finished after 126 steps: 최근 10 Episode의 평균 단계 수 = 92.2
120 Episode: Finished after 89 steps: 최근 10 Episode의 평균 단계 수 = 93.8
121 Episode: Finished after 105 steps: 최근 10 Episode의 평균 단계 수 = 91.5
122 Episode: Finished after 83 steps: 최근 10 Episode의 평균 단계 수 = 94.3
123 Episode: Finished after 94 steps: 최근 10 Episode의 평균 단계 수 = 95.4
124 Episode: Finished after 84 steps: 최근 10 Episode의 평균 단계 수 = 94.6
126 Episode: Finished after 96 steps: 최근 10 Episode의 평균 단계 수 = 94.6
127 Episode: Finished after 136 steps: 최근 10 Episode의 평균 단계 수 = 101.8
128 Episode: Finished after 135 steps: 최근 10 Episode의 평균 단계 수 = 106.5
129 Episode: Finished after 178 steps: 최근 10 Episode의 평균 단계 수 = 112.6
130 Episode: Finished after 108 steps: 최근 10 Episode의 평균 단계 수 = 110.8
131 Episode: Finished after 64 steps: 최근 10 Episode의 평균 단계 수 = 108.3
133 Episode: Finished after 129 steps: 최근 10 Episode의 평균 단계 수 = 110.7
134 Episode: Finished after 133 steps: 최근 10 Episode의 평균 단계 수 = 115.7
135 Episode: Finished after 102 steps: 최근 10 Episode의 평균 단계 수 = 116.5
136 Episode: Finished after 71 steps: 최근 10 Episode의 평균 단계 수 = 115.2
137 Episode: Finished after 112 steps: 최근 10 Episode의 평균 단계 수 = 116.8
138 Episode: Finished after 85 steps: 최근 10 Episode의 평균 단계 수 = 111.7
139 Episode: Finished after 91 steps: 최근 10 Episode의 평균 단계 수 = 107.3
140 Episode: Finished after 172 steps: 최근 10 Episode의 평균 단계 수 = 106.7
141 Episode: Finished after 121 steps: 최근 10 Episode의 평균 단계 수 = 108.0
142 Episode: Finished after 78 steps: 최근 10 Episode의 평균 단계 수 = 109.4
143 Episode: Finished after 83 steps: 최근 10 Episode의 평균 단계 수 = 104.8
144 Episode: Finished after 95 steps: 최근 10 Episode의 평균 단계 수 = 101.0
145 Episode: Finished after 132 steps: 최근 10 Episode의 평균 단계 수 = 104.0
146 Episode: Finished after 65 steps: 최근 10 Episode의 평균 단계 수 = 103.4
147 Episode: Finished after 68 steps: 최근 10 Episode의 평균 단계 수 = 99.0
148 Episode: Finished after 72 steps: 최근 10 Episode의 평균 단계 수 = 97.7
150 Episode: Finished after 82 steps: 최근 10 Episode의 평균 단계 수 = 96.8
151 Episode: Finished after 85 steps: 최근 10 Episode의 평균 단계 수 = 88.1
152 Episode: Finished after 110 steps: 최근 10 Episode의 평균 단계 수 = 87.0
153 Episode: Finished after 94 steps: 최근 10 Episode의 평균 단계 수 = 88.6
155 Episode: Finished after 64 steps: 최근 10 Episode의 평균 단계 수 = 86.7
156 Episode: Finished after 92 steps: 최근 10 Episode의 평균 단계 수 = 86.4
157 Episode: Finished after 56 steps: 최근 10 Episode의 평균 단계 수 = 78.8
159 Episode: Finished after 75 steps: 최근 10 Episode의 평균 단계 수 = 79.8
160 Episode: Finished after 69 steps: 최근 10 Episode의 평균 단계 수 = 79.9
162 Episode: Finished after 130 steps: 최근 10 Episode의 평균 단계 수 = 85.7
163 Episode: Finished after 140 steps: 최근 10 Episode의 평균 단계 수 = 91.5
164 Episode: Finished after 195 steps: 최근 10 Episode의 평균 단계 수 = 102.5
165 Episode: Finished after 138 steps: 최근 10 Episode의 평균 단계 수 = 105.3
166 Episode: Finished after 57 steps: 최근 10 Episode의 평균 단계 수 = 101.6
167 Episode: Finished after 83 steps: 최근 10 Episode의 평균 단계 수 = 103.5
168 Episode: Finished after 70 steps: 최근 10 Episode의 평균 단계 수 = 101.3
169 Episode: Finished after 68 steps: 최근 10 Episode의 평균 단계 수 = 102.5
170 Episode: Finished after 73 steps: 최근 10 Episode의 평균 단계 수 = 102.3
171 Episode: Finished after 114 steps: 최근 10 Episode의 평균 단계 수 = 106.8
172 Episode: Finished after 83 steps: 최근 10 Episode의 평균 단계 수 = 102.1
173 Episode: Finished after 89 steps: 최근 10 Episode의 평균 단계 수 = 97.0
174 Episode: Finished after 75 steps: 최근 10 Episode의 평균 단계 수 = 85.0
175 Episode: Finished after 95 steps: 최근 10 Episode의 평균 단계 수 = 80.7
176 Episode: Finished after 58 steps: 최근 10 Episode의 평균 단계 수 = 80.8
177 Episode: Finished after 49 steps: 최근 10 Episode의 평균 단계 수 = 77.4
178 Episode: Finished after 56 steps: 최근 10 Episode의 평균 단계 수 = 76.0
179 Episode: Finished after 72 steps: 최근 10 Episode의 평균 단계 수 = 76.4
180 Episode: Finished after 71 steps: 최근 10 Episode의 평균 단계 수 = 76.2
181 Episode: Finished after 88 steps: 최근 10 Episode의 평균 단계 수 = 73.6
182 Episode: Finished after 70 steps: 최근 10 Episode의 평균 단계 수 = 72.3
183 Episode: Finished after 53 steps: 최근 10 Episode의 평균 단계 수 = 68.7
184 Episode: Finished after 95 steps: 최근 10 Episode의 평균 단계 수 = 70.7
185 Episode: Finished after 53 steps: 최근 10 Episode의 평균 단계 수 = 66.5
186 Episode: Finished after 66 steps: 최근 10 Episode의 평균 단계 수 = 67.3
187 Episode: Finished after 47 steps: 최근 10 Episode의 평균 단계 수 = 67.1
188 Episode: Finished after 44 steps: 최근 10 Episode의 평균 단계 수 = 65.9
190 Episode: Finished after 65 steps: 최근 10 Episode의 평균 단계 수 = 65.2
191 Episode: Finished after 65 steps: 최근 10 Episode의 평균 단계 수 = 64.6
192 Episode: Finished after 60 steps: 최근 10 Episode의 평균 단계 수 = 61.8
193 Episode: Finished after 86 steps: 최근 10 Episode의 평균 단계 수 = 63.4
194 Episode: Finished after 109 steps: 최근 10 Episode의 평균 단계 수 = 69.0
195 Episode: Finished after 60 steps: 최근 10 Episode의 평균 단계 수 = 65.5
196 Episode: Finished after 55 steps: 최근 10 Episode의 평균 단계 수 = 65.7
197 Episode: Finished after 59 steps: 최근 10 Episode의 평균 단계 수 = 65.0
198 Episode: Finished after 60 steps: 최근 10 Episode의 평균 단계 수 = 66.3
199 Episode: Finished after 51 steps: 최근 10 Episode의 평균 단계 수 = 67.0
200 Episode: Finished after 87 steps: 최근 10 Episode의 평균 단계 수 = 69.2
201 Episode: Finished after 58 steps: 최근 10 Episode의 평균 단계 수 = 68.5
202 Episode: Finished after 57 steps: 최근 10 Episode의 평균 단계 수 = 68.2
204 Episode: Finished after 58 steps: 최근 10 Episode의 평균 단계 수 = 65.4
205 Episode: Finished after 52 steps: 최근 10 Episode의 평균 단계 수 = 59.7
206 Episode: Finished after 66 steps: 최근 10 Episode의 평균 단계 수 = 60.3
207 Episode: Finished after 162 steps: 최근 10 Episode의 평균 단계 수 = 71.0
209 Episode: Finished after 57 steps: 최근 10 Episode의 평균 단계 수 = 70.8
210 Episode: Finished after 77 steps: 최근 10 Episode의 평균 단계 수 = 72.5
212 Episode: Finished after 93 steps: 최근 10 Episode의 평균 단계 수 = 76.7
215 Episode: Finished after 54 steps: 최근 10 Episode의 평균 단계 수 = 73.4
216 Episode: Finished after 49 steps: 최근 10 Episode의 평균 단계 수 = 72.5
217 Episode: Finished after 99 steps: 최근 10 Episode의 평균 단계 수 = 76.7
218 Episode: Finished after 71 steps: 최근 10 Episode의 평균 단계 수 = 78.0
223 Episode: Finished after 192 steps: 최근 10 Episode의 평균 단계 수 = 92.0

2.8 Entry 실행

plt.plot(cartpole_env.episodes)
plt.xlabel('Episode')
plt.ylabel('reach #step')
plt.title('# step of episode')
plt.show()

3 학습결과

profile
Don't hesitate!

0개의 댓글