26 使用 TensorFlow 进行智能体训练

强化学习是机器学习的一个重要分支，通过与环境交互来学习最优策略。在本节中，我们将使用 TensorFlow 建立一个简单的强化学习项目，以训练智能体在迷宫中找到出口。

小节 1: 环境创建

我们首先需要定义一个环境。在这个示例中，我们将创建一个简单的网格迷宫环境。

import numpy as np

class MazeEnv:
    def __init__(self):
        self.maze = np.array([[0, 0, 0, 0, 0],
                              [0, 1, 1, 1, 0],
                              [0, 0, 0, 1, 0],
                              [1, 1, 0, 0, 0],
                              [0, 0, 0, 1, 0],
                              [0, 1, 0, 0, 0]])
        self.start_position = (0, 0)
        self.goal_position = (5, 4)
        self.current_position = self.start_position

    def reset(self):
        self.current_position = self.start_position
        return self.current_position

    def step(self, action):
        if action == 0:  # 上
            next_position = (self.current_position[0] - 1, self.current_position[1])
        elif action == 1:  # 下
            next_position = (self.current_position[0] + 1, self.current_position[1])
        elif action == 2:  # 左
            next_position = (self.current_position[0], self.current_position[1] - 1)
        elif action == 3:  # 右
            next_position = (self.current_position[0], self.current_position[1] + 1)

        if self.is_valid_move(next_position):
            self.current_position = next_position

        reward = 1 if self.current_position == self.goal_position else -0.1
        done = self.current_position == self.goal_position
        return self.current_position, reward, done

    def is_valid_move(self, position):
        return (0 <= position[0] < self.maze.shape[0] and
                0 <= position[1] < self.maze.shape[1] and
                self.maze[position[0], position[1]] == 0)

    def render(self):
        maze_copy = self.maze.copy()
        maze_copy[self.current_position] = 0.5  # 表示智能体位置
        maze_copy[self.goal_position] = 2  # 表示目标位置
        print(maze_copy)

小结

这里的代码定义了一个简单的迷宫环境，智能体可以在这个环境中移动并尝试找到目标。

小节 2: 构建 Q 网络

我们将使用 TensorFlow 创建一个 Q 网络，以进行强化学习。这个网络将接受当前状态作为输入，并输出每个动作的 Q 值。

import tensorflow as tf

class QNetwork(tf.keras.Model):
    def __init__(self, action_size):
        super(QNetwork, self).__init__()
        self.dense1 = tf.keras.layers.Dense(24, activation='relu')
        self.dense2 = tf.keras.layers.Dense(24, activation='relu')
        self.output_layer = tf.keras.layers.Dense(action_size)  # 输出每个动作的 Q 值

    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dense2(x)
        return self.output_layer(x)

小结

这个简单的 Q 网络由两个隐藏层和一个输出层组成，输出每个可能动作的 Q 值。

小节 3: DQN 训练算法

在这里，我们实现 DQN 的核心训练算法，使用 epsilon-greedy 策略来选择动作。

import random

class DQNAgent:
    def __init__(self, action_size):
        self.action_size = action_size
        self.memory = []
        self.gamma = 0.95  # 折扣因子
        self.epsilon = 1.0  # 探索的概率
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.model = QNetwork(action_size)

    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.action_size)  # 随机选择动作
        q_values = self.model.predict(state)  # 预测动作的 Q 值
        return np.argmax(q_values[0])  # 选择 Q 值最大的动作

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def replay(self, batch_size):
        if len(self.memory) < batch_size:
            return
        batch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in batch:
            target = reward
            if not done:
                target += self.gamma * np.amax(self.model.predict(next_state)[0])

            target_f = self.model.predict(state)
            target_f[0][action] = target  # 更新 Q 值

            self.model.fit(state, target_f, epochs=1, verbose=0)

        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay  # 减少探索概率

小结

DQNAgent 类定义了一个具有可转化记忆和回放能力的智能体。其使用 replay 方法训练 Q 网络，并使用 act 方法根据当前状态选择下一个动作。

小节 4: 训练智能体

我们现在可以将环境和智能体结合起来，训练智能体在迷宫中找到出口。

if __name__ == "__main__":
    env = MazeEnv()
    agent = DQNAgent(action_size=4)
    episodes = 1000
    batch_size = 32

    for e in range(episodes):
        state = env.reset()
        state = np.reshape(state, [1, 2])  # 调整输入形状

        for time in range(500):
            action = agent.act(state)
            next_state, reward, done = env.step(action)
            next_state = np.reshape(next_state, [1, 2])
            agent.remember(state, action, reward, next_state, done)
            state = next_state

            if done:
                print(f"episode: {e}/{episodes}, score: {time}, e: {agent.epsilon:.2}")
                break

            if len(agent.memory) > batch_size:
                agent.replay(batch_size)

小结

上述代码将环境着重集成到 DQN 智能体中，通过训练使其在迷宫中找到目标。通过