suhelahamed/MSMU_SST_CO: MSMU_SST_CO
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_graphingenerate_base_dataset.pymirrors 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.
thetadenotes the maximum tolerable delay in seconds, not a path-loss exponent. It is used in the feasibility testslocal_sat,trans_sat, andoffload_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 MLPoutput/results_metrics.csv— per-user, per-method metrics on the test setoutput/summary_metrics.csv— aggregated metrics (mean ± std) per methodoutput/summary_table.tex— LaTeX summary of latency, energy, cost, deadline violation, and accuracyoutput/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.pywith 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,.csvfiles underdata/andoutput/): CC BY 4.0 — seeLICENSE-DATA - Code (all
.pyfiles): Apache License 2.0 — seeLICENSE
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
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
Additional details
Related works
- Is supplement to
- Software: https://github.com/suhelahamed/MSMU_SST_CO/tree/MSMU_SST_CO (URL)
Software
- Repository URL
- https://github.com/suhelahamed/MSMU_SST_CO