Fungsi nilai aproksimasi

Generalisasi antar-state dengan fitur dan jaringan.

Daftar isi

Fungsi nilai aproksimasi mengganti tabel $Q(s,a)$ dengan sebuah fungsi berparameter $\hat{q}(s,a;\theta)$ yang dapat digeneralisasi antar-state. Topik ini memperkenalkan bentuk aproksimator linear dan jaringan saraf sebagai fungsi nilai, menjelaskan mengapa generalisasi menjadi kebutuhan ketika state berdimensi tinggi, lalu menunjukkan satu langkah pelatihan terbimbing (supervised) pada CartPole-v1. Pembaca akan melihat sebuah jaringan kecil menghasilkan $Q$ pada observasi awal, lalu turun loss-nya setelah beberapa langkah gradient descent terhadap sebuah target.

Dari tabel ke fungsi berparameter#

Pada FrozenLake dengan 16 state, tabel $Q$ berukuran $16 \times 4$ cukup karena tiap state dikunjungi berulang dan nilainya disimpan secara independen. Pada CartPole-v1, observasi berupa vektor empat dimensi bernilai kontinu, sehingga jumlah state yang mungkin tidak terbatas. Menyimpan nilai per state menjadi tidak mungkin, dan pendekatan tabel gagal sebelum pelatihan dimulai. Aproksimasi fungsi mengatasi hal ini dengan memetakan observasi ke nilai aksi melalui parameter bersama, sehingga state yang berdekatan di ruang observasi memperoleh nilai yang berdekatan pula.

Bentuk paling sederhana adalah aproksimator linear, $\hat{q}(s,a;\theta)=\theta^\top \phi(s,a)$ , dengan $\phi(s,a)$ vektor fitur yang dibuat dari $s$ dan $a$ . Pendekatan ini murah dan stabil, namun terbatas pada representasi linear sehingga kesalahannya tetap besar pada hubungan nonlinear. Jaringan saraf memperluasnya menjadi $\hat{q}(s,a;\theta)=f_\theta(s,a)$ dengan $f_\theta$ nonlinear, sehingga kapasitas representasi meningkat tajam pada observasi berdimensi tinggi. Karena $Q$ sekarang berparameter, pelatihan dilakukan dengan menurunkan loss terhadap target, bukan menimpa entri tabel.

Satu langkah pelatihan terbimbing pada jaringan kecil#

Berkas aproksimasi_nilai.py berikut membangun jaringan satu lapis tersembunyi berukuran 32 yang memetakan observasi CartPole-v1 ke dua nilai aksi. Jaringan belum dilatih, sehingga keluarannya pada observasi awal mencerminkan inisialisasi acak. Sebuah target tetap $[1{,}0, 0{,}5]$ ditetapkan, dan lima langkah SGD menurunkan MSE antara prediksi dan target.

python aproksimasi_nilai.py

import warnings; warnings.filterwarnings("ignore")
import numpy as np, torch
np.random.seed(0); torch.manual_seed(0)
import random; random.seed(0)
import gymnasium as gym
torch.set_printoptions(precision=4, sci_mode=False)

env = gym.make("CartPole-v1")
obs, info = env.reset(seed=0)
env.action_space.seed(0)
env.observation_space.seed(0)

class QNet(torch.nn.Module):
    def __init__(self, obs_dim, n_actions, hidden=32):
        super().__init__()
        self.net = torch.nn.Sequential(
            torch.nn.Linear(obs_dim, hidden),
            torch.nn.ReLU(),
            torch.nn.Linear(hidden, n_actions),
        )
    def forward(self, x):
        return self.net(x)

qnet = QNet(4, 2, 32)
obs_t = torch.tensor(obs, dtype=torch.float32).unsqueeze(0)
q_values = qnet(obs_t)
print("obs         =", obs)
print("Q(s, .)     =", q_values.detach().flatten())

target = torch.tensor([[1.0, 0.5]])
loss_fn = torch.nn.MSELoss()
loss_before = loss_fn(q_values, target)
print("loss_before =", f"{loss_before.item():.4f}")

opt = torch.optim.SGD(qnet.parameters(), lr=0.1)
for _ in range(5):
    pred = qnet(obs_t)
    loss = loss_fn(pred, target)
    opt.zero_grad()
    loss.backward()
    opt.step()
pred_after = qnet(obs_t)
loss_after = loss_fn(pred_after, target)
print("loss_after  =", f"{loss_after.item():.4f}")
print("Q(s, .) aft =", pred_after.detach().flatten())

text Keluaran

obs         = [ 0.01369617 -0.02302133 -0.04590265 -0.04834723]
Q(s, .)     = tensor([-0.2024, -0.0397])
loss_before = 0.8686
loss_after  = 0.0570
Q(s, .) aft = tensor([0.6966, 0.3520])

Generalisasi melalui parameter bersama#

Loss turun dari 0,8686 menjadi 0,0570 setelah lima langkah, dan prediksi $Q(s,\cdot)$ bergeser dari $[-0{,}2024, -0{,}0397]$ menjadi $[0{,}6966, 0{,}3520]$ , mendekati target $[1{,}0, 0{,}5]$ . Yang penting, pembaruan ini dilakukan pada satu observasi, namun karena parameter jaringan bersama, perubahan pada bobot juga menggeser $Q$ untuk observasi lain yang berdekatan. Inilah generalisasi: pembaruan pada satu state membawa state lain ikut berubah sesuai kemiripan fiturnya.

Generalisasi ini bermata dua. Pada state yang berkaitan secara halus, generalisasi mempercepat pelatihan karena satu pembaruan memperbaiki banyak sekaligus. Pada state yang sekilas mirip namun berperilaku berbeda, generalisasi justru menyebarkan kesalahan dan menimbulkan interferensi negatif. Inilah sebabnya pemilihan fitur atau arsitektur jaringan menjadi penentu kualitas aproksimasi, dan sebagian besar penyempurnaan DQN pada topik selanjutnya menargetkan kestabilan pelatihan alih-alih sekadar menambah kapasitas.

Kesalahan umum#

Mengangkat target langsung dari prediksi jaringan. Penyebabnya, target dihitung dari $\hat{q}(s',a';\theta)$ dengan $\theta$ yang sama yang sedang diupdate, sehingga target ikut berubah pada setiap langkah. Akibatnya, pelatihan menjadi tidak stabil karena mengejar target yang bergerak. Perbaikannya, gunakan jaringan target yang bobotnya diperbarui secara berkala, yang menjadi pokok bahasan pada topik replay dan target network.

Lupa menstandardisasi skala observasi. Penyebabnya, observasi mentah dengan rentang besar, misalnya sudut CartPole yang kecil bersanding kecepatan yang besar, dimasukkan langsung ke jaringan. Akibatnya, gradien pada dimensi berskala besar mendominasi dan pelatihan tidak seimbang. Perbaikannya, standardisasi observasi ke rentang sekitar nol, baik dengan normalisasi batch maupun dengan informasi statistik dari observation_space.

Ringkasan#

Aproksimasi fungsi mengganti tabel $Q(s,a)$ dengan fungsi berparameter $\hat{q}(s,a;\theta)$ , yang menggeneralisasi antar-state melalui parameter bersama.
Aproksimator linear murah dan stabil namun terbatas, sedangkan jaringan saraf menambah kapasitas nonlinear pada observasi berdimensi tinggi.
Satu langkah supervised pada CartPole-v1 menurunkan MSE dari 0,8686 ke 0,0570 dalam lima langkah SGD, dan prediksi $Q(s,\cdot)$ bergeser mendekati target $[1{,}0, 0{,}5]$ .

Referensi#

Reinforcement Learning: An Introduction, ch. 9 — Sutton & Barto — Bab “On-policy Prediction with Approximation” yang memperkenalkan aproksimasi fungsi nilai dan generalisasinya.
Human-level control through deep reinforcement learning — Mnih et al. 2015 — Makalah DQN yang memakai jaringan saraf sebagai fungsi nilai pada observasi piksel.