[Coursera/IBM course #3] 강화학습(Reinforcement Learning)

[IBM AI course #3] Deep Learning & Neural Networks with Keras

 

강화학습(Reinforcement Learning)

에이전트는 환경과 상호작용하며, 행동(action)을 통해 환경을 변화시키고 보상(reward)을 받음.

(예: 게임에서는 플레이어 = 에이전트, 체스판이나 웹페이지 = 환경.)

→ 에이전트가 보상을 극대화하는 최적의 정책(policy)을 학습하는 알고리즘

 

사례

DeepMind의 Atari, AlphaGo는 강화학습 기반으로 인간을 이김.

 

학습 원리

행동은 환경 상태를 변화시키고,

보상이 주어지면 해당 행동이 강화되어, 유사한 상황에서 반복될 가능성이 높아짐

보상은 즉시 주어지지 않을 수 있고, 여러 단계 후에 발생하는 경우도 있음

 

문제점

데이터와 연산량이 많이 필요함.

 

비즈니스 활용

추천 시스템, 마케팅 자동화, 실시간 입찰 시스템 등에 강화학습 활용 가능.

 

Python 구현 예시

OpenAI Gym 사용, gym.make()로 환경 생성, render()로 시각화.

 

Q-Learning (Q-러닝)

Q-learning은 대표적인 값 기반(value-based) 강화학습 알고리즘

핵심은 Q-value 함수 Q(s,a)

→ 특정 상태 s에서 행동 a를 취했을 때 기대되는 누적 보상

벨만 방정식(Bellman Equation)을 사용해 Q값을 반복적으로 업데이트 (즉시 보상 + 미래 보상의 기대치를 반영)

 

Q-value 업데이트 방식

벨만 방정식(Bellman Equation)을 사용해 Q값을 반복적으로 업데이트 (즉시 보상 + 미래 보상의 기대치를 반영)

$$Q(s, a) \leftarrow Q(s, a) + \alpha \left[ r + \gamma \max_{a'} Q(s', a') - Q(s, a) \right]$$

• α(learning rate): 새로운 정보가 기존 정보에 미치는 영향
• r(reward) : 현재 스텝에서 받은 보상
• γ(discount factor): 미래 보상의 중요도

 

행동 선택 정책 (Policy) 필요성

Q-learning은 Q값을 업데이트하는 알고리즘일 뿐, 어떤 행동을 실제로 선택할지에 대한 정책(policy)은 별도로 정의해야 함. 이때 가장 널리 사용되는 행동 선택 전략은 ε-greedy (입실론-그리디) 임.

 

Epsilon-Greedy Policy

$$\pi(s) = \begin{cases} \text{random action}, & \text{with probability } \varepsilon \\ \arg\max_a Q(s, a), & \text{with probability } 1 - \varepsilon \end{cases}$$

• 확률 ε로 무작위 행동(random action) → 탐험 (exploration)
• 확률 1−ε로 현재 Q값이 가장 높은 행동 선택 → 활용 (exploitation)

ε(exploration rate)

에이전트가 새로운 행동을 시도할 확률. 탐험 vs 활용 전략.

보통 학습 초기에 ε은 크게 설정하고, 시간이 지남에 따라 감소(decay) 시켜 → 탐험 중심 → 활용 중심으로 전략을 전환함.

 

 

구현 순서

1. 환경 초기화
   예: gym.make('CartPole-v1')
2. Q-Network 구성
   상태를 입력받아 각 행동에 대한 Q값을 출력하는 신경망 모델
3. Q-Network 훈련
   경험을 저장하고, 샘플링한 데이터로 신경망 업데이트
   Q(s, a) 추론
   $y = r + γ max Q(s', a')$ ← Bellman Equation
   $loss = (y - Q(s,a))^2$
   optimizer로 가중치 업데이트
4. 에이전트 평가
   훈련된 Q-Network로 실제 환경에서 행동 수행 및 성능 측정
   $argmax_a Q(s, a)$ 사용 → 최적 행동 선택

# 탐험(ε-greedy) 관련 
# 학습 초기에는 무작위 탐험을 많이 하도록 설정 (ε=1.0)
# 에이전트가 학습할수록 점차 확신 있는 선택을 하도록 ε 값을 줄여 나감
epsilon = 1.0  # Starting with a high exploration rate
epsilon_min = 0.01  # Minimum exploration rate
epsilon_decay = 0.99  # Faster decay rate for epsilon after each episode

# 에이전트의 경험을 저장
memory = deque(maxlen=2000) 
def remember(state, action, reward, next_state, done):
    memory.append((state, action, reward, next_state, done))

# Q-learning 업데이트 – Bellman Equation 적용
def replay(batch_size=64):  # Increased batch size
    ...
    
    target = rewards[i]
    if not dones[i]:
        target += 0.95 * np.amax(q_next[i])  # Update Q value with the discounted future reward
    q_target[i][actions[i]] = target  # Update only the taken action's Q value. 벨만 방정식을 통해 타깃 Q값 
    
    ...
    model.fit(states, q_target, epochs=1, verbose=0)  # Train in batch mode

    # Reduce exploration rate (epsilon) after each training step
    global epsilon
    if epsilon > epsilon_min:
        epsilon *= epsilon_decay

# 행동 선택 함수 – Epsilon-Greedy
def act(state):
    if np.random.rand() <= epsilon:
        return random.randrange(action_size)  # Explore: choose a random action. 확률 ε로 무작위 행동 선택 (탐험)
    
    act_values = model.predict(state)  # Exploit: predict action based on the state
    return np.argmax(act_values[0])  # Return the action with the highest Q-value. 그렇지 않으면 현재 Q값이 가장 높은 행동 선택 (활용)

#  에이전트 훈련 루프
for e in range(episodes):
    ...
    action = act(state)
    next_state, reward, terminated, truncated, _ = env.step(action) # env.step()을 통해 행동 → 보상 → 상태 전이 경험
    ...
    remember(...)  # 경험 저장
    ...
    if time % train_frequency == 0:
        replay(batch_size=64) # 일정 간격마다 Q-Network 훈련. epsilon은 replay() 안에서 decay됨     

 

 

Deep Q-Networks (DQN)

DQNs은 Q-Learning의 확장으로, Q-Value 함수를 신경망으로 근사한 것

기존 Q-Table은 상태-행동 쌍이 너무 많을 경우 메모리와 속도에서 한계. 즉, 비효율적 → DQNs는 이를 신경망으로 대체해 해결

DeepMind가 Atari 게임에서 인간 수준 성능 달성 시 사용한 방식

 

핵심

• Q-Value 함수 근사
  Q(s, a) 값을 신경망으로 추정함 (Q-테이블 대신)
  → 상태 s를 입력으로 받아 모든 가능한 행동 a에 대한 Q값을 출력함.
• Experience Replay
  에이전트의 경험(상태, 행동, 보상, 다음 상태)을 버퍼에 저장 후 랜덤 샘플링(연속된 경험은 상관성이 높아 학습이 불안정해지기 쉬우므로, 랜덤 샘플링으로 분산된 학습) → 학습 안정화
• Target Network
  타겟 Q-value 생성을 위한 별도 네트워크 → 일정 주기로만 업데이트 ⇒ 진동* 방지

*학습이 진동한다 = 모델의 손실(loss)이나 출력값이 일정한 방향으로 수렴하지 않고 오르락내리락 불안정하게 변동하는 현상

 

 

구현 순서

1. 환경 초기화 (CartPole)
2. 하이퍼파라미터 설정
   학습률, 할인률, 탐험률, 배치 크기 등
3. Q-network 및 target network 구축
   동일한 구조의 두 개의 신경망 생성. 타겟 네트워크는 안정적인 학습 목표를 제공하며, 주 네트워크는 실시간 업데이트를 담당.
4. Experience Replay 구현 (remember)
   에이전트의 경험을 저장하고, 랜덤 샘플로 학습하여 과적합과 샘플 상관성 완화.
5. Q-Network 훈련
   벨만 방정식 기반으로 Q값 업데이트 → 경사 하강법 적용
   $Q_target = reward + gamma * max(Q_target(next_state))$
   $loss = mse(Q_target, Q_predict)$
6. 에이전트 평가 진행
   학습된 정책으로 환경과 상호작용하며 누적 보상 기준으로 성능 측정.
   탐험 없이 (epsilon ≈ 0) 최대 Q값을 기준으로 행동 선택함.

# 환경 초기화 (CartPole)
import gym
env = gym.make('CartPole-v1')  # ← 환경 생성
state_size = env.observation_space.shape[0]
action_size = env.action_space.n

# 하이퍼파라미터 설정
epsilon = 1.0               # 탐험률 초기값
epsilon_min = 0.01          # 최소 탐험률
epsilon_decay = 0.995       # 탐험률 감소율
gamma = 0.95                # 할인율 (future reward discount factor)
batch_size = 32             # 리플레이 미니배치 크기
episodes = 50               # 학습 에피소드 수

# Q-Network 및 Target Network 구축
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

def build_model(state_size, action_size):
    model = Sequential()
    model.add(Dense(24, input_dim=state_size, activation='relu'))
    model.add(Dense(24, activation='relu'))
    model.add(Dense(action_size, activation='linear'))  # 행동별 Q값 출력
    model.compile(loss='mse', optimizer=Adam(learning_rate=0.001))
    return model

model = build_model(state_size, action_size)  # ← 주 네트워크

# Experience Replay 구현
from collections import deque
import random

memory = deque(maxlen=2000)  # 경험 저장 버퍼

def remember(state, action, reward, next_state, done):
    memory.append((state, action, reward, next_state, done))  # 경험 저장

def act(state):  # epsilon-greedy 방식으로 행동 선택
	if np.random.rand() <= epsilon:
    	return random.randrange(action_size)
    q_values = model.predict(state)
    return np.argmax(q_values[0])

# Q-Network 훈련 (벨만 방정식 적용)
def replay(batch_size):
    global epsilon
    minibatch = random.sample(memory, batch_size)  # 랜덤 샘플링
    for state, action, reward, next_state, done in minibatch:
        target = reward
        if not done:
            # 벨만 방정식 기반 Q값 계산
            target = reward + gamma * np.amax(model.predict(next_state)[0])
        target_f = model.predict(state)
        target_f[0][action] = target
        # 모델 업데이트 (1회 학습)
        model.fit(state, target_f, epochs=1, verbose=0)
    # 탐험률 감소
    if epsilon > epsilon_min:
        epsilon *= epsilon_decay

# Q-Network 훈련 루프
for e in range(episodes):
    state = env.reset()
    if isinstance(state, tuple): state = state[0]
    state = np.reshape(state, [1, state_size])

    for time in range(200):  # 에피소드 내 최대 스텝 수
        action = act(state)
        result = env.step(action)
        if len(result) == 4:
            next_state, reward, done, _ = result
        else:
            next_state, reward, done, _, _ = result

        if isinstance(next_state, tuple): next_state = next_state[0]
        next_state = np.reshape(next_state, [1, state_size])

        remember(state, action, reward, next_state, done)  # 경험 저장
        state = next_state

        if done:
            print(f"Episode: {e+1}/{episodes}, Score: {time}, Epsilon: {epsilon:.2f}")
            break

    if len(memory) > batch_size:
        replay(batch_size)  # 모델 훈련

env.close()

# 에이전트 평가 진행 (탐험 없이 greedy 행동만 사용)
evaluation_episodes = 10
scores = []

for e in range(evaluation_episodes):
    state = env.reset()
    if isinstance(state, tuple): state = state[0]
    state = np.reshape(state, [1, state_size])
    total_reward = 0

    for time in range(200):
        action = np.argmax(model.predict(state)[0])  # 항상 최대 Q값을 선택
        result = env.step(action)
        if len(result) == 4:
            next_state, reward, done, _ = result
        else:
            next_state, reward, done, _, _ = result

        if isinstance(next_state, tuple): next_state = next_state[0]
        next_state = np.reshape(next_state, [1, state_size])

        state = next_state
        total_reward += reward

        if done:
            print(f"Evaluation Episode: {e+1}/{evaluation_episodes}, Score: {time}, Total Reward: {total_reward}")
            scores.append(total_reward)
            break

print(f"Average Reward: {np.mean(scores):.2f}, Max Reward: {np.max(scores)}, Min Reward: {np.min(scores)}")
env.close()