Sieben beliebte Reinforcement-Learning-Algorithmen und Code-Implementierungen

Zu den derzeit beliebten Reinforcement-Learning-Algorithmen gehören Q-Learning, SARSA, DDPG, A2C, PPO, DQN und TRPO. Diese Algorithmen wurden in verschiedenen Anwendungen wie Spielen, Robotik und Entscheidungsfindung eingesetzt und werden ständig weiterentwickelt und verbessert. In diesem Artikel geben wir eine kurze Einführung in sie.

1. Q-Learning

Q-Learning: Q-Learning ist ein modellfreier, nicht strategiebasierter Lernalgorithmus. Es schätzt die optimale Aktionswertfunktion mithilfe der Bellman-Gleichung, die den geschätzten Wert für ein bestimmtes Zustands-Aktionspaar iterativ aktualisiert. Q-Learning ist bekannt für seine Einfachheit und die Fähigkeit, große kontinuierliche Zustandsräume zu verarbeiten.

Das Folgende ist ein einfaches Beispiel für die Verwendung von Python zur Implementierung von Q-Learning:

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_state

Im obigen Beispiel sind state_space_size und action_space_size die Anzahl der Zustände bzw. Aktionen in der Umgebung. num_episodes ist die Anzahl der Runden, für die der Algorithmus ausgeführt werden soll. initial_state ist der Startzustand der Umgebung. take_action(current_state, action) ist eine Funktion, die als Eingabe den aktuellen Status und eine Aktion verwendet und den nächsten Status, die Belohnung und einen booleschen Wert zurückgibt, der angibt, ob die Runde abgeschlossen ist.

Verwenden Sie in der While-Schleife die Epsilon-Greedy-Strategie, um eine Aktion basierend auf dem aktuellen Status auszuwählen. Verwenden Sie das Wahrscheinlichkeits-Epsilon, um eine zufällige Aktion auszuwählen, und verwenden Sie das Wahrscheinlichkeits-1-Epsilon, um die Aktion mit dem höchsten Q-Wert für den aktuellen Zustand auszuwählen.

Nachdem Sie Maßnahmen ergriffen haben, beobachten Sie den nächsten Zustand und die nächste Belohnung und aktualisieren Sie q mithilfe der Bellman-Gleichung. und aktualisiert den aktuellen Status auf den nächsten Status. Dies ist nur ein einfaches Beispiel für Q-Learning und berücksichtigt nicht die Initialisierung der Q-Tabelle und die spezifischen Details des zu lösenden Problems.

2. SARSA

SARSA: SARSA ist ein modellfreier, richtlinienbasierter Verstärkungslernalgorithmus. Es verwendet auch die Bellman-Gleichung, um die Aktionswertfunktion zu schätzen, basiert jedoch auf dem erwarteten Wert der nächsten Aktion und nicht auf der optimalen Aktion wie beim Q-Learning. SARSA ist bekannt für seine Fähigkeit, stochastische Dynamikprobleme zu lösen.

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_action

state_space_size und action_space_size sind die Anzahl der Zustände bzw. Operationen in der Umgebung. num_episodes ist die Anzahl der Runden, in denen Sie den SARSA-Algorithmus ausführen möchten. Initial_state ist der Anfangszustand der Umgebung. take_action(current_state, action) ist eine Funktion, die den aktuellen Status und die Aktion als Eingabe verwendet und den nächsten Status, die Belohnung und einen booleschen Wert zurückgibt, der angibt, ob die Handlung abgeschlossen ist.

Verwenden Sie in der while-Schleife die Epsilon-Greedy-Richtlinie, die in einer separaten Funktion epsilon_greedy_policy(epsilon, Q, current_state) definiert ist, um eine Aktion basierend auf dem aktuellen Status auszuwählen. Wählen Sie eine zufällige Aktion mit Wahrscheinlichkeits-Epsilon und die Aktion mit dem höchsten Q-Wert für den aktuellen Zustand mit Wahrscheinlichkeits-1-Epsilon aus.

Das Obige ist dasselbe wie Q-Learning, aber nachdem eine Aktion ausgeführt wurde, wird eine gierige Strategie verwendet, um die nächste Aktion auszuwählen und dabei den nächsten Zustand und die nächste Belohnung zu beobachten. und aktualisieren Sie die q-Tabelle mithilfe der Bellman-Gleichung.

3. DDPG

DDPG ist ein modellfreier, nicht richtlinienkonformer Algorithmus für kontinuierliche Aktionsräume. Es handelt sich um einen Akteur-Kritiker-Algorithmus, bei dem ein Akteursnetzwerk zur Auswahl von Aktionen und ein Kritikernetzwerk zur Bewertung von Aktionen verwendet wird. DDPG ist besonders nützlich für die Robotersteuerung und andere kontinuierliche Steuerungsaufgaben.

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_state

In diesem Beispiel sind state_space_size und action_space_size die Anzahl der Zustände bzw. Aktionen in der Umgebung. num_episodes ist die Anzahl der Runden. Initial_state ist der Anfangszustand der Umgebung. Take_action (current_state, action) ist eine Funktion, die den aktuellen Status und die aktuelle Aktion als Eingabe akzeptiert und die nächste Aktion zurückgibt.

4. A2C

A2C (Advantage Actor-Critic) ist ein strategischer Akteur-Kritiker-Algorithmus, der die Advantage-Funktion verwendet, um die Strategie zu aktualisieren. Der Algorithmus ist einfach zu implementieren und kann sowohl diskrete als auch kontinuierliche Aktionsräume verarbeiten.

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_state

In diesem Beispiel ist das Akteurmodell ein neuronales Netzwerk mit 2 versteckten Schichten von jeweils 32 Neuronen mit einer Relu-Aktivierungsfunktion und einer Ausgabeschicht mit einer Softmax-Aktivierungsfunktion. Das kritische Modell ist ebenfalls ein neuronales Netzwerk mit zwei verborgenen Schichten, 32 Neuronen in jeder Schicht, einer Relu-Aktivierungsfunktion und einer Ausgabeschicht mit einer linearen Aktivierungsfunktion.

Verwenden Sie die kategoriale Kreuzentropieverlustfunktion, um das Akteurmodell zu trainieren, und verwenden Sie die mittlere quadratische Fehlerverlustfunktion, um das Kritikermodell zu trainieren. Aktionen werden basierend auf den Vorhersagen des Akteurmodells ausgewählt, wobei zur Erkundung Rauschen hinzugefügt wird.

5. PPO

PPO (Proximal Policy Optimization) ist ein Richtlinienalgorithmus, der die Vertrauensdomänenoptimierungsmethode verwendet, um die Richtlinie zu aktualisieren. Es ist besonders nützlich in Umgebungen mit hochdimensionaler Beobachtung und kontinuierlichen Aktionsräumen. PPO ist für seine Stabilität und hohe Probeneffizienz bekannt.

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_state

6, DQN

DQN (Deep Q Network) ist ein modellfreier, nicht richtlinienkonformer Algorithmus, der neuronale Netze verwendet, um die Q-Funktion anzunähern. DQN ist besonders nützlich für Atari-Spiele und andere ähnliche Probleme, bei denen der Zustandsraum hochdimensional ist und neuronale Netze zur Approximation der Q-Funktion verwendet werden.

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_state

上面的代码，Q-network有2个隐藏层，每个隐藏层有32个神经元，使用relu激活函数。该网络使用均方误差损失函数和Adam优化器进行训练。

7、TRPO

TRPO （Trust Region Policy Optimization）是一种无模型的策略算法，它使用信任域优化方法来更新策略。 它在具有高维观察和连续动作空间的环境中特别有用。

TRPO 是一个复杂的算法，需要多个步骤和组件来实现。TRPO不是用几行代码就能实现的简单算法。

所以我们这里使用实现了TRPO的现有库，例如OpenAI Baselines，它提供了包括TRPO在内的各种预先实现的强化学习算法，。

要在OpenAI Baselines中使用TRPO，我们需要安装:

pip install baselines

然后可以使用baselines库中的trpo_mpi模块在你的环境中训练TRPO代理，这里有一个简单的例子:

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)

我们使用Gym库初始化环境。然后定义策略网络，并调用TRPO模块中的learn()函数来训练模型。

还有许多其他库也提供了TRPO的实现，例如TensorFlow、PyTorch和RLLib。下面时一个使用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()

在这个例子中，我们首先使用TensorFlow的Keras API定义一个策略网络。然后使用Gym库和策略网络初始化环境。然后定义用于训练策略网络的优化器和损失函数。

在训练循环中，从策略网络中采样一个动作，在环境中前进一步，然后使用TensorFlow的GradientTape计算损失和梯度。然后我们使用优化器执行更新步骤。

这是一个简单的例子，只展示了如何在TensorFlow 2.0中实现TRPO。TRPO是一个非常复杂的算法，这个例子没有涵盖所有的细节，但它是试验TRPO的一个很好的起点。

总结

以上就是我们总结的7个常用的强化学习算法，这些算法并不相互排斥，通常与其他技术(如值函数逼近、基于模型的方法和集成方法)结合使用，可以获得更好的结果。

Das obige ist der detaillierte Inhalt vonSieben beliebte Reinforcement-Learning-Algorithmen und Code-Implementierungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!