Saat ini algoritma Reinforcement Learning yang populer meliputi Q-learning, SARSA, DDPG, A2C, PPO, DQN dan TRPO. Algoritma ini telah digunakan dalam berbagai aplikasi seperti game, robotika dan pengambilan keputusan, dan algoritme populer ini masih terus dikembangkan dan ditingkatkan. Pada artikel ini, kami akan memberikan pengantar singkat tentangnya.
1. Q-learning
Q-learning adalah algoritme Reinforcement Learning non-kebijakan yang bebas model. Ini memperkirakan fungsi nilai aksi optimal menggunakan persamaan Bellman yang secara iteratif memperbarui nilai estimasi untuk pasangan aksi keadaan tertentu. Q-learning dikenal karena kesederhanaan dan kemampuannya untuk menangani ruang keadaan kontinu yang besar.
Berikut adalah contoh sederhana penerapan Q-learning dengan Python:
import numpy as np
# Define the Q-table and the learning rate
Q = np.zeros((state_space_size, action_space_size))
alpha = 0.1
# Define the exploration rate and discount factor
epsilon = 0.1
gamma = 0.99
for episode in range(num_episodes):
current_state = initial_state
while not done:
# Choose an action using an epsilon-greedy policy
if np.random.uniform(0, 1) < epsilon:
action = np.random.randint(0, action_space_size)
else:
action = np.argmax(Q[current_state])
# Take the action and observe the next state and reward
next_state, reward, done = take_action(current_state, action)
# Update the Q-table using the Bellman equation
Q[current_state, action] = Q[current_state, action] + alpha * (reward + gamma * np.max(Q[next_state]) - Q[current_state, action])
current_state = next_stateDalam contoh di atas, state_space_size dan action_space_size masing-masing adalah jumlah status dan tindakan di lingkungan. num_episodes adalah jumlah zaman untuk menjalankan algoritme. initial_state adalah status awal lingkungan. take_action(current_state, action) adalah fungsi yang mengambil status saat ini dan tindakan sebagai input, dan mengembalikan status berikutnya, hadiah, dan boolean yang menunjukkan apakah putaran selesai.
Pada kondisi while loop menggunakan strategi epsilon-greedy untuk memilih tindakan berdasarkan kondisi saat ini. Tindakan acak dipilih dengan probabilitas epsilon dan tindakan dengan nilai Q tertinggi untuk keadaan saat ini dipilih dengan probabilitas 1-epsilon.
Setelah mengambil tindakan, mengamati keadaan dan hadiah berikutnya, perbarui q menggunakan persamaan Bellman. dan perbarui status saat ini ke status berikutnya. Ini hanyalah contoh sederhana dari Q-learning dan tidak memperhitungkan secara spesifik inisialisasi Q-table dan masalah yang harus dipecahkan.
2. Algoritma Reinforcement Learning SARSA
SARSA adalah algoritma Reinforcement Learning berbasis kebijakan yang bebas model. Itu juga menggunakan persamaan Bellman untuk memperkirakan fungsi nilai tindakan, tetapi didasarkan pada nilai yang diharapkan dari tindakan selanjutnya, bukan tindakan optimal seperti di Q-learning. SARSA dikenal karena kemampuannya menangani masalah dengan dinamika stokastik.
import numpy as np
# Define the Q-table and the learning rate
Q = np.zeros((state_space_size, action_space_size))
alpha = 0.1
# Define the exploration rate and discount factor
epsilon = 0.1
gamma = 0.99
for episode in range(num_episodes):
current_state = initial_state
action = epsilon_greedy_policy(epsilon, Q, current_state)
while not done:
# Take the action and observe the next state and reward
next_state, reward, done = take_action(current_state, action)
# Choose next action using epsilon-greedy policy
next_action = epsilon_greedy_policy(epsilon, Q, next_state)
# Update the Q-table using the Bellman equation
Q[current_state, action] = Q[current_state, action] + alpha * (reward + gamma * Q[next_state, next_action] - Q[current_state, action])
current_state = next_state
action = next_actionstate_space_size dan action_space_size masing-masing adalah jumlah status dan tindakan di lingkungan. num_episodes adalah jumlah zaman yang Anda inginkan untuk menjalankan algoritme SARSA. Initial_state adalah keadaan awal lingkungan. take_action(current_state, action) adalah fungsi yang mengambil status saat ini dan sebagai masukan tindakan, dan mengembalikan status berikutnya, hadiah, dan boolean yang menunjukkan apakah episode sudah selesai.
Dalam while loop, menggunakan kebijakan epsilon-greedy yang didefinisikan dalam fungsi terpisah. Epsilon_greedy_policy(epsilon, Q, current_state) untuk memilih tindakan berdasarkan status saat ini. Pilih tindakan acak dengan probabilitas epsilon dan tindakan dengan nilai Q tertinggi untuk keadaan saat ini dengan probabilitas 1-epsilon.
Hal di atas sama dengan Q-learning, tetapi setelah mengambil tindakan, kemudian memilih tindakan selanjutnya menggunakan strategi serakah sambil mengamati keadaan dan hadiah selanjutnya. Dan perbarui tabel-q menggunakan persamaan Bellman.
Baca 3 Cara Menggunakan For Loop Python Dengan Mudah
3. DDPG
DDPG adalah algoritma bebas model, di luar kebijakan untuk ruang tindakan berkelanjutan. Ini adalah algoritma aktor-kritik di mana jaringan aktor digunakan untuk memilih tindakan dan jaringan kritik digunakan untuk mengevaluasi tindakan. DDPG sangat berguna untuk kontrol robot dan tugas kontrol berkelanjutan lainnya.
import numpy as np
from keras.models import Model, Sequential
from keras.layers import Dense, Input
from keras.optimizers import Adam
# Define the actor and critic models
actor = Sequential()
actor.add(Dense(32, input_dim=state_space_size, activation='relu'))
actor.add(Dense(32, activation='relu'))
actor.add(Dense(action_space_size, activation='tanh'))
actor.compile(loss='mse', optimizer=Adam(lr=0.001))
critic = Sequential()
critic.add(Dense(32, input_dim=state_space_size, activation='relu'))
critic.add(Dense(32, activation='relu'))
critic.add(Dense(1, activation='linear'))
critic.compile(loss='mse', optimizer=Adam(lr=0.001))
# Define the replay buffer
replay_buffer = []
# Define the exploration noise
exploration_noise = OrnsteinUhlenbeckProcess(size=action_space_size, theta=0.15, mu=0, sigma=0.2)
for episode in range(num_episodes):
current_state = initial_state
while not done:
# Select an action using the actor model and add exploration noise
action = actor.predict(current_state)[0] + exploration_noise.sample()
action = np.clip(action, -1, 1)
# Take the action and observe the next state and reward
next_state, reward, done = take_action(current_state, action)
# Add the experience to the replay buffer
replay_buffer.append((current_state, action, reward, next_state, done))
# Sample a batch of experiences from the replay buffer
batch = sample(replay_buffer, batch_size)
# Update the critic model
states = np.array([x[0] for x in batch])
actions = np.array([x[1] for x in batch])
rewards = np.array([x[2] for x in batch])
next_states = np.array([x[3] for x in batch])
target_q_values = rewards + gamma * critic.predict(next_states)
critic.train_on_batch(states, target_q_values)
# Update the actor model
action_gradients = np.array(critic.get_gradients(states, actions))
actor.train_on_batch(states, action_gradients)
current_state = next_stateDalam contoh ini, state_space_size dan action_space_size masing-masing adalah jumlah status dan tindakan di lingkungan. num_episodes adalah jumlah episode. Initial_state adalah keadaan awal lingkungan. Take_action(current_state, action) adalah fungsi yang mengambil status saat ini dan tindakan sebagai input, dan mengembalikan tindakan selanjutnya.
Baca 24 Keterampilan Menggunakan Python Yang Berguna
4. A2C
A2C (Advantage Actor-Critic) adalah Algoritma Reinforcement Learning aktor-kritik strategis yang menggunakan fungsi Advantage untuk memperbarui strategi. Algoritme ini sederhana untuk diterapkan dan dapat menangani ruang tindakan diskrit dan berkelanjutan.
import numpy as np
from keras.models import Model, Sequential
from keras.layers import Dense, Input
from keras.optimizers import Adam
from keras.utils import to_categorical
# Define the actor and critic models
state_input = Input(shape=(state_space_size,))
actor = Dense(32, activation='relu')(state_input)
actor = Dense(32, activation='relu')(actor)
actor = Dense(action_space_size, activation='softmax')(actor)
actor_model = Model(inputs=state_input, outputs=actor)
actor_model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001))
state_input = Input(shape=(state_space_size,))
critic = Dense(32, activation='relu')(state_input)
critic = Dense(32, activation='relu')(critic)
critic = Dense(1, activation='linear')(critic)
critic_model = Model(inputs=state_input, outputs=critic)
critic_model.compile(loss='mse', optimizer=Adam(lr=0.001))
for episode in range(num_episodes):
current_state = initial_state
done = False
while not done:
# Select an action using the actor model and add exploration noise
action_probs = actor_model.predict(np.array([current_state]))[0]
action = np.random.choice(range(action_space_size), p=action_probs)
# Take the action and observe the next state and reward
next_state, reward, done = take_action(current_state, action)
# Calculate the advantage
target_value = critic_model.predict(np.array([next_state]))[0][0]
advantage = reward + gamma * target_value - critic_model.predict(np.array([current_state]))[0][0]
# Update the actor model
action_one_hot = to_categorical(action, action_space_size)
actor_model.train_on_batch(np.array([current_state]), advantage * action_one_hot)
# Update the critic model
critic_model.train_on_batch(np.array([current_state]), reward + gamma * target_value)
current_state = next_stateDalam contoh ini, model aktor adalah jaringan saraf dengan 2 lapisan tersembunyi masing-masing 32 neuron, dengan fungsi aktivasi relu dan fungsi aktivasi softmax di lapisan output. Model kritik juga merupakan jaringan saraf dengan 2 lapisan tersembunyi masing-masing 32 neuron, dengan fungsi aktivasi relu, dan fungsi aktivasi linier di lapisan output.
Model aktor dilatih menggunakan fungsi kerugian lintas-entropi kategorikal, dan model kritik dilatih menggunakan fungsi kerugian mean square error. Tindakan dipilih berdasarkan prediksi model aktor, dengan tambahan noise untuk eksplorasi.
Baca juga Cara Belajar Pemrograman Untuk Pemula Secara Otodidak
5. Algoritma Reinforcement Learning PPO
PPO (Proximal Policy Optimization) adalah algoritma kebijakan yang menggunakan metode optimalisasi domain kepercayaan untuk memperbarui kebijakan. Ini sangat berguna di lingkungan dengan observasi dimensi tinggi dan ruang aksi berkelanjutan. PPO dikenal dengan stabilitas dan efisiensi sampel yang tinggi.
import numpy as np
from keras.models import Model, Sequential
from keras.layers import Dense, Input
from keras.optimizers import Adam
# Define the policy model
state_input = Input(shape=(state_space_size,))
policy = Dense(32, activation='relu')(state_input)
policy = Dense(32, activation='relu')(policy)
policy = Dense(action_space_size, activation='softmax')(policy)
policy_model = Model(inputs=state_input, outputs=policy)
# Define the value model
value_model = Model(inputs=state_input, outputs=Dense(1, activation='linear')(policy))
# Define the optimizer
optimizer = Adam(lr=0.001)
for episode in range(num_episodes):
current_state = initial_state
while not done:
# Select an action using the policy model
action_probs = policy_model.predict(np.array([current_state]))[0]
action = np.random.choice(range(action_space_size), p=action_probs)
# Take the action and observe the next state and reward
next_state, reward, done = take_action(current_state, action)
# Calculate the advantage
target_value = value_model.predict(np.array([next_state]))[0][0]
advantage = reward + gamma * target_value - value_model.predict(np.array([current_state]))[0][0]
# Calculate the old and new policy probabilities
old_policy_prob = action_probs[action]
new_policy_prob = policy_model.predict(np.array([next_state]))[0][action]
# Calculate the ratio and the surrogate loss
ratio = new_policy_prob / old_policy_prob
surrogate_loss = np.minimum(ratio * advantage, np.clip(ratio, 1 - epsilon, 1 + epsilon) * advantage)
# Update the policy and value models
policy_model.trainable_weights = value_model.trainable_weights
policy_model.compile(optimizer=optimizer, loss=-surrogate_loss)
policy_model.train_on_batch(np.array([current_state]), np.array([action_one_hot]))
value_model.train_on_batch(np.array([current_state]), reward + gamma * target_value)
current_state = next_state6. DQN
Deep Q-Network atau DQN adalah Algoritma Reinforcement Learning di luar kebijakan bebas model yang menggunakan jaringan saraf untuk memperkirakan fungsi Q. DQN sangat cocok untuk game Atari dan masalah serupa lainnya di mana ruang keadaan berdimensi tinggi dan fungsi Q didekati menggunakan jaringan saraf.
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Input
from keras.optimizers import Adam
from collections import deque
# Define the Q-network model
model = Sequential()
model.add(Dense(32, input_dim=state_space_size, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(action_space_size, activation='linear'))
model.compile(loss='mse', optimizer=Adam(lr=0.001))
# Define the replay buffer
replay_buffer = deque(maxlen=replay_buffer_size)
for episode in range(num_episodes):
current_state = initial_state
while not done:
# Select an action using an epsilon-greedy policy
if np.random.rand() < epsilon:
action = np.random.randint(0, action_space_size)
else:
action = np.argmax(model.predict(np.array([current_state]))[0])
# Take the action and observe the next state and reward
next_state, reward, done = take_action(current_state, action)
# Add the experience to the replay buffer
replay_buffer.append((current_state, action, reward, next_state, done))
# Sample a batch of experiences from the replay buffer
batch = random.sample(replay_buffer, batch_size)
# Prepare the inputs and targets for the Q-network
inputs = np.array([x[0] for x in batch])
targets = model.predict(inputs)
for i, (state, action, reward, next_state, done) in enumerate(batch):
if done:
targets[i, action] = reward
else:
targets[i, action] = reward + gamma * np.max(model.predict(np.array([next_state]))[0])
# Update the Q-network
model.train_on_batch(inputs, targets)
current_state = next_statePada kode di atas, Q-network memiliki 2 lapisan tersembunyi, setiap lapisan tersembunyi memiliki 32 neuron, dan menggunakan fungsi aktivasi relu. Jaringan dilatih menggunakan fungsi mean squared error loss dan pengoptimal Adam.
7. Algoritma Reinforcement Learning TRPO
TRPO (Trust Region Policy Optimization) adalah algoritme kebijakan bebas model yang menggunakan metode optimalisasi wilayah kepercayaan untuk memperbarui kebijakan. Ini sangat berguna di lingkungan dengan observasi dimensi tinggi dan ruang aksi berkelanjutan.
TRPO adalah algoritma kompleks yang membutuhkan banyak langkah dan komponen untuk diterapkan. TRPO bukanlah algoritma sederhana yang dapat diimplementasikan dengan beberapa baris kode.
Jadi di sini kami menggunakan perpustakaan yang sudah ada yang mengimplementasikan TRPO, seperti OpenAI Baselines, yang menyediakan berbagai algoritme Reinforcement Learning yang telah diimplementasikan sebelumnya, termasuk TRPO.
Untuk menggunakan TRPO di OpenAI Baselines, kita perlu menginstal:
pip install baselinesAgen TRPO kemudian dapat dilatih di lingkungan Anda menggunakan modul trpo_mpi dari pustaka baseline, berikut adalah contoh sederhananya:
import gym
from baselines.common.vec_env.dummy_vec_env import DummyVecEnv
from baselines.trpo_mpi import trpo_mpi
#Initialize the environment
env = gym.make("CartPole-v1")
env = DummyVecEnv([lambda: env])
# Define the policy network
policy_fn = mlp_policy
#Train the TRPO model
model = trpo_mpi.learn(env, policy_fn, max_iters=1000)Kami menginisialisasi lingkungan menggunakan perpustakaan Gym. Kemudian tentukan jaringan kebijakan, dan panggil fungsi learn() dalam modul TRPO untuk melatih model.
Ada banyak library lain yang juga menyediakan implementasi TRPO, seperti TensorFlow, PyTorch, dan RLLib. Berikut adalah contoh implementasi menggunakan TF 2.0
import tensorflow as tf
import gym
# Define the policy network
class PolicyNetwork(tf.keras.Model):
def __init__(self):
super(PolicyNetwork, self).__init__()
self.dense1 = tf.keras.layers.Dense(16, activation='relu')
self.dense2 = tf.keras.layers.Dense(16, activation='relu')
self.dense3 = tf.keras.layers.Dense(1, activation='sigmoid')
def call(self, inputs):
x = self.dense1(inputs)
x = self.dense2(x)
x = self.dense3(x)
return x
# Initialize the environment
env = gym.make("CartPole-v1")
# Initialize the policy network
policy_network = PolicyNetwork()
# Define the optimizer
optimizer = tf.optimizers.Adam()
# Define the loss function
loss_fn = tf.losses.BinaryCrossentropy()
# Set the maximum number of iterations
max_iters = 1000
# Start the training loop
for i in range(max_iters):
# Sample an action from the policy network
action = tf.squeeze(tf.random.categorical(policy_network(observation), 1))
# Take a step in the environment
observation, reward, done, _ = env.step(action)
with tf.GradientTape() as tape:
# Compute the loss
loss = loss_fn(reward, policy_network(observation))
# Compute the gradients
grads = tape.gradient(loss, policy_network.trainable_variables)
# Perform the update step
optimizer.apply_gradients(zip(grads, policy_network.trainable_variables))
if done:
# Reset the environment
observation = env.reset()Dalam contoh ini, pertama-tama kita mendefinisikan jaringan kebijakan menggunakan API TensorFlow. Lingkungan kemudian diinisialisasi menggunakan perpustakaan Gym dan jaringan kebijakan. Kemudian tentukan fungsi pengoptimal dan kerugian yang digunakan untuk melatih jaringan kebijakan. Baca juga Bahasa Pemrograman Komputer
Dalam loop pelatihan, tindakan diambil sampel dari jaringan kebijakan, langkah diambil di lingkungan, dan kerugian serta gradien dihitung menggunakan GradientTape TensorFlow. Kami kemudian melakukan langkah pembaruan menggunakan pengoptimal.
Ini adalah contoh sederhana yang hanya menunjukkan cara mengimplementasikan TRPO di TensorFlow 2.0. TRPO adalah algoritme yang sangat kompleks dan contoh ini tidak mencakup semua detail, tetapi merupakan titik awal yang baik untuk bereksperimen dengan TRPO.
Kesimpulan
Di atas adalah ringkasan kami dari 7 algoritma Reinforcement Learning yang umum digunakan. Algoritma ini tidak eksklusif satu sama lain dan biasanya digunakan dalam kombinasi dengan teknik lain. Seperti perkiraan fungsi nilai, metode berbasis model dan metode ansambel untuk mencapai hasil yang lebih baik.
