7가지 인기 있는 강화 학습 알고리즘 및 코드 구현-일체 포함-php.cn

현재 널리 사용되는 강화 학습 알고리즘에는 Q-learning, SARSA, DDPG, A2C, PPO, DQN 및 TRPO가 있습니다. 이러한 알고리즘은 게임, 로봇 공학, 의사 결정 등 다양한 응용 분야에서 사용되어 왔으며 이러한 인기 있는 알고리즘은 지속적으로 개발 및 개선되고 있습니다. 이 기사에서는 이에 대해 간략하게 소개하겠습니다.

7가지 인기 있는 강화 학습 알고리즘 및 코드 구현

1. Q-learning

Q-learning: Q-learning은 모델이 없고 전략이 없는 강화 학습 알고리즘입니다. 주어진 상태-행동 쌍에 대한 추정값을 반복적으로 업데이트하는 Bellman 방정식을 사용하여 최적의 행동 가치 함수를 추정합니다. Q-러닝은 대규모 연속 상태 공간을 처리하는 단순성과 능력으로 잘 알려져 있습니다.

다음은 Python을 사용하여 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

로그인 후 복사

위 예에서 state_space_size와 action_space_size는 각각 환경의 상태 수와 작업 수입니다. num_episodes는 알고리즘을 실행할 라운드 수입니다. initial_state는 환경의 시작 상태입니다. take_action(current_state, action)은 현재 상태와 동작을 입력으로 받아 다음 상태, 보상, 라운드 완료 여부를 나타내는 부울 값을 반환하는 함수입니다.

while 루프에서 엡실론 탐욕 전략을 사용하여 현재 상태에 따라 작업을 선택합니다. 무작위 행동을 선택하려면 확률 엡실론을 사용하고, 현재 상태에 대해 Q 값이 가장 높은 행동을 선택하려면 확률 1-엡실론을 사용합니다.

행동을 취한 후 다음 상태를 관찰하고 보상하고 벨만 방정식을 이용하여 q를 업데이트합니다. 현재 상태를 다음 상태로 업데이트합니다. 이는 Q-학습의 단순한 예일 뿐이며 Q-테이블의 초기화 및 해결해야 할 문제의 구체적인 세부 사항을 고려하지 않습니다.

2. SARSA

SARSA: SARSA는 모델이 없는 정책 기반 강화 학습 알고리즘입니다. 벨만 방정식을 이용해 액션값함수를 추정하는데, Q-러닝처럼 최적의 액션이 아닌 다음 액션의 기대값을 기반으로 한다. SARSA는 확률론적 역학 문제를 처리하는 능력으로 유명합니다.

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 및 action_space_size는 각각 환경의 상태 및 작업 수입니다. num_episodes는 SARSA 알고리즘을 실행하려는 라운드 수입니다. Initial_state는 환경의 초기 상태입니다. take_action(current_state, action)은 현재 상태와 액션을 입력으로 받아 다음 상태, 보상, 플롯 완료 여부를 나타내는 부울 값을 반환하는 함수입니다.

while 루프에서는 별도의 함수 epsilon_greedy_policy(epsilon, Q, current_state)에 정의된 epsilon-greedy 정책을 사용하여 현재 상태에 따라 작업을 선택합니다. 확률 엡실론을 사용하여 무작위 동작을 선택하고 확률 1-엡실론을 사용하여 현재 상태에 대해 가장 높은 Q 값을 갖는 동작을 선택합니다.

위 내용은 Q-learning과 동일하지만, 행동을 취한 후 다음 상태와 보상을 관찰하면서 다음 행동을 선택하는 그리디(Greedy) 전략을 사용합니다. Bellman 방정식을 사용하여 q-table을 업데이트합니다.

3. DDPG

DDPG는 연속적인 행동 공간을 위한 모델이 없는 비정책 알고리즘입니다. 행위자 네트워크를 사용하여 행위를 선택하고 비평가 네트워크를 사용하여 행위를 평가하는 행위자-비평 알고리즘입니다. DDPG는 로봇 제어 및 기타 연속 제어 작업에 특히 유용합니다.

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

로그인 후 복사

이 예에서 state_space_size 및 action_space_size는 각각 환경의 상태 및 작업 수입니다. num_episodes는 라운드 수입니다. Initial_state는 환경의 초기 상태입니다. Take_action(current_state, action)은 현재 상태와 액션을 입력으로 받아들이고 다음 액션을 반환하는 함수이다.

4. A2C

A2C(Advantage Actor-Critic)는 Advantage 기능을 사용하여 전략을 업데이트하는 전략적 배우-비평 알고리즘입니다. 이 알고리즘은 구현이 간단하며 이산 및 연속 동작 공간을 모두 처리할 수 있습니다.

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

로그인 후 복사

이 예에서 액터 모델은 각각 relu 활성화 함수가 있는 32개의 뉴런으로 구성된 2개의 숨겨진 레이어와 소프트맥스 활성화 함수가 있는 출력 레이어가 있는 신경망입니다. 비판 모델은 또한 2개의 숨겨진 레이어, 각 레이어에 32개의 뉴런, relu 활성화 함수 및 선형 활성화 함수가 있는 출력 레이어가 있는 신경망입니다.

범주형 교차 엔트로피 손실 함수를 사용하여 행위자 모델을 훈련하고, 평균 제곱 오차 손실 함수를 사용하여 비판 모델을 훈련합니다. 액션은 행위자 모델 예측을 기반으로 선택되며 탐색을 위해 노이즈가 추가됩니다.

5. PPO

PPO(Proximal Policy Optimization)는 신뢰 도메인 최적화 방법을 사용하여 정책을 업데이트하는 정책 알고리즘입니다. 특히 고차원 관찰과 연속적인 행동 공간이 있는 환경에서 유용합니다. PPO는 안정성과 높은 시료 효율성으로 잘 알려져 있습니다.

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)은 신경망을 사용하여 Q 함수를 근사화하는 모델이 없고 정책이 없는 알고리즘입니다. DQN은 상태 공간이 고차원이고 신경망을 사용하여 Q 함수를 근사화하는 Atari 게임 및 기타 유사한 문제에 특히 유용합니다.

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的一个很好的起点。