Memulai TorchRL untuk Deep Reinforcement Learning

Menyiapkan TorchRL

Pada bagian ini, saya akan menunjukkan cara menginstal dan mulai menggunakan TorchRL. 

Prasyarat

Anda memerlukan beberapa paket perangkat lunak dependensi sebelum menginstal dan menggunakan TorchRL:

• PyTorch: TorchRL berbasis PyTorch, jadi Anda memerlukannya sebagai prasyarat. 
• Gymnasium: Anda membutuhkan paket Gymnasium untuk mengimpor environment RL. Per Januari 2025, versi terbaru Gymnasium tidak kompatibel dengan TorchRL, seperti dijelaskan pada halaman Git Discussions ini. Karena itu, instal versi lama 0.29.1. 
• PyGame: Ini adalah paket Python untuk gim video.  TorchRL membutuhkannya untuk mensimulasikan environment RL mirip gim, seperti CartPole. 
• TensorDict: Menggunakan struktur data mirip kamus untuk menyimpan input dan output jaringan saraf memudahkan bekerja dengan tensor di TorchRL. TensorDict menyediakan kontainer tensor yang menyimpan tensor sebagai pasangan kunci-nilai. 

Instal paket prasyarat:

!pip install torch tensordict  gymnasium==0.29.1 pygame

Menginstal TorchRL

Instal TorchRL menggunakan pip. Saya sangat menyarankan untuk menginstal paket-paket ini di lingkungan Conda jika Anda bekerja di komputer pribadi atau server. 

!pip install torchrl

Memverifikasi instalasi

Setelah menginstal, uji bahwa TorchRL telah terpasang dengan sukses. Coba impor torchrl di shell (atau notebook) Python. Gunakan metode check_env_specs() untuk memeriksa bahwa sebuah environment standar (seperti CartPole) sesuai dengan spesifikasi torchrl:

import torchrl 
from torchrl.envs import GymEnv 
from torchrl.envs.utils import check_env_specs

check_env_specs(GymEnv("CartPole-v1"))

Keluaran harus menunjukkan bahwa environment berhasil dibuat dan bekerja dengan TorchRL. 

[torchrl][INFO] check_env_specs succeeded!

Komponen Kunci TorchRL

Sebelum membangun agen RL pertama Anda, mari lihat blok bangunan inti TorchRL.

Environments

TorchRL menyediakan API seragam untuk berinteraksi dengan berbagai environment. Ini dilakukan dengan membungkus fungsionalitas spesifik setiap environment ke serangkaian kelas dan fungsi pembungkus standar. Anda meneruskan parameter yang sesuai ke pembungkus, dan secara internal ia memetakan perintah Anda ke pemanggilan fungsi yang sesuai pada environment spesifik. Khususnya:

• TorchRL mengonversi state (observasi), aksi, dan reward environment menjadi objek tensor PyTorch, yang dapat langsung digunakan oleh modul-modul yang mengimplementasikan algoritma RL.
• Memungkinkan penerapan langkah pra-pemrosesan dan pascapemrosesan, misalnya untuk menormalkan dan menskalakan tensor input atau menyajikan tensor output dalam format tertentu.

Sebagai contoh, untuk membuat environment dari Gymnasium, gunakan modul GymEnv:

env = GymEnv("CartPole-v1")

Transforms

Menambahkan fitur dan transformasi pada environment bawaan adalah hal yang umum dan sebaliknya harus Anda implementasikan sendiri. Misalnya, Anda dapat menambahkan modul penghitung langkah ke environment alih-alih menulis kodenya sendiri. Penghitung langkah melacak jumlah langkah di setiap episode. Modul transformedEnv membantu hal ini:

from torchrl.envs import GymEnv, StepCounter, TransformedEnv
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())

Demikian pula, menormalkan tensor sebelum mengoperasikannya adalah langkah pra-pemrosesan yang umum. Transformasi normalisasi, menggunakan modul ObservationNorm menormalkan tensor. Dokumentasi fungsi TransformedEnv membahas berbagai jenis transformasi. 

Anda juga dapat menggabungkan beberapa transformasi menggunakan parameter compose():

base_env = GymEnv('CartPole-v1', device=device) 

env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        StepCounter()
    )
)

Agen dan kebijakan (policy)

Dalam RL, agen menentukan aksinya menggunakan kebijakan dan berdasarkan state environment yang diamati. Tujuan agen adalah memaksimalkan reward kumulatif dari environment. Agen menerima reward saat memilih aksi yang tepat (seperti berhenti di lampu merah). 

Sebagai contoh, pada mobil swa-kemudi, agen mengemudikan mobil. Keputusannya (seperti membelokkan mobil ke arah tertentu) didasarkan pada observasi terhadap state environment (seperti lalu lintas, posisi mobil, dan sebagainya) dan kebijakannya (seperti menghindari pejalan kaki dan rintangan lainnya, berhenti di lampu merah, dan lain-lain). 

Kebijakan paling sederhana adalah memilih aksi secara acak. Aktor secara acak memilih salah satu aksi dari ruang aksi yang mungkin. Kebijakan acak terkadang digunakan untuk menghasilkan dataset awal interaksi sebelum mulai melatih model. 

Gunakan modul RandomPolicy untuk membuat kebijakan acak. Kebijakan acak ini menerima parameter action_spec yang menentukan ruang aksi. Pada contoh di bawah, ruang aksi terdiri dari angka (kontinu) antara -1 dan +1. Jadi, kebijakan acak memilih aksi yang direpresentasikan oleh angka acak antara -1 dan +1. 

import torchrl 
import torch
from tensordict import TensorDict
from torchrl.data.tensor_specs import Bounded

action_spec = Bounded(-torch.ones(1), torch.ones(1))
actor = torchrl.envs.utils.RandomPolicy(action_spec=action_spec) 
td = actor(TensorDict({}, batch_size=[])) 
print(td.get("action"))

Keluaran harus berupa tensor, seperti di bawah ini:

tensor([0.9258])

Periksa bahwa kebijakan memang acak dengan menjalankan aktor lagi:

td = actor(TensorDict({}, batch_size=[])) 
print(td.get("action"))

Seharusnya menghasilkan tensor acak yang berbeda.

Jika Anda membutuhkan pengantar konsep RL, lihat jalur keterampilan Reinforcement Learning in Python di DataCamp!

Membangun Agen RL Pertama Anda dengan TorchRL

Pada bagian ini, saya menunjukkan cara mengimplementasikan agen Reinforcement Learning sederhana menggunakan TorchRL. 

Sebelum mulai, impor paket perangkat lunak prasyarat di Python:

• time untuk mengukur waktu pelatihan agen.
• GymEnv, StepCounter, dan TransformedEnv untuk bekerja dengan environment Gymnasium.
• MLP untuk membuat jaringan saraf MLP (multi-layer perceptron) sederhana. 
• EGreedyModule untuk menyeimbangkan eksplorasi environment dan eksploitasi kebijakan terbaik yang diketahui.
• QValueModule dan DQNLoss untuk mengimplementasikan algoritma Deep Q-Learning.
• SoftUpdate untuk memperbarui jaringan saraf.
• SyncDataCollector untuk mengumpulkan data dari interaksi agen. 
• ReplayBuffer untuk menyimpan data dari interaksi agen.
• Adam untuk backpropagation.
• matplotlib untuk menampilkan progres pelatihan secara visual. 
• torchrl_logger untuk mencatat sesi pelatihan.

import time
import matplotlib.pyplot as plt
from torchrl.envs import GymEnv, StepCounter, TransformedEnv
from tensordict.nn import TensorDictModule as TensorDict, TensorDictSequential as Seq
from torchrl.modules import EGreedyModule, MLP, QValueModule
from torchrl.objectives import DQNLoss, SoftUpdate
from torchrl.collectors import SyncDataCollector
from torchrl.data import LazyTensorStorage, ReplayBuffer
from torch.optim import Adam
from torchrl._utils import logger as torchrl_logger

Langkah 1: Definisikan environment

Pada contoh ini, kita menyelesaikan environment CartPole. Impor environment ini dari Gymnasium beserta penghitung langkah untuk melacak jumlah langkah pelatihan:

env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())

Seed environment Python dan RL untuk mereplikasi hasil serupa di berbagai sesi pelatihan. 

torch.manual_seed(0)
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())
env.set_seed(0)

Definisikan parameter dan hiperparameter untuk pelatihan: 

• INIT_RAND_STEPS: Jumlah langkah di mana agen bertindak secara acak sebelum menggunakan kebijakan. Langkah awal ini digunakan untuk mengumpulkan data awal guna memulai pelatihan kebijakan.
• FRAMES_PER_BATCH: Jumlah titik data (satu untuk setiap interaksi atau time-step) dalam satu batch pelatihan. 
• OPTIM_STEPS: Jumlah langkah untuk mengakumulasi loss sebelum menjalankan satu kali backward pass. 
• EPS_0: Nilai awal epsilon, koefisien eksplorasi. 
• BUFFER_LEN: Ukuran replay buffer.
• ALPHA: Laju pembelajaran.
• TARGET_UPDATE_EPS: Faktor peluruhan untuk memperbarui target network dengan modul soft-update.
• REPLAY_BUFFER_SAMPLE: Ukuran sampel acak yang diambil dari replay buffer di setiap iterasi pelatihan. Replay buffer menyimpan hasil interaksi agen dengan environment di setiap timestep. 
• LOG_EVERY: Jumlah langkah setelah itu progres pelatihan dicetak.
• MLP_SIZE: Ukuran jaringan saraf.

INIT_RAND_STEPS = 5000 
FRAMES_PER_BATCH = 100
OPTIM_STEPS = 10
EPS_0 = 0.5
BUFFER_LEN = 100_000
ALPHA = 0.05
TARGET_UPDATE_EPS = 0.95
REPLAY_BUFFER_SAMPLE = 128
LOG_EVERY = 1000
MLP_SIZE = 64

Langkah 2: Buat kebijakan

Definisikan jaringan saraf sederhana untuk mengimplementasikan kebijakan: 

• Definisikan MLP (jaringan saraf). Diberi sebuah observasi, MLP menghasilkan nilai aksi, yang secara efektif menjalankan fungsi Q.
• Definisikan kamus tensor menggunakan modul TensorDict pada MLP di atas. Kamus ini memetakan observasi state environment (kunci kamus) ke nilai probabilitas aksi (nilai kamus) yang sesuai dengan state tersebut. 
• Gunakan QValueModule untuk mengimplementasikan fungsi Q. Diberi tensor yang berisi nilai aksi, modul ini mengembalikan aksi dengan nilai aksi tertinggi. Ini mengimplementasikan strategi greedy (eksploitasi). 
• Gabungkan (menggunakan TensorDictSequential module) kamus tensor MLP dan QValueModule untuk mendefinisikan kebijakan. 

value_mlp = MLP(out_features=env.action_spec.shape[-1], num_cells=[MLP_SIZE, MLP_SIZE])
value_net = TensorDict(value_mlp, in_keys=["observation"], out_keys=["action_value"])
policy = Seq(value_net, QValueModule(spec=env.action_spec))

• Definisikan fungsi eksplorasi menggunakan EGreedyModule - modul ini menerima masukan ruang aksi environment, panjang replay buffer, dan koefisien eksplorasi, epsilon. Rangkai (menggunakan modul TensorDictSequential) fungsi eksplorasi ini dengan kebijakan yang didefinisikan di atas untuk mendapatkan kebijakan akhir:

exploration_module = EGreedyModule(
    env.action_spec, annealing_num_steps=BUFFER_LEN, eps_init=EPS_0
)
policy_explore = Seq(policy, exploration_module)

Langkah 3: Latih agen

Langkah pertama dalam melatih agen adalah mengumpulkan data dari interaksi agen dengan environment. Gunakan SyncDataCollector untuk membangun kolektor yang mengeksekusi kebijakan dan mengumpulkan hasil interaksi agen: 

collector = SyncDataCollector(
    env,
    policy_explore,
    frames_per_batch=FRAMES_PER_BATCH,
    total_frames=-1,
    init_random_frames=INIT_RAND_STEPS,
)

Buat replay buffer untuk menyimpan hasil interaksi:

rb = ReplayBuffer(storage=LazyTensorStorage(BUFFER_LEN))

Anda juga perlu mendeklarasikan modul khusus pelatihan, seperti fungsi loss (untuk menggunakan perhitungan loss berbasis DQN), optimizer (algoritma Adam tradisional), dan fungsi updater (untuk memperbarui jaringan saraf). Semua ini berbasis modul TorchRL yang telah ditentukan:

loss = DQNLoss(value_network=policy, action_space=env.action_spec, delay_value=True)
optim = Adam(loss.parameters(), lr=ALPHA)
updater = SoftUpdate(loss, eps=TARGET_UPDATE_EPS)

Inisialisasi penghitung untuk melacak total jumlah langkah dan episode, langkah sukses per episode, serta waktu eksekusi:

total_count = 0
total_episodes = 0
t0 = time.time()
success_steps = []

Fungsi pelatihan terdiri dari 2 for loop: 

• Loop teratas mengeksekusi kebijakan dan menambahkan hasil interaksi agen ke replay buffer.
• Loop bagian dalam membagi sampel pelatihan menjadi batch. Setiap batch diproses sebagai berikut: 
• Ambil sampel acak dari replay buffer.
• Hitung loss menggunakan fungsi loss.
• Jalankan optimizer dan updater.
• Perbarui penghitung.

Setiap langkah melibatkan pemanggilan modul TorchRL siap pakai tanpa membuat kode dari nol. Kode di bawah ini menunjukkan cara mengimplementasikan langkah-langkah tersebut:

for i, data in enumerate(collector):
    rb.extend(data)
    max_length = rb[:]["next", "step_count"].max()
    if len(rb) > INIT_RAND_STEPS:
        for _ in range(OPTIM_STEPS):
            sample = rb.sample(REPLAY_BUFFER_SAMPLE)
            loss_vals = loss(sample)
            loss_vals["loss"].backward()
            optim.step()

            optim.zero_grad()
            # Update exploration factor
            exploration_module.step(data.numel())

            # Update target params
            updater.step()
            total_count += data.numel()
            total_episodes += data["next", "done"].sum()
    success_steps.append(max_length)

Langkah 4: Evaluasi agen

Loop pada bagian sebelumnya melatih kebijakan secara berkelanjutan. Kita perlu menetapkan kriteria untuk mengevaluasi kinerja dan memutuskan kapan pelatihan dianggap berhasil. Kita juga ingin menampilkan progres pelatihan. 

Kita mencetak progres pelatihan secara berkala menggunakan logger TorchRL:

if total_count > 0 and total_count % LOG_EVERY == 0:
    torchrl_logger.info(f"Successful steps in the last episode: {max_length}, rb length {len(rb)}, Number of episodes: {total_episodes}")

Kita menggunakan jumlah maksimum langkah yang dicapai agen pada episode terakhir untuk menentukan apakah pelatihan berhasil. Environment CartPole-v1 membatasi jumlah langkah maksimum dan total reward per episode hingga 500. Secara konvensional, kebijakan dianggap berhasil jika mencapai lebih dari 475 langkah:

if max_length > 475:
    print("TRAINING COMPLETE")
    break

Dua potongan kode di atas harus ditambahkan di akhir loop pelatihan (ditunjukkan sebelumnya). Kode berikut menunjukkan loop pelatihan dengan kode untuk mengevaluasi agen: 

for i, data in enumerate(collector):
    # Write data in replay buffer
    rb.extend(data)
    max_length = rb[:]["next", "step_count"].max()
    if len(rb) > INIT_RAND_STEPS:
        for _ in range(OPTIM_STEPS):
            sample = rb.sample(REPLAY_BUFFER_SAMPLE)
            loss_vals = loss(sample)
            loss_vals["loss"].backward()
            optim.step()

            optim.zero_grad()
            # Update exploration factor
            exploration_module.step(data.numel())

            # Update target params
            updater.step()
            total_count += data.numel()
            total_episodes += data["next", "done"].sum()
    success_steps.append(max_length)

    if total_count > 0 and total_count % LOG_EVERY == 0:
        torchrl_logger.info(f"Successful steps in the last episode: {max_length}, rb length {len(rb)}, Number of episodes: {total_episodes}")

    if max_length > 475:
        print("TRAINING COMPLETE")
        break

Terakhir, setelah pelatihan dan evaluasi, cetak total waktu pelatihan dan plot progres pelatihan:

t1 = time.time()

torchrl_logger.info(
    f"solved after {total_count} steps, {total_episodes} episodes and in {t1-t0}s."
)

def plot_steps():
    plt.plot(success_steps)
    plt.title('Successful steps over training episodes')
    plt.xlabel('Training episodes')
    plt.ylabel('Steps')
    plt.show()

plot_steps()

Anda dapat menemukan dan mengeksekusi kode lengkap untuk mengimplementasikan DQN menggunakan TorchRL di workbook DataLab ini. 

Pada bagian ini, kita membangun dan melatih agen RL menggunakan algoritma DQN sederhana. Pada bagian berikutnya, kita mengeksplorasi cara menggunakan modul TorchRL siap pakai untuk mengimplementasikan algoritma yang lebih kompleks seperti PPO. 

Mengeksplorasi Algoritma Siap Pakai di TorchRL

Seperti disebutkan di bagian sebelumnya, TorchRL hadir dengan beberapa algoritma siap pakai. Mari kita lihat dan cara kerjanya.

Algoritma yang didukung

TorchRL menyertakan modul siap pakai untuk banyak algoritma Deep Reinforcement Learning umum, seperti: 

• Deep Q networks (DQN)
• Deep deterministic policy gradient (DDPG)
• Soft actor-critic (SAC)
• Randomized ensembled double Q-learning (REDQ)
• CrossQ
• Implicit Q-learning (IQL)
• Continuous Q-learning (CQL)
• Generative adversarial imitation learning (GAIL)
• Decision transformer (DT)
• Twin-delayed DDPG (TD3) 
• Actor-advantage critic (A2C)
• Proximal policy optimization (PPO)
• REINFORCE
• dan lainnya 

Ini membuat eksperimen dengan berbagai jenis algoritma menjadi efisien dan mempelajari kinerja masing-masing untuk menyelesaikan suatu masalah tertentu. 

Contoh: PPO di TorchRL

Proximal Policy Optimization menggunakan fungsi objektif surrogate yang di-clipping untuk mencapai proses pelatihan yang mulus yang menyeimbangkan eksplorasi dan eksploitasi. 

Pada bagian ini, saya akan menunjukkan cara menggunakan modul PPO siap pakai di TorchRL. Mirip dengan implementasi sebelumnya, impor modul prasyarat. Selain modul (seperti ReplayBuffer, SyncDataCollector, dll.) yang dibutuhkan untuk implementasi sebelumnya, Anda memerlukan beberapa paket tambahan untuk PPO:

• ProbabilisticActor, untuk memilih aksi secara stokastik. Memilih aksi secara stokastik (alih-alih selalu mengikuti kebijakan dan memaksimalkan reward) memfasilitasi eksplorasi environment dan menemukan jalur yang lebih optimal selama pelatihan.
• OneHotCategorical, untuk menghasilkan one-hot encoding dari tensor yang menunjukkan log probabilitas aksi. 
• ValueOperator, untuk membangun modul TorchRL berbasis jaringan saraf yang mengimplementasikan fungsi nilai.
• GAE, untuk mengimplementasikan generalized advantage estimate. PPO menggunakan fungsi advantage sebagai proxy untuk fungsi nilai. Modul nilai (di atas) adalah masukan ke GAE. 
• ClipPPOLoss, untuk membangun fungsi objektif yang di-clipping guna mengimplementasikan PPO. 

import torch
from torch import nn

from torchrl.envs import Compose, ObservationNorm, DoubleToFloat, StepCounter, TransformedEnv
from torchrl.envs.libs.gym import GymEnv
from torchrl.envs.utils import check_env_specs
from torchrl.modules import ProbabilisticActor, OneHotCategorical, ValueOperator
from torchrl.collectors import SyncDataCollector
from torchrl.data.replay_buffers import ReplayBuffer
from torchrl.data.replay_buffers.storages import LazyTensorStorage
from torchrl.data.replay_buffers.samplers import SamplerWithoutReplacement
from torchrl.objectives.value import GAE
from torchrl.objectives import ClipPPOLoss
from tensordict.nn import TensorDictModule

Deklarasikan parameter dan hiperparameter untuk pelatihan:

• FRAMES_PER_BATCH: Jumlah frame (timestep) di setiap batch data hasil interaksi agen dengan environment. 
• SUB_BATCH_SIZE: Jumlah timestep di setiap sub-batch. Dalam pelatihan PPO, setiap batch dibagi menjadi sub-batch. 
• TOTAL_FRAMES: Total jumlah timestep untuk menjalankan pelatihan. 
• GAMMA: Faktor diskonto untuk mendiskonto nilai reward dari timestep masa depan.
• CLIP_EPSILON: Mendefinisikan trust region di mana kebijakan dapat berubah pada setiap iterasi pelatihan berikutnya. Ini diimplementasikan dengan melakukan clipping pada kebijakan yang diperbarui sehingga rasio antara probabilitas baru dan lama berada dalam batas tertentu. 
• ALPHA: Laju pembelajaran.
• ENTROPY_EPS: Hiperparameter yang mengontrol perbandingan eksplorasi dan eksploitasi. 
• OPTIM_STEPS: Jumlah kali menjalankan optimizer pada setiap sub-batch data. 
• LOG_EVERY: Jumlah langkah setelah itu kebijakan dievaluasi dan reward dicetak. 

FRAMES_PER_BATCH = 1024
TOTAL_FRAMES = 1048576
GAMMA = 0.99
LAMBDA = 0.95
CLIP_EPSILON = 0.2
ALPHA = 1e-4
ENTROPY_EPS = 5e-4 
SUB_BATCH_SIZE = 64
OPTIM_STEPS = 8
LOG_EVERY = 16

Impor environment CartPole dasar dari Gymnasium:

device="cpu"
base_env = GymEnv('CartPole-v1', device=device) 

Deklarasikan environment TorchRL dengan mengimpor environment dasar dan menambahkan modul untuk menormalkan tensor observasi dan menghitung jumlah langkah:

env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        DoubleToFloat(), 
        StepCounter()
    )
)

Inisialisasi environment dan seed generator bilangan acak:

env.transform[0].init_stats(1024) 
torch.manual_seed(0)
env.set_seed(0)
check_env_specs(env) 

Deklarasikan aktor sebagai jaringan saraf dengan 1 hidden layer berisi 16 bobot. Jaringan ini menerima masukan observasi dari environment dan menghasilkan likelihood setiap aksi dalam ruang aksi. 

actor_net = nn.Sequential(
    nn.Linear(env.observation_spec["observation"].shape[-1], 32, device=device),
    nn.ReLU(),
    nn.Linear(32, 32, device=device),
    nn.ReLU(),
    nn.Linear(32, env.action_spec.shape[-1], device=device),
    nn.ReLU()
)

Buat kamus tensor (berdasarkan jaringan saraf di atas) dengan kunci dan nilai yang memetakan state ke probabilitas aksi. 

actor_module = TensorDictModule(actor_net, in_keys=["observation"], out_keys=["logits"])

Untuk melatih PPO (dan banyak algoritma RL lainnya), Anda tidak selalu memilih aksi yang menghasilkan reward tertinggi pada langkah berikutnya. Memiliki tingkat keacakkan dalam pemilihan aksi memungkinkan agen mengeksplorasi environment dan menemukan jalur yang lebih baik yang dapat menghasilkan return jangka panjang lebih tinggi. Buat probabilistic actor untuk melakukan ini:

actor = ProbabilisticActor(
    module = actor_module,
    spec = env.action_spec,
    in_keys = ["logits"],
    distribution_class = OneHotCategorical, 
    return_log_prob = True
)

Buat jaringan untuk mengimplementasikan fungsi nilai. Jaringan ini memiliki 16 bobot. Ia menerima masukan state (observasi) environment dan menghasilkan nilai harapan state tersebut. 

value_net = nn.Sequential(
    nn.Linear(env.observation_spec["observation"].shape[-1], 16, device=device),
    nn.ReLU(),
    nn.Linear(16, 1, device=device),
    nn.ReLU()
)

Buat modul TorchRL yang membungkus fungsi nilai (diimplementasikan di atas) menggunakan ValueOperator(). Modul ini berinteraksi dengan komponen TorchRL lainnya. 

value_module = ValueOperator(
    module = value_net,
    in_keys = ["observation"]
)

Buat replay buffer untuk menyimpan hasil interaksi agen dengan environment: 

replay_buffer = ReplayBuffer(
    storage = LazyTensorStorage(max_size=FRAMES_PER_BATCH),
    sampler = SamplerWithoutReplacement()
)

Buat data collector untuk menjalankan kebijakan pada environment dan mengumpulkan hasil interaksi agen dengan environment di setiap timestep (frame):

collector = SyncDataCollector(
    env,
    actor,
    frames_per_batch = FRAMES_PER_BATCH,
    total_frames = TOTAL_FRAMES,
    split_trajs = True,
    reset_at_each_iter = True,
    device=device
)

Gunakan modul GAE untuk mengimplementasikan fungsi advantage untuk PPO. Fungsi advantage berbasis fungsi nilai. 

advantage_module = GAE(
    gamma = GAMMA, 
    lmbda = GAMMA, 
    value_network = value_module,
    average_gae = True
) 

Gunakan modul bawaan ClipPPOLoss untuk mengimplementasikan fungsi loss sesuai algoritma PPO:

loss_module = ClipPPOLoss(
    actor_network = actor,
    critic_network = value_module,
    clip_epsilon = CLIP_EPSILON,
    entropy_bonus = bool(ENTROPY_EPS),
    entropy_coef = ENTROPY_EPS
)

Deklarasikan optimizer Adam: 

optim = torch.optim.Adam(loss_module.parameters(), lr=ALPHA)

Buat scheduler untuk secara bertahap mengurangi laju pembelajaran seiring progres pelatihan: 

scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, TOTAL_FRAMES // FRAMES_PER_BATCH)

Bangun loop pelatihan menggunakan komponen yang dibuat di atas. Fungsi pelatihan terdiri dari tiga loop for:

• Loop terluar menjalankan data yang dikumpulkan dari interaksi agen dengan environment. Parameter TOTAL_FRAMES menentukan berapa banyak timestep agen dijalankan. 
• Loop tengah melakukan hal berikut: 
• Menjalankan loop terdalam untuk jumlah iterasi tetap (biasanya antara 5 hingga 10), seperti didefinisikan oleh hiperparameter OPTIM_STEPS. 
• Memperbarui laju pembelajaran setelah setiap iterasi pelatihan. 
• Juga menghitung nilai fungsi advantage untuk setiap timestep. 
• Evaluasi kebijakan secara berkala dan cetak reward. 
• Loop terdalam menjalankan loop pelatihan:
• Ambil sampel batch data pelatihan dari replay buffer.
• Hitung loss menggunakan modul loss. 
• Jalankan backpropagation pada loss.
• Gunakan optimizer untuk melakukan gradient descent. 

Kode di bawah ini mengimplementasikan loop pelatihan:

for i, tensordict_data in enumerate(collector): 
    for _ in range(OPTIM_STEPS): 
        advantage_module(tensordict_data)
        replay_buffer.extend(tensordict_data.reshape(-1).cpu())
        for _ in range(FRAMES_PER_BATCH // SUB_BATCH_SIZE): 
            data = replay_buffer.sample(SUB_BATCH_SIZE)
            loss = loss_module(data.to(device))
            loss_value = loss["loss_objective"] + loss["loss_critic"] + loss["loss_entropy"]
            loss_value.backward()
            optim.step()
            optim.zero_grad()
    scheduler.step()

    if i % LOG_EVERY == 0:
        with torch.no_grad():
            rollout = env.rollout(FRAMES_PER_BATCH, actor)
            reward_eval = rollout["next","reward"].sum()
            #print(rollout["next","reward"].sum())
            print(reward_eval)
            rewards.append(reward_eval)
            del rollout

Workbook DataLab ini memiliki kode (seperti ditunjukkan di atas) untuk melatih agen RL menggunakan algoritma PPO dari TorchRL. Gunakan sebagai titik awal untuk menyetel parameter dan meningkatkan kinerja agen. 

Kustomisasi algoritma

TorchRL memiliki desain modular yang memungkinkan kustomisasi solusi RL. Kerangka kerja menangani penghubung antar komponen. Untuk menguji dan membandingkan kinerjanya, Anda dapat pasang-cabut environment, berbagai kebijakan, replay buffer, dan algoritma RL. Berkat modularitas ini:

• Anda dapat menukar komponen berbeda tanpa harus menulis ulang sebagian besar program. 
• Komponen individual juga dapat dimodifikasi secara independen untuk membuat solusi kustom. 

• Anda dapat bereksperimen dengan berbagai modul dan membangun solusi yang dioptimalkan. 

Beberapa contoh kustomisasi di TorchRL adalah:

• Loop pelatihan dapat dikustomisasi dengan scheduler laju pembelajaran, logger, dan metrik kustom. 
• Panjang replay buffer yang berbeda dapat digunakan untuk menyesuaikan durasi pelatihan.
• Environment dapat dikustomisasi untuk menyertakan fungsi penskalaan dan normalisasi, penghitung langkah, dll. 

Memvisualisasikan dan Debugging Pelatihan RL

Bagian sebelumnya menunjukkan cara menggunakan modul TorchRL untuk melatih agen RL. Pada bagian ini, kita membahas cara memantau dan memvisualisasikan progres pelatihan. 

Memantau progres pelatihan

Akan sangat membantu untuk mencatat berbagai metrik selama proses pelatihan guna memantau progresnya. Paket seperti TensorBoard memudahkan pencatatan hasil secara langsung selama proses pelatihan. Misalnya, SummaryWriter milik TensorBoard memungkinkan Anda memanggilnya di dalam loop pelatihan untuk mencatat metrik. Pseudocode berikut menunjukkan caranya:

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter(log_dir="training_logs")

for _ in training_data (): # training loop
    loss = … 
    loss.backprop() 
    writer.add_scalar(“Loss - “, loss.item(), step)
   … 

writer.close() 

Setelah menyelesaikan pelatihan dan pencatatan, Anda dapat memplot dan memvisualisasikan hasilnya. Misalnya, gunakan perintah tensorboard untuk memvisualisasikan progres pelatihan. 

tensorboard --logdir=”training_logs”

Debugging dengan TorchRL

Debugging penting untuk memverifikasi interaksi agen dengan environment. Sebagai langkah pertama, Anda ingin memeriksa ruang aksi dan ruang observasi. Dokumentasi environment harus menyertakan spesifikasi environment. Misalnya, dokumentasi CartPole menunjukkan bahwa: 

• Ruang aksi mencakup dua nilai diskrit — 0 (untuk mendorong kereta ke kiri) dan 1 (mendorong kereta ke kanan) 
• Ruang observasi memiliki 4 nilai: 
• Posisi kereta, dengan nilai antara 
• -4,8 dan +4,8. 
• Kecepatan kereta, dengan nilai bilangan real apa pun
• Sudut tiang, dengan nilai antara -24 ° dan  +24 °
• Kecepatan sudut tiang, dengan nilai bilangan real apa pun

Inspeksi ruang observasi dan aksi untuk memeriksa bahwa keduanya sesuai dengan nilai yang diharapkan. Misalnya:

print("Observation space: ", env.observation_spec)
print("Action space: ", env.action_spec)

Selain itu, Anda dapat mengambil sampel acak dari ruang observasi dan aksi serta memeriksa nilainya: 

print("Sample Observation:", base_env.observation_spec.sample().get("observation"))
print("Sample Action:", base_env.action_spec.sample())

Keluaran menyerupai sampel di bawah ini:

Sample Observation: tensor([-4.5960e+00,  3.4028e+38,  2.2261e-02,  3.4028e+38])
Sample Action: tensor([1, 0])

Perhatikan bahwa keempat nilai state berada dalam rentang yang ditentukan sebelumnya. Ulangi perintah di atas beberapa kali dan perhatikan bahwa nilai keluaran (diambil secara acak) yang berbeda tetap berada dalam rentang yang ditentukan. 

Dua perintah di atas berbasis environment dasar, yang diimpor langsung dari Gymnasium. Dalam praktiknya, kita menggunakan environment yang ditransformasikan, yang menerapkan transformasi, seperti normalisasi, pada nilai tensor asli. Dengan demikian, saat Anda menggunakan environment TorchRL yang ditransformasikan untuk mengambil sampel observasi, nilai-nilainya mungkin tidak lagi berada dalam rentang yang sama seperti di environment Gymnasium asli. 

Sebagai contoh, ambil sampel dari environment yang ditransformasikan:  

print("Sample Observation:", env.observation_spec.sample().get("observation"))

Keluaran menyerupai: 

Sample Observation: tensor([-57.5869,      nan,   4.5276,      nan])

Perhatikan bahwa nilai posisi kereta dan sudut tiang berada di luar rentang. Ini karena nilai tensor telah dinormalisasi. Selain itu, kecepatan kereta dan kecepatan sudut tiang memiliki nilai nan karena agen belum mulai berinteraksi dengan environment. 

Memvisualisasikan kinerja agen

Selain memplot progres pelatihan, akan bermanfaat untuk merender environment dan mengamati interaksi agen secara visual. Ini dapat memberikan wawasan tentang bagaimana kinerja agen. 

Cara paling pragmatis untuk memvisualisasikan environment adalah dengan merender video. Anda memerlukan beberapa paket tambahan: 

• torchvision, untuk bekerja dengan berkas multimedia
• av, untuk membungkus paket ffmpeg agar dapat berinteraksi dengan PyTorch. 

pip install torchvision
pip install av==12.0.0

Setelah menyelesaikan pelatihan, ikuti langkah persiapan berikut untuk merender video:

• Deklarasikan path (relatif) untuk menyimpan video.
• Inisialisasi logger untuk menyimpan hasil interaksi agen dalam format CSV.
• Inisialisasi perekam video untuk menggunakan log CSV guna menghasilkan video.
• Transformasikan environment TorchRL untuk menyertakan perekam video.

…
# training loop
# for _ in …
…
…

from torchrl.record import CSVLogger, VideoRecorder 

path = "./training_loop"
logger = CSVLogger(exp_name="dqn", log_dir=path, video_format="mp4")
video_recorder = VideoRecorder(logger, tag="video")
record_env = TransformedEnv(
    GymEnv("CartPole-v1", from_pixels=True, pixels_only=False), video_recorder
)

Jalankan kebijakan (yang telah dilatih) pada environment dan tuangkan hasil render ke dalam berkas video:

record_env.rollout(max_steps=1000, policy=policy)
video_recorder.dump()

Setelah menjalankan program, Anda akan menemukan video di direktori path (./training_loop pada cuplikan di atas) yang telah Anda tetapkan sebelumnya. Perlu diingat bahwa workbook DataLab untuk mengimplementasikan DQN menggunakan TorchRL tidak menyertakan kode untuk membuat video karena mengekspor berkas video dengan notebook online sulit dilakukan. Jalankan program (dan tambahkan langkah di atas) pada komputer lokal atau server untuk merekam video.

Praktik Terbaik Menggunakan TorchRL

Terakhir, mari singgung beberapa praktik terbaik. Berikut rekomendasi saya.

Mulai dari environment sederhana

Terlepas dari kemudahan pengembangan berkat TorchRL, melatih agen RL untuk berkinerja baik di environment kompleks tetap menantang. Karena itu, sebelum mencoba menyelesaikan masalah sulit, penting untuk menyelesaikan environment sederhana seperti CartPole. 

Modularitas TorchRL memungkinkan eksperimen dengan berbagai algoritma dan parameter. Sebelum menggunakan algoritma alternatif dan opsi kustomisasi dalam praktik, perlu memperoleh wawasan tentang cara kerjanya. Ini paling baik dilakukan di environment sederhana, di mana dampak perubahan individual mudah diamati secara visual. 

Bereksperimen dengan hiperparameter

Kinerja pelatihan model RL sensitif terhadap berbagai hiperparameter, seperti laju pembelajaran, tingkat eksplorasi, tingkat diskonto, dan hiperparameter spesifik algoritma lainnya, seperti clipping ratio untuk PPO. Misalnya, laju pembelajaran yang terlalu tinggi membuat pelatihan tidak stabil, sedangkan yang terlalu rendah membutuhkan waktu lama untuk konvergen. 

Demikian pula, tingkat eksplorasi yang sangat tinggi mencegah pelatihan untuk konvergen, sedangkan tingkat eksplorasi yang terlalu rendah dapat mencegah agen menemukan jalur optimal. 

Tidak ada rumus untuk menentukan nilai hiperparameter yang tepat. Terdapat panduan dan nilai yang direkomendasikan untuk environment standar, namun mungkin tidak berlaku untuk semua masalah. Karena itu, perlu bereksperimen dengan berbagai metode, seperti grid search atau random search, untuk menentukan nilai terbaik untuk hiperparameter. 

Anda juga dapat menggunakan pustaka otomatis seperti Weights & Biases Sweeps atau Optuna untuk menguji kinerja pelatihan di berbagai kombinasi hiperparameter. 

Manfaatkan algoritma siap pakai

Seperti yang Anda lihat pada contoh sebelumnya, menggunakan modul siap pakai dari TorchRL menghemat upaya pengembangan yang besar. Alternatifnya adalah membangun seluruh fungsionalitas dari nol, yang akan memakan waktu dan biaya pengembangan serta pengujian jauh lebih besar. 

Karena banyak pengembang menggunakan modul TorchRL, modul-modul tersebut juga diuntungkan telah diuji di berbagai skenario. Dengan demikian, Anda dapat mengharapkan modul tersebut lebih minim bug dibandingkan modul buatan kustom. Jadi, untuk sebagian besar use case standar, sangat disarankan menggunakan modul siap pakai. 

Penutup

Dalam artikel ini, kita membahas konsep dasar TorchRL, kerangka kerja berbasis PyTorch untuk mengimplementasikan algoritma RL. Kita juga melihat contoh praktis penggunaan TorchRL untuk mengimplementasikan solusi yang lebih sederhana seperti Deep Q-Learning dan algoritma yang lebih kompleks seperti PPO. 

Sebagai langkah berikutnya, Anda dapat menggunakan program-program ini sebagai dasar untuk bereksperimen dengan environment dan algoritma lain. 

Jika Anda ingin memperdalam pemahaman tentang dasar-dasar RL dan penerapan praktisnya, lihat Reinforcement Learning with Gymnasium in Python untuk mendapatkan lebih banyak pengalaman langsung dengan environment berbasis Gymnasium.