Apa itu Reinforcement Learning dalam Kecerdasan Buatan (AI) dan Machine Learning (ML)?

Reinforcement Learning Diagram

C. Fitur Utama dan Pendekatan Implementasi Reinforcement Learning

Fitur Utama pada Reinforcement Learning adalah :

• Dalam RL, agen tidak diinstruksikan tentang lingkungan dan tindakan apa yang harus diambil.
• Itu didasarkan pada proses hit dan trial.
• Agen mengambil tindakan selanjutnya dan mengubah status sesuai dengan umpan balik dari tindakan sebelumnya.
• Agen mungkin mendapatkan hadiah yang tertunda.
• Lingkungan bersifat stokastik, dan agen perlu menjelajahinya untuk mencapai dan mendapatkan imbalan positif yang maksimal.

Ada 3 (Tiga) cara utama untuk menerapkan Reinforcement Learning, yaitu :

1. Value-based

Pendekatan berbasis nilai akan menemukan fungsi nilai optimal, yang merupakan nilai maksimum pada suatu negara di bawah kebijakan apa pun. Oleh karena itu, agen mengharapkan pengembalian jangka panjang di setiap negara bagian di bawah kebijakan π.

2. Policy-based

Pendekatan berbasis kebijakan adalah menemukan kebijakan optimal untuk imbalan masa depan maksimum tanpa menggunakan fungsi nilai. Dalam pendekatan ini, agen mencoba menerapkan kebijakan sedemikian rupa sehingga tindakan yang dilakukan di setiap langkah membantu memaksimalkan imbalan di masa mendatang.

Pendekatan berbasis kebijakan terutama memiliki dua jenis kebijakan :

• Deterministik : Tindakan yang sama dihasilkan oleh kebijakan (π) di negara mana pun.
• Stokastik : Dalam kebijakan ini, probabilitas menentukan tindakan yang dihasilkan.

3. Model-based

Dalam pendekatan berbasis model, model virtual dibuat untuk lingkungan, dan agen menjelajahi lingkungan tersebut untuk mempelajarinya. Tidak ada solusi atau algoritma khusus untuk pendekatan ini karena representasi model berbeda untuk setiap lingkungan.

D. Aplikasi dan contoh dari Reinforcement Learning

Meskipun Pembelajaran Penguatan (Reinforcement Learning) telah menjadi topik yang banyak diminati di bidang AI, penerapan dan penerapannya yang meluas di dunia nyata tetap terbatas. Namun, mencatat hal ini, makalah penelitian berlimpah pada aplikasi teoretis, dan ada beberapa kasus penggunaan yang berhasil.

Berikut adalah beberapa contoh aplikasi dari Reinforcement Learning (RL) :

1. Game playing

RL telah digunakan dalam berbagai permainan seperti Go, catur, shogi, poker, dan video game, untuk menciptakan agen yang bisa bermain dengan tingkat keahlian manusia atau bahkan melampaui keahlian manusia. Contohnya adalah AlphaGo, AlphaZero, dan OpenAI Five.

2. Robotika

RL dapat digunakan untuk melatih robot untuk belajar melakukan tugas-tugas seperti manipulasi objek, navigasi, dan berinteraksi dengan lingkungan sekitar. Contohnya adalah manipulasi benda dengan tangan robot, mengemudikan mobil otonom, dan drone yang bisa terbang sendiri.

Deep Learning dan Reinforcement Learning dapat digunakan untuk mengajarkan robot memahami berbagai objek, termasuk yang tidak terlihat selama pelatihan. Misalnya, dapat digunakan untuk memproduksi produk di jalur perakitan. Ini dicapai dengan mengintegrasikan pengoptimalan terdistribusi skala besar dengan QT-Opt, varian dari Deep Q-Learning.

Karena QT-Opt mendukung mode operasi berkelanjutan, sangat cocok untuk tantangan robotika. Model dilatih secara offline sebelum digunakan dan disesuaikan dengan robot hidup. Selama empat bulan, Google AI menerapkan teknologi ini pada robotika, di mana tujuh robot sungguhan bekerja selama 800 Jam.

3. Sistem Rekomendasi

RL dapat digunakan dalam sistem rekomendasi untuk merekomendasikan produk atau konten yang relevan kepada pengguna berdasarkan kebiasaan dan preferensi mereka. Contohnya adalah Netflix dan Spotify.

4. Manajemen Persediaan

RL dapat digunakan untuk mengoptimalkan manajemen persediaan, di mana agen belajar untuk mengambil keputusan tentang kapan dan berapa banyak stok yang harus diambil dari gudang. Contohnya adalah pengiriman barang oleh Amazon dan Alibaba.

5. Pengendalian Energi

RL dapat digunakan untuk mengoptimalkan penggunaan energi di rumah, gedung, atau jaringan listrik dengan mengambil keputusan tentang kapan dan bagaimana menghasilkan, menyimpan, dan menggunakan energi. Contohnya adalah smart home dan smart grid.

6. Pengendalian Lalu Lintas

RL dapat digunakan untuk mengoptimalkan pengaturan lalu lintas dan mencegah kemacetan di jalan raya dengan mengambil keputusan tentang waktu dan arah yang tepat untuk mengubah sinyal lalu lintas. Contohnya adalah kota Oslo di Norwegia dan Los Angeles di Amerika Serikat.

7. Sektor Kesehatan

Kebijakan yang dipelajari menggunakan sistem RL Reinforcement Learning dapat membantu pasien dalam perawatan kesehatan.  Reinforcement Learning dapat membangun pilihan tindakan yang optimal berdasarkan pengalaman atau diagnosis sebelumnya, bahkan tanpa pemahaman sebelumnya tentang model matematika sistem biologis.

Oleh karena itu, teknologi ini lebih cocok untuk kesehatan daripada sistem berbasis pemantauan lainnya. Contoh  Reinforcement Learning dalam perawatan kesehatan termasuk Rejimen pengobatan dinamis atau dynamic treatment regimens (DTR) pada penyakit kronis atau perawatan kritis, diagnostik medis otomatis, dan aplikasi luas lainnya.

8. Otomasi Industri

Robot berbasis pembelajaran digunakan untuk melakukan berbagai tugas dalam penguatan industri. Selain lebih efisien dari manusia, robot-robot ini juga dapat melakukan tugas-tugas yang mungkin dianggap tidak aman oleh manusia.

Contoh yang bagus adalah penggunaan agen AI oleh Deepmind untuk mendinginkan Pusat Data Google. Hal ini mengakibatkan penurunan konsumsi energi sebesar 40%. Sistem AI saat ini mengontrol pusat sepenuhnya tanpa interaksi manusia. Para ahli di pusat data jelas masih bertanggung jawab atas pengawasan. Sistem beroperasi sebagai berikut :

• Mengambil snapshot data selama lima menit dari pusat data dan memasukkannya ke algoritma jaringan  yang dalam
• Kemudian meramalkan dampak dari berbagai kombinasi pada penggunaan energi di masa depan.
• Mengidentifikasi langkah-langkah yang akan menghasilkan penggunaan energi minimal sambil mematuhi serangkaian standar keselamatan
• Mengirim aktivitas ini ke pusat data dan menerapkannya

9. Bidang Lainnya

Dan masih banyak bidang-bidang lainnya yang dapat diterapkan pada Reinforcement Learning.

E. Perbedaan Reinforcement Learning dalam Deep Learning (DL) dan Machine Learning (ML)

Faktanya, perbedaan antara Machine Learning, Deep Learning, dan Reinforcement Learning harus kabur. Machine Learning adalah kategori terbesar, sedangkan Reinforcement Learning adalah yang tersempit. Reinforcement Learning di sisi lain, adalah aplikasi khusus dari machine dan deep learning yang digunakan untuk memecahkan masalah dengan cara tertentu.

1. Machine Learning

Yaitu semacam AI di mana komputer diberi kemampuan untuk meningkatkan kinerja mereka pada tugas tertentu dari waktu ke waktu dengan menggunakan data daripada diajarkan secara langsung (menurut Arthur Lee Samuel). Dia menciptakan istilah "machine learning" yang dibagi menjadi dua jenis: diawasi dan tidak diawasi. Machine learning yang diawasi terjadi ketika seorang programmer dapat memberikan label untuk setiap masukan pelatihan ke dalam sistem pembelajaran mesin.

2. Supervised Learning

Terjadi ketika seorang programmer dapat memberi label pada setiap input pelatihan ke dalam sistem pembelajaran mesin. Aplikasi umum dari pembelajaran yang diawasi adalah model pengenalan gambar. Model-model ini menerima satu set gambar berlabel dan belajar membedakan atribut umum dari bentuk yang telah ditentukan sebelumnya.

3. Semi-supervised Learning

Metode ini mengambil pendekatan jalan tengah. Pengembang memasukkan kumpulan data pelatihan berlabel yang relatif kecil, serta kumpulan data tidak berlabel yang lebih besar. Algoritme kemudian diinstruksikan untuk mengekstrapolasi apa yang dipelajarinya dari data berlabel ke data yang tidak berlabel dan menarik kesimpulan dari himpunan secara keseluruhan.

4. Unsupervised Learning

Terjadi ketika model hanya disediakan dengan data input, tetapi tidak ada label eksplisit. Metode ini harus menyaring data untuk mengungkap struktur atau korelasi yang mendasarinya. Perancang/programmer mungkin tidak menyadari struktur atau hasil dari model machine learning. Prediksi churn adalah salah satu contoh yang  digunakan. Sistem mengevaluasi data konsumen dan merancang algoritme untuk mengklasifikasikan klien ke dalam kelompok. Kelompok-kelompok, di sisi lain, tidak dipilih oleh sistem. Sistem dapat mengidentifikasi kelompok berisiko tinggi (mereka yang memiliki tingkat churn tinggi) setelahnya, dan perusahaan tahu siapa yang harus didekati terlebih dahulu. Deteksi nomaly adalah bentuk lain dari unsupervised learning, di mana algoritma harus mengidentifikasi elemen yang tidak termasuk dalam grup. Ini bisa berupa produk yang salah, kemungkinan transaksi penipuan, atau insiden lain yang tidak biasa.

5. Deep Learning

Terdiri dari beberapa lapisan jaringan saraf yang dimaksudkan untuk menyelesaikan tugas yang lebih kompleks. Model deep learning dibuat menggunakan versi sederhana dari desain otak manusia. Model deep learning terdiri dari beberapa lapisan jaringan saraf yang bertugas secara bertahap mempelajari properti yang lebih abstrak tentang input tertentu. Meskipun solusi deep learning dapat menghasilkan hasil yang fantastis, mereka tidak cocok untuk otak manusia dalam hal skala. Setiap lapisan mengambil hasil dari yang sebelumnya sebagai input, dan seluruh jaringan dilatih sebagai satu unit.

6. Reinforcement Learning

Seperti yang dinyatakan di atas menggunakan sistem rewards dan punishment untuk memaksa komputer memecahkan masalah dengan sendirinya. Keterlibatan manusia terbatas pada perubahan lingkungan dan menyempurnakan sistem rewards dan punishment. Ketika komputer berusaha untuk memaksimalkan rewards, ia cenderung menemukan cara baru untuk mencapainya. Keterlibatan manusia ditujukan untuk mencegah komputer menyalahgunakan sistem dan menginspirasinya untuk melakukan pekerjaan sebagaimana dimaksud. Ketika tidak ada "cara yang benar / right way" untuk menyelesaikan task, tetapi ada aturan yang harus diikuti model untuk melakukan tugasnya dengan benar, reinforcement learning dapat digunakan secara efektif. Contohnya road code.

F. Jenis-jenis Algoritma dalam Reinforcement Learning

Algoritma Reinforcement Learning (RL) dapat dibagi menjadi tiga jenis berdasarkan pendekatan mereka dalam menyelesaikan masalah, yaitu :

1. Policy Gradient (PG)

Dalam metode ini, kita memiliki kebijakan π yang memiliki parameter θ. π ini menghasilkan distribusi probabilitas tindakan.

Kemudian kita harus mencari parameter terbaik (θ) untuk memaksimalkan (mengoptimalkan) fungsi skor J(θ), dengan memberikan faktor diskon γ dan reward r.

Langkah utama :

• Mengukur kualitas suatu kebijakan dengan fungsi skor kebijakan.
• Gunakan kenaikan gradien kebijakan untuk menemukan parameter terbaik yang meningkatkan kebijakan.

Contoh Program :

import torch
import torch.nn as nn
import torch.optim as optim

class Policy(nn.Module):
    def __init__(self, state_size, action_size, hidden_size):
        super(Policy, self).__init__()
        self.fc1 = nn.Linear(state_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, action_size)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.softmax(self.fc2(x))
        return x

def train(env, policy, optimizer, gamma):
    state = env.reset()
    log_probs = []
    rewards = []
    episode_reward = 0

    while True:
        state = torch.FloatTensor(state)
        action_probs = policy(state)
        dist = torch.distributions.Categorical(action_probs)
        action = dist.sample()
        log_prob = dist.log_prob(action)
        log_probs.append(log_prob)

        state, reward, done, _ = env.step(action.item())
        rewards.append(reward)
        episode_reward += reward

        if done:
            discounted_rewards = []
            G = 0
            for reward in rewards[::-1]:
                G = gamma * G + reward
                discounted_rewards.insert(0, G)
            discounted_rewards = torch.FloatTensor(discounted_rewards)
            discounted_rewards = (discounted_rewards - discounted_rewards.mean()) / (discounted_rewards.std() + 1e-9)
            policy_loss = []
            for log_prob, G in zip(log_probs, discounted_rewards):
                policy_loss.append(-log_prob * G)
            optimizer.zero_grad()
            policy_loss = torch.stack(policy_loss).sum()
            policy_loss.backward()
            optimizer.step()
            break

    return episode_reward

if __name__ == '__main__':
    env = gym.make('CartPole-v1')
    state_size = env.observation_space.shape[0]
    action_size = env.action_space.n
    hidden_size = 64
    lr = 0.001
    gamma = 0.99

    policy = Policy(state_size, action_size, hidden_size)
    optimizer = optim.Adam(policy.parameters(), lr=lr)

    for i in range(1000):
        episode_reward = train(env, policy, optimizer, gamma)
        print('Episode', i, 'Reward', episode_reward)

2. Asynchronous Advantage Actor-Critic (A3C)

Metode ini diterbitkan oleh Google DeepMind Group dan mencakup konsep kunci berikut yang disematkan dalam penamaannya:

• Asinkron : Beberapa agen dilatih dalam salinan lingkungannya sendiri dan model dari agen ini dikumpulkan dalam agen utama. Alasan di balik ide ini adalah bahwa pengalaman masing-masing agen tidak bergantung pada pengalaman agen lainnya. Dengan cara ini keseluruhan pengalaman yang tersedia untuk pelatihan menjadi lebih beragam.
• Keuntungan : Serupa dengan PG di mana aturan pembaruan menggunakan pengembalian yang dipotong dari serangkaian pengalaman untuk memberi tahu agnet tindakan mana yang "baik" atau "buruk".
• Aktor-kritik : menggabungkan manfaat kedua pendekatan dari metode iterasi kebijakan sebagai PG dan metode iterasi nilai sebagai Q-learning (Lihat di bawah). Jaringan akan mengestimasi fungsi nilai V(s) (seberapa baik keadaan tertentu) dan kebijakan π(s).

import torch
import torch.nn as nn
import torch.optim as optim
import gym

class ActorCritic(nn.Module):
    def __init__(self):
        super(ActorCritic, self).__init__()
        self.fc1 = nn.Linear(4, 256)
        self.fc2 = nn.Linear(256, 2)
        self.fc3 = nn.Linear(256, 1)
        self.optimizer = optim.Adam(self.parameters(), lr=0.01)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        action_scores = self.fc2(x)
        state_values = self.fc3(x)
        return action_scores, state_values
    
    def get_action(self, state):
        action_scores, _ = self.forward(state)
        action_probs = torch.softmax(action_scores, dim=-1)
        action = torch.multinomial(action_probs, num_samples=1)
        return action.item()
    
env = gym.make('CartPole-v0')
model = ActorCritic()
gamma = 0.99

for i_episode in range(1000):
    state = env.reset()
    done = False
    while not done:
        log_probs = []
        values = []
        rewards = []
        for t in range(100):
            action = model.get_action(torch.FloatTensor(state))
            next_state, reward, done, _ = env.step(action)
            log_prob = torch.log_softmax(model.forward(torch.FloatTensor(state))[0], dim=-1)[action]
            value = model.forward(torch.FloatTensor(state))[1]
            log_probs.append(log_prob)
            values.append(value)
            rewards.append(reward)
            state = next_state
            if done:
                break
        returns = []
        R = 0
        for r in reversed(rewards):
            R = r + gamma * R
            returns.insert(0, R)
        returns = torch.FloatTensor(returns)
        log_probs = torch.cat(log_probs)
        values = torch.cat(values)
        advantage = returns - values
        actor_loss = (-log_probs * advantage.detach()).mean()
        critic_loss = advantage.pow(2).mean()
        loss = actor_loss + critic_loss
        model.optimizer.zero_grad()
        loss.backward()
        model.optimizer.step()

3. Trust Region Policy Optimization (TRPO)

Algoritma sesuai kebijakan yang dapat digunakan atau lingkungan dengan ruang tindakan diskrit atau kontinu. TRPO memperbarui kebijakan dengan mengambil langkah sebesar mungkin untuk meningkatkan kinerja, sambil memenuhi batasan khusus tentang seberapa dekat kebijakan baru dan lama diperbolehkan.

Pengantar komprehensif disediakan di TRPO dalam posting blog ini dan ini serta repo hebat yang menyediakan solusi berbasis Tensorflow dan OpenAI Gym.

Contoh Program :

import tensorflow as tf
import gym

# define hyperparameters
lr_actor = 0.0003
lr_critic = 0.001
gamma = 0.99
gae_lambda = 0.95
clip_ratio = 0.2
ent_coef = 0.01
batch_size = 64
max_episodes = 5000
max_steps = 200
critic_update_freq = 10

# define environment
env = gym.make('Pendulum-v0')

# define network architecture
input_shape = env.observation_space.shape[0]
output_shape = env.action_space.shape[0]

def build_actor(input_shape, output_shape):
    input_layer = tf.keras.layers.Input(shape=(input_shape,))
    x = tf.keras.layers.Dense(64, activation='relu')(input_layer)
    x = tf.keras.layers.Dense(64, activation='relu')(x)
    output_layer = tf.keras.layers.Dense(output_shape, activation='tanh')(x)
    model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)
    return model

def build_critic(input_shape):
    input_layer = tf.keras.layers.Input(shape=(input_shape,))
    x = tf.keras.layers.Dense(64, activation='relu')(input_layer)
    x = tf.keras.layers.Dense(64, activation='relu')(x)
    output_layer = tf.keras.layers.Dense(1)(x)
    model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)
    return model

# define actor and critic
actor = build_actor(input_shape, output_shape)
critic = build_critic(input_shape)

# define optimizer
optimizer_actor = tf.keras.optimizers.Adam(lr_actor)
optimizer_critic = tf.keras.optimizers.Adam(lr_critic)

# define loss function
mse_loss = tf.keras.losses.MeanSquaredError()

# define function to calculate advantage
def calculate_advantage(rewards, values, next_value):
    n = len(rewards)
    td_targets = np.zeros(n)
    advantages = np.zeros(n)

    for i in range(n-1, -1, -1):
        if i == n-1:
            td_targets[i] = rewards[i] + gamma * next_value
        else:
            td_targets[i] = rewards[i] + gamma * values[i+1]

        advantages[i] = td_targets[i] - values[i]

    return advantages, td_targets

# define function to compute gradients
@tf.function
def compute_gradients(states, actions, advantages, old_log_probs):
    with tf.GradientTape() as tape:
        # calculate log probabilities and entropy of the actions
        logits = actor(states)
        dist = tfp.distributions.Normal(loc=logits, scale=tf.ones_like(logits))
        new_log_probs = dist.log_prob(actions)
        entropy = dist.entropy()

        # calculate ratio and clipped ratio
        ratio = tf.exp(new_log_probs - old_log_probs)
        clipped_ratio = tf.clip_by_value(ratio, 1-clip_ratio, 1+clip_ratio)

        # calculate actor loss
        actor_loss = -tf.reduce_mean(tf.minimum(ratio * advantages, clipped_ratio * advantages))
        actor_loss -= ent_coef * tf.reduce_mean(entropy)

    actor_gradients = tape.gradient(actor_loss, actor.trainable_variables)

    with tf.GradientTape() as tape:
        # calculate critic loss
        values = critic(states)
        critic_loss = tf.reduce_mean(mse_loss(values, td_targets))

    critic_gradients = tape.gradient(critic_loss, critic.trainable_variables)

    return actor_gradients, critic_gradients, actor_loss, critic_loss

4. Proximal Policy Optimization (PPO)

Juga algoritme on-policy yang serupa dengan TRPO dapat bekerja pada ruang tindakan diskrit atau berkelanjutan. PPO berbagi motivasi dengan TRPO dalam tugas menjawab pertanyaan: bagaimana meningkatkan perbaikan kebijakan tanpa risiko keruntuhan kinerja? Idenya adalah PPO meningkatkan stabilitas pelatihan Aktor dengan membatasi pembaruan kebijakan pada setiap langkah pelatihan.

Contoh Program :

import torch
import torch.nn as nn
import torch.optim as optim
import gym

# Hyperparameters
lr = 0.00025
gamma = 0.99
epsilon_clip = 0.2
batch_size = 64
ppo_epochs = 10

# Neural network for policy
class Policy(nn.Module):
    def __init__(self, num_inputs, num_actions):
        super(Policy, self).__init__()
        self.fc1 = nn.Linear(num_inputs, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, num_actions)
        self.optimizer = optim.Adam(self.parameters(), lr=lr)
        
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def act(self, state):
        state = torch.from_numpy(state).float().unsqueeze(0)
        logits = self.forward(state)
        probs = nn.functional.softmax(logits, dim=1)
        action_probs = torch.distributions.Categorical(probs)
        action = action_probs.sample()
        log_prob = action_probs.log_prob(action)
        return action.item(), log_prob.item()
    
    def evaluate(self, state, action):
        logits = self.forward(state)
        probs = nn.functional.softmax(logits, dim=1)
        dist = torch.distributions.Categorical(probs)
        log_prob = dist.log_prob(action)
        entropy = dist.entropy()
        return log_prob, entropy

# Memory buffer for storing transitions
class Memory:
    def __init__(self):
        self.states = []
        self.actions = []
        self.rewards = []
        self.log_probs = []
        
    def clear_memory(self):
        del self.states[:]
        del self.actions[:]
        del self.rewards[:]
        del self.log_probs[:]

    def add_memory(self, state, action, reward, log_prob):
        self.states.append(state)
        self.actions.append(action)
        self.rewards.append(reward)
        self.log_probs.append(log_prob)

# PPO algorithm
def ppo(env, num_episodes):
    policy = Policy(env.observation_space.shape[0], env.action_space.n)
    memory = Memory()
    
    for episode in range(num_episodes):
        state = env.reset()
        done = False
        total_reward = 0
        while not done:
            action, log_prob = policy.act(state)
            next_state, reward, done, _ = env.step(action)
            memory.add_memory(state, action, reward, log_prob)
            total_reward += reward
            state = next_state
        
        # Policy update
        for _ in range(ppo_epochs):
            states = torch.FloatTensor(memory.states)
            actions = torch.LongTensor(memory.actions)
            old_log_probs = torch.FloatTensor(memory.log_probs)
            rewards = torch.FloatTensor(memory.rewards)
            
            # Advantage estimation
            returns = []
            discounted_reward = 0
            for reward in reversed(rewards):
                discounted_reward = reward + gamma * discounted_reward
                returns.insert(0, discounted_reward)
            returns = torch.tensor(returns)
            advantages = returns - returns.mean()
            advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-5)
            
            # Policy update using PPO loss
            advantages = rewards - values
            for _ in range(num_epochs):
                for i in range(num_steps):
                    with tf.GradientTape() as tape:
                        logits, values = actor_critic_model(tf.convert_to_tensor(states[i], dtype=tf.float32))
                        dist = tfp.distributions.Categorical(logits=logits)
                        entropy = tf.reduce_mean(dist.entropy())
                        new_log_prob = dist.log_prob(tf.convert_to_tensor(actions[i], dtype=tf.int32))
                        ratio = tf.exp(new_log_prob - old_log_probs[i])
                        surr1 = ratio * advantages[i]
                        surr2 = tf.clip_by_value(ratio, 1 - epsilon, 1 + epsilon) * advantages[i]
                        actor_loss = -tf.reduce_mean(tf.minimum(surr1, surr2))
                        critic_loss = tf.reduce_mean(tf.square(rewards - values))
                        total_loss = actor_loss + critic_coef * critic_loss - entropy_coef * entropy
                
                    gradients = tape.gradient(total_loss, actor_critic_model.trainable_variables)
                    optimizer.apply_gradients(zip(gradients, actor_critic_model.trainable_variables))

5. State-Action-Reward State-Action (SARSA)

State-Action-Reward State-Action atau SARSA adalah algoritma lain yang sering digunakan dalam Reinforcement Learning. Algoritma ini mirip dengan Q-Learning, tetapi lebih mengutamakan kestabilan daripada kecepatan pembelajaran. SARSA menggunakan nilai aksi yang aktual yang diambil oleh agen saat melakukan aksi pada saat berikutnya, sehingga memperhitungkan lebih banyak faktor dari tindakan yang diambil saat ini.

Contoh Program :

import numpy as np

# inisialisasi Q table
Q = np.zeros([state_space_size, action_space_size])

# hyperparameters
alpha = 0.1
gamma = 0.99
epsilon = 0.1

# main loop
for episode in range(num_episodes):
    state = env.reset()
    done = False
    
    # pilih aksi pertama menggunakan epsilon-greedy
    if np.random.rand() < epsilon:
        action = env.action_space.sample()
    else:
        action = np.argmax(Q[state])
    
    while not done:
        # lakukan aksi
        next_state, reward, done, _ = env.step(action)
        
        # pilih aksi selanjutnya menggunakan epsilon-greedy
        if np.random.rand() < epsilon:
            next_action = env.action_space.sample()
        else:
            next_action = np.argmax(Q[next_state])

6. Double Deep Q-Network (DDQN)

Double Deep Q-Network (DDQN) adalah variasi dari DQN yang mengatasi masalah overestimation pada DQN. Pada DQN, Q-value yang dihitung seringkali overestimate, terutama saat modelnya sudah terlalu percaya pada suatu tindakan yang telah dilakukan. Hal ini dapat mengarah pada keputusan yang buruk dalam situasi yang kompleks. Oleh karena itu, DDQN menggunakan dua jaringan saraf untuk mengatasi overestimation: satu untuk memprediksi aksi yang optimal, dan satu lagi untuk mengevaluasi nilainya. Dalam hal ini, Q-value dihitung menggunakan jaringan yang mengevaluasi nilai, dan aksi yang dipilih dihitung menggunakan jaringan yang memprediksi aksi yang optimal.

Rumus :

Contoh Program :

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

class DQNAgent():
    def __init__(self, state_dim, action_dim, lr, gamma, epsilon_decay):
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.lr = lr
        self.gamma = gamma
        self.epsilon_decay = epsilon_decay

        self.epsilon = 1.0
        self.memory = []
        self.batch_size = 32
        self.epsilon_min = 0.01
        self.model = self.build_model()
        self.target_model = self.build_model()

    def build_model(self):
        model = nn.Sequential(
            nn.Linear(self.state_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, self.action_dim)
        )
        optimizer = optim.Adam(model.parameters(), lr=self.lr)
        criterion = nn.MSELoss()
        return model, optimizer, criterion

    def select_action(self, state):
        if np.random.rand() <= self.epsilon:
            return np.random.choice(self.action_dim)
        state_tensor = torch.tensor(state, dtype=torch.float32)
        q_values = self.model(state_tensor)
        return torch.argmax(q_values).item()

    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
        batch = np.array(random.sample(self.memory, self.batch_size))
        states = torch.tensor(np.stack(batch[:, 0]), dtype=torch.float32)
        actions = torch.tensor(batch[:, 1], dtype=torch.int64).reshape(-1, 1)
        rewards = torch.tensor(batch[:, 2], dtype=torch.float32).reshape(-1, 1)
        next_states = torch.tensor(np.stack(batch[:, 3]), dtype=torch.float32)
        dones = torch.tensor(batch[:, 4], dtype=torch.float32).reshape(-1, 1)

        # DDQN
        q_values = self.model(states)
        next_q_values = self.model(next_states)
        next_q_state_values = self.target_model(next_states)
        next_q_state_values = next_q_state_values.gather(1, torch.argmax(next_q_values, dim=1, keepdim=True)).detach()
        target_q_values = rewards + self.gamma * next_q_state_values * (1 - dones)
        target_q_values = target_q_values.detach()

        q_values = q_values.gather(1, actions)
        loss = self.criterion(q_values, target_q_values)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

        self.epsilon *= self.epsilon_decay
        self.epsilon = max(self.epsilon_min, self.epsilon)

    def update_target_model(self):
        self.target_model.load_state_dict(self.model.state_dict())

    def save_model(self, filename):
        torch.save(self.model.state_dict(), filename)

    def load_model(self, filename):
        self.model.load_state_dict(torch.load(filename))
        self.target_model.load_state_dict(torch.load(filename))

7. Deep Q Neural Network (DQN)

DQN adalah Q-learning dengan Neural Networks. Motivasi di baliknya hanya terkait dengan lingkungan ruang keadaan besar di mana mendefinisikan tabel-Q akan menjadi tugas yang sangat kompleks, menantang, dan memakan waktu. Alih-alih Q-table Neural Networks memperkirakan nilai-Q untuk setiap tindakan berdasarkan status.

Nilai Q-learning dapat diturunkan dari Persamaan Bellman. Pertimbangkan Persamaan Bellman yang diberikan di bawah ini :

Contoh Program :

# Hyperparameters
EPISODES = 1000
BATCH_SIZE = 32
LEARNING_RATE = 0.001
DISCOUNT_FACTOR = 0.99
REPLAY_MEMORY_SIZE = 10000
UPDATE_TARGET_EVERY = 5

# Initialize replay memory
replay_memory = deque(maxlen=REPLAY_MEMORY_SIZE)

# Initialize the DQN model and target network
dqn = DQNAgent(state_size, action_size, LEARNING_RATE, DISCOUNT_FACTOR)
target_dqn = DQNAgent(state_size, action_size, LEARNING_RATE, DISCOUNT_FACTOR)

# Copy the DQN model weights to the target network
target_dqn.model.set_weights(dqn.model.get_weights())

# Training loop
for episode in range(EPISODES):
    # Initialize state
    state = env.reset()

    # Initialize variables for the episode
    total_reward = 0
    done = False

    while not done:
        # Choose an action using the DQN model
        action = dqn.act(state)

        # Take the chosen action and observe the next state, reward, and done flag
        next_state, reward, done, _ = env.step(action)

        # Add the experience to the replay memory
        replay_memory.append((state, action, reward, next_state, done))

        # Update the DQN model weights every UPDATE_TARGET_EVERY steps
        if len(replay_memory) >= BATCH_SIZE and episode % UPDATE_TARGET_EVERY == 0:
            # Sample a minibatch from the replay memory
            minibatch = random.sample(replay_memory, BATCH_SIZE)

            # Preprocess the minibatch data
            states = np.array([m[0] for m in minibatch])
            actions = np.array([m[1] for m in minibatch])
            rewards = np.array([m[2] for m in minibatch])
            next_states = np.array([m[3] for m in minibatch])
            dones = np.array([m[4] for m in minibatch])

            # Calculate the target Q-values using the target network
            target_q_values = target_dqn.model.predict(next_states)
            target_q_values[dones] = np.zeros((action_size,))
            target_q_values = rewards + DISCOUNT_FACTOR * np.max(target_q_values, axis=1)

            # Train the DQN model on the minibatch
            dqn.train_on_batch(states, actions, target_q_values)

            # Update the target network weights with the DQN model weights
            target_dqn.model.set_weights(dqn.model.get_weights())

        # Update the state and total reward
        state = next_state
        total_reward += reward

    # Print the episode results
    print("Episode:", episode + 1, "Total Reward:", total_reward)

8. Q-Learning

import numpy as np

# Inisialisasi lingkungan
num_states = 6
num_actions = 2
reward_matrix = np.array([
    [-1, -1, -1, -1, 0, -1],
    [-1, -1, -1, 0, -1, 100],
    [-1, -1, -1, 0, -1, -1],
    [-1, 0, 0, -1, 0, -1],
    [0, -1, -1, 0, -1, 100],
    [-1, 0, -1, -1, 0, 100]
])

# Inisialisasi Q-table
q_table = np.zeros((num_states, num_actions))

# Hyperparameter
learning_rate = 0.8
discount_factor = 0.95
num_episodes = 1000

# Pelatihan
for episode in range(num_episodes):
    # Inisialisasi state awal
    current_state = np.random.randint(0, num_states)

    while current_state != 5: # Lakukan sampai mencapai state goal
        # Pilih aksi dengan explorasi atau exploitation
        if np.random.uniform() < 0.2:
            action = np.random.randint(0, num_actions)
        else:
            action = np.argmax(q_table[current_state, :])

        # Perbarui Q-table
        next_state = np.argmax(reward_matrix[current_state, :])
        q_table[current_state, action] = q_table[current_state, action] + learning_rate * \
            (reward_matrix[current_state, action] + discount_factor * np.max(q_table[next_state, :]) -
             q_table[current_state, action])

        current_state = next_state

# Cetak Q-table
print("Q-table:")
print(q_table)

Output :

Q-table:
[[-1.     -1.    ]
 [-1.     -1.    ]
 [-1.9025 -1.9025]
 [-1.95   -0.95  ]
 [ 0.     -1.    ]
 [ 0.      0.    ]]

G. Cara Kerja Reinforcement Learning

Reinforcement learning (RL) adalah sebuah metode di mana agen belajar bagaimana merespons lingkungan yang tidak dikenal dan mencapai tujuan tertentu. RL didasarkan pada asumsi bahwa setiap tujuan dapat dicapai dengan cara memaksimalkan jumlah imbalan yang diharapkan.

Dalam RL, agen harus belajar merespons dan memengaruhi lingkungan dengan mengambil tindakan yang tepat untuk mendapatkan imbalan maksimal. Tujuan dari algoritma RL adalah untuk menemukan kebijakan tindakan yang akan memaksimalkan rata-rata nilai imbalan yang dapat diperoleh dari setiap keadaan dalam sistem.

Untuk memahami proses kerja reinforcement learning, kita perlu memperhatikan dua hal utama :

• Lingkungan : Ini bisa berupa apa saja seperti ruangan, labirin, lapangan sepak bola, dll.
• Agen : Agen cerdas seperti robot AI.

Mari kita ambil contoh lingkungan labirin yang perlu dijelajahi oleh agen. Perhatikan gambar di bawah ini :

Pada gambar di atas, agen berada di blok pertama labirin. Labirin terdiri dari blok S6, yang merupakan dinding, S8 adalah lubang api, dan S4 adalah blok berlian.

Agen tidak dapat melewati blok S6, karena merupakan dinding yang kokoh. Jika agen mencapai blok S4, maka akan mendapat imbalan +1; jika mencapai lubang api, maka mendapat imbalan poin -1. Agen dapat mengambil empat tindakan: bergerak ke atas, bergerak ke bawah, bergerak ke kiri, dan bergerak ke kanan.

Agen dapat mengambil jalan apa pun untuk mencapai titik akhir, tetapi ia perlu melakukannya dengan langkah yang paling sedikit.

Misalkan agen mempertimbangkan jalur S9-S5-S1-S2-S3, maka dia akan mendapatkan poin imbalan +1.

Agen akan mencoba mengingat langkah-langkah sebelumnya yang telah diambil untuk mencapai langkah terakhir.

Untuk menghafal langkah-langkah, agen memberikan nilai 1 untuk setiap langkah sebelumnya. Pertimbangkan langkah di bawah ini :

Cara Kerja Reinforcement Learning

Kasus ini akan menjadi kondisi yang sulit bagi agen apakah ia harus naik atau turun karena setiap blok memiliki nilai yang sama.

Jadi, pendekatan di atas tidak cocok bagi agen untuk mencapai tujuan. Oleh karena itu untuk memecahkan masalah ini, kita akan menggunakan Persamaan Bellman, yang merupakan konsep utama di balik Reinforcement Learning.

Dengan menggunakan Persamaan Bellman di atas, kita akan menemukan nilai pada setiap keadaan lingkungan yang diberikan. Kita akan mulai dari blok yang berada di sebelah blok target.

Untuk blok ke-1 :

V(s3) = max [R(s,a) + V(s`)], di sini V(s')= 0 karena tidak ada keadaan lebih lanjut untuk dipindahkan.

V(s3) = max[R(s,a)]=> V(s3)= max[1]=> V(s3)= 1.

Untuk blok ke-2 :

V(s2) = max [R(s,a) + V(s`)], di sini = 0.9(let), V(s')= 1, dan R(s, a)= 0, karena ada tidak ada imbalan di keadaan ini.

V(s2) = maks[0,9(1)]=> V(s)= maks[0,9]=> V(s2) =0,9

Untuk blok ke-3 :

V(s1) = max [R(s,a) + V(s`)], di sini = 0.9(let), V(s')= 0.9, dan R(s, a)= 0, karena ada tidak ada imbalan di keadaan ini juga.

V(s1) = maks[0.9(0.9)]=> V(s3)= maks[0.81]=> V(s1) =0.81

Untuk blok ke-4 :

V(s5) = max [R(s,a) + V(s`)], disini = 0.9(let), V(s')= 0.81, dan R(s, a)= 0, karena ada tidak ada imbalan di keadaan ini juga.

V(s5) = maks[0.9(0.81)]=> V(s5)= maks[0.81]=> V(s5) =0.73

Untuk blok ke-5 :

V(s9) = max [R(s,a) + V(s`)], di sini = 0.9(let), V(s')= 0.73, dan R(s, a)= 0, karena ada tidak ada imbalan di keadaan ini.

V(s9) = maks[0.9(0.73)]=> V(s4)= maks[0.81]=> V(s4) =0.66

Perhatikan gambar di bawah ini :

Reinforcement Learning (Bellman Equation)

Sekarang, kita akan bergerak lebih jauh ke blok ke-6, dan di sini agen dapat mengubah rute karena agen harus berusaha mencari jalur yang optimal.

Mari kita pertimbangkan blok di sebelah lubang api.

Sekarang, agen memiliki tiga opsi untuk pindah; jika dia pindah ke kotak biru, maka dia akan berbenturan dengan tembok, jika dia pindah ke lubang api, maka dia akan mendapatkan imbalan -1. 

Karena di sini kita hanya mengambil imbalan positif, maka agen akan naik ke atas saja. Nilai blok lengkap akan dihitung menggunakan rumus yang sudah kita gunakan sebelumnya.

Itulah Materi tentang Reinforcement Learning (RL) dalam Machine Learning (ML) dan Kecerdasan Buatan (AI). Mohon maaf apabila ada kesalahan apapun.

Terima Kasih 😄😘👌👍 :)

Wassalamu‘alaikum wr. wb.