Tutorial Lengkap Melatih Agen DQN untuk Game Atari dengan Python

Mari kita mulai petualangan seru dalam dunia Reinforcement Learning! Dalam tutorial ini, kita akan melatih agen cerdas untuk bermain game Atari, menggunakan algoritma Deep Q-Network (DQN) yang diimplementasikan dengan Python. Siapkan diri Anda, karena kita akan menyelami kode dan konsep yang menarik!

Pengantar Reinforcement Learning dan Deep Q-Networks (DQN)

Reinforcement Learning (RL) adalah cabang machine learning di mana agen belajar membuat keputusan dengan berinteraksi dengan lingkungannya. Bayangkan seekor anjing yang belajar trik baru. Anjing (agen) mencoba berbagai tindakan; jika tindakannya benar, ia mendapat hadiah (misalnya, makanan). Jika salah, ia tidak mendapat apa-apa, atau bahkan mendapat hukuman. Seiring waktu, anjing belajar tindakan mana yang menghasilkan hadiah terbanyak.

Baca juga: Panduan Lengkap Reinforcement Learning: Konsep, Algoritma, dan Aplikasi

Konsep utama dalam RL:

• Agen: Entitas yang belajar dan membuat keputusan (misalnya, anjing atau, dalam kasus kita, program komputer).
• Lingkungan: Dunia tempat agen berinteraksi (misalnya, ruangan tempat anjing berlatih atau game Atari).
• State: Kondisi saat ini dari lingkungan (misalnya, posisi anjing dan pemiliknya, atau tampilan layar game Atari).
• Action: Tindakan yang dapat diambil oleh agen (misalnya, duduk, berguling, atau menekan tombol atas/bawah/kiri/kanan di game Atari).
• Reward: Umpan balik numerik yang diterima agen setelah melakukan tindakan (misalnya, +1 jika anjing melakukan trik dengan benar, 0 jika salah, atau skor dalam game Atari).

Deep Q-Networks (DQN) adalah algoritma RL yang menggabungkan konsep Q-learning dengan deep learning. Q-learning adalah metode untuk mempelajari fungsi Q(s, a), yang memperkirakan nilai (expected return) dari melakukan tindakan a pada state s. DQN menggunakan jaringan saraf tiruan (neural network) untuk memprediksi nilai Q ini. Karena game Atari memiliki state berupa pixel gambar, DQN sangat cocok karena dapat belajar langsung dari input visual berdimensi tinggi, tanpa perlu feature engineering manual. Library yang kita gunakan adalah gym (untuk lingkungan Atari) dan PyTorch (untuk membangun jaringan saraf).

Baca juga: Deep Q-Network (DQN): Panduan Lengkap untuk Pemula

Menyiapkan Lingkungan Pengembangan

Instalasi Python dan Package yang Dibutuhkan

Pastikan Anda memiliki Python versi 3.7 atau lebih baru. Kita akan menggunakan pip untuk menginstal library yang dibutuhkan. Buka terminal atau command prompt, lalu jalankan perintah berikut:

pip install gym[atari] torch numpy matplotlib

Perintah di atas akan menginstal:

• gym[atari]: OpenAI Gym, toolkit untuk mengembangkan dan membandingkan algoritma RL, dengan environment game Atari.
• torch: PyTorch, library untuk membangun dan melatih jaringan saraf.
• numpy: Library untuk komputasi numerik.
• matplotlib: Library untuk visualisasi data.

Jika Anda lebih suka menggunakan TensorFlow daripada PyTorch, Anda bisa mengganti torch dengan tensorflow pada perintah di atas. Namun, dalam tutorial ini, kita akan fokus pada PyTorch.

Verifikasi Instalasi

Untuk memastikan semua library terinstal dengan benar, buat file Python baru (misalnya, test.py), lalu masukkan kode berikut:

import gym
import torch
import numpy as np
import matplotlib.pyplot as plt

print("Gym version:", gym.__version__)
print("PyTorch version:", torch.__version__)
print("NumPy version:", np.__version__)

# Coba buat environment Atari
env = gym.make("Breakout-v0", render_mode="human") #tambahkan render_mode='human'
env.reset()
for _ in range(100):
    action = env.action_space.sample()  # Ambil tindakan acak
    obs, reward, terminated, truncated, info = env.step(action)
    env.render()
    if terminated or truncated:
        env.reset()
env.close()

Jalankan file tersebut: python test.py. Jika tidak ada error, Anda melihat versi library yang terinstal, dan jendela yang menampilkan game Breakout (meskipun gerakannya acak) muncul, berarti instalasi berhasil.

Membangun Agen DQN

Impor Library

Buat file Python baru (misalnya, dqn_agent.py), kemudian impor library yang dibutuhkan:

import gym
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import random
from collections import deque
import matplotlib.pyplot as plt

Mendefinisikan Arsitektur Jaringan Saraf (Neural Network)

Kita akan menggunakan Convolutional Neural Network (CNN) untuk memproses input gambar dari game Atari. CNN sangat efektif untuk mengekstrak fitur dari gambar.

class DQN(nn.Module):
    def __init__(self, input_shape, num_actions):
        super(DQN, self).__init__()
        self.conv1 = nn.Conv2d(input_shape[0], 32, kernel_size=8, stride=4)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)
        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, stride=1)
        self.fc1 = nn.Linear(self.get_conv_out_size(input_shape), 512)
        self.fc2 = nn.Linear(512, num_actions)

    def forward(self, x):
        x = x.float() / 255.  # Normalisasi input
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = torch.relu(self.conv3(x))
        x = x.view(x.size(0), -1)  # Flatten
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x
    
    def get_conv_out_size(self, shape):
        o = self.conv1(torch.zeros(1, *shape))
        o = self.conv2(o)
        o = self.conv3(o)
        return int(np.prod(o.size()))

Penjelasan:

• __init__: Mendefinisikan layer-layer jaringan.
• nn.Conv2d: Layer konvolusi, untuk mengekstrak fitur dari gambar.
• nn.Linear: Layer fully connected, untuk menghubungkan hasil konvolusi ke output (nilai Q).
• forward: Mendefinisikan bagaimana input diproses melalui jaringan (forward pass).
• Normalisasi input: Membagi nilai pixel dengan 255 agar berada dalam rentang 0-1.
• torch.relu: Fungsi aktivasi ReLU (Rectified Linear Unit).
• x.view: Meratakan (flatten) output konvolusi menjadi vektor sebelum masuk ke layer fully connected.
• get_conv_out_size: Menghitung ukuran output dari layer konvolusi. Ini diperlukan untuk mendefinisikan layer fully connected pertama.

Membuat Kelas Agen DQN

class DQNAgent:
    def __init__(self, input_shape, num_actions, learning_rate=0.001, gamma=0.99, epsilon_start=1.0, epsilon_end=0.01, epsilon_decay=0.995, memory_size=10000, batch_size=32, target_update_freq=100):
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.dqn = DQN(input_shape, num_actions).to(self.device)
        self.target_dqn = DQN(input_shape, num_actions).to(self.device)
        self.target_dqn.load_state_dict(self.dqn.state_dict()) # Inisialisasi target network
        self.target_dqn.eval() # Target network tidak perlu di-train
        self.optimizer = optim.Adam(self.dqn.parameters(), lr=learning_rate)
        self.memory = deque(maxlen=memory_size)
        self.gamma = gamma
        self.epsilon = epsilon_start
        self.epsilon_end = epsilon_end
        self.epsilon_decay = epsilon_decay
        self.batch_size = batch_size
        self.num_actions = num_actions
        self.target_update_freq = target_update_freq
        self.steps = 0

    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.num_actions)  # Eksplorasi
        state = torch.tensor(np.array(state), dtype=torch.float32).unsqueeze(0).to(self.device)
        q_values = self.dqn(state)
        return torch.argmax(q_values).item()  # Eksploitasi

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def replay(self):
        if len(self.memory) < self.batch_size:
            return  # Belum cukup pengalaman untuk replay

        batch = random.sample(self.memory, self.batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)

        states = torch.tensor(np.array(states), dtype=torch.float32).to(self.device)
        actions = torch.tensor(np.array(actions), dtype=torch.long).to(self.device)
        rewards = torch.tensor(np.array(rewards), dtype=torch.float32).to(self.device)
        next_states = torch.tensor(np.array(next_states), dtype=torch.float32).to(self.device)
        dones = torch.tensor(np.array(dones), dtype=torch.float32).to(self.device)
      
        #double DQN
        q_values = self.dqn(states)
        next_q_values = self.dqn(next_states)
        next_q_state_values = self.target_dqn(next_states)

        q_value = q_values.gather(1, actions.unsqueeze(1)).squeeze(1)
        next_q_value = next_q_state_values.gather(1, torch.max(next_q_values, 1)[1].unsqueeze(1)).squeeze(1)
        expected_q_value = rewards + self.gamma * next_q_value * (1 - dones)

        # Standard DQN
        # q_values = self.dqn(states)
        # next_q_values = self.target_dqn(next_states).detach()

        # q_value = q_values.gather(1, actions.unsqueeze(1)).squeeze(1)
        # # max_next_q_value = next_q_values.max(1)[0] # Standard DQN
        # expected_q_value = rewards + (1 - dones) * self.gamma * next_q_value # Standard DQN

        loss = nn.MSELoss()(q_value, expected_q_value)

        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

        self.epsilon = max(self.epsilon_end, self.epsilon_decay * self.epsilon)  # Kurangi epsilon

    def target_train(self):
      # target network update
      if self.steps % self.target_update_freq == 0:
          self.target_dqn.load_state_dict(self.dqn.state_dict())
      self.steps+=1

Penjelasan:

• __init__:
• Inisialisasi model DQN (self.dqn) dan target DQN (self.target_dqn). Target DQN digunakan untuk menghitung target Q-values, yang membantu menstabilkan pelatihan.
• Inisialisasi optimizer (Adam), replay memory (self.memory), dan parameter lainnya.
• act: Memilih tindakan berdasarkan state.
• Epsilon-greedy policy: Dengan probabilitas epsilon, agen memilih tindakan acak (eksplorasi). Jika tidak, agen memilih tindakan dengan nilai Q tertinggi (eksploitasi).
• remember: Menyimpan pengalaman (state, action, reward, next_state, done) ke replay memory.
• replay: Melatih model DQN dengan experience replay.
• Mengambil sampel acak (batch) dari replay memory.
• Menghitung target Q-values, menggunakan target DQN.
• Menghitung loss (perbedaan antara Q-values yang diprediksi dan target Q-values). Kita menggunakan Mean Squared Error (MSE) sebagai fungsi loss.
• Melakukan backpropagation dan update parameter model DQN.
• Mengurangi nilai epsilon secara bertahap (agar agen lebih banyak melakukan eksploitasi seiring waktu).
• target_train: Secara berkala menyalin bobot dari dqn ke target_dqn.

Proses Pelatihan Agen

Inisialisasi Lingkungan dan Agen

env = gym.make('Breakout-v0') # Ganti dengan game Atari lain jika mau
input_shape = env.observation_space.shape
num_actions = env.action_space.n

agent = DQNAgent(input_shape, num_actions)

Membuat Loop Pelatihan

num_episodes = 500  # Jumlah episode pelatihan
rewards_per_episode = []

for episode in range(num_episodes):
    state = env.reset()[0]
    total_reward = 0
    done = False
    truncated = False

    while not done and not truncated:
        action = agent.act(state)
        next_state, reward, terminated, truncated, info = env.step(action)
        done = terminated
        agent.remember(state, action, reward, next_state, done)
        agent.replay()
        agent.target_train()
        state = next_state
        total_reward += reward
        # env.render() # Aktifkan untuk visualisasi selama training (akan memperlambat)

    rewards_per_episode.append(total_reward)
    print(f"Episode: {episode+1}, Total Reward: {total_reward}, Epsilon: {agent.epsilon:.2f}")


env.close()

Penjelasan:

1. Looping per episode: Pelatihan dilakukan dalam sejumlah episode. Satu episode berarti agen bermain game dari awal hingga game over.
2. Reset lingkungan: env.reset() mengembalikan state awal game.
3. Looping dalam episode:
• agent.act(state): Memilih tindakan berdasarkan state saat ini.
• env.step(action): Mengeksekusi tindakan di lingkungan dan mengembalikan next_state, reward, done (apakah episode selesai), dan info (informasi tambahan).
• agent.remember(...): Menyimpan pengalaman ke replay memory.
• agent.replay(): Melatih model DQN.
• agent.target_train(): Memperbarui target network
• state = next_state: Memperbarui state saat ini.
• total_reward += reward: Menambahkan reward ke total reward episode.
4. Setelah episode selesai:
• Menyimpan total reward episode ke rewards_per_episode.
• Mencetak informasi episode (nomor episode, total reward, epsilon).

Menyimpan Model

torch.save(agent.dqn.state_dict(), 'dqn_model.pth') # Menyimpan parameter model

Kode di atas akan menyimpan ‘bobot’ atau parameter dari model DQN.

Evaluasi dan Visualisasi Hasil

Memuat Model Terlatih

# Load Model
# Jika ingin melanjutkan training dari model yang sudah dilatih
# agent.dqn.load_state_dict(torch.load('dqn_model.pth'))

Menjalankan Agen di Lingkungan

# Evaluasi
env = gym.make('Breakout-v0', render_mode='human')  # Gunakan render_mode='human' untuk visualisasi
state = env.reset()[0]
total_reward = 0
done = False
truncated = False

while not done and not truncated:
    action = agent.act(state)  # Gunakan agen untuk memilih tindakan
    next_state, reward, terminated, truncated, info = env.step(action)
    done = terminated
    state = next_state
    total_reward += reward
    env.render()

print(f"Total reward: {total_reward}")
env.close()

Visualisasi Performa Agen

# Plotting
plt.plot(rewards_per_episode)
plt.xlabel('Episode')
plt.ylabel('Total Reward')
plt.title('Reward per Episode')
plt.show()

Kode ini akan membuat grafik yang menunjukkan reward yang diperoleh agen di setiap episode selama pelatihan. Kita berharap reward-nya akan meningkat seiring waktu, yang menunjukkan bahwa agen semakin baik dalam bermain game.

Evaluasi Kuantitatif

Selain visualisasi, metrik yang bisa digunakan adalah:

• Average Reward: Rata-rata reward yang didapatkan dalam sejumlah episode.
• Maximum Reward: Reward tertinggi yang pernah dicapai.
• Reward Standard Deviation: Untuk melihat kestabilan performa.

Tips dan Troubleshooting

Hyperparameter Tuning

Hyperparameter (seperti learning rate, discount factor, epsilon decay, ukuran replay memory, dan batch size) sangat memengaruhi performa DQN. Tidak ada nilai yang pasti benar untuk semua game; Anda perlu bereksperimen. Beberapa tips:

• Learning rate: Coba nilai antara 0.0001 dan 0.001.
• Discount factor (gamma): Biasanya antara 0.9 dan 0.99.
• Epsilon decay: Sesuaikan agar eksplorasi berkurang secara bertahap.
• Replay memory size: Cukup besar untuk menampung pengalaman yang beragam (misalnya, 10,000 – 100,000).
• Batch size: Umumnya antara 32 dan 256.
• Target Update Frequency: Seberapa sering target network di-update. Jika terlalu sering, update menjadi tidak stabil; jika terlalu jarang, menjadi lambat. Nilai 100-1000 bisa dicoba.

Mengatasi Overfitting

Jika agen memiliki performa yang sangat baik pada saat training, tetapi buruk saat testing, ada kemungkinan terjadi overfitting. Solusinya bisa berupa:

• Menambah data (experience replay): Pastikan replay memory cukup besar dan beragam.
• Mengurangi kompleksitas model: Jika model terlalu kompleks (terlalu banyak layer atau neuron), coba sederhanakan.
• Menambahkan regularisasi: Teknik seperti dropout dapat membantu mencegah overfitting.

Masalah Umum dan Solusi

• Agen tidak belajar: Pastikan reward yang diberikan benar, learning rate tidak terlalu tinggi atau terlalu rendah, dan epsilon berkurang seiring waktu.
• Performa buruk: Coba hyperparameter tuning, pastikan implementasi DQN benar (terutama perhitungan target Q-values), dan coba game yang lebih sederhana terlebih dahulu.

Kesimpulan dan Pengembangan Lebih Lanjut

Selamat! Anda telah berhasil melatih agen DQN untuk bermain game Atari. Anda telah belajar tentang:

• Konsep dasar Reinforcement Learning.
• Cara kerja Deep Q-Networks.
• Implementasi DQN dengan PyTorch.
• Proses pelatihan dan evaluasi agen.

Ada banyak cara untuk mengembangkan proyek ini:

• Double DQN: Menggunakan dua jaringan DQN untuk mengurangi overestimation nilai Q.
• Dueling DQN: Memisahkan estimasi nilai state dan advantage dari setiap tindakan.
• Prioritized Experience Replay: Memberi prioritas pada pengalaman yang lebih “penting” dalam replay memory.
• Mencoba game Atari lain: Setiap game memiliki tantangan yang berbeda.

Baca juga: Panduan Lengkap Q-Learning Algoritma Reinforcement Learning

• Menggunakan algoritma RL lain: Ada banyak algoritma RL lain, seperti A2C, PPO, dan SAC.

Dengan pengetahuan dan kode yang telah Anda dapatkan, Anda siap untuk menjelajahi dunia Reinforcement Learning lebih jauh!

Kirim.ai hadir sebagai solusi digital berbasis AI yang komprehensif, siap membantu Anda dalam berbagai aspek pengembangan dan pemasaran digital. Jika Anda tertarik untuk mengimplementasikan solusi AI canggih, seperti yang dijelaskan dalam tutorial ini, atau membutuhkan bantuan dalam pengembangan aplikasi, website, atau strategi pemasaran digital, jangan ragu untuk mempelajari lebih lanjut tentang layanan kami. Kami menyediakan platform SaaS dengan berbagai alat AI, termasuk AI Agent untuk optimasi SEO otomatis.