Add files using upload-large-folder tool

README.md

@@ -0,0 +1,49 @@
+---
+license: mit
+task_categories:
+- audio-classification
+tags:
+- side-channel
+- chipwhisperer
+- gpu
+- moe
+- downsampled
+size_categories:
+- 100K<n<1M
+---
+
+# GPT-OSS-20B MoE Expert Power Traces (Downsampled to 16k)
+
+This is the downsampled variant of the 320k expert-trace capture set.
+
+## Source
+
+Raw source dataset (same captures):
+- 32 experts (`expert_00`..`expert_31`)
+- 10,000 traces per expert
+- 320,000 total traces
+- raw trace length ~195k samples per trace
+
+## Downsampling method
+
+Each raw trace was resampled to exactly `16384` samples using linear interpolation (`np.interp`) exactly as in the training preprocessing path.
+
+No baseline normalization or derivative feature is baked into these files; this dataset stores only the downsampled current traces.
+
+## Format
+
+For each class folder `expert_XX`:
+- `traces.npy`: shape `(10000, 16384)`, dtype `float32`
+- `trial_ids.npy`: shape `(10000,)`, dtype `int32`
+- `meta.json`: class-level conversion metadata
+
+Top-level files:
+- `downsample_summary.json`
+- `capture_meta.json` (original capture metadata)
+- `scripts/downsample_traces_to_16k.py`
+- `scripts/train_expert_classifier_multiclass.py`
+
+## Notes
+
+- This is still a controlled forced-single-expert harness capture, not a full unmodified forward pass.
+- Trainer setups that use `curr` features typically append a `dx` channel at training time.

downsample_summary.json

@@ -0,0 +1,366 @@
+{
+  "source_traces": "/home/amodo/pytorch-example/classifier_runs/gpt_oss_all_experts_10000each_10ms_20260225_014300/traces",
+  "output_root": "/home/amodo/pytorch-example/classifier_runs/gpt_oss_all_experts_10000each_10ms_ds16k_20260306_162007",
+  "target_len": 16384,
+  "dtype": "float32",
+  "workers": 8,
+  "classes": [
+    "expert_00",
+    "expert_01",
+    "expert_02",
+    "expert_03",
+    "expert_04",
+    "expert_05",
+    "expert_06",
+    "expert_07",
+    "expert_08",
+    "expert_09",
+    "expert_10",
+    "expert_11",
+    "expert_12",
+    "expert_13",
+    "expert_14",
+    "expert_15",
+    "expert_16",
+    "expert_17",
+    "expert_18",
+    "expert_19",
+    "expert_20",
+    "expert_21",
+    "expert_22",
+    "expert_23",
+    "expert_24",
+    "expert_25",
+    "expert_26",
+    "expert_27",
+    "expert_28",
+    "expert_29",
+    "expert_30",
+    "expert_31"
+  ],
+  "class_count": 32,
+  "total_traces": 320000,
+  "runtime_sec": 132.90376782417297,
+  "per_class": [
+    {
+      "class_name": "expert_00",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 18.34366774559021,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_01",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 20.759073734283447,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_02",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 30.851003646850586,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_03",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 30.827183723449707,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_04",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 30.856876611709595,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_05",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 30.879770040512085,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_06",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 30.86545157432556,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_07",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 30.85197901725769,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_08",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 32.362895250320435,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_09",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 32.304593086242676,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_10",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 32.961785078048706,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_11",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.36036944389343,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_12",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.485454082489014,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_13",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.55538511276245,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_14",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.555989265441895,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_15",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.541316747665405,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_16",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.18041491508484,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_17",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.97498822212219,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_18",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.69656419754028,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_19",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.51633596420288,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_20",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.55102515220642,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_21",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.44319558143616,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_22",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.5269718170166,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_23",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.52531170845032,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_24",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.71062898635864,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_25",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 34.407108306884766,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_26",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 32.7304322719574,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_27",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 32.72821378707886,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_28",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 32.78094506263733,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_29",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.148813009262085,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_30",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.06109166145325,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    },
+    {
+      "class_name": "expert_31",
+      "num_traces": 10000,
+      "target_len": 16384,
+      "dtype": "float32",
+      "elapsed_sec": 33.067235708236694,
+      "source_length_histogram": {
+        "187500": 10000
+      }
+    }
+  ]
+}

expert_00/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_00",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 18.34366774559021,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_01/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_01",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 20.759073734283447,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_02/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_02",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 30.851003646850586,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_03/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_03",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 30.827183723449707,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_03/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d33faaa0054a44e3d4eeee1031ef40181f431bb136c14c1e9cddd67a04ffe7ba
+size 655360128

expert_04/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_04",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 30.856876611709595,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_05/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_05",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 30.879770040512085,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_05/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:301fe8efae8db814761479a581e7b806c481f98dda5218742b145028f45b1742
+size 655360128

expert_06/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_06",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 30.86545157432556,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_07/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_07",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 30.85197901725769,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_07/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3082ec7e513572c44350d819043aec0ed94f1aaf0a05f5e568f2d1dcbc812908
+size 655360128

expert_08/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_08",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 32.362895250320435,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_09/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_09",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 32.304593086242676,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_09/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3215bbc737db7df233f43408bcba949d69130a56893315c9d12c642f79f76e74
+size 655360128

expert_10/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_10",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 32.961785078048706,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_11/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_11",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.36036944389343,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_12/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_12",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.485454082489014,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_12/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:509903627f457b61b8f4cdcfc174fdac2865d241de4c09642665b90f703536a1
+size 655360128

expert_13/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_13",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.55538511276245,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_14/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_14",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.555989265441895,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_14/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:543b4130b41ead48c6f8a3093afe9cc69bfff28fdcb6204d99f00ef4af64a579
+size 655360128

expert_15/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_15",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.541316747665405,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_16/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_16",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.18041491508484,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_16/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bff329a5b39c390cde7963034961272172a09f6cf4f3d11eea9b7c3db23c4b9d
+size 655360128

expert_17/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_17",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.97498822212219,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_17/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b965bc72911ae602db5b6085669b46e5caf03a90e98e40e69b47e5f7dc1db8ec
+size 655360128

expert_18/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_18",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.69656419754028,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_18/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8231ff78910b333eb91a50f33db262c53c49f0606973d84d5e27eada4610143b
+size 655360128

expert_19/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_19",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.51633596420288,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_19/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c38bf2c4228d51fbb49e7991819381869ce47e5695ebb2ff8d6dc49d79d4a414
+size 655360128

expert_20/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_20",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.55102515220642,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_20/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2a096903c42bdee16eb12aa3148e5db18d72413acd960de2ef15e85fc82ecae
+size 655360128

expert_21/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_21",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.44319558143616,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_22/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_22",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.5269718170166,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_22/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fcd78d8ee763e791ff7aff5321dce4a28cb78d4c7104dc36345992ff0e09f44
+size 655360128

expert_23/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_23",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.52531170845032,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_23/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5eb16c6890f1eb47cfe4ba06ef574b8e61213b00b954854f98bc30bb176a583
+size 655360128

expert_24/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_24",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.71062898635864,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_24/traces.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04adf9f4690c337d12cfea6ed6ff99a4cbcdc3a4e22b0bf20ed22c4e620e3d5d
+size 655360128

expert_25/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_25",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 34.407108306884766,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_26/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_26",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 32.7304322719574,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_27/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_27",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 32.72821378707886,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_28/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_28",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 32.78094506263733,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_29/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_29",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.148813009262085,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_30/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_30",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.06109166145325,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

expert_31/meta.json

@@ -0,0 +1,10 @@
+{
+  "class_name": "expert_31",
+  "num_traces": 10000,
+  "target_len": 16384,
+  "dtype": "float32",
+  "elapsed_sec": 33.067235708236694,
+  "source_length_histogram": {
+    "187500": 10000
+  }
+}

scripts/downsample_traces_to_16k.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import os
+import re
+import time
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import numpy as np
+
+TRIAL_RE = re.compile(r"trial_(\\d+)\\.npy$")
+
+
+def trial_id_from_path(p: Path) -> int:
+    m = TRIAL_RE.search(p.name)
+    return int(m.group(1)) if m else -1
+
+
+def _convert_one_class(class_dir_s: str, out_root_s: str, target_len: int, out_dtype: str, verbose_every: int):
+    class_dir = Path(class_dir_s)
+    out_root = Path(out_root_s)
+
+    paths = sorted(class_dir.glob("trial_*.npy"), key=trial_id_from_path)
+    if not paths:
+        return {
+            "class_name": class_dir.name,
+            "num_traces": 0,
+            "target_len": int(target_len),
+            "dtype": out_dtype,
+            "elapsed_sec": 0.0,
+            "source_length_histogram": {},
+        }
+
+    cls_out = out_root / class_dir.name
+    cls_out.mkdir(parents=True, exist_ok=True)
+
+    dtype = np.float16 if out_dtype == "float16" else np.float32
+
+    n = len(paths)
+    traces_out = cls_out / "traces.npy"
+    ids_out = cls_out / "trial_ids.npy"
+    mm = np.lib.format.open_memmap(traces_out, mode="w+", dtype=dtype, shape=(n, int(target_len)))
+    ids = np.empty((n,), dtype=np.int32)
+
+    length_hist = {}
+    cache = {}
+
+    t0 = time.time()
+    for i, p in enumerate(paths, start=1):
+        x = np.load(p).astype(np.float32, copy=False)
+        src_len = int(len(x))
+        length_hist[src_len] = int(length_hist.get(src_len, 0)) + 1
+
+        if src_len == int(target_len):
+            y = x
+        else:
+            cached = cache.get(src_len)
+            if cached is None:
+                src_idx = np.arange(src_len, dtype=np.float32)
+                dst_idx = np.linspace(0, max(0, src_len - 1), int(target_len), dtype=np.float32)
+                cached = (src_idx, dst_idx)
+                cache[src_len] = cached
+            src_idx, dst_idx = cached
+            y = np.interp(dst_idx, src_idx, x).astype(np.float32, copy=False)
+
+        if dtype == np.float16:
+            mm[i - 1] = y.astype(np.float16, copy=False)
+        else:
+            mm[i - 1] = y
+
+        ids[i - 1] = int(trial_id_from_path(p))
+
+        if verbose_every > 0 and (i % int(verbose_every) == 0):
+            print("[{}] {}/{}".format(class_dir.name, i, n), flush=True)
+
+    mm.flush()
+    np.save(ids_out, ids)
+
+    meta = {
+        "class_name": class_dir.name,
+        "num_traces": int(n),
+        "target_len": int(target_len),
+        "dtype": out_dtype,
+        "elapsed_sec": float(time.time() - t0),
+        "source_length_histogram": {str(k): int(v) for k, v in sorted(length_hist.items())},
+    }
+    with open(cls_out / "meta.json", "w") as f:
+        json.dump(meta, f, indent=2)
+
+    return meta
+
+
+def main():
+    p = argparse.ArgumentParser(description="Downsample raw trace files to fixed length")
+    p.add_argument("--source-traces", required=True, help="Path to source traces root (contains expert_* dirs)")
+    p.add_argument("--output-root", required=True, help="Path to output dataset root")
+    p.add_argument("--target-len", type=int, default=16384)
+    p.add_argument("--dtype", choices=["float32", "float16"], default="float32")
+    p.add_argument("--workers", type=int, default=max(1, min(8, (os.cpu_count() or 4))))
+    p.add_argument("--verbose-every", type=int, default=1000)
+    args = p.parse_args()
+
+    src = Path(os.path.expanduser(args.source_traces)).resolve()
+    out_root = Path(os.path.expanduser(args.output_root)).resolve()
+    out_root.mkdir(parents=True, exist_ok=True)
+
+    class_dirs = sorted([d for d in src.iterdir() if d.is_dir()])
+    if not class_dirs:
+        raise RuntimeError("No class directories found under {}".format(src))
+
+    run_t0 = time.time()
+
+    # Copy capture metadata if present
+    parent = src.parent
+    cap_meta = parent / "capture_meta.json"
+    if cap_meta.exists():
+        with open(cap_meta, "rb") as fin, open(out_root / "capture_meta.json", "wb") as fout:
+            fout.write(fin.read())
+
+    print("[info] classes={} target_len={} dtype={} workers={}".format(len(class_dirs), args.target_len, args.dtype, args.workers), flush=True)
+
+    results = []
+    if int(args.workers) <= 1:
+        for d in class_dirs:
+            print("[start] {}".format(d.name), flush=True)
+            r = _convert_one_class(str(d), str(out_root), int(args.target_len), str(args.dtype), int(args.verbose_every))
+            print("[done] {} traces={} elapsed={:.1f}s".format(d.name, r["num_traces"], r["elapsed_sec"]), flush=True)
+            results.append(r)
+    else:
+        with ProcessPoolExecutor(max_workers=int(args.workers)) as ex:
+            futs = {
+                ex.submit(
+                    _convert_one_class,
+                    str(d),
+                    str(out_root),
+                    int(args.target_len),
+                    str(args.dtype),
+                    int(args.verbose_every),
+                ): d.name
+                for d in class_dirs
+            }
+            for fut in as_completed(futs):
+                name = futs[fut]
+                r = fut.result()
+                print("[done] {} traces={} elapsed={:.1f}s".format(name, r["num_traces"], r["elapsed_sec"]), flush=True)
+                results.append(r)
+
+    results = sorted(results, key=lambda x: x["class_name"])
+
+    total_traces = int(sum(r["num_traces"] for r in results))
+    summary = {
+        "source_traces": str(src),
+        "output_root": str(out_root),
+        "target_len": int(args.target_len),
+        "dtype": str(args.dtype),
+        "workers": int(args.workers),
+        "classes": [r["class_name"] for r in results],
+        "class_count": int(len(results)),
+        "total_traces": total_traces,
+        "runtime_sec": float(time.time() - run_t0),
+        "per_class": results,
+    }
+
+    with open(out_root / "downsample_summary.json", "w") as f:
+        json.dump(summary, f, indent=2)
+
+    print("[all-done] total_traces={} runtime={:.1f}s".format(total_traces, summary["runtime_sec"]), flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/train_expert_classifier_multiclass.py

@@ -0,0 +1,578 @@
+#!/usr/bin/env python3
+"""
+Capture traces for GPT-OSS expert classification.
+
+Each class corresponds to one selected expert from one GPT-OSS layer.
+Per trial, the same random hidden states are used for all selected classes,
+and capture order is randomized within each trial.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import random
+import time
+from datetime import datetime
+from pathlib import Path
+
+os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, Mxfp4Config
+
+from train_classifier import (
+    ScopeConfig,
+    configure_scope,
+    connect_scope,
+    ensure_dir,
+    nvml_snapshot,
+    recover_husky_fast_smc,
+    save_trace,
+    set_seed,
+    train_classifier,
+)
+
+
+def now_stamp() -> str:
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def class_name_for_expert(expert_id: int) -> str:
+    return "expert_{:02d}".format(int(expert_id))
+
+
+def tensor_sha256(t: torch.Tensor) -> str:
+    x = t.detach().contiguous().view(torch.uint8).cpu().numpy().tobytes()
+    return hashlib.sha256(x).hexdigest()
+
+
+def resolve_selected_experts(args, num_experts: int):
+    if args.all_experts:
+        selected = list(range(num_experts))
+    elif args.experts:
+        selected = sorted({int(x) for x in args.experts})
+    else:
+        selected = [int(args.expert_a), int(args.expert_b)]
+
+    if len(selected) < 2:
+        raise ValueError("Need at least 2 experts for classification")
+
+    for e in selected:
+        if e < 0 or e >= num_experts:
+            raise ValueError("expert id {} out of range [0, {})".format(e, num_experts))
+
+    return selected
+
+
+def resolve_trace_counts(args, num_classes: int):
+    if args.trials_per_class is None:
+        if args.total_traces < num_classes or args.total_traces % num_classes != 0:
+            raise ValueError(
+                "--total-traces must be divisible by selected class count ({})".format(num_classes)
+            )
+        trials_per_class = int(args.total_traces // num_classes)
+    else:
+        trials_per_class = int(args.trials_per_class)
+        if trials_per_class < 1:
+            raise ValueError("--trials-per-class must be >= 1")
+
+    total_traces = int(trials_per_class * num_classes)
+    return total_traces, trials_per_class
+
+
+def _delay_ms(ms: float, mode: str = "busy"):
+    d = float(ms)
+    if d <= 0.0:
+        return
+    if str(mode).lower() == "sleep":
+        time.sleep(d / 1000.0)
+        return
+    t0 = time.perf_counter()
+    target = t0 + d / 1000.0
+    while time.perf_counter() < target:
+        pass
+
+
+@torch.no_grad()
+def _run_state_scrub(scrub_buf: torch.Tensor, stream=None):
+    if scrub_buf is None:
+        return
+    if stream is None:
+        scrub_buf.mul_(0.9995).add_(0.0005)
+        torch.cuda.synchronize()
+        return
+    with torch.cuda.stream(stream):
+        scrub_buf.mul_(0.9995).add_(0.0005)
+    stream.synchronize()
+
+
+@torch.no_grad()
+def run_expert_layer(experts_module, hidden_states, router_indices, router_weights, iters: int, stream=None):
+    if stream is None:
+        stream = torch.cuda.current_stream()
+    start = torch.cuda.Event(enable_timing=True)
+    end = torch.cuda.Event(enable_timing=True)
+
+    start.record(stream)
+    out = None
+    with torch.cuda.stream(stream):
+        for _ in range(iters):
+            out = experts_module(hidden_states, router_indices, router_weights)
+    end.record(stream)
+    end.synchronize()
+
+    ms = float(start.elapsed_time(end))
+    return ms, out
+
+
+@torch.no_grad()
+def capture_expert_trace(
+    scope,
+    experts_module,
+    hidden_states,
+    router_indices,
+    router_weights,
+    iters_in_capture: int,
+    warmup_iters: int = 5,
+    stream=None,
+    trigger_delay_ms: float = 0.0,
+    trigger_delay_mode: str = "busy",
+    scrub_buf: torch.Tensor = None,
+):
+    if stream is None:
+        stream = torch.cuda.current_stream()
+    with torch.cuda.stream(stream):
+        for _ in range(warmup_iters):
+            experts_module(hidden_states, router_indices, router_weights)
+    stream.synchronize()
+    time.sleep(0.05)
+    _run_state_scrub(scrub_buf, stream=stream)
+
+    try:
+        scope.sc.setFastSMC(0)
+    except Exception:
+        try:
+            scope.sc._fast_fifo_read_active = False
+        except Exception:
+            pass
+
+    nv_before = nvml_snapshot(0)
+
+    scope.io.tio4 = "gpio_low"
+    scope.arm()
+    _delay_ms(1.0, mode=trigger_delay_mode)
+    scope.io.tio4 = "gpio_high"
+
+    try:
+        _delay_ms(float(trigger_delay_ms), mode=trigger_delay_mode)
+        ms, _ = run_expert_layer(
+            experts_module,
+            hidden_states,
+            router_indices,
+            router_weights,
+            iters_in_capture,
+            stream=stream,
+        )
+        ret = scope.capture(poll_done=True)
+    finally:
+        try:
+            scope.io.tio4 = "gpio_low"
+        except Exception as e:
+            print("[warn] tio4 cleanup:", repr(e), flush=True)
+
+    if ret:
+        raise RuntimeError("ChipWhisperer capture timed out (no trigger?)")
+
+    trace = np.array(scope.get_last_trace(), dtype=np.float32)
+    nv_after = nvml_snapshot(0)
+    return trace, float(ms), nv_before, nv_after
+
+
+def capture_expert_dataset(run_dir: Path, args):
+    traces_root = run_dir / "traces"
+    ensure_dir(traces_root)
+
+    scope = connect_scope()
+    scope_info = configure_scope(
+        scope,
+        ScopeConfig(
+            capture_ms=args.capture_ms,
+            gain_db=args.gain_db,
+            clkgen_freq=args.clkgen_freq,
+            pretrigger_ms=float(args.pretrigger_ms),
+        ),
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(
+        args.model_name,
+        device_map=torch.cuda.current_device(),
+        quantization_config=Mxfp4Config(dequantize=True),
+    )
+    model.eval()
+
+    layer = model.model.layers[args.layer_idx]
+    experts_module = layer.mlp.experts
+
+    hidden_size = int(model.config.hidden_size)
+    num_experts = int(model.config.num_local_experts)
+    selected_experts = resolve_selected_experts(args, num_experts)
+
+    class_names = [class_name_for_expert(e) for e in selected_experts]
+    class_to_expert = {class_name_for_expert(e): int(e) for e in selected_experts}
+
+    total_traces, trials_per_class = resolve_trace_counts(args, len(class_names))
+    args.total_traces = total_traces
+    args.trials_per_class = trials_per_class
+
+    router_weights = torch.ones((args.tokens, 1), device="cuda", dtype=torch.bfloat16)
+    router_idx = {
+        cname: torch.full((args.tokens, 1), int(eid), device="cuda", dtype=torch.long)
+        for cname, eid in class_to_expert.items()
+    }
+
+    hidden_states = torch.empty((args.tokens, hidden_size), device="cuda", dtype=torch.bfloat16)
+    order_rng = random.Random(args.seed)
+    expert_stream = torch.cuda.Stream() if bool(args.use_dedicated_stream) else torch.cuda.current_stream()
+
+    scrub_buf = None
+    if int(args.state_scrub_mb) > 0:
+        scrub_bytes = int(args.state_scrub_mb) * 1024 * 1024
+        scrub_numel = max(1, scrub_bytes // 2)  # bfloat16
+        scrub_buf = torch.empty((scrub_numel,), device="cuda", dtype=torch.bfloat16)
+        scrub_buf.normal_(mean=0.0, std=1.0)
+
+    # One-time kernel warmup to avoid startup effects in the first captured trace.
+    hidden_states.normal_(mean=0.0, std=float(args.hidden_std))
+    for cname in class_names:
+        run_expert_layer(
+            experts_module,
+            hidden_states,
+            router_idx[cname],
+            router_weights,
+            iters=max(2, int(args.warmup_iters)),
+            stream=expert_stream,
+        )
+    expert_stream.synchronize()
+
+    expert_meta = {
+        "layer_idx": int(args.layer_idx),
+        "hidden_size": hidden_size,
+        "num_local_experts": num_experts,
+        "selected": {},
+    }
+
+    for cname, eid in class_to_expert.items():
+        gate = experts_module.gate_up_proj[eid].detach()
+        down = experts_module.down_proj[eid].detach()
+        gate_b = experts_module.gate_up_proj_bias[eid].detach()
+        down_b = experts_module.down_proj_bias[eid].detach()
+        expert_meta["selected"][cname] = {
+            "expert_id": int(eid),
+            "gate_up_proj_shape": list(gate.shape),
+            "down_proj_shape": list(down.shape),
+            "gate_up_proj_sha256": tensor_sha256(gate),
+            "down_proj_sha256": tensor_sha256(down),
+            "gate_up_proj_bias_sha256": tensor_sha256(gate_b),
+            "down_proj_bias_sha256": tensor_sha256(down_b),
+        }
+
+    if args.save_experts:
+        expert_dump = {
+            "model_name": args.model_name,
+            "layer_idx": int(args.layer_idx),
+            "experts": {},
+        }
+        for cname, eid in class_to_expert.items():
+            expert_dump["experts"][cname] = {
+                "expert_id": int(eid),
+                "gate_up_proj": experts_module.gate_up_proj[eid].detach().cpu(),
+                "gate_up_proj_bias": experts_module.gate_up_proj_bias[eid].detach().cpu(),
+                "down_proj": experts_module.down_proj[eid].detach().cpu(),
+                "down_proj_bias": experts_module.down_proj_bias[eid].detach().cpu(),
+            }
+        expert_path = run_dir / "selected_experts.pt"
+        torch.save(expert_dump, expert_path)
+        expert_meta["saved_file"] = str(expert_path)
+
+    capture_meta = {
+        "mode": "capture_gpt_oss_experts_multiclass",
+        "created_at": datetime.now().isoformat(),
+        "model_name": args.model_name,
+        "class_names": class_names,
+        "selected_experts": selected_experts,
+        "class_to_expert": class_to_expert,
+        "total_traces_requested": total_traces,
+        "trials_per_class": trials_per_class,
+        "trace_repeats": int(args.trace_repeats),
+        "capture_order": "interleaved_by_trial_randomized",
+        "capture_order_seed": int(args.seed),
+        "tokens": int(args.tokens),
+        "hidden_std": float(args.hidden_std),
+        "expert_iters": int(args.expert_iters),
+        "warmup_iters": int(args.warmup_iters),
+        "pretrigger_ms": float(args.pretrigger_ms),
+        "trigger_delay_ms": float(args.trigger_delay_ms),
+        "trigger_delay_mode": str(args.trigger_delay_mode),
+        "use_dedicated_stream": bool(args.use_dedicated_stream),
+        "state_scrub_mb": int(args.state_scrub_mb),
+        "max_expert_ms": None if args.max_expert_ms is None else float(args.max_expert_ms),
+        "scope": scope_info,
+        "experts": expert_meta,
+        "gpu_start": nvml_snapshot(0),
+        "records": [],
+    }
+
+    try:
+        for t in range(trials_per_class):
+            hidden_states.normal_(mean=0.0, std=float(args.hidden_std))
+            expert_stream.synchronize()
+
+            class_order = class_names.copy()
+            order_rng.shuffle(class_order)
+
+            for class_pos, class_name in enumerate(class_order):
+                ridx = router_idx[class_name]
+
+                ok = False
+                last_err = None
+                for attempt in range(args.max_retries):
+                    try:
+                        trace_list = []
+                        ms_list = []
+                        nv_b = None
+                        nv_a = None
+
+                        for _ in range(args.trace_repeats):
+                            tr, ms, nb, na = capture_expert_trace(
+                                scope,
+                                experts_module,
+                                hidden_states,
+                                ridx,
+                                router_weights,
+                                iters_in_capture=args.expert_iters,
+                                warmup_iters=args.warmup_iters,
+                                stream=expert_stream,
+                                trigger_delay_ms=float(args.trigger_delay_ms),
+                                trigger_delay_mode=str(args.trigger_delay_mode),
+                                scrub_buf=scrub_buf,
+                            )
+                            trace_list.append(tr)
+                            ms_list.append(float(ms))
+                            if nv_b is None:
+                                nv_b = nb
+                            nv_a = na
+
+                        trace = np.mean(np.stack(trace_list, axis=0), axis=0).astype(np.float32)
+                        ms = float(np.mean(ms_list))
+                        ms_peak = float(np.max(ms_list))
+                        trace_mean = float(trace.mean())
+                        trace_std = float(trace.std())
+                        if len(trace) != int(scope_info["adc_samples"]):
+                            raise RuntimeError(
+                                "Unexpected sample count {} (expected {})".format(
+                                    len(trace), int(scope_info["adc_samples"])
+                                )
+                            )
+                        if not np.isfinite(trace).all():
+                            raise RuntimeError("Trace contains non-finite values")
+                        try:
+                            adc_errors = int(scope.adc.errors)
+                        except Exception:
+                            adc_errors = 0
+                        if adc_errors != 0:
+                            try:
+                                scope.adc.errors = 0
+                            except Exception:
+                                pass
+                            raise RuntimeError("ADC reported errors: {}".format(adc_errors))
+                        if args.max_expert_ms is not None and ms_peak > float(args.max_expert_ms):
+                            raise RuntimeError(
+                                "Expert runtime {:.4f}ms exceeded max_expert_ms {:.4f}ms".format(
+                                    ms_peak, float(args.max_expert_ms)
+                                )
+                            )
+                        if abs(trace_mean) > float(args.max_abs_mean) or trace_std > float(args.max_std):
+                            raise RuntimeError(
+                                "Trace quality check failed (mean={:.5f}, std={:.5f})".format(trace_mean, trace_std)
+                            )
+
+                        fpath = save_trace(traces_root, class_name, t, trace)
+                        rec = {
+                            "class": class_name,
+                            "expert_id": int(class_to_expert[class_name]),
+                            "trial": int(t),
+                            "group_id": int(t),
+                            "class_order": class_order,
+                            "class_pos": int(class_pos),
+                            "global_step": int(t * len(class_names) + class_pos),
+                            "attempt": int(attempt + 1),
+                            "trace_repeats": int(args.trace_repeats),
+                            "trace_file": str(fpath),
+                            "samples": int(len(trace)),
+                            "mean": trace_mean,
+                            "std": trace_std,
+                            "expert_ms": float(ms),
+                            "expert_ms_peak": float(ms_peak),
+                            "nvml_before": nv_b,
+                            "nvml_after": nv_a,
+                        }
+                        capture_meta["records"].append(rec)
+
+                        print(
+                            "class={} eid={} trial={} pos={} step={} ms={:.3f} ms_peak={:.3f} samples={:,} mean={:.5f} std={:.5f}".format(
+                                class_name,
+                                rec["expert_id"],
+                                t,
+                                class_pos,
+                                rec["global_step"],
+                                ms,
+                                ms_peak,
+                                len(trace),
+                                rec["mean"],
+                                rec["std"],
+                            ),
+                            flush=True,
+                        )
+                        ok = True
+                        break
+
+                    except Exception as e:
+                        last_err = e
+                        print(
+                            "class={} trial={} pos={} attempt {} failed: {}".format(
+                                class_name, t, class_pos, attempt + 1, repr(e)
+                            ),
+                            flush=True,
+                        )
+                        recover_husky_fast_smc()
+                        try:
+                            scope.dis()
+                        except Exception:
+                            pass
+                        scope = connect_scope()
+                        configure_scope(
+                            scope,
+                            ScopeConfig(
+                                capture_ms=args.capture_ms,
+                                gain_db=args.gain_db,
+                                clkgen_freq=args.clkgen_freq,
+                                pretrigger_ms=float(args.pretrigger_ms),
+                            ),
+                        )
+
+                if not ok:
+                    raise RuntimeError(
+                        "Capture failed for class={}, trial={} after retries: {}".format(class_name, t, repr(last_err))
+                    )
+    finally:
+        try:
+            scope.dis()
+        except Exception:
+            pass
+
+        try:
+            del model
+        except Exception:
+            pass
+        torch.cuda.empty_cache()
+
+    capture_meta["gpu_end"] = nvml_snapshot(0)
+    return traces_root, capture_meta, class_names
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Capture GPT-OSS expert traces and train a classifier")
+    p.add_argument("--output-root", default="~/pytorch-example/classifier_runs")
+    p.add_argument("--run-name", default=None)
+
+    p.add_argument("--model-name", default="openai/gpt-oss-20b")
+    p.add_argument("--layer-idx", type=int, default=0)
+    p.add_argument("--expert-a", type=int, default=0)
+    p.add_argument("--expert-b", type=int, default=1)
+    p.add_argument("--experts", nargs="+", type=int, default=None, help="Explicit expert IDs to classify")
+    p.add_argument("--all-experts", action="store_true", help="Use all experts in the selected layer")
+    p.add_argument("--save-experts", action="store_true")
+
+    p.add_argument("--total-traces", type=int, default=500, help="Total traces across all selected classes")
+    p.add_argument("--trials-per-class", type=int, default=None, help="Override per-class traces")
+
+    p.add_argument("--tokens", type=int, default=512)
+    p.add_argument("--hidden-std", type=float, default=1.0)
+    p.add_argument("--expert-iters", type=int, default=24)
+    p.add_argument("--warmup-iters", type=int, default=5)
+    p.add_argument("--max-retries", type=int, default=2)
+    p.add_argument("--trace-repeats", type=int, default=1)
+    p.add_argument("--max-abs-mean", type=float, default=0.25)
+    p.add_argument("--max-std", type=float, default=0.20)
+    p.add_argument("--max-expert-ms", type=float, default=None)
+
+    p.add_argument("--capture-ms", type=float, default=8.0)
+    p.add_argument("--pretrigger-ms", type=float, default=0.0, help="Pre-trigger duration in ms")
+    p.add_argument("--gain-db", type=float, default=10.0)
+    p.add_argument("--clkgen-freq", type=float, default=150e6)
+    p.add_argument(
+        "--trigger-delay-ms",
+        type=float,
+        default=0.0,
+        help="Delay from trigger-high to compute start (ms)",
+    )
+    p.add_argument(
+        "--trigger-delay-mode",
+        choices=["busy", "sleep"],
+        default="busy",
+        help="How to implement trigger delay",
+    )
+    p.add_argument("--state-scrub-mb", type=int, default=0, help="Run a fixed memory scrub between captures")
+    p.add_argument("--use-dedicated-stream", dest="use_dedicated_stream", action="store_true")
+    p.add_argument("--no-dedicated-stream", dest="use_dedicated_stream", action="store_false")
+
+    p.add_argument("--feature-len", type=int, default=4096)
+    p.add_argument("--baseline-samples", type=int, default=2000)
+    p.add_argument("--preprocess-mode", choices=["curr", "no_std", "raw", "dx_only"], default="curr")
+    p.add_argument("--model", choices=["mlp", "cnn", "transformer"], default="cnn")
+    p.add_argument("--cnn-norm", choices=["group", "batch", "layer", "none"], default="group")
+    p.add_argument("--cnn-dropout", type=float, default=0.2)
+    p.add_argument("--tx-patch-len", type=int, default=32)
+    p.add_argument("--tx-d-model", type=int, default=128)
+    p.add_argument("--tx-nhead", type=int, default=4)
+    p.add_argument("--tx-layers", type=int, default=4)
+    p.add_argument("--tx-ff-mult", type=int, default=4)
+    p.add_argument("--tx-dropout", type=float, default=0.2)
+    p.add_argument("--epochs", type=int, default=80)
+    p.add_argument("--batch-size", type=int, default=32)
+    p.add_argument("--lr", type=float, default=1e-3)
+    p.add_argument("--val-frac", type=float, default=0.25)
+    p.add_argument("--val-size", type=int, default=0, help="Target validation sample count (best-effort)")
+    p.add_argument("--split-mode", choices=["grouped_trial", "stratified"], default="grouped_trial")
+    p.add_argument("--seed", type=int, default=7)
+    p.add_argument("--capture-only", action="store_true", help="Only capture traces; skip classifier training")
+    p.set_defaults(use_dedicated_stream=True)
+
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    set_seed(args.seed)
+
+    output_root = Path(os.path.expanduser(args.output_root))
+    run_name = args.run_name or "gpt_oss_experts_multi_{}".format(now_stamp())
+    run_dir = output_root / run_name
+    ensure_dir(run_dir)
+
+    traces_root, capture_meta, class_names = capture_expert_dataset(run_dir, args)
+
+    with open(run_dir / "capture_meta.json", "w") as f:
+        json.dump(capture_meta, f, indent=2)
+
+    if args.capture_only:
+        print("[done] capture-only mode: skipping training", flush=True)
+        return
+
+    train_classifier(run_dir, traces_root, class_names, args, capture_meta)
+
+
+if __name__ == "__main__":
+    main()