OSCR

Neural Surrogate-Enhanced Metaheuristic Optimization for Distributed Quadrotor Swarm Control.

Code ↔ Paper

4 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 4 matches
  1. [1] § 5. Results and Discussion › 5.1. Experimental Protocol ↔ src/eval_closed_loop.py, lines 172–195 · score 0.72 · step overrun ratio, collision free rate, obstacle hard, violation, sum, closed loop
  2. [2] § 2. System Modeling and Problem Formulation › 2.3. Obstacles and Gap-Based Avoidance Model ↔ src/mpio_swarm_simv1.py, lines 313–354 · score 0.59 · interior gaps, boundary gaps, obstacle avoidance
  3. [3] § 5. Results and Discussion › 5.2. Closed-Loop Simulation Results ↔ src/eval_closed_loop.py, lines 172–195 · score 0.57 · step overrun ratio, collision free rate, closed loop, budget, formation, margin
  4. [4] § 3. Multi-Objective Optimization Formulation and Online Modified MPIO Solver ↔ src/base_mpio_solver.py, lines 398–487 · score 0.51 · MPIO solver, obstacle avoidance, vector, pigeon, optimize, UAV

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 488 lines · 22 KB · MIT · 2 matches

  1. import argparse
  2. import copy
  3. import json
  4. from pathlib import Path
  5. from typing import Dict, Iterable, List, Tuple
  7. import numpy as np
  8. import torch
  10. from base_mpio_solver import SimParams as BaseSimParams, run_episode as run_base_episode
  11. from mpio_swarm_simv1 import (
  12. SimParams as ModifiedSimParams,
  13. extract_features,
  14. neighbors_within,
  15. run_episode as run_modified_episode,
  16. )
  17. from dataset_gen import sample_scene, _init_swarm, N_RANGE
  19. TARGET_SCENE_TYPES = (
  20. "b_chicane_chain",
  21. "e_pillar_forest",
  22. "g_forest_dynamic_spheres",
  23. )
  24. METHODS = ("mlp", "base_mpio", "mpio")
  27. def _n_bucket(n_uav: int) -> str:
  28. if n_uav <= 5:
  29. return "3-5"
  30. if n_uav <= 8:
  31. return "6-8"
  32. return f"9-{N_RANGE[1]}"
  35. def _parse_csv_list(raw: str) -> List[str]:
  36. if not raw:
  37. return []
  38. return [item.strip() for item in raw.split(",") if item.strip()]
  41. def _to_jsonable(value):
  42. if isinstance(value, np.ndarray):
  43. return value.tolist()
  44. if isinstance(value, np.generic):
  45. return value.item()
  46. if isinstance(value, dict):
  47. return {str(k): _to_jsonable(v) for k, v in value.items()}
  48. if isinstance(value, (list, tuple)):
  49. return [_to_jsonable(v) for v in value]
  50. return value
  53. def _progress_path(out_path: Path) -> Path:
  54. return out_path.parent / f"{out_path.name}.progress.json"
  57. def _save_scene_json(scene_cfg: Dict[str, object], out_path: Path) -> None:
  58. out_path.parent.mkdir(parents=True, exist_ok=True)
  59. out_path.write_text(json.dumps(_to_jsonable(scene_cfg), indent=2), encoding="utf-8")
  62. def sample_scene_legacy_easy(rng: np.random.Generator) -> Dict[str, object]:
  63. n_uav = int(rng.integers(5, 7))
  64. ve_mag = float(rng.uniform(6.0, 12.0))
  65. try:
  66. from dataset_gen import _scene_legacy_easy
  67. except ImportError as exc:
  68. raise SystemExit(
  69. "legacy_easy scene is not available in dataset_gen.py; "
  70. "run without --legacy_easy_only or add _scene_legacy_easy."
  71. ) from exc
  72. obstacles, obstacles_vxy = _scene_legacy_easy(rng)
  73. init_p, init_vxy = _init_swarm(rng, n_uav, ve_mag)
  74. return {
  75. "scene_type": "legacy_easy",
  76. "N_uav": n_uav,
  77. "ve_mag": ve_mag,
  78. "init_P": init_p,
  79. "init_Vxy": init_vxy,
  80. "ve_xy": (ve_mag, 0.0),
  81. "obstacles": obstacles,
  82. "obstacles_vxy": obstacles_vxy,
  83. "obstacles_use_prediction": True,
  84. "square_enable": False,
  85. "formation_err_mean_thresh": 3.0,
  86. "formation_err_max_thresh": 10.0,
  87. "formation_over_limit": 0.20,
  88. }
  91. def _load_scene_cfg(path: Path) -> Dict[str, object]:
  92. data = json.loads(path.read_text(encoding="utf-8"))
  93. array_keys = {"init_P", "init_Vxy", "obstacles", "obstacles_vxy"}
  94. tuple_keys = {"ve_xy", "square_center_xy", "square_vxy", "obstacles_bounds"}
  96. scene_cfg: Dict[str, object] = {}
  97. for key, value in data.items():
  98. if value is None:
  99. scene_cfg[key] = None
  100. elif key in array_keys:
  101. scene_cfg[key] = np.asarray(value, dtype=float)
  102. elif key in tuple_keys:
  103. scene_cfg[key] = tuple(value)
  104. else:
  105. scene_cfg[key] = value
  107. scene_cfg.setdefault("scene_type", "custom")
  108. scene_cfg.setdefault("scene_level", 1)
  109. scene_cfg.setdefault("N_uav", 0)
  110. scene_cfg.setdefault("ve_mag", 0.0)
  111. scene_cfg.setdefault("he", 50.0)
  112. scene_cfg.setdefault("ve_xy", (0.0, 0.0))
  113. scene_cfg.setdefault("obstacles_use_prediction", False)
  114. scene_cfg.setdefault("square_enable", False)
  115. scene_cfg.setdefault("square_center_xy", (0.0, 0.0))
  116. scene_cfg.setdefault("square_side", 0.0)
  117. scene_cfg.setdefault("square_vxy", (0.0, 0.0))
  118. scene_cfg.setdefault("x_goal", 0.0)
  119. scene_cfg.setdefault("y_goal", 0.0)
  120. scene_cfg.setdefault("rng_seed", None)
  121. return scene_cfg
  124. def _new_method_stats(selected_methods: Iterable[str]) -> Dict[str, Dict[str, float]]:
  125. return {method: {} for method in selected_methods}
  128. def _accumulate(stats: Dict[str, float], results: Dict[str, object], formation_metrics: Dict[str, float]) -> None:
  129. stats["count"] = stats.get("count", 0) + 1
  130. stats["safe_ok"] = stats.get("safe_ok", 0) + int(results["safe_ok"])
  131. stats["reach_ok"] = stats.get("reach_ok", 0) + int(results["reach_ok"])
  132. stats["formation_ok"] = stats.get("formation_ok", 0) + int(results["formation_ok"])
  133. stats["formation_mean"] = stats.get("formation_mean", 0.0) + formation_metrics["mean_err"]
  134. stats["formation_max"] = stats.get("formation_max", 0.0) + formation_metrics["max_err"]
  135. cost_flags = results.get("cost_flags", {})
  136. stats["collision_obs"] = stats.get("collision_obs", 0) + int(cost_flags.get("c3_any", False))
  137. stats["collision_obs_hard"] = stats.get("collision_obs_hard", 0) + int(cost_flags.get("c3_hard_any", False))
  138. stats["collision_nbr"] = stats.get("collision_nbr", 0) + int(cost_flags.get("c4_any", False))
  139. hard_collision = bool(cost_flags.get("c3_hard_any", False)) or bool(cost_flags.get("c4_any", False))
  140. stats["collision_free"] = stats.get("collision_free", 0) + int(not hard_collision)
  141. latency = results.get("latency", {})
  142. stats["lat_step_mean_sum"] = stats.get("lat_step_mean_sum", 0.0) + float(latency.get("step_mean_ms", 0.0))
  143. stats["lat_step_std_sum"] = stats.get("lat_step_std_sum", 0.0) + float(latency.get("step_std_ms", 0.0))
  144. stats["lat_step_p95_sum"] = stats.get("lat_step_p95_sum", 0.0) + float(latency.get("step_p95_ms", 0.0))
  145. stats["lat_decision_mean_sum"] = stats.get("lat_decision_mean_sum", 0.0) + float(latency.get("decision_mean_ms", 0.0))
  146. stats["lat_decision_std_sum"] = stats.get("lat_decision_std_sum", 0.0) + float(latency.get("decision_std_ms", 0.0))
  147. stats["lat_decision_p95_sum"] = stats.get("lat_decision_p95_sum", 0.0) + float(latency.get("decision_p95_ms", 0.0))
  148. stats["lat_step_overrun_count"] = stats.get("lat_step_overrun_count", 0) + int(latency.get("step_overrun_count", 0))
  149. stats["lat_step_count"] = stats.get("lat_step_count", 0) + int(latency.get("step_count", 0))
  150. stats["lat_budget_ms"] = float(latency.get("budget_ms", stats.get("lat_budget_ms", 0.0)))
  153. def _episode_diag(results: Dict[str, object]) -> Dict[str, object]:
  154. collision = results.get("collision")
  155. latency = results.get("latency", {})
  156. return {
  157. "safe_ok": bool(results.get("safe_ok")),
  158. "reach_ok": bool(results.get("reach_ok")),
  159. "formation_ok": bool(results.get("formation_ok")),
  160. "collision_obs": bool(results.get("cost_flags", {}).get("c3_any", False)),
  161. "collision_obs_hard": bool(results.get("cost_flags", {}).get("c3_hard_any", False)),
  162. "collision_nbr": bool(results.get("cost_flags", {}).get("c4_any", False)),
  163. "latency_step_mean_ms": float(latency.get("step_mean_ms", 0.0)),
  164. "latency_step_p95_ms": float(latency.get("step_p95_ms", 0.0)),
  165. "latency_step_overrun_ratio": float(latency.get("step_overrun_ratio", 0.0)),
  166. "failure_step": collision.get("step") if isinstance(collision, dict) else None,
  167. "failure_type": collision.get("type") if isinstance(collision, dict) else None,
  168. "min_clearance": results.get("min_clearance"),
  169. }
  172. def _finalize(stats: Dict[str, float]) -> Dict[str, float]:
  173. count = max(int(stats.get("count", 0)), 1)
  174. lat_step_count = max(int(stats.get("lat_step_count", 0)), 1)
  175. return {
  176. "count": int(stats.get("count", 0)),
  177. "collision_free_rate": float(stats.get("collision_free", 0) / count),
  178. "safe_ok_rate": float(stats.get("safe_ok", 0) / count),
  179. "reach_ok_rate": float(stats.get("reach_ok", 0) / count),
  180. "formation_ok_rate": float(stats.get("formation_ok", 0) / count),
  181. "formation_mean": float(stats.get("formation_mean", 0.0) / count),
  182. "formation_max": float(stats.get("formation_max", 0.0) / count),
  183. "collision_obs_rate": float(stats.get("collision_obs", 0) / count),
  184. "obstacle_margin_violation_rate": float(stats.get("collision_obs", 0) / count),
  185. "obstacle_hard_collision_rate": float(stats.get("collision_obs_hard", 0) / count),
  186. "collision_nbr_rate": float(stats.get("collision_nbr", 0) / count),
  187. "latency_budget_ms": float(stats.get("lat_budget_ms", 0.0)),
  188. "latency_step_mean_ms": float(stats.get("lat_step_mean_sum", 0.0) / count),
  189. "latency_step_std_ms": float(stats.get("lat_step_std_sum", 0.0) / count),
  190. "latency_step_p95_ms": float(stats.get("lat_step_p95_sum", 0.0) / count),
  191. "latency_decision_mean_ms": float(stats.get("lat_decision_mean_sum", 0.0) / count),
  192. "latency_decision_std_ms": float(stats.get("lat_decision_std_sum", 0.0) / count),
  193. "latency_decision_p95_ms": float(stats.get("lat_decision_p95_sum", 0.0) / count),
  194. "latency_step_overrun_ratio": float(stats.get("lat_step_overrun_count", 0) / lat_step_count),
  195. }
  198. def _build_final_summary(summary_raw: Dict[str, object], selected_methods: Tuple[str, ...]) -> Dict[str, object]:
  199. summary = copy.deepcopy(summary_raw)
  200. for scene_key, stats in summary["scene_stats"].items():
  201. for method in selected_methods:
  202. summary["scene_stats"][scene_key][method] = _finalize(stats[method])
  203. for bucket_key, stats in summary["bucket_stats"].items():
  204. for method in selected_methods:
  205. summary["bucket_stats"][bucket_key][method] = _finalize(stats[method])
  206. for method in selected_methods:
  207. summary["overall"][method] = _finalize(summary["overall"][method])
  208. return summary
  211. def _write_progress(
  212. progress_path: Path,
  213. summary_raw: Dict[str, object],
  214. rng: np.random.Generator,
  215. valid_eps: int,
  216. target_scene_counts: Dict[str, int],
  217. scene_ptr: int,
  218. ) -> None:
  219. payload = {
  220. "summary_raw": summary_raw,
  221. "rng_state": _to_jsonable(rng.bit_generator.state),
  222. "valid_eps": int(valid_eps),
  223. "target_scene_counts": {k: int(v) for k, v in target_scene_counts.items()},
  224. "scene_ptr": int(scene_ptr),
  225. }
  226. progress_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
  229. def _make_base_params() -> BaseSimParams:
  230. sp = BaseSimParams()
  231. sp.dt = 0.5
  232. sp.sim_time = 59.5
  233. setattr(sp, "safe_clearance_m", 0.5)
  234. setattr(sp, "safe_soft_band", 1.0)
  235. return sp
  238. def _make_modified_params() -> ModifiedSimParams:
  239. sp = ModifiedSimParams()
  240. setattr(sp, "safe_clearance_m", 0.5)
  241. return sp
  244. def main() -> None:
  245. parser = argparse.ArgumentParser()
  246. parser.add_argument("--model_dir", type=str, default="mlp_out")
  247. parser.add_argument("--num_episodes", type=int, default=50)
  248. parser.add_argument("--episodes_per_scene", type=int, default=50)
  249. parser.add_argument("--seed", type=int, default=2024)
  250. parser.add_argument("--out_path", type=str, default="results.json")
  251. parser.add_argument("--legacy_easy_only", action="store_true")
  252. parser.add_argument("--scene_dir", type=str, default="", help="use scene jsons from this dir instead of sample_scene")
  253. parser.add_argument("--methods", type=str, default="mlp,base_mpio,mpio", help="comma-separated subset of: mlp,base_mpio,mpio")
  254. parser.add_argument("--scene_types", type=str, default="", help="comma-separated scene types to run; default uses protocol scene set")
  255. parser.add_argument("--resume", action="store_true", help="resume from out_path.progress.json")
  256. parser.add_argument("--save_scene_dir", type=str, default="", help="save accepted eval scenes as ep_XXXXXX.json for later replay")
  257. args = parser.parse_args()
  259. selected_methods = tuple(_parse_csv_list(args.methods))
  260. if not selected_methods:
  261. raise SystemExit("no methods selected")
  262. invalid_methods = [m for m in selected_methods if m not in METHODS]
  263. if invalid_methods:
  264. raise SystemExit(f"unknown methods: {invalid_methods}; valid={METHODS}")
  266. requested_scene_types = tuple(_parse_csv_list(args.scene_types))
  267. invalid_scene_types = [s for s in requested_scene_types if s not in TARGET_SCENE_TYPES]
  268. if invalid_scene_types:
  269. raise SystemExit(f"unknown scene_types: {invalid_scene_types}; valid={TARGET_SCENE_TYPES}")
  271. model = None
  272. mean = std = None
  273. if "mlp" in selected_methods:
  274. model_dir = Path(args.model_dir)
  275. scaler = np.load(model_dir / "scaler.npz")
  276. mean = scaler["mean"]
  277. std = scaler["std"]
  279. ckpt = torch.load(model_dir / "model.pt", map_location="cpu")
  280. input_dim = int(ckpt.get("input_dim", mean.shape[0]))
  281. if mean.shape[0] != input_dim:
  282. raise SystemExit("scaler dim != model dim")
  284. model = torch.nn.Sequential(
  285. torch.nn.Linear(input_dim, 128),
  286. torch.nn.ReLU(),
  287. torch.nn.Linear(128, 64),
  288. torch.nn.ReLU(),
  289. torch.nn.Linear(64, 2),
  290. torch.nn.Sigmoid(),
  291. )
  292. state = ckpt["model_state"]
  293. if any(k.startswith("net.") for k in state.keys()):
  294. state = {k.replace("net.", "", 1): v for k, v in state.items()}
  295. model.load_state_dict(state, strict=True)
  296. model.eval()
  298. rng = np.random.default_rng(args.seed)
  300. def mlp_policy(i, P, V_xy, psi, lamb, obs_state, obstacles_plan, sp,
  301. ff_raw, fa_raw, fc_raw, vf_z, vo_raw, step_k, t):
  302. if model is None or mean is None or std is None:
  303. raise RuntimeError("mlp policy requested but model is not loaded")
  304. nbr_idx = neighbors_within(P, i, sp.R1_comm)
  305. neighbors = np.array([
  306. [P[j, 0], P[j, 1], V_xy[j, 0], V_xy[j, 1]] for j in nbr_idx
  307. ], dtype=float)
  308. obstacles = np.hstack([obstacles_plan, obs_state[:, 3:5]])
  309. feat = extract_features(
  310. pos_i=P[i, :],
  311. vel_i=V_xy[i, :],
  312. psi_i=psi[i],
  313. lamb_i=lamb[i],
  314. neighbors=neighbors,
  315. obstacles=obstacles,
  316. ve_xy=sp.ve_xy,
  317. )
  318. x = (feat - mean) / std
  319. with torch.no_grad():
  320. w = model(torch.from_numpy(x.astype(np.float32))).numpy()
  321. return np.clip(w.astype(float), 0.0, 1.0)
  323. balanced_mode = not args.scene_dir and not args.legacy_easy_only
  324. target_scene_types = list(requested_scene_types) if requested_scene_types else (
  325. list(TARGET_SCENE_TYPES) if balanced_mode else []
  326. )
  327. target_total_episodes = (
  328. len(target_scene_types) * args.episodes_per_scene
  329. if balanced_mode else args.num_episodes
  330. )
  332. summary = {
  333. "episodes": target_total_episodes,
  334. "valid_episodes": 0,
  335. "scene_sample_attempts": 0,
  336. "invalid_scene_skips": 0,
  337. "balanced_scene_eval": bool(balanced_mode),
  338. "episodes_per_scene": int(args.episodes_per_scene) if balanced_mode else None,
  339. "target_scene_types": target_scene_types,
  340. "selected_methods": list(selected_methods),
  341. "obstacle_metric_definition": "collision_obs_rate is evaluated on inflated boundary: dist_to_center < r_obs + safe_clearance_m",
  342. "latency_protocol": "step-level decision latency (sum over UAVs per sim step); overrun if latency > dt",
  343. "scene_stats": {},
  344. "bucket_stats": {},
  345. "overall": {method: {} for method in selected_methods},
  346. "episodes_detail": [],
  347. }
  349. scene_paths: List[Path] = []
  350. if args.scene_dir:
  351. scene_dir = Path(args.scene_dir)
  352. if not scene_dir.exists():
  353. raise SystemExit(f"scene_dir not found: {scene_dir}")
  354. scene_paths = sorted(scene_dir.glob("ep_*.json"))
  355. if requested_scene_types:
  356. scene_paths = [p for p in scene_paths if _load_scene_cfg(p).get("scene_type") in requested_scene_types]
  357. if not scene_paths:
  358. raise SystemExit(f"no scene jsons in {scene_dir} after scene_type filter")
  359. target_total_episodes = len(scene_paths) if args.num_episodes <= 0 else min(args.num_episodes, len(scene_paths))
  360. summary["episodes"] = target_total_episodes
  361. summary["balanced_scene_eval"] = False
  362. summary["episodes_per_scene"] = None
  363. summary["target_scene_types"] = list(requested_scene_types)
  365. sample_scene_fn = sample_scene_legacy_easy if args.legacy_easy_only else sample_scene
  366. target_scene_counts = {scene_type: 0 for scene_type in target_scene_types}
  367. valid_eps = 0
  368. scene_ptr = 0
  369. progress_path = _progress_path(Path(args.out_path))
  370. save_scene_dir = Path(args.save_scene_dir) if args.save_scene_dir else None
  371. if save_scene_dir is not None:
  372. save_scene_dir.mkdir(parents=True, exist_ok=True)
  374. if args.resume:
  375. if not progress_path.exists():
  376. raise SystemExit(f"resume requested but progress file not found: {progress_path}")
  377. payload = json.loads(progress_path.read_text(encoding="utf-8"))
  378. summary = payload["summary_raw"]
  379. valid_eps = int(payload.get("valid_eps", summary.get("valid_episodes", 0)))
  380. summary["valid_episodes"] = valid_eps
  381. target_scene_counts = {k: int(v) for k, v in payload.get("target_scene_counts", target_scene_counts).items()}
  382. scene_ptr = int(payload.get("scene_ptr", 0))
  383. rng.bit_generator.state = payload["rng_state"]
  384. print(f"[eval] resumed progress: {valid_eps}/{summary['episodes']} from {progress_path}", flush=True)
  386. max_attempts = max(target_total_episodes * 50, 1000)
  387. while valid_eps < target_total_episodes:
  388. summary["scene_sample_attempts"] += 1
  389. if summary["scene_sample_attempts"] > max_attempts:
  390. raise SystemExit(
  391. f"failed to collect {target_total_episodes} valid episodes after {summary['scene_sample_attempts']} attempts; "
  392. f"invalid_scene_skips={summary['invalid_scene_skips']}"
  393. )
  395. if scene_paths:
  396. if scene_ptr >= len(scene_paths):
  397. break
  398. scene_cfg = _load_scene_cfg(scene_paths[scene_ptr])
  399. scene_ptr += 1
  400. if scene_cfg.get("rng_seed") is None:
  401. scene_cfg["rng_seed"] = int(rng.integers(1, 1_000_000_000))
  402. elif balanced_mode:
  403. remaining_types = [
  404. scene_type for scene_type, count in target_scene_counts.items()
  405. if count < args.episodes_per_scene
  406. ]
  407. if not remaining_types:
  408. break
  409. scene_type = remaining_types[0]
  410. max_scene_tries = 500
  411. scene_cfg = {}
  412. for _ in range(max_scene_tries):
  413. scene_cfg = sample_scene(rng)
  414. if not scene_cfg:
  415. continue
  416. if scene_cfg.get("scene_type") != scene_type:
  417. continue
  418. break
  419. if not scene_cfg:
  420. raise SystemExit(f"failed to sample enough scenes for type={scene_type} after {max_scene_tries} tries")
  421. scene_cfg["rng_seed"] = int(rng.integers(1, 1_000_000_000))
  422. else:
  423. scene_cfg = sample_scene_fn(rng)
  424. if not scene_cfg or "scene_type" not in scene_cfg:
  425. summary["invalid_scene_skips"] += 1
  426. continue
  427. if requested_scene_types and scene_cfg["scene_type"] not in requested_scene_types:
  428. continue
  429. scene_cfg["rng_seed"] = int(rng.integers(1, 1_000_000_000))
  431. n_uav = int(scene_cfg.get("N_uav", 0))
  432. if not (N_RANGE[0] <= n_uav <= N_RANGE[1]):
  433. summary["invalid_scene_skips"] += 1
  434. continue
  435. scene_cfg["verbose_uav1"] = False
  436. scene_cfg["csv_path"] = ""
  438. results_by_method = {}
  439. if "mlp" in selected_methods:
  440. results_by_method["mlp"] = run_modified_episode(_make_modified_params(), scene_cfg, collect=False, policy_fn=mlp_policy)
  441. if "mpio" in selected_methods:
  442. results_by_method["mpio"] = run_modified_episode(_make_modified_params(), scene_cfg, collect=False, policy_fn=None)
  443. if "base_mpio" in selected_methods:
  444. results_by_method["base_mpio"] = run_base_episode(_make_base_params(), scene_cfg, collect=False)
  446. scene_key = scene_cfg["scene_type"]
  447. if balanced_mode and scene_key in target_scene_counts:
  448. if target_scene_counts[scene_key] >= args.episodes_per_scene:
  449. continue
  450. target_scene_counts[scene_key] += 1
  451. bucket_key = _n_bucket(scene_cfg["N_uav"])
  452. if save_scene_dir is not None:
  453. scene_path = save_scene_dir / f"ep_{valid_eps:06d}.json"
  454. _save_scene_json(scene_cfg, scene_path)
  455. summary["scene_stats"].setdefault(scene_key, _new_method_stats(selected_methods))
  456. summary["bucket_stats"].setdefault(bucket_key, _new_method_stats(selected_methods))
  458. ep_diag = {
  459. "scene_type": scene_key,
  460. "N_uav": int(scene_cfg["N_uav"]),
  461. "rng_seed": int(scene_cfg["rng_seed"]),
  462. }
  463. for method, result in results_by_method.items():
  464. ep_diag[method] = _episode_diag(result)
  465. _accumulate(summary["scene_stats"][scene_key][method], result, result["formation_metrics"])
  466. _accumulate(summary["bucket_stats"][bucket_key][method], result, result["formation_metrics"])
  467. _accumulate(summary["overall"][method], result, result["formation_metrics"])
  468. summary["episodes_detail"].append(ep_diag)
  470. valid_eps += 1
  471. summary["valid_episodes"] = valid_eps
  472. if balanced_mode:
  473. summary["scene_target_counts"] = {k: int(args.episodes_per_scene) for k in target_scene_types}
  474. summary["scene_actual_counts"] = {k: int(v) for k, v in target_scene_counts.items()}
  476. progress_scene = ""
  477. if balanced_mode and scene_key in target_scene_counts:
  478. progress_scene = f" [{scene_key} {target_scene_counts[scene_key]}/{args.episodes_per_scene}]"
  479. print(f"[eval] progress {valid_eps}/{target_total_episodes}{progress_scene}", flush=True)
  480. _write_progress(progress_path, summary, rng, valid_eps, target_scene_counts, scene_ptr)
  482. final_summary = _build_final_summary(summary, selected_methods)
  483. Path(args.out_path).write_text(json.dumps(final_summary, indent=2), encoding="utf-8")
  484. print(f"[eval] wrote {args.out_path}", flush=True)
  487. if __name__ == "__main__":
  488. main()

eval_closed_loop.py at commit 7f3212e, under MIT · at the source

Overview

Authors: Jinze Li1, Zeling Wen1, Zhaoke Ning1,2
ORCID iDs: Zeling Wen, Zhaoke Ning
  1. School of Aeronautics and Astronautics, Sichuan University, Chengdu 610207, China; (J.L.); (Z.W.)
  2. Multi-Source Information Intelligent Fusion Key Laboratory of Sichuan Province, Chengdu 610207, China
Institutions: Sichuan University (China)
Journal: Sensors (Basel, Switzerland), volume 26, issue 11, article 3398
Dates: received 17 April 2026; accepted 18 May 2026; published online 27 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/s26113398 · PMID 42280917 · PMCID PMC13259504 · OpenAlex W7162530465
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: cognitive (subfield)
Methods: Spectral & time-frequency, Machine learning
Keywords: UAV swarms, multi-objective optimization, neural surrogate, distributed control, real-time decision making
Topic: Distributed Control Multi-Agent Systems (Computer Networks and Communications, Computer Science), according to OpenAlex
Citations: not cited yet (Europe PMC); 33 references in the paper

Abstract

Real-time cooperative control of quadrotor swarms in cluttered environments requires balancing formation maintenance, obstacle avoidance, inter-UAV safety, and per-step computational cost. This paper proposes a multilayer perceptron (MLP) surrogate for high-level objective-weight selection in a modified multi-objective pigeon-inspired optimization (modified MPIO) distributed controller. The proposed MLP surrogate learns the state-to-weight mapping of the online search and directly predicts the two-dimensional objective-weight vector, while the original flocking, gap-based obstacle-avoidance, and command generation rules are retained unchanged. The surrogate is trained from teacher-generated weight labels using randomized scenes, DAgger-based state aggregation, and risk-weighted supervision. On a fixed closed-loop benchmark, the proposed controller increases the true collision free rate from 48.00% to 86.89% and the safe success rate from 38.67% to 74.22% relative to modified MPIO, while reducing the mean per-step decision latency for the whole swarm from 8494.70 ms to 0.92 ms. The improvement is most pronounced in safety-related and runtime metrics, while the formation-related gain is comparatively modest. Ablation results show that the final benchmark performance is not explained by DAgger or risk weighting alone, and that the medium-sized surrogate provides the best safety-latency tradeoff among the tested network architectures. A qualitative AirSim case study further indicates that the same high-level surrogate controller can be executed in a higher-fidelity asynchronous multirotor simulator.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 4 matches between paragraphs and lines of code.

cliche71/quadrotor-swarm-neural-surrogate

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 7f3212e243f2375c2b727b222a329a6325aad774, 19 April 2026
Languages: Python (8)
Size: 30 files, 8 scripts
Software Heritage: not archived
Found in: the text, “1. Introduction”
Holds: README, license file, environment (requirements-airsim.txt, requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (7 files), PyTorch (4 files), Matplotlib (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
10 files
At the source: github.com/cliche71/quadrotor-swarm-neural-surrogate.git

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 8 scripts, each with its path and the digest of its content;
  • 4 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability Statement

The datasets generated and analyzed during the current study are not publicly archived. They are available from the first author upon reasonable request. The source code supporting the implementation is available in the public repository cited in the manuscript.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 5 keywords, 30 references.

Cite

This paper

Li, J., Wen, Z., & Ning, Z. (2026). Neural Surrogate-Enhanced Metaheuristic Optimization for Distributed Quadrotor Swarm Control. Sensors (Basel, Switzerland), 26(11), 3398. https://doi.org/10.3390/s26113398

BibTeX

@article{li2026neural,
author = {Li, Jinze and Wen, Zeling and Ning, Zhaoke},
title = {{Neural Surrogate-Enhanced Metaheuristic Optimization for Distributed Quadrotor Swarm Control}},
journal = {Sensors (Basel, Switzerland)},
year = {2026},
month = may,
volume = {26},
number = {11},
pages = {3398},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {1424-8220},
doi = {10.3390/s26113398},
url = {https://doi.org/10.3390/s26113398},
pmid = {42280917},
pmcid = {PMC13259504}
}

RIS

TY - JOUR
AU - Li, Jinze
AU - Wen, Zeling
AU - Ning, Zhaoke
TI - Neural Surrogate-Enhanced Metaheuristic Optimization for Distributed Quadrotor Swarm Control
T2 - Sensors (Basel, Switzerland)
J2 - Sensors (Basel)
PY - 2026
DA - 2026/05/27
VL - 26
IS - 11
SP - 3398
SN - 1424-8220
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/s26113398
UR - https://doi.org/10.3390/s26113398
LA - en
ER -

CSL-JSON

{
"id": "10.3390/s26113398",
"type": "article-journal",
"title": "Neural Surrogate-Enhanced Metaheuristic Optimization for Distributed Quadrotor Swarm Control",
"container-title": "Sensors (Basel, Switzerland)",
"author": [
{
"family": "Li",
"given": "Jinze"
},
{
"family": "Wen",
"given": "Zeling"
},
{
"family": "Ning",
"given": "Zhaoke"
}
],
"container-title-short": "Sensors (Basel)",
"volume": "26",
"issue": "11",
"page": "3398",
"DOI": "10.3390/s26113398",
"PMID": "42280917",
"PMCID": "PMC13259504",
"ISSN": "1424-8220",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/s26113398",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
27
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.3390/biomimetics11040288 [code]
BioLAMR: A Biomimetically Inspired Large Language Model Adaptation Framework for Automatic Modulation Recognition.
Journal: Biomimetics (Basel, Switzerland)
In common: PyTorch, Matplotlib, NumPy, 1 reference
[2] doi:10.3389/fneur.2026.1831912
Efficient EEG channel-and-frequency-band selection for epileptic seizure classification using multi-objective optimization.
Journal: Frontiers in neurology
In common: 1 reference

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.