Menerapkan Pembelajaran-Q dalam Python

Dalam pelajaran ini, kita akan menerapkan algoritma Pembelajaran-Q sederhana dalam Python. Agen akan belajar menavigasi dunia kisi untuk memaksimalkan imbalannya.

Menentukan Lingkungan

Kita menentukan dunia kisi berukuran 4×4 yang sederhana. Agen mulai dari sudut kiri atas dan harus mencapai sudut kanan bawah untuk menerima imbalan.

import numpy as np

# Define the environment
num_states = 16  # 4x4 grid
num_actions = 4  # Up, Down, Left, Right

# Define rewards (-1 for each step, +10 for the goal)
rewards = np.zeros(num_states)
rewards[-1] = 10

Menginisialisasi Tabel-Q

Tabel-Q diinisialisasi dengan zeros untuk semua pasangan keadaan-tindakan.

# Initialize the Q-Table
q_table = np.zeros((num_states, num_actions))

print("Initial Q-Table:")
print(q_table)

Mengimplementasikan Algoritma Pembelajaran-Q

Kita menggunakan parameter berikut:

• α (Laju Pembelajaran): Mengatur seberapa besar informasi baru menimpa informasi lama.
• γ (Faktor Diskonto): Menentukan bobot imbalan masa depan dibandingkan dengan imbalan langsung.
• ε (Laju Eksplorasi): Menyeimbangkan eksplorasi dan eksploitasi.

# Parameters
alpha = 0.1  # Learning rate
gamma = 0.9  # Discount factor
epsilon = 0.1  # Exploration rate

# Q-Learning loop
num_episodes = 1000
for episode in range(num_episodes):
    state = 0  # Start at the first state
    done = False
    while not done:
        # Exploration or exploitation
        if np.random.rand() < epsilon:
            action = np.random.randint(num_actions)  # Explore
        else:
            action = np.argmax(q_table[state])  # Exploit

        # Transition to the next state
        next_state = (state + action) % num_states  # Simplified transition logic
        reward = rewards[next_state]

        # Update Q-value
        q_table[state, action] = q_table[state, action] + alpha * (
            reward + gamma * np.max(q_table[next_state]) - q_table[state, action]
        )

        # Move to the next state
        state = next_state
        done = state == num_states - 1

Mengevaluasi Kebijakan yang Dipelajari

Setelah pelatihan, kita mengevaluasi kebijakan dengan mengikuti tindakan optimal yang tersimpan dalam Tabel-Q:

# Evaluate the policy
state = 0
optimal_path = [state]
while state != num_states - 1:
    action = np.argmax(q_table[state])
    state = (state + action) % num_states  # Simplified transition logic
    optimal_path.append(state)

print("Optimal Path:", optimal_path)

Memvisualisasikan Tabel-Q

Kita dapat memvisualisasikan Tabel-Q untuk memahami nilai yang dipelajari untuk setiap pasangan keadaan-tindakan:

import matplotlib.pyplot as plt
import seaborn as sns

# Visualize Q-Table
plt.figure(figsize=(10, 8))
sns.heatmap(q_table, annot=True, fmt=".2f", cmap="coolwarm")
plt.title("Q-Table Heatmap")
plt.xlabel("Actions")
plt.ylabel("States")
plt.show()

Keunggulan Pembelajaran-Q

Pembelajaran-Q menawarkan beberapa manfaat:

• Sederhana dan mudah diimplementasikan.
• Dapat menangani lingkungan stokastik.
• Mencapai kebijakan optimal dengan eksplorasi yang memadai.

Keterbatasan Pembelajaran-Q

Pembelajaran-Q memiliki beberapa keterbatasan:

• Tidak dapat diskalakan dengan baik untuk lingkungan dengan ruang keadaan-tindakan yang besar.
• Proses pembelajaran dapat berlangsung lambat dalam lingkungan yang kompleks.
• Memerlukan representasi keadaan-tindakan yang terdefinisi dengan baik.

Rangkuman dan Langkah Berikutnya

Dalam pelajaran ini, kita:

• Mengimplementasikan algoritma Pembelajaran-Q sederhana dalam Python.
• Melatih agen untuk menavigasi dunia kisi menggunakan Tabel-Q.
• Mengevaluasi kebijakan yang dipelajari dan memvisualisasikan Tabel-Q.

Selanjutnya, kita akan mempelajari Pembelajaran-Q Mendalam, yang menggunakan jaringan saraf untuk menangani lingkungan dengan ruang keadaan-tindakan yang besar.