Konsep Reinforcement Learning

Chapter penutup Section Causal Machine Learning berakhir pada satu pertanyaan: apa yang terjadi jika kita melakukan satu perubahan sekali. Reinforcement learning (RL) membalik arah pertanyaan tersebut — alih-alih menilai satu intervensi, RL mempelajari bagaimana seorang agent mengambil keputusan berulang kali dan memperbaiki dirinya dari konsekuensi tindakannya sendiri. Tidak ada guru yang membubuhkan label “aksi yang benar” pada setiap keputusan; satu-satunya umpan balik adalah sinyal ganjaran (reward) yang sering baru tiba beberapa langkah setelah keputusan diambil. Paradigma ini menjadi fondasi sistem yang mengendalikan robot pengantar di gudang, menyetel penempatan iklan, dan mengatur pendinginan ruang server. Chapter ini membangun kosakata dasarnya — lingkar agent-environment, episode, kebijakan, dan fungsi nilai — di atas dunia mainan yang bisa kita hitung dengan tangan.

Lingkar Agent dan Environment #

Aturan main RL dapat diringkas menjadi satu lingkar yang diulang terus-menerus. Pada langkah ke-t, agent membaca state saat ini s_t, lalu memilih sebuah action a_t. Environment — dunia tempat agent berada — merespons dengan dua hal: ganjaran skalar r_t dan state baru s_t+1. Agent tidak diberi tahu aksi mana yang seharusnya dipilih; agent hanya melihat akibat dari aksi yang benar-benar dipilih. Urutan s_0, a_0, r_0, s_1, a_1, r_1, ... berjalan sampai kondisi berhenti tercapai — target tercapai, batas langkah terlampaui, atau agent gagal — dan satu putaran penuh semacam itu kita sebut satu episode.

Tujuan agent dinyatakan bukan sebagai “menebak aksi yang benar”, melainkan memaksimalkan jumlah ganjaran yang terkumpul sepanjang episode. Formulasi ini terasa asing bagi yang terbiasa supervised learning, dan perbedaan itulah yang perlu kita luruskan sebelum lanjut.

Tanpa Jawaban Benar: RL vs Supervised vs Unsupervised #

Ketiga paradigma pembelajaran mesin dibedakan paling jernih lewat sumber umpan baliknya. Supervised learning menerima pasangan input–label; kekeliruan prediksi langsung terlihat karena jawaban benar tersedia. Unsupervised learning tidak menerima label dan mencari struktur tersembunyi pada data. RL tidak menerima keduanya: data yang dilihat agent adalah akibat tindakannya sendiri, dan penilaian baik-buruknya datang terlambat — ganjaran di langkah t bisa menjadi buah dari keputusan di langkah t−5.

Dua konsekuensi praktis mengikuti tabel di atas. Pertama, data RL tidak berdistribusi tetap: kebijakan yang terus berubah membuat data yang dikumpulkan besok berbeda dari hari ini. Kedua, agent pemalas tidak akan pernah tahu bahwa aksi yang belum pernah dicoba sebenarnya lebih baik — masalah eksplorasi yang kita bahas tuntas pada Chapter Exploration vs Exploitation.

Hipotesis Ganjaran #

Kalau satu-satunya umpan balik adalah angka ganjaran, apakah semua tujuan bisa dinyatakan lewat angka tersebut? Jawaban kerja di dunia RL disebut hipotesis ganjaran (reward hypothesis), dirumuskan oleh Sutton dan Barto: segala tujuan dapat diringkas menjadi memaksimalkan nilai harapan dari jumlah ganjaran yang terkumpul. Hipotesis ini bukan teorema yang terbukti, melainkan kesepakatan desain yang produktif — ia mengubah “agent yang bekerja baik” menjadi target yang bisa dihitung.

Konsekuensinya, ganjaran adalah kenop desain, bukan kebenaran yang jatuh dari langit. Di koridor nanti kita menetapkan biaya −1 per langkah dan bonus +10 di tujuan; angka tersebut secara diam-diam mengajari agent bahwa waktu adalah sumber daya yang harus dihemat. Ubah angkanya, dan perilaku optimal yang muncul ikut berubah — babak akhir Section ini (Chapter Arah Deep Reinforcement Learning) menampilkan contoh nyata betapa teliti penentuan ganjaran harus dirancang.

Kamus Lima Istilah Inti #

• Kebijakan (policy, π): aturan pemilihan aksi, pemetaan dari state ke aksi — boleh deterministik maupun acak. Kebijakan adalah “hasil akhir” yang kita cari.
• Return (G_t): jumlah ganjaran yang terkumpul dari langkah t sampai episode berakhir, biasanya dengan diskon yang kita temui di Chapter Markov Decision Process.
• Fungsi nilai (value function, V): taksiran nilai harapan return jika memulai dari sebuah state lalu mengikuti kebijakan tertentu.
• Fungsi nilai-aksi (action-value function, Q): seperti V, tetapi dengan satu aksi pertama yang sudah dipatok — bahan bakar utama Q-learning.
• Model lingkungan (environment model): pengetahuan tentang P dan R — peluang transisi dan ganjaran — jika tersedia. RL yang belajar tanpanya disebut model-free.

Dunia Mainan: Koridor Satu Dimensi #

Mari kita wujudkan seluruh kosakata di atas ke dalam dunia terkecil yang masih bermakna: sebuah koridor 8 sel. Agent robot mini mulai di sel 0 dan tujuan berada di sel 7. Dua aksi tersedia — kiri dan kanan — dengan dinding kiri yang menahan agent tetap di tempat. Setiap langkah berbiaya −1 (baterai terpakai), dan tiba di sel 7 memberi bonus +10 lalu mengakhiri episode pada batas 30 langkah. Kita membandingkan dua kebijakan: kebijakan acak yang melempar koin setiap langkah, dan kebijakan terarah yang selalu melangkah ke kanan.

# Koridor satu dimensi: dunia mainan paling kecil untuk merasakan
# lingkar agent-environment. Agent bergerak di koridor 8 sel dan
# tujuan berada di ujung kanan. Kita membandingkan dua kebijakan:
# kebijakan acak (kiri/kanan dengan peluang sama) dan kebijakan
# terarah (selalu melangkah ke kanan).

import numpy as np

PANJANG_KORIDOR = 8          # state sah: 0..7
POSISI_AWAL = 0
POSISI_TUJUAN = 7
BATAS_LANGKAH = 30           # batas panjang satu episode
GANJARAN_LANGKAH = -1.0      # biaya setiap langkah
GANJARAN_TUJUAN = 10.0       # bonus saat tiba di tujuan


def kebijakan_acak(posisi, rng):
    """Kebijakan tanpa pengetahuan: kiri atau kanan dengan peluang sama."""
    return 1 if rng.random() < 0.5 else 0


def kebijakan_terarah(posisi, rng):
    """Kebijakan yang ditulis tangan: selalu melangkah ke kanan."""
    return 1


def transisi(posisi, aksi):
    """Dinamika koridor: dinding kiri menahan agent tetap di sel 0."""
    if aksi == 1:
        return min(posisi + 1, POSISI_TUJUAN)
    return max(posisi - 1, 0)


def jalankan_episode(kebijakan, rng):
    """Satu episode lengkap.

    Mengembalikan (total ganjaran, jumlah langkah, sampai tujuan, jejak posisi).
    """
    posisi = POSISI_AWAL
    total = 0.0
    jejak = [posisi]
    for langkah_ke in range(1, BATAS_LANGKAH + 1):
        aksi = kebijakan(posisi, rng)
        pos_baru = transisi(posisi, aksi)
        jejak.append(pos_baru)
        if pos_baru == POSISI_TUJUAN:
            total += GANJARAN_TUJUAN
            return total, langkah_ke, True, jejak
        total += GANJARAN_LANGKAH
        posisi = pos_baru
    return total, BATAS_LANGKAH, False, jejak


rng = np.random.default_rng(42)
N_EPISODE = 10

print("Koridor 8 sel | tujuan sel 7 | batas 30 langkah per episode")
print("Kebijakan acak vs kebijakan terarah (selalu ke kanan)\n")

hasil_acak = []
hasil_terarah = []
for ep in range(1, N_EPISODE + 1):
    total_a, langkah_a, sampai_a, jejak_a = jalankan_episode(kebijakan_acak, rng)
    total_t, langkah_t, sampai_t, jejak_t = jalankan_episode(kebijakan_terarah, rng)
    hasil_acak.append((total_a, langkah_a, sampai_a))
    hasil_terarah.append((total_t, langkah_t, sampai_t))
    if ep == 1:
        print(f"Jejak episode 1 kebijakan acak    : {jejak_a}")
        print(f"Jejak episode 1 kebijakan terarah : {jejak_t}\n")

print(f"{'Ep':>3} | {'acak: total':>12} {'langkah':>7} {'sampai':>6} | "
      f"{'terarah: total':>15} {'langkah':>7} {'sampai':>6}")
for ep, (a, t) in enumerate(zip(hasil_acak, hasil_terarah), start=1):
    print(f"{ep:>3} | {a[0]:>12.1f} {a[1]:>7} {'ya' if a[2] else 'tidak':>6} | "
          f"{t[0]:>15.1f} {t[1]:>7} {'ya' if t[2] else 'tidak':>6}")

rata_acak = sum(h[0] for h in hasil_acak) / N_EPISODE
rata_terarah = sum(h[0] for h in hasil_terarah) / N_EPISODE
sampai_acak = sum(1 for h in hasil_acak if h[2])
sampai_terarah = sum(1 for h in hasil_terarah if h[2])

print(f"\nRata-rata total ganjaran | acak: {rata_acak:+.3f} | "
      f"terarah: {rata_terarah:+.3f}")
print(f"Episode mencapai tujuan   | acak: {sampai_acak}/{N_EPISODE} | "
      f"terarah: {sampai_terarah}/{N_EPISODE}")
print("Ganjaran terarah selalu: 7 langkah, 6 x (-1) + 10 = +4.0")

Output yang Dihasilkan:

Koridor 8 sel | tujuan sel 7 | batas 30 langkah per episode
Kebijakan acak vs kebijakan terarah (selalu ke kanan)

Jejak episode 1 kebijakan acak    : [0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 2, 3, 2, 1, 0, 1, 2, 1, 2, 1, 0, 0, 1, 0, 0, 0, 1, 2, 3, 4, 3]
Jejak episode 1 kebijakan terarah : [0, 1, 2, 3, 4, 5, 6, 7]

 Ep |  acak: total langkah sampai |  terarah: total langkah sampai
  1 |        -30.0      30  tidak |             4.0       7     ya
  2 |          2.0       9     ya |             4.0       7     ya
  3 |        -30.0      30  tidak |             4.0       7     ya
  4 |        -14.0      25     ya |             4.0       7     ya
  5 |        -30.0      30  tidak |             4.0       7     ya
  6 |        -12.0      23     ya |             4.0       7     ya
  7 |        -30.0      30  tidak |             4.0       7     ya
  8 |        -30.0      30  tidak |             4.0       7     ya
  9 |        -30.0      30  tidak |             4.0       7     ya
 10 |        -30.0      30  tidak |             4.0       7     ya

Rata-rata total ganjaran | acak: -23.400 | terarah: +4.000
Episode mencapai tujuan   | acak: 3/10 | terarah: 10/10
Ganjaran terarah selalu: 7 langkah, 6 x (-1) + 10 = +4.0

Mari kita bedah bagian-bagian pentingnya:

1. Baris 9–14 (konstanta dunia): kelima konstanta ini adalah definisi lengkap lingkungan koridor — state sah 0 sampai 7, posisi awal, tujuan, batas episode, dan struktur ganjaran. Mengubah satu angka di sini sama dengan mendesain ulang masalah.
2. Baris 17–24 (dua kebijakan): kebijakan_acak memakai rng.random() < 0.5 sebagai pelempar koin, sedangkan kebijakan_terarah mengabaikan posisi dan rng lalu selalu mengembalikan 1 (kanan). Keduanya menerima tanda tangan yang sama sehingga bisa dipertukarkan di dalam jalankan_episode.
3. Baris 27–31 (transisi): fungsi ini adalah environment dalam bentuk paling murni — min dan max memodelkan pergerakan serta dinding kiri yang menahan agent di sel 0.
4. Baris 34–51 (jalankan_episode): lingkar agent-environment yang sesungguhnya. Setiap iterasi membaca state, memilih aksi, memanggil transisi, lalu membukukan ganjaran; kondisi pos_baru == POSISI_TUJUAN mengakhiri episode dengan bonus, dan jika 30 langkah habis, episode berakhir tanpa bonus.
5. Baris 54 (np.random.default_rng(42)): seluruh keacakan kebijakan acak mengalir dari satu generator berseed, sehingga hasil eksekusi identik setiap kali dijalankan.
6. Baris 62–69 (perbandingan berpasangan): kedua kebijakan menjalani 10 episode dari kondisi awal yang sama; jejak episode 1 dicetak agar lingkar state-aksi-ganjaran terlihat konkret.

Celah antara kedua kolom hasil itulah seluruh kisah RL. Kebijakan terarah selalu menuntaskan episode dalam 7 langkah dengan total +4,0 — tujuh langkah berbiaya −6 ditambah bonus +10 — sedangkan kebijakan acak rata-rata merugi −23,4 dan hanya 3 dari 10 episode yang sampai tujuan sebelum batas 30 langkah. Perhatikan juga episode 2 kebijakan acak yang beruntung (+2,0 dengan 9 langkah): hasil satu episode belum tentu mencerminkan kualitas kebijakan, sehingga penilaian RL selalu memerlukan rata-rata lintas banyak episode. Yang tidak ada di kode ini adalah cara menemukan kebijakan terarah — sampai sekarang kita menuliskannya dengan tangan. Mengubah lingkar longgar ini menjadi masalah matematis yang bisa dipecahkan algoritme adalah tugas Chapter Markov Decision Process.

Referensi Resmi #

• numpy — Random sampling (numpy.random) — dokumentasi resmi Generator default_rng yang menjadi sumber keacakan tunggal pada contoh koridor.
• numpy — numpy.argmax — API resmi pemilihan indeks bernilai maksimum yang akan sering kita pakai sepanjang Section ini.
• Gymnasium — situs resmi pustaka lingkungan RL standar industri; di Course ini kita membangun lingkungan sendiri dengan NumPy murni karena pustaka tersebut tidak terpasang di lingkungan belajar.