NLP

강화학습 A to Z까지(2)

by
강화학습
강화학습

UNIT 4. 강화학습의 POLICY GRADIENT WITH PYTORCH

Introduction

이번 단원에서는 강화학습의 또 다른 주요 방법론인 정책 기반(Policy-based) 방법에 대해 알아보고, PyTorch를 활용해 실제로 정책 경사(Policy Gradient) 알고리즘을 구현해보겠습니다.

강화학습은 주로 가치 기반(value-based)과 정책 기반(policy-based) 방법으로 분류할 수 있습니다. 이전 단원에서는 Q-러닝을 비롯한 가치 기반 방법에 대해 배웠습니다. 이번 단원에서는 정책 기반 방법에 대해 배워보겠습니다.

What are the policy-based methods?

정책 기반 방법은 강화학습의 한 방식으로, 에이전트가 어떤 행동을 취할지를 직접적으로 모델링하는 방식입니다. 이는 가치 기반 방식과는 대조적인 접근법이며, 에이전트의 행동이 확률적으로 결정되는 것이 특징입니다.

정책(policy)이란, 주어진 상태에서 행동을 선택하는 방법을 말합니다. 이 정책을 통해 에이전트는 각 상태에서 어떤 행동을 취할지 결정합니다. 이 정책은 파라미터를 가지고 있으며, 이를 최적화하는 것이 목표입니다.

정책 기반 방법의 핵심 개념은 정책의 기댓값(expected return)을 최대화하는 것입니다. 이를 위해 강화학습 에이전트는 환경과 상호작용하며 데이터를 수집하고, 수집한 데이터를 바탕으로 정책을 업데이트합니다.

The advantages and disadvantages of policy-gradient methods

정책 기반 방법에는 몇 가지 장점과 단점이 있습니다.

장점:

  1. 확률적인 행동 선택: 정책 기반 방법에서는 행동이 확률적으로 선택되기 때문에, 탐색과 이용의 균형을 잘 맞출 수 있습니다.
  2. 연속적인 행동 공간 처리: 가치 기반 방법에서는 연속적인 행동 공간을 처리하는 것이 어렵지만, 정책 기반 방법에서는 이를 쉽게 처리할 수 있습니다.
  3. 최적 정책 찾기: 정책 기반 방법은 최적 정책을 직접 찾아내기 때문에, 궁극적으로 더 좋은 성능을 낼 수 있습니다.

단점:

  1. 대체로 학습이 느립니다.
  2. 국소 최적점에 빠질 수 있습니다.
  3. 분산이 크다는 단점이 있습니다.

Diving deeper into policy-gradient

정책 기반 방법의 핵심은 정책의 기댓값(expected return)을 최대화하는 것입니다. 이를 위해, 우리는 정책의 경사를 계산해야 합니다. 정책 경사는 기대 반환값이 최대가 되도록 정책 파라미터를 업데이트하는 방향을 제공합니다.

이러한 정책 기반 방법 중 가장 잘 알려진 방법 중 하나가 바로 정책 경사(Policy Gradient) 알고리즘입니다. 이 알고리즘은 강화학습 에이전트가 환경과 상호작용을 통해 데이터를 수집하고, 그 데이터를 바탕으로 정책을 업데이트하는 방법입니다.

(Optional) the Policy Gradient Theorem

정책 경사 정리(Policy Gradient Theorem)에 따르면, 정책의 기댓값을 최대화하는 방향은 다음과 같이 주어진다:

mathCopy code∇θJ(θ) = Eπ[∇θlogπθ(a|s)Qπ(s,a)]

여기서 ∇θ는 파라미터 θ에 대한 경사(gradient), J(θ)는 기대 반환값(objective function), Eπ는 정책 π에 대한 기대값(expectation), logπθ(a|s)는 정책에 대한 로그-우도(log-likelihood), 그리고 Qπ(s,a)는 상태 s에서 행동 a를 선택했을 때의 행동 가치 함수입니다.

이 식을 통해 에이전트는 기댓값을 최대화하는 방향으로 정책을 업데이트합니다. 이때, 이 경사는 정책의 로그-우도와 Q-값의 곱에 기대값을 취한 것으로 주어집니다.

Hands-on

이제 PyTorch를 사용하여 실제로 정책 경사 알고리즘을 구현해보겠습니다. 기본적인 강화학습 환경인 CartPole을 사용하여 정책 경사 알고리즘을 훈련시키겠습니다.

pythonCopy codeimport torch
import torch.nn as nn
import torch.optim as optim
import gym
import numpy as np

# Define the policy network
class PolicyNet(nn.Module):
    def __init__(self, n_states, n_actions):
        super(PolicyNet, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(n_states, 128),
            nn.ReLU(),
            nn.Linear(128, n_actions),
            nn.Softmax(dim=-1)
        )
    
    def forward(self, x):

UNIT 5. INTRODUCTION TO UNITY ML-AGENTS

Introduction

이번 단원에서는 Unity의 머신러닝 에이전트인 Unity ML-Agents에 대해 알아보겠습니다. Unity ML-Agents는 Unity 게임 엔진을 활용해 강화학습 연구와 개발을 지원하는 오픈소스 프로젝트입니다.

Unity ML-Agents를 사용하면 복잡하고 다양한 환경에서 강화학습 알고리즘을 테스트하고 개발할 수 있습니다. 또한, 사용자는 Unity의 기능을 활용해 자신만의 강화학습 환경을 설계하고 제작할 수 있습니다.

How ML-Agents works?

Unity ML-Agents는 에이전트, 환경, 학습 알고리즘의 세 가지 주요 구성 요소로 작동합니다.

  1. 에이전트(Agent): 에이전트는 환경과 상호작용하며 학습합니다. 에이전트는 주어진 상태에서 행동을 선택하고, 그 행동에 따라 보상을 받습니다. ML-Agents에서는 에이전트를 직접 설계하고, 강화학습 알고리즘을 적용하여 에이전트가 최적의 행동을 학습하도록 할 수 있습니다.
  2. 환경(Environment): 환경은 에이전트의 행동에 따라 상태를 업데이트하고, 보상을 제공합니다. ML-Agents에서는 다양한 기본 환경을 제공하며, 사용자는 Unity의 강력한 기능을 활용해 직접 복잡한 환경을 설계할 수 있습니다.
  3. 학습 알고리즘(Trainer): 학습 알고리즘은 에이전트의 행동을 최적화하기 위해 사용됩니다. ML-Agents는 여러 강화학습 알고리즘을 지원하며, 이를 활용해 에이전트를 훈련시킬 수 있습니다.

The SnowballTarget environment

SnowballTarget 환경은 Unity ML-Agents에서 제공하는 기본 환경 중 하나입니다. 이 환경에서 에이전트는 눈덩이를 목표물에 던져 최대한 많은 점수를 얻어야 합니다.

The Pyramids environment

Pyramids 환경은 또 다른 기본 환경으로, 여기서 에이전트는 피라미드 형태의 구조물을 피해 이동하며 목표 지점에 도달해야 합니다.

(Optional) What is curiosity in Deep Reinforcement Learning?

강화학습에서의 호기심(curiosity)은 에이전트가 더 많은 정보를 탐색하고 학습하는 데 도움을 주는 개념입니다. 호기심은 에이전트가 아직 탐색하지 않은 영역이나, 예측하기 어려운 상태에 대해 더 많은 경험을 얻도록 도와줍니다.

Hands-on

이제 실제로 Unity ML-Agents를 활용해보겠습니다. 우선 ML-Agents 환경을 설치하고 실행해보겠습니다.

pythonCopy code# Install ml-agents via pip
!pip install mlagents

# Import ml-agents
from mlagents_envs.environment import UnityEnvironment

# Load the Unity environment
env = UnityEnvironment(file_name="path_to_your_environment")

# Get the default brain
brain_name = env.brain_names[0]
brain = env.brains[brain_name]

# Reset the environment and get initial state
env_info = env.reset(train_mode=True)[brain_name]
initial_state = env_info.vector_observations[0]

# Your reinforcement learning code goes here

위 코드는 ML-Agents 환경을 설치하고, Unity 환경을 로드하고, 초기 상태를 가져오는 기본적인 절차를 보여줍니다. 이후에는 자신의 강화학습 알고리즘을 적용하여 에이전트를 훈련시킬 수 있습니다.

Bonus. Learn to create your own environments with Unity and MLAgents

Unity와 ML-Agents를 사용하면 자신만의 강화학습 환경을 만들 수 있습니다. Unity의 강력한 기능을 활용해 다양하고 복잡한 환경을 제작하고, ML-Agents로 에이전트를 훈련시키는 과정은 강화학습 연구와 개발에 많은 도움을 줍니다.

환경을 제작하는 방법은 다음과 같습니다:

  1. Unity를 설치하고 실행합니다.
  2. 2. 새로운 프로젝트를 생성하고, ML-Agents SDK를 임포트합니다.
  1. 게임 오브젝트와 환경을 설계합니다. 이 과정에서는 에이전트와 목표물, 장애물 등을 생성하고 배치합니다.
  2. 에이전트 스크립트를 작성하고, 강화학습 알고리즘을 적용하여 에이전트를 학습시킵니다.
pythonCopy code# Here is an example of how to create your own environments with Unity and MLAgents

# First, import the necessary modules
from mlagents_envs.environment import UnityEnvironment

# Create a new environment
env = UnityEnvironment(file_name="Your_Custom_Environment")

# Get the default brain
brain_name = env.brain_names[0]
brain = env.brains[brain_name]

# Reset the environment and get initial state
env_info = env.reset(train_mode=True)[brain_name]
initial_state = env_info.vector_observations[0]

# Your reinforcement learning code goes here

Unity를 활용하여 자신만의 강화학습 환경을 만드는 것은 큰 도전일 수 있지만, 이 과정을 통해 강화학습 알고리즘이 실제 환경에서 어떻게 작동하는지 깊이 이해하게 됩니다.

Conclusion

이번 단원에서는 Unity ML-Agents에 대해 알아보았습니다. Unity ML-Agents는 Unity의 강력한 기능을 활용하여 복잡하고 다양한 환경에서 강화학습 알고리즘을 테스트하고 개발할 수 있게 해줍니다. ML-Agents를 사용하면 에이전트와 환경을 설계하고, 다양한 강화학습 알고리즘을 적용하여 에이전트를 학습시킬 수 있습니다.

다음 단원에서는 액터-크리틱 메소드와 로보틱스 환경에 대해 알아볼 것입니다.

UNIT 6. ACTOR CRITIC METHODS WITH ROBOTICS ENVIRONMENTS

Introduction

이번 단원에서는 액터-크리틱(Actor-Critic) 메소드와 로보틱스 환경에 대해 알아보겠습니다. 액터-크리틱 메소드는 강화학습에서 매우 중요한 알고리즘으로, 이는 최적의 정책을 찾기 위해 행동을 선택하는 액터와 그 행동을 평가하는 크리틱을 사용합니다.

The Problem of Variance in Reinforce

Reinforce 알고리즘은 간단하면서도 효과적인 정책 그래디언트 방법입니다. 하지만 이 알고리즘의 주요 문제점 중 하나는 분산이 크다는 것입니다. 이는 경험을 통해 업데이트된 그래디언트 추정치가 실제 그래디언트를 정확하게 반영하지 못할 수 있음을 의미합니다. 이러한 문제는 학습을 불안정하게 만들고, 수렴을 느리게 합니다.

Advantage Actor Critic (A2C)

분산 문제를 해결하는 한 가지 방법은 액터-크리틱 방법을 사용하는 것입니다. 액터-크리틱 방법에서는 크리틱이 액터의 행동을 평가하고, 이 평가를 기반으로 액터의 정책을 업데이트합니다. 이런 식으로, 크리틱은 액터의 학습을 안내하고, 분산을 줄이는 역할을 합니다.

Advantage Actor Critic (A2C)는 액터-크리틱 방법 중 하나로, 크리틱이 사용하는 가치 함수를 업데이트하는 데 “Advantage”라는 개념을 사용합니다. Advantage는 현재 상태와 행동이 평균보다 얼마나 좋은지를 나타내는 측정값입니다.

수식으로 표현하면 아래와 같습니다:

A(s, a) = Q(s, a) – V(s)

여기서,

  • A(s, a)는 상태 s에서 행동 a를 취했을 때의 Advantage 입니다.
  • Q(s, a)는 상태 s에서 행동 a를 취했을 때의 행동 가치 함수입니다.
  • V(s)는 상태 s에서의 가치 함수입니다.

이 Advantage 함수를 활용하면, 액터는 더 나은 행동에 더 많은 확률을 할당하고, 크리틱은 가치 함수를 더 정확하게 추정할 수 있게 됩니다. 이를 통해 분산을 줄이고 학습 효율성을 높일 수 있습니다.

Advantage Actor Critic (A2C) using Robotics Simulations with PyBullet and Panda-Gym 🤖

액터-크리틱 방법은 특히 복잡한 로보틱스 환경에서 잘 작동합니다. 로보틱스 환경은 대체로 높은 차원의 상태 공간과 연속적인 행동 공간을 가지므로, 그런 환경에서 높은 성능을 달성하는 것은 매우 어렵습니다. 하지만 액터-크리틱 방법은 이러한 복잡한 문제를 효과적으로 해결할 수 있습니다.

PyBullet과 Panda-Gym은 이러한 로보틱스 시뮬레이션에 매우 적합한 도구입니다. PyBullet은 물리 시뮬

레이션을 위한 라이브러리이며, Panda-Gym은 PyBullet 위에서 다양한 로보틱스 환경을 제공하는 프레임워크입니다.

다음은 A2C를 사용하여 Panda-Gym의 로보틱스 환경에서 에이전트를 학습시키는 예시입니다.

pythonCopy code# Import required libraries
import gym
from stable_baselines3 import A2C
from stable_baselines3.common.vec_env import DummyVecEnv

# Load the environment
env = gym.make('PandaReach-v1') # For example, 'PandaReach-v1' environment

# Make sure the environment is vectorized
env = DummyVecEnv([lambda: env])

# Initialize the model
model = A2C('MlpPolicy', env, verbose=1)

# Train the model
model.learn(total_timesteps=10000)

# Test the trained model
obs = env.reset()
for _ in range(1000):
    action, _states = model.predict(obs)
    obs, rewards, dones, info = env.step(action)
    env.render()

Conclusion

이번 단원에서는 액터-크리틱 메소드에 대해 알아보았습니다. 액터-크리틱 메소드는 정책 업데이트의 분산을 줄이는 데 도움이 되며, Advantage Actor Critic (A2C) 방법을 사용하면 더 나은 행동에 더 많은 확률을 할당하여 학습 효율성을 높일 수 있습니다. 또한, 이러한 방법은 복잡한 로보틱스 환경에서도 높은 성능을 달성할 수 있습니다.

다음 단원에서는 다중 에이전트와 AI 대 AI에 대해 알아보겠습니다.

UNIT 7. INTRODUCTION TO MULTI-AGENTS AND AI VS AI

Introduction

강화학습의 다음 단계는 여러 에이전트가 상호작용하는 환경입니다. 이번 단원에서는 다중 에이전트 강화학습(Multi-Agent Reinforcement Learning, MARL)에 대해 알아보고, AI가 AI와 어떻게 경쟁하고 협력하는지 살펴보겠습니다.

An introduction to Multi-Agents Reinforcement Learning (MARL)

다중 에이전트 강화학습은 여러 에이전트가 동시에 학습하고 상호작용하는 환경에서의 학습 방법입니다. MARL의 주요 도전 과제는 각 에이전트가 다른 에이전트의 행동에 의해 영향을 받는다는 것입니다. 이렇게 되면 환경은 더 이상 정적이지 않고, 동적으로 변화하는 것처럼 보이며, 이는 학습을 복잡하게 만듭니다.

Designing Multi-Agents systems

다중 에이전트 시스템을 설계할 때 고려해야 할 몇 가지 중요한 요소가 있습니다:

  1. 협력 vs 경쟁: 에이전트는 협력하여 공통의 목표를 달성할 수 있거나, 서로 경쟁하여 자신의 보상을 최대화할 수 있습니다. 시스템의 목표에 따라 이 두 가지 방식 중 하나를 선택해야 합니다.
  2. 통신: 에이전트가 서로 정보를 교환할 수 있다면, 보다 효과적인 학습과 행동이 가능해집니다. 하지만 이는 추가적인 복잡성을 더하며, 통신 전략을 설계해야 합니다.
  3. 공유된 학습 vs 독립적인 학습: 모든 에이전트가 같은 정책을 공유하여 학습할 수 있습니다(중앙집중적 학습). 반면에, 각 에이전트가 자신만의 정책을 가질 수도 있습니다(독립적 학습). 중앙집중적 학습은 학습을 간소화하지만, 독립적인 학습은 더 유연한 행동을 가능하게 합니다.

다음으로, AI 대 AI의 개념에 대해 알아보겠습니다.

Self-Play

Self-play는 같은 종류의 두 AI 에이전트가 서로 대결하는 학습 방법입니다. 이 방법은 특히 게임 환경에서 유용하며, AlphaGo와 OpenAI Five와 같은 유명한 시스템에서 사용되었습니다.

Self-play의 주요 장점은 에이전트가 항상 적합한 대상을 가지고 있어, 학습이 빠르게 진행된다는 것입니다. 또한, 에이전트는 자신의 전략에 대한 피드백을 받을 수 있어, 전략을 지속적으로 개선할 수 있습니다.

Let’s train our soccer team to beat your classmates’ teams (AI vs. AI)

이제 여러분의 축구 팀을 훈련시켜 동료들의 팀을 이길 준비를 해봅시다. 이를 위해, 우리는 각 에이전트가 공을 차고, 팀원과 협력하며, 상대방 골문에 득점하도록 훈련시킬 것입니다. 이 과정에서 우리는 MARL의 주요 원칙을 적용하고, 협력과 경쟁, 그리고 self-play의 개념을 이용할 것입니다.

# Import required libraries
import gym
# stable_baselines3 import PPO
from stable_baselines3.common.vec_env import DummyVecEnv

# Load the environment
env = gym.make('Soccer-v0')  # For example, 'Soccer-v0' environment

# Make sure the environment is vectorized
env = DummyVecEnv([lambda: env])

# Initialize the model
model = PPO('MlpPolicy', env, verbose=1)

# Train the model
model.learn(total_timesteps=10000)

# Test the trained model
obs = env.reset()
for _ in range(1000):
    action, _states = model.predict(obs)
    obs, rewards, dones, info = env.step(action)
    env.render()

이 코드는 간단한 예제이며, 실제 상황에서는 훨씬 복잡한 학습 전략과 통신 전략이 필요할 수 있습니다. 그러나 이 코드는 여러분이 출발점으로 시작하여, AI 축구 팀을 훈련시키는 것을 목표로 삼을 수 있습니다.

Conclusion

이번 단원에서는 다중 에이전트 강화학습에 대해 알아보았습니다. MARL은 여러 에이전트가 동시에 학습하고 상호작용하는 복잡한 환경에서 강화학습을 적용하는 방법입니다. 이 방법은 협력과 경쟁, 통신, 공유된 학습과 독립적인 학습 등 다양한 원칙을 사용합니다. 마지막으로, 우리는 축구 팀의 에이전트를 훈련시키는 예제를 살펴보았습니다.

다음 단원에서는 Proximal Policy Optimization에 대해 알아보겠습니다.

UNIT 8. PART 1 PROXIMAL POLICY OPTIMIZATION (PPO)

Introduction

이번 단원에서는 Proximal Policy Optimization (PPO)에 대해 알아보겠습니다. PPO는 OpenAI에서 개발된 강화학습 알고리즘으로, Actor-Critic 방식을 기반으로 합니다. PPO는 샘플 효율성과 안정성을 향상시키는 것을 목표로 하고 있습니다.

The intuition behind PPO

PPO는 강화학습 알고리즘 중 하나로, policy gradient를 활용한 학습 방법입니다. 그러나 다른 policy gradient 방법들과는 달리, PPO는 각각의 업데이트 단계에서 policy가 너무 많이 변하지 않도록 제한하는 ‘proximal’ 조건을 도입하였습니다. 이를 통해 PPO는 학습의 안정성을 높이고, 샘플 효율성을 향상시킵니다.

Introducing the Clipped Surrogate Objective Function

PPO는 이 ‘proximal’ 조건을 충족시키기 위해 ‘clipped surrogate objective’라는 새로운 목표 함수를 도입합니다. 이 함수는 업데이트가 policy를 너무 크게 변경하는 것을 방지하며, 이는 효율적인 학습을 가능하게 합니다.

Surrogate objective function은 다음과 같이 정의됩니다:

scssCopy codeL^CLIP(θ) = E_t [ min(r_t(θ) A_t, clip(r_t(θ), 1 - ε, 1 + ε) A_t) ]

여기서 r_t(θ)는 현재 policy와 old policy의 비율을 나타내며, A_t는 advantage estimate를 나타냅니다. clip 함수는 r_t(θ)를 [1 - ε, 1 + ε] 범위로 제한합니다.

Visualize the Clipped Surrogate Objective Function

Clipped Surrogate Objective 함수를 시각화하면 그 목적을 더 잘 이해할 수 있습니다. r_t(θ)의 값이 1에 가까울수록, 우리는 업데이트가 policy를 크게 변경하지 않는다는 것을 알 수 있습니다. 반대로, r_t(θ)의 값이 1에서 멀어질수록, 업데이트는 policy를 더 많이 변경하려고 합니다. 하지만 clip 함수 덕분에, 이 변경은 [1 - ε, 1 + ε] 범위로 제한됩니다.

이는 아래의 파이썬 코드를 사용하여 시각화할 수 있습니다:

pythonCopy codeimport matplotlib.pyplot as plt
import numpy as np

def clipped_surrogate_objective(r, epsilon=0.2):
    return np.minimum(r, np.clip(r, 1 - epsilon, 1 + epsilon))

r = np.linspace(0.5, 1.5, 100)
plt.plot(r, clipped_surrogate_objective(r))
plt.xlabel('r')
plt.ylabel('Clipped Surrogate Objective')
plt.show()

이 코드를 실행하면, Clipped Surrogate Objective 함수의 형태를 볼 수 있습니다. 이 함수의 형태는 PPO가 어떻게 policy 업데이트를 제한하는지를 시각적으로 보여줍니다.

PPO with CleanRL

CleanRL은 강화학습 알고리즘을 단순하고 이해하기 쉬운 코드로 구현한 라이브러리입니다. 이번 섹션에서는 CleanRL을 사용하여 PPO를 구현하는 방법을 살펴보겠습니다.

다음은 PPO를 구현하는 파이썬 코드의 일부입니다:

pythonCopy codeimport torch
from cleanrl import ppo

# Initialize PPO with policy network and value network
policy_net = ...
value_net = ...
ppo_agent = ppo.PPOAgent(policy_net, value_net)

# Loop over episodes
for i_episode in range(1000):
    # Reset environment and episode reward
    state = env.reset()
    ep_reward = 0

    # For each step in the episode
    for t in     range(1, 10000):
        # Select action with policy
        action = ppo_agent.select_action(state)

        # Take action in the environment
        next_state, reward, done, _ = env.step(action)

        # Update agent
        ppo_agent.update(state, action, reward, next_state, done)

        # Update state and episode reward
        state = next_state
        ep_reward += reward

        # End episode if done
        if done:
            break

    # Print episode reward
    print(f"Episode {i_episode}: {ep_reward}")

이 코드는 PPO 에이전트를 초기화하고, 에피소드를 수행하면서 각 단계에서 에이전트를 업데이트하는 기본적인 루프를 보여줍니다.

Conclusion

이번 단원에서는 Proximal Policy Optimization (PPO)에 대해 알아보았습니다. PPO는 policy gradient를 활용한 강화학습 알고리즘 중 하나로, 각 업데이트 단계에서 policy가 너무 많이 변하지 않도록 제한하는 특징을 가지고 있습니다. 이를 위해 PPO는 ‘clipped surrogate objective’라는 새로운 목표 함수를 도입하였습니다.

Additional Readings

UNIT 8. PART 2 PROXIMAL POLICY OPTIMIZATION (PPO) WITH DOOM

Introduction

이번 섹션에서는 PPO를 Doom 게임 환경에서 어떻게 사용하는지 알아보겠습니다. Doom은 3D ego-shooting 게임으로, 강화학습의 환경으로 많이 사용되고 있습니다.

PPO with Sample Factory and Doom

Sample Factory는 PPO와 같은 강화학습 알고리즘을 위한 고성능 학습 라이브러리입니다. 이 라이브러리를 사용하면, PPO를 Doom 환경에서 쉽게 훈련시킬 수 있습니다.

다음은 Sample Factory를 사용하여 PPO를 Doom 환경에서 훈련시키는 파이썬 코드의 일부입니다:

pythonCopy codefrom sample_factory.runner.run_description import RunDescription, Experiment, ParamGrid
from sample_factory.algorithms.appo import appo_parser
from sample_factory.algorithms.appo.train_appo import train_appo
from sample_factory.envs.create_env import create_env
from sample_factory.utils.utils import log, AttrDict

def main():
    # Define parameters
    params = AttrDict(
        {
            'env': 'doom',
            'train_for_steps': 10000000,
            'algo': 'appo',
            'env_frameskip': 1,
            'use_rnn': True,
            'num_workers': 48,
            'num_envs_per_worker': 16,
            'ppo_epochs': 1,
            'rollout': 32,
            'recurrence': 32,
            'batch_size': 1024,
            'wide_aspect_ratio': False,
        }
    )

    # Run the training
    success = train_appo(params)
    return success

if __name__ == '__main__':
    main()

이 코드는 Doom 환경에서 PPO를 훈련시키는 과정을 간략하게 보여줍니다. 여러분은 이 코드를 사용하여 자신만의 PPO 에이전트를 Doom 환경에서 훈련시킬 수 있습니다.

Conclusion

이번 섹션에서는 PPO를 Doom 게임 환경에서 어떻게 사용하는지 알아보았습니다. PPO는 각 업데이트 단계에서 policy가 너무 많이 변하지 않도록 제한하는 특징을 가지고 있어, 복잡하고 동적인 환경인 Doom에서도 효과적으로 사용할 수 있습니다. Sample Factory 라이브러리를 활용하면, 이러한 PPO를 쉽게 구현하고 훈련시킬 수 있습니다.

다음 단원에서는 다른 강화학습 알고리즘에 대해 알아보겠습니다.

UNIT 9. DISTRIBUTED REINFORCEMENT LEARNING

Introduction

분산 강화 학습(Distributed Reinforcement Learning)은 강화학습 문제를 풀기 위한 매우 효과적인 접근 방식입니다. 여기서는 여러 에이전트를 동시에 사용하여 학습 과정을 가속화하는 방법에 대해 알아보겠습니다.

Distributed Reinforcement Learning: An Overview

분산 강화 학습은 여러 에이전트가 동시에 환경과 상호작용하며 학습하는 방법입니다. 이러한 접근 방식은 학습 과정을 병렬화하여 더 빠르게 수행할 수 있게 해줍니다. 예를 들어, AlphaGo와 같은 고성능의 강화 학습 시스템에서는 수 천 개의 CPU와 GPU를 사용하여 학습을 수행하였습니다.

Implementing Distributed Reinforcement Learning

분산 강화 학습을 구현하는 것은 간단하지 않습니다. 여러 에이전트를 동시에 관리하고, 각 에이전트의 경험을 공유하는 방법을 찾아야 합니다. 이런 문제들을 해결하기 위해, 분산 학습 알고리즘을 개발하고 있습니다.

다음은 간단한 분산 강화 학습 구현의 파이썬 코드 예시입니다:

pythonCopy codefrom ray import tune
from ray.rllib.agents.ppo import PPOTrainer

def train_drl():
    tune.run(PPOTrainer, config={
        "env": "CartPole-v1",
        "num_workers": 8,
        "num_gpus": 1,
        "num_envs_per_worker": 10,
    })

if __name__ == "__main__":
    train_drl()

이 코드는 Ray 프레임워크의 RLlib 라이브러리를 사용하여 분산 PPO 훈련을 수행합니다. 각 워커는 독립적으로 환경과 상호 작용하고, 그 경험을 공유하여 전체 학습 과정을 가속화합니다.

Conclusion

이번 단원에서는 분산 강화 학습에 대해 알아보았습니다. 분산 학습은 여러 에이전트를 동시에 사용하여 학습 과정을 병렬화하고, 더 빠른 학습을 가능하게 합니다. 하지만, 분산 학습을 구현하는 것은 간단하지 않으며, 여러 문제들을 해결해야 합니다.

UNIT 10. INTRINSIC MOTIVATION AND CURIOSITY

Introduction

다음 단원에서는 강화학습에서의 내재적 동기부여와 호기심에 대해 알아보겠습니다. 이 개념들은 에이전트가 환경을 탐색하고 학습하는 방법에 큰 영향을 미칩니다.

Intrinsic Motivation and Curiosity in Reinforcement Learning

내재적 동기부여는 에이전트가 보상이 없는 상황에서도 학습하고 탐색할 수 있게 도와주는 중요한 요소입니다. 이를 통해 에이전트는 환경에 대한 더 깊은 이해를 획득하고, 보상을 얻는 방법을 더 잘 찾아낼 수 있습니다.

호기심은 내재적 동기부여의 한 형태로, 에이전트가 알려지지 않은 상태나 행동을 탐색하도록 독려합니다. 이는 에이전트가 환경의 다양한 부분을 탐색하고, 새로운 전략을 발견하는 데 도움을 줍니다.

Implementing Intrinsic Motivation and Curiosity

내재적 동기부여와 호기심은 추가적인 보상 함수를 통해 구현될 수 있습니다. 이 보상 함수는 에이전트가 새로운 상태를 탐색하거나 예측하기 어려운 상태를 탐색할 때 추가적인 보상을 제공합니다.

다음은 내재적 동기부여와 호기심을 구현한 간단한 파이썬 코드 예시입니다:

class IntrinsicRewardWrapper(gym.Wrapper):
    def __init__(self, env):
        super().__init__(env)
        self.curiosity_factor = 0
        self.intrinsic_reward = 0

    def step(self, action):
        next_state, reward, done, info = self.env.step(action)
        self.intrinsic_reward = self.curiosity_factor * self.calculate_curiosity(next_state)
        total_reward = reward + self.intrinsic_reward
        return next_state, total_reward, done, info

    def calculate_curiosity(self, next_state):
        # This is a simplified example, in a real scenario you would
        # estimate the prediction error of a model trained to predict the next state.
        return np.random.random()

위의 코드는 Gym 환경을 감싸는 wrapper 클래스로, 에이전트가 취한 각 행동에 대해 내재적 보상을 계산하고 제공합니다. 보상 계산은 calculate_curiosity 메서드에서 이루어지며, 이는 예시를 위해 랜덤 값을 반환하도록 설정되어 있습니다. 실제로는 이곳에서 다음 상태를 예측하는 모델의 예측 오차를 기반으로 호기심을 계산합니다.

Conclusion

이번 단원에서는 내재적 동기부여와 호기심에 대해 알아보았습니다. 이들은 보상이 주어지지 않은 상황에서도 에이전트가 적극적으로 환경을 탐색하고 학습할 수 있도록 도와줍니다. 이를 통해 에이전트는 환경에 대한 더 깊은 이해를 얻고, 더욱 효과적인 학습이 가능해집니다. 다음 단원에서는 이러한 개념들을 더욱 활용하는 방법에 대해 알아보겠습니다.

강화학습 A to Z 까지(1)

답글 남기기