Assalamu‘alaikum wr. wb.
Halo gais! Reinforcement Learning merupakan bagian dari Machine Learning yang juga termasuk dalam Kecerdasan Buatan (AI) untuk berperilaku di Lingkungan dengan melakukan tindakan dan melihat hasil dari tindakan dan belajar melalui percobaan. Mari kita bahas pada Artikel ini sampai tuntas.
Ilustrasi Reinforcement Learning Model |
Sumber Artikel Materi : en.Wikipedia.org, Javatpoint.com, Techtarget.com, Geeksforgeeks.org, Glair.ai, Trivusi.web.id, dan Smartlabai.Medium.com
A. Pengertian Reinforcement Learning
Reinforcement Learning (RL) atau pembelajaran penguatan adalah sub-bidang dalam machine learning yang fokus pada bagaimana sebuah agen dapat belajar untuk membuat keputusan dalam sebuah lingkungan untuk memaksimalkan imbalan akumulatif. Agen belajar melalui Trial and Error, dengan mengambil tindakan dalam lingkungan, dan menerima umpan balik dalam bentuk sinyal imbalan (reward), yang merupakan nilai skalar yang mencerminkan keinginan atas hasil yang diinginkan.
Tujuan dari RL adalah untuk menemukan kebijakan optimal, yaitu pemetaan dari keadaan (state) ke tindakan (action), yang memaksimalkan imbalan akumulatif yang diharapkan dari waktu ke waktu. Kebijakan dapat berupa deterministik atau stokastik, tergantung pada domain masalah. Dalam RL, lingkungan dimodelkan sebagai proses keputusan Markov (Markov decision process atau MDP), yaitu kerangka matematika yang memformalkan masalah pengambilan keputusan dengan interaksi sekuensial antara agen dan lingkungan.
Algoritma RL dapat dibagi menjadi dua kategori: model-based dan model-free. Algoritma berbasis model (model-based) memerlukan model eksplisit dari lingkungan, termasuk probabilitas transisi antara keadaan (states) dan fungsi imbalan (reward function). Algoritma tanpa model (model-free), di sisi lain, belajar kebijakan optimal langsung dari data yang diamati, tanpa mengasumsikan pengetahuan tentang dinamika lingkungan yang mendasarinya.
B. Istilah-istilah dalam Reinforcement Learning
Reinforcement Learning Diagram |
Adapun Istilah-istilah yang digunakan dalam Reinforcement Learning adalah sebagai berikut :
- Agent : Entitas yang dapat melihat/menjelajahi lingkungan dan bertindak berdasarkan itu.
- Environment : Lingkungan atau situasi di mana agen hadir atau dikelilingi olehnya. Di RL, kita mengasumsikan lingkungan bersifat stokastik atau acak.
- Action : Action adalah gerakan yang diambil oleh agen dalam lingkungan.
- State : State adalah situasi yang dikembalikan oleh lingkungan setelah setiap tindakan yang dilakukan oleh agen.
- Reward : Umpan balik yang dikembalikan ke agen dari lingkungan untuk mengevaluasi tindakan agen.
- Policy : Policy adalah strategi yang diterapkan oleh agen untuk tindakan selanjutnya berdasarkan keadaan saat ini.
- Value : Imbalan jangka panjang yang diharapkan dengan faktor diskon dan kebalikan dari imbalan jangka pendek.
- Q-value : Q-value sebagian besar mirip dengan value, tetapi dibutuhkan satu parameter tambahan sebagai tindakan saat ini (a).
- Function Approximator : Mengacu pada masalah penginduksian fungsi dari contoh pelatihan. Approximators standar termasuk pohon keputusan, jaringan saraf, dan metode tetangga terdekat.
- Dynamic Programming (DP) : Merupakan kelas metode solusi untuk memecahkan masalah keputusan berurutan dengan struktur biaya komposisi. Richard Bellman adalah salah satu pendiri utama dari pendekatan ini.
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 torchimport torch.nn as nnimport torch.optim as optimclass 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 xdef train(env, policy, optimizer, gamma):state = env.reset()log_probs = []rewards = []episode_reward = 0while 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 += rewardif done:discounted_rewards = []G = 0for reward in rewards[::-1]:G = gamma * G + rewarddiscounted_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()breakreturn episode_rewardif __name__ == '__main__':env = gym.make('CartPole-v1')state_size = env.observation_space.shape[0]action_size = env.action_space.nhidden_size = 64lr = 0.001gamma = 0.99policy = 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).
- Advantage Function :
- Actor Update :
- Critic Update :
Contoh Program :
import torchimport torch.nn as nnimport torch.optim as optimimport gymclass 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_valuesdef 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.99for i_episode in range(1000):state = env.reset()done = Falsewhile 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_stateif done:breakreturns = []R = 0for r in reversed(rewards):R = r + gamma * Rreturns.insert(0, R)returns = torch.FloatTensor(returns)log_probs = torch.cat(log_probs)values = torch.cat(values)advantage = returns - valuesactor_loss = (-log_probs * advantage.detach()).mean()critic_loss = advantage.pow(2).mean()loss = actor_loss + critic_lossmodel.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 tfimport gym# define hyperparameterslr_actor = 0.0003lr_critic = 0.001gamma = 0.99gae_lambda = 0.95clip_ratio = 0.2ent_coef = 0.01batch_size = 64max_episodes = 5000max_steps = 200critic_update_freq = 10# define environmentenv = gym.make('Pendulum-v0')# define network architectureinput_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 modeldef 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 criticactor = build_actor(input_shape, output_shape)critic = build_critic(input_shape)# define optimizeroptimizer_actor = tf.keras.optimizers.Adam(lr_actor)optimizer_critic = tf.keras.optimizers.Adam(lr_critic)# define loss functionmse_loss = tf.keras.losses.MeanSquaredError()# define function to calculate advantagedef 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_valueelse: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.functiondef compute_gradients(states, actions, advantages, old_log_probs):with tf.GradientTape() as tape:# calculate log probabilities and entropy of the actionslogits = 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 ratioratio = tf.exp(new_log_probs - old_log_probs)clipped_ratio = tf.clip_by_value(ratio, 1-clip_ratio, 1+clip_ratio)# calculate actor lossactor_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 lossvalues = 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 torchimport torch.nn as nnimport torch.optim as optimimport gym# Hyperparameterslr = 0.00025gamma = 0.99epsilon_clip = 0.2batch_size = 64ppo_epochs = 10# Neural network for policyclass 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 xdef 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 transitionsclass 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 algorithmdef 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 = Falsetotal_reward = 0while 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 += rewardstate = next_state# Policy updatefor _ 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 estimationreturns = []discounted_reward = 0for reward in reversed(rewards):discounted_reward = reward + gamma * discounted_rewardreturns.insert(0, discounted_reward)returns = torch.tensor(returns)advantages = returns - returns.mean()advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-5)# Policy update using PPO lossadvantages = rewards - valuesfor _ 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 * entropygradients = 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 tableQ = np.zeros([state_space_size, action_space_size])# hyperparametersalpha = 0.1gamma = 0.99epsilon = 0.1# main loopfor episode in range(num_episodes):state = env.reset()done = False# pilih aksi pertama menggunakan epsilon-greedyif np.random.rand() < epsilon:action = env.action_space.sample()else:action = np.argmax(Q[state])while not done:# lakukan aksinext_state, reward, done, _ = env.step(action)# pilih aksi selanjutnya menggunakan epsilon-greedyif 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 npimport torchimport torch.nn as nnimport torch.optim as optimclass DQNAgent():def __init__(self, state_dim, action_dim, lr, gamma, epsilon_decay):self.state_dim = state_dimself.action_dim = action_dimself.lr = lrself.gamma = gammaself.epsilon_decay = epsilon_decayself.epsilon = 1.0self.memory = []self.batch_size = 32self.epsilon_min = 0.01self.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, criteriondef 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:returnbatch = 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)# DDQNq_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_decayself.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 :
# HyperparametersEPISODES = 1000BATCH_SIZE = 32LEARNING_RATE = 0.001DISCOUNT_FACTOR = 0.99REPLAY_MEMORY_SIZE = 10000UPDATE_TARGET_EVERY = 5# Initialize replay memoryreplay_memory = deque(maxlen=REPLAY_MEMORY_SIZE)# Initialize the DQN model and target networkdqn = 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 networktarget_dqn.model.set_weights(dqn.model.get_weights())# Training loopfor episode in range(EPISODES):# Initialize statestate = env.reset()# Initialize variables for the episodetotal_reward = 0done = Falsewhile not done:# Choose an action using the DQN modelaction = dqn.act(state)# Take the chosen action and observe the next state, reward, and done flagnext_state, reward, done, _ = env.step(action)# Add the experience to the replay memoryreplay_memory.append((state, action, reward, next_state, done))# Update the DQN model weights every UPDATE_TARGET_EVERY stepsif len(replay_memory) >= BATCH_SIZE and episode % UPDATE_TARGET_EVERY == 0:# Sample a minibatch from the replay memoryminibatch = random.sample(replay_memory, BATCH_SIZE)# Preprocess the minibatch datastates = 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 networktarget_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 minibatchdqn.train_on_batch(states, actions, target_q_values)# Update the target network weights with the DQN model weightstarget_dqn.model.set_weights(dqn.model.get_weights())# Update the state and total rewardstate = next_statetotal_reward += reward# Print the episode resultsprint("Episode:", episode + 1, "Total Reward:", total_reward)
8. Q-Learning
Di mana :
- Q(s,a) adalah nilai Q dari aksi a pada state s
- R(s,a) adalah reward yang didapat saat melakukan aksi a pada state s
- α adalah learning rate, yaitu konstanta yang menentukan seberapa besar pengaruh reward baru terhadap nilai Q
- γ adalah discount factor, yaitu konstanta yang menentukan seberapa besar pengaruh nilai Q pada state berikutnya terhadap nilai Q saat ini
- maxQ(s',a') adalah nilai Q tertinggi dari aksi yang dapat dilakukan pada state berikutnya s'
- s' adalah state berikutnya yang dihasilkan oleh aksi a.
Contoh Program :
import numpy as np# Inisialisasi lingkungannum_states = 6num_actions = 2reward_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-tableq_table = np.zeros((num_states, num_actions))# Hyperparameterlearning_rate = 0.8discount_factor = 0.95num_episodes = 1000# Pelatihanfor episode in range(num_episodes):# Inisialisasi state awalcurrent_state = np.random.randint(0, num_states)while current_state != 5: # Lakukan sampai mencapai state goal# Pilih aksi dengan explorasi atau exploitationif np.random.uniform() < 0.2:action = np.random.randint(0, num_actions)else:action = np.argmax(q_table[current_state, :])# Perbarui Q-tablenext_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-tableprint("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.