Reinforcement Learning (RL) adalah paradigma machine learning ketiga, dan yang paling mirip cara manusia belajar: coba, kena reward atau hukuman, perbaiki strategi, ulangi. Tidak ada dataset berlabel seperti supervised learning; ada agent yang beraksi di environment dan belajar dari konsekuensi. Episode ini penutup rangkaian konsep dasar, catatan saya memahami empat kata kuncinya: agent, environment, reward, dan policy.
Empat Kata Kunci
- Agent: si pelaku yang mengambil keputusan. Program kita.
- Environment: dunia tempat agent berada, yang merespons aksi dan memberi feedback.
- Reward: sinyal angka setelah tiap aksi — positif atau negatif. Satu-satunya definisi “benar” yang agent punya.
- Policy: strategi agent, fungsi dari state ke aksi. Tujuan training adalah policy yang memaksimalkan total reward jangka panjang.
Siklusnya berputar terus: agent melihat state, memilih aksi sesuai policy, environment merespons dengan state baru plus reward, ulangi. Analogi programmer: ini loop game. State adalah snapshot dunia, aksi adalah input, reward adalah score. Yang dipelajari RL bukan jawaban benar per kasus, tapi strategi yang menang dalam jangka panjang.
Exploration vs Exploitation
Dilema paling ikonik di RL: haruskah agent terus memakai jalur yang sudah terbukti memberi reward (exploitation), atau mencoba jalur baru yang mungkin lebih baik (exploration)? Restoran favorit versus restoran baru yang belum dicoba. Kalau terlalu rakus, agent terjebak di solusi biasa-biasa saja. Kalau terlalu petualang, dia tak pernah konsisten memanen reward terbaik. Strategi umum bernama epsilon-greedy: sebagian besar waktu pakai aksi terbaik yang diketahui, sisanya (probabilitas ε) coba acak.
Q-Learning: Belajar Nilai Aksi
Cara klasik memahami RL: Q-learning. Ide intinya tabel Q(state, action) yang menyimpan estimasi “seberapa bagus aksi ini dari state ini”. Setelah tiap pengalaman, estimasi diperbarui dengan reward yang diterima plus estimasi terbaik dari state berikutnya — belajar dari masa depan yang diproyeksikan. Rumus update-nya disebut Bellman equation, dan implementasi minimalnya mengejutkan pendek:
import numpy as np
Q = np.zeros((n_states, n_actions)) # tabel Q diinisialisasi nol
for episode in range(5000):
s = env.reset()
done = False
while not done:
if np.random.rand() < epsilon:
a = np.random.randint(n_actions) # explore
else:
a = np.argmax(Q[s]) # exploit
s2, r, done = env.step(a)
# update Q: reward + estimasi masa depan
Q[s, a] += alpha * (r + gamma * np.max(Q[s2]) - Q[s, a])
s = s2Hyperparameter singkat: alpha adalah learning rate (seberapa keras update), gamma adalah discount factor (seberapa dihargai reward masa depan vs sekarang), epsilon mengatur exploration. Tabel Q bekerja untuk state diskrit sedikit; begitu state-nya jutaan — misalnya frame piksel game — tabelnya mustahil, dan di situlah neural network menggantikan tabel (DQN, Deep Q-Network).
Contoh Q-Learning dengan FrozenLake
Supaya konsep Q-learning tidak hanya teori, berikut contoh lengkap yang bisa langsung dijalankan. FrozenLake dari Gymnasium adalah environment klasik: agent berjalan di atas kolam beku, harus mencapai goal tanpa jatuh ke lubang. State-nya diskrit (16 grid), aksinya empat arah — cocok sekali untuk tabel Q tanpa neural network.
import gymnasium as gym
import numpy as np
env = gym.make("FrozenLake-v1", is_slippery=False)
n_states = env.observation_space.n # 16
n_actions = env.action_space.n # 4
Q = np.zeros((n_states, n_actions))
alpha, gamma, epsilon = 0.1, 0.99, 0.1
episodes = 5000
for ep in range(episodes):
state, _ = env.reset()
done = False
while not done:
if np.random.rand() < epsilon:
action = env.action_space.sample()
else:
action = int(np.argmax(Q[state]))
next_state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
# Bellman update
Q[state, action] += alpha * (
reward + gamma * np.max(Q[next_state]) - Q[state, action]
)
state = next_state
# Evaluasi: jalankan 100 episode tanpa exploration
wins = 0
for _ in range(100):
state, _ = env.reset()
done = False
while not done:
action = int(np.argmax(Q[state]))
state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
wins += reward
print(f"Win rate: {wins}%")Pengalaman pertama saya menjalankan kode ini: win rate-nya naik dari 0% di awal training menjadi 80-100% setelah ribuan episode. Menakjubkan melihat tabel Q yang awalnya kosong perlahan terisi angka-angka yang mencerminkan strategi optimal — agent “memahami” bahwa beberapa jalur aman dan lainnya berbahaya.
Simulasi Loop Agent-Environment
Sebelum masuk ke metode lanjutan, penting untuk benar-benar memahami siklus dasar RL. Berikut simulasi minimal dari loop agent-environment tanpa dependency apa pun — hanya Python standar. Ini membantu memvisualisasikan alur data di setiap langkah:
# Simulasi sederhana: agent-environment loop
# Tanpa library — hanya untuk memahami konsep
import random
states = ["s0", "s1", "s2", "s3"]
actions = ["left", "right"]
goal = "s3"
def env_step(state, action):
"""Transisi deterministik sederhana."""
if state == "s0":
return "s1" if action == "right" else "s0"
elif state == "s1":
return "s2" if action == "right" else "s0"
elif state == "s2":
return "s3" if action == "right" else "s1"
return state
def reward(state):
return 1.0 if state == goal else -0.1
# Training loop
Q = {(s, a): 0.0 for s in states for a in actions}
for episode in range(1000):
state = "s0"
for step in range(20):
# Epsilon-greedy
if random.random() < 0.1:
action = random.choice(actions)
else:
action = max(actions, key=lambda a: Q[(state, a)])
next_state = env_step(state, action)
r = reward(next_state)
# Q-update
best_next = max(Q[(next_state, a)] for a in actions)
Q[(state, action)] += 0.1 * (r + 0.99 * best_next - Q[(state, action)])
state = next_state
if state == goal:
break
print("Learned Q-values:")
for s in states:
vals = {a: round(Q[(s, a)], 2) for a in actions}
print(f" {s}: {vals}")Dari simulasi di atas, terlihat jelas bagaimana Q-values yang awalnya nol perlahan terisi. State terdekat ke goal memiliki Q-value “right” tertinggi, dan agent belajar menuju sana. Ini esensi RL: interaksi berulang membentuk keputusan yang semakin baik.
DQN: Neural Network Menggantikan Tabel
Q-learning punya kelemahan fundamental: tabel Q tidak diskalakan. Game Atari memiliki ~2^72 state yang mungkin — mustahil membuat tabel sebesar itu. Deep Q-Network (DQN), diperkenalkan DeepMind tahun 2015, mengganti tabel dengan neural network. Input: state (misalnya piksel layar). Output: Q-value untuk setiap aksi. Jadi neural network berfungsi sebagai function approximator — memetakan state ke estimasi nilai aksi.
Dua inovasi kunci DQN: pertama, experience replay — agent menyimpan pengalaman (state, aksi, reward, next_state) ke dalam buffer, lalu melatih neural network dari sampel acak batch, bukan urutan sekuensial. Ini memecah korelasi antar-observasi berurutan. Kedua, target network — jaringan kedua yang di-update periodik, bukan di setiap langkah, untuk menstabilkan training. Tanpa ini, target update terus berubah dan training menjadi unstable, seperti mengejar target yang terus bergerak.
Analogi yang membantu: Q-learning seperti spreadsheet ratusan baris; DQN seperti otak yang melihat gambar dan langsung memprediksi seberapa bagus sebuah aksi. Spreadsheet rapi tapi terbatas; otak fleksibel tapi butuh banyak data dan komputasi.
Policy Gradient: Langsung Optimasi Policy
Cara pendekatan lain: alih-alih mempelajari Q-value lalu memilih aksi terbaik, langsung optimasi policy. Policy Gradient methods memparametriskan policy sebagai neural network π(a|s; θ) dan meng-update parameter θ menggunakan gradient ascent pada expected reward. Intuisinya: jalankan policy, kumpulkan episode, tingkatkan probabilitas aksi yang menghasilkan reward tinggi, kurangi yang menghasilkan reward rendah.
REINFORCE adalah algoritma policy gradient paling sederhana: jalankan beberapa episode, hitung return (total reward) untuk setiap langkah, gunakan sebagai bobot untuk update gradient. Kelemahannya: variance tinggi, training lambat. PPO (Proximal Policy Optimization) dari OpenAI adalah solusi praktis: membatasi seberapa besar parameter boleh berubah di tiap update (clipped objective), sehingga training lebih stabil tanpa kompleksitas berlebih. PPO menjadi algoritma default di banyak project modern, termasuk training RLHF untuk ChatGPT.
Perbandingan Q-Learning vs DQN vs Policy Gradient
| Aspek | Q-Learning (tabular) | DQN | Policy Gradient |
|---|---|---|---|
| Representasi state | Tabel diskrit | Neural network | Neural network |
| Output | Q-value per aksi | Q-value per aksi | Probabilitas aksi |
| Aksi | Discrete saja | Discrete saja | Discrete & continuous |
| Stabilitas training | Sangat stabil | Butuh trick (target net, replay) | Variance tinggi, PPO bantu |
| State space besar | Tidak bisa | Bisa (dengan CNN) | Bisa (dengan CNN) |
| Contoh penggunaan | Grid world, FrozenLake | Atari, game simple | Robotika, LLM alignment |
Reward Shading: Seni Mendesain Sinyal yang Baik
Salah satu tantangan paling nyata di RL bukan pada algoritma, melainkan pada reward function. Reward yang buruk menghasilkan agent yang secara teknis “sukses” dengan perilaku absurd — fenomena bernama reward hacking. Contoh klasik: agent di game CoastRunners justru belajar berputar-putar di satu titik karena mengumpulkan reward kecil berulang alih-alih finish balapan.
Prinsip reward shaping yang saya catat: (1) reward harus mendekati sparse — beri sinyal sedekat mungkin dengan goal akhir, bukan hanya di akhir episode, (2) hindari reward yang bisa dieksploitasi secara lokal, (3) gunakan reward shaping dengan potential-based method agar optimal policy tetap terjaga secara teoritis. Analogi KPI di kerja: kalau metriknya salah, tim akan sangat efisien mencapai hal yang salah. Sama persis dengan agent RL — dia sempurna dalam mengoptimalkan apa yang kita ukur, bukan apa yang kita inginkan.
Aplikasi Nyata Reinforcement Learning
RL bukan sekadar eksperimen di laboratorium. Berikut contoh aplikasi nyata yang menginspirasi:
- Game AI — AlphaGo & AlphaZero: DeepMind mengalahkan juara dunia Go tahun 2016 dengan kombinasi Monte Carlo Tree Search dan policy/value network. AlphaZero kemudian mempelajari catur, shogi, dan Go dari nol — hanya dari bermain melawan dirinya sendiri.
- Atari Games — DQN: Paper DQN 2015 menunjukkan satu arsitektur yang sama bisa bermain 49 game Atari dengan pixel input saja, mencapai level manusia profesional di beberapa game.
- Robotika: Robot Boston Dynamics berdiri dan melompat bukan karena diprogram gerakannya, tapi karena policies yang dioptimasi dengan RL. Robot belajar jatuh dan bangun kembali berulang di simulasi sebelum diterapkan di dunia nyata.
- RLHF (Reinforcement Learning from Human Feedback): Inilah yang mengubah Large Language Model dari “autocomplete canggih” menjadi asisten yang helpful. Model belajar dari preferensi manusia menggunakan PPO — menarik karena RLHF adalah jembatan antara RL klasik dan AI modern yang kita pakai sehari-hari.
Perbandingan Tiga Paradigma
| Paradigma | Data | Feedback | Contoh |
|---|---|---|---|
| Supervised | (input, label) | Benar/salah per contoh | Klasifikasi gambar |
| Unsupervised | Input saja | Tidak ada label | Clustering pelanggan |
| Reinforcement | Interaksi dengan environment | Reward tertunda | Game AI, robotika |
Catatan jujur penutup seri konsep: RL adalah area yang paling sulit saya debug. Reward yang salah desain menghasilkan perilaku absurd yang secara teknis “sukses” — agent menemukan celah yang tidak kita bayangkan, seperti bug yang mengeksploitasi undefined behavior. Merancang reward function ternyata seni semacam merancang metrik KPI: ukur hal yang salah, dapatkan hal yang salah, dengan sangat efisien.
Yang paling menarik dari RL menurut saya: ini satu-satunya paradigma di mana AI benar-benar “berpikir tentang masa depan”. Supervised learning memprediksi jawaban; unsupervised learning menemukan pola; tapi reinforcement learning membuat keputusan yang mengorbankan keuntungan sekarang demi hasil lebih besar nanti. Itu resonansi personal bagi saya — sebagai programmer, kita terus-menerus melakukan trade-off exploitation (tulis kode yang sudah kita tahu berhasil) dan exploration (pelajari framework baru yang mungkin lebih baik tapi butuh waktu). RL formalisasi dilemma yang kita hadapi setiap hari.
Komentar Terbaru