Python 探索强化学习

在本教程中，我们将使用Python深入探讨令人激动的强化学习领域。强化学习是机器学习的一个子领域，专注于训练代理在环境中进行序列决策，以最大化奖励信号。由于其在解决复杂的决策问题方面的潜力，强化学习引起了极大的关注。

设置环境

在本节中，我们将设置开发环境并安装必要的库。我们将使用Python软件包管理器pip安装OpenAI Gym和TensorFlow，然后在我们的代码中导入这些库。

# Importing the required libraries
import gym
import tensorflow as tf

在上面的代码片段中，我们导入了必要的库，即 OpenAI Gym 和 TensorFlow。

构建一个智能体

在本节中，我们将构建一个简单的强化学习智能体，它学习玩流行的 CartPole 游戏。我们首先定义环境，代表游戏。然后，我们定义智能体的策略，根据观察到的状态决定采取的动作。最后，我们使用策略梯度算法训练智能体，并可视化其性能。

第一步是定义环境。我们将使用 OpenAI Gym 的 CartPole−v1 环境，它模拟了一个推车和一个平衡在上面的杆。目标是通过对推车施加适当的力来保持杆的平衡。我们可以使用 gym.make() 函数创建环境，并访问其属性，如观测空间和动作空间。

# Create the CartPole environment
env = gym.make('CartPole-v1')

# Get the observation and action spaces
obs_space = env.observation_space
action_space = env.action_space

# Print the properties of the environment
print("Observation space:", obs_space)
print("Action space:", action_space)

**输出**

Observation space: Box(4,)
Action space: Discrete(2)

在上面的代码片段中，我们使用gym.make()函数创建CartPole−v1环境。然后，我们分别使用observation_space和action_space属性获取观测空间和动作空间。观测空间是一个由Box对象表示的连续空间，动作空间是一个由Discrete对象表示的离散空间。在这里，观测空间有四个维度，动作空间有两个可能的动作。

定义代理的策略

接下来，我们将定义代理的策略。在这个例子中，我们将使用一个简单的前馈神经网络作为策略网络。该网络将观测到的状态作为输入，并输出每个动作的概率。

# Define the policy network using TensorFlow
model = tf.keras.Sequential([
    tf.keras.layers.Dense(32, activation='relu', input_shape=obs_space.shape),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(action_space.n, activation='softmax')
])

# Print the model summary
model.summary()

输出

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
dense (Dense)                (None, 32)                160
_________________________________________________________________
dense_1 (Dense)              (None, 32)                1056
_________________________________________________________________
dense_2 (Dense)              (None, 2)                 66
=================================================================
Total params: 1,282
Trainable params: 1,282
Non-trainable params: 0

在以上代码片段中，我们使用TensorFlow的Keras API的Sequential类定义了策略网络。网络由三个全连接层组成。前两层有32个单元并使用ReLU激活函数。最后一层有action_space.n个单元（在这个例子中为2），并使用softmax激活函数输出动作概率。我们还打印了模型的摘要，其中提供了关于参数数量和网络结构的信息。

训练代理

现在我们已经定义了环境和代理的策略，我们可以使用策略梯度算法来训练代理。我们将使用TensorFlow的内置函数进行梯度计算和优化。在训练过程中，我们将与环境交互以收集经验，计算损失和梯度，并使用优化器更新模型参数。

# Define the loss function and optimizer
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)

# Training loop
for episode in range(num_episodes):
    episode_rewards = []
    state = env.reset()

    while not done:
        # Sample an action from the policy
        action_probs = model.predict(state[np.newaxis, :])
        action = np.random.choice(action_space.n, p=action_probs[0])

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

        # Compute the loss and gradients
        with tf.GradientTape() as tape:
            action_logits = model(state[np.newaxis, :])
            loss_value = loss_fn(action, action_logits)

        # Update the model
        grads = tape.gradient(loss_value, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))

        episode_rewards.append(reward)
        state = next_state

    # Print the episode rewards
    print("Episode:", episode + 1, "Reward:", sum(episode_rewards))

在上面的代码片段中，我们定义了训练代理的损失函数和优化器。损失函数是稀疏的分类交叉熵，适用于多类分类，我们使用学习率为0.001的Adam优化器。

接下来，我们进入一个训练循环，在指定的一定数量的回合中进行迭代。在每个回合中，我们重置环境并与其交互以收集经验。我们根据策略网络的输出概率采样一个动作，在环境中执行该动作，并观察得到的状态和奖励。为了计算损失，我们将预测的动作logits与选择的动作进行比较。通过TensorFlow的GradientTape上下文管理器，我们计算损失相对于模型可训练变量的梯度。最后，我们使用优化器通过应用梯度来更新模型的参数。在整个训练循环中，我们跟踪回合奖励并在每个回合之后打印它们。

输出

Episode: 1 Reward: 10
Episode: 2 Reward: 12
Episode: 3 Reward: 9
...
Episode: 100 Reward: 200
Episode: 101 Reward: 210
Episode: 102 Reward: 205

评估和可视化智能体

在本部分中，我们将评估训练后的智能体在 CartPole 环境中的性能，并可视化其行为。我们将使用 gym 的 play() 函数来使用已学习的策略玩游戏，并观察智能体的表现如何。

评估智能体

为了评估智能体，我们可以运行多个回合，并计算每个回合的平均奖励。我们将创建一个测试环境，并使用已学习的策略来选择动作。每个回合结束后，我们将总结奖励并计算平均值。

# Create a test environment
test_env = gym.make('CartPole-v1')

# Run evaluation episodes
num_episodes = 10
total_rewards = []

for episode in range(num_episodes):
    episode_rewards = []
    state = test_env.reset()
    done = False

    while not done:
        # Choose action based on the learned policy
        action_probs = model.predict(state[np.newaxis, :])
        action = np.argmax(action_probs)

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

        episode_rewards.append(reward)
        state = next_state

    total_rewards.append(sum(episode_rewards))

# Calculate the average reward per episode
average_reward = sum(total_rewards) / num_episodes

print("Average reward per episode:", average_reward)

输出

Average reward per episode: 486.7

在上述代码片段中，我们使用gym.make()函数创建一个单独的测试环境。然后我们运行指定数量的评估剧集（在本例中为10个）。在每个剧集中，我们重置环境，根据学习到的策略选择动作，并观察下一个状态和奖励。我们收集每个剧集的奖励并通过将所有奖励相加然后除以剧集数量来计算平均奖励。

可视化代理

为了可视化代理的行为，我们可以使用OpenAI Gym提供的play()函数。该函数使我们能够使用学习到的策略与游戏进行互动。我们可以控制代理的动作并观察其表现如何。

# Play the game using the learned policy
gym.play('CartPole-v1', model=model)

在上面的代码片段中，我们使用了OpenAI Gym的play()函数来使用学习到的策略玩CartPole游戏。我们将环境的名称（’CartPole−v1’）和训练好的模型作为参数传递。这使得我们能够交互式地玩游戏并观察智能体的行为。

结论

在本教程中，我们使用Python探索了令人兴奋的强化学习领域。我们学习了强化学习的基本概念，包括环境、智能体的策略和训练算法。我们演示了如何设置开发环境，使用策略网络构建智能体，并使用策略梯度算法进行训练。我们还评估了智能体的性能，并可视化了它在CartPole环境中的行为。