#!/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()