应急管理响应决策智能体
1. 功能定位
决策智能体在应急场景中扮演“政府指挥中枢”或“联合指挥部”角色，负责整合多源数据、统筹跨部门资源，并下达关键指令。它的精确度与及时性对整体救援成效和灾害应对速度具有决定性影响。
-
宏观指挥核心
- 全局视角：实时汇总灾情（洪水范围、地震烈度、火情位置）、物资库存、交通负载、舆情指标等信息；
- 多智能体协作：根据策略或规则，对资源执行智能体、对抗智能体的防御环节、舆情管理子系统等发布指令；
- 跨级别应急部署：在本地灾害无法独立应对时，自动向上级或邻近区域发出支援请求，形成应急联动。
-
跨部门联动（可选扩展）
- 子智能体划分：在高度复杂场景可拆分为“交通指挥子智能体”“医疗应急子智能体”“电力保障子智能体”等，分别负责专业领域的指令；
- 统一决策层：最高层由“政府主决策智能体”进行综合调度、冲突管理及优先级划分，保证指令不相互冲突或浪费资源。
-
可扩展指令范围
- 传统应急命令：预警发布、人员疏散、交通管制；
- 经济与社会稳定措施：燃油与物价管控、谣言辟谣、警力部署；
- 区域/跨国合作：在特大灾难或跨区域危机时，发起跨区物资调拨、国际救援协议等高级指令。
2. 内部数据结构与状态空间
决策智能体在每个仿真时步或关键事件（如堤坝超限、强余震）中，需要基于最新灾情态势和历史决策记录做应急动作。其状态可分为以下五个维度：
-
灾害态势信息
- 物理灾情：洪水水位、地震烈度、火灾蔓延范围、余震概率等；
- 次生灾害预警：泥石流、堤坝破裂、化工泄漏、疫情扩散；
- 地理分区：标记高风险地区（低洼地、断层带、人口密集区）及关键基础设施（医院、电网、交通枢纽）。
-
资源可用性
- 物资库存：各仓库或应急中心储备的食品、药品、器材数量及保质期；
- 人力/设备：应急车辆、无人机、工程抢险队、消防、医疗人员、志愿者；
- 物流/补给链：通畅或受损的交通线路、跨区支援能力，保证远程物资可及时调度。
-
社会舆情与公众行为
- 恐慌度：按区域统计公众情绪；
- 舆情指数：监控谣言扩散或负面舆论高峰；
- 交通状况：拥堵路段、公共交通负载率、临时封闭区域等。
-
历史指令与执行反馈
- 已发出指令清单：每次管制、预警、撤离命令都详细记录发布时间、目标范围；
- 执行效果：资源执行智能体回传完成度、遇到的障碍（道路损坏、物资不足、车辆故障等）；
- 失败或滞后指令：对因通信延误、审批阻碍造成的指令失效做标记，方便下一时步补救。
-
内部记忆或模型参数
- 策略网络/规划算法：若使用强化学习或规划算法，此处存储网络权重、启发式搜索表或元学习元策略；
- 跨场景历史：在多灾种训练下，可能留存洪水、地震、火灾等类型对应的策略快照。
3. 动作空间与指令执行流程
决策智能体可对外发布多维度指令，其粒度与优先级决定了资源执行智能体的操作步骤及公众响应。
-
动作类型分类
- 早期预警与公共发布
- 预警分级：蓝/黄/橙/红或本地更细分；
- 信息渠道：短信、广播、电视、社交媒体，保障覆盖不同年龄层与地理区域。
- 疏散与管控
- 区域撤离命令：指定撤离顺序、优先帮扶特殊人群（老人、病患）；
- 道路管制：封闭或改道绕行，设立单向通行方案，避免双向拥堵；
- 避难所分配：人群分流策略，避免单个避难所过度拥挤。
- 资源调度与支援
- 物资调用：调配粮食、药品、抢险器材；
- 人力/装备：派遣救援队、无人机、直升机、工程机械至指定地点；
- 跨部门协调：通知交通、医疗、电力、通信、公安等部门开展联合行动。
- 经济与社会稳定措施（可选）
- 价格/燃油管控：临时冻结物价或限制燃油销售；
- 舆情干预：媒体辟谣、专家解读，对谣言高发区域强化警力巡控。
- 早期预警与公共发布
-
指令层级与优先级
- 普通指令：如临时封闭小街巷或调用少量物资；
- 高级指令：跨部门或跨区域的大规模征用、强制性命令；
- 紧急指令：在极端状况下可跳过审批，但可能带来更高社会或政治风险。
-
执行周期与反馈回路
- 时步/事件触发：基于仿真时间步（如每 5 分钟）或重大事件（堤坝决口、余震）更新指令；
- 资源执行智能体响应：执行方及时返回进度、遇阻信息，决策智能体实时修正策略；
- 人机协同：在实际指挥体系中，专家或领导可对自动建议进行微调或否决。
4. 决策逻辑与算法实现
-
规则/专家系统
- 基线规则库：对常见灾害与应急预案做硬编码，如洪水红色预警需封闭特定闸口；
- 触发条件：根据交通拥堵度、公众恐慌度等多因子设定自动阈值，一旦超限则执行对应指令。
-
规划/调度算法
- 混合整数规划（MIP）：在资源有限情况下寻优，保证最短救援时间或最低损耗；
- 启发式搜索：遗传算法、Tabu 搜索等对复杂或动态变动的物资调配问题做近似求解。
-
（元）强化学习策略
- Actor-Critic：基于当前态势评估动作分布；
- 层次式 RL：分高层（发布预警、大规模调度）与低层（局部交通管控、局部资源分配）；
- 场景自适应：在不同灾种或新地形能快速迁移策略，减少训练周期。
5. 协同与安全机制
决策智能体拥有“最高权限”，需要严格的安全与协同设计来避免失控或冲突指令。
-
跨智能体协同
- 数据汇聚标准：通过消息队列或共享内存收集资源执行智能体等状态；
- 冲突检测：如果多条指令冲突（两方都申请同一物资），需自动分配或强制优先级判断；
- 同步节点：在关键时段统一汇报资源占用与放还信息，避免重叠浪费。
-
人工干预与审批流程
- 人机协同接口：领导或专家对系统指令有审签权，对重大决策保留“最后拍板”；
- 审批/延时模拟：针对极端指令（全面封城、跨省军队征调）可以模拟审批时间与不同级别授权流程。
-
安全回退策略
- 指令撤销：若检测到下达指令造成严重后果，可及时撤销；
- 自动切换备用策略：若检测到决策网络出现异常（例如误判灾情范围），可启动前一个稳定版本策略或人工接管。
6. 评价与可视化
-
决策效果指标
- 效率：疏散完成时间、救援覆盖率；
- 安全：伤亡人数、二次灾害引发率；
- 资源成本：物资损耗、财政支出；
- 社会稳定：舆情负面度、交通瘫痪时长。
-
可视化与人机接口
- 指令大屏：可视化已发出指令、执行进度、地图标注受灾区域与管制路段；
- 模拟回放：灾情演化+指令时序回溯，观察关键节点决策效果；
- 交互式编辑：专家可拖拽或微调方案（如更改撤离路线、调配其他仓库物资）与系统建议进行对比。
7. 代码目录
emergency_decision_agent/
├── config/
│ ├── base_config.yaml
│ ├── disaster_types.yaml
│ ├── agent_parameters.yaml
│ ├── logging_config.yaml
│ └──
├── data/
│ ├── raw/
│ │ ├── historical_cases/
│ │ ├── synthetic_cases/
│ │ └──
│ ├── processed/
│ │ ├── disaster_maps/
│ │ ├── resource_status/
│ │ └──
│ └── external/
│ ├── weather_forecast/
│ └──
├── models/
│ ├── policy_network/
│ │ ├── __init__.py
│ │ ├── architecture.py
│ │ ├── training.py
│ │ └── utils.py
│ ├── value_network/
│ │ ├── __init__.py
│ │ ├── architecture.py
│ │ ├── training.py
│ │ └── utils.py
│ └──
├── agents/
│ ├── decision_agent/
│ │ ├── __init__.py
│ │ ├── decision_logic.py
│ │ ├── command_dispatcher.py
│ │ ├── state_monitor.py
│ │ └── utils.py
│ ├── resource_execution_agent/
│ │ ├── __init__.py
│ │ ├── execution_logic.py
│ │ ├── status_feedback.py
│ │ └── utils.py
│ ├── adversarial_agent/
│ │ ├── __init__.py
│ │ ├── attack_strategy.py
│ │ ├── disruption_logic.py
│ │ └── utils.py
│ ├── disaster_agent/
│ │ ├── __init__.py
│ │ ├── disaster_evolution.py
│ │ ├── scenario_generator.py
│ │ └── utils.py
│ └──
├── utils/
│ ├── data_processing.py
│ ├── logging.py
│ ├── visualization.py
│ ├── metrics.py
│ ├── config_loader.py
│ └──
├── simulation/
│ ├── environment.py
│ ├── event_handler.py
│ ├── interaction_manager.py
│ └──
├── visualization/
│ ├── dashboard.py
│ ├── replay_player.py
│ ├── interactive_editor.py
│ └──
├── tests/
│ ├── unit/
│ │ ├── test_decision_logic.py
│ │ ├── test_execution_logic.py
│ │ └──
│ ├── integration/
│ │ ├── test_agent_interaction.py
│ │ └──
│ └──
├── scripts/
│ ├── train_policy.sh
│ ├── deploy_agent.sh
│ └──
├── docs/
│ ├── architecture.md
│ ├── user_guide.md
│ ├── developer_guide.md
│ └──
├── logs/
│ ├── decision_agent/
│ │ ├── decision.log
│ │ └──
│ ├── resource_execution_agent/
│ │ ├── execution.log
│ │ └──
│ └──
├── configs/
│ ├── disaster_config.yaml
│ ├── resource_config.yaml
│ └──
├── notebooks/
│ ├── data_analysis.ipynb
│ ├── model_training.ipynb
│ └──
├── docker/
│ ├── Dockerfile.decision_agent
│ ├── Dockerfile.resource_execution_agent
│ ├── docker-compose.yml
│ └──
├── .github/
│ └── workflows/
│ ├── ci.yml
│ └── cd.yml
├── requirements.txt
├── setup.py
├── README.md
├── LICENSE
└── .gitignore
8. 主要代码
8.1. base_config.yaml
功能：定义项目的基础配置，包括全局参数、环境设置和默认策略等。这些配置作为其他配置文件的基础，确保统一性与一致性。
# base_config.yaml
# 基础配置文件，定义全局参数和默认设置
# 全局参数
global:
simulation:
time_step: 300 # 仿真时间步长（秒），例如每5分钟更新一次
max_steps: 10000 # 仿真最大步数，防止无限循环
seed: 42 # 随机种子，确保可复现性
logging:
level: INFO # 日志级别（DEBUG, INFO, WARNING, ERROR, CRITICAL）
format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
handlers:
console:
class: logging.StreamHandler
level: INFO
formatter: standard
file:
class: logging.FileHandler
level: DEBUG
formatter: detailed
filename: logs/system.log
resources:
default_supply_rate: 10 # 默认资源补给速率（单位：物资/时间步）
# 环境设置
environment:
geographic:
regions:
- name: RegionA
type: urban
population: 100000
critical_infrastructure:
- hospital
- power_plant
- communication_hub
- name: RegionB
type: rural
population: 50000
critical_infrastructure:
- water_treatment
- agricultural_facilities
disaster_types:
- flood
- earthquake
- wildfire
- chemical_spill
# 默认策略
strategies:
evacuation_priority: ["elderly", "children", "disabled", "general_population"]
resource_allocation:
priority_regions:
- RegionA
- RegionB
default_allocation: 50 # 默认分配比例（%）给优先区域
communication:
channels:
- sms
- radio
- social_media
- public_address_system
8.2. disaster_types.yaml
功能：定义不同灾害类型的特定参数，包括灾害的触发条件、影响范围、持续时间等。这些配置帮助决策智能体根据具体灾害类型制定相应的应对策略。
# disaster_types.yaml
# 不同灾害类型的特定配置
disaster_types:
flood:
trigger_conditions:
rainfall_intensity: ">200 mm/24h" # 降雨强度触发条件
river_level: ">5 meters" # 河流水位触发条件
impact:
regions_affected: ["RegionA", "RegionB"]
infrastructure_damage:
power_plant: "high"
communication_hub: "medium"
hospital: "low"
population_affected: 80% # 受灾人口比例
duration: 86400 # 持续时间（秒），例如1天
secondary_effects:
- "waterborne_diseases"
- "economic_loss"
earthquake:
trigger_conditions:
magnitude: ">7.0" # 地震震级触发条件
depth: "<10 km" # 地震深度触发条件
impact:
regions_affected: ["RegionA"]
infrastructure_damage:
power_plant: "critical"
communication_hub: "critical"
hospital: "high"
population_affected: 60%
duration: 3600 # 持续时间（秒），例如1小时
secondary_effects:
- "aftershocks"
- "tsunami"
wildfire:
trigger_conditions:
temperature: ">40°C"
humidity: "<20%"
wind_speed: ">30 km/h"
impact:
regions_affected: ["RegionB"]
infrastructure_damage:
agricultural_facilities: "high"
communication_hub: "low"
population_affected: 30%
duration: 43200 # 持续时间（秒），例如12小时
secondary_effects:
- "air_quality_degradation"
- "wildlife_displacement"
chemical_spill:
trigger_conditions:
accident_type: "industrial"
quantity: ">1000 liters"
impact:
regions_affected: ["RegionA"]
infrastructure_damage:
water_treatment: "critical"
hospital: "high"
population_affected: 50%
duration: 7200 # 持续时间（秒），例如2小时
secondary_effects:
- "environmental_pollution"
- "public_health_crisis"
8.3. agent_parameters.yaml
功能：定义决策智能体及其他智能体的行为参数，如学习率、决策阈值、资源分配策略等。这些参数控制智能体的学习过程与决策行为，影响其在不同灾害情景下的响应效果。
# agent_parameters.yaml
# 智能体行为参数配置
agents:
decision_agent:
learning_rate: 0.001 # 学习率
discount_factor: 0.99 # 折扣因子
exploration_rate:
initial: 1.0
min: 0.1
decay: 0.995
policy_network:
architecture: "actor_critic" # 策略网络架构（如 actor_critic, q_learning）
hidden_layers: [256, 128] # 隐藏层神经元数量
activation: "relu" # 激活函数
value_network:
architecture: "critic" # 价值网络架构
hidden_layers: [256, 128]
activation: "relu"
resource_allocation_strategy: "priority_based" # 资源分配策略（priority_based, equal_distribution, etc.）
resource_execution_agent:
response_time: 60 # 响应时间步长（秒）
efficiency: 0.9 # 执行效率（0-1）
failure_rate: 0.05 # 执行失败率
recovery_time: 300 # 资源恢复时间步长（秒）
capacity_limits:
vehicles: 100
drones: 50
medical_units: 20
adversarial_agent:
learning_rate: 0.002
discount_factor: 0.95
exploration_rate:
initial: 1.0
min: 0.05
decay: 0.99
attack_priority: ["critical_infrastructure", "resource_supply", "communication_network"]
attack_methods:
critical_infrastructure:
- "power_grid_attack"
- "bridge_destruction"
- "hospital_disruption"
resource_supply:
- "warehouse_blockade"
- "fuel_supply_cutoff"
communication_network:
- "data_system_hack"
- "gps_jamming"
disaster_agent:
scenario_generation_rate: 0.1 # 新场景生成频率（每步概率）
max_scenarios: 10 # 同时存在的最大灾害场景数
scenario_complexity:
max_disasters_per_region: 3
min_intensity: 0.5
max_intensity: 1.0
# 其他全局智能体参数
global_agents:
logging:
level: DEBUG
format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
8.4. logging_config.yaml
功能：配置项目的日志记录系统，包括日志级别、格式、处理器（控制台与文件）等。确保系统运行中的关键信息、警告与错误能被及时记录与追踪。
# logging_config.yaml
# 日志记录配置文件
version: 1
disable_existing_loggers: False
formatters:
standard:
format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
detailed:
format: "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
handlers:
console:
class: logging.StreamHandler
level: INFO
formatter: standard
stream: ext://sys.stdout
file:
class: logging.FileHandler
level: DEBUG
formatter: detailed
filename: logs/system_debug.log
mode: a
encoding: utf-8
error_file:
class: logging.FileHandler
level: ERROR
formatter: detailed
filename: logs/system_errors.log
mode: a
encoding: utf-8
loggers:
emergency_decision_agent:
level: DEBUG
handlers: [console, file, error_file]
propagate: no
agents.decision_agent:
level: DEBUG
handlers: [console, file, error_file]
propagate: no
agents.resource_execution_agent:
level: DEBUG
handlers: [console, file, error_file]
propagate: no
agents.adversarial_agent:
level: DEBUG
handlers: [console, file, error_file]
propagate: no
agents.disaster_agent:
level: DEBUG
handlers: [console, file, error_file]
propagate: no
root:
level: WARNING
handlers: [console]
8.5.1 emergency_protocols.yaml
功能：定义各类灾害情况下的应急响应协议，包括指令触发条件、应对措施及优先级。
# emergency_protocols.yaml
# 各类灾害应急响应协议
protocols:
flood:
trigger:
rainfall_intensity: ">200 mm/24h"
river_level: ">5 meters"
actions:
- type: "evacuation"
priority: "high"
target_regions: ["RegionA", "RegionB"]
- type: "resource_allocation"
priority: "high"
resources:
- "medical_supplies"
- "food_reserves"
- type: "infrastructure_protection"
priority: "medium"
targets:
- "power_grid"
- "communication_hub"
earthquake:
trigger:
magnitude: ">7.0"
depth: "<10 km"
actions:
- type: "evacuation"
priority: "critical"
target_regions: ["RegionA"]
- type: "resource_allocation"
priority: "critical"
resources:
- "rescue_teams"
- "medical_units"
- type: "infrastructure_repair"
priority: "high"
targets:
- "bridges"
- "roads"
wildfire:
trigger:
temperature: ">40°C"
humidity: "<20%"
wind_speed: ">30 km/h"
actions:
- type: "fire_fighting"
priority: "high"
target_regions: ["RegionB"]
- type: "public_warning"
priority: "medium"
channels:
- "sms"
- "social_media"
- type: "resource_allocation"
priority: "medium"
resources:
- "fire_fighting_equipment"
chemical_spill:
trigger:
accident_type: "industrial"
quantity: ">1000 liters"
actions:
- type: "evacuation"
priority: "high"
target_regions: ["RegionA"]
- type: "contamination_control"
priority: "critical"
methods:
- "containment_barricades"
- "decontamination_units"
- type: "public_health_response"
priority: "critical"
resources:
- "medical_supplies"
- "healthcare_staff"
8.5.2 resource_limits.yaml
功能：设定各类资源在不同灾害情景下的使用限制，确保资源分配的合理性与效率。
# resource_limits.yaml
# 资源使用限制配置
resource_limits:
general:
max_allocation_per_step:
vehicles: 10
drones: 5
medical_units: 2
replenishment_rate:
vehicles: 2
drones: 1
medical_units: 0.5
usage_cost:
vehicles: 5 # 单位：资源点数/步
drones: 3
medical_units: 10
high_priority:
max_allocation_per_step:
vehicles: 20
drones: 10
medical_units: 5
replenishment_rate:
vehicles: 5
drones: 2
medical_units: 1
usage_cost:
vehicles: 10
drones: 6
medical_units: 20
critical:
max_allocation_per_step:
vehicles: 50
drones: 25
medical_units: 15
replenishment_rate:
vehicles: 10
drones: 5
medical_units: 2
usage_cost:
vehicles: 20
drones: 12
medical_units: 40
8.6.1 agent_hyperparameters.yaml
功能：定义智能体在训练过程中使用的超参数，如学习率、折扣因子、探索率等，便于灵活调整和优化。
# agent_hyperparameters.yaml
# 智能体训练过程中的超参数配置
agents:
decision_agent:
training:
learning_rate: 0.0005
discount_factor: 0.95
batch_size: 64
buffer_size: 100000
update_frequency: 4
tau: 0.01 # 软更新参数
exploration:
initial_epsilon: 1.0
min_epsilon: 0.05
decay_rate: 0.995
adversarial_agent:
training:
learning_rate: 0.001
discount_factor: 0.90
batch_size: 128
buffer_size: 200000
update_frequency: 2
tau: 0.005
exploration:
initial_epsilon: 1.0
min_epsilon: 0.01
decay_rate: 0.99
8.6.2 simulation_settings.yaml
功能：定义仿真环境的具体设置，如天气变化、地理特征、灾害触发频率等，确保仿真过程的真实与多样性。
# simulation_settings.yaml
# 仿真环境具体设置
simulation:
weather:
enable_dynamic_weather: true
weather_change_probability: 0.1 # 每个时间步天气变化的概率
weather_types:
- clear
- cloudy
- rainy
- stormy
- foggy
geography:
elevation_map: "data/processed/disaster_maps/elevation_map.png"
river_network: "data/processed/disaster_maps/river_network.geojson"
road_network: "data/processed/disaster_maps/road_network.geojson"
disaster_trigger:
flood:
frequency: 0.01 # 每个时间步触发洪水的概率
earthquake:
frequency: 0.005
wildfire:
frequency: 0.02
chemical_spill:
frequency: 0.003
random_events:
include:
- "power_outage"
- "communication_failure"
- "traffic_jam"
- "public_panic"
event_probability: 0.05 # 每个时间步发生随机事件的概率
9.1. models/policy_network/__init__.py
功能：初始化策略网络模块，方便在项目中导入各个组件。
# models/policy_network/__init__.py
from .architecture import PolicyNetwork
from .training import train_policy_network
from .utils import save_policy_model, load_policy_model
__all__ = [
"PolicyNetwork",
"train_policy_network",
"save_policy_model",
"load_policy_model",
]
9.2. models/policy_network/architecture.py
功能：定义策略网络的神经网络架构。策略网络负责输出在当前状态下采取各动作的概率分布。
# models/policy_network/architecture.py
import torch
import torch.nn as nn
import torch.nn.functional as F
class PolicyNetwork(nn.Module):
def __init__(self, state_dim, action_dim, hidden_layers=[256, 128]):
"""
初始化策略网络。
Args:
state_dim (int): 状态空间维度。
action_dim (int): 动作空间维度。
hidden_layers (list): 隐藏层神经元数量列表。
"""
super(PolicyNetwork, self).__init__()
layers = []
input_dim = state_dim
for hidden_dim in hidden_layers:
layers.append(nn.Linear(input_dim, hidden_dim))
layers.append(nn.ReLU())
input_dim = hidden_dim
self.hidden = nn.Sequential(*layers)
self.output = nn.Linear(input_dim, action_dim)
self.softmax = nn.Softmax(dim=-1)
def forward(self, state):
"""
前向传播。
Args:
state (torch.Tensor): 当前状态。
Returns:
torch.Tensor: 动作概率分布。
"""
x = self.hidden(state)
x = self.output(x)
action_probs = self.softmax(x)
return action_probs
9.3. models/policy_network/training.py
功能：实现策略网络的训练逻辑，使用策略梯度方法（如 REINFORCE）进行优化。
# models/policy_network/training.py
import torch
import torch.optim as optim
from torch.distributions import Categorical
from .architecture import PolicyNetwork
from .utils import save_policy_model, load_policy_model
def train_policy_network(policy_net, optimizer, episodes, gamma=0.99, log_interval=10):
"""
训练策略网络。
Args:
policy_net (PolicyNetwork): 策略网络实例。
optimizer (torch.optim.Optimizer): 优化器。
episodes (int): 训练的回合数。
gamma (float): 折扣因子。
log_interval (int): 日志记录间隔。
"""
policy_net.train()
for episode in range(1, episodes + 1):
state = env.reset() # 假设已定义环境 env
log_probs = []
rewards = []
done = False
while not done:
state = torch.FloatTensor(state).unsqueeze(0)
action_probs = policy_net(state)
m = Categorical(action_probs)
action = m.sample()
log_prob = m.log_prob(action)
next_state, reward, done, _ = env.step(action.item()) # 假设 action.item() 是合法动作
log_probs.append(log_prob)
rewards.append(reward)
state = next_state
# 计算回报
returns = []
G = 0
for r in reversed(rewards):
G = r + gamma * G
returns.insert(0, G)
returns = torch.FloatTensor(returns)
returns = (returns - returns.mean()) / (returns.std() + 1e-5)
# 计算损失
policy_loss = []
for log_prob, G in zip(log_probs, returns):
policy_loss.append(-log_prob * G)
policy_loss = torch.cat(policy_loss).sum()
# 更新网络
optimizer.zero_grad()
policy_loss.backward()
optimizer.step()
# 日志记录
if episode % log_interval == 0:
print(f"Episode {episode}\tLast reward: {rewards[-1]}")
print("Training completed.")
return policy_net
9.4. models/policy_network/utils.py
功能：提供策略网络的辅助功能，如模型保存与加载。
# models/policy_network/utils.py
import torch
from .architecture import PolicyNetwork
def save_policy_model(policy_net, filepath):
"""
保存策略网络模型。
Args:
policy_net (PolicyNetwork): 策略网络实例。
filepath (str): 保存路径。
"""
torch.save(policy_net.state_dict(), filepath)
print(f"Policy network saved to {filepath}")
def load_policy_model(state_dim, action_dim, filepath):
"""
加载策略网络模型。
Args:
state_dim (int): 状态空间维度。
action_dim (int): 动作空间维度。
filepath (str): 模型文件路径。
Returns:
PolicyNetwork: 加载后的策略网络实例。
"""
policy_net = PolicyNetwork(state_dim, action_dim)
policy_net.load_state_dict(torch.load(filepath))
policy_net.eval()
print(f"Policy network loaded from {filepath}")
return policy_net
9.5. models/value_network/__init__.py
功能：初始化价值网络模块，方便在项目中导入各个组件。
# models/value_network/__init__.py
from .architecture import ValueNetwork
from .training import train_value_network
from .utils import save_value_model, load_value_model
__all__ = [
"ValueNetwork",
"train_value_network",
"save_value_model",
"load_value_model",
]
9.6. models/value_network/architecture.py
功能：定义价值网络的神经网络架构。价值网络负责评估给定状态的价值。
# models/value_network/architecture.py
import torch
import torch.nn as nn
import torch.nn.functional as F
class ValueNetwork(nn.Module):
def __init__(self, state_dim, hidden_layers=[256, 128]):
"""
初始化价值网络。
Args:
state_dim (int): 状态空间维度。
hidden_layers (list): 隐藏层神经元数量列表。
"""
super(ValueNetwork, self).__init__()
layers = []
input_dim = state_dim
for hidden_dim in hidden_layers:
layers.append(nn.Linear(input_dim, hidden_dim))
layers.append(nn.ReLU())
input_dim = hidden_dim
self.hidden = nn.Sequential(*layers)
self.output = nn.Linear(input_dim, 1) # 输出单一的状态价值
def forward(self, state):
"""
前向传播。
Args:
state (torch.Tensor): 当前状态。
Returns:
torch.Tensor: 状态的价值评估。
"""
x = self.hidden(state)
state_value = self.output(x)
return state_value
9.7. models/value_network/training.py
功能：实现价值网络的训练逻辑，使用均方误差（MSE）损失进行优化。
# models/value_network/training.py
import torch
import torch.optim as optim
from .architecture import ValueNetwork
from .utils import save_value_model, load_value_model
def train_value_network(value_net, optimizer, episodes, gamma=0.99, log_interval=10):
"""
训练价值网络。
Args:
value_net (ValueNetwork): 价值网络实例。
optimizer (torch.optim.Optimizer): 优化器。
episodes (int): 训练的回合数。
gamma (float): 折扣因子。
log_interval (int): 日志记录间隔。
"""
value_net.train()
loss_fn = torch.nn.MSELoss()
for episode in range(1, episodes + 1):
state = env.reset() # 假设已定义环境 env
done = False
states = []
rewards = []
while not done:
state_tensor = torch.FloatTensor(state).unsqueeze(0)
value = value_net(state_tensor)
action = policy_net(state_tensor).multinomial(num_samples=1).item() # 假设已定义策略网络 policy_net
next_state, reward, done, _ = env.step(action)
states.append(state_tensor)
rewards.append(reward)
state = next_state
# 计算回报
returns = []
G = 0
for r in reversed(rewards):
G = r + gamma * G
returns.insert(0, G)
returns = torch.FloatTensor(returns).unsqueeze(1)
# 计算损失
values = torch.cat([value_net(s) for s in states])
loss = loss_fn(values, returns)
# 更新网络
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 日志记录
if episode % log_interval == 0:
print(f"Episode {episode}\tLoss: {loss.item():.4f}")
print("Training completed.")
return value_net
9.8. models/value_network/utils.py
功能：提供价值网络的辅助功能，如模型保存与加载。
# models/value_network/utils.py
import torch
from .architecture import ValueNetwork
def save_value_model(value_net, filepath):
"""
保存价值网络模型。
Args:
value_net (ValueNetwork): 价值网络实例。
filepath (str): 保存路径。
"""
torch.save(value_net.state_dict(), filepath)
print(f"Value network saved to {filepath}")
def load_value_model(state_dim, filepath):
"""
加载价值网络模型。
Args:
state_dim (int): 状态空间维度。
filepath (str): 模型文件路径。
Returns:
ValueNetwork: 加载后的价值网络实例。
"""
value_net = ValueNetwork(state_dim)
value_net.load_state_dict(torch.load(filepath))
value_net.eval()
print(f"Value network loaded from {filepath}")
return value_net
9.9.1 models/adversarial_network/__init__.py
# models/adversarial_network/__init__.py
from .architecture import AdversarialNetwork
from .training import train_adversarial_network
from .utils import save_adversarial_model, load_adversarial_model
__all__ = [
"AdversarialNetwork",
"train_adversarial_network",
"save_adversarial_model",
"load_adversarial_model",
]
9.9.2 models/adversarial_network/architecture.py
# models/adversarial_network/architecture.py
import torch
import torch.nn as nn
import torch.nn.functional as F
class AdversarialNetwork(nn.Module):
def __init__(self, state_dim, action_dim, hidden_layers=[256, 128]):
"""
初始化对抗网络。
Args:
state_dim (int): 状态空间维度。
action_dim (int): 动作空间维度。
hidden_layers (list): 隐藏层神经元数量列表。
"""
super(AdversarialNetwork, self).__init__()
layers = []
input_dim = state_dim + action_dim # 结合状态与动作
for hidden_dim in hidden_layers:
layers.append(nn.Linear(input_dim, hidden_dim))
layers.append(nn.ReLU())
input_dim = hidden_dim
self.hidden = nn.Sequential(*layers)
self.output = nn.Linear(input_dim, 1) # 输出对抗评分
def forward(self, state, action):
"""
前向传播。
Args:
state (torch.Tensor): 当前状态。
action (torch.Tensor): 当前动作。
Returns:
torch.Tensor: 对抗评分。
"""
x = torch.cat([state, action], dim=1)
x = self.hidden(x)
score = self.output(x)
return score
9.9.3 models/adversarial_network/training.py
# models/adversarial_network/training.py
import torch
import torch.optim as optim
from .architecture import AdversarialNetwork
from .utils import save_adversarial_model, load_adversarial_model
def train_adversarial_network(adversarial_net, optimizer, episodes, gamma=0.99, log_interval=10):
"""
训练对抗网络。
Args:
adversarial_net (AdversarialNetwork): 对抗网络实例。
optimizer (torch.optim.Optimizer): 优化器。
episodes (int): 训练的回合数。
gamma (float): 折扣因子。
log_interval (int): 日志记录间隔。
"""
adversarial_net.train()
loss_fn = torch.nn.BCEWithLogitsLoss()
for episode in range(1, episodes + 1):
state = env.reset() # 假设已定义环境 env
done = False
states = []
actions = []
adversarial_labels = []
while not done:
state_tensor = torch.FloatTensor(state).unsqueeze(0)
action_probs = policy_net(state_tensor) # 假设已定义策略网络 policy_net
m = torch.distributions.Categorical(action_probs)
action = m.sample()
log_prob = m.log_prob(action)
next_state, reward, done, _ = env.step(action.item())
states.append(state_tensor)
actions.append(action.unsqueeze(0))
adversarial_labels.append(torch.tensor([[1.0]])) # 假设对抗标签为1表示成功攻击
state = next_state
# 计算对抗评分
scores = adversarial_net(torch.cat(states), torch.cat(actions))
labels = torch.cat(adversarial_labels)
# 计算损失
loss = loss_fn(scores, labels)
# 更新网络
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 日志记录
if episode % log_interval == 0:
print(f"Episode {episode}\tAdversarial Loss: {loss.item():.4f}")
print("Adversarial training completed.")
return adversarial_net
9.9.4 models/adversarial_network/utils.py
# models/adversarial_network/utils.py
import torch
from .architecture import AdversarialNetwork
def save_adversarial_model(adversarial_net, filepath):
"""
保存对抗网络模型。
Args:
adversarial_net (AdversarialNetwork): 对抗网络实例。
filepath (str): 保存路径。
"""
torch.save(adversarial_net.state_dict(), filepath)
print(f"Adversarial network saved to {filepath}")
def load_adversarial_model(state_dim, action_dim, filepath):
"""
加载对抗网络模型。
Args:
state_dim (int): 状态空间维度。
action_dim (int): 动作空间维度。
filepath (str): 模型文件路径。
Returns:
AdversarialNetwork: 加载后的对抗网络实例。
"""
adversarial_net = AdversarialNetwork(state_dim, action_dim)
adversarial_net.load_state_dict(torch.load(filepath))
adversarial_net.eval()
print(f"Adversarial network loaded from {filepath}")
return adversarial_net
10.1.1 agents/decision_agent/__init__.py
功能：初始化决策智能体模块，便于在项目中导入各个组件。
# agents/decision_agent/__init__.py
from .decision_logic import DecisionLogic
from .command_dispatcher import CommandDispatcher
from .state_monitor import StateMonitor
from .utils import DecisionUtils
__all__ = [
"DecisionLogic",
"CommandDispatcher",
"StateMonitor",
"DecisionUtils",
]
10.1.2 agents/decision_agent/decision_logic.py
功能：实现决策智能体的核心决策逻辑，基于当前状态和策略网络生成应急指令。
# agents/decision_agent/decision_logic.py
import torch
from models.policy_network import PolicyNetwork, load_policy_model
from utils.config_loader import load_config
from .command_dispatcher import CommandDispatcher
from .state_monitor import StateMonitor
class DecisionLogic:
def __init__(self, state_dim, action_dim, config_path='config/agent_parameters.yaml'):
"""
初始化决策逻辑。
Args:
state_dim (int): 状态空间维度。
action_dim (int): 动作空间维度。
config_path (str): 智能体参数配置文件路径。
"""
self.config = load_config(config_path)
self.policy_net = load_policy_model(state_dim, action_dim, 'models/policy_network/policy_model.pth')
self.policy_net.eval()
self.state_monitor = StateMonitor()
self.command_dispatcher = CommandDispatcher()
def decide(self, state):
"""
基于当前状态做出决策。
Args:
state (dict): 当前环境状态。
Returns:
list: 生成的应急指令列表。
"""
# 将状态转换为模型输入格式
state_tensor = self.state_monitor.process_state(state)
with torch.no_grad():
action_probs = self.policy_net(state_tensor)
action = torch.argmax(action_probs, dim=1).item()
# 根据动作生成指令
commands = self.command_dispatcher.dispatch(action, state)
return commands
10.1.3 agents/decision_agent/command_dispatcher.py
功能：根据决策逻辑生成的动作，分发具体的应急指令。
# agents/decision_agent/command_dispatcher.py
from .utils import DecisionUtils
class CommandDispatcher:
def __init__(self):
"""
初始化指令分发模块。
"""
self.utils = DecisionUtils()
def dispatch(self, action, state):
"""
根据动作和当前状态生成应急指令。
Args:
action (int): 决策智能体选择的动作编号。
state (dict): 当前环境状态。
Returns:
list: 应急指令列表。
"""
commands = []
# 假设动作编号对应不同的应急行动
if action == 0:
command = self.utils.generate_evacuation_command(state)
commands.append(command)
elif action == 1:
command = self.utils.generate_resource_allocation_command(state)
commands.append(command)
elif action == 2:
command = self.utils.generate_public_warning_command(state)
commands.append(command)
# 添加更多动作对应的指令生成逻辑
return commands
10.1.4 agents/decision_agent/state_monitor.py
功能：监控和处理当前环境状态，准备决策智能体的输入。
# agents/decision_agent/state_monitor.py
import torch
class StateMonitor:
def __init__(self):
"""
初始化状态监控模块。
"""
pass
def process_state(self, state):
"""
处理环境状态，转换为模型输入格式。
Args:
state (dict): 当前环境状态。
Returns:
torch.Tensor: 处理后的状态张量。
"""
# 将状态字典转换为浮点数列表
state_vector = []
# 假设 state 包含多个关键指标
state_vector.append(state.get('flood_level', 0.0))
state_vector.append(state.get('earthquake_intensity', 0.0))
state_vector.append(state.get('wildfire_intensity', 0.0))
state_vector.append(state.get('chemical_spill_quantity', 0.0))
state_vector.append(state.get('resource_available', 0.0))
state_vector.append(state.get('public_panic_level', 0.0))
# 更多状态指标...
state_tensor = torch.FloatTensor(state_vector).unsqueeze(0) # 添加批次维度
return state_tensor
10.1.5 agents/decision_agent/utils.py
功能：提供决策智能体的辅助工具函数，如指令生成逻辑。
# agents/decision_agent/utils.py
class DecisionUtils:
def __init__(self):
"""
初始化决策智能体工具函数模块。
"""
pass
def generate_evacuation_command(self, state):
"""
生成疏散指令。
Args:
state (dict): 当前环境状态。
Returns:
dict: 疏散指令详情。
"""
command = {
'type': 'evacuation',
'priority': 'high',
'target_regions': ['RegionA', 'RegionB'],
'details': {
'evacuation_order': ['elderly', 'children', 'disabled', 'general_population'],
'routes': ['Route1', 'Route2'],
'resources_needed': ['buses', 'ambulances']
}
}
return command
def generate_resource_allocation_command(self, state):
"""
生成资源分配指令。
Args:
state (dict): 当前环境状态。
Returns:
dict: 资源分配指令详情。
"""
command = {
'type': 'resource_allocation',
'priority': 'high',
'target_regions': ['RegionA', 'RegionB'],
'resources': {
'medical_supplies': 1000,
'food_reserves': 5000,
'rescue_teams': 20
}
}
return command
def generate_public_warning_command(self, state):
"""
生成公共警报指令。
Args:
state (dict): 当前环境状态。
Returns:
dict: 公共警报指令详情。
"""
command = {
'type': 'public_warning',
'priority': 'medium',
'message': 'Severe weather conditions expected. Please follow evacuation orders.',
'channels': ['sms', 'radio', 'social_media']
}
return command
# 添加更多指令生成函数...
10.2.1 agents/resource_execution_agent/__init__.py
功能：初始化资源执行智能体模块，便于在项目中导入各个组件。
# agents/resource_execution_agent/__init__.py
from .execution_logic import ExecutionLogic
from .status_feedback import StatusFeedback
from .utils import ExecutionUtils
__all__ = [
"ExecutionLogic",
"StatusFeedback",
"ExecutionUtils",
]
10.2.2 agents/resource_execution_agent/execution_logic.py
功能：实现资源执行智能体的核心执行逻辑，接收指令并执行相应的资源调配。
# agents/resource_execution_agent/execution_logic.py
import time
from .status_feedback import StatusFeedback
from .utils import ExecutionUtils
class ExecutionLogic:
def __init__(self, config_path='config/agent_parameters.yaml'):
"""
初始化执行逻辑。
Args:
config_path (str): 智能体参数配置文件路径。
"""
self.utils = ExecutionUtils()
self.status_feedback = StatusFeedback()
self.config = self.utils.load_config(config_path)
def execute_commands(self, commands):
"""
执行接收到的应急指令。
Args:
commands (list): 应急指令列表。
Returns:
list: 执行反馈列表。
"""
feedbacks = []
for command in commands:
if command['type'] == 'evacuation':
feedback = self.execute_evacuation(command)
elif command['type'] == 'resource_allocation':
feedback = self.execute_resource_allocation(command)
elif command['type'] == 'public_warning':
feedback = self.execute_public_warning(command)
# 添加更多指令类型的执行逻辑
else:
feedback = self.status_feedback.generate_feedback(command, success=False, reason="Unknown command type")
feedbacks.append(feedback)
return feedbacks
def execute_evacuation(self, command):
"""
执行疏散指令。
Args:
command (dict): 疏散指令详情。
Returns:
dict: 执行反馈。
"""
# 模拟疏散过程
try:
print(f"Executing evacuation for regions: {command['target_regions']}")
time.sleep(1) # 模拟执行时间
success = True # 假设执行成功
return self.status_feedback.generate_feedback(command, success=success)
except Exception as e:
return self.status_feedback.generate_feedback(command, success=False, reason=str(e))
def execute_resource_allocation(self, command):
"""
执行资源分配指令。
Args:
command (dict): 资源分配指令详情。
Returns:
dict: 执行反馈。
"""
try:
print(f"Allocating resources to regions: {command['target_regions']}")
print(f"Resources: {command['resources']}")
time.sleep(1) # 模拟执行时间
success = True
return self.status_feedback.generate_feedback(command, success=success)
except Exception as e:
return self.status_feedback.generate_feedback(command, success=False, reason=str(e))
def execute_public_warning(self, command):
"""
执行公共警报指令。
Args:
command (dict): 公共警报指令详情。
Returns:
dict: 执行反馈。
"""
try:
print(f"Publishing warning message: {command['message']}")
print(f"Channels: {command['channels']}")
time.sleep(0.5) # 模拟执行时间
success = True
return self.status_feedback.generate_feedback(command, success=success)
except Exception as e:
return self.status_feedback.generate_feedback(command, success=False, reason=str(e))
10.2.3 agents/resource_execution_agent/status_feedback.py
功能：处理执行指令后的反馈信息，记录执行结果和可能的异常。
# agents/resource_execution_agent/status_feedback.py
class StatusFeedback:
def __init__(self):
"""
初始化执行反馈模块。
"""
pass
def generate_feedback(self, command, success=True, reason=None):
"""
生成执行反馈。
Args:
command (dict): 执行的指令详情。
success (bool): 执行是否成功。
reason (str, optional): 失败原因。
Returns:
dict: 执行反馈详情。
"""
feedback = {
'command_type': command['type'],
'success': success,
'timestamp': time.time(),
'details': command.get('details', {}),
}
if not success:
feedback['reason'] = reason
return feedback
10.2.4 agents/resource_execution_agent/utils.py
功能：提供资源执行智能体的辅助工具函数，如配置加载与指令解析。
# agents/resource_execution_agent/utils.py
import yaml
class ExecutionUtils:
def __init__(self):
"""
初始化执行智能体工具函数模块。
"""
pass
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
10.3. 对抗智能体模块 (adversarial_agent/)
10.3.1 agents/adversarial_agent/__init__.py
功能：初始化对抗智能体模块，便于在项目中导入各个组件。
# agents/adversarial_agent/__init__.py
from .attack_strategy import AttackStrategy
from .disruption_logic import DisruptionLogic
from .utils import AdversarialUtils
__all__ = [
"AttackStrategy",
"DisruptionLogic",
"AdversarialUtils",
]
10.3.2 agents/adversarial_agent/attack_strategy.py
功能：实现对抗智能体的攻击策略，决定何时何地以及如何发起干扰。
# agents/adversarial_agent/attack_strategy.py
import random
from .disruption_logic import DisruptionLogic
from .utils import AdversarialUtils
class AttackStrategy:
def __init__(self, config_path='config/agent_parameters.yaml'):
"""
初始化攻击策略。
Args:
config_path (str): 智能体参数配置文件路径。
"""
self.utils = AdversarialUtils()
self.config = self.utils.load_config(config_path)
self.disruption_logic = DisruptionLogic()
self.attack_priority = self.config['agents']['adversarial_agent']['attack_priority']
self.attack_methods = self.config['agents']['adversarial_agent']['attack_methods']
def select_attack_target(self, state):
"""
根据当前状态选择攻击目标和方法。
Args:
state (dict): 当前环境状态。
Returns:
tuple: (attack_type, method, target)
"""
# 优先级高的攻击类型优先选择
for attack_type in self.attack_priority:
methods = self.attack_methods.get(attack_type, [])
if methods:
method = random.choice(methods)
target = self.utils.select_target(attack_type, state)
return (attack_type, method, target)
return (None, None, None)
def initiate_attack(self, state):
"""
发起一次攻击。
Args:
state (dict): 当前环境状态。
Returns:
dict: 攻击结果反馈。
"""
attack_type, method, target = self.select_attack_target(state)
if attack_type and method and target:
print(f"Initiating attack: {attack_type} via {method} on {target}")
success = self.disruption_logic.perform_disruption(attack_type, method, target)
return {
'attack_type': attack_type,
'method': method,
'target': target,
'success': success
}
else:
print("No valid attack target selected.")
return {
'attack_type': None,
'method': None,
'target': None,
'success': False,
'reason': 'No valid attack target selected'
}
10.3.3 agents/adversarial_agent/disruption_logic.py
功能：实现具体的干扰逻辑，执行对关键基础设施或资源的破坏。
# agents/adversarial_agent/disruption_logic.py
class DisruptionLogic:
def __init__(self):
"""
初始化干扰逻辑模块。
"""
pass
def perform_disruption(self, attack_type, method, target):
"""
执行干扰动作。
Args:
attack_type (str): 攻击类型（如 critical_infrastructure）。
method (str): 攻击方法（如 power_grid_attack）。
target (str): 攻击目标（如 PowerPlantA）。
Returns:
bool: 干扰是否成功。
"""
try:
# 根据攻击类型和方法模拟干扰
if attack_type == 'critical_infrastructure':
if method == 'power_grid_attack':
self.attack_power_grid(target)
elif method == 'bridge_destruction':
self.destroy_bridge(target)
elif method == 'hospital_disruption':
self.disrupt_hospital(target)
elif attack_type == 'resource_supply':
if method == 'warehouse_blockade':
self.blockade_warehouse(target)
elif method == 'fuel_supply_cutoff':
self.cutoff_fuel_supply(target)
elif attack_type == 'communication_network':
if method == 'data_system_hack':
self.hack_data_system(target)
elif method == 'gps_jamming':
self.jam_gps(target)
# 添加更多攻击类型和方法的逻辑
return True
except Exception as e:
print(f"Disruption failed: {e}")
return False
def attack_power_grid(self, target):
"""
攻击电网。
Args:
target (str): 电网目标。
"""
print(f"Attacking power grid at {target}")
# 实际实现应与仿真环境交互，影响电力状态
def destroy_bridge(self, target):
"""
摧毁桥梁。
Args:
target (str): 桥梁目标。
"""
print(f"Destroying bridge {target}")
# 实际实现应与仿真环境交互，影响交通状况
def disrupt_hospital(self, target):
"""
干扰医院。
Args:
target (str): 医院目标。
"""
print(f"Disrupting hospital {target}")
# 实际实现应与仿真环境交互，影响医疗服务
def blockade_warehouse(self, target):
"""
封锁仓库。
Args:
target (str): 仓库目标。
"""
print(f"Blockading warehouse {target}")
# 实际实现应与仿真环境交互，影响物资供应
def cutoff_fuel_supply(self, target):
"""
切断燃油供应。
Args:
target (str): 燃油供应点目标。
"""
print(f"Cutting off fuel supply at {target}")
# 实际实现应与仿真环境交互，影响车辆和设备的运行
def hack_data_system(self, target):
"""
黑客攻击数据系统。
Args:
target (str): 数据系统目标。
"""
print(f"Hacking data system at {target}")
# 实际实现应与仿真环境交互，影响数据的准确性或可用性
def jam_gps(self, target):
"""
GPS干扰。
Args:
target (str): GPS目标。
"""
print(f"Jamming GPS at {target}")
# 实际实现应与仿真环境交互，影响定位和导航系统
10.3.4 agents/adversarial_agent/utils.py
功能：提供对抗智能体的辅助工具函数，如配置加载与目标选择。
# agents/adversarial_agent/utils.py
import yaml
import random
class AdversarialUtils:
def __init__(self):
"""
初始化对抗智能体工具函数模块。
"""
pass
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
def select_target(self, attack_type, state):
"""
根据攻击类型和当前状态选择具体的攻击目标。
Args:
attack_type (str): 攻击类型。
state (dict): 当前环境状态。
Returns:
str: 选择的攻击目标。
"""
# 从关键基础设施中随机选择一个目标
targets = state.get('critical_infrastructure', {}).get(attack_type, [])
if targets:
return random.choice(targets)
else:
return "Unknown_Target"
10.4.1 agents/disaster_agent/__init__.py
功能：初始化灾害代理智能体模块，便于在项目中导入各个组件。
# agents/disaster_agent/__init__.py
from .disaster_evolution import DisasterEvolution
from .scenario_generator import ScenarioGenerator
from .utils import DisasterUtils
__all__ = [
"DisasterEvolution",
"ScenarioGenerator",
"DisasterUtils",
]
10.4.2 agents/disaster_agent/disaster_evolution.py
功能：管理灾害的演化过程，模拟灾害的扩散与变化。
# agents/disaster_agent/disaster_evolution.py
import random
from .utils import DisasterUtils
class DisasterEvolution:
def __init__(self, config_path='config/agent_parameters.yaml'):
"""
初始化灾害演化模块。
Args:
config_path (str): 智能体参数配置文件路径。
"""
self.utils = DisasterUtils()
self.config = self.utils.load_config(config_path)
self.gamma = self.config['simulation_settings']['disaster_trigger']['frequency']
def evolve(self, current_scenarios, state):
"""
演化当前灾害场景，可能新增、扩散或消退灾害。
Args:
current_scenarios (list): 当前存在的灾害场景列表。
state (dict): 当前环境状态。
Returns:
list: 更新后的灾害场景列表。
"""
updated_scenarios = []
# 遍历当前灾害场景，更新其状态
for scenario in current_scenarios:
# 根据灾害类型和演化规则更新灾害强度
new_intensity = self.update_intensity(scenario)
if new_intensity > 0:
scenario['intensity'] = new_intensity
updated_scenarios.append(scenario)
# 可能新增灾害场景
new_scenarios = self.generate_new_scenarios(state)
updated_scenarios.extend(new_scenarios)
return updated_scenarios
def update_intensity(self, scenario):
"""
根据灾害类型更新灾害强度。
Args:
scenario (dict): 灾害场景详情。
Returns:
float: 更新后的灾害强度。
"""
# 灾害强度随时间衰减或根据某些条件增强
decay_rate = 0.95
new_intensity = scenario['intensity'] * decay_rate
return new_intensity
def generate_new_scenarios(self, state):
"""
根据灾害触发概率生成新的灾害场景。
Args:
state (dict): 当前环境状态。
Returns:
list: 新增的灾害场景列表。
"""
new_scenarios = []
for disaster_type, params in self.config['simulation_settings']['disaster_trigger'].items():
if disaster_type == 'frequency':
continue
frequency = params.get('frequency', 0.0)
if random.random() < frequency:
scenario = self.utils.create_disaster_scenario(disaster_type, state)
new_scenarios.append(scenario)
return new_scenarios
10.4.3 agents/disaster_agent/scenario_generator.py
功能：生成新的灾害场景，包括灾害类型、影响范围及具体参数。
# agents/disaster_agent/scenario_generator.py
import random
from .utils import DisasterUtils
class ScenarioGenerator:
def __init__(self, config_path='config/agent_parameters.yaml'):
"""
初始化场景生成模块。
Args:
config_path (str): 智能体参数配置文件路径。
"""
self.utils = DisasterUtils()
self.config = self.utils.load_config(config_path)
def generate_scenario(self, disaster_type, state):
"""
生成一个新的灾害场景。
Args:
disaster_type (str): 灾害类型。
state (dict): 当前环境状态。
Returns:
dict: 生成的灾害场景详情。
"""
scenario = {
'type': disaster_type,
'intensity': self.utils.random_intensity(disaster_type),
'affected_regions': self.utils.select_affected_regions(disaster_type, state),
'start_time': time.time(),
'duration': self.utils.get_duration(disaster_type)
}
return scenario
def batch_generate_scenarios(self, num, state):
"""
批量生成灾害场景。
Args:
num (int): 生成的场景数量。
state (dict): 当前环境状态。
Returns:
list: 生成的灾害场景列表。
"""
scenarios = []
for _ in range(num):
disaster_type = random.choice(self.config['simulation_settings']['disaster_trigger']['disaster_types'])
scenario = self.generate_scenario(disaster_type, state)
scenarios.append(scenario)
return scenarios
10.4.4 agents/disaster_agent/utils.py
功能：提供灾害代理智能体的辅助工具函数，如配置加载、场景创建与选择受影响区域。
# agents/disaster_agent/utils.py
import yaml
import random
import time
class DisasterUtils:
def __init__(self):
"""
初始化灾害智能体工具函数模块。
"""
pass
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
def create_disaster_scenario(self, disaster_type, state):
"""
创建一个灾害场景。
Args:
disaster_type (str): 灾害类型。
state (dict): 当前环境状态。
Returns:
dict: 灾害场景详情。
"""
intensity = self.random_intensity(disaster_type)
affected_regions = self.select_affected_regions(disaster_type, state)
duration = self.get_duration(disaster_type)
scenario = {
'type': disaster_type,
'intensity': intensity,
'affected_regions': affected_regions,
'start_time': time.time(),
'duration': duration
}
return scenario
def random_intensity(self, disaster_type):
"""
根据灾害类型随机生成灾害强度。
Args:
disaster_type (str): 灾害类型。
Returns:
float: 灾害强度。
"""
intensity_range = {
'flood': (0.5, 1.0),
'earthquake': (0.6, 1.0),
'wildfire': (0.4, 1.0),
'chemical_spill': (0.7, 1.0)
}
low, high = intensity_range.get(disaster_type, (0.5, 1.0))
return random.uniform(low, high)
def select_affected_regions(self, disaster_type, state):
"""
根据灾害类型选择受影响区域。
Args:
disaster_type (str): 灾害类型。
state (dict): 当前环境状态。
Returns:
list: 受影响区域列表。
"""
regions = state.get('geographic', {}).get('regions', [])
affected_regions = []
for region in regions:
# 根据灾害类型和区域特性决定是否受影响
if disaster_type == 'flood' and region['type'] == 'urban':
if random.random() < 0.7:
affected_regions.append(region['name'])
elif disaster_type == 'earthquake' and region['type'] == 'urban':
if random.random() < 0.8:
affected_regions.append(region['name'])
elif disaster_type == 'wildfire' and region['type'] == 'rural':
if random.random() < 0.9:
affected_regions.append(region['name'])
elif disaster_type == 'chemical_spill' and region['type'] == 'industrial':
if random.random() < 0.95:
affected_regions.append(region['name'])
return affected_regions
def get_duration(self, disaster_type):
"""
获取灾害持续时间。
Args:
disaster_type (str): 灾害类型。
Returns:
int: 灾害持续时间（秒）。
"""
duration_range = {
'flood': (86400, 172800), # 1-2 天
'earthquake': (3600, 7200), # 1-2 小时
'wildfire': (43200, 86400), # 12-24 小时
'chemical_spill': (7200, 14400) # 2-4 小时
}
low, high = duration_range.get(disaster_type, (3600, 7200))
return random.randint(low, high)
10.5.1 agents/medical_emergency_agent/__init__.py
功能：初始化医疗应急子智能体模块，便于在项目中导入各个组件。
# agents/medical_emergency_agent/__init__.py
from .medical_logic import MedicalLogic
from .resource_manager import ResourceManager
from .utils import MedicalUtils
__all__ = [
"MedicalLogic",
"ResourceManager",
"MedicalUtils",
]
10.5.2 agents/medical_emergency_agent/medical_logic.py
功能：实现医疗应急子智能体的核心逻辑，基于医疗需求分配资源。
# agents/medical_emergency_agent/medical_logic.py
from .resource_manager import ResourceManager
from .utils import MedicalUtils
class MedicalLogic:
def __init__(self, config_path='config/agent_parameters.yaml'):
"""
初始化医疗逻辑。
Args:
config_path (str): 智能体参数配置文件路径。
"""
self.utils = MedicalUtils()
self.config = self.utils.load_config(config_path)
self.resource_manager = ResourceManager()
def assess_needs(self, state):
"""
评估当前医疗需求。
Args:
state (dict): 当前环境状态。
Returns:
dict: 医疗资源需求详情。
"""
# 根据灾害类型和受影响区域评估医疗需求
needs = {}
for disaster in state.get('current_scenarios', []):
if disaster['type'] == 'earthquake':
needs['medical_units'] = needs.get('medical_units', 0) + 10
elif disaster['type'] == 'flood':
needs['medical_units'] = needs.get('medical_units', 0) + 5
# 添加更多灾害类型的医疗需求评估
return needs
def allocate_resources(self, needs, state):
"""
根据医疗需求分配资源。
Args:
needs (dict): 医疗资源需求详情。
state (dict): 当前环境状态。
Returns:
dict: 资源分配结果反馈。
"""
allocation = self.resource_manager.allocate(needs, state)
return allocation
10.5.3 agents/medical_emergency_agent/resource_manager.py
功能：管理医疗资源的分配与调度。
# agents/medical_emergency_agent/resource_manager.py
class ResourceManager:
def __init__(self):
"""
初始化资源管理模块。
"""
pass
def allocate(self, needs, state):
"""
分配医疗资源。
Args:
needs (dict): 医疗资源需求详情。
state (dict): 当前环境状态。
Returns:
dict: 资源分配结果反馈。
"""
allocation = {}
for resource, amount_needed in needs.items():
available = state.get('resources', {}).get(resource, 0)
allocated = min(amount_needed, available)
allocation[resource] = allocated
# 更新环境状态中的资源
state['resources'][resource] -= allocated
return allocation
10.5.4 agents/medical_emergency_agent/utils.py
功能：提供医疗应急智能体的辅助工具函数，如配置加载与数据处理。
# agents/medical_emergency_agent/utils.py
import yaml
class MedicalUtils:
def __init__(self):
"""
初始化医疗智能体工具函数模块。
"""
pass
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
11.1. simulation/__init__.py
功能：初始化仿真模块，便于在项目中导入各个组件。
# simulation/__init__.py
from .environment import EmergencyEnvironment
from .event_handler import EventHandler
from .interaction_manager import InteractionManager
from .utilities import SimulationUtils
__all__ = [
"EmergencyEnvironment",
"EventHandler",
"InteractionManager",
"SimulationUtils",
]
11.2. simulation/environment.py
功能：定义仿真环境的核心接口与实现，模拟灾害场景与智能体交互。
# simulation/environment.py
import random
from gym import Env
from gym.spaces import Discrete, Box
import numpy as np
import time
class EmergencyEnvironment(Env):
"""
自定义应急管理仿真环境，继承自 OpenAI Gym 的 Env 类。
"""
def __init__(self, config_path='config/simulation_settings.yaml'):
"""
初始化仿真环境。
Args:
config_path (str): 仿真设置配置文件路径。
"""
super(EmergencyEnvironment, self).__init__()
self.config = self.load_config(config_path)
self.state_dim = self.get_state_dim()
self.action_dim = self.get_action_dim()
# 定义动作和状态空间
self.action_space = Discrete(self.action_dim) # 动作空间，例如不同的应急指令编号
self.observation_space = Box(low=0, high=1, shape=(self.state_dim,), dtype=np.float32) # 状态空间
# 初始化环境状态
self.state = self.reset()
self.current_step = 0
self.max_steps = self.config['simulation']['max_steps']
# 初始化事件处理器
self.event_handler = EventHandler(config_path=config_path)
# 初始化智能体交互管理
self.interaction_manager = InteractionManager(config_path=config_path)
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
import yaml
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
def get_state_dim(self):
"""
获取状态空间维度。
Returns:
int: 状态空间维度。
"""
# 根据配置定义状态维度
return len(self.config['environment']['geographic']['regions']) * 6 # 每个区域6个状态指标
def get_action_dim(self):
"""
获取动作空间维度。
Returns:
int: 动作空间维度。
"""
# 根据策略定义动作数量
return len(self.config['strategies']['communication']['channels']) + 3 # 更多动作可以按需添加
def reset(self):
"""
重置仿真环境到初始状态。
Returns:
np.ndarray: 初始状态。
"""
self.current_step = 0
self.state = self.initialize_state()
return self.state
def initialize_state(self):
"""
初始化环境状态。
Returns:
np.ndarray: 初始化状态向量。
"""
state_vector = []
for region in self.config['environment']['geographic']['regions']:
# 为每个区域添加状态指标
state_vector.extend([
0.0, # flood_level
0.0, # earthquake_intensity
0.0, # wildfire_intensity
0.0, # chemical_spill_quantity
1.0, # resource_available (normalized)
0.0 # public_panic_level
])
return np.array(state_vector, dtype=np.float32)
def step(self, action):
"""
执行一步仿真，根据动作更新状态并计算奖励。
Args:
action (int): 智能体选择的动作编号。
Returns:
tuple: (next_state, reward, done, info)
"""
self.current_step += 1
info = {}
# 智能体指令执行
commands = self.interaction_manager.execute_action(action, self.state)
feedback = self.event_handler.process_commands(commands, self.state)
# 更新环境状态
self.state = self.update_state(feedback)
# 处理事件
events = self.event_handler.generate_events(self.state)
self.state = self.update_state(events)
# 计算奖励
reward = self.calculate_reward(feedback, events)
# 判断是否结束
done = self.current_step >= self.max_steps
return self.state, reward, done, info
def update_state(self, feedback):
"""
根据反馈更新环境状态。
Args:
feedback (dict): 执行反馈或事件详情。
Returns:
np.ndarray: 更新后的状态向量。
"""
# 根据反馈调整状态指标
for key, value in feedback.items():
# 具体的状态更新逻辑应根据项目需求定义
pass
return self.state
def calculate_reward(self, feedback, events):
"""
计算当前步的奖励。
Args:
feedback (dict): 执行反馈详情。
events (dict): 当前步生成的事件详情。
Returns:
float: 当前步的奖励值。
"""
# 简单的奖励函数，根据成功执行指令和减少灾害影响
reward = 0.0
if feedback.get('success', False):
reward += 1.0
# 奖励减少灾害强度
disaster_reduction = sum([
event.get('impact', 0.0) for event in events.get('disasters', [])
])
reward += disaster_reduction
return reward
def render(self, mode='human'):
"""
渲染仿真环境状态（可选）。
Args:
mode (str): 渲染模式。
"""
if mode == 'human':
print(f"Step: {self.current_step}")
print(f"State: {self.state}")
def close(self):
"""
关闭仿真环境（可选）。
"""
pass
11.3. simulation/event_handler.py
功能：处理执行指令后的反馈信息，生成和管理灾害事件，模拟灾害的演化和次生影响。
# simulation/event_handler.py
import random
from .utilities import SimulationUtils
class EventHandler:
"""
事件处理模块，负责处理执行指令后的反馈信息，生成和管理灾害事件。
"""
def __init__(self, config_path='config/simulation_settings.yaml'):
"""
初始化事件处理器。
Args:
config_path (str): 仿真设置配置文件路径。
"""
self.utils = SimulationUtils()
self.config = self.utils.load_config(config_path)
def process_commands(self, commands, state):
"""
处理执行指令，更新环境状态或生成反馈。
Args:
commands (list): 执行的应急指令列表。
state (np.ndarray): 当前环境状态向量。
Returns:
dict: 执行反馈详情。
"""
feedback = {}
for command in commands:
if command['type'] == 'evacuation':
feedback['evacuation'] = self.handle_evacuation(command, state)
elif command['type'] == 'resource_allocation':
feedback['resource_allocation'] = self.handle_resource_allocation(command, state)
elif command['type'] == 'public_warning':
feedback['public_warning'] = self.handle_public_warning(command, state)
# 添加更多指令类型的处理逻辑
return feedback
def handle_evacuation(self, command, state):
"""
处理疏散指令，模拟人员疏散并更新状态。
Args:
command (dict): 疏散指令详情。
state (np.ndarray): 当前环境状态向量。
Returns:
dict: 疏散执行反馈。
"""
# 根据目标区域减少公共恐慌水平
feedback = {'success': True}
return feedback
def handle_resource_allocation(self, command, state):
"""
处理资源分配指令，模拟资源调配并更新状态。
Args:
command (dict): 资源分配指令详情。
state (np.ndarray): 当前环境状态向量。
Returns:
dict: 资源分配执行反馈。
"""
feedback = {'success': True}
return feedback
def handle_public_warning(self, command, state):
"""
处理公共警报指令，模拟信息发布并更新状态。
Args:
command (dict): 公共警报指令详情。
state (np.ndarray): 当前环境状态向量。
Returns:
dict: 公共警报执行反馈。
"""
feedback = {'success': True}
return feedback
def generate_events(self, state):
"""
根据当前状态生成灾害事件或次生影响。
Args:
state (np.ndarray): 当前环境状态向量。
Returns:
dict: 生成的灾害事件详情。
"""
events = {'disasters': []}
for disaster_type in self.config['disaster_types']:
if random.random() < self.config['simulation']['disaster_trigger'][disaster_type]['frequency']:
event = self.utils.create_disaster_event(disaster_type, state)
events['disasters'].append(event)
return events
11.4. simulation/interaction_manager.py
功能：管理智能体与仿真环境之间的交互，执行智能体的动作并生成对应的指令反馈。
# simulation/interaction_manager.py
class InteractionManager:
"""
智能体交互管理模块，负责执行智能体的动作并与仿真环境交互。
"""
def __init__(self, config_path='config/simulation_settings.yaml'):
"""
初始化交互管理器。
Args:
config_path (str): 仿真设置配置文件路径。
"""
self.config = self.load_config(config_path)
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
import yaml
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
def execute_action(self, action, state):
"""
根据智能体的动作生成应急指令。
Args:
action (int): 智能体选择的动作编号。
state (np.ndarray): 当前环境状态向量。
Returns:
list: 应急指令列表。
"""
commands = []
# 动作编号对应不同的应急指令类型
if action == 0:
command = {
'type': 'evacuation',
'priority': 'high',
'target_regions': ['RegionA', 'RegionB'],
'details': {
'evacuation_order': ['elderly', 'children', 'disabled', 'general_population'],
'routes': ['Route1', 'Route2'],
'resources_needed': ['buses', 'ambulances']
}
}
commands.append(command)
elif action == 1:
command = {
'type': 'resource_allocation',
'priority': 'high',
'target_regions': ['RegionA', 'RegionB'],
'resources': {
'medical_supplies': 1000,
'food_reserves': 5000,
'rescue_teams': 20
}
}
commands.append(command)
elif action == 2:
command = {
'type': 'public_warning',
'priority': 'medium',
'message': 'Severe weather conditions expected. Please follow evacuation orders.',
'channels': ['sms', 'radio', 'social_media']
}
commands.append(command)
# 添加更多动作对应的指令生成逻辑
return commands
11.5. simulation/utilities.py
功能：提供仿真环境的辅助工具函数，如配置加载、灾害事件创建等。
# simulation/utilities.py
import yaml
import random
import time
class SimulationUtils:
"""
仿真工具函数模块，提供各种辅助功能。
"""
def __init__(self):
"""
初始化仿真工具函数模块。
"""
pass
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
def create_disaster_event(self, disaster_type, state):
"""
创建一个灾害事件。
Args:
disaster_type (str): 灾害类型。
state (np.ndarray): 当前环境状态向量。
Returns:
dict: 灾害事件详情。
"""
intensity = self.random_intensity(disaster_type)
affected_regions = self.select_affected_regions(disaster_type, state)
duration = self.get_duration(disaster_type)
event = {
'type': disaster_type,
'intensity': intensity,
'affected_regions': affected_regions,
'start_time': time.time(),
'duration': duration,
'impact': self.calculate_impact(disaster_type, intensity)
}
return event
def random_intensity(self, disaster_type):
"""
根据灾害类型随机生成灾害强度。
Args:
disaster_type (str): 灾害类型。
Returns:
float: 灾害强度。
"""
intensity_range = {
'flood': (0.5, 1.0),
'earthquake': (0.6, 1.0),
'wildfire': (0.4, 1.0),
'chemical_spill': (0.7, 1.0)
}
low, high = intensity_range.get(disaster_type, (0.5, 1.0))
return random.uniform(low, high)
def select_affected_regions(self, disaster_type, state):
"""
根据灾害类型选择受影响区域。
Args:
disaster_type (str): 灾害类型。
state (np.ndarray): 当前环境状态向量。
Returns:
list: 受影响区域列表。
"""
# 从状态向量中解析受影响区域
# 假设每个区域对应6个状态指标，如 flood_level、earthquake_intensity 等
regions = self.load_config('config/environment.yaml')['geographic']['regions']
affected_regions = []
num_regions = len(regions)
for i in range(num_regions):
# 根据灾害类型和强度决定是否受影响
if disaster_type == 'flood':
flood_level = state[i*6]
if flood_level > 0.7:
affected_regions.append(regions[i]['name'])
elif disaster_type == 'earthquake':
earthquake_intensity = state[i*6 + 1]
if earthquake_intensity > 0.8:
affected_regions.append(regions[i]['name'])
elif disaster_type == 'wildfire':
wildfire_intensity = state[i*6 + 2]
if wildfire_intensity > 0.6:
affected_regions.append(regions[i]['name'])
elif disaster_type == 'chemical_spill':
chemical_spill_quantity = state[i*6 + 3]
if chemical_spill_quantity > 0.9:
affected_regions.append(regions[i]['name'])
return affected_regions
def get_duration(self, disaster_type):
"""
获取灾害持续时间。
Args:
disaster_type (str): 灾害类型。
Returns:
int: 灾害持续时间（秒）。
"""
duration_range = {
'flood': (86400, 172800), # 1-2 天
'earthquake': (3600, 7200), # 1-2 小时
'wildfire': (43200, 86400), # 12-24 小时
'chemical_spill': (7200, 14400) # 2-4 小时
}
low, high = duration_range.get(disaster_type, (3600, 7200))
return random.randint(low, high)
def calculate_impact(self, disaster_type, intensity):
"""
计算灾害的影响程度。
Args:
disaster_type (str): 灾害类型。
intensity (float): 灾害强度。
Returns:
float: 影响程度评分。
"""
# 简单的影响评分计算
return intensity * 10 # 可以根据具体需求调整
11.7. simulation/utilities.py
功能：提供仿真环境的辅助工具函数，如配置加载、灾害事件创建等。
# simulation/utilities.py
import yaml
import random
import time
class SimulationUtils:
"""
仿真工具函数模块，提供各种辅助功能。
"""
def __init__(self):
"""
初始化仿真工具函数模块。
"""
pass
def load_config(self, config_path):
"""
加载配置文件。
Args:
config_path (str): 配置文件路径。
Returns:
dict: 配置内容。
"""
with open(config_path, 'r') as file:
config = yaml.safe_load(file)
return config
def create_disaster_event(self, disaster_type, state):
"""
创建一个灾害事件。
Args:
disaster_type (str): 灾害类型。
state (np.ndarray): 当前环境状态向量。
Returns:
dict: 灾害事件详情。
"""
intensity = self.random_intensity(disaster_type)
affected_regions = self.select_affected_regions(disaster_type, state)
duration = self.get_duration(disaster_type)
event = {
'type': disaster_type,
'intensity': intensity,
'affected_regions': affected_regions,
'start_time': time.time(),
'duration': duration,
'impact': self.calculate_impact(disaster_type, intensity)
}
return event
def random_intensity(self, disaster_type):
"""
根据灾害类型随机生成灾害强度。
Args:
disaster_type (str): 灾害类型。
Returns:
float: 灾害强度。
"""
intensity_range = {
'flood': (0.5, 1.0),
'earthquake': (0.6, 1.0),
'wildfire': (0.4, 1.0),
'chemical_spill': (0.7, 1.0)
}
low, high = intensity_range.get(disaster_type, (0.5, 1.0))
return random.uniform(low, high)
def select_affected_regions(self, disaster_type, state):
"""
根据灾害类型选择受影响区域。
Args:
disaster_type (str): 灾害类型。
state (np.ndarray): 当前环境状态向量。
Returns:
list: 受影响区域列表。
"""
# 从状态向量中解析受影响区域
# 假设每个区域对应6个状态指标，如 flood_level、earthquake_intensity 等
config = self.load_config('config/environment.yaml')
regions = config['geographic']['regions']
affected_regions = []
num_regions = len(regions)
for i in range(num_regions):
# 根据灾害类型和强度决定是否受影响
if disaster_type == 'flood':
flood_level = state[i*6]
if flood_level > 0.7:
affected_regions.append(regions[i]['name'])
elif disaster_type == 'earthquake':
earthquake_intensity = state[i*6 + 1]
if earthquake_intensity > 0.8:
affected_regions.append(regions[i]['name'])
elif disaster_type == 'wildfire':
wildfire_intensity = state[i*6 + 2]
if wildfire_intensity > 0.6:
affected_regions.append(regions[i]['name'])
elif disaster_type == 'chemical_spill':
chemical_spill_quantity = state[i*6 + 3]
if chemical_spill_quantity > 0.9:
affected_regions.append(regions[i]['name'])
return affected_regions
def get_duration(self, disaster_type):
"""
获取灾害持续时间。
Args:
disaster_type (str): 灾害类型。
Returns:
int: 灾害持续时间（秒）。
"""
duration_range = {
'flood': (86400, 172800), # 1-2 天
'earthquake': (3600, 7200), # 1-2 小时
'wildfire': (43200, 86400), # 12-24 小时
'chemical_spill': (7200, 14400) # 2-4 小时
}
low, high = duration_range.get(disaster_type, (3600, 7200))
return random.randint(low, high)
def calculate_impact(self, disaster_type, intensity):
"""
计算灾害的影响程度。
Args:
disaster_type (str): 灾害类型。
intensity (float): 灾害强度。
Returns:
float: 影响程度评分。
"""
# 简单的影响评分计算
return intensity * 10 # 可以根据具体需求调整
11.9.1 simulation/weather_simulator.py
功能：模拟天气变化，影响灾害触发和演化。
# simulation/weather_simulator.py
import random
from .utilities import SimulationUtils
class WeatherSimulator:
"""
天气模拟模块，负责模拟天气变化对灾害的影响。
"""
def __init__(self, config_path='config/simulation_settings.yaml'):
"""
初始化天气模拟器。
Args:
config_path (str): 仿真设置配置文件路径。
"""
self.utils = SimulationUtils()
self.config = self.utils.load_config(config_path)
self.weather_types = self.config['simulation']['weather']['weather_types']
self.current_weather = 'clear'
def update_weather(self):
"""
根据天气变化概率更新当前天气类型。
"""
change_prob = self.config['simulation']['weather']['weather_change_probability']
if random.random() < change_prob:
self.current_weather = random.choice(self.weather_types)
print(f"Weather updated to {self.current_weather}")
def affect_disasters(self, state):
"""
根据当前天气影响灾害触发概率和强度。
Args:
state (np.ndarray): 当前环境状态向量。
Returns:
np.ndarray: 更新后的状态向量。
"""
# 根据天气类型调整某些状态指标
if self.current_weather == 'rainy':
# 增加洪水水位
state += 0.05
elif self.current_weather == 'stormy':
# 增加地震强度
state += 0.03
elif self.current_weather == 'foggy':
# 增加公共恐慌水平
state += 0.02
# 更多天气影响...
return state
小结
通过 决策智能体 可在应急仿真或真实系统中实现高度精细化的应急指挥过程：
- 功能定位：
- 兼具全局视角与跨部门协同能力，确保多智能体统一调度与指令不冲突。
- 内部状态空间：
- 五大维度（灾害态势、资源可用性、社会舆情、历史指令、策略模型）全面支撑精准决策。
- 动作与指令执行流程：
- 从预警发布、疏散与管控、物资调度，到社会稳定措施，实现多层次指令发放与反馈。
- 决策算法：
- 结合规则库、规划算法或（元）强化学习，使系统可灵活应对不同规模与复杂度的灾害场景。
- 协同与安全机制：
- 数据汇聚、冲突检测、审批与回退策略保证指令合法合规且易于安全管控。
- 效果评估与可视化：
- 通过多维指标与交互界面，让专家或领导层更好地掌握实时进度、辨别不足并持续迭代改进。
最终，这样的决策智能体不仅具备高保真、多元化的指令覆盖能力，还在跨部门联动、社会舆情管理、资源整合等关键环节为应急管理提供智能化与安全性的强力支撑。