强化学习汇总(附具体代码实现)

第一部分 强化学习基础

第1章 强化学习概述

1.1 强化学习概念

  1. 定义:强化学习是机器通过与环境交互来实现目标的一种计算方法。
    机器与环境的一轮交互:机器在环境的一个状态下做一个动作决策,动作执行后,环境发生改变并把相应的奖励反馈和下一轮状态传回机器。
  2. 交互
    在这里插入图片描述
    • 感知:智能体在某种程度上感知环境的状态
    • 决策:智能体根据当前状态计算出到达目标需要采取的动作的过程;
      策略是智能体最终体现的智能形式,是不同智能体之间的核心区别
    • 奖励:环境根据状态和智能体采取的动作,产生一个标量信号作为奖励反馈;
      最大化累计奖励期望是智能体提升策略的目标,也是衡量智能体策略好坏的关键指标

1.2 强化学习的环境

  环境的下一刻状态的概率分布由当前状态和智能体的动作共同决定,公式如下:

环境的下一刻状态 ∼ P ( ⋅ ∣ 当前状态,智能体的动作 ) 环境的下一刻状态 \sim P(\cdot | 当前状态,智能体的动作) 环境的下一刻状态P(当前状态,智能体的动作)

1.3 强化学习的目标

  • 整体回报:整个交互过程的每一轮获得的奖励信号的累加,类似一盘游戏最后的得分。
  • 价值:回报的期望,也是智能体学习的优化目标。
    计算方式:需要对交互过程中每一轮智能体采取动作的概率分布和环境相应的状态转移的概率分布做积分运算。

1.4 强化学习的数据

  在强化学习中,数据是智能体与环境交互的过程中得到的。如果智能体不采取某个决策动作,那么该动作对于的数据就无法被观测到,所以当前智能体的训练数据来自之前智能体的决策结果。因此,策略不同,得到的数据分布就不同。

  强化学习中有一个关于数据分布的概念,叫作占用度量。归一化的占用度量用于衡量在交互过程中,采样到一个具体的状态动作对的概率分布。

  占用度量的一个重要性质:占用度量相同当且仅当策略相同。因此,寻找最优策略对应寻找最优占用度量。

第2章 多臂老虎机问题(MAB)

访问文章:多臂老虎机问题

第3章 马尔可夫决策过程(MDP)

访问文章:马尔可夫决策过程

第4章 动态规划算法

4.1 简介

  • 动态规划介绍
      动态规划会保存已解决的子问题的答案,在求解目标问题的过程中,需要这些子问题的答案时就可以直接利用,避免重复计算。
  • 动态规划分类:基于动态规划的强化学习算法主要有两种:
    • 策略迭代:由策略评估和策略提升两部分组成,其中策略评估使用贝尔曼期望方程来得到一个策略的状态价值函数。
    • 价值迭代:直接使用贝尔曼最优方程来进行动态规划
  • 动态规划评价
    • 优点 :高效、避免重复计算
    • 缺点:只适用于白盒环境【事先知道环境的状态转移函数和奖励函数,即知道整个马尔可夫决策过程】、只适用于有限马尔可夫决策过程【即状态空间和动作空间是离散且有限的】

4.2 悬崖漫步环境

4.2.1 介绍

  悬崖漫步环境要求一个智能体从起点出发,避开悬崖行走,最终到达目标位置。如下图所示,有一个 4 × 12 4\times 12 4×12 的网格世界,每一个网格表示一个状态。智能体的起点是左下角的状态,目标是右下角的状态,智能体在每一个状态都可以采取 4 种动作:上、下、左和右。如果碰到边界则不改变状态,否则进入下一个状态。掉入悬崖和到达目标状态是终止状态。智能体每走一步的奖励是 -1,掉入悬崖的奖励是 -100。

在这里插入图片描述

编码实现:

新建项目 DP,项目结构如下:

在这里插入图片描述

新建文件 CliffWalkingEnv.py 文件,文件代码如下:

class CliffWalkingEnv:
    def __init__(self, row=4, col=12):
        self.row = row
        self.col = col
        # 转移矩阵 P[state][a] = [(p —— 转移概率 , next_state , reward , done —— 是否终止 )]
        self.P = self.create_P()

    def create_P(self):
        P = [[[] for j in range(4)] for i in range(self.row * self.col)]
        # 上下左右,上 —— x+0,y-1;下 —— x+0,y+1;左 —— x-1,y+0;右 —— x+1,y+0
        change = [[0, -1], [0, 1], [-1, 0], [1, 0]]
        for i in range(self.row):
            for j in range(self.col):
                for a in range(4):
                    # 位置在悬崖和目标状态表示终止,奖励为 0
                    if i == self.row - 1 and j > 0:
                        P[i * self.col + j][a] = [1, i * self.col + j, 0, True]
                        continue
                    # 其他位置
                    next_x = min(self.col - 1, max(0, j + change[a][0]))
                    next_y = min(self.row - 1, max(0, i + change[a][1]))
                    next_state = next_y * self.col + next_x
                    reward = -1
                    done = False
                    # 下一个位置在终点或者悬崖
                    if next_y == self.row - 1 and next_x > 0:
                        done = True
                        if next_x != self.col - 1:
                            reward = -100
                    P[i * self.col + j][a] = [(1, next_state, reward, done)]
        return P
4.2.2 策略迭代算法

  策略迭代时策略评估和策略提升不断循环交替,直到最后得到最优策略的过程。

4.2.2.1 策略评估
4.2.2.2 策略提升
4.2.2.3 策略迭代
4.2.3 价值迭代算法

第5章 时序差分算法

第6章 Dyna-Q 算法

第二部分 强化学习进阶

第7章 DQN 算法

第8章 DQN 改进算法

第9章 策略梯度算法

第10章 Actor-Critic 算法

第11章 TRPO 算法

第12章 PPO 算法

第13章 DDPG 算法

第14章 SAC 算法

第三部分 强化学习前沿

第15章 模仿学习

第16章 模型预测控制

第17章 基于模型的策略优化

第18章 离线强化学习

第19章 目标导向的强化学习

第20章 多智能体强化学习入门

第21章 多智能体强化学习进阶

当涉及到多智能体强化学习时,常用的算法之一是多智能体深度确定性策略梯度 (Multi-Agent Deep Deterministic Policy Gradient, MADDPG)。以下是一个使用PyTorch和OpenAI Gym实现MADDPG算法的简单示例代码: ```python import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F import numpy as np import gym # 定义MADDPG模型中的Actor网络 class Actor(nn.Module): def __init__(self, state_dim, action_dim): super(Actor, self).__init__() self.fc1 = nn.Linear(state_dim, 64) self.fc2 = nn.Linear(64, 32) self.fc3 = nn.Linear(32, action_dim) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = torch.tanh(self.fc3(x)) return x # 定义MADDPG模型中的Critic网络 class Critic(nn.Module): def __init__(self, state_dim, action_dim): super(Critic, self).__init__() self.fc1 = nn.Linear(state_dim + action_dim, 64) self.fc2 = nn.Linear(64, 32) self.fc3 = nn.Linear(32, 1) def forward(self, state, action): x = torch.cat([state, action], dim=1) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x # 定义MADDPG算法 class MADDPG: def __init__(self, num_agents, state_dim, action_dim): self.num_agents = num_agents self.state_dim = state_dim self.action_dim = action_dim self.actors = [Actor(state_dim, action_dim) for _ in range(num_agents)] self.critics = [Critic(num_agents * state_dim, num_agents * action_dim) for _ in range(num_agents)] self.target_actors = [Actor(state_dim, action_dim) for _ in range(num_agents)] self.target_critics = [Critic(num_agents * state_dim, num_agents * action_dim) for _ in range(num_agents)] self.actor_optimizers = [optim.Adam(actor.parameters(), lr=0.001) for actor in self.actors] self.critic_optimizers = [optim.Adam(critic.parameters(), lr=0.001) for critic in self.critics] self.memory = [] def select_action(self, agent_id, state): state = torch.FloatTensor(state) actor = self.actors[agent_id] actor.eval() with torch.no_grad(): action = actor(state) actor.train() return action.numpy() def remember(self, state, action, reward, next_state): self.memory.append((state, action, reward, next_state)) def update(self, batch_size, gamma): if len(self.memory) < batch_size: return batch = np.random.choice(len(self.memory), batch_size, replace=False) states, actions, rewards, next_states = zip(*[self.memory[i] for i in batch]) states = torch.FloatTensor(states) actions = torch.FloatTensor(actions) rewards = torch.FloatTensor(rewards) next_states = torch.FloatTensor(next_states) for agent_id in range(self.num_agents): actor = self.actors[agent_id] critic = self.critics[agent_id] target_actor = self.target_actors[agent_id] target_critic = self.target_critics[agent_id] actor_optimizer = self.actor_optimizers[agent_id] critic_optimizer = self.critic_optimizers[agent_id] # 更新Critic网络 next_actions = torch.cat([actor(next_states[:, i, :]) for i in range(self.num_agents)], dim=1) target_next_actions = torch.cat([target_actor(next_states[:, i, :]) for i in range(self.num_agents)], dim=1) target_q_values = target_critic(next_states.view(batch_size, -1), target_next_actions) target_q_values = rewards[:, agent_id].view(-1, 1) + gamma * target_q_values q_values = critic(states.view(batch_size, -1), actions.view(batch_size, -1)) critic_loss = F.mse_loss(q_values, target_q_values) critic_optimizer.zero_grad() critic_loss.backward() critic_optimizer.step() # 更新Actor网络 actions_pred = torch.cat([actor(states[:, i, :]) if i == agent_id else actor(states[:, i, :]).detach() for i in range(self.num_agents)], dim=1) actor_loss = -critic(states.view(batch_size, -1), actions_pred).mean() actor_optimizer.zero_grad() actor_loss.backward() actor_optimizer.step() # 软更新目标网络 for target_param, param in zip(target_actor.parameters(), actor.parameters()): target_param.data.copy_(0.995 * target_param.data + 0.005 * param.data) for target_param, param in zip(target_critic.parameters(), critic.parameters()): target_param.data.copy_(0.995 * target_param.data + 0.005 * param.data) def save(self, path): torch.save({ 'actors': [actor.state_dict() for actor in self.actors], 'critics': [critic.state_dict() for critic in self.critics] }, path) def load(self, path): checkpoint = torch.load(path) for i, actor in enumerate(self.actors): actor.load_state_dict(checkpoint['actors'][i]) for i, critic in enumerate(self.critics): critic.load_state_dict(checkpoint['critics'][i]) # 定义训练过程 def train(env, num_agents, num_episodes, batch_size, gamma): state_dim = env.observation_space.shape[0] action_dim = env.action_space.shape[0] maddpg = MADDPG(num_agents, state_dim, action_dim) for episode in range(num_episodes): state = env.reset() done = False episode_reward = 0 while not done: actions = [maddpg.select_action(agent_id, state) for agent_id in range(num_agents)] next_state, rewards, done, _ = env.step(actions) episode_reward += sum(rewards) for agent_id in range(num_agents): maddpg.remember(state[agent_id], actions[agent_id], rewards[agent_id], next_state[agent_id]) maddpg.update(batch_size, gamma) state = next_state print("Episode: {}, Reward: {}".format(episode, episode_reward)) return maddpg # 使用CartPole环境进行训练 env = gym.make('CartPole-v0') maddpg = train(env, num_agents=2, num_episodes=1000, batch_size=64, gamma=0.99) # 保存训练好的模型 maddpg.save('maddpg_model.pth') ``` 请注意,这只是一个简单的示例代码,实际上,多智能体强化学习实现可能更加复杂,并且需要根据具体的问题进行调整和优化。还有其他更复杂的算法和技术可用于多智能体强化学习,如Multi-Agent Proximal Policy Optimization (MADDPPO)和Multi-Agent Soft Actor-Critic (MASAC)等。希望这个示例代码能够帮助你入门多智能体强化学习实现
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值