Belajar Machine Learning - Reinforcement Learning (Pengenalan)

#Pendahuluan

Semua model yang kita bangun sejauh ini belajar dari data statis: contoh berlabel yang sudah ada. Episode ini memperkenalkan paradigma yang sama sekali berbeda: reinforcement learning (RL) — belajar dari tindakan dan konsekuensinya.

Bayangkan belajar main sepeda: tidak ada dataset "cara menyeimbangkan badan". Kalian mencoba, jatuh, merasakan sakit (hukuman), menyesuaikan, dan akhirnya bisa. RL meniru proses ini: agent belajar kebijakan optimal melalui trial-and-error dengan sinyal reward. Ini cara model belajar hal yang belum pernah terjadi di data historis — relevan untuk robotika, game, dan optimasi keputusan berurutan.

#Komponen Dasar RL

RL dibangun dari lima komponen:

Lingkaran inilah inti RL: agent mengamati state, memilih action, environment merespons dengan state baru dan reward, lalu berulang. Tujuan agent: memaksimalkan total reward kumulatif, bukan hanya reward langsung — kadang langkah yang tampak merugi sekarang membuahkan hasil besar di kemudian hari (exploration).

#Eksplorasi vs Eksploitasi

Dilema paling fundamental di RL: eksploitasi (lakukan action yang sudah terbukti bagus) vs eksplorasi (coba action baru yang bisa lebih baik). Terlalu banyak eksploitasi → agent terjebak di solusi suboptimal. Terlalu banyak eksplorasi → buang waktu.

Strategi paling umum: epsilon-greedy. Dengan probabilitas ε pilih action acak (eksplorasi), selebihnya pilih action terbaik menurut pengetahuan saat ini (eksploitasi):

import random
 
def choose_action(q_values, epsilon=0.1):
    if random.random() < epsilon:
        return random.randrange(len(q_values))  # eksplorasi
    return int(q_values.argmax())              # eksploitasi

epsilon biasanya diturunkan seiring waktu — awal banyak eksplorasi, makin lama makin eksploitasi.

#Q-Learning: RL Tabel

Q-Learning adalah algoritma dasar RL: ia memelihara tabel Q-table berisi nilai Q(s, a) — "seberapa baik action a di state s". Agent memperbarui tabel ini setiap langkah menggunakan Bellman equation:

alpha = 0.1   # learning rate
gamma = 0.9   # discount factor
 
def update_q(q_table, state, action, reward, next_state):
    best_next = q_table[next_state].max()
    q_table[state, action] += alpha * (
        reward + gamma * best_next - q_table[state, action]
    )

gamma dekat 1 → agent mempertimbangkan reward jangka panjang; dekat 0 → hanya peduli reward segera. Q-Learning bagus untuk state terbatas; untuk state kontinu tak terbatas, tabel tidak mungkin — di situlah DQN masuk.

#DQN: Neural Network sebagai Q-Function

Deep Q-Network (DQN) mengganti tabel Q dengan neural network yang menghitung Q(s, a) dari state apa pun. Inilah RL yang mengalahkan manusia di game Atari (DeepMind, 2015).

import torch
import torch.nn as nn
 
class DQN(nn.Module):
    def __init__(self, n_state, n_action):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n_state, 128),
            nn.ReLU(),
            nn.Linear(128, n_action),
        )
 
    def forward(self, state):
        return self.net(state)  # Q(s, a) untuk semua action

Dua trick yang membuat DQN stabil: experience replay (simpan transisi dan sampling acak untuk training — memutus korelasi antar langkah) dan target network (Q yang di-update pelan-pelan). Detail implementasi penuh ada di series learn-deep-learning; di sini yang penting memahami konsepnya.

#PPO: Standar 2026 untuk Kebijakan

PPO (Proximal Policy Optimization) adalah keluarga policy gradient: ia mengoptimalkan kebijakan (policy) langsung — memetakan state ke action — alih-alih nilai Q. PPO menambahkan batasan agar update kebijakan tidak terlalu besar per langkah, sehingga training stabil.

PPO adalah default pilihan industri 2026: stabil, bisa dilatih paralel, dan bekerja baik di robotika, game, dan fine-tuning LLM (RLHF). Untuk praktik langsung, kalian biasanya tidak menulis PPO dari nol — memakai library seperti Stable-Baselines3:

from stable_baselines3 import PPO
 
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=100_000)

#Praktik dengan Gymnasium

Gymnasium (penerus OpenAI Gym) menyediakan banyak environment siap pakai — tempat terbaik untuk memulai.

#Bandit Problem: Klik yang Tepat

Masalah bandit adalah RL paling sederhana: satu state, beberapa action, reward acak. Agent harus menemukan action terbaik. Ini pondasi eksplorasi vs eksploitasi.

import gymnasium as gym
import numpy as np
 
env = gym.make("BanditTwoArmedHighLowFixed-v0")
 
q = np.zeros(env.action_space.n)
counts = np.zeros(env.action_space.n)
 
for _ in range(200):
    action = choose_action(q, epsilon=0.2)
    _, reward, terminated, _, _ = env.step(action)
 
    counts[action] += 1
    q[action] += (reward - q[action]) / counts[action]
    env.reset()
 
print(f"Q-values: {q}")  # action terbaik punya Q tertinggi

Perhatikan: Q diperbarui sebagai rata-rata bergerak dari reward per action — persis konsep Q-Learning dalam bentuk paling sederhana.

#Cartpole: Keseimbangan yang Dijaga

Cartpole adalah environment klasik: tiang di atas kereta, agent menggerakkan kereta kiri/kanan agar tiang tidak jatuh. State-nya kontinu (posisi, sudut), sehingga Q-Learning tabel tidak cukup — tempat ideal mencoba DQN atau PPO:

import gymnasium as gym
 
env = gym.make("CartPole-v1")
state, _ = env.reset()
 
for _ in range(10):
    action = env.action_space.sample()  # acak dulu
    state, reward, terminated, truncated, _ = env.step(action)
    if terminated or truncated:
        state, _ = env.reset()
 
print(f"Action space: {env.action_space}")
print(f"Observation: {state}")

Latih dengan PPO dari Stable-Baselines3, dan dalam ratusan ribu timesteps agent akan menjaga tiang tetap berdiri:

model = PPO("MlpPolicy", "CartPole-v1", verbose=0)
model.learn(total_timesteps=200_000)
 
state, _ = env.reset()
total_reward = 0
for _ in range(500):
    action, _ = model.predict(state, deterministic=True)
    state, reward, terminated, truncated, _ = env.step(action)
    total_reward += reward
    if terminated or truncated:
        break
 
print(f"Total reward: {total_reward}")  # 500 = sempurna

#Kapan Memakai RL

RL bukan solusi universal — ia untuk masalah keputusan berurutan dengan reward yang jelas:

Aturan praktis: jika kalian bisa membuat dataset berlabel, supervised learning lebih mudah dan stabil. RL layak dipertimbangkan saat keputusan saling bergantung dan berurutan.

#Common Pitfalls

• gamma terlalu kecil — agent hanya peduli reward segera, tidak belajar strategi jangka panjang.
• epsilon tidak diturunkan — terus eksplorasi, tidak pernah memantapkan strategi.
• Menilai RL dari sedikit episode — training butuh ribuan hingga jutaan timesteps.
• Menerapkan RL ke masalah yang butuh supervised — salah alat, hasil tidak stabil.
• Lupa env.reset() antar episode — state kotor, training kacau.

#Penutup

Pada episode 21 ini, kalian telah mengenal paradigma reinforcement learning.

Inti yang harus dibawa pulang:

• RL = agent belajar dari interaksi: state, action, reward, memaksimalkan reward kumulatif.
• Eksplorasi vs eksploitasi dikendalikan epsilon-greedy.
• Q-Learning untuk state terbatas; DQN menggantikan tabel dengan neural network; PPO standar modern.
• Gymnasium untuk praktik: bandit problem dan CartPole.
• RL untuk keputusan berurutan, bukan pengganti supervised.

Di episode 22 selanjutnya kita membahas scale: big data & AutoML — memproses dataset besar dengan Polars, Dask, dan Spark ML, lalu AutoML (auto-sklearn, H2O, Optuna + TPOT) dan kapan memakai AutoML vs manual. Sampai jumpa di episode 22!