学习日志12

这段代码实现了一个基于量子机器学习的深度Q学习(DQN)算法,用于解决OpenAI Gym的FrozenLake环境。以下是对代码的主要部分进行解释:

状态输入编码:

使用计算基编码将状态输入编码为量子态。这种编码方式将离散状态映射到量子比特上。
动作输出:

使用softmax函数输出动作概率分布。这样可以得到每个动作的概率值,而不是简单地选择最大值对应的动作。
深度Q学习(DQN):

使用深度神经网络作为Q函数的近似器。这里使用了一个量子电路来实现Q函数的近似。
经验回放:

使用经验回放缓存来进行无关样本的训练。这有助于打破样本之间的相关性,提高训练的稳定性。
目标网络:

使用另一组独立的参数作为目标网络,定期更新以提高稳定性。这种方法可以减少Q值预测和目标Q值之间的差异,从而提高训练的收敛性。
PyTorch集成:

利用PyTorch的深度学习框架实现了整个算法。这可以充分利用PyTorch的自动求导和优化功能。
此外,代码还包括一些辅助功能,如绘制训练结果的函数,以及保存模型参数的功能。

总的来说,这个实现展示了如何将量子机器学习与深度强化学习相结合,在FrozenLake环境中进行学习和决策。这是一个非常有趣的尝试,可以帮助我们更好地理解量子计算在强化学习中的应用。

QML as Q Learning function approximator
 使用量子机器学习作为Q学习的函数近似器

 Need to specify STATE input format
 需要指定状态输入的格式

# Computational Basis Encoding
# 使用计算基编码

# action output is still softmax [a_0, a_1, a_2, a_3, a_4, a_5]
# 动作输出仍然使用softmax函数 [a_0, a_1, a_2, a_3, a_4, a_5]

# Deep Q-Learning DQN
# 使用深度Q学习(DQN)

# Experimence Replay (For i.i.d sampling)
# 经验回放(用于独立同分布采样)

# Target Network (Updata every C episodes) ==> Another Circuit Parameter Set
# 目标网络(每C个回合更新一次) ==> 另一组电路参数集

# This version is enhanced with PyTorch
# 这个版本增加了PyTorch的支持

# Adapt some code from 
# 改编自以下代码:
# PyTorch tutorial on deep reinforcement learning
# and
# Xanadu AI github repository

# Environment: OpenAI gym FrozenLake
# 环境: OpenAI gym FrozenLake

总的来说,这段注释描述了这个实现的一些关键特点,包括使用量子机器学习作为Q函数的近似器,采用计算基编码表示状态,使用softmax输出动作概率,以及结合深度Q学习、经验回放和目标网络等技术。同时,这个版本还集成了PyTorch框架,并参考了一些相关的教程和代码库。最后,它针对的是OpenAI gym的FrozenLake环境。

状态输入编码: 使用计算基编码将状态输入编码为量子态。
# 动作输出: 使用softmax函数输出动作概率分布。
# 深度Q学习(DQN): 使用深度神经网络作为Q函数的近似器。
# 经验回放: 使用经验回放缓存来进行无关样本的训练。
# 目标网络: 使用另一组独立的参数作为目标网络,定期更新以提高稳定性。
# PyTorch集成: 利用PyTorch的深度学习框架实现。

这部分注释进一步解释了代码中使用的一些关键技术:

状态输入编码: 使用计算基编码将状态输入转换为量子态表示。
动作输出: 使用softmax函数输出动作的概率分布。
深度Q学习(DQN): 使用深度神经网络作为Q函数的近似器。
经验回放: 使用经验回放缓存来进行无关样本的训练,提高训练的稳定性。
目标网络: 使用另一组独立的参数作为目标网络,定期更新以提高收敛性。
PyTorch集成: 利用PyTorch的深度学习框架实现了整个算法。
这些技术的组合使得这个实现能够利用量子机器学习的优势来解决强化学习问题。

## Definition of Replay Memory
## If next_state == None
## it is in the terminal state

Transition = namedtuple('Transition',
                        ('state', 'action', 'reward', 'next_state', 'done'))

class ReplayMemory(object):

    def __init__(self, capacity):
        self.capacity = capacity
        self.memory = []
        self.position = 0

    def push(self, *args):
        """Saves a transition."""
        if len(self.memory) < self.capacity:
            self.memory.append(None)
        self.memory[self.position] = Transition(*args)
        self.position = (self.position + 1) % self.capacity

    def sample(self, batch_size):
        return random.sample(self.memory, batch_size)

    def output_all(self):
        return self.memory

    def __len__(self):
        return len(self.memory)

这部分注释和代码定义了一个经验回放(Replay Memory)的实现:

定义了一个Transition命名元组,用于存储状态、动作、奖励、下一个状态和是否完成的信息。
ReplayMemory类实现了经验回放的功能,包括:
初始化一个固定容量的内存
将新的转移样本添加到内存中
从内存中随机采样一个批次的转移样本
输出内存中所有的转移样本
返回内存中当前存储的样本数
这个经验回放缓存可以用于打破样本之间的相关性,提高训练的稳定性。

 register(
#     id='Deterministic-4x4-FrozenLake-v0', # name given to this new environment
#     entry_point='gym.envs.toy_text.frozen_lake:FrozenLakeEnv', # env entry point
#     kwargs={'map_name': '4x4', 'is_slippery': False} # argument passed to the env
# )

# 这段代码注册了一个新的FrozenLake环境,命名为'Deterministic-4x4-FrozenLake-v0'。
# 这个环境使用gym.envs.toy_text.frozen_lake:FrozenLakeEnv作为入口点,
# 并且设置了地图名称为'4x4'和'is_slippery'为False,表示这是一个确定性的环境。

# register(
#     id='Deterministic-ShortestPath-4x4-FrozenLake-v0', # name given to this new environment
#     entry_point='ShortestPathFrozenLake:ShortestPathFrozenLake', # env entry point
#     kwargs={'map_name': '4x4', 'is_slippery': False} # argument passed to the env
# )

# 这段代码注册了另一个新的FrozenLake环境,命名为'Deterministic-ShortestPath-4x4-FrozenLake-v0'。
# 这个环境使用'ShortestPathFrozenLake:ShortestPathFrozenLake'作为入口点,
# 并且设置了地图名称为'4x4'和'is_slippery'为False,表示这也是一个确定性的环境。
# 这个环境可能与前一个有所不同,比如可能会关注寻找最短路径的任务。

这部分注释描述了代码中注册了两个新的FrozenLake环境。

第一个环境命名为’Deterministic-4x4-FrozenLake-v0’,使用了标准的FrozenLakeEnv作为入口点,并且设置了地图大小为4x4,且环境是确定性的(没有滑动效果)。

第二个环境命名为’Deterministic-ShortestPath-4x4-FrozenLake-v0’,使用了一个名为’ShortestPathFrozenLake’的自定义环境作为入口点,同样设置了4x4的地图大小和确定性的环境。这个环境可能会关注寻找最短路径的任务。

通过注册这些自定义环境,可以更好地适配算法实现的需求。

# 定义Q网络
# 输入: 状态编码 (量子态)
# 输出: 动作概率分布 (softmax)
class QNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(QNetwork, self).__init__()
        self.state_dim = state_dim
        self.action_dim = action_dim
        
        # 量子电路层
        self.quantum_circuit = QuantumCircuit(self.state_dim)
        
        # 全连接层
        self.fc = nn.Linear(self.state_dim, self.action_dim)

    def forward(self, state):
        # 状态编码为量子态
        quantum_state = state_to_quantum_state(state, self.state_dim)
        
        # 量子电路层
        quantum_state = self.quantum_circuit(quantum_state)
        
        # 全连接层
        action_logits = self.fc(quantum_state)
        
        # Softmax输出动作概率
        action_probs = F.softmax(action_logits, dim=1)
        
        return action_probs

这部分注释描述了Q网络的定义:

Q网络是一个PyTorch模块,输入为状态编码(量子态),输出为动作概率分布(softmax)。
网络包含两个主要部分:
量子电路层,用于对状态进行量子态编码和处理。
全连接层,将量子态映射到动作概率分布。
在前向传播过程中:
首先将输入状态编码为量子态。
然后通过量子电路层处理量子态。
最后通过全连接层输出动作概率分布。
这种结构允许将量子机器学习与深度神经网络相结合,形成一个混合的Q函数近似器。
总的来说,这个Q网络是整个量子强化学习算法的核心部分,负责根据输入状态输出动作概率分布。

# 定义DQN代理
class DQNAgent:
    def __init__(self, state_dim, action_dim, gamma, lr, capacity, batch_size):
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.gamma = gamma
        self.lr = lr
        self.batch_size = batch_size

        # 创建Q网络和目标网络
        self.q_network = QNetwork(self.state_dim, self.action_dim)
        self.target_q_network = QNetwork(self.state_dim, self.action_dim)
        self.target_q_network.load_state_dict(self.q_network.state_dict())

        # 优化器和损失函数
        self.optimizer = optim.Adam(self.q_network.parameters(), lr=self.lr)
        self.criterion = nn.MSELoss()

        # 经验回放缓存
        self.replay_memory = ReplayMemory(capacity)

    # 根据当前状态选择动作
    def select_action(self, state, epsilon):
        if random.random() < epsilon:
            return random.randint(0, self.action_dim - 1)
        else:
            with torch.no_grad():
                action_probs = self.q_network(state)
                return torch.argmax(action_probs, dim=1).item()

    # 训练Q网络
    def train_q_network(self):
        if len(self.replay_memory) < self.batch_size:
            return

        transitions = self.replay_memory.sample(self.batch_size)
        batch = Transition(*zip(*transitions))

        # 计算当前Q值和目标Q值
        current_q_values = self.q_network(batch.state).gather(1, batch.action.unsqueeze(1))
        next_q_values = self.target_q_network(batch.next_state).max(1)[0].detach()
        expected_q_values = batch.reward + self.gamma * next_q_values * (1 - batch.done)

        # 更新Q网络
        loss = self.criterion(current_q_values, expected_q_values.unsqueeze(1))
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

    # 更新目标网络
    def update_target_network(self):
        self.target_q_network.load_state_dict(self.q_network.state_dict())

这部分注释描述了DQN代理的实现:

初始化时创建了Q网络和目标网络,并设置了优化器和损失函数。
实现了select_action方法,根据当前状态和一定的探索概率选择动作。
实现了train_q_network方法,从经验回放缓存中采样一个批次的转移样本,计算当前Q值和目标Q值,然后更新Q网络的参数。
实现了update_target_network方法,将Q网络的参数复制到目标网络,以提高训练的稳定性。
这个DQN代理是整个量子强化学习算法的核心部分,负责根据当前状态选择动作,并通过经验回放和目标网络更新来训练Q网络。

# 训练DQN代理
def train_dqn(env, agent, num_episodes, max_steps, epsilon_start, epsilon_end, epsilon_decay):
    rewards = []
    steps = []
    epsilon = epsilon_start

    for episode in range(num_episodes):
        state = env.reset()
        total_reward = 0
        
        for step in range(max_steps):
            action = agent.select_action(torch.tensor([state], dtype=torch.float32), epsilon)
            next_state, reward, done, _ = env.step(action)
            agent.replay_memory.push(state, action, reward, next_state, done)
            agent.train_q_network()
            
            state = next_state
            total_reward += reward
            
            if done:
                break
        
        agent.update_target_network()
        
        rewards.append(total_reward)
        steps.append(step + 1)
        
        epsilon = max(epsilon_end, epsilon * epsilon_decay)
        
        print(f"Episode {episode+1}/{num_episodes}, Reward: {total_reward}, Steps: {step+1}, Epsilon: {epsilon:.2f}")
    
    return rewards, steps

这部分注释描述了训练DQN代理的过程:

定义了train_dqn函数,接受环境、代理、训练轮数、最大步数、探索概率的起始值、结束值和衰减率等参数。
在每个训练轮次中:
重置环境,获取初始状态。
循环执行最大步数:
根据当前状态和探索概率选择动作。
执行动作,获取下一个状态、奖励和是否完成。
将转移样本存入经验回放缓存。
训练Q网络。
更新目标网络。
记录当前轮次的总奖励和步数。
更新探索概率。
最后返回所有轮次的奖励和步数列表。
这个训练函数实现了DQN算法的核心流程,包括状态-动作选择、经验回放、Q网络训练和目标网络更新等关键步骤。通过循环执行这个函数,可以训练出一个强化学习代理。

# 测试DQN代理
def test_dqn(env, agent, num_episodes, max_steps):
    rewards = []
    steps = []

    for episode in range(num_episodes):
        state = env.reset()
        total_reward = 0

        for step in range(max_steps):
            action = agent.select_action(torch.tensor([state], dtype=torch.float32), epsilon=0.0)
            next_state, reward, done, _ = env.step(action)
            state = next_state
            total_reward += reward

            if done:
                break

        rewards.append(total_reward)
        steps.append(step + 1)
        print(f"Episode {episode+1}/{num_episodes}, Reward: {total_reward}, Steps: {step+1}")

    return rewards, steps

这部分注释描述了测试DQN代理的过程:

定义了test_dqn函数,接受环境、代理、测试轮数和最大步数等参数。
在每个测试轮次中:
重置环境,获取初始状态。
循环执行最大步数:
根据当前状态选择动作(探索概率设为0.0,即完全利用)。
执行动作,获取下一个状态和奖励。
更新当前状态。
累计总奖励。
记录当前轮次的总奖励和步数。
打印当前轮次的结果。
最后返回所有轮次的奖励和步数列表。
这个测试函数用于评估训练好的DQN代理在环境中的表现。它会在每个测试轮次中选择最优动作,并记录总奖励和步数。通过比较不同训练方法或超参数下的测试结果,可以评估DQN代理的性能。

if __name__ == "__main__":
    # 创建环境
    env = gym.make('Deterministic-4x4-FrozenLake-v0')
    state_dim = env.observation_space.n
    action_dim = env.action_space.n

    # 创建DQN代理
    agent = DQNAgent(state_dim, action_dim, gamma=0.99, lr=0.001, capacity=10000, batch_size=32)

    # 训练DQN代理
    num_episodes = 1000
    max_steps = 100
    epsilon_start = 1.0
    epsilon_end = 0.01
    epsilon_decay = 0.995
    train_rewards, train_steps = train_dqn(env, agent, num_episodes, max_steps, epsilon_start, epsilon_end, epsilon_decay)

    # 测试DQN代理
    num_test_episodes = 100
    test_rewards, test_steps = test_dqn(env, agent, num_test_episodes, max_steps)

    # 打印结果
    print("Training Results:")
    print(f"Average Reward: {sum(train_rewards) / num_episodes:.2f}")
    print(f"Average Steps: {sum(train_steps) / num_episodes:.2f}")

    print("\nTesting Results:")
    print(f"Average Reward: {sum(test_rewards) / num_test_episodes:.2f}")
    print(f"Average Steps: {sum(test_steps) / num_test_episodes:.2f}")

这部分注释描述了整个程序的主要流程:

创建FrozenLake环境,并获取状态和动作维度。
创建DQN代理,设置相关超参数。
调用train_dqn函数训练DQN代理,传入环境、代理和训练相关参数。
调用test_dqn函数测试训练好的DQN代理,传入环境、代理和测试相关参数。
打印训练和测试的平均奖励和平均步数。
这个主程序部分将前面定义的环境、代理和训练/测试函数整合在一起,构成了一个完整的量子强化学习算法的实现。通过运行这个程序,可以训练出一个DQN代理,并评估其在FrozenLake环境中的表现。

# 经验回放缓存
class ReplayMemory:
    def __init__(self, capacity):
        self.capacity = capacity
        self.memory = []
        self.position = 0

    def push(self, *args):
        """保存一个转移样本"""
        if len(self.memory) < self.capacity:
            self.memory.append(None)
        self.memory[self.position] = Transition(*args)
        self.position = (self.position + 1) % self.capacity

    def sample(self, batch_size):
        """从缓存中随机采样一个批次的转移样本"""
        return random.sample(self.memory, batch_size)

    def __len__(self):
        """返回缓存中当前的转移样本数量"""
        return len(self.memory)

# 转移样本
Transition = namedtuple('Transition',
                        ('state', 'action', 'reward', 'next_state', 'done'))

这部分注释描述了经验回放缓存的实现:

ReplayMemory类用于存储和管理转移样本(状态、动作、奖励、下一状态、是否完成)。
它有一个固定容量,当缓存满时会覆盖最早添加的样本。
push方法用于添加一个新的转移样本到缓存中。
sample方法用于从缓存中随机采样一个批次的转移样本。
__len__方法返回当前缓存中的转移样本数量。
Transition是一个命名元组,用于表示一个转移样本的各个组成部分。

这个经验回放缓存是DQN算法中非常重要的组件,它可以打破样本之间的相关性,提高训练的稳定性和效率。

# Q网络
class QNetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(QNetwork, self).__init__()
        self.fc1 = nn.Linear(state_dim, 128)
        self.fc2 = nn.Linear(128, 128)
        self.fc3 = nn.Linear(128, action_dim)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

这部分注释描述了Q网络的实现:

QNetwork类继承自nn.Module,是一个基于PyTorch的神经网络模型。
它包含三个全连接层:
第一层接受状态输入,输出128个特征。
第二层进一步处理特征,输出128个特征。
第三层输出每个动作的Q值。
forward方法定义了前向传播过程,将输入状态经过三个全连接层,最终输出每个动作的Q值。
这个Q网络是DQN算法的核心组件,它用于近似计算给定状态下各个动作的预期未来回报(Q值)。通过训练这个网络,DQN代理可以学习如何选择最优动作。

# DQN代理
class DQNAgent:
    def __init__(self, state_dim, action_dim, gamma, lr, capacity, batch_size):
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.gamma = gamma
        self.lr = lr
        self.batch_size = batch_size

        self.q_network = QNetwork(state_dim, action_dim)
        self.target_network = QNetwork(state_dim, action_dim)
        self.target_network.load_state_dict(self.q_network.state_dict())
        self.target_network.eval()

        self.optimizer = optim.Adam(self.q_network.parameters(), lr=self.lr)
        self.replay_memory = ReplayMemory(capacity)

    def select_action(self, state, epsilon):
        """根据当前状态和探索概率选择动作"""
        if random.random() < epsilon:
            return env.action_space.sample()
        else:
            with torch.no_grad():
                return self.q_network(state).max(1)[1].item()

    def train_q_network(self):
        """训练Q网络"""
        if len(self.replay_memory) < self.batch_size:
            return

        transitions = self.replay_memory.sample(self.batch_size)
        batch = Transition(*zip(*transitions))

        state_batch = torch.tensor(batch.state, dtype=torch.float32)
        action_batch = torch.tensor(batch.action, dtype=torch.int64).unsqueeze(1)
        reward_batch = torch.tensor(batch.reward, dtype=torch.float32)
        next_state_batch = torch.tensor(batch.next_state, dtype=torch.float32)
        done_batch = torch.tensor(batch.done, dtype=torch.float32)

        q_values = self.q_network(state_batch).gather(1, action_batch)
        next_q_values = self.target_network(next_state_batch).max(1)[0].detach()
        expected_q_values = reward_batch + self.gamma * next_q_values * (1 - done_batch)

        loss = F.mse_loss(q_values, expected_q_values.unsqueeze(1))
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

    def update_target_network(self):
        """更新目标网络"""
        self.target_network.load_state_dict(self.q_network.state_dict())

这部分注释描述了DQN代理的实现:

DQNAgent类包含了DQN算法所需的所有组件:
状态和动作维度
折扣因子和学习率
批量大小
Q网络和目标网络
优化器
经验回放缓存
select_action方法根据当前状态和探索概率选择动作,用于在环境中执行。
train_q_network方法从经验回放缓存中采样一个批次的转移样本,计算损失并更新Q网络。
update_target_network方法将Q网络的参数复制到目标网络,用于稳定训练过程。
这个DQN代理类封装了DQN算法的所有核心组件,为训练和测试提供了一个高度抽象和可复用的接口。通过实例化这个类并调用相应的方法,可以实现一个完整的强化学习代理。

# 训练DQN代理
def train_dqn(env, agent, num_episodes, max_steps, epsilon_start, epsilon_end, epsilon_decay):
    rewards = []
    steps = []
    epsilon = epsilon_start

    for episode in range(num_episodes):
        state = env.reset()
        total_reward = 0

        for step in range(max_steps):
            action = agent.select_action(torch.tensor([state], dtype=torch.float32), epsilon)
            next_state, reward, done, _ = env.step(action)
            agent.replay_memory.push(state, action, reward, next_state, done)
            agent.train_q_network()
            state = next_state
            total_reward += reward

            if done:
                break

        agent.update_target_network()
        rewards.append(total_reward)
        steps.append(step + 1)
        epsilon = max(epsilon_end, epsilon * epsilon_decay)
        print(f"Episode {episode+1}/{num_episodes}, Reward: {total_reward}, Steps: {step+1}, Epsilon: {epsilon:.2f}")

    return rewards, steps

这部分注释描述了训练DQN代理的过程:

train_dqn函数接受环境、代理、训练轮数、最大步数、初始探索概率、最终探索概率和探索概率衰减因子等参数。
在每个训练轮次中:
重置环境,获取初始状态。
循环执行最大步数:
根据当前状态和探索概率选择动作。
执行动作,获取下一个状态、奖励和是否完成标志。
将转移样本(状态、动作、奖励、下一状态、是否完成)推入经验回放缓存。
训练Q网络。
更新当前状态。
累计总奖励。
更新目标网络。
记录当前轮次的总奖励和步数。
更新探索概率。
打印当前轮次的结果。
最后返回所有轮次的奖励和步数列表。
这个训练函数实现了DQN算法的核心流程,包括:

在环境中与代理交互,收集转移样本。
从经验回放缓存中采样批量数据,训练Q网络。
定期更新目标网络,提高训练稳定性。
逐步降低探索概率,使代理更好地利用已学习的知识。
通过多轮次的训练,DQN代理可以逐步学习出最优的行为策略。

# 测试DQN代理
def test_dqn(env, agent, num_episodes, max_steps):
    rewards = []
    steps = []

    for episode in range(num_episodes):
        state = env.reset()
        total_reward = 0

        for step in range(max_steps):
            action = agent.select_action(torch.tensor([state], dtype=torch.float32), 0.0)
            next_state, reward, done, _ = env.step(action)
            state = next_state
            total_reward += reward

            if done:
                break

        rewards.append(total_reward)
        steps.append(step + 1)
        print(f"Test Episode {episode+1}/{num_episodes}, Reward: {total_reward}, Steps: {step+1}")

    return rewards, steps

这部分注释描述了测试DQN代理的过程:

test_dqn函数接受环境、代理、测试轮数和最大步数等参数。
在每个测试轮次中:
重置环境,获取初始状态。
循环执行最大步数:
根据当前状态选择动作(不进行探索)。
执行动作,获取下一个状态、奖励和是否完成标志。
更新当前状态。
累计总奖励。
记录当前轮次的总奖励和步数。
打印当前轮次的结果。
最后返回所有轮次的奖励和步数列表。
这个测试函数用于评估训练好的DQN代理在环境中的性能。它不会进行探索,而是直接根据已学习的策略选择动作。通过多轮次的测试,可以得到代理的平均奖励和平均步数,从而评估其在给定任务上的表现。

这个测试过程是DQN算法实现的最后一步,为了更好地理解代理的学习效果,通常会将训练和测试结果进行对比和分析。

# 主函数
if __name__ == "__main__":
    # 设置环境和代理参数
    env = gym.make("CartPole-v1")
    state_dim = env.observation_space.shape[0]
    action_dim = env.action_space.n
    gamma = 0.99
    lr = 1e-3
    capacity = 10000
    batch_size = 32
    num_episodes = 500
    max_steps = 200
    epsilon_start = 1.0
    epsilon_end = 0.01
    epsilon_decay = 0.995

    # 创建DQN代理
    agent = DQNAgent(state_dim, action_dim, gamma, lr, capacity, batch_size)

    # 训练DQN代理
    train_rewards, train_steps = train_dqn(env, agent, num_episodes, max_steps, epsilon_start, epsilon_end, epsilon_decay)

    # 测试DQN代理
    test_rewards, test_steps = test_dqn(env, agent, 100, max_steps)

    # 打印结果
    print("Training Results:")
    print(f"Average Reward: {np.mean(train_rewards):.2f}")
    print(f"Average Steps: {np.mean(train_steps):.2f}")

    print("\nTesting Results:")
    print(f"Average Reward: {np.mean(test_rewards):.2f}")
    print(f"Average Steps: {np.mean(test_steps):.2f}")

这部分注释描述了主函数的实现:

设置环境和代理参数:
创建OpenAI Gym的CartPole-v1环境。
获取状态和动作维度。
设置折扣因子、学习率、经验回放缓存容量、批量大小等超参数。
设置训练轮数、最大步数、探索概率范围和衰减因子。
创建DQN代理实例。
调用train_dqn函数,训练DQN代理。
调用test_dqn函数,测试训练好的DQN代理。
打印训练和测试的平均奖励和平均步数。
这个主函数将前面定义的所有组件整合在一起,实现了一个完整的DQN算法。通过设置不同的环境和超参数,可以将这个框架应用于各种强化学习任务。

整个代码实现了DQN算法的核心流程,包括经验回放缓存、Q网络、目标网络、训练和测试等关键组件。这为理解和应用DQN算法提供了一个很好的参考。