Reinforcement Learning dengan Gymnasium: Panduan Praktis

Menyiapkan Gymnasium

Gymnasium memerlukan versi spesifik (bukan rilis terbaru) dari berbagai dependensi seperti NumPy dan PyTorch. Karena itu, kami merekomendasikan membuat environment Conda atau venv yang baru, atau notebook baru untuk memasang, menggunakan Gymnasium, dan menjalankan program RL. 

Anda dapat menggunakan DataLab workbook ini untuk mengikuti tutorial.

Memasang Gymnasium

Untuk memasang Gymnasium di server atau mesin lokal, jalankan: 

$ pip install gymnasium 

Untuk memasang menggunakan Notebook seperti Colab milik Google atau DataLab milik DataCamp, gunakan:

!pip install gymnasium

Perintah di atas memasang Gymnasium beserta versi dependensi yang tepat.

Mengeksplorasi environment Gymnasium

Per November 2024, Gymnasium mencakup lebih dari 60 environment bawaan. Untuk menelusuri environment bawaan yang tersedia, gunakan fungsi gym.envs.registry.all(), seperti ditunjukkan pada contoh di bawah: 

import gymnasium as gym
for i in gym.envs.registry.keys():
	print(i)

Anda juga dapat mengunjungi beranda Gymnasium. Kolom kiri memuat tautan ke semua environment. Halaman web setiap environment berisi detailnya, seperti aksi, state, dan lain-lain. 

Environment diorganisasi ke dalam kategori seperti Classic Control, Box2D, dan lainnya. Di bawah ini, saya daftar beberapa environment umum di tiap grup:

• Classic Control: Ini adalah environment kanonik yang digunakan dalam pengembangan RL; menjadi dasar banyak contoh di buku teks. Environment ini memberikan perpaduan kompleksitas dan kesederhanaan yang tepat untuk menguji dan membandingkan algoritma RL baru. Environment classic control di Gymnasium mencakup: 
• Acrobot
• Cart Pole
• Mountain Car Discrete
• Mountain Car Continuous
• Pendulum
• Box2D: Box2D adalah Engine Fisika 2D untuk Gim. Environment berbasis engine ini mencakup gim sederhana seperti:
• Lunar Lander
• Car Racing
• ToyText: Ini adalah environment kecil dan sederhana yang sering digunakan untuk debugging algoritma RL. Banyak environment ini berbasis model grid world kecil dan gim kartu sederhana. Contohnya: 
• Blackjack
• Taxi
• Frozen Lake
• MuJoCo: Multi-Joint dynamics with Contact (MuJoCo) adalah engine fisika open-source yang mensimulasikan environment untuk aplikasi seperti robotika, biomekanika, ML, dan lain-lain. Environment MuJoCo di Gymnasium mencakup:
• Ant
• Hopper
• Humanoid
• Swimmer
• Dan lainnya

Selain environment bawaan, Gymnasium dapat digunakan dengan banyak environment eksternal menggunakan API yang sama. 

Kita akan menggunakan salah satu environment Classic Control yang kanonik dalam tutorial ini. Untuk mengimpor environment tertentu, gunakan perintah .make() dan teruskan nama environment sebagai argumen. Misalnya, untuk membuat environment baru berbasis CartPole (versi 1), gunakan perintah di bawah: 

import gymnasium as gym
env = gym.make("CartPole-v1")

Memahami Konsep Reinforcement Learning di Gymnasium

Secara singkat, Reinforcement Learning terdiri dari seorang agen (seperti robot) yang berinteraksi dengan lingkungannya. Sebuah kebijakan (policy) menentukan aksi agen. Bergantung pada aksi agen, environment memberi reward (atau penalti) di setiap timestep. Agen menggunakan RL untuk mencari kebijakan optimal yang memaksimalkan total reward yang diperoleh agen. 

Komponen environment RL

Berikut adalah komponen kunci dari environment RL: 

• Environment: Sistem, dunia, atau konteks eksternal. Agen berinteraksi dengan environment dalam serangkaian timestep. Pada setiap timestep, berdasarkan aksi agen, environment:
• Memberi reward (atau penalti) 
• Menentukan state selanjutnya 
• State: Representasi matematis dari konfigurasi environment saat ini. 
• Sebagai contoh, state pada environment pendulum dapat mencakup posisi pendulum dan kecepatan sudutnya pada setiap timestep. 
• Terminal state: State yang tidak mengarah ke state baru/lainnya. 
• Agen: Algoritma yang mengamati environment dan mengambil berbagai aksi berdasarkan observasi tersebut. Tujuan agen adalah memaksimalkan reward-nya. 
• Misalnya, agen memutuskan seberapa kuat dan ke arah mana mendorong pendulum.  
• Observasi: Representasi matematis dari pandangan agen terhadap environment, diperoleh misalnya dengan sensor. 
• Aksi: Keputusan yang dibuat oleh agen sebelum melanjutkan ke langkah berikutnya. Aksi memengaruhi state environment selanjutnya dan menghasilkan reward bagi agen. 
• Reward: Umpan balik dari environment ke agen. Dapat positif atau negatif, tergantung pada aksi dan state environment. 
• Return: Perkiraan return kumulatif pada timestep mendatang. Reward dari timestep masa depan dapat didiskon menggunakan faktor diskon. 
• Policy: Strategi agen tentang aksi apa yang diambil di berbagai state. Biasanya direpresentasikan sebagai matriks probabilitas, P, yang memetakan state ke aksi.
• Diberikan himpunan hingga dari m state yang mungkin dan n aksi yang mungkin, elemen Pmn pada matriks menyatakan probabilitas mengambil aksi an pada state sm.  
• Episode: Serangkaian timestep dari state awal (acak) hingga agen mencapai terminal state.

Observation space dan action space

Observasi adalah informasi yang dikumpulkan agen tentang environment. Seorang agen, misalnya robot, dapat mengumpulkan informasi lingkungan menggunakan sensor. Idealnya, agen harus dapat mengobservasi state lengkap, yang menggambarkan seluruh aspek environment. Dalam praktiknya, agen menggunakan observasi sebagai proksi untuk state. Dengan demikian, observasi menentukan aksi agen. 

Sebuah space dianalogikan sebagai sehimpunan matematis. Space dari item X mencakup semua kemungkinan instans dari X. Space dari X juga mendefinisikan struktur (sintaks dan format) semua item bertipe X. Setiap environment Gymnasium memiliki dua space, yaitu action space, action_space, dan observation space, observation_space. Baik action maupun observation space diturunkan dari superclass induk gymnasium.spaces.Space. 

Observation space 

Observation space adalah space yang mencakup semua observasi yang mungkin. Space ini juga mendefinisikan format penyimpanan observasi. Observation space biasanya direpresentasikan sebagai objek dengan datatipe Box. Ini adalah ndarray yang menggambarkan parameter observasi. Box menentukan batas setiap dimensi. Anda dapat melihat observation space untuk sebuah environment menggunakan metode observation_space:

print("observation space: ", env.observation_space)

Untuk environment CartPole-v1, keluarannya terlihat seperti contoh di bawah: 

observation space:  Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32)

Pada contoh ini, observation space CartPole-v1 memiliki 4 dimensi. Empat elemen array observasi adalah:

• Posisi kereta (cart position) - bervariasi antara -4.8 dan +4.8
• Kecepatan kereta (cart velocity) - berkisar antara - hingga +
• Sudut tiang (pole angle) - bervariasi antara -0.4189 dan +0.4189
• Kecepatan sudut tiang (pole angular velocity) - berkisar antara  - hingga +

Untuk melihat contoh array observasi individual, gunakan perintah .reset(). 

observation, info = env.reset()
print("observation: ", observation)

Untuk environment CartPole-v1, keluarannya terlihat seperti contoh di bawah: 

[ 0.03481963 -0.0277232   0.01703267 -0.04870504]                                                                                                       

Keempat elemen array ini berkorespondensi dengan empat besaran yang diobservasi (posisi kereta, kecepatan kereta, sudut tiang, kecepatan sudut tiang), seperti dijelaskan sebelumnya. 

Action space

Action space mencakup semua aksi yang mungkin diambil agen. Space ini juga mendefinisikan format representasi aksi. Anda dapat melihat action space untuk sebuah environment menggunakan metode action_space:

print("action space: ", env.action_space)

Untuk environment CartPole-v1, keluarannya terlihat seperti contoh di bawah: 

action space:  Discrete(2)

Untuk environment CartPole-v1, action space bersifat diskret. Terdapat total dua aksi yang dapat diambil agen:

• 0: Dorong kereta ke kiri
• 1: Dorong kereta ke kanan

Membangun Agen RL Pertama Anda dengan Gymnasium

Pada bagian sebelumnya, kita mengeksplorasi konsep dasar RL dan Gymnasium. Bagian ini menunjukkan cara menggunakan Gymnasium untuk membangun agen RL. 

Membuat dan mereset environment

Langkah pertama adalah membuat instance environment. Untuk membuat environment baru, gunakan metode .make(). 

env = gym.make('CartPole-v1')

Interaksi agen mengubah state environment. Metode .reset() mereset environment ke state awal. Secara default, environment diinisialisasi ke state acak. Anda dapat menggunakan parameter SEED dengan metode .reset() untuk menginisialisasi environment ke state yang sama setiap kali program dijalankan. Kode di bawah menunjukkan caranya:

SEED = 1111
env.reset(seed=SEED)

Pengambilan sampel aksi juga melibatkan keacakan. Untuk mengendalikan keacakan ini dan mendapatkan jalur pelatihan yang sepenuhnya reprodusibel, kita dapat memberi seed pada generator acak NumPy dan PyTorch:

np.random.seed(SEED)
torch.manual_seed(SEED)

Aksi acak versus cerdas

Di setiap langkah dalam proses Markov, agen dapat memilih aksi secara acak dan mengeksplorasi environment hingga mencapai terminal state. Dengan memilih aksi secara acak: 

• Dapat memakan waktu lama untuk mencapai terminal state.
• Reward kumulatif jauh lebih rendah daripada yang seharusnya bisa dicapai.

Melatih agen untuk mengoptimalkan pemilihan aksi berdasarkan pengalaman sebelumnya (dari interaksi dengan environment) lebih efisien untuk memaksimalkan reward jangka panjang. 

Agen yang belum terlatih memulai dengan aksi acak berdasarkan policy yang diinisialisasi secara acak. Policy ini biasanya direpresentasikan sebagai neural network. Selama pelatihan, agen mempelajari policy optimal yang memaksimalkan reward. Dalam RL, proses pelatihan ini juga disebut optimisasi policy (policy optimization). 

Ada berbagai metode policy optimization. Persamaan Bellman menjelaskan cara menghitung nilai policy RL dan menentukan policy optimal. Dalam tutorial ini, kita akan menggunakan teknik sederhana bernama policy gradients. Metode lain juga ada, seperti Proximal Policy Optimization (PPO). 

Menerapkan Agen Policy Gradient Sederhana

Untuk membangun agen RL yang menggunakan policy gradients, kita membuat neural network untuk mengimplementasikan policy, menulis fungsi untuk menghitung return dan loss dari reward per langkah serta probabilitas aksi, dan memperbarui policy secara iteratif menggunakan teknik backpropagation standar. 

Menyiapkan policy network

Kita menggunakan neural network untuk mengimplementasikan policy. Karena CartPole-v1 adalah environment sederhana, kita menggunakan neural network dengan:

• Dimensi input sama dengan dimensi observation space environment. 
• Satu hidden layer dengan 64 neuron. 
• Dimensi output sama dengan dimensi action space environment.

Dengan demikian, fungsi policy network adalah memetakan state yang diobservasi ke aksi. Diberikan observasi input, jaringan memprediksi aksi yang tepat. Kode di bawah mengimplementasikan policy network:

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

Pengumpulan reward dan forward pass

Seperti disebutkan, pada setiap langkah proses Markov, environment memberikan reward berdasarkan aksi dan state agen. Tujuan dalam RL adalah memaksimalkan total return. 

• Return pada setiap timestep adalah jumlah kumulatif reward yang diperoleh dari awal hingga langkah tersebut. 
• Total return tiap episode diperoleh dengan mengakumulasi semua reward per langkah dari episode tersebut. Jadi, total return adalah return pada timestep terakhir (ketika agen mencapai terminal state). 

Dalam praktik, saat mengakumulasi reward, umum untuk: 

• Menyesuaikan reward masa depan menggunakan faktor diskon. 
• Menormalkan array return per langkah untuk memastikan pelatihan yang mulus dan stabil. 

Kode di bawah menunjukkan caranya: 

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0
    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returns

Forward pass terdiri dari menjalankan agen berdasarkan policy saat ini hingga mencapai terminal state dan mengumpulkan reward per langkah serta probabilitas aksi. Langkah-langkah di bawah menjelaskan cara mengimplementasikan forward pass: 

• Reset environment ke state awal. 
• Inisialisasi buffer untuk menyimpan probabilitas aksi, reward, dan return kumulatif
• Gunakan fungsi .step() untuk menjalankan agen secara iteratif dalam environment sampai terminasi:
• Dapatkan observasi state environment.
• Dapatkan aksi yang diprediksi oleh policy berdasarkan observasi.
• Gunakan fungsi Softmax untuk memperkirakan probabilitas mengambil aksi yang diprediksi.
• Mensimulasikan distribusi probabilitas kategorikal berdasarkan probabilitas yang diestimasi ini.
• Sampling distribusi ini untuk mendapatkan aksi agen.
• Mengestimasi log probabilitas aksi yang diambil dari distribusi yang disimulasikan. 
• Tambahkan log probabilitas aksi dan reward dari setiap langkah ke buffer masing-masing. 
• Estimasi nilai return yang didiskon dan dinormalisasi di setiap langkah berdasarkan reward. 

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0
    policy.train()
    observation, info = env.reset()
    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)
        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated
        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward
    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)
    return episode_return, stepwise_returns, log_prob_actions

Memperbarui policy berdasarkan reward

Loss merepresentasikan kuantitas yang kita terapkan gradient descent padanya. Tujuan dalam RL adalah memaksimalkan return. Jadi, kita menggunakan nilai return yang diharapkan sebagai proxy untuk loss. Nilai return yang diharapkan dihitung sebagai hasil kali return yang diharapkan per langkah dan log probabilitas aksi per langkah. Kode di bawah menghitung loss:

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return loss

Untuk memperbarui policy, Anda menjalankan backpropagation terhadap fungsi loss. Metode update_policy() di bawah memanggil metode calculate_loss(). Kemudian menjalankan backpropagation pada loss ini untuk memperbarui parameter policy, yaitu bobot model dari policy network.

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    return loss.item()

Memperbarui policy berdasarkan gradien return disebut metode policy gradient. 

Melatih policy

Sekarang kita memiliki semua komponen untuk melatih dan mengevaluasi policy. Kita mengimplementasikan loop pelatihan seperti dijelaskan dalam langkah-langkah berikut:  

Sebelum memulai, kita mendeklarasikan hyperparameter, membuat instance policy, dan membuat optimizer:

• Deklarasikan hyperparameter sebagai konstanta Python:
• MAX_EPOCHS adalah jumlah iterasi maksimum yang kita siapkan untuk menjalankan pelatihan policy. 
• DISCOUNT_FACTOR menentukan signifikansi relatif reward dari timestep mendatang. Faktor diskon 1 berarti semua reward sama pentingnya, sedangkan nilai 0 berarti hanya reward dari timestep saat ini yang penting. 
• N_TRIALS adalah jumlah episode yang kita gunakan untuk merata-ratakan return guna mengevaluasi kinerja agen. Kita menilai pelatihan berhasil jika return rata-rata selama N_TRIALS episode berada di atas ambang batas.
• REWARD_THRESHOLD: Jika policy dapat mencapai return lebih besar dari ambang, maka dianggap berhasil. 
• DROPOUT menentukan fraksi bobot yang harus di-nol-kan secara acak. Fungsi dropout secara acak mengatur sebagian bobot model menjadi nol. Ini mengurangi ketergantungan pada neuron tertentu dan mencegah overfitting, sehingga jaringan lebih tangguh.
• LEARNING_RATE menentukan seberapa besar parameter policy dapat diubah di setiap langkah. Pembaruan parameter pada tiap iterasi adalah hasil kali gradien dan learning rate. 
• Definisikan policy sebagai instance kelas PolicyNetwork (yang diimplementasikan sebelumnya). 
• Buat optimizer menggunakan algoritma Adam dan learning rate. 

Untuk melatih policy, kita menjalankan langkah pelatihan secara iteratif hingga return rata-rata (selama N_TRIALS) lebih besar dari ambang reward:

• Untuk setiap episode, jalankan forward pass sekali. Kumpulkan log probabilitas aksi, return per langkah, dan total return dari episode tersebut. Akumulasikan return per episode dalam sebuah array. 
• Hitung loss menggunakan log probabilitas dan return per langkah. Jalankan backpropagation pada loss. Gunakan optimizer untuk memperbarui parameter policy. 
• Periksa apakah return rata-rata selama N_TRIALS melebihi ambang reward. 

Kode di bawah mengimplementasikan langkah-langkah tersebut:

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5
    episode_returns = []
    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)
    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)
    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)
        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])
        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')
        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break

Terakhir, panggil fungsi main() untuk melatih policy:

main()

Gunakan DataLab workbook ini untuk menjalankan algoritma di atas secara langsung dan menyelesaikan environment CartPole menggunakan RL. 

Teknik Lanjutan di Gymnasium

Setelah mendemonstrasikan cara menerapkan algoritma RL, kini kita membahas beberapa teknik lanjutan yang umum digunakan dalam praktik. 

Menggunakan arsitektur siap pakai

Menerapkan algoritma RL dari nol adalah proses yang panjang dan sulit, terutama untuk environment kompleks dan policy mutakhir. 

Alternatif yang lebih praktis adalah menggunakan perangkat lunak seperti Stable Baselines3. Paket ini hadir dengan implementasi algoritma RL yang telah teruji. Termasuk agen pra-latih, skrip pelatihan, alat evaluasi, dan modul untuk membuat grafik serta merekam video. 

Ray RLib adalah alat populer lainnya untuk RL. RLib dirancang sebagai solusi yang dapat diskalakan, memudahkan implementasi algoritma RL pada sistem multi-GPU. Ia juga mendukung RL multi-agen, yang membuka kemungkinan baru seperti:

• Pembelajaran multi-agen independen: Setiap agen memperlakukan agen lain sebagai bagian dari environment.
• Pelatihan multi-agen kolaboratif: Sekelompok agen berbagi policy dan fungsi nilai yang sama serta belajar dari pengalaman satu sama lain secara paralel. 
• Pelatihan adversarial: Agen (atau kelompok agen) saling berkompetisi dalam environment kompetitif mirip gim. 

Dengan RLib dan Stable Baselines3, Anda dapat mengimpor dan menggunakan environment dari OpenAI Gymnasium. 

Environment kustom

Environment yang dikemas bersama Gymnasium adalah pilihan tepat untuk menguji strategi RL baru dan melatih policy. Namun, untuk sebagian besar aplikasi praktis, Anda perlu membuat dan menggunakan environment yang secara akurat merefleksikan masalah yang ingin Anda selesaikan. Anda dapat menggunakan Gymnasium untuk membuat environment kustom. Keuntungan menggunakan environment kustom Gymnasium adalah banyak alat eksternal seperti RLib dan Stable Baselines3 sudah dikonfigurasi untuk bekerja dengan struktur API Gymnasium. 

Untuk membuat environment kustom di Gymnasium, Anda perlu mendefinisikan: 

• Observation space.
• Kondisi terminal.
• Kumpulan aksi yang dapat dipilih agen.
• Cara menginisialisasi environment (saat fungsi reset() dipanggil). 
• Bagaimana environment menentukan state berikutnya berdasarkan aksi agen (saat fungsi step() dipanggil). 

Untuk mempelajari lebih lanjut, ikuti panduan Gymnasium tentang membuat environment kustom. 

Praktik Terbaik Menggunakan Gymnasium

Bereksperimen dengan berbagai environment

Kode dalam tutorial ini menunjukkan cara menerapkan algoritma policy gradient di environment CartPole. Ini adalah environment sederhana dengan action space diskret. Untuk memahami RL lebih baik, kami menyarankan Anda menerapkan algoritma policy gradient yang sama (dan algoritme lain, seperti PPO) di environment lain. 

Misalnya, environment Pendulum memiliki action space kontinu. Terdiri dari satu input yang direpresentasikan sebagai variabel kontinu - (besar dan arah) torsi yang diterapkan pada pendulum pada state tertentu. Torsi ini dapat bernilai antara -2 dan +2. 

Bereksperimen dengan algoritma berbeda di berbagai environment membantu Anda lebih memahami beragam solusi RL dan tantangannya. 

Memantau progres pelatihan

Environment RL sering kali berupa robot, pendulum, mountain car, video game, dan sebagainya. Memvisualisasikan aksi agen dalam environment memberi pemahaman intuitif yang lebih baik tentang kinerja policy. 

Di Gymnasium, metode env.render() memvisualisasikan interaksi agen dengan environment. Ini menampilkan secara grafis state environment saat ini—layar gim, posisi pendulum atau cart pole, dan sebagainya. Umpan balik visual atas aksi agen dan respons environment membantu memantau kinerja dan progres agen sepanjang proses pelatihan. 

Ada empat mode render: “human”, “rgb_array”, “ansi”, dan “rgb_array_list”. Untuk memvisualisasikan kinerja agen, gunakan mode render “human”. Mode render ditentukan saat environment diinisialisasi. Contohnya:

env = gym.make(‘CartPole-v1’, render_mode=’human’)

Untuk melakukan rendering, panggil metode .render() setelah setiap aksi yang dilakukan agen (melalui pemanggilan metode .step()). Pseudo-code di bawah mengilustrasikan caranya:

while not done:
    …
   step, reward, terminated, truncated, info = env.step(action.item())
   env.render()
    …

Mengatasi error umum

Gymnasium memudahkan antarmuka dengan environment RL yang kompleks. Namun, ini adalah perangkat lunak yang terus diperbarui dengan banyak dependensi. Karena itu, penting untuk mewaspadai beberapa jenis error umum.

Ketidakcocokan versi

• Ketidakcocokan versi Gymnasium: Paket perangkat lunak Gymnasium dari Farama di-fork dari Gym milik OpenAI pada versi 0.26.2. Ada beberapa perubahan yang tidak kompatibel antara Gym versi lama dan versi baru Gymnasium. Banyak implementasi yang tersedia publik berbasis rilis Gym lama dan mungkin tidak langsung bekerja dengan rilis terbaru. Dalam kasus seperti itu, perlu untuk melakukan rollback instalasi ke versi lebih lama atau menyesuaikan kode agar bekerja dengan rilis yang lebih baru. 
• Ketidakcocokan versi environment: Banyak environment Gymnasium memiliki versi berbeda. Misalnya, ada dua environment CartPole - CartPole-v1 dan CartPole-v0. Meskipun perilaku environment sama di kedua versi, beberapa parameter seperti panjang episode, ambang reward, dan sebagainya, bisa berbeda. Policy yang dilatih pada satu versi mungkin tidak berkinerja sebaik pada versi lain dari environment yang sama. Anda perlu memperbarui parameter pelatihan dan melatih ulang policy untuk setiap versi environment. 
• Ketidakcocokan versi dependensi: Gymnasium bergantung pada dependensi seperti NumPy dan PyTorch. Per Desember 2024, versi terbaru dependensi tersebut adalah numpy 2.1.3 dan torch 2.5.1. Namun, Gymnasium bekerja paling baik dengan torch 1.13.0 dan numpy 1.23.3. Anda mungkin mengalami masalah jika memasang Gymnasium ke environment yang dependensinya sudah terpasang. Kami merekomendasikan memasang dan bekerja dengan Gymnasium di environment Conda yang baru. 

Masalah konvergensi

• Hyperparameter: Seperti algoritma machine learning lainnya, policy RL sensitif terhadap hyperparameter seperti learning rate, faktor diskon, dan sebagainya. Kami menyarankan bereksperimen dan menyetel hyperparameter secara manual atau menggunakan teknik otomatis seperti grid search dan random search. 
• Eksplorasi versus eksploitasi: Untuk beberapa kelas policy (seperti PPO), agen mengadopsi strategi dua arah: mengeksplorasi environment untuk menemukan jalur baru dan mengadopsi pendekatan rakus (greedy) untuk memaksimalkan reward berdasarkan jalur yang diketahui sejauh ini. Jika terlalu banyak mengeksplorasi, policy tidak konvergen. Sebaliknya, jika tidak cukup mengeksplorasi, ia tidak pernah mencoba jalur optimal. Jadi, penting menemukan keseimbangan yang tepat antara eksplorasi dan eksploitasi. Umum juga untuk memprioritaskan eksplorasi pada episode awal dan eksploitasi pada episode akhir selama pelatihan. 

Ketidakstabilan pelatihan

• Learning rate besar: Jika learning rate terlalu tinggi, parameter policy mengalami pembaruan besar di setiap langkah. Ini bisa menyebabkan titik optimum terlewat. Solusi umum adalah secara bertahap mengurangi learning rate, memastikan pembaruan yang lebih kecil dan stabil saat pelatihan konvergen. 
• Eksplorasi berlebihan: Terlalu banyak keacakan (entropi) dalam pemilihan aksi mencegah konvergensi dan menyebabkan variasi besar pada fungsi loss antara langkah-langkah berturut-turut. Untuk proses pelatihan yang stabil dan konvergen, seimbangkan eksplorasi dengan eksploitasi. 
• Pilihan algoritma yang keliru: Algoritma sederhana seperti policy gradient dapat menyebabkan pelatihan tidak stabil di environment kompleks dengan action dan state space besar. Dalam kasus seperti itu, kami merekomendasikan menggunakan algoritma yang lebih tangguh seperti PPO dan Trust Region Policy Optimization (TRPO). Algoritma ini menghindari pembaruan policy yang besar di setiap langkah dan bisa lebih stabil.
• Keacakan: Algoritma RL sangat sensitif terhadap state awal dan keacakan yang melekat pada pemilihan aksi. Ketika sebuah sesi pelatihan tidak stabil, terkadang bisa distabilkan dengan menggunakan seed acak yang berbeda atau dengan menginisialisasi ulang policy.

Kesimpulan

Dalam tutorial ini, kita mengeksplorasi prinsip dasar RL, membahas Gymnasium sebagai paket perangkat lunak dengan API yang bersih untuk berinteraksi dengan berbagai environment RL, dan menunjukkan cara menulis program Python untuk menerapkan algoritma RL sederhana dan mengaplikasikannya di environment Gymnasium.

Setelah memahami dasar-dasarnya di tutorial ini, saya merekomendasikan menggunakan environment Gymnasium untuk menerapkan konsep RL guna menyelesaikan masalah praktis seperti optimisasi rute taksi dan simulasi perdagangan saham.