七、多智能体强化学习高级主题及其趋势

7.1 高级话题

7.1.1 层次化强化学习（Hierarchical RL, HRL）

(1) 为什么需要层次化？

• 在大规模、复杂决策场景中，直接从原始动作空间学到最优策略往往困难且收敛缓慢。
• 层次化 RL (HRL) 通过在策略层面引入层级结构，让智能体分解任务为更高层的“元动作”或“子任务”，从而简化学习过程、减少探索难度。

(2) 核心思路

1. 分层策略：
   • 高层策略（Meta-Controller）：在抽象层面决定哪个“子任务”或“技能”被激活；
   • 低层策略（Sub-Controller / Option）：在具体操作层面实现对应子任务的执行。
2. 选项框架（Options Framework）：
   • 将一段连续动作序列视为一个“Option”，可由高层策略在特定状态下调用；
   • 在智能体内部形成“可复用技能”，如“走到某处”“拾取物体”之类。

(3) 代表方法

• Option-Critic：在 Actor-Critic 框架中学习可复用“选项”以及选项终止条件；
• HIRO：针对高维连续环境的分层 RL，用高层提出子目标（sub-goal），低层尝试实现；
• HAC (Hierarchical Actor-Critic)、FeUdal Networks 等也在此领域具有代表性。

(4) 在多智能体场景的应用

• 多智能体若各自内部也具备层级策略，可提高协作效率，如高层策略管理团队战术布置，低层执行具体战斗/协同动作；
• 可与价值分解结合，让高层价值函数关注长期协作目标，低层专注局部技能或动作序列。

7.1.2 元强化学习（Meta RL）

(1) 元学习概念

• Meta Learning：在“学习如何学习”的范式下，让智能体能从一系列任务中提炼元知识，在遇到新任务或环境时能快速适应；
• 元强化学习（Meta-RL）将此思路带到强化学习领域，希望智能体在看到一些训练任务后，能在新任务中迅速找到优良策略，而无需从零开始大量试错。

(2) 典型方法

1. MAML (Model-Agnostic Meta-Learning)：
   • 虽然最初针对监督学习，但也被用于 RL 场景，通过梯度更新公式在不同任务间共享参数；
2. PEARL：
   • 在离线或少量交互下，通过贝叶斯后验推断当前任务特征 (task embedding)，再快速适配策略；
3. RL^2：
   • 用 RNN 处理过往 episode 经验，将其“内化”为隐藏状态，从而在下一个 episode 里具备“元策略”信息。

(3) 多智能体中的元学习

• 在多智能体协作或对抗环境中，一旦任务切换（如敌方策略变化、地图变化），能否元学习到在新场景下的快速适应策略，是前沿研究方向；
• 也可让一个 Agent 学习“对手模型”或“环境切换”时的快速应对。

7.1.3 强化学习的安全性与鲁棒性研究

(1) 安全强化学习（Safe RL）

• 强调在训练或执行过程中避免危险操作或违反约束（如物理安全、伦理约束、资源上限等）；
• 常见手段：在奖励中添加惩罚项，或在策略更新时加入约束优化 (CMDP)、盾式RL (Shielded RL) 等。

(2) 鲁棒强化学习（Robust RL）

• 鲁棒性指智能体在面对环境模型不确定性、对手策略变化、噪声扰动时，仍能维持良好性能；
• 可通过最坏情况优化(minimax training) 或随机扰动(domain randomization) 等方式提高策略的鲁棒性；
• 在多智能体协作/对抗中，鲁棒性尤其关键，因为对手策略的变化可能导致原先训练策略失效。

(3) 应用

• 工业自动化、机器人操作（涉及物理安全），无人机编队（避免碰撞），自动驾驶（安全约束），以及军事/应急指挥（鲁棒对抗对手或未知干扰）。

7.2 最新论文与方法

7.2.1 最近的 NIPS / ICML / ICLR / AAAI 等会议中的多智能体、人机协作相关研究

1. 多智能体通信与图网络

   • 大量工作关注如何在多智能体之间学习通信协议或借助 GNN 表达复杂交互；
   • 通过注意力机制、分布式编解码网络等实现高效消息传递与信用分配。

2. 可解释性和人机混合决策

   • 越来越多论文探讨如何向人类指挥官解释多智能体策略，以及如何在关键时刻将人类反馈或指令融入训练；
   • 出现interactive RL、human-in-the-loop RL、混合博弈等关键词研究。

3. 分布式与大规模训练

   • 针对大规模多智能体系统（数百~上千Agent），在通信代价、训练效率、收敛稳定性上提出新的分区策略、层次化调度算法；
   • 部分工作结合云端集群或硬件加速（GPU/TPU），实现更大规模的 MARL 实验。

4. 新颖的价值分解与 AC 方法

   • 如 QPLEX、CWQMIX、FACMAC、HATRPO 等，有的在价值分解基础上强化可表达性，有的将 Actor-Critic 与分解思路结合。

7.2.2 新的算法框架与库的出现、趋势观察

1. Mava (基于 DeepMind Acme)
   • 多智能体分布式学习，支持多种算法 (MADDPG、HATRPO、FacMAC 等)；
2. MARLlib
   • 基于 Ray RLlib 的多智能体扩展库，提供便捷的 MARL 接口与示例；
3. PyMARL2 / PyMARL fork
   • 在 PyMARL 之上添加更多算法、改进对 StarCraft or 其他环境的支持；
4. 趋势观察
   • 更注重多智能体通信、元学习、复杂博弈、高效大规模分布式；
   • 人机交互、安全合规与伦理等方面的关注度也在提升。

7.3 研究思路与项目应用

7.3.1 如何阅读前沿论文并将其应用到实际项目

1. 快速梳理动机与对比

   • 看论文的问题定义、核心贡献、对比基线，以及作者给出的实验环境和效果；
   • 判断该方法适合解决何种场景、需要哪些假设、是否与自己的项目需求相符。

2. 深入理解技术细节

   • 关注算法伪代码、损失函数、网络结构、训练流程；
   • 若要在项目中复现，需要匹配自己的环境接口（如 Gym/PettingZoo 等）和分布式/硬件条件。

3. 尝试小规模实验

   • 先在已有 benchmark（如 SMAC、PettingZoo 的多智能体游戏）中复现结果，验证稳定性和参数敏感度；
   • 之后再迁移到自定义场景或更贴近业务的环境。

4. 与现有系统结合

   • 分析如何把该论文的算法模块插入到现有的多智能体平台（RLlib、PyMARL、Mava 等）；
   • 可能要自定义 replay buffer、通信机制或 reward shaping，以适配论文所需流程。

7.3.2 如何在已有算法和系统基础上做个性化改进

1. 算法改造

   • 若现有算法无法处理你特定需求（如多目标、安全约束、人机混合决策），可在其损失函数或网络结构上做定制；
   • 结合价值分解和元学习，或在层次化思路上额外添加层级策略控制。

2. 系统工程化

   • 在工业/实战项目中，需要考虑高可用、可扩容、监控与日志、人机接口等；
   • 需将多智能体系统的推理服务化（REST/gRPC），或与云端平台对接（K8s、分布式日志）等工程实践。

3. 调参与性能优化

   • 多智能体算法通常对超参数敏感，且训练资源消耗大；
   • 需结合自动调参（Bayesian Optimization、Population Based Training）与大规模并行（Ray、SLURM 集群）来加速实验迭代。

下面给出一些典型应用场景，介绍如何将多智能体价值分解与协同决策方法，以及层次化强化学习、元强化学习、安全性和鲁棒性等高级话题，结合到实际业务或研究中去。这些场景充分体现了多智能体强化学习在工业、社会、军事、医疗、安全等方面的广阔前景。

1. 机器人协作与制造自动化

(1) 多机器人搬运 / 组装

• 需求背景：在智能制造车间中，多台机器人（或机械手臂）需要协同完成流水线上的装配或搬运任务，如协同抬举大件部件、分工拧紧螺丝、传递工件等。
• 多智能体价值分解：
  • 使用 VDN / QMIX，让所有机器人共享一个全局生产效率或装配成功率的奖励，通过价值分解给每台机器人一个局部 Q 函数，解决“如果装配失败，责任谁来承担”这类信用分配难题；
  • 机器人在局部观测下知道自己当前工位所需操作，但通过价值分解能学会协同时机与行动互补。
• 层次化思路：
  • 高层策略决定“机器人 A 先抓取部件、机器人 B 先旋转机械臂就位”，低层执行具体动作（抓、移动、对齐）；
  • 减少大动作空间带来的搜索难度。

(2) 物流仓储调度

• 需求背景：在大型电商仓库中，多台 AGV（Automated Guided Vehicle）或机器人需要自主分拣、配送到打包区；
• 元学习：
  • 当仓储货物种类、订单峰值模式经常变化时，使用元强化学习让机器人在面对新布局或新订单量激增时快速适应，不需再次大量试错。
• 安全与鲁棒性：
  • 需要避免机器人发生碰撞或在狭窄通道中相互阻塞；
  • 鲁棒性训练应考虑多种随机故障或硬件延迟，让系统在意外情况中仍能稳定调度。

2. 交通系统与城市管理

(1) 智能交通信号灯控制

• 需求背景：市内多路口信号灯需要同时决策红绿灯时长或相位切换，目标是最大化全局车辆通行效率、最小化拥堵。
• 多智能体价值分解：
  • 全局奖励可以是“全城平均等待时长”或“车辆累计排队长度”。使用价值分解算法（如 QMIX）对每个路口建立一个局部 Q 函数；
  • 保证每个路口在分散执行时，都能朝着降低全城拥堵的方向调整灯时。
• 层次化：
  • 城市中可按行政区或道路网划分，先让高层策略在不同区域间分配“绿波优先级”，低层具体信号灯执行微调。
• 安全与鲁棒性：
  • 需要在极端高峰或紧急事故时维持较好通行能力；
  • 若部分路口监控数据缺失，系统仍需做出相对合理的灯控决策。

(2) 城市应急响应与资源调度

• 需求背景：抢险救灾场景下，多类应急车辆（消防、救护、电力维修、警务）需要协同完成城市范围内的事故处理。
• 价值分解：
  • 全局目标：最短时间内消除灾情，最小化人员伤亡与财产损失；
  • 通过价值分解给每类车辆一个局部 Q 函数，解决“哪辆车先去哪个地点”以及“车队如何协同分工”的问题。
• 人机协作：
  • 指挥官在高层人工决策（如确定优先保护哪些关键区域），RL 在低层具体分配车辆任务路线；
  • 强调安全与鲁棒性（地形破坏、通讯不稳定等突发情况），需要在算法中引入约束或鲁棒训练机制。

3. 军事与安防

(1) 多无人机/无人车编队作战

• 需求背景：在军事或安防场景中，多无人机需要对目标区域进行侦察、监视或进攻协同，敌方可能有对抗或干扰。
• 价值分解 + 协同决策：
  • 不同无人机在局部观测下学到最优编队阵型或火力覆盖，全局奖励衡量整体任务成效；
  • QMIX 常用于军事仿真环境（与 SMAC 类似），解决多机协同火力打击或干扰规避。
• 安全性与鲁棒性：
  • 对抗敌方干扰、传感器失效或 GPS 信号堵塞等；
  • 考虑最坏情况或不确定对手策略时需要“最小最大优化”或“domain randomization”。

(2) 边境巡逻安保 / 智能巡检

• 需求背景：多个机器人或无人车在海陆边境、化工厂管道等地协同巡检，及时发现异常并报警。
• 元强化学习：
  • 当巡逻任务地点变换或突发新的威胁模式时，智能体能快速适应；
• 层次化：
  • 高层决定巡逻路径和分区策略，低层进行自主规避障碍、处理突发事件。

4. 金融交易与经济系统

(1) 多策略交易商协同 / 对抗

• 需求背景：在金融市场中，不同交易商或基金在同一市场中进行撮合交易，有时需要达成协作（联盟报价），有时竞争对手使市场波动。
• 价值分解：
  • 若是同一母基金下的不同子账户策略，需要协同完成某个全局投资目标（如对冲风险、稳定收益）；
  • 通过 VDN / QMIX 分配各子账户操作，减少内部互相博弈导致的收益浪费。
• 安全性与鲁棒性：
  • 金融市场噪声极大，政策或行情的极端变化需要算法具备鲁棒性和快速自适应。

(2) 拍卖与博弈

• 需求背景：多个拍卖方协同参与大规模竞价，想要达到某种联盟最优；或多智能体同时在电力市场、期货市场做分配；
• 协同决策：
  • 若拍卖方属于同一集团或共享部分收益，可用价值分解方法在竞价策略上互相让利，提高整体收益。
• 元学习：
  • 市场环境变化迅速（新对手、监管政策、需求变化），通过元学习降低每次重新训练的成本。

5. 医疗与公共健康

(1) 多医生 / 多智能体诊疗决策

• 需求背景：一个病人在住院期间，来自呼吸科、心内科、外科等多个科室需要协同诊疗；
• 价值分解：
  • 设定全局健康指标或治愈进程作为奖励，各科室 Agent 在分散观测病情下做协作诊疗决策（用药、手术时机、检查安排）；
• 安全与伦理：
  • 医疗领域有强安全和伦理要求，需要在策略中内置安全约束、对高风险操作进行限制或人工确认。

(2) 流行病传播模拟 & 防控策略

• 需求背景：在传染病爆发时，多个城市/区域卫生部门需要协同决策，如封锁措施、物资分配、人员流动限制等；
• 人机协作：
  • 高层政府人员在关键节点做指令，RL 提供动态优化方案（资源调配、优先救助）；
• 层次化：
  • 先在国家层面分配总预算、关键药物生产/分发策略，再由各区域低层策略执行筛查与防控。

6. 游戏与虚拟环境

(1) 大规模实时策略游戏 (RTS)

• 需求背景：如星际争霸、刀塔等多人即时策略游戏中，有成百上千个单位协同或对抗；
• 价值分解 + 协同决策：
  • 在科研和工业上常作为多智能体算法测试台，如 SMAC 场景中测试 QMIX、QTRAN 等；
  • 若引入层次化 RL，可让高层管理宏观战略，低层执行微操。

(2) 人机混合对战

• 需求背景：在对战游戏中，让 AI 作为队友与真人玩家协作（CO-OP 模式），实时做出与玩家策略相符的配合；
• 元学习：
  • AI 可能需要快速适应不同玩家风格，并在几分钟的对局中“学会”如何与玩家 best synergy；
• 可解释交互：
  • 向玩家简单地展示 AI 的意图（如在小地图上高亮目标），减少误解或配合失误。

通过以上场景可以看出，“多智能体价值分解 + 协同决策”在多机器人制造、智能交通、应急救灾、军事安防、金融博弈、医疗诊疗、游戏娱乐等领域都具备广泛且深远的应用价值。而进一步结合层次化强化学习、元强化学习、安全鲁棒性以及人机协作，可以有效应对更大规模、更复杂约束、更频繁变化的现实问题，也能更好地满足工业和公共领域对于效率、安全、可解释、合规的多重需求。

在实施层面，需要定制化地搭建合适的仿真或真实环境，并在价值分解算法之上引入分层调度、快速任务切换、安全边界控制、人机接口等多方面的工程化模块，才能真正将多智能体强化学习从论文走向落地项目，为实际业务或社会场景产生可观的价值。

应急响应与资源调度示例代码

import numpy as np
import random
import torch
import torch.nn as nn
import torch.optim as optim
from typing import Dict, List, Tuple
from pettingzoo.utils import ParallelEnv
from collections import deque
import copy

###############################################################
# 城市应急响应与资源调度多智能体强化学习项目
# 主要特性：
# 1. 多类型智能体（消防车、救护车、警车、维修队、指挥官）
# 2. 动态环境变化（火势蔓延、道路损坏）
# 3. 多目标奖励（效率、安全、成本）
# 4. 价值分解算法（VDN、QMIX）
# 5. 集中训练，分散执行（CTDE）框架
###############################################################

# 环境定义
class UrbanEmergencyResponseEnv(ParallelEnv):
    """
    城市应急响应与资源调度环境
    多智能体并行决策，支持消防车、救护车、警车、维修队及指挥官等多类型智能体
    """
    
    metadata = {"render_modes": ["human"], "name": "UrbanEmergencyResponseEnv_v1"}

    def __init__(self):
        super().__init__()
        # 定义智能体
        self.agents = [
            "commander_fire",
            "commander_medical",
            "firetruck_ai_1",
            "firetruck_ai_2",
            "ambulance_ai_1",
            "ambulance_ai_2",
            "police_ai_1",
            "police_ai_2",
            "repaircrew_ai_1",
            "repaircrew_ai_2"
        ]
        self.num_agents = len(self.agents)
        
        # 地图参数
        self.grid_size = 20  # 城市地图为20x20网格
        self.max_timestep = 100  # 最大时间步数
        self.timestep = 0

        # 火灾点、伤员点、道路损坏
        self.map_state = None  # 0=空地, 1=火灾, 2=伤员, 3=道路损坏

        # 智能体位置初始化
        self.initial_positions = {
            "commander_fire": (0, 0),
            "commander_medical": (0, 1),
            "firetruck_ai_1": (19, 19),
            "firetruck_ai_2": (18, 19),
            "ambulance_ai_1": (19, 18),
            "ambulance_ai_2": (18, 18),
            "police_ai_1": (17, 19),
            "police_ai_2": (17, 18),
            "repaircrew_ai_1": (16, 19),
            "repaircrew_ai_2": (16, 18)
        }
        self.positions = copy.deepcopy(self.initial_positions)
        
        # 智能体状态
        self._dones = {agent: False for agent in self.agents}
        self._rewards = {agent: 0.0 for agent in self.agents}
        self._infos = {agent: {} for agent in self.agents}
        
        # 动作空间定义
        # 0=UP, 1=RIGHT, 2=DOWN, 3=LEFT, 4=ACTION, 5=NOOP
        self.action_space = {agent: 6 for agent in self.agents}
        
        # 观测空间定义
        # 每个智能体的观测包含地图信息 + 自身位置
        self.obs_dim = self.grid_size * self.grid_size + 2  # 平铺地图 + x, y 坐标

    def reset(self, seed=None, return_info=False, options=None):
        """
        重置环境，随机生成火灾、伤员、道路损坏
        """
        self.timestep = 0
        # 初始化地图
        self.map_state = np.zeros((self.grid_size, self.grid_size), dtype=np.int32)
        
        # 随机放置火灾点
        num_fires = random.randint(5, 10)
        for _ in range(num_fires):
            x, y = random.randint(0, self.grid_size -1), random.randint(0, self.grid_size -1)
            self.map_state[x, y] = 1  # 火灾
        
        # 随机放置伤员点
        num_casualties = random.randint(5, 10)
        for _ in range(num_casualties):
            x, y = random.randint(0, self.grid_size -1), random.randint(0, self.grid_size -1)
            if self.map_state[x, y] == 0:
                self.map_state[x, y] = 2  # 伤员
        
        # 随机道路损坏
        num_damaged_roads = random.randint(5, 10)
        for _ in range(num_damaged_roads):
            x, y = random.randint(0, self.grid_size -1), random.randint(0, self.grid_size -1)
            if self.map_state[x, y] == 0:
                self.map_state[x, y] = 3  # 道路损坏
        
        # 重置智能体位置
        self.positions = copy.deepcopy(self.initial_positions)
        
        # 重置状态
        self._dones = {agent: False for agent in self.agents}
        self._rewards = {agent: 0.0 for agent in self.agents}
        self._infos = {agent: {} for agent in self.agents}
        
        return self._generate_obs_dict()

    def step(self, actions: Dict[str, int]):
        """
        执行所有智能体的动作，并更新环境状态
        """
        self.timestep += 1
        
        # 清空旧奖励
        self._rewards = {agent: 0.0 for agent in self.agents}
        
        # 执行各智能体动作
        for agent, action in actions.items():
            if self._dones[agent]:
                continue
            self._execute_action(agent, action)
        
        # 环境动态变化
        self._spread_fire()
        self._damage_roads()
        
        # 计算多目标奖励（效率、安全、成本）
        self._compute_rewards()
        
        # 检查是否完成
        if self._all_tasks_done() or self.timestep >= self.max_timestep:
            for agent in self.agents:
                self._dones[agent] = True
        
        obs_dict = self._generate_obs_dict()
        rew_dict = self._rewards.copy()
        done_dict = self._dones.copy()
        info_dict = self._infos.copy()
        
        return obs_dict, rew_dict, done_dict, info_dict

    def _generate_obs_dict(self) -> Dict[str, np.ndarray]:
        """
        生成每个智能体的观测字典
        """
        obs_dict = {}
        for agent in self.agents:
            obs_dict[agent] = self._get_observation(agent)
        return obs_dict

    def _get_observation(self, agent: str) -> np.ndarray:
        """
        获取单个智能体的观测
        包含平铺的地图状态和自身的位置信息
        """
        map_flat = self.map_state.flatten().astype(np.float32)
        pos = self.positions[agent]
        obs = np.concatenate([map_flat, np.array(pos, dtype=np.float32)])
        return obs

    def _execute_action(self, agent: str, action: int):
        """
        根据智能体的动作更新位置或执行操作
        动作定义：
        0=UP, 1=RIGHT, 2=DOWN, 3=LEFT, 4=ACTION, 5=NOOP
        """
        x, y = self.positions[agent]
        base_reward = 0.0  # 基础奖励
        
        if action == 0 and x > 0:
            if self.map_state[x-1, y] != 3:  # 道路未损坏
                x -= 1
        elif action == 1 and y < self.grid_size -1:
            if self.map_state[x, y+1] != 3:
                y += 1
        elif action == 2 and x < self.grid_size -1:
            if self.map_state[x+1, y] != 3:
                x += 1
        elif action == 3 and y > 0:
            if self.map_state[x, y-1] != 3:
                y -= 1
        elif action == 4:
            # 执行具体操作
            tile = self.map_state[x, y]
            if "firetruck" in agent and tile == 1:
                self.map_state[x, y] = 0  # 扑灭火灾
                base_reward += 10.0  # 效率奖励
            elif "ambulance" in agent and tile == 2:
                self.map_state[x, y] = 0  # 救助伤员
                base_reward += 10.0
            elif "repaircrew" in agent and tile == 3:
                self.map_state[x, y] = 0  # 修复道路
                base_reward += 5.0
            elif "police" in agent:
                base_reward += 2.0  # 维持秩序，安全奖励
            elif agent.startswith("commander"):
                base_reward += 1.0  # 指挥奖励
        elif action == 5:
            pass  # NOOP
        
        # 更新位置
        self.positions[agent] = (x, y)
        # 更新奖励
        self._rewards[agent] += base_reward

    def _spread_fire(self):
        """
        模拟火势蔓延，每个火灾点有一定概率点燃相邻格子
        """
        new_fires = []
        directions = [(-1,0),(1,0),(0,-1),(0,1)]
        for x in range(self.grid_size):
            for y in range(self.grid_size):
                if self.map_state[x, y] == 1:
                    for dx, dy in directions:
                        nx, ny = x + dx, y + dy
                        if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size:
                            if self.map_state[nx, ny] == 0 and random.random() < 0.1:
                                new_fires.append((nx, ny))
        for (fx, fy) in new_fires:
            self.map_state[fx, fy] = 1

    def _damage_roads(self):
        """
        随机损坏部分道路，影响智能体移动
        """
        for _ in range(2):
            rx, ry = random.randint(0, self.grid_size -1), random.randint(0, self.grid_size -1)
            if self.map_state[rx, ry] == 0 and random.random() < 0.05:
                self.map_state[rx, ry] = 3

    def _compute_rewards(self):
        """
        计算多目标奖励，包括效率、安全、成本
        """
        # 效率奖励已经在执行动作时计算
        # 安全奖励：若有未处理的火灾或伤员，扣除安全分
        num_fires = np.sum(self.map_state == 1)
        num_casualties = np.sum(self.map_state == 2)
        safety_penalty = (num_fires + num_casualties) * 1.0  # 每个未处理点扣1分
        
        for agent in self.agents:
            self._rewards[agent] -= safety_penalty  # 安全性惩罚
            # 成本奖励：行动消耗资源，假设每个行动扣0.1分
            # 可以根据具体需求调整
            # 这里只简单示范，每个行动扣0.1
            # 若action == 5 (NOOP) 则不扣
            # 需要在 execute_action 中记录每个智能体的动作类型
            # 这里简化为所有非NOOP动作均扣0.1
            # 假设在 execute_action 中已经记录了是否执行了动作
            # 这里略过，直接扣0.1
            self._rewards[agent] -= 0.1

    def _all_tasks_done(self) -> bool:
        """
        判断所有火灾和伤员是否已处理
        """
        if np.sum(self.map_state == 1) == 0 and np.sum(self.map_state == 2) == 0:
            return True
        return False

    def render(self, mode="human"):
        """
        简单渲染地图与智能体位置
        """
        print(f"\n--- Timestep {self.timestep} ---")
        grid_display = np.full((self.grid_size, self.grid_size), '.', dtype=str)
        grid_display[self.map_state == 1] = '

标签：dim,self,高级,agent,智能,state,agents,强化,size	

From： https://blog.csdn.net/cxr828/article/details/145068808