SEMM-Latent-Telemetry

Bare-metal hardware telemetry and SNN latent space routing data for neuromorphic quantization research. This dataset documents the discovery of Semantic Attractor Clustering — that a Spiking Neural Network physically routes different semantic concepts (abstract language vs code syntax vs math logic) into distinct, repeatable biological pathways when L2 Normalization is applied to LLM embeddings.

Hub ID: rmems/SEMM-Latent-Telemetry
Names: SEMM = Spiking Experts Mixture Mechanism · SAAQ = Spiking Adaptive Activity Quantization · Metis = research idea that SAAQ can deepen understanding of SNN–ANN hybrid setups

---

Dataset Details

• Curated by: Raul Montoya Cardenas
• Language(s): English, Code
• License: Apache 2.0 / MIT (dual-licensed)
• Repository: huggingface.co/datasets/rmems/SEMM-Latent-Telemetry
• Primary routing model (first-day discovery): allenai/OLMoE-1B-7B-0125-Instruct · GGUF: allenai/OLMoE-1B-7B-0125-Instruct-GGUF
• SR campaign models: see Models Tested (8 GGUF lineups + OLMoE baseline)
• Implementation: corinth-canal (SNN quantization pipeline)
• Analysis: Surrogate_Viz.jl (symbolic regression)
• Hardware baseline (planned home): rmems/gaming-telemetry (RE4 path-tracing seed; multi-title corpus)

---

Dataset Description

Origins of Metis

Before this was a formal dataset, it was an attempt to solve a bare-metal problem. I had been experimenting with mining telemetry, HFT bots, and sync node data to train a spiking neural network (SNN), but the data kept returning dead zeros in value after being used for training.

The breakthrough came entirely by accident. I was running heavy mods — DLSS 4.0 and path tracing — on Cyberpunk 2077 and the Resident Evil 4 Remake. My workstation PC was screaming, pushing harder and louder than it ever did during crypto mining. That sparked the realization: What if I used raw gaming telemetry data for neuromorphic spike data conversion? Dynamic GPU/CPU stress traces gave usable temporal structure where mining/sync logs had returned dead zeros. (Early notes sometimes called this an “artificial heartbeat”; that framing is not a current research track — the live line is SAAQ / SEMM routing and adaptation laws.)

When I pitched this idea, most people didn't believe the spike data conversion would work. But after refining the early thermal equations using that Resident Evil 4 telemetry, Metis was born: the research idea that SAAQ (Spiking Adaptive Activity Quantization) could open a clearer window onto SNN–ANN hybrid setups — using real hardware pressure, MoE latent drive, and spiking routing as the instrument. This Hub dataset is the telemetry backbone for that program, aimed at understanding SEMM (Spiking Experts Mixture Mechanism).

Relationship to Spikenaut

Spikenaut is my pure SNN model, built from scratch as a native spiking neural network. Metis is the research program and teacher-side probe: SAAQ applied through the OLMoE Mixture-of-Experts model to discover routing laws and adaptation equations. Those discoveries are meant to transfer into SEMM and into Spikenaut's native training and evolution. Metis proves the math; Spikenaut implements it natively.

---

The Science: Semantic Attractor Clustering

This dataset contains the raw bare-metal telemetry logs and latent space visualizations generated by the routing encoder. The objective is to map the physical routing of LLM embeddings (specifically from the allenai/OLMoE-1B-7B-0125-Instruct-GGUF Mixture of Experts model) as they are processed by biologically-inspired neuronal fatigue mechanics.

The Discovery: Physical Neighborhood Mapping

The primary breakthrough documented in this dataset is the organic, physical separation of semantic concepts into distinct routing bands. By applying L2 Normalization to the embeddings, the network bounds semantic pressure, forcing tokens to follow the biological path of least resistance.

Telemetry visualizations prove that the Spike-based routing physically routes different cognitive tasks into isolated biological neighborhoods:

Abstract Language Routing (2000-Route)	Structured Logic Routing (600-800 Band)
Abstract English logic establishes a dominant attractor basin at the 2000-index walker route	Rust syntax and math logic collapse into the same 600-800 frequency band

When fed abstract English logic, the network distributes energy across multiple nodes, establishing a dominant attractor basin at the 2000-index walker route, with secondary echoes in Walkers 700 and 1450.

When fed rigid mathematical statements or raw Rust syntax, the network completely abandons the 2000-route. The tokens experience mathematical pushback in abstract centers and organically collapse into the exact same 600-800 frequency band. This demonstrates that the network physically maps highly structured logic tasks to adjacent biological neighborhoods to conserve energy.

---

Experiment Progression

The dataset documents the chronological progression from synthetic baselines to actual semantic routing:

Phase	Name	Input	Key Result
1	Synthetic Baseline	Synthetic sine wave	Verified GPU temporal loop (10,000 ticks) and basic biological fatigue
2	F16 Magnitude Collapse	Real LLM embeddings (OLMoE)	Unscaled F16-to-F32 extraction caused routing collapse (single walker overwhelmed)
3	Attractor Discovery	"Let's teach this MoE model..."	L2 Normalization shattered the collapse; energy settled into Walker 2000
4	Rust Syntax	fn main() { println!(); }	Code syntax routed to completely different biological neighborhood (600-800 band)
5	Math Logic Clustering	"The derivative of a constant is mathematically zero."	Math logic routed to the same 600-800 band as Rust syntax — confirming Semantic Attractor Clustering

---

Symbolic Regression Benchmark

The sr_benchmark/ directory contains the outputs of a multi-model symbolic regression campaign run via Surrogate_Viz.jl. The goal: discover compact mathematical equations that predict SAAQ delta-q targets from latent telemetry features.

Setup

• Target variable: saaq_delta_q_target
• Features: avg_pop_firing_rate_hz, membrane_dv_dt, routing_entropy, saaq_delta_q_prev
• Operators: +, -, *, /, exp, sqrt, square
• Config: maxsize=15, parsimony=0.01, 30 iterations per run
• Rule: SaaqV1_5SqrtRate

Models Tested (SR benchmark)

Slug names match sr_benchmark/{slug}/ and the model column in the sr_pareto Hub config. Base = upstream weights on Hugging Face; GGUF used = local quant file lineage (community or official GGUF repo when known).

Slug (sr_benchmark/)	Quant	Base model (HF)	GGUF / quant source	Conditions in this release
olmoe_1b_7b_f16	F16	allenai/OLMoE-1B-7B-0125-Instruct	allenai/OLMoE-1B-7B-0125-Instruct-GGUF (F16)	math_logic, rust_syntax, english_snn
olmoe-1b-7b	baseline	same	same family; hall-of-fame only in tree	math_logic (partial)
qwen3_moe_iq3_m	IQ3_M	Qwen/Qwen3-30B-A3B	Official GGUF: Qwen/Qwen3-30B-A3B-GGUF; this run used an IQ3_M community quant of the Qwen3 MoE family	math_logic, rust_syntax, english_snn
kimi_vl_a3b_q6_k	Q6_K	moonshotai/Kimi-VL-A3B-Instruct	e.g. mradermacher/Kimi-VL-A3B-Instruct-GGUF	math_logic×2, rust_syntax, english_snn
marco_nano_base_q8_0	Q8_0	AIDC-AI/Marco-Nano-Base	e.g. mradermacher/Marco-Nano-Base-GGUF	math_logic×2, rust_syntax, english_snn
zaya1_8b_q8_0	Q8_0	Zyphra/ZAYA1-8B	Local Q8_0 GGUF from Zyphra ZAYA1-8B	math_logic×2, rust_syntax, english_snn
deepseek_coder_v2_lite_q6_k_l	Q6_K_L	deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct	e.g. bartowski/DeepSeek-Coder-V2-Lite-Instruct-GGUF	math_logic, rust_syntax, english_snn
gemma4_26b_a4b_iq4_nl	IQ4_NL	google/gemma-4-26B-A4B-it	e.g. unsloth/gemma-4-26B-A4B-it-GGUF (UD-IQ4_NL)	math_logic, rust_syntax, english_snn
llama_3_2_dark_champion_q5_k_m	Q5_K_M	DavidAU/Llama-3.2-8X3B-MOE-Dark-Champion-Instruct-uncensored-abliterated-18.4B	DavidAU/…-18.4B-GGUF	math_logic, rust_syntax, english_snn

First-day Semantic Attractor Clustering maps (English / Rust / math) were produced with OLMoE only. The multi-model table is the symbolic regression campaign over SAAQ features (often RE4-backed drive + prompt embeddings), not a re-run of every routing map on every model.

Files Per Model

Each model directory contains Pareto front CSVs ({condition}_pareto.csv) and run manifests ({condition}_manifest.json). The Pareto fronts map complexity vs loss for discovered equations. See sr_benchmark/sr_pareto_all.parquet (Hub config sr_pareto) for the consolidated table, and bundle.json for campaign metadata.

Key Result

The SAAQ 1.5 delta-Q adaptation law was discovered from this benchmark:

$$\mathrm{\Delta }{q}_{\text{target}}\approx 0.0573\cdot \sqrt{{\bar{f}}_{\text{pop}}}+0.496\cdot \mathrm{\Delta }{q}_{\text{prev}}\backslash Delta\; q\_\{\backslash text\{target\}\}\; \backslash approx\; 0.0573\; \backslash cdot\; \backslash sqrt\{\backslash bar\{f\}\_\{\backslash text\{pop\}\}\}\; +\; 0.496\; \backslash cdot\; \backslash Delta\; q\_\{\backslash text\{prev\}\}$$

See SAAQ 1.5/ for the full derivation and interpretation.

---

Usage

There is no anonymous default config. Always pass a config name.

Config	What you get
hardware_re4	Full NVML parquet from Resident Evil 4 path tracing on Ship of Theseus (~96k rows, 48 batches)
sr_pareto	Consolidated symbolic-regression Pareto fronts (model, condition, complexity, loss, equation)
latent_routing	Not published yet — gated until English, Rust, and math each have a feature CSV (Rust exists today)

Quick Start (Python)

from datasets import load_dataset

# Bare-metal GPU/CPU telemetry (explicit config required)
hw = load_dataset("rmems/SEMM-Latent-Telemetry", "hardware_re4", split="train")
print(hw.features)
print(hw[0])

# Symbolic regression Pareto table
sr = load_dataset("rmems/SEMM-Latent-Telemetry", "sr_pareto", split="train")
print(sr.features)
print(sr[0])

Rebuild the consolidated SR table after adding runs:

python scripts/build_sr_pareto_all.py
python scripts/validate_dataset.py

Data Schema (hardware_re4 — full parquet)

Captured at ~5ms intervals via NVML on Ship of Theseus. The Hub interface matches all on-disk columns (not a reduced neuromorphic subset).

Feature	Type	Description
timestamp_ms	int64	UNIX timestamp in milliseconds
power_usage_mw	uint32	Total GPU power usage in milliwatts
temperature_c	uint32	GPU core temperature in Celsius
graphics_clock_mhz	uint32	GPU graphics clock (MHz)
memory_clock_mhz	uint32	GPU memory clock (MHz)
pcie_rx_kbps	uint32	Incoming PCIe throughput (KB/s)
pcie_tx_kbps	uint32	Outgoing PCIe throughput (KB/s)
pstate	uint32	GPU performance state
throttle_reasons_bitmask	uint64	Hardware throttling events bitmask
fan_speed_perc	uint32	Fan speed percent
memory_used_mb	uint64	GPU memory used (MB)
memory_total_mb	uint64	GPU memory total (MB)
encoder_util_perc	uint32	NVIDIA Encoder (NVENC) utilization %
decoder_util_perc	uint32	NVIDIA Decoder (NVDEC) utilization %
cpu_tctl_c	float32	CPU package temperature (Tctl)
cpu_ccd1_c	float32	CPU Core Complex Die 1 temperature
cpu_ccd2_c	float32	CPU Core Complex Die 2 temperature
cpu_package_power_w	float32	CPU package power (W)

Note: RE4_path_tracing_telemetry.csv is a legacy 5-column export (gpu_temp_c, gpu_power_w, …). It is not the same schema as the parquet batches. Prefer hardware_re4 for Hub loads.

Data Schema (sr_pareto)

Feature	Type	Description
model	string	Model directory name under sr_benchmark/
condition	string	Prompt condition (english_snn, math_logic, rust_syntax, …)
complexity	float32	Equation complexity on the Pareto front
loss	float32	Fit loss (MSE-style)
equation	string	Discovered symbolic expression

Built by scripts/build_sr_pareto_all.py from per-model *_pareto.csv files.

Neuromorphic Mapping

This data behaves as "sensorimotor" stimulus for neural networks:

• Excitatory Inputs: High surges in pcie_rx_kbps indicate asset floods (e.g., BVH structure updates for path tracing), mimicking sensory signals
• Action Potentials: encoder_util_perc, decoder_util_perc, and power_usage_mw transients represent internal activity and firing rates
• Inhibitory Inputs: Non-zero throttle_reasons_bitmask signals act as inhibitory governors, dynamically suppressing activity
• State/Momentum: Slow-moving temperatures (cpu_tctl_c, temperature_c) and memory capacity

---

Dataset Structure

├── origin_hardware_baselines/
│   └── resident_evil_4/
│       ├── system_telemetry_v1_batch_*.parquet   (48 files)
│       ├── RE4_path_tracing_telemetry.csv
│       └── README.md
├── first-day-testing-real-weights/
│   ├── first-test-falied/        # Routing collapse visualization
│   ├── second-test/              # English logic routing (2000-route)
│   ├── third-test/               # Rust syntax routing (600-800 band)
│   └── fourth-test/              # Math logic routing (600-800 band)
├── experiments/                  # Smoke test visualizations
├── sr_benchmark/                 # Multi-model symbolic regression benchmark
│   ├── sr_pareto_all.parquet     # Hub config: sr_pareto (consolidated)
│   ├── bundle.json               # Campaign metadata (prefer consolidated table)
│   ├── dashboards/               # Pareto plots (optional visuals)
│   └── {model}/                  # Per-model Pareto fronts + manifests
├── scripts/
│   ├── build_sr_pareto_all.py    # Build consolidated SR table
│   └── validate_dataset.py       # Local interface checks (CI later)
├── SAAQ 1.0/                     # Foundational L2-normalized voltage bound
├── SAAQ 1.5/                     # Delta-Q adaptation law (discovered via SR)
├── CONTEXT.md                    # Domain glossary + multi-config decisions
├── Research notes/               # Informal research notes
└── model_metadata_manifest.json  # Structured project metadata

Hub configs today: hardware_re4, sr_pareto.
Gated: latent_routing (needs English + Rust + math feature CSVs).

---

Hardware Environment

Component	Spec
Workstation	Ship of Theseus
GPU	ASUS ProArt GeForce RTX 5080 (16GB VRAM)
CPU	AMD Ryzen 9 9950X
OS	Fedora 43
Implementation	Custom Rust/CUDA via corinth-canal

---

Bias, Risks, and Limitations

• This dataset is generated from a single hardware configuration (RTX 5080 + Ryzen 9 9950X). Routing patterns may differ on other GPU architectures.
• The telemetry captures are from gaming workloads (Resident Evil 4 Remake with path tracing). Other GPU stress patterns may produce different power/thermal signatures.
• The SNN routing visualizations represent a specific quantization approach (SAAQ) applied to a specific model (OLMoE). Results may not generalize to other SNN architectures or MoE models.
• The dataset is small (48 parquet batches) and is intended for research and equation discovery, not large-scale training.

---

Citation

BibTeX:

@dataset{montoya_2026,
  author = {Raul Montoya Cardenas},
  title = {SEMM-Latent-Telemetry: Spiking Experts Mixture Mechanism Routing Data},
  year = {2026},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/rmems/SEMM-Latent-Telemetry}}
}

APA:

Montoya Cardenas, R. (2026). SEMM-Latent-Telemetry: Spiking Experts Mixture Mechanism routing data [Dataset]. Hugging Face. https://huggingface.co/datasets/rmems/SEMM-Latent-Telemetry

---

Glossary

Term	Definition
Walker	A pulse of electrical energy (spike) that physically explores the network to find the path of least resistance. Analogous to electrical impulses in a biological brain.
L2 Normalization	Bounds semantic pressure to the unit sphere, preventing any single neuron from becoming dominant. Mimics biological brain energy distribution.
Semantic Attractor Clustering	The phenomenon where an SNN physically maps different semantic concepts (abstract language vs code syntax) to distinct, repeatable biological pathways.
Fatigue Mechanics	Neurons that fire too much become less responsive, preventing energy overload and enabling network adaptation.
SAAQ	Spiking Adaptive Activity Quantization — the activity-aware quantization technique developed through this research (L2 voltage bound + delta-q adaptation).
SEMM	Spiking Experts Mixture Mechanism — spike-driven experts / mixture routing under study (this dataset’s subject).
Metis	Research idea that SAAQ can enable deeper understanding of SNN–ANN hybrid setups; teacher/probe program that feeds Spikenaut.

---

License

This dataset is dual-licensed under Apache 2.0 and MIT.