OSCR

Drift-Robust Lightweight Deep Learning on Open Gas Sensor Benchmarks: A Reproducible Architecture Study with CBRN Applicability Mapping.

Code ↔ Paper

16 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 16 matches
  1. [1] § 2. Materials and Methods › 2.4. LiteSensor-Net Architecture ↔ code/modules/models.py, lines 19–35 · score 0.82 · sensor channel separability, ReLU, Cross sensor, axis, mixing, BN
  2. [2] § 2. Materials and Methods › 2.4. LiteSensor-Net Architecture ↔ code/modules/training.py, lines 21–63 · score 0.77 · cosine annealing, weight decay, AdamW, cross entropy, min, loss
  3. [3] § 2. Materials and Methods › 2.7. Domain–Adaptation Task Definitions ↔ code/eval_drift_taskB.py, lines 1–36 · score 0.74 · cumulative training scenario, DRCA fair, fine tuning, KD DM, target batch, held
  4. [4] § 2. Materials and Methods › 2.6. Knowledge-Distillation Drift-Compensation Module ↔ code/analysis_main.py, lines 167–290 · score 0.74 · KD DM unsup, DRCA fair, fine tuning, unsupervised, pseudo, temperature
  5. [5] § 2. Materials and Methods › 2.4. LiteSensor-Net Architecture ↔ code/eval_compression.py, lines 31–129 · score 0.72 · ReLU, pointwise, FC, DSConv, activations, BN
  6. [6] § 2. Materials and Methods › 2.4. LiteSensor-Net Architecture ↔ code/run_litesensor_t1.py, lines 64–105 · score 0.72 · weight decay, AdamW, cross entropy, smoothing, cosine, validation
  7. [7] § 2. Materials and Methods › 2.6. Knowledge-Distillation Drift-Compensation Module ↔ code/run_combo2.py, lines 259–338 · score 0.72 · stratified random, cross entropy, fine tuning, KD DM, target batch, KL
  8. [8] § 2. Materials and Methods › 2.5. Multi-Stage Compression › 2.5.1. INT8 Post-Training Quantization ↔ code/run_t3_qat.py, lines 1–31 · score 0.63 · Quantization aware training, QAT, fine tuning, PTQ, Post, weights
  9. [9] § 3. Results › 3.4. Sensor Drift Compensation › 3.4.1. Task A: Laboratory Re-Calibration Scenario ↔ code/run_kdm_v4.py, lines 115–239 · score 0.61 · KD DM unsup, DRCA fair, Random Forest, target batch, NC, chronological
  10. [10] § 3. Results › 3.4. Sensor Drift Compensation › 3.4.1. Task A: Laboratory Re-Calibration Scenario ↔ code/analysis_main.py, lines 167–290 · score 0.60 · KD DM unsup, DRCA fair, Random Forest, NC, chronological, fraction
  11. [11] § 3. Results › 3.3. CBRN Simulant Classification Performance ↔ code/eval_classification.py, lines 61–146 · score 0.59 · confusion matrix, macro F1, recall, CWA, precision, scores
  12. [12] § 2. Materials and Methods › 2.5. Multi-Stage Compression › 2.5.1. INT8 Post-Training Quantization ↔ code/eval_compression.py, lines 1–21 · score 0.57 · TensorFlow, INT8 quantized, activations, weights, Lite
  13. [13] § 2. Materials and Methods › 2.3. Preprocessing Pipeline ↔ code/modules/data_loader.py, lines 128–140 · score 0.54 · Feature selection, Random Forest, Gini, Batch
  14. [14] § 2. Materials and Methods › 2.6. Knowledge-Distillation Drift-Compensation Module ↔ code/run_combo2.py, lines 259–338 · score 0.53 · soft target, fine tuning, KD DM, ensemble, logits, student
  15. [15] § 2. Materials and Methods › 2.7. Domain–Adaptation Task Definitions ↔ code/run_kdm_v4.py, lines 115–239 · score 0.53 · KD DM unsup, DRCA fair, target batch, NC, fraction
  16. [16] § 2. Materials and Methods › 2.6. Knowledge-Distillation Drift-Compensation Module ↔ code/run_s1_30splits.py, lines 18–118 · score 0.53 · member ensemble, fine tuning, KD DM, supervision, student, teacher

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 · 431 lines · 18 KB · Apache-2.0 · 2 matches

  1. """Re-experiment orchestrator (CHUNK MODE) — Molecules MS-4274054 R1 revision.
  3. Sandbox bash call has a 45 s limit, so each invocation runs **ONE** chunk and
  4. exits, persisting state to disk. Subsequent calls resume.
  6. Chunk identifiers
  7. p2_s{seed_idx} : Phase 2 — all 4 archs × 1 seed × Batch 1
  8. p3_b{batch_id}_s{seed_idx} : Phase 3 — 1 target batch × 1 seed × all 5 conditions
  9. p4 : Phase 4 — compression breakdown + sanity + summary
  11. State files
  12. results/progress.json : list of completed chunks
  13. results/raw_results_benchmark.csv : appended after each p2 chunk
  14. results/raw_results_drift.csv : appended after each p3 chunk
  15. results/experiment_summary.json : written by p4
  17. Usage
  18. python analysis_main.py --resume # auto-pick next chunk
  19. python analysis_main.py --chunk p2_s0 --device cpu # explicit chunk
  20. python analysis_main.py --chunk p3_b2_s0
  21. python analysis_main.py --chunk p4
  22. """
  23. from __future__ import annotations
  24. import argparse
  25. import csv
  26. import json
  27. import os
  28. import random
  29. import sys
  30. import time
  31. from pathlib import Path
  32. from typing import List
  34. import numpy as np
  35. import pandas as pd
  36. import torch
  37. import yaml
  39. ROOT = Path(__file__).resolve().parent
  40. sys.path.insert(0, str(ROOT))
  42. from modules import data_loader as DL
  43. from modules import models as M
  44. from modules import compression as C
  45. from modules import kd_dm as KD
  46. from modules import evaluate as EV
  47. from modules import training as TR
  50. def set_seed(seed: int):
  51. random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
  52. torch.backends.cudnn.deterministic = True
  55. def reshape_for_sensors(X: np.ndarray) -> np.ndarray:
  56. return DL.reshape_for_sensors(X, n_sensors=16, n_feat_per_sensor=8)
  59. # =================================================================
  60. # Chunk planning
  61. # =================================================================
  62. def all_chunks(cfg: dict) -> List[str]:
  63. seeds = cfg["statistics"]["seeds"]
  64. chunks = [f"p2_s{i}" for i in range(len(seeds))]
  65. for bid in range(2, cfg["dataset"]["n_batches"] + 1):
  66. for i in range(len(seeds)):
  67. chunks.append(f"p3_b{bid}_s{i}")
  68. chunks.append("p4")
  69. return chunks
  72. def load_progress(path: Path) -> set:
  73. if path.exists():
  74. return set(json.loads(path.read_text()).get("done", []))
  75. return set()
  78. def save_progress(path: Path, done: set):
  79. path.write_text(json.dumps({"done": sorted(done),
  80. "ts": time.strftime("%Y-%m-%dT%H:%M:%S")},
  81. indent=2))
  84. # =================================================================
  85. # CSV append helpers
  86. # =================================================================
  87. BENCH_HEADERS = ["chunk_id", "seed", "model", "value", "macro_f1", "params",
  88. "size_fp32_kB", "size_int8_kB", "infer_ms", "train_s", "best_val_acc"]
  89. DRIFT_HEADERS = ["chunk_id", "seed", "target_batch", "method", "variant",
  90. "acc", "macro_f1", "n_test"]
  93. def append_csv(path: Path, headers: list, rows: list[dict]):
  94. new = not path.exists()
  95. with path.open("a", newline="") as f:
  96. w = csv.DictWriter(f, fieldnames=headers)
  97. if new: w.writeheader()
  98. for r in rows:
  99. w.writerow({k: r.get(k, "") for k in headers})
  102. # =================================================================
  103. # Phase 2 chunk
  104. # =================================================================
  105. def run_p2_chunk(seed_idx: int, cfg: dict, batches, device: str) -> list[dict]:
  106. seed = cfg["statistics"]["seeds"][seed_idx]
  107. set_seed(seed)
  108. b1 = batches[0]
  109. n = len(b1.y)
  110. n_test = max(2, int(0.30 * n))
  111. Xtr_full = b1.X[:n - n_test]; ytr_full = b1.y[:n - n_test]
  112. Xte = b1.X[n - n_test:]; yte = b1.y[n - n_test:]
  113. mu, sigma = DL.fit_standardiser(Xtr_full)
  114. Xtr_full = DL.standardise(Xtr_full, mu, sigma)
  115. Xte = DL.standardise(Xte, mu, sigma)
  117. idx = np.arange(len(ytr_full)); np.random.shuffle(idx); v = int(0.20 * len(idx))
  118. val_i, tr_i = idx[:v], idx[v:]
  119. Xtr = reshape_for_sensors(Xtr_full[tr_i]); ytr = ytr_full[tr_i] - 1
  120. Xv = reshape_for_sensors(Xtr_full[val_i]); yv = ytr_full[val_i] - 1
  121. Xtest = reshape_for_sensors(Xte); ytest = yte - 1
  123. model_specs = {
  124. "litesensor": cfg["models"]["liteSensor"],
  125. "mobilenet1d": cfg["models"]["mobileNet1D"],
  126. "inceptiontime1d": cfg["models"]["inceptionTime1D"],
  127. "resnet1d": cfg["models"]["resNet1D"],
  128. }
  129. n_classes = cfg["dataset"]["n_classes"]
  130. rows = []
  131. for name, mc in model_specs.items():
  132. model = M.build(name, n_classes=n_classes, in_ch=16, **mc)
  133. t0 = time.time()
  134. res = TR.train_supervised(
  135. model, Xtr, ytr, Xv, yv,
  136. epochs=cfg["training"]["epochs_source"],
  137. lr=cfg["training"]["lr"],
  138. batch_size=cfg["training"]["batch_size_source"],
  139. weight_decay=cfg["training"]["weight_decay"],
  140. device=device,
  141. )
  142. train_s = time.time() - t0
  143. model.load_state_dict(res.best_state)
  144. yhat = TR.predict(model, Xtest, device=device)
  145. t1 = time.time()
  146. for _ in range(3):
  147. _ = TR.predict(model, Xtest[:1], device=device)
  148. inf_ms = (time.time() - t1) / 3 * 1000
  149. n_params = M.count_parameters(model)
  150. rows.append({
  151. "chunk_id": f"p2_s{seed_idx}",
  152. "seed": seed, "model": name,
  153. "value": EV.accuracy(ytest, yhat),
  154. "macro_f1": EV.macro_f1(ytest, yhat),
  155. "params": n_params,
  156. "size_fp32_kB": round(n_params * 4 / 1024, 2),
  157. "size_int8_kB": round(n_params / 1024, 2),
  158. "infer_ms": round(inf_ms, 2),
  159. "train_s": round(train_s, 1),
  160. "best_val_acc": res.best_val_acc,
  161. })
  162. print(f" {name:18s} acc={rows[-1]['value']:.4f} f1={rows[-1]['macro_f1']:.4f} "
  163. f"params={n_params:,} inf={inf_ms:.2f}ms train={train_s:.1f}s")
  164. return rows
  167. # =================================================================
  168. # Phase 3 chunk
  169. # =================================================================
  170. def run_p3_chunk(batch_id: int, seed_idx: int, cfg: dict, batches, device: str) -> list[dict]:
  171. seed = cfg["statistics"]["seeds"][seed_idx]
  172. set_seed(seed)
  173. b1 = batches[0]
  174. n = len(b1.y); n_test = max(2, int(0.30 * n))
  175. Xtr_b1, ytr_b1 = b1.X[:n - n_test], b1.y[:n - n_test]
  176. mu, sigma = DL.fit_standardiser(Xtr_b1)
  177. Xtr_b1n = DL.standardise(Xtr_b1, mu, sigma)
  178. cfg_lite = cfg["models"]["liteSensor"]
  179. n_classes = cfg["dataset"]["n_classes"]
  180. epochs_src = cfg["training"]["epochs_source"]
  181. epochs_kd = cfg["training"]["epochs_kd_finetune"]
  183. Xtr = reshape_for_sensors(Xtr_b1n); ytr = ytr_b1 - 1
  184. idx = np.arange(len(ytr)); np.random.shuffle(idx); v = int(0.20 * len(idx))
  185. teacher = M.build("litesensor", n_classes=n_classes, in_ch=16, **cfg_lite)
  186. res = TR.train_supervised(
  187. teacher, Xtr[idx[v:]], ytr[idx[v:]], Xtr[idx[:v]], ytr[idx[:v]],
  188. epochs=epochs_src, lr=cfg["training"]["lr"],
  189. batch_size=cfg["training"]["batch_size_source"], device=device,
  190. )
  191. teacher.load_state_dict(res.best_state)
  193. batch = batches[batch_id - 1] # batch_id 2..10 → index 1..9
  194. X_b = DL.standardise(batch.X, mu, sigma)
  195. rows = []
  197. # NC
  198. il, iu, ite = DL.stratified_chronological_split(
  199. DL.BatchData(batch.batch_id, X_b, batch.y, batch.order),
  200. target_labeled_fraction=0.20,
  201. test_holdout_fraction=cfg["splits"]["test_holdout_fraction"],
  202. rng=np.random.default_rng(seed),
  203. )
  204. Xte_t = reshape_for_sensors(X_b[ite]); yte_t = batch.y[ite] - 1
  205. yhat_nc = TR.predict(teacher, Xte_t, device=device)
  206. rows.append(_drow(seed_idx, seed, batch.batch_id, "NC", "supervised_00",
  207. EV.accuracy(yte_t, yhat_nc), EV.macro_f1(yte_t, yhat_nc), len(yte_t)))
  209. # KD-DM ablation
  210. for frac in cfg["splits"]["target_labeled_fraction"]:
  211. il_f, iu_f, ite_f = DL.stratified_chronological_split(
  212. DL.BatchData(batch.batch_id, X_b, batch.y, batch.order),
  213. target_labeled_fraction=frac,
  214. test_holdout_fraction=cfg["splits"]["test_holdout_fraction"],
  215. rng=np.random.default_rng(seed + int(frac * 100)),
  216. )
  217. if len(il_f) == 0:
  218. continue # no labeled samples for this batch
  219. Xl = reshape_for_sensors(X_b[il_f])
  220. yl = torch.as_tensor(batch.y[il_f] - 1, dtype=torch.long)
  221. Xu = reshape_for_sensors(X_b[iu_f]) if len(iu_f) > 0 else np.zeros((0, 16, 8), dtype=np.float32)
  222. student = M.build("litesensor", n_classes=n_classes, in_ch=16, **cfg_lite)
  223. student.load_state_dict(teacher.state_dict())
  224. student, _ = KD.fine_tune_kd_dm(
  225. teacher, student,
  226. torch.as_tensor(Xl, dtype=torch.float32),
  227. yl,
  228. torch.as_tensor(Xu, dtype=torch.float32),
  229. epochs=epochs_kd, alpha=cfg["kd_dm"]["alpha"], T=cfg["kd_dm"]["temperature"],
  230. lr=cfg["training"]["lr"], device=device,
  231. batch_size=cfg["training"]["batch_size_target"],
  232. )
  233. Xte_test = reshape_for_sensors(X_b[ite_f]); yte_test = batch.y[ite_f] - 1
  234. yhat = TR.predict(student, Xte_test, device=device)
  235. rows.append(_drow(seed_idx, seed, batch.batch_id,
  236. f"KD-DM-{int(frac*100):02d}", f"supervised_{int(frac*100):02d}",
  237. EV.accuracy(yte_test, yhat), EV.macro_f1(yte_test, yhat), len(yte_test)))
  239. # KD-DM-unsup
  240. il0, iu0, ite0 = DL.stratified_chronological_split(
  241. DL.BatchData(batch.batch_id, X_b, batch.y, batch.order),
  242. target_labeled_fraction=0.0,
  243. test_holdout_fraction=cfg["splits"]["test_holdout_fraction"],
  244. rng=np.random.default_rng(seed + 999),
  245. )
  246. Xall_unsup = reshape_for_sensors(np.concatenate([X_b[il0], X_b[iu0]], axis=0))
  247. student = M.build("litesensor", n_classes=n_classes, in_ch=16, **cfg_lite)
  248. student.load_state_dict(teacher.state_dict())
  249. student, _ = KD.fine_tune_kd_dm(
  250. teacher, student,
  251. torch.zeros(0, 16, 8), torch.zeros(0, dtype=torch.long),
  252. torch.as_tensor(Xall_unsup, dtype=torch.float32),
  253. epochs=epochs_kd, alpha=0.0, T=cfg["kd_dm"]["temperature"],
  254. lr=cfg["training"]["lr"], device=device,
  255. pseudo_label_threshold=0.7,
  256. batch_size=cfg["training"]["batch_size_target"],
  257. )
  258. Xte_test = reshape_for_sensors(X_b[ite0]); yte_test = batch.y[ite0] - 1
  259. yhat = TR.predict(student, Xte_test, device=device)
  260. rows.append(_drow(seed_idx, seed, batch.batch_id, "KD-DM-unsup", "unsupervised",
  261. EV.accuracy(yte_test, yhat), EV.macro_f1(yte_test, yhat), len(yte_test)))
  263. # DRCA-fair
  264. from sklearn.ensemble import RandomForestClassifier
  265. il20, iu20, ite20 = DL.stratified_chronological_split(
  266. DL.BatchData(batch.batch_id, X_b, batch.y, batch.order),
  267. target_labeled_fraction=0.20,
  268. test_holdout_fraction=cfg["splits"]["test_holdout_fraction"],
  269. rng=np.random.default_rng(seed + 555),
  270. )
  271. if len(il20) > 0:
  272. clf, _ = KD.drca_fair_adapt(
  273. lambda: RandomForestClassifier(n_estimators=80, random_state=seed),
  274. teacher,
  275. reshape_for_sensors(Xtr_b1n), ytr_b1 - 1,
  276. reshape_for_sensors(X_b[il20]), batch.y[il20] - 1,
  277. reshape_for_sensors(X_b[iu20]) if len(iu20) > 0 else np.zeros((0,16,8),dtype=np.float32),
  278. device=device,
  279. )
  280. with torch.no_grad():
  281. Ft_test = teacher(torch.as_tensor(reshape_for_sensors(X_b[ite20]),
  282. dtype=torch.float32, device=device))
  283. Ft_test = (Ft_test[1] if isinstance(Ft_test, tuple) else Ft_test).cpu().numpy()
  284. yhat_drca = clf.predict(Ft_test)
  285. yte_drca = batch.y[ite20] - 1
  286. rows.append(_drow(seed_idx, seed, batch.batch_id, "DRCA-fair-20", "supervised_20",
  287. EV.accuracy(yte_drca, yhat_drca),
  288. EV.macro_f1(yte_drca, yhat_drca), len(yte_drca)))
  290. return rows
  293. def _drow(seed_idx, seed, target_batch, method, variant, acc, f1, n):
  294. return {"chunk_id": f"p3_b{target_batch}_s{seed_idx}",
  295. "seed": seed, "target_batch": target_batch, "method": method,
  296. "variant": variant, "acc": float(acc), "macro_f1": float(f1), "n_test": int(n)}
  299. # =================================================================
  300. # Phase 4 — final summary
  301. # =================================================================
  302. def run_p4(cfg: dict, results_dir: Path) -> dict:
  303. n_classes = cfg["dataset"]["n_classes"]
  304. fp32 = M.build("litesensor", n_classes=n_classes, in_ch=16, **cfg["models"]["liteSensor"])
  305. pruned = C.structured_l1_prune(fp32, sparsity=cfg["compression"]["prune_target_sparsity"])
  306. breakdown = C.precision_vs_sparsity_breakdown(fp32, pruned)
  308. df = pd.read_csv(results_dir / "raw_results_drift.csv")
  309. nc_per = df[df.method == "NC"].groupby("target_batch").acc.mean().sort_index().values.tolist()
  310. mono = EV.sanity_monotonicity(nc_per, "down")
  311. base = {"expected": 1.0 / n_classes,
  312. "observed": float(df[df.method == "NC"].acc.mean()),
  313. "passed": bool(df[df.method == "NC"].acc.mean() >= 1.0 / n_classes - 0.05)}
  314. cross = EV.sanity_cross_condition(
  315. df[df.method.str.startswith("KD-DM-20")].acc.mean(),
  316. df[df.method == "DRCA-fair-20"].acc.mean(),
  317. )
  319. summary = {
  320. "version": "v1_reduced_2026-05-10",
  321. "n_seeds": len(cfg["statistics"]["seeds"]),
  322. "n_target_batches": int(df["target_batch"].nunique()),
  323. "compression_breakdown_R3_14": breakdown,
  324. "sanity_checks_GATE4": {
  325. "monotonicity_NC": mono,
  326. "baseline_plausibility": base,
  327. "cross_condition": cross,
  328. },
  329. "drift_method_summary": (
  330. df.groupby("method").agg(
  331. mean_acc=("acc", "mean"), std_acc=("acc", "std"),
  332. mean_f1=("macro_f1", "mean"), n=("acc", "size"),
  333. ).round(4).reset_index().to_dict(orient="records")
  334. ),
  335. "submitted_claims_to_revise": {
  336. "78_percent_reduction": (
  337. f"submitted=78%; revised: precision={breakdown['precision_reduction_pct']}% "
  338. f"+ structural_sparsity={breakdown['sparsity_reduction_pct']}%"
  339. ),
  340. "Task_A_100_percent": "submitted=~100% (random splits); see raw_results_drift.csv",
  341. "MCU_scale": "edge-board-scale (Cortex-A class)",
  342. "LiteSensor_params": (
  343. f"submitted=47,392 params/41 kB; "
  344. f"measured={breakdown['size_fp32_kB']} kB FP32, "
  345. f"{breakdown['size_int8_pruned_kB']} kB INT8 pruned"
  346. ),
  347. },
  348. }
  349. return summary
  352. # =================================================================
  353. # Main
  354. # =================================================================
  355. def main():
  356. ap = argparse.ArgumentParser()
  357. ap.add_argument("--config", default="config.yaml")
  358. ap.add_argument("--device", default="cpu")
  359. ap.add_argument("--chunk", default=None,
  360. help="explicit chunk id (e.g., p2_s0, p3_b2_s0, p4)")
  361. ap.add_argument("--resume", action="store_true",
  362. help="auto-pick next pending chunk")
  363. args = ap.parse_args()
  365. with open(args.config) as f:
  366. cfg = yaml.safe_load(f)
  368. results_dir = (ROOT / cfg["paths"]["results_dir"]).resolve()
  369. results_dir.mkdir(parents=True, exist_ok=True)
  370. progress_file = results_dir / "progress.json"
  371. bench_csv = results_dir / "raw_results_benchmark.csv"
  372. drift_csv = results_dir / "raw_results_drift.csv"
  374. done = load_progress(progress_file)
  375. plan = all_chunks(cfg)
  377. if args.resume and not args.chunk:
  378. pending = [c for c in plan if c not in done]
  379. if not pending:
  380. print("ALL CHUNKS DONE."); return
  381. args.chunk = pending[0]
  382. print(f"[RESUME] next pending chunk: {args.chunk} ({len(done)}/{len(plan)} done)")
  384. if not args.chunk:
  385. print("No chunk specified. Use --chunk or --resume."); return
  387. if args.chunk in done:
  388. print(f"chunk {args.chunk} already done — skipping"); return
  390. raw_dir = (ROOT / cfg["paths"]["raw_data_dir"]).resolve()
  391. print(f"[chunk={args.chunk}] loading batches ...")
  392. batches = DL.load_all_batches(str(raw_dir), n_batches=cfg["dataset"]["n_batches"])
  394. t0 = time.time()
  395. if args.chunk.startswith("p2_s"):
  396. seed_idx = int(args.chunk.split("_s")[1])
  397. rows = run_p2_chunk(seed_idx, cfg, batches, args.device)
  398. append_csv(bench_csv, BENCH_HEADERS, rows)
  399. print(f"[chunk={args.chunk}] benchmark rows appended: {len(rows)}")
  401. elif args.chunk.startswith("p3_"):
  402. # p3_b{batch_id}_s{seed_idx}
  403. parts = args.chunk.split("_")
  404. batch_id = int(parts[1][1:]); seed_idx = int(parts[2][1:])
  405. rows = run_p3_chunk(batch_id, seed_idx, cfg, batches, args.device)
  406. append_csv(drift_csv, DRIFT_HEADERS, rows)
  407. print(f"[chunk={args.chunk}] drift rows appended: {len(rows)}")
  409. elif args.chunk == "p4":
  410. # require all p2 + p3 chunks done
  411. prereq = [c for c in plan if c != "p4" and c not in done]
  412. if prereq:
  413. print(f"p4 blocked — pending: {prereq[:5]}..."); return
  414. summary = run_p4(cfg, results_dir)
  415. out = results_dir / "experiment_summary.json"
  416. out.write_text(json.dumps(summary, indent=2, ensure_ascii=False,
  417. default=lambda o: bool(o) if hasattr(o, "__bool__") else str(o)))
  418. print(f"summary written: {out}")
  419. print(json.dumps(summary, indent=2,
  420. default=lambda o: bool(o) if hasattr(o, "__bool__") else str(o))[:1500])
  421. else:
  422. print(f"unknown chunk: {args.chunk}"); return
  424. done.add(args.chunk)
  425. save_progress(progress_file, done)
  426. elapsed = time.time() - t0
  427. print(f"[chunk={args.chunk}] done in {elapsed:.1f}s ({len(done)}/{len(plan)})")
  430. if __name__ == "__main__":
  431. main()

analysis_main.py at commit c102c14, under Apache-2.0 · at the source

Overview

Authors: Soohwan Kim1, Myeongsik Shin1, Ku Kang1, Doo-Hee Lee1, David G Churchill2,3, Yoon Jeong Jang1
ORCID iDs: Soohwan Kim, Ku Kang, Doo-Hee Lee
  1. CBRN Defense Research Institute, Seoul 06796, Republic of Korea; (S.K.); (M.S.); (K.K.); (D.-H.L.)
  2. Department of Chemistry, Korea Advanced Institute of Science and Technology (KAIST), Daejeon 34141, Republic of Korea
  3. Therapeutic Bioengineering Section, KAIST Institute for Health Science and Technology (KIHST), Daejeon 34141, Republic of Korea
Institutions: Korea Advanced Institute of Science and Technology (South Korea)
Journal: Molecules (Basel, Switzerland), volume 31, issue 11, article 1884
Dates: received 7 April 2026; accepted 25 May 2026; published online 1 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/molecules31111884 · PMID 42280188 · PMCID PMC13257611 · OpenAlex W7163049842
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: methods / tools (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing
Keywords: CBRN detection, gas sensor array, edge AI, TinyML, knowledge distillation, sensor drift compensation
Topic: Advanced Chemical Sensor Technologies (Biomedical Engineering, Engineering), according to OpenAlex
Citations: not cited yet (Europe PMC); 33 references in the paper

Abstract

Resource-constrained edge processors deployed on unmanned aerial vehicles and wearable platforms require compact, drift-robust gas classification models for a range of environmental and security monitoring applications, including CBRN-motivated scenarios. Existing approaches rely on server-grade architectures incompatible with edge-board-scale deployment, or on classifiers that chemically degrade severely under long-term sensor drift. Each UCI gas class was mapped to a CBRN behavioral category based on physicochemical analogy (molecular functional group, vapor pressure, and metal-oxide semiconductor (MOS) cross-sensitivity pattern), following established precedent. Analyzed were Ammonia (NH3), Acetaldehyde (CH3CHO), Acetone ((CH3)2CO), Ethylene (C2H4), Ethanol (C2H5OH), Toluene (C6H5CH3). We propose herein an end-to-end pipeline integrating a novel 1-D convolutional neural network with depth-wise separable convolutions (LiteSensor-Net), INT8 post-training quantization, structured magnitude pruning, and a knowledge-distillation domain-adaptation module (KD–DM) for sensor drift compensation. Using the UCI Gas Sensor Array Drift Dataset (13,910 measurements; 16 metal-oxide sensors; six analyte gases; a 36-month work span). LiteSensor-Net achieved accuracy = 92.63 ± 2.02%, macro-F1 = 0.898, model size = 5.99 kB INT8 pruned, inference latency = 6.3 ms, RAM footprint = 31.7 kB, and energy per inference = 0.04 mJ (all metrics on Raspberry Pi 4B, ARM Cortex-A72). Under chronological forward-chaining evaluation, KD–DM–20 achieved 47.91 ± 18.79% mean accuracy over Batches 2–10, representing a +9.25 pp improvement over uncompensated NC (38.66%). A six-metric benchmark framework—accuracy, macro-F1, model size, inference latency, RAM footprint, and energy per inference—is introduced to standardize edge-AI gas classifier evaluation. The proposed pipeline provides an open-source, deployable foundation for edge-class gas classification systems, with CBRN detection as a motivating application. Full operational validation on certified chemical simulants remains as future work.

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 16 matches between paragraphs and lines of code.

bisu9082/LiteSensor-Net

License: Apache-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c102c1466471fcf980787b6a57958f438d693dd0, 16 May 2026
Languages: Python (31), Shell (3)
Size: 100 files, 34 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, license file, CITATION.cff, environment (code/environment.yml, code/pyproject.toml, code/requirements.txt), tests, documentation
Not found: continuous integration
Tools: NumPy (26 files), PyTorch (26 files), scikit-learn (10 files), pandas (4 files), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
36 files
At the source: github.com/bisu9082/LiteSensor-Net

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;
  • 34 scripts, each with its path and the digest of its content;
  • 16 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 UCI Gas Sensor Array Drift Dataset is publicly available at https://doi.org/10.24432/C5RP6W. The Scientific Data long-term drift dataset is at https://doi.org/10.1038/s41597-025-05993-8. The public GitHub repository (https://github.com/bisu9082/LiteSensor-Net, accessed on 24 May 2026), implemented in Python 3.10 with PyTorch 2.4.0 and TensorFlow Lite runtime ≥ 2.14, contains the training/evaluation code, raw UCI batch files, raw result CSV/JSON outputs, configuration files, and reproducibility documentation required to reproduce the revised benchmark, compression ablation, drift-compensation experiments, and calibration analyses.

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, 27 September 2026: the first record

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

Cite

This paper

Kim, S., Shin, M., Kang, K., Lee, D.-H., Churchill, D. G., & Jang, Y. J. (2026). Drift-Robust Lightweight Deep Learning on Open Gas Sensor Benchmarks: A Reproducible Architecture Study with CBRN Applicability Mapping. Molecules (Basel, Switzerland), 31(11), 1884. https://doi.org/10.3390/molecules31111884

BibTeX

@article{kim2026drift,
author = {Kim, Soohwan and Shin, Myeongsik and Kang, Ku and Lee, Doo-Hee and Churchill, David G and Jang, Yoon Jeong},
title = {{Drift-Robust Lightweight Deep Learning on Open Gas Sensor Benchmarks: A Reproducible Architecture Study with CBRN Applicability Mapping}},
journal = {Molecules (Basel, Switzerland)},
year = {2026},
month = jun,
volume = {31},
number = {11},
pages = {1884},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {1420-3049},
doi = {10.3390/molecules31111884},
url = {https://doi.org/10.3390/molecules31111884},
pmid = {42280188},
pmcid = {PMC13257611}
}

RIS

TY - JOUR
AU - Kim, Soohwan
AU - Shin, Myeongsik
AU - Kang, Ku
AU - Lee, Doo-Hee
AU - Churchill, David G
AU - Jang, Yoon Jeong
TI - Drift-Robust Lightweight Deep Learning on Open Gas Sensor Benchmarks: A Reproducible Architecture Study with CBRN Applicability Mapping
T2 - Molecules (Basel, Switzerland)
J2 - Molecules
PY - 2026
DA - 2026/06/01
VL - 31
IS - 11
SP - 1884
SN - 1420-3049
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/molecules31111884
UR - https://doi.org/10.3390/molecules31111884
LA - en
ER -

CSL-JSON

{
"id": "10.3390/molecules31111884",
"type": "article-journal",
"title": "Drift-Robust Lightweight Deep Learning on Open Gas Sensor Benchmarks: A Reproducible Architecture Study with CBRN Applicability Mapping",
"container-title": "Molecules (Basel, Switzerland)",
"author": [
{
"family": "Kim",
"given": "Soohwan"
},
{
"family": "Shin",
"given": "Myeongsik"
},
{
"family": "Kang",
"given": "Ku"
},
{
"family": "Lee",
"given": "Doo-Hee"
},
{
"family": "Churchill",
"given": "David G"
},
{
"family": "Jang",
"given": "Yoon Jeong"
}
],
"container-title-short": "Molecules",
"volume": "31",
"issue": "11",
"page": "1884",
"DOI": "10.3390/molecules31111884",
"PMID": "42280188",
"PMCID": "PMC13257611",
"ISSN": "1420-3049",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/molecules31111884",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
1
]
]
}
}

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.1016/j.isci.2026.117206 [code]
ReliST: A model-agnostic risk layer for spatial transcriptomics deconvolution.
Journal: iScience
In common: PyTorch, scikit-learn, pandas, 2 other tools, 1 reference
[2] doi:10.1038/s41746-026-02778-0 [code]
Trust-gated synthetic EEG augmentation reduces performance drops when generalizing to new patients.
Journal: NPJ digital medicine
In common: PyTorch, scikit-learn, pandas, 2 other tools, 1 reference
[3] doi:10.3390/diagnostics16111588 [code]
Bridging Annotation Gaps: Hierarchical Self-Support Learning for Brain Tumor Segmentation.
Journal: Diagnostics (Basel, Switzerland)
In common: PyTorch, SciPy, NumPy, methods / tools, 1 reference
[4] doi:10.1038/s41598-026-54785-6 [code]
Lightweight deep learning model for nonconvulsive status epilepticus diagnosis using EEG time-frequency analysis.
Journal: Scientific reports
In common: PyTorch, SciPy, NumPy, 1 reference
[5] doi:10.1038/s41598-026-54840-2 [code]
Predictive metacognition: a neuro-computational framework for self-monitoring in large language models.
Journal: Scientific reports
In common: PyTorch, pandas, NumPy, 1 reference
[6] doi:10.3390/jimaging12060233 [code]
Brain Tumor Classification in MRI Images Using Combined Transfer Learning and Convolutional Neural Networks.
Journal: Journal of imaging
In common: scikit-learn, pandas, NumPy, 1 reference
[7] doi:10.1016/j.patter.2026.101564 [code]
Spacing effect improves generalization in biological and artificial systems.
Journal: Patterns (New York, N.Y.)
In common: PyTorch, NumPy, 1 reference
[8] doi:10.1038/s41598-026-50603-1
A multi-class framework for face mask compliance detection using lightweight deep learning models.
Journal: Scientific reports
In common: methods / tools, 1 reference
[9] doi:
NeuroTrustNet: a cost-effective multimodal ensemble framework for brain tumor classification under cross-dataset variability
Journal: Frontiers in artificial intelligence
In common: methods / tools, 1 reference
[10] doi:10.3389/frai.2026.1849571
NeuroPlast: a learnable activation function evaluated under knowledge distillation for medical image classification.
Journal: Frontiers in artificial intelligence
In common: methods / tools, 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.