Dasar Reinforcement Learning

Sepanjang course ini kita melatih model dari data yang sudah tersedia: dataset berlabel pada supervised learning, atau pretext task buatan pada self-supervised learning. Reinforcement learning (RL) mengambil jalan berbeda — tidak ada dataset yang disiapkan sebelumnya; data tercipta saat model, yang kita sebut agent, berinteraksi dengan sebuah environment dan menerima sinyal reward. Sinyal itu sering jarang (hanya muncul di akhir permainan, misalnya), namun darinya agent harus menyusun keputusan berurutan: aksi sekarang memengaruhi situasi yang akan dihadapi besok. Pada chapter ini kita membedakan paradigma ini dari supervised learning, mengenali istilah intinya, lalu menjalankan agen acak pada dunia mini sebagai titik pembanding.

Paradigma Ketiga: Belajar dari Interaksi #

Cara paling cepat memahami RL adalah membandingkannya dengan supervised learning yang sudah kita kuasai, misalnya pada chapter Loss Function :

Kolom kedua dari bawah adalah pembeda paling mendasar. Seorang pengendali robot yang mengambil keputusan buruk sekarang akan menghadapi posisi yang lebih sulit pada langkah berikutnya — datanya sendiri bergeser akibat aksinya. Karena itu pula dataset RL tidak bisa “dikumpulkan sekali lalu dipakai selamanya” tanpa pertimbangan eksplorasi, tema yang kita bahas tuntas pada chapter Exploration vs Exploitation .

Siklus Agent dan Environment #

Seluruh RL berputar pada satu loop. Agent membaca state, memilih action; environment menjawab dengan reward dan state baru:

Loop ini berjalan dari reset() hingga episode berakhir — target tercapai, atau batas langkah terlampaui. Tidak ada guru yang menyebut aksi yang benar; paling banyak agent hanya tahu seberapa baik total reward yang terkumpul. Ketiadaan koreksi per-langkah inilah yang membuat RL terasa lambat dibanding supervised learning: satu sinyal reward harus menilai seluruh rangkaian keputusan yang mendahuluinya.

Istilah Inti #

Sebuah kebijakan baik adalah kebijakan yang menghasilkan total reward (disebut return) tinggi bila dijalankan dari state awal — definisi formal return dan cara menghitungnya membutuhkan kerangka Markov Decision Process pada chapter berikutnya.

Demo: GridWorld 1D dengan Agen Acak #

Sebelum ada algoritma belajar, kita butuh titik nol: seberapa baik performa kebijakan yang memilih aksi sepenuhnya acak. Berkas random_walk.py membangun dunia mini satu dimensi — 5 sel, target di sel 4, reward -0.1 per langkah dan +1 saat tiba — lalu menjalankan 10 episode dengan aksi acak:

"""GridWorld 1D mini: 5 sel, target di kanan, agen berjalan acak.

Episode dimulai di sel 0. Aksi "kanan" maju satu sel, aksi "kiri" mundur
satu sel (tidak bisa keluar papan). Setiap langkah dikenai reward -0.1;
mencapai sel 4 memberi reward +1.0 dan episode berakhir. Agen pada demo
ini memilih aksi secara acak -- belum ada proses belajar.
"""

import numpy as np

rng = np.random.default_rng(42)


class GridWorld1D:
    """Papan 1D sederhana: n sel, target di sel terakhir."""

    def __init__(self, jumlah_sel=5, maks_langkah=20):
        self.jumlah_sel = jumlah_sel
        self.maks_langkah = maks_langkah

    def reset(self):
        """Kembalikan agen ke sel 0; kembalikan state awal."""
        self.posisi = 0
        self.langkah_ke = 0
        return self.posisi

    def step(self, aksi):
        """Terima aksi (0=kiri, 1=kanan); kembalikan (state, reward, selesai)."""
        if aksi == 1:
            self.posisi = min(self.posisi + 1, self.jumlah_sel - 1)
        else:
            self.posisi = max(self.posisi - 1, 0)
        self.langkah_ke += 1
        selesai = self.posisi == self.jumlah_sel - 1
        reward = 1.0 if selesai else -0.1
        if self.langkah_ke >= self.maks_langkah:
            selesai = True
        return self.posisi, reward, selesai


def jalankan_episode(env, rng, catat=False):
    """Jalankan satu episode dengan aksi acak; kembalikan total reward."""
    env.reset()
    total = 0.0
    t = 0
    while True:
        t += 1
        aksi = int(rng.integers(0, 2))
        state, reward, selesai = env.step(aksi)
        total += reward
        if catat:
            nama = "kanan" if aksi else "kiri "
            print(f"  langkah {t:2d}: aksi={nama} -> state {state}, "
                  f"reward {reward:+.1f}")
        if selesai:
            break
    return total


env = GridWorld1D(jumlah_sel=5, maks_langkah=20)

print("Episode 1 (dicatat per langkah):")
total_1 = jalankan_episode(env, rng, catat=True)
print(f"  episode berakhir: total reward = {total_1:+.1f}")

print()
print("Total reward per episode (agen acak, 10 episode):")
totals = [total_1]
for episode in range(2, 11):
    totals.append(jalankan_episode(env, rng))
for episode, total in enumerate(totals, start=1):
    print(f"  episode {episode:2d}: total reward = {total:+.2f}")

print(f"\nRata-rata total reward : {np.mean(totals):+.3f}")
print(f"Episode mencapai target: {sum(t > 0 for t in totals)}/10")

Output yang Dihasilkan:

Episode 1 (dicatat per langkah):
  langkah  1: aksi=kiri  -> state 0, reward -0.1
  langkah  2: aksi=kanan -> state 1, reward -0.1
  langkah  3: aksi=kanan -> state 2, reward -0.1
  langkah  4: aksi=kiri  -> state 1, reward -0.1
  langkah  5: aksi=kiri  -> state 0, reward -0.1
  langkah  6: aksi=kanan -> state 1, reward -0.1
  langkah  7: aksi=kiri  -> state 0, reward -0.1
  langkah  8: aksi=kanan -> state 1, reward -0.1
  langkah  9: aksi=kiri  -> state 0, reward -0.1
  langkah 10: aksi=kiri  -> state 0, reward -0.1
  langkah 11: aksi=kanan -> state 1, reward -0.1
  langkah 12: aksi=kanan -> state 2, reward -0.1
  langkah 13: aksi=kanan -> state 3, reward -0.1
  langkah 14: aksi=kanan -> state 4, reward +1.0
  episode berakhir: total reward = -0.3

Total reward per episode (agen acak, 10 episode):
  episode  1: total reward = -0.30
  episode  2: total reward = -0.10
  episode  3: total reward = -0.60
  episode  4: total reward = +0.30
  episode  5: total reward = +0.00
  episode  6: total reward = -2.00
  episode  7: total reward = +0.00
  episode  8: total reward = -0.30
  episode  9: total reward = -2.00
  episode 10: total reward = +0.70

Rata-rata total reward : -0.430
Episode mencapai target: 4/10

Episode pertama memperlihatkan siklus agent-environment secara harfiah: aksi kiri di sel 0 membuat agen menabrak dinding dan tetap di state 0, tetap dikenai reward -0.1. Dari 14 langkah, hanya 7 yang benar-benar maju — total reward -0.3 meskipun target tercapai. Sepuluh episode berikutnya bervariasi luas: episode 10 beruntung (3 langkah, +0.70), sementara episode 6 dan 9 kehabisan 20 langkah tanpa pernah tiba (-2.00). Rata-rata -0.430 adalah baseline kebijakan acak; setiap algoritma RL yang kita pelajari selanjutnya dinilai dari kemampuannya menggeser angka ini ke atas. Mari kita telaah kodenya baris per baris:

1. Baris 9-11 (rng): generator acak dengan seed 42 — seluruh episode dapat direproduksi persis, dan angka pada blok output dijamin sama setiap kali skrip dijalankan.
2. Baris 14-19 (GridWorld1D.__init__): konfigurasi dunia disimpan sebagai atribut — 5 sel dan batas 20 langkah per episode.
3. Baris 21-25 (reset): memulai episode baru; posisi kembali ke sel 0 dan penghitung langkah dikosongkan. Konvensi reset()/step() ini meniru antarmuka pustaka environment standar seperti Gymnasium.
4. Baris 27-38 (step): satu putaran loop — aksi diterjemahkan menjadi perpindahan (dibatasi min/max agar tidak keluar papan), reward ditentukan (+1 di target, selain itu -0.1), episode ditandai selesai bila target tiba atau batas langkah tercapai.
5. Baris 41-57 (jalankan_episode): menjalankan loop hingga selesai; parameter catat mengaktifkan pencatatan per langkah untuk episode pertama saja agar keluaran tetap ringkas.
6. Baris 60-75: episode pertama dicatat penuh, sembilan episode berikutnya diringkas, lalu rata-rata dan jumlah episode yang mencapai target dicetak sebagai ringkasan baseline.

Di Mana RL Dipakai #

Tiga keluarga penerapan paling umum: permainan — dari Atari hingga Go, tempat skor permainan menjadi reward alami; robotika — robot belajar berjalan atau memindahkan objek dengan reward berbasis sensor; serta sistem rekomendasi dan alokasi sumber daya — reward berupa klik pengguna atau efisiensi energi, dengan state berupa konteks pengguna atau beban sistem. Ketiganya berbagi ciri yang sama: tidak ada “jawaban benar” yang bisa dilabeli ke setiap situasi; yang ada hanyalah konsekuensi bertingkat dari setiap aksi.

Agen acak memberi kita angka pembanding, tetapi pertanyaan sesungguhnya baru menyusul: dari mana reward itu berasal, dan bagaimana cara mendesainnya agar perilaku yang muncul memang perilaku yang kita inginkan? Desain reward yang ceroboh bisa menghasilkan agen yang mengambil jalan tak terduga — pembahasan itu menjadi fokus chapter Agent, Environment, dan Reward .