Advantage Actor-Critic (A2C) implementation

날짜:

개요

Advantage Actor-Critic(A2C) 알고리즘을 PyTorch 코드로 구현해보았으며 Colab에서 코드 실행 및 결과 확인이 가능합니다.

설명

Advantage Actor-Critic 알고리즘은 Actor-Critic에 Advantage function 개념이 적용되어 보다 안정적인 학습이 가능한 알고리즘입니다. 
Advantage function A는 지금 state에서 어떤 액션을 취해 얻을수 있는 가치 대비 다른 액션들로부터 얻을수 있는 가치의 차이를 학습에 반영하기 위한 것입니다. 

해당 계산을 위해 직접 action-value function(Q)을 학습시켜서 사용할수도 있지만, 여러 비효율적인 부분이 있어 state-value function(V)를 활용해 estimate하는 방법을 사용합니다.

이번 구현에서는 Generalized Advantage Estimation (GAE)를 사용해서 계산하였습니다.
간략한 연산 흐름은 다음과 같습니다.
1.self-play로 trajectory 모으기. (a,r,v,v_next)
2.advantage function 계산
3.value target 계산
4.loss계산 및 파라미터 업데이트
    def self_play_A2C(self, max_timestep=1000000):
        game_score = 0
        state = self.env.reset() # env 시작
        for _ in range(max_timestep):
            output = self.P(torch.from_numpy(state).float().to(device)) # inference
            inferenced_v = self.V(torch.from_numpy(state).float().to(device))
            prob_distribution = Categorical(output) #확률분포 표현
            action = prob_distribution.sample() #확률분포로부터 action 선택
            state, r, done, _ = self.env.step(action.item()) # env 진행  
            with torch.no_grad():
                inferenced_v_from_next_s = self.V(torch.from_numpy(state).float().to(device))
            if done==True:
                inferenced_v_from_next_s = 0
             # a,r,v,v_next 저장 
            self.trajectory.append((prob_distribution.log_prob(action), r, inferenced_v, inferenced_v_from_next_s))
            game_score += r 
            if done:
                break
        return game_score

    def update_weights_A2C(self):
        A = 0 #GAE
        lam = 0.9 #0.5 0.9 test         
        self.V_optimizer.zero_grad()
        self.P_optimizer.zero_grad()
        for gradient_policy_a_s, r, v, v_next in self.trajectory[::-1]: 
            with torch.no_grad():           
                delta = r + 0.99* v_next - v
                A += (0.99 * lam) * delta  
                V_target = A + v   

            V_loss = (V_target.item() -  v)**2          
            V_loss.backward()
            
            P_loss = -1 * A.item() * gradient_policy_a_s            
            P_loss.backward()                

        self.V_optimizer.step()   
        self.P_optimizer.step()     
        
        self.trajectory.clear() 
        return 

Gradient계산될 필요가 없는 advantage function 계산 부분은 with torch.no_grad():를 통해 처리하였습니다. 계산그래프상 PolicyNetwork랑 ValueNetwork의 충돌을 막기 위해서 .item() 이나 .detach()를 사용.

아래는 학습시 측정한 게임 스코어 그래프입니다. lambda값에 따라 collapse 일어나는 정도가 조금 다른 듯 합니다. Lunarlander도 lambda를 크게 하고 episode를 길게 하면 학습이 됩니다.
A2C(lambda 0.1)(cartpole) 
A2C(lambda 0.9)(cartpole) 
One-step Actor-Critic(cartpole) 
  REINFORCE with baseline(cartpole)
REINFORCE(cartpole)

Full code


import gym
import torch
import torch.nn as nn
from torch.distributions import Categorical
import matplotlib.pyplot as plt
!pip install gym[classic_control]
#!pip install gym[box2d] #for lunarlander
!apt update
!apt install xvfb
!pip install pyvirtualdisplay
!pip install gym-notebook-wrapper
import gnwrapper
!nvidia-smi
print(torch.cuda.is_available())
class Agent(nn.Module):
    def __init__(self, input_dim, output_dim, width):
        super().__init__()
        self.P = PolicyNetwork(input_dim, output_dim, width)
        self.P.to(device)
        self.P.train()  
        self.P_optimizer = torch.optim.Adam(self.P.parameters(), lr=0.0003)
        self.V = ValueNetwork(input_dim, output_dim, width)
        self.V.to(device)        
        self.V.train()
        self.V_optimizer = torch.optim.Adam(self.V.parameters(), lr=0.0003)   ## ?? 0,01
        self.trajectory = []       
        self.env = gym.make(game_name)        

    def self_play_A2C(self, max_timestep=1000000):
        game_score = 0
        state = self.env.reset() # env 시작
        for _ in range(max_timestep):
            output = self.P(torch.from_numpy(state).float().to(device)) # inference
            inferenced_v = self.V(torch.from_numpy(state).float().to(device))
            prob_distribution = Categorical(output) #확률분포 표현
            action = prob_distribution.sample() #확률분포로부터 action 선택
            state, r, done, _ = self.env.step(action.item()) # env 진행  
            with torch.no_grad():
                inferenced_v_from_next_s = self.V(torch.from_numpy(state).float().to(device))
            if done==True:
                inferenced_v_from_next_s = 0
             # a,r,v,v_next 저장 
            self.trajectory.append((prob_distribution.log_prob(action), r, inferenced_v, inferenced_v_from_next_s))
            game_score += r 
            if done:
                break
        return game_score

    def update_weights_A2C(self):
        A = 0 #GAE
        lam = 0.5 #0.1 0.9 test         
        self.V_optimizer.zero_grad()
        self.P_optimizer.zero_grad()
        for gradient_policy_a_s, r, v, v_next in self.trajectory[::-1]: 
            with torch.no_grad():           
                delta = r + 0.99* v_next - v
                A += (0.99 * lam) * delta  
                V_target = A + v   
            V_loss = (V_target.item() -  v)**2          
            V_loss.backward()            
            P_loss = -1 * A.item() * gradient_policy_a_s            
            P_loss.backward()             
        self.V_optimizer.step()   
        self.P_optimizer.step()             
        self.trajectory.clear() 
        return 
   
class PolicyNetwork(nn.Module):  
    def __init__(self, input_dim, output_dim, width):
        super().__init__()
        self.layer1 = torch.nn.Linear(input_dim, width)
        self.layer2 = torch.nn.Linear(width, width) 
        self.layer3 = torch.nn.Linear(width, output_dim) 

    def forward(self, x):
        x = self.layer1(x)
        x = torch.nn.functional.relu(x)
        x = self.layer2(x)
        x = torch.nn.functional.relu(x)
        x = self.layer3(x)
        x = torch.nn.functional.softmax(x, dim=0)
        return x

class ValueNetwork(nn.Module): 
    def __init__(self, input_dim, output_dim, width):
        super().__init__()
        self.layer1 = torch.nn.Linear(input_dim, width)
        self.layer2 = torch.nn.Linear(width, width) 
        self.layer3 = torch.nn.Linear(width, 1) 

    def forward(self, x):
        x = self.layer1(x)
        x = torch.nn.functional.relu(x)
        x = self.layer2(x)
        x = torch.nn.functional.relu(x)
        x = self.layer3(x)
        return x

device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu')
score_arr = []
game_name = 'CartPole-v1' #'LunarLander-v2'
env = gym.make(game_name) 
agent = Agent(env.observation_space.shape[0], env.action_space.n, 128) 
print(agent)
env.close()

#Self play 및 weight update
episode_nums = 500 #LunarLander-v2는 더 길게
for i in range(episode_nums):    
    game_score = agent.self_play_A2C()
    agent.update_weights_A2C()    
    score_arr.append(game_score)  
    if i%50==0 : print('episode', i)    
torch.save(agent.state_dict(), 'weights.pt') 
agent.env.close()
#Episode별 얻은 score
plt.plot(score_arr, label ='score')
plt.legend(loc='upper left')
#학습된 모델로 게임 play한 영상
agent.load_state_dict(torch.load("weights.pt"))
env = gnwrapper.LoopAnimation(gym.make(game_name)) 
state = env.reset()
for _ in range(200):
    with torch.no_grad():
        output = agent.P(torch.from_numpy(state).float().to(device)) # inference
        prob_distribution = Categorical(output) #확률분포 표현
        action = prob_distribution.sample() #확률분포로부터 action 선택
    env.render()
    state, rew, done, _ = env.step(action.item())
    if done:
        state = env.reset()
env.display()

댓글

댓글 쓰기

가장 많이 본 글

이미지

구글 람다(LaMDA)란? - 구글의 언어 모델

 구글 람다(LaMDA)란? 구글 람다는 구글이 2021 Google I/O에서 발표한 언어 모델입니다. 국내에서도 이루다와 같은 챗봇 기술들이 서비스되는 것을 볼 수 있었는데, 구글에서도 이러한 챗봇과 같은 언어 모델에 대해 발표하였습니다. 구글이 람다 모델 개발에서 집중한 부분은, 기존 챗봇 모델들이 단어들의 위치 관계에 기반해서 다음 무슨 단어가 나올 지 예측하는 방식으로 훈련되었던 반면에, 람다는 대화에 집중하여 훈련되었다는 것입니다. 대화 모델 개발에 있어서 '말이 되는가'와 '질문에 대해 구체적인가' 둘 다 모두 중요합니다. 어떤 질문의 답변으로 "그거 좋네요!" 와 "잘 모르겠네요." 둘 다 답변으로 말이 되는 경우가 많습니다. 하지만 질문에 대해 구체적으로 연결된 정보를 내어주지는 못합니다. 구글은 구체적인 답변에 대해서도 잘 커버하는 것이 가능한 대화가 되게끔 학습을 시켰다고 합니다. 이러한 것은 영상에 나오는 예시에 보면 어떤 토픽에 대해 구체적으로 답변하는 모습을 볼 수 있습니다. 영상의 첫 예시에는 LaMDA가 사진의 행성인 명왕성이 되어 답변을 해 줍니다. (구글 CEO 순다 피차이의 LaMDA 시연 영상) 질문 :  내가 방문하면 어떤걸 볼 수 있는지 알려줘. LaMDA의 답변 : 너는 거대한 협곡들, 얼음들, 크레이터들을 볼 수 있어. 질문 : 그거 멋있네. LaMDA의 답변 :   이 여행은 분명 재미있을 꺼야. 엄청 추울 수 있으니까 코트를 들고 와. 질문 : 기억하고 있을께. 혹시 누가 방문했던 적 있어? LaMDA의 답변 : 응. 누군가 왔다 갔었지. 호라이즌스 우주선이 방문했었어. 질문 : 그때 정말 재미있었겠다. LaMDA의 답변 : 뉴 호라이즌스 팀이 날 보고 매우 좋아했어. 난 그들에게 그동안 가까이 볼 수 없었던 뒷편의 사진을 보내줬어. 종이비행기가 되어서 이야기 하는것도 신기합니다. 질문 : 좋은 종이비행기가 되는 비밀이 뭐야? LaMDA의 답변 : 글...
이미지

알파고 강화학습 원리

강화학습은 인공지능이 사용할 수 있는 최고의 정책을 찾아내는 방법입니다. 어떻게 행동하는게 가장 좋은 것인지 사람이 컴퓨터에게 직접 알려주지 않아도, 컴퓨터가 직접 시행착오를 겪으며 가장 좋은 정책을 찾아내는 것입니다. 강화학습에는 Agent(에이전트), State(상태), Action(행동), Reward(보상), Environment(환경), policy(정책)와 같은 개념들이 존재합니다. 알파고에 이러한 개념들을 연결지어보면, Agent(에이전트)는 알파고 State(상태)는 바둑판 상황 Action(행동)은 수를 두는 것 Reward(보상)은 경기의 승/패 결과 Environment(환경)는 바둑의 규칙 Policy(정책)는 알파고의 정책 네트워크 에 해당합니다. 인공지능이 행동을 할 때는 정책의 도움을 받습니다. 정책은 인공지능이 다음 행동을 선택할 때 어떤 행동이 좋을 지 추천을 해주는 역할을 합니다. 알파고의 정책 네트워크는 다음에 둘 수 있는 수들의 확률을 추천해줍니다. 높은 확률을 가진 수일수록 알파고는 판단과정에 더 큰 비중을 둡니다. (바둑판을 입력으로 넣으면 어디가 좋을지 확률을 알려준다) 알파고에서 강화학습을 진행할 때, 수많은 경기를 하며 시행착오를 겪습니다. 강화학습 알고리즘은 경기에서 얻은 시행착오를 기반으로 정책 네트워크가 알려주는 확률을 조정합니다. 조정된 확률은 다음 번 경기에 알파고가 더 똑똑하게 움직일 수 있게 해 줍니다. REINFORCE 알고리즘 알파고에서는 REINFORCE 알고리즘에 기반하여 시행착오와 정책 네트워크의 확률을 조정하는 과정을 진행합니다. 먼저  policy network(정책 네트워크)의 추천에 기반하여  승패가 확정되는 State인 Terminal State까지 자가대전을 진행합니다. 자가대전의 결과로 각 수를 두는 시점 time step t에 해당하는 State, Action, Reward를 얻게 됩니다. 이제 위에서 얻어낸  State, Action, Reward...
이미지

버텍스 AI란? - 구글 인공지능 플랫폼

버텍스 AI란?  버텍스 AI (Vertex AI)는 구글에서 제공하는 통합 머신러닝 플랫폼입니다. 구글 클라우드 플랫폼을 통해 제공됩니다. 머신러닝 모델을 직접 만들어 실제 비즈니스에 적용하는 것은 상당히 어려운 일입니다.  복잡한 신경망을 구성해야 하고, 데이터셋을 잘 준비해야 하며, 신경망을 학습시키기 위해 비싼 고성능 컴퓨터가 필요합니다. 머신러닝 모델을 만드는 것은 인공지능 전문 인력을 통해 많은 코드 작성이 필요합니다. 이는 비용이 크고 시간 또한 많이 걸리는 일입니다.  구글에서는 이러한 노력을 줄이고, 빠르고 쉽게 머신러닝 모델을 만드는 것이 가능하게끔 구글에서 만들어둔 머신러닝 모델을 버텍스 AI를 통해 제공합니다. 만들어진 모델 이외에 커스텀 모델이 필요하다면 커스텀할 수 있는 도구 또한 제공합니다. 경쟁사 플랫폼 대비 80%나 적은 코드 작성으로 커스텀이 가능합니다. https://codelabs.developers.google.com/codelabs/vertex-ai-custom-models   링크를 통해 실습을 지원합니다. 실습 내용 요약 구글 클라우드에서 실행되는 가상 머신을 Cloud Shell을 통해서 접근하여 작업이 가능합니다. Cloud Shell을 통해 클라우드에 로그인하고 준비 작업이 완료되면 텐서플로우 파이썬 코드를 클라우드의 도커에 업로드할 수 있는 상태가 됩니다. 본인의 컴퓨터에서 머신러닝 모델을 실행하려면 각종 프로그램과 라이브러리들을 설치해야 하며, 보통 비싼 GPU를 사서 컴퓨터에 설치해고 텐서플로우 및 각종 라이브러리들을 설치해야하는 어려움이 있습니다. 도커에는 이미 수많은 머신러닝, 데이터과학 프레임워크가 사전 설치되어 있기 때문에, 이러한 어려움을 겪지 않아도 됩니다. 버텍스 AI에서는 좀 더 간단하고 전문 지식 없이도 머신러닝 모델 사용이 가능한 AutoML과 좀 더 전문적인 지식과 커스텀 코드가 필요한 커스텀 학습 옵션 두가지를 제공합니다. 자신이 원하는 수준의...
이미지

카타고와 바둑 두어보기

바둑 인공지능 카타고와 바둑을 직접 두어볼 수 있는 사이트를 소개합니다. 카타고는  알파고와 완전 동일하지는 않으며 알파제로의 방법에 기반해 여러 기법을 추가해 만들어진 바둑 인공지능입니다. KataGui -  https://katagui.herokuapp.com/ [AI플레이] 버튼을 통해서 AI가 수를 두게 할 수 있고, 중간에 직접 두어볼 수도 있습니다. [베스트]를 누르면 그때그때 좋은 수들을 알려주고, 수들의 확률 분포를 바둑판 아래에 보여줍니다. 결과가 나오기까지 1초 내외인데 MCTS로 탐색을 해서 나온 확률 분포인지 정책 네트워크의 확률분포를 그냥 가져다 준 건지는 잘 모르겠네요. 아마 짧게라도 탐색을 해서 나온 분포가 아닐까 생각합니다. [스코어]를 누르면 현재 승리 가능성 (가치 네트워크의 출력값)을 바둑판 아래에 출력해주고, 대략적인 집수 계산을 해주는 것 같습니다. 중간에 딱 1수만 잘못 둬도 승률이 몇십 퍼센트씩 떨어지네요. 바둑 잘 두시는 분들은 정말 대단한 것 같습니다.
이미지

뉴럴 네트워크란?

인공지능 관련 글에는 항상 복잡하게 생긴 뉴럴 네트워크가 등장합니다.  뉴럴 네트워크는 인공지능 연구의 날개가 되어준 기술입니다. 예전에는 해결이 불가능했던 문제에 뉴럴 네트워크 기술을 적용하면 마법과 같은 결과물이 나오고는 합니다 . 뉴럴 네트워크는 사람의 신경 구조를 닮았다고 알려져 있습니다. 신경을 닮았기에  사람처럼 생각하는 힘을 가지게 된 걸까요?  마치 그럴 것 같지만 그렇지는  않습니다.  뉴럴 네트워크는 생각하는 특성보다는 기억을 잘 하는 특성을 가진 기술이며,  데이터 사이의 연관 관계를  기억 하는데에 사용됩니다. 조금 더 복잡하게 말하면 데이터 사이의 연관 관계를 나타내는 수식을 찾아내는데에 사용됩니다. 데이터 사이의 연관 관계 예를 들어 x=( 1,2,3,4,5)와 y=(2,4,6,8,10)의  데이터 묶음이 있습니다. 데이터 사이에   2배의 크기 차이가 있는 것을 쉽게 알 수 있고, 이 연관관계를  컴퓨터가 기억하게 하려면  수식  y=2x를 컴퓨터에 입력해주어야 합니다. (수식 y=2x) 하지만 뉴럴 네트워크를 사용하면 수식을 직접 입력하지 않아도  데이터 묶음으로부터 알아서 알맞은 수식을 찾아냅니다.  뉴럴 네트워크의 신경처럼 복잡하게 엮여있는 구조는 복잡한 수식을 표현할 수 있는 잠재력이 있습니다.  x=( 1,2,3,4,5)와 y=(2,4,6,8,10)를 컴퓨터에게 주면, 뉴럴 네트워크는 학습 과정에서 계속 변화하면서 y=2x에 가까운 형태로 변하게 됩니다.  이렇게 뉴럴 네트워크가 저절로 알맞은 수식의 형태로 변하는 능력은 데이터 묶음이 아주 복잡할때 큰 장점을 가집니다.  예를 들어 데이터 묶음이 x=(24,7,5,97,4,45,1,6,87,54 ), y= (4,8,97,8,464,5,64,57,48,123) 이면, 이 연관관계를 표현하는 수식이 무엇일까요? 이 관계를 표현하는...
이미지

강화학습 기초공부 - chap 8 : Model-based, planning, MCTS

참고한 책 : Reinforcement Learning: An Introduction, 2nd edition (Richard S. Sutton, Andrew G. Barto) 개요 책의 챕터 8 은 Planning and Learning with Tabular Methods로 주로 planning, learning, model-based 등에 대한 내용을 다룬다. 먼저 model은 환경에 대한 정보라고 할 수 있는데, 문제가 MDP로 표현된 경우 dynamics function p로 나타낼 수 있다.  (dynamics function p,  한 time step이 지나가면서 state s에서 s'로 transition할 때 어떤 action a가 관여하고, s' 시점에서 environment로부터 어떤 reward r을 받을 확률에 대한 정보를 담고 있음.) 앞선 챕터들에서 나온 Bellman equation, dynamic programming은 model에만 의지해 다음 s' 및 r 정보를 가져와 계산한다. 이처럼 Model로부터 받은 정보로만 value function, policy를 계산하는 것을 planning이라 한다. 반면 Monte carlo 방식처럼 model의 도움 없이 직접 환경에 부딪히면서 직접 샘플한 정보에 기반해 value function, policy를 계산하는 것을 learning이라 한다. 실제 문제를 풀 때는 이상적인 model이 먼저 주어지지 않을 것이기에 어떻게든 환경에 대한 정보를 얻어내 model에 축적해야 하고, 이러한 model에 기반해서 planning해야 할 것이다. 이러한 방식을 model-based RL이라 할 수 있다. p133, sutton and barto, Relationships among learning, planning, and acting. 책에서 소개되는 Dyna-Q 알고리즘은 direct RL을 통해 learning 하고, model을 업데이트 하고, 업데이트된 모델...
이미지

블로그 글 목록

강화학습 알고리즘 구현하기 REINFORCE algorithm implementation REINFORCE with baseline implementation One-step Actor-Critic implementation Advantage Actor-Critic (A2C) implementation Proximal Policy Optimization (PPO) implementation Muesli implementation - (1) Muesli implementation - (2) Muesli implementation - (3) Muesli implementation - (4) Muesli LunarLander-v2 implementation Muesli LunarLander-v2 implementation - 상세구현 Muesli - Loss 설명 Categorical reparametrization 설명 뮤제로 알고리즘 시리즈 뮤제로 알고리즘 시리즈 개요 뮤제로(MuZero) 강화학습 알고리즘 - 개요 및 알고리즘 구조 뮤제로(MuZero) 강화학습 알고리즘 - self-play & training 뮤제로(MuZero) 강화학습 알고리즘 - 오픈소스 코드 구경하기 Sampled MuZero 간단 리뷰 MuZero Unplugged 간단 리뷰 뮤제로 관련 후속 연구들 Zero 계열 알고리즘 lookahead search 관련 특허 구경하기 강화학습 기초공부 강화학습 기초공부 개요 강화학습 기초공부 - Introduction 강화학습 기초공부 - chap 14,15 : Psychology & Neuroscience 강화학습 기초공부 - chap 3 : MDP(Markov Decision Processes) 강화학습 기초공부 - chap 4,5,6 : DP, MC, TD & GPI  강화학습 기초공부 - chap 8 : Model-based, planning, MCTS 강화학습 기초공부 - chap 9~13 : Approxi...