I remember now what happen, hf_dataset_card.md replaced README.md through terminal command.

README.md

@@ -1,76 +1,109 @@
 ---
 license: gpl-3.0
-task_categories:
-- time-series-forecasting
+pretty_name: "Metis-OLMoE Latent Telemetry: Spikenaut SNN Routing"
+language:
+  - en
+  - code
 tags:
-- neuromorphic
-- snn
-- liquid-state-machines
-- gaming
-- hardware-telemetry
-- gpu
-pretty_name: Metis SMoE Latent Telemetry (Gaming)
+  - snn
+  - spiking-neural-network
+  - olmoe
+  - mixture-of-experts
+  - quantization
+  - neuromorphic
+  - telemetry
+  - semantic-routing
+  - latent-space
+  - cuda
+  - rust
+  - gguf
+  - saaq
+datasets:
+  - allenai/OLMoE-1B-7B-0125-Instruct-GGUF
+task_categories:
+  - text-generation
+  - feature-extraction
 ---
 
-# Metis SMoE Latent Telemetry
-## Neuromorphic Hardware Telemetry from demanding Gaming Workloads
+# Metis-OLMoE-Latent-Telemetry: Spikenaut SNN Routing
+
+## 1. The 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?* What if I could use this intense hardware stress to create an artificial heartbeat for AI?
+
+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—a MoE-based SNN quantizaton model and dataset architecture for exploring SNN quantization. 
+
+### Relationship to Spikenaut
+
+**Spikenaut** is my pure SNN model, built from scratch as a native spiking neural network. **Metis** (this repository) serves as the architect and teacher—exploring SNN quantization techniques through the OLMoE Mixture-of-Experts model. The discoveries, equations, and architecture frameworks developed here feed directly into Spikenaut's training and evolution. Metis proves the math; Spikenaut implements it natively.
+
+## 2. 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. These insights directly inform the training of **Spikenaut**, my pure native SNN.
+
+### 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 (The 2000-Route)
+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.
+![English Logic Routing](first-day-testing-real-weights/second-test/map_olmoe_english_logic.png)
+
+#### Structured Logic Routing (The 600-800 Band)
+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.
+![Math Logic Routing](first-day-testing-real-weights/fourth-test/map_olmoe_math_logic.png)
+![Rust Syntax Routing](first-day-testing-real-weights/third-test/map_olmoe_rust_syntax_logic.png)
+
+## 3. Experiment Progression
+The dataset documents the chronological progression from synthetic baselines to actual semantic routing:
 
-This dataset provides high-fidelity, high-frequency (5ms interval) hardware telemetry data captured from extreme PC gaming workloads. This dataset is optimized to simulate the biological responses of a nervous system to intense stimulus (excitatory input, action potentials/firing rates, and inhibitory responses).
+* **Phase 1: Synthetic Baseline (Smoke Test)**
+  * **Input:** Synthetic sine wave.
+  * **Result:** Verified the GPU temporal loop (10,000 ticks) and basic biological fatigue without crashing the CUDA context.
+* **Phase 2: The F16 Magnitude Collapse (Unbounded)**
+  * **Input:** Real LLM embeddings (OLMoE).
+  * **Result:** Unscaled F16-to-F32 extraction resulted in raw, unbounded electrical pressure. A single expert neuron (Walker ~620) was overwhelmed, causing a routing collapse where one walker took the entire load for the full temporal loop.
+* **Phase 3: L2 Normalization & Philosophy Attractors**
+  * **Input:** `"Let's teach this MoE model..."` (Abstract English).
+  * **Result:** L2 Normalization successfully shattered the routing collapse. Energy dynamically settled into high-register attractor bands, predominantly isolating into the **2000-route**.
+* **Phase 4: Semantic Clustering (Code & Math Logic)**
+  * **Input A:** `fn main() { println!("Hello, World!"); }` (Rust Syntax)
+  * **Input B:** `"The derivative of a constant is mathematically zero."` (Math Logic)
+  * **Result:** The SNN abandoned the 2000-route completely. Both raw Rust syntax and mathematical logic organically fell into the exact same **600-800 frequency band**. This demonstrates that the network physically maps highly structured logic tasks to adjacent biological neighborhoods.
 
-### Context
-The telemetry data was recorded using a custom Rust-based data collector via the NVIDIA Management Library (NVML) on a Fedora 43 Linux system. Workloads represent highly transient rendering applications including:
-- **Resident Evil 4 (Remake)** (with rendering complexities)
-- **Cyberpunk 2077** (Path Tracing, DLSS 4.0)
+**Dataset for Spikenaut SNN Research**
 
-This system provides the rich, high-frequency time-series data required to train **Spiking Neural Networks (SNNs)** and **Liquid State Machines (LSMs)**.
+This dataset contains latent telemetry and routing data generated from the SNN-quantized version of AllenAI’s OLMoE-1B-7B-0125-Instruct model using the `corinth-canal` pipeline. The heavy mathethical analysis is documented and implemented in the 'surrogate_viz.jl' repository.
 
-### Neuromorphic Mapping (SNN Utility)
-This data behaves as "sensorimotor" stimulus for neural networks:
-- **Excitatory Inputs (Stimulus):** High surges in `pcie_rx_kbps` indicate asset floods (e.g., BVH structure updates for Path Tracing), mimicking sensory signals entering the system.
-- **Action Potentials (Firing Rates):** `encoder_util_perc`, `decoder_util_perc`, and overall spatial `power_usage_mw` transients represent internal activity and network firing rates.
-- **Inhibitory Inputs (Refractory/Limits):** Non-zero `throttle_reasons_bitmask` signals and thermal limits act as inhibitory governors, dynamically suppressing system activity.
-- **State/Momentum:** Slow-moving environmental data like temperatures (`cpu_tctl_c`, `temperature_c`) and memory capacity.
 
-### Data Schema
 
-The data is provided natively as Parquet files partitioned into train batches (`system_telemetry_v1_batch_*.parquet`).
+### Purpose
+These files are used to study spiking behavior, routing stability, and adaptive quantization (SAAQ) in SNN-converted MoE models. The data feeds SymbolicRegression.jl to discover new equations for improved SNN quantization and ultimately trains the pure native **Spikenaut** SNN.
 
-| Feature | Type | Description |
-| :--- | :--- | :--- |
-| `timestamp_ms` | `Int64` | UNIX timestamp in milliseconds (5ms interval captures). |
-| `power_usage_mw` | `UInt32` | Total GPU power usage in milliwatts. |
-| `temperature_c` | `Float32` | GPU core temperature in Celsius. |
-| `pcie_rx_kbps` | `UInt32` | Incoming PCIe throughput in Kilobytes per second (Excitatory). |
-| `pcie_tx_kbps` | `UInt32` | Outgoing PCIe throughput in Kilobytes per second. |
-| `encoder_util_perc` | `Float32` | NVIDIA Encoder (NVENC) utilization percentage. |
-| `decoder_util_perc` | `Float32` | NVIDIA Decoder (NVDEC) utilization percentage. |
-| `mangohud_active` | `Boolean` | Whether MangoHud overlay telemetry was active during the snapshot. |
-| `cpu_tctl_c` | `Float32` | Primary CPU package temperature (Tctl). |
-| `cpu_ccd1_c` | `Float32` | Temperature of CPU Core Complex Die 1. |
-| `cpu_ccd2_c` | `Float32` | Temperature of CPU Core Complex Die 2. |
-| `throttle_reasons_bitmask`| `UInt64` | Bitmask defining hardware throttling events (Power, Thermal, Sync) - acts as Inhibitory signals. |
+### Folder Structure
 
-### Usage with Hugging Face `datasets`
+- **routing/** — CSV files containing routing and latent telemetry data
+- **first-day/** — Early experimental runs (optional)
+- **SAAQ 3.0/** — Future runs with new algorithm versions
+- **experiments/** — Additional test configurations and variants
+- **results/**
+  - **plots/** — Visualization of SNN routing paths and firing density
+  - **raw_telemetry/** — Original tick-by-tick log files
 
-You can seamlessly integrate this telemetry into your Neuromorphic modeling workflows using the Hugging Face `datasets` library.
+  ### Origin Hardware Baselines (`/origin_hardware_baselines/`)
+This directory contains the foundational, bare-metal hardware telemetry that inspired the Spikenaut SAAQ thermal equations. 
 
-```python
-from datasets import load_dataset
-import pyarrow.parquet as pq
+* **`RE4_path_tracing_telemetry.csv`**: This file captures the extreme hardware stress (GPU/CPU temps, package power, clock speeds) generated by running the *Resident Evil 4 Remake* with heavy modifications (path tracing, DLSS 4.0) on a high-performance workstation PC. 
+* **Purpose:** This specific dataset proved that intense gaming workloads create a highly dynamic, non-zero biological "heartbeat" compared to static crypto-mining telemetry. These exact thermal fluctuations were used to derive the baseline fatigue limits for the SNN's `tick_gpu_temporal` loop.
 
-# Load the entire telemetry dataset as a single stream
-dataset = load_dataset("rmems/Metis-SMoE-Latent-Telemetry", split="train")
+  ### Related Repos
+- [corinth-canal](https://github.com/Limen-Neural/corinth-canal) — SNN quantization pipeline
+- [Surrogate_Viz.jl](https://github.com/Spikenaut/Surrogate_Viz.jl) — Symbolic regression and visualization
 
-print(dataset.features)
-print(dataset[0])
-```
 
-### Export to Canonical CSV (For Corinth Canal Replay)
-If you are using the Spikenaut `corinth-canal` framework, you can export a canonical CSV by grabbing a single dataset file:
 
-```bash
-cargo run --bin export_csv data/train/system_telemetry_v1_batch_1.parquet canonical.csv
-```
 
-### License
-This dataset is distributed under the GPL-3.0 License.