16. 딥 강화학습(Deep RL) 입문 DQN부터 시작하기, DQN 구현 및 학습 과정 설명

딥 강화학습은 강화학습과 딥러닝을 결합한 형태로, 복잡한 환경에서 최적의 행동을 찾기 위해 신경망을 이용합니다. 이 글에서는 딥 Q-러닝(Deep Q-Learning, DQN)의 개념과 알고리즘을 설명하고, 이에 대한 간단한 구현을 통해 DQN의 작동 방식에 대해 이해할 수 있도록 하겠습니다.

1. 강화학습 개요

강화학습은 에이전트가 환경과 상호작용하면서 최대의 보상을 얻기 위한 최적의 정책을 학습하는 과정입니다. 여기서 에이전트는 행동을 취하고, 환경은 그에 대한 보상을 반환합니다. 강화학습의 주요 요소는 다음과 같습니다:

  • 상태 (State, S): 에이전트가 현재 처해 있는 환경의 상태를 나타냅니다.
  • 행동 (Action, A): 에이전트가 선택할 수 있는 행동입니다.
  • 보상 (Reward, R): 에이전트가 특정 행동을 취했을 때 환경으로부터 받는 피드백입니다.
  • 정책 (Policy, π): 에이전트가 주어진 상태에서 어떤 행동을 선택할지 결정하는 전략입니다.
  • Q-값 (Q-value): 특정 상태에서 특정 행동을 취했을 때 예상되는 미래 보상의 합입니다.

2. DQN 개요

딥 Q-러닝은 Q-러닝의 한계를 극복하기 위해 딥러닝을 활용하여 Q-값을 근사합니다. 일반적인 Q-러닝은 Q-테이블을 사용해 모든 상태-행동 쌍에 대해 값을 업데이트하지만, 상태 공간이 커지는 경우 이를 저장하는 것이 비효율적입니다. DQN은 신경망을 사용하여 상태에 대한 Q-값을 근사함으로써 이 문제를 해결합니다.

2.1 DQN의 구조

DQN은 다음과 같은 주요 구성 요소로 이루어져 있습니다:

  • 신경망 구조: DQN은 입력층, 은닉층, 출력층으로 구성된 신경망을 사용합니다. 입력층은 상태 정보를 받고, 출력층은 Q-값을 반환합니다.
  • 경험 replay buffer: 에이전트가 환경과 상호작용하며 경험한 상태, 행동, 보상 등을 저장하는 버퍼입니다. 이 데이터를 랜덤하게 샘플링하여 신경망을 학습시킵니다.
  • 타겟 네트워크: 네트워크의 안정성을 높이기 위해 주 네트워크와 별도로 타겟 네트워크를 사용합니다. 주 네트워크는 학습 과정에서 업데이트 되지만, 타겟 네트워크는 일정 주기로만 업데이트 됩니다.

3. DQN 알고리즘

DQN 알고리즘은 다음 단계로 구성됩니다:

  1. 환경에서 초기 상태를 관찰합니다.
  2. 현재 상태에 대한 Q-값을 계산하고, ε-greedy 전략을 사용하여 행동을 선택합니다.
  3. 선택한 행동을 수행한 후 환경의 다음 상태와 보상을 관찰합니다.
  4. 경험을 replay buffer에 저장합니다.
  5. 버퍼에서 무작위로 샘플링하여 미니배치 학습을 수행합니다.
  6. Q-값을 업데이트합니다: Q(s, a) = r + γ * max(Q(s', a')), 여기서 γ는 할인 계수입니다.
  7. 일정 주기로 타겟 네트워크를 업데이트합니다.
  8. 에피소드를 반복합니다.

4. DQN 구현 예제

이제 DQN을 구현해 보겠습니다. 이 예제에서는 OpenAI의 Gym 라이브러리를 사용하여 간단한 환경을 설정하고 DQN 에이전트를 학습시킵니다.

4.1 필요 라이브러리 설치

pip install gym keras numpy

4.2 DQN 클래스 구현

import random
import numpy as np
import gym
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam

class DQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.memory = []
        self.gamma = 0.95    # 할인 계수
        self.epsilon = 1.0    # 탐색 확률
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.model = self._build_model()

    def _build_model(self):
        model = Sequential()
        model.add(Dense(24, input_dim=self.state_size, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(self.action_size, activation='linear'))
        model.compile(loss='mse', optimizer=Adam(lr=0.001))
        return model

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.action_size)
        act_values = self.model.predict(state)
        return np.argmax(act_values[0])

    def replay(self, batch_size):
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                target += self.gamma * np.amax(self.model.predict(next_state)[0])
            target_f = self.model.predict(state)
            target_f[0][action] = target
            self.model.fit(state, target_f, epochs=1, verbose=0)
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

4.3 학습 함수

def train_dqn(episodes):
    for e in range(episodes):
        state = env.reset()
        state = np.reshape(state, [1, state_size])
        for time in range(500):
            action = agent.act(state)
            next_state, reward, done, _ = env.step(action)
            reward = reward if not done else -10
            next_state = np.reshape(next_state, [1, state_size])
            agent.remember(state, action, reward, next_state, done)
            state = next_state
            if done:
                print(f"Episode: {e}/{episodes}, score: {time}, e: {agent.epsilon:.2}")
                break
        if len(agent.memory) > batch_size:
            agent.replay(batch_size)

4.4 메인 함수

if __name__ == "__main__":
    env = gym.make('CartPole-v1')
    state_size = env.observation_space.shape[0]
    action_size = env.action_space.n
    agent = DQNAgent(state_size, action_size)
    batch_size = 32
    train_dqn(1000)

4.5 코드 설명

위의 코드는 DQN 알고리즘을 구현한 것입니다. 주요 구성 요소를 살펴보면:

  • DQNAgent 클래스: 에이전트의 동작 및 기억을 관리합니다.
  • _build_model 메서드: Q-값을 추정하는 신경망을 생성합니다.
  • act 메서드: ε-greedy 전략을 사용하여 행동을 선택합니다.
  • replay 메서드: 경험을 학습합니다.

5. DQN의 한계와 개선 방법

DQN은 몇 가지 한계가 있습니다:

  • Q-값 함수를 근사하는데 있어 과적합의 위험이 있습니다.
  • 탐색-개발 사이의 균형을 맞추는 것이 어렵습니다.
  • 상태-행동 공간이 매우 큰 경우 성능이 떨어질 수 있습니다.

이러한 한계를 극복하기 위한 몇 가지 방법은 다음과 같습니다:

  • 우선 순위 경험 재플레이 (Prioritized Experience Replay): 더 중요한 경험을 우선적으로 샘플링하여 학습합니다.
  • 더블 딥 Q-러닝 (Double DQN): 타겟 네트워크와 주 네트워크의 업데이트를 분리하여 과적합을 줄입니다.
  • 듀얼 딥 Q-러닝 (Dueling DQN): Q-값을 상태 가치와 Advantage 함수를 분리하여 계산하는 방법입니다.

결론

DQN은 딥러닝을 활용한 강화학습의 중요한 이정표로, 여러 복잡한 문제를 해결하는 데 사용되고 있습니다. 이 글에서는 DQN의 기본 개념과 구현을 살펴보았으며, 실제로 간단한 환경에서 에이전트를 학습시키는 과정을 구현했습니다. 다양한 개선 방법을 활용하면 DQN의 성능을 더욱 향상시킬 수 있습니다. 앞으로의 연구와 실험이 기대됩니다.