๋ฐ์ํ
๊ฐํ ํ์ต (Reinforcement Learning) ์ด๋?
๊ฐํ ํ์ต์ ์์ด์ ํธ๊ฐ ํ๊ฒฝ๊ณผ ์ํธ์์ฉํ๋ฉด์ ๋ณด์์ ์ต๋ํํ๋ ํ๋ ์ ์ฑ ์ ํ์ตํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
์์ด์ ํธ๋ ์ฃผ์ด์ง ํ๊ฒฝ์์ ์ต์ ์ ํ๋์ ํ์ตํ์ฌ ์ฅ๊ธฐ์ ์ผ๋ก ๋์ ๋ณด์์ ์ต๋ํํ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค.
๊ฐํ ํ์ต์ ๋ชฉ์
์ต์ ์ ํ๋ ์ ์ฑ ํ์ต: ์์ด์ ํธ๊ฐ ์ฃผ์ด์ง ํ๊ฒฝ์์ ์ต์ ์ ํ๋์ ์ ํํ์ฌ ๋์ ๋ณด์์ ์ต๋ํํ๋ ์ ์ฑ ์ ํ์ตํ๋ ๊ฒ์ด ๋ชฉ์ ์ ๋๋ค.
Q-learning
๊ฐํํ์ต์์, Q-learning์ด๋ผ๋ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. ํ๋ฒ ์์ธํ ์์๋ณด๊ฒ ์ต๋๋ค.
Q-learning์ ์ํ-ํ๋ ๊ฐ์น ํจ์(Q-ํจ์)๋ฅผ ํ์ตํ์ฌ ์ต์ ์ ์ ์ฑ ์ ์ฐพ๋ ๊ฐํ ํ์ต ๋ฐฉ๋ฒ ์ค ํ๋์ ๋๋ค.
์ด ๋ฐฉ๋ฒ์ ์ฃผ์ด์ง ์ํ์์ ์ด๋ค ํ๋์ ์ทจํด์ผ ํ๋์ง๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
Q-learning์ ์๋ฆฌ
- ์ด๊ธฐํ
- ๋ชจ๋ ์ํ-ํ๋ ์์ Q-๊ฐ์ ์ด๊ธฐํํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก Q-๊ฐ์ 0์ผ๋ก ์ด๊ธฐํ๋ฉ๋๋ค.
- ์์ด์ ํธ-ํ๊ฒฝ ์ํธ์์ฉ
- ์์ด์ ํธ๋ ํ์ฌ ์ํ์์ ํ๋์ ์ ํํ๊ณ , ๊ทธ์ ๋ฐ๋ฅธ ํ๊ฒฝ์ ๋ฐ์(์ฆ, ๋ณด์๊ณผ ๋ค์ ์ํ)์ ๊ด์ฐฐํฉ๋๋ค.
- Q-ํจ์ ์
๋ฐ์ดํธ
- Q-ํจ์๋ ๋ค์๊ณผ ๊ฐ์ ์์์ผ๋ก ์ ๋ฐ์ดํธ๋ฉ๋๋ค.
- ์ฌ๊ธฐ์:
- s๋ ํ์ฌ ์ํ
- a๋ ์ ํํ ํ๋
- r์ ๋ฐ์ ๋ณด์
- s′๋ ๋ค์ ์ํ
- α๋ ํ์ต๋ฅ
- ๋ ํ ์ธ ์ธ์์ ๋๋ค.
- ์ ์ฑ
์
๋ฐ์ดํธ
- Q-ํจ์๊ฐ ์ ๋ฐ์ดํธ๋ ํ, ์์ด์ ํธ๋ ์๋ก์ด Q-ํจ์์ ๋ฐ๋ผ ๋ค์ ํ๋์ ์ ํํฉ๋๋ค.
- ๋ฐ๋ณต
- ์ด ๊ณผ์ ์ ์ฌ๋ฌ ์ํผ์๋ ๋๋ ์๊ฐ ๋จ๊ณ์ ๊ฑธ์ณ ๋ฐ๋ณตํ์ฌ Q-ํจ์๋ฅผ ์ต์ ํํ๊ณ ์๋ ด์ํต๋๋ค.
Q-learning์ ์ฃผ์ ๊ตฌ์ฑ ์์
- ํ์ต๋ฅ (Learning Rate,
)
- Q-๊ฐ ์ ๋ฐ์ดํธ์ ๋น์จ์ ๊ฒฐ์ ํฉ๋๋ค. ํ์ต๋ฅ ์ด ๋์์๋ก Q-๊ฐ์ด ๋ ๋น ๋ฅด๊ฒ ์ ๋ฐ์ดํธ๋ฉ๋๋ค. 0 < α ≤ 1 ์ ๋ฒ์๋ฅผ ๊ฐ์ง๋๋ค.
- ํ ์ธ ์ธ์ (Discount Factor,
)
- ๋ฏธ๋ ๋ณด์์ ํ์ฌ ๊ฐ์น๋ฅผ ๊ฒฐ์ ํฉ๋๋ค. ํ ์ธ ์ธ์๊ฐ ํด์๋ก ๋ฏธ๋ ๋ณด์์ ๋ ์ค์ํ๊ฒ ๊ณ ๋ คํฉ๋๋ค. 0 ≤ γ ≤ 1์ ๋ฒ์๋ฅผ ๊ฐ์ง๋๋ค.
- ํํ๊ณผ ํ์ฉ (Exploration vs. Exploitation)
- ํํ(Exploration): ์๋ก์ด ํ๋์ ์๋ํ์ฌ ๋ ๋ง์ ์ ๋ณด๋ฅผ ์ป๋ ๊ณผ์ ์ ๋๋ค.
- ํ์ฉ(Exploitation): ํ์ฌ ์๊ณ ์๋ ์ต์ ์ ํ๋์ ์ ํํ๋ ๊ณผ์ ์ ๋๋ค.
- -ํ์ ์ ์ฑ (ฯต-greedy policy): ํ๋ฅ ฯต(epsilon)๋ก ํํํ๊ณ , 1 − ฯต(epsilon) ์ ํ๋ฅ ๋ก ์ต์ ์ ํ๋์ ์ ํํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
Q-learning์ ์ฅ, ๋จ์
Q-learning์ ์ฅ์
- ๋จ์์ฑ: ์๊ณ ๋ฆฌ์ฆ์ด ๋จ์ํ๊ณ ๊ตฌํ์ด ์ฉ์ดํฉ๋๋ค.
- ์คํ๋ผ์ธ ํ์ต: ํ๊ฒฝ์ ๋ชจ๋ธ์ด ํ์ ์์ผ๋ฉฐ, ์ค์ ํ๊ฒฝ์์ ์ง์ ์ํธ์์ฉ ์์ด๋ ํ์ต์ด ๊ฐ๋ฅํฉ๋๋ค.
- ๋ณดํธ์ฑ: ๋ค์ํ ๊ฐํ ํ์ต ๋ฌธ์ ์ ์ ์ฉํ ์ ์์ต๋๋ค.
Q-learning์ ๋จ์
- ํฐ ์ํ ๊ณต๊ฐ: ์ํ ๊ณต๊ฐ์ด ํด ๊ฒฝ์ฐ, Q-ํ ์ด๋ธ์ ํฌ๊ธฐ๊ฐ ์ปค์ ธ์ ๋ฉ๋ชจ๋ฆฌ์ ๊ณ์ฐ ๋น์ฉ์ด ํฌ๊ฒ ์ฆ๊ฐํฉ๋๋ค.
- ์ฐ์์ ์ธ ์ํ ๋ฐ ํ๋ ๊ณต๊ฐ: Q-learning์ ์ด์ฐ์ ์ธ ์ํ ๋ฐ ํ๋ ๊ณต๊ฐ์ ์ ํฉํ๋ฉฐ, ์ฐ์์ ์ธ ์ํ ๋ฐ ํ๋ ๊ณต๊ฐ์์๋ ํจ์จ์ ์ด์ง ์์ต๋๋ค.
- ํํ-ํ์ฉ ๊ท ํ: ์ ์ ํ ฯต\epsilon ๊ฐ์ ์ ํํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ๋๋ฌด ๋ฎ๊ฑฐ๋ ๋์ผ๋ฉด ํ์ต์ด ๋นํจ์จ์ ์ผ ์ ์์ต๋๋ค.
Q-learning Example Code
# ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํฌํธ
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# ๊ทธ๋ฆฌ๋์๋ ํ๊ฒฝ ์ ์
class GridWorld:
def __init__(self, size):
# ๊ทธ๋ฆฌ๋์ ํฌ๊ธฐ๋ฅผ ์ค์ ํฉ๋๋ค.
self.size = size
# ์ด๊ธฐ ์ํ๋ฅผ (0, 0)์ผ๋ก ์ค์ ํฉ๋๋ค.
self.state = (0, 0)
# ๋ชฉํ ์ํ๋ฅผ ๊ทธ๋ฆฌ๋์ ์ค๋ฅธ์ชฝ ์๋ ๋ชจ์๋ฆฌ๋ก ์ค์ ํฉ๋๋ค.
self.goal = (size-1, size-1)
def reset(self):
# ์ํ๋ฅผ ์ด๊ธฐ ์ํ๋ก ๋ฆฌ์
ํฉ๋๋ค.
self.state = (0, 0)
return self.state
def step(self, action):
# ํ์ฌ ์ํ์ x, y ์ขํ๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
x, y = self.state
# ํ๋์ ๋ฐ๋ผ ์๋ก์ด ์ํ๋ฅผ ๊ฒฐ์ ํฉ๋๋ค.
if action == 0:
x = max(0, x - 1) # ์๋ก ์ด๋
elif action == 1:
x = min(self.size - 1, x + 1) # ์๋๋ก ์ด๋
elif action == 2:
y = max(0, y - 1) # ์ผ์ชฝ์ผ๋ก ์ด๋
elif action == 3:
y = min(self.size - 1, y + 1) # ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋
# ์๋ก์ด ์ํ๋ฅผ ์ค์ ํฉ๋๋ค.
self.state = (x, y)
# ์๋ก์ด ์ํ๊ฐ ๋ชฉํ ์ํ์ธ์ง ํ์ธํฉ๋๋ค.
reward = 1 if self.state == self.goal else -0.1
done = self.state == self.goal
# ์๋ก์ด ์ํ, ๋ณด์, ์๋ฃ ์ฌ๋ถ๋ฅผ ๋ฐํํฉ๋๋ค.
return self.state, reward, done
# Q-learning ํ๋ผ๋ฏธํฐ ์ค์
size = 5 # ๊ทธ๋ฆฌ๋์ ํฌ๊ธฐ
env = GridWorld(size) # ๊ทธ๋ฆฌ๋์๋ ํ๊ฒฝ ์์ฑ
q_table = np.zeros((size, size, 4)) # Q-ํ
์ด๋ธ ์ด๊ธฐํ (์ํ-ํ๋ ๊ฐ์น ํจ์)
alpha = 0.1 # ํ์ต๋ฅ
gamma = 0.9 # ํ ์ธ ์ธ์
epsilon = 0.1 # ํํ ํ๋ฅ
episodes = 1000 # ํ์ต ์ํผ์๋ ์
# Q-learning ์๊ณ ๋ฆฌ์ฆ
for episode in range(episodes):
state = env.reset() # ์ํผ์๋ ์์ ์ ์ํ๋ฅผ ์ด๊ธฐํ
done = False # ์ํผ์๋๊ฐ ๋๋ฌ๋์ง ์ฌ๋ถ
while not done:
if np.random.rand() < epsilon:
action = np.random.choice(4) # ํํ: ๋ฌด์์๋ก ํ๋ ์ ํ
else:
action = np.argmax(q_table[state[0], state[1]]) # ํ์ฉ: Q-๊ฐ์ด ์ต๋์ธ ํ๋ ์ ํ
next_state, reward, done = env.step(action) # ํ๊ฒฝ์์ ํ๋ ์ํ
q_value = q_table[state[0], state[1], action] # ํ์ฌ ์ํ์ Q-๊ฐ
best_next_q_value = np.max(q_table[next_state[0], next_state[1]]) # ๋ค์ ์ํ์์์ ์ต๋ Q-๊ฐ
# Q-ํ
์ด๋ธ ์
๋ฐ์ดํธ
q_table[state[0], state[1], action] = q_value + alpha * (reward + gamma * best_next_q_value - q_value)
state = next_state # ์ํ ์
๋ฐ์ดํธ
# Q-ํ
์ด๋ธ ์๊ฐํ
# Q-learning ์๊ณ ๋ฆฌ์ฆ์์ ์ฌ์ฉํ๋ ์ํ-ํ๋ ๊ฐ์น ํจ์(State-Action Value Function)๋ฅผ ์ ์ฅํ๋ ํ
์ด๋ธ
# Q-ํ
์ด๋ธ์ ๊ฐ ํญ๋ชฉ์ ํน์ ์ํ์์ ํน์ ํ๋์ ์ทจํ์ ๋์ ๊ธฐ๋ ๋ณด์์ ๋ํ๋
plt.figure(figsize=(10, 7))
sns.heatmap(np.max(q_table, axis=2), annot=True, cmap='viridis')
plt.title('Q-Table')
plt.xlabel('State (y)')
plt.ylabel('State (x)')
plt.show()
๋ฐ์ํ
'๐ Machine Learning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ML] Hyperparameter Tuning (ํ์ดํผ ํ๋ผ๋ฏธํฐ ํ๋) (0) | 2024.08.29 |
---|---|
[ML] Recommender System (์ถ์ฒ์์คํ ) (0) | 2024.08.26 |
[ML] Emsemble Methods (์์๋ธ ๊ธฐ๋ฒ) (0) | 2024.08.23 |
[ML] ์ฐ๊ด ๊ท์น ํ์ต (Association Rule Learning) (0) | 2024.08.22 |
[ML] t-SNE (t-Distributed Stochastic Neighbor Embedding) (0) | 2024.08.20 |