Published August 24, 2026 | Version MSMU_SST_CO

suhelahamed/MSMU_SST_CO: MSMU_SST_CO

  • 1. GGV, Bilaspur

Description

MSMU-SST-CO: Edge-AI-based Selective Subtask Offloading in UAV-Supported MEC

Version 1.0 · Reproducible seed 42 DOI: 10.5281/zenodo.22084174

This repository contains the generation pipeline, datasets, and experiment code for an Edge-AI-based selective subtask computation offloading framework in UAV-supported multi-server multi-user mobile edge computing (MEC).

The project:

  • Generates base task-level MEC offloading scenarios using the MCMF solver from the MSMU-CO tool as an offline oracle for optimal task-level offloading decisions.
  • Decomposes each user task into K = 3 subtasks and derives oracle selective-offloading labels under the MSMU-CO cost model.
  • Augments the environment with UAV-supported MEC semantics: UAV versus ground servers, 3D geometry, elevation, and line-of-sight probability.
  • Trains a lightweight Edge-AI model (MLP) to predict per-subtask offloading decisions from task, channel, and UAV context.
  • Benchmarks against naive baselines (all-local, all-MCMF, random) and an LR-style greedy optimization baseline.

MSMU-SST-CO is the first release in a dataset family. It is extended by MSMU-UAV-CO, which adds a time horizon and a 100-UAV swarm.

1. Provenance and Originality

All data in this release is original work, generated by the scripts distributed with it.

generate_base_dataset.py imports two functions — solve_once and range_random — at runtime from the MSMU-CO generation tool of Liang et al. (github.com/qiyu3816/MSMU-CO), which the user clones separately (§3.1), and calls them with the parameters specified in that script. All remaining logic is original to this project, including the bipartite connectivity construction, the cost-model evaluation, the subtask decomposition and oracle labelling, the UAV overlay, the Edge-AI model, and the baselines.

Specifically:

  • No MSMU-CO data is used or redistributed. The 800 scenarios here were generated, not downloaded. Their regimes — S ∈ {3, 5} × U ∈ {10, 20} — do not correspond to any server/user combination in the published MSMU-CO dataset release.
  • No MSMU-CO code is redistributed. The two imported functions are loaded at runtime from a repository the user clones independently; no upstream source file is included here.
  • The cost model follows the formulation published by Liang et al. and is cited accordingly. It is reimplemented in this project's own code.
  • generate_graph in generate_base_dataset.py mirrors the structure of the upstream connectivity generator, with a documented fix: it caps a user's connection count at the available server count, which the original does not, and which raises a sampling error at S = 3. The deviation is noted in the function docstring.

The pipeline is deterministic (random.seed(42), np.random.seed(42)), so all outputs regenerate exactly.

2. Project Overview

2.1 Problem Setting

A multi-server multi-user MEC system in which each ground user generates a computation task that may be processed locally or offloaded to one of several edge servers (UAV-borne or ground). Each task is decomposed into three subtasks — pre-processing, heavy compute, and post-processing — enabling selective subtask offloading rather than all-or-nothing offload.

The objective minimises a weighted sum of latency and energy per user, subject to server capacity constraints, using user-specific latency–energy trade-off weights alpha.

2.2 Pipeline

Step Script Produces
1. Base scenario generation generate_base_dataset.py data/raw/base_msmu_raw.parquet
2. Subtask mutation + oracle labels build_subtask_dataset.py data/subtask/{train,val,test}_subtask.parquet
3. UAV augmentation build_uav_dataset.py data/uav_subtask/{train,val,test}_uav.parquet
4. Edge-AI training + evaluation train_edge_ai.py models/, output/
5. LR-greedy baseline add_lr_greedy.py updated output/

3. Repository Structure

MSMU_SST_CO/
  data/
    raw/                        # base task-level scenarios
      base_msmu_raw.parquet
      base_msmu_config.json     # global parameter sidecar
    subtask/                    # subtask-level datasets + oracle labels
      train_subtask.parquet
      val_subtask.parquet
      test_subtask.parquet
    uav_subtask/                # UAV-augmented subtask datasets
      train_uav.parquet
      val_uav.parquet
      test_uav.parquet
      user_positions.parquet
      server_positions.parquet
  models/
    subtask_uav_mlp.pt          # trained Edge-AI MLP checkpoint
  output/
    results_metrics.csv         # per-user metrics per method
    summary_metrics.csv         # aggregated metrics
    summary_table.tex           # LaTeX table
    latency_cdf.png
    energy_bar.png
    deadline_bar.png
    uav_vs_ground_latency.png
  generate_base_dataset.py
  build_subtask_dataset.py
  build_uav_dataset.py
  train_edge_ai.py
  add_lr_greedy.py
  README.md
 

MSMU-CO/ is not included; clone it into the repository root before running Step 1 (§3.1 below).

4. Dependencies and Setup

4.1 MSMU-CO generation tool

Step 1 imports two functions from the MSMU-CO tool, which must be present at ./MSMU-CO/generate_explorative_data.py:

git clone https://github.com/qiyu3816/MSMU-CO.git
 

MSMU-CO is a separate work by other authors, described as a dataset generation tool based on minimum-cost multi-commodity flow (MCMF) for multi-server multi-user computation offloading. At the time of writing its repository carries no license file; consult it for current terms. Nothing in this release redistributes it.

Steps 2–5 have no MSMU-CO dependency and run from this project's own outputs.

4.2 Python environment

Python 3.10 or later.

pip install numpy pandas pyarrow scipy networkx torch matplotlib seaborn
 

5. Reproducing the Pipeline

5.1 Step 1 — Base scenarios

python generate_base_dataset.py
 

Generates 200 scenarios in each of four regimes (S ∈ {3, 5} × U ∈ {10, 20}), for 800 scenarios and 12,000 users total, in long format with one row per (scenario, user) pair.

For each user the table records task data size, required CPU cycles, local CPU frequency, the latency–energy weight alpha, connectivity count, channel gains, and the MCMF-optimal assignment (mcmf_assigned_server, with −1 denoting local execution) together with its resource-allocation ratio.

Global parameters, constant across servers and attached to every row plus written to base_msmu_config.json:

Parameter Value Meaning
F_t 3.36 × 10¹⁰ cycles/s Server CPU capacity
theta 2.0 s Maximum tolerable delay
P_t 0.3 W Transmit power
P_I 0.15 W Device power while awaiting remote execution
kappa 1 × 10⁻²⁸ Local-computation energy coefficient
B 8 × 10⁷ Hz Channel bandwidth (80 MHz)
N0 7.96159 × 10⁻¹³ Noise power
input size 2 – 11 Mbit Truncated normal, μ = 6.5 Mbit, σ = 3 Mbit
local CPU freq 1 – 10 GHz Truncated normal, μ = 6.4 GHz, σ = 5 GHz
cycles per bit 3 × 10³ required_cycles = input_size × 3000

Note. theta denotes the maximum tolerable delay in seconds, not a path-loss exponent. It is used in the feasibility tests local_sat, trans_sat, and offload_sat.

5.2 Step 2 — Subtask mutation and oracle labels

python build_subtask_dataset.py
 

Loads data/raw/base_msmu_raw.parquet and splits each user task into K = 3 subtasks (pre, heavy, post) with random weights. Three patterns are evaluated per user under the MSMU-CO cost model:

  • P1 — all subtasks offloaded to the MCMF anchor server
  • P2 — selective offload (heavy subtasks offloaded, light ones local)
  • P3 — all local

The minimum-cost pattern becomes the oracle selective-offloading decision, yielding labels exec_location_label (0 = local, 1 = offload), exec_is_local, and exec_server_index. Output is split into train / val / test by scenario_id, producing 36,000 subtask rows.

5.3 Step 3 — UAV augmentation

python build_uav_dataset.py
 

For each scenario, designates 1–2 servers as UAVs and the rest as ground servers, samples 3D positions for all servers (UAVs at altitude, ground at z = 0) and positions for all users, then derives distances, elevation angle, LoS probability, and effective rate to the anchor server, plus scenario-level context (UAV count, minimum distance to any UAV, coverage indicators).

5.4 Step 4 — Edge-AI training and evaluation

python train_edge_ai.py
 

Trains an MLP classifier (21 → 256 → 128 → 1, ReLU with dropout) with BCE loss and Adam on train_uav.parquet and val_uav.parquet, using task, subtask, global, and UAV-context features against target exec_location_label. The best checkpoint is saved to models/subtask_uav_mlp.pt.

Evaluation on test_uav.parquet compares against the oracle, all-local, all-MCMF, and random baselines, reusing the same cost model to compute per-user latency, energy, and cost; deadline violation rate (deadline = 1.5 × median oracle latency); and subtask-level classification metrics (accuracy, precision, recall, F1, AUC).

5.5 Step 5 — LR-greedy baseline

python add_lr_greedy.py
 

Computes, for each user, the cost difference between all-local and all-offload-to-anchor, sorts users by cost gain, and greedily admits offloading subject to server capacity. Results are added to output/ as method lr_greedy and the figures are regenerated.

6. Main Artifacts

  • models/subtask_uav_mlp.pt — trained Edge-AI MLP
  • output/results_metrics.csv — per-user, per-method metrics on the test set
  • output/summary_metrics.csv — aggregated metrics (mean ± std) per method
  • output/summary_table.tex — LaTeX summary of latency, energy, cost, deadline violation, and accuracy
  • output/latency_cdf.png, energy_bar.png, deadline_bar.png, uav_vs_ground_latency.png

7. Adapting This Pipeline

  • Substitute a different base generator in generate_base_dataset.py.
  • Change the subtask structure or cost model in build_subtask_dataset.py.
  • Alter UAV geometry or the channel model in build_uav_dataset.py.
  • Replace the MLP in train_edge_ai.py with another model class (GNN, transformer, DRL).
  • Add baselines alongside add_lr_greedy.py.

8. Related Resources

MSMU-UAV-CO — time-indexed 100-UAV swarm extension of this dataset. Ahamed, S., & Dewangan, A. K. (2026). IEEE DataPort. https://doi.org/10.21227/gzx7-k572

MSMU-CO tool — scenario generator and MCMF solver used in Step 1. Liang, R. (2024). MSMU-CO: A dataset generation tool based on minimum-cost multi-commodity flow for multi-server multi-user computation offloading [Computer software]. GitHub. https://github.com/qiyu3816/MSMU-CO

MSMU-CO dataset — published instances and origin of the cost-model formulation. Liang, R., Yang, B., Chen, P., Cao, X., Yu, Z., Debbah, M., Poor, H. V., & Yuen, C. (2024). A dataset for multi-server multi-user computation offloading [Data set]. IEEE DataPort. https://doi.org/10.21227/386p-7h83

9. Citation

@software{ahamed2026msmusstco,
  author    = {Ahamed, Suhel},
  title     = {{MSMU-SST-CO}: Edge-AI-based Selective Subtask Offloading
               in {UAV}-Supported {MEC}},
  year      = {2026},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.22084174}
}
 

Please also cite the MSMU-CO tool and dataset of Liang et al., whose cost-model formulation this project follows.

10. License

  • Data (all .parquet, .json, .csv files under data/ and output/): CC BY 4.0 — see LICENSE-DATA
  • Code (all .py files): Apache License 2.0 — see LICENSE

The MSMU-CO tool referenced in §4.1 is a separate work by other authors and is not covered by these terms.

11. Contact

Suhel Ahamed Department of Information Technology Guru Ghasidas Vishwavidyalaya, Bilaspur, Chhattisgarh, India suhelahamed@ieee.org · @suhelahamed

README.md

The code and data here reproduce the main experiments reported in the associated research manuscript.

Note on the uplink rate model (clarification added 15 October 2026; no data file changed).
The oracle labels and every reported cost use the uplink rate R = B log2(1 + x) with x = P_tx h^2 / (N0 + P_tx h^2), where h is the user’s best channel gain. This is a bounded, single-user form of the MSMU-CO generator’s expression, so users do not interfere with one another on the uplink and each offloading user may use the full bandwidth B. Earlier documents call x an “SINR”; it is not a signal-to-interference-plus-noise ratio in the usual sense. Because P_tx h^2 is far above N0 for every user, R lies between 79.999921 and 80.000000 Mbit/s for all 36,000 subtask rows, so the channel gain has practically no effect on the cost; offloading decisions are driven by the 0.2 s setup delay, the workload, the server share and the latency-energy weight. The UAV-augmentation column assigned_effective_rate uses x = P_tx h_eff / N0 (a signal-to-noise ratio); it is descriptive only and is not used in any cost. Users are coupled through the MCMF server assignment and the sharing of server CPU. Details and the script check_rates.py that reports these numbers: https://github.com/suhelahamed/MSMU_SST_CO/tree/v1.0.1 (README section 5.3a).

Files

suhelahamed/MSMU_SST_CO-MSMU_SST_CO.zip

Files (7.6 MB)

Name Size
md5:9eddcfcca23cc33cc55750088666e0c2
7.6 MB Preview Download

Additional details

Related works