Delete dataset/spikenaut_snn_v2_complete_enhanced

dataset/spikenaut_snn_v2_complete_enhanced/README.md

@@ -1,852 +0,0 @@
-# Spikenaut SNN v2 - Blockchain Telemetry Dataset
-
-[![Hugging Face Dataset](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Dataset-blue)](https://huggingface.co/datasets/rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters)
-[![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](https://opensource.org/licenses/GPL-3.0)
-[![Python](https://img.shields.io/badge/Python-3.8%2B-blue)](https://python.org)
-[![Rust](https://img.shields.io/badge/Rust-1.70%2B-orange)](https://rust-lang.org)
-[![Julia](https://img.shields.io/badge/Julia-1.8%2B-purple)](https://julialang.org)
-
----
-
-## 🦁 Spikenaut-SNN-v2 Telemetry + Weights + Parameters
-
-**Live March 2026 blockchain telemetry + distilled Q8.8 weights for the 16-channel neuromorphic SNN.**
-
-### 📊 Dataset: [Telemetry + Weights + Parameters](https://huggingface.co/datasets/rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters)
-
-### 🔗 Cross-Links
-- **Model**: [Spikenaut-SNN-v2](https://huggingface.co/rmems/Spikenaut-SNN-v2) - 262k-neuron teacher brain
-- **Rust Backend**: [neuromod](https://crates.io/crates/neuromod) - Production implementation
-- **Main Repository**: [Eagle-Lander](https://github.com/rmems/Eagle-Lander) - Complete system
-
----
-
-## 🎯 What's Inside
-
-### **Core Data**
-- **`fresh_sync_data.jsonl`** → Real-time Kaspa (8–13 blocks/sec) + Monero (~9.27 blocks/sec) node sync logs
-- **`hybrid_training_results.json`** → Julia-Rust training convergence (E-prop + OTTT)
-- **`parameters/`** → Q8.8 .mem files (thresholds, weights 16×16, decay rates) for Artix-7 FPGA
-
-### **Enhanced Features** (v2.0 additions)
-- **20+ engineered features** per sample including spike encodings
-- **Time series splits** (train/validation/test) for forecasting
-- **FPGA-ready parameters** in multiple formats
-- **Complete documentation** with usage examples
-
----
-
-## 🚀 Used For
-
-- **Training the 262k-neuron teacher brain** → distilling to 16-channel production model
-- **Hardware-aware SNN** with mining_dopamine, thermal pain receptors, live crypto node sync
-- **Edge neuromorphic systems** for crypto, robotics, or neuro-recovery
-- **Real-time blockchain monitoring** and prediction
-- **FPGA deployment** with sub-50µs processing
-
----
-
-## 🏗️ Part of Spikenaut Ecosystem
-
-**Spikenaut-SNN-v2**: https://huggingface.co/rmems/Spikenaut-SNN-v2  
-**Rust backend (neuromod)**: https://crates.io/crates/neuromod  
-**Main repository**: https://github.com/rmems/Eagle-Lander
-
-This is raw fuel for anyone building edge neuromorphic systems for crypto, robotics, or neuro-rehabilitation.
-
-## 🏷️ Tags
-
-**neuromorphic, snn, spiking-neural-networks, fpga, telemetry, blockchain, crypto-mining, hft, edge-ai, neuro-rehabilitation, kaspa, monero, qubic, julia, rust, q8.8-fixed-point, time-series-forecasting**
-
----
-
-## � Dataset Statistics
-
-| Metric | Value |
-|--------|-------|
-| **Total Samples** | 8 (enhanced from original) |
-| **Features per Sample** | 20+ (including spike encodings) |
-| **Parameter Files** | 3 Q8.8 .mem files |
-| **Time Coverage** | March 2026 (live telemetry) |
-| **Update Rate** | Real-time blockchain events |
-| **Formats** | JSONL, DatasetDict, PyTorch, FPGA .mem |
-
----
-
-## 🎯 Quick Start
-
-### **One-Line Loading** (Fixed!)
-```python
-from datasets import load_dataset
-
-# Load the enhanced dataset
-ds = load_dataset("rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters")
-
-print(f"Training samples: {len(ds['train'])}")
-print(f"Features: {list(ds['train'].features.keys())}")
-
-# Access enhanced data
-sample = ds['train'][0]
-print(f"Blockchain: {sample['blockchain']}")
-print(f"Spike encoding: {sample['spike_hashrate']}")
-print(f"Efficiency: {sample['power_efficiency']:.3f}")
-```
-
-### **Load Your Real Trained Parameters**
-```python
-import torch
-
-# Load YOUR actual trained weights (95.2% accuracy)
-your_params = torch.load('your_real_parameters/spikenaut_your_weights.pth')
-
-print("🦁 YOUR Spikenaut Parameters:")
-print(f"  Architecture: 16×16 neurons")
-print(f"  Training accuracy: 95.2%")
-print(f"  Processing speed: 35µs/tick")
-```
-
-### **FPGA Deployment**
-```verilog
-// Initialize FPGA with YOUR trained Q8.8 parameters
-initial begin
-    $readmemh("parameters/parameters_weights.mem", synaptic_weights);
-    $readmemh("parameters/parameters.mem", neuron_thresholds);
-    $readmemh("parameters/parameters_decay.mem", decay_constants);
-end
-```
-
----
-
-## 📁 Dataset Structure
-
-```
-Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters/
-├── 📊 Main Dataset
-│   ├── hf_dataset/                    # Hugging Face DatasetDict
-│   │   ├── train/                    # 5 samples, 20+ features
-│   │   ├── validation/               # 1 sample
-│   │   ├── test/                     # 2 samples
-│   │   └── dataset_dict.json
-│   ├── fresh_sync_data.jsonl          # Original telemetry
-│   └── hybrid_training_results.json   # Training metrics
-│
-├── 🔧 Parameters (Multi-Format)
-│   ├── parameters/                    # FPGA Q8.8 format
-│   │   ├── parameters.mem             # 16 neuron thresholds
-│   │   ├── parameters_weights.mem     # 16×16 synaptic weights
-│   │   ├── parameters_decay.mem      # 16 decay constants
-│   │   └── README.md                  # FPGA documentation
-│   └── your_real_parameters/         # YOUR trained weights
-│       ├── spikenaut_your_weights.pth # PyTorch format
-│       └── [enhanced formats]
-│
-├── 📚 Examples & Documentation
-│   ├── examples/
-│   │   ├── spike_encoding_demo.ipynb    # Complete tutorial
-│   │   ├── snn_training_demo.ipynb       # SNN training
-│   │   └── fpga_deployment_guide.ipynb  # Hardware guide
-│   └── legacy_enhanced_data/            # 223K legacy records
-│
-└── 🛠️ Tools & Scripts
-    ├── convert_to_hf_format.py        # Dataset conversion
-    ├── generate_spike_data.py         # Spike encoding
-    └── [processing scripts]
-```
-
----
-
-## 🔬 Data Schema
-
-### **Core Telemetry Fields**
-| Field | Type | Description |
-|-------|------|-------------|
-| `timestamp` | string | Event timestamp (ISO 8601) |
-| `blockchain` | string | "kaspa" or "monero" |
-| `event_type` | string | "block_accepted" or "sync_progress" |
-| `telemetry` | object | Hardware and network metrics |
-
-### **Enhanced Features** (v2.0)
-| Field | Type | Description |
-|-------|------|-------------|
-| `spike_hashrate` | int | Binary spike encoding (0/1) |
-| `spike_power` | int | Power spike indicator |
-| `spike_temp` | int | Temperature spike indicator |
-| `hashrate_normalized` | float | Normalized hashrate (0-1) |
-| `power_efficiency` | float | MH/kW efficiency metric |
-| `thermal_efficiency` | float | MH/°C efficiency metric |
-| `composite_reward` | float | Multi-objective reward signal |
-| `target_hashrate_change` | float | Next-tick forecast target |
-
----
-
-## 🧠 Advanced Usage
-
-### **SNN Training with Your Weights**
-```python
-# See examples/snn_training_demo.ipynb for complete pipeline
-import torch
-from datasets import load_dataset
-
-# Load dataset and your trained parameters
-ds = load_dataset("rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters")
-your_params = torch.load('your_real_parameters/spikenaut_your_weights.pth')
-
-# Create SNN with YOUR weights
-class YourSpikenautSNN(torch.nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.hidden_layer = torch.nn.Linear(8, 16)
-        self.output_layer = torch.nn.Linear(16, 3)
-        self.load_state_dict(your_params, strict=False)
-    
-    def forward(self, x):
-        # E-prop SNN processing
-        return x
-
-model = YourSpikenautSNN()
-print("🎉 SNN ready with YOUR 95.2% accurate weights!")
-```
-
-### **Legacy Data Analysis** (223K Records)
-```python
-# Access your massive historical dataset
-import pandas as pd
-import json
-
-legacy_df = pd.read_json('legacy_enhanced_data/legacy_chunk_0000.jsonl', lines=True)
-print(f"📊 Legacy data: {len(legacy_df):,} records")
-print(f"Portfolio growth: ${500}→${legacy_df['portfolio_value'].max():.2f}")
-```
-
----
-
-## 🎯 Performance Metrics
-
-### **Your Training Results**
-- **Accuracy**: 95.2% (from hybrid_training_results.json)
-- **Speed**: 35µs/tick (sub-50µs target achieved)
-- **Latency**: 0.8µs IPC overhead
-- **Memory**: 1.6KB usage
-- **Convergence**: 20 epochs
-
-### **Dataset Quality**
-- **JSON Validity**: 100% across all files
-- **Completeness**: 100% for core fields
-- **Temporal Coverage**: Real-time March 2026
-- **Enhancement**: 20+ features per sample
-
----
-
-## 🔗 Related Resources
-
-### **Ecosystem Links**
-- **🤖 Model**: [Spikenaut-SNN-v2](https://huggingface.co/rmems/Spikenaut-SNN-v2) - 262k-neuron teacher brain
-- **⚙️ Rust Crate**: [neuromod](https://crates.io/crates/neuromod) - Production backend
-- **🦅 Main Repo**: [Eagle-Lander](https://github.com/rmems/Eagle-Lander) - Complete system
-- **📚 Documentation**: [Examples](examples/) - 3 complete tutorials
-
-### **Research Applications**
-- **Neuromorphic Computing**: SNN research and benchmarking
-- **Blockchain Analytics**: Real-time monitoring and prediction
-- **Edge AI**: Low-power deployment on FPGA
-- **Neuro-rehabilitation**: Spike-based learning algorithms
-
----
-
-
----
-
-## 🧠 Additional Data Sources (NEW!)
-
-### **Training Data** (`training/`)
-- **Real SNN training** with 16-neuron spike patterns
-- **Reward signals** and stimuli for reinforcement learning
-- **Market-specific** and mind telemetry training
-- **Total**: 43KB across 3 training datasets
-
-### **Mining Operations** (`mining/`)
-- **55MB of real mining logs** from BzMiner v24.0.1
-- **Hashrate metrics**, temperature readings, GPU monitoring
-- **Hardware performance** data for correlation studies
-- **Production-tested** mining operation telemetry
-
-### **System Operations** (`operations/`)
-- **Supervisor telemetry** with system monitoring events
-- **Process lifecycle** tracking and status updates
-- **Timestamped operations** from March 2026
-
-### **Research Dataset** (`research/`)
-- **380MB neuromorphic dataset** for advanced research
-- **Massive spike-based** data patterns
-- **Time-series neuromorphic** records
-
----
-
-## 📊 Enhanced Dataset Statistics
-
-| **Component** | **Size** | **Records** | **Description** |
-|---------------|----------|-------------|-----------------|
-| Core Dataset | ~200MB | 8 samples | Enhanced telemetry + parameters |
-| Training Data | 43KB | ~40K records | Real SNN spike training |
-| Mining Logs | 55MB | Millions | BzMiner operation data |
-| Operations | 1KB | 7 events | Supervisor telemetry |
-| Research Data | 380MB | ~400K est | Neuromorphic research |
-| **TOTAL** | **~635MB** | **~440K+** | **Complete ecosystem** |
-
----
-
-## 🚀 Usage with Additional Data
-
-### **Load Training Data**
-```python
-import json
-import pandas as pd
-
-# Load SNN training data
-with open('training/snn_training_all.jsonl', 'r') as f:
-    training_data = [json.loads(line) for line in f]
-
-print(f"Training records: {len(training_data):,}")
-print(f"Neuron patterns: {len(training_data[0]['expected_spikes'])}")
-```
-
-### **Analyze Mining Performance**
-```python
-# Mining log analysis
-import re
-
-hashrates = []
-temperatures = []
-
-with open('mining/miner.log', 'r') as f:
-    for line in f:
-        if 'MH/s' in line:
-            # Extract hashrate values
-            hr_match = re.search(r'(\d+\.?\d*)\s*MH/s', line)
-            if hr_match:
-                hashrates.append(float(hr_match.group(1)))
-
-print(f"Mining hashrate samples: {len(hashrates)}")
-print(f"Average hashrate: {np.mean(hashrates):.2f} MH/s")
-```
-
-### **System Monitoring**
-```python
-# Load supervisor events
-with open('operations/supervisor_telemetry.jsonl', 'r') as f:
-    events = [json.loads(line) for line in f]
-
-print(f"System events: {len(events)}")
-for event in events[:5]:
-    print(f"  {event['timestamp']}: {event['status']}")
-```
-
----
-
-## 🎯 Complete Research Pipeline
-
-With all data sources, you can now:
-
-1. **Train SNN** with real spike patterns from `training/`
-2. **Correlate Performance** between mining logs and SNN metrics
-3. **Monitor Operations** with supervisor telemetry
-4. **Advanced Research** with massive neuromorphic dataset
-5. **Deploy to FPGA** using your real trained parameters
-
-**This is the most comprehensive neuromorphic blockchain dataset available!**
-
-
-
-
----
-
-## 🧠 Additional Data Sources (NEW!)
-
-### **Training Data** (`training/`)
-- **Real SNN training** with 16-neuron spike patterns
-- **Reward signals** and stimuli for reinforcement learning
-- **Market-specific** and mind telemetry training
-- **Total**: 43KB across 3 training datasets
-
-### **Mining Operations** (`mining/`)
-- **55MB of real mining logs** from BzMiner v24.0.1
-- **Hashrate metrics**, temperature readings, GPU monitoring
-- **Hardware performance** data for correlation studies
-- **Production-tested** mining operation telemetry
-
-### **System Operations** (`operations/`)
-- **Supervisor telemetry** with system monitoring events
-- **Process lifecycle** tracking and status updates
-- **Timestamped operations** from March 2026
-
-### **Research Dataset** (`research/`)
-- **380MB neuromorphic dataset** for advanced research
-- **Massive spike-based** data patterns
-- **Time-series neuromorphic** records
-
----
-
-## 📊 Enhanced Dataset Statistics
-
-| **Component** | **Size** | **Records** | **Description** |
-|---------------|----------|-------------|-----------------|
-| Core Dataset | ~200MB | 8 samples | Enhanced telemetry + parameters |
-| Training Data | 43KB | ~40K records | Real SNN spike training |
-| Mining Logs | 55MB | Millions | BzMiner operation data |
-| Operations | 1KB | 7 events | Supervisor telemetry |
-| Research Data | 380MB | ~400K est | Neuromorphic research |
-| **TOTAL** | **~635MB** | **~440K+** | **Complete ecosystem** |
-
----
-
-## 🚀 Usage with Additional Data
-
-### **Load Training Data**
-```python
-import json
-import pandas as pd
-
-# Load SNN training data
-with open('training/snn_training_all.jsonl', 'r') as f:
-    training_data = [json.loads(line) for line in f]
-
-print(f"Training records: {len(training_data):,}")
-print(f"Neuron patterns: {len(training_data[0]['expected_spikes'])}")
-```
-
-### **Analyze Mining Performance**
-```python
-# Mining log analysis
-import re
-
-hashrates = []
-temperatures = []
-
-with open('mining/miner.log', 'r') as f:
-    for line in f:
-        if 'MH/s' in line:
-            # Extract hashrate values
-            hr_match = re.search(r'(\d+\.?\d*)\s*MH/s', line)
-            if hr_match:
-                hashrates.append(float(hr_match.group(1)))
-
-print(f"Mining hashrate samples: {len(hashrates)}")
-print(f"Average hashrate: {np.mean(hashrates):.2f} MH/s")
-```
-
-### **System Monitoring**
-```python
-# Load supervisor events
-with open('operations/supervisor_telemetry.jsonl', 'r') as f:
-    events = [json.loads(line) for line in f]
-
-print(f"System events: {len(events)}")
-for event in events[:5]:
-    print(f"  {event['timestamp']}: {event['status']}")
-```
-
----
-
-## 🎯 Complete Research Pipeline
-
-With all data sources, you can now:
-
-1. **Train SNN** with real spike patterns from `training/`
-2. **Correlate Performance** between mining logs and SNN metrics
-3. **Monitor Operations** with supervisor telemetry
-4. **Advanced Research** with massive neuromorphic dataset
-5. **Deploy to FPGA** using your real trained parameters
-
-**This is the most comprehensive neuromorphic blockchain dataset available!**
-
-
-
-## 📄 License
-
-GPL-3.0 - See [LICENSE](../LICENSE) file for details.
-
----
-
-## 🤝 Contributing
-
-Contributions welcome! Please see the main repository for guidelines:
-- **Issues**: [GitHub Issues](https://github.com/rmems/Eagle-Lander/issues)
-- **Pull Requests**: [GitHub PRs](https://github.com/rmems/Eagle-Lander/pulls)
-
----
-
-## 📞 Contact
-
-**Author**: Raul Montoya Cardenas  
-**Affiliation**: Texas State University Electrical Engineering  
-**Email**: rmems@texasstate.edu
-
----
-
----
-
-## 📊 Dataset Contents
-
-- **`hf_dataset/`**: Main dataset in Hugging Face format (train/validation/test splits)
-- **`fresh_sync_data.jsonl`**: Raw telemetry data (Kaspa + Monero blockchain events)
-- **`hybrid_training_results.json`**: Julia-Rust training convergence metrics
-- **`parameters/`**: Q8.8 fixed-point weights for Artix-7 FPGA deployment
-- **`examples/`**: Complete Jupyter notebook tutorials
-- **`your_real_parameters/`**: YOUR actual trained weights (95.2% accuracy)
-- **`legacy_enhanced_data/`**: 223K historical trading records
-
----
-
-## 🎯 Impact & Discoverability
-
-**Expected Impact**: +300–500% discoverability overnight with proper tagging and cross-linking
-
-**Key Discovery Paths**:
-- **Neuromorphic Computing**: SNN research and benchmarking
-- **Blockchain Analytics**: Real-time monitoring and prediction  
-- **Edge AI**: Low-power deployment on FPGA
-- **High-Frequency Trading**: Sub-50µs processing capability
-- **Neuro-rehabilitation**: Spike-based learning algorithms
-
----
-
-## � Ready for Production
-
-This dataset provides **raw fuel** for anyone building edge neuromorphic systems for:
-- **Crypto**: Real-time blockchain monitoring and prediction
-- **Robotics**: Spike-based sensorimotor processing
-- **Neuro-recovery**: Adaptive learning algorithms
-- **Edge AI**: Low-power neuromorphic deployment
-
-**All components are production-tested and ready for immediate use.**
-
-## 🔬 Technical Specifications
-
-### Data Collection
-- **Sources**: Kaspa mainnet, Monero mainnet
-- **Frequency**: Event-driven (block acceptance, sync events)
-- **Hardware**: RTX 5080, custom monitoring rig
-- **Format**: JSONL → Apache Arrow (HF format)
-
-### Feature Engineering
-- **Spike Encoding**: Threshold-based binary features
-- **Normalization**: Min-max scaling to [0,1] range
-- **Temporal Features**: Hour/day cyclical encoding
-- **Efficiency Metrics**: Hardware performance ratios
-
-### Quality Assurance
-- **Validation**: 100% valid JSON records
-- **Completeness**: No missing values
-- **Consistency**: Monitored timestamp ordering
-- **Accuracy**: Cross-validated with node logs
-
-## 🚀 Advanced Usage
-
-### Custom Spike Encoding
-
-```python
-def custom_spike_encoder(telemetry, thresholds=None):
-    """Create custom spike encodings from telemetry data"""
-    if thresholds is None:
-        thresholds = {
-            'hashrate': 0.9,
-            'power': 390,
-            'temp': 43,
-            'qubic': 0.95
-        }
-    
-    spikes = {}
-    spikes['hashrate'] = 1 if telemetry['hashrate_mh'] > thresholds['hashrate'] else 0
-    spikes['power'] = 1 if telemetry['power_w'] > thresholds['power'] else 0
-    spikes['temp'] = 1 if telemetry['gpu_temp_c'] > thresholds['temp'] else 0
-    spikes['qubic'] = 1 if telemetry['qubic_tick_trace'] > thresholds['qubic'] else 0
-    
-    return spikes
-```
-
-### Real-time Inference
-
-```python
-import time
-from datasets import load_dataset
-
-# Load trained model parameters
-parameters = load_q8_8_parameters("parameters/parameters_weights.mem")
-
-def real_time_inference(telemetry_data):
-    """Run real-time SNN inference on new telemetry"""
-    # Encode spikes
-    spikes = custom_spike_encoder(telemetry_data)
-    
-    # Simple matrix multiplication (simulating SNN)
-    spike_vector = np.array([spikes['hashrate'], spikes['power'], 
-                            spikes['temp'], spikes['qubic']])
-    
-    # Apply trained weights
-    output = np.dot(spike_vector, parameters[:4])  # Simple example
-    
-    # Decode prediction
-    prediction = {
-        'next_hashrate_trend': 'up' if output > 0 else 'down',
-        'confidence': abs(output),
-        'recommendation': 'continue' if output > 0.1 else 'monitor'
-    }
-    
-    return prediction
-
-# Example usage
-new_telemetry = {
-    'hashrate_mh': 1.2,
-    'power_w': 395.0,
-    'gpu_temp_c': 44.5,
-    'qubic_tick_trace': 0.98
-}
-
-result = real_time_inference(new_telemetry)
-print(f"Prediction: {result}")
-```
-
-## 📚 Related Resources
-
-- **Main Repository**: [Spikenaut SNN v2](https://github.com/rmems/Eagle-Lander)
-- **FPGA Implementation**: [Basys3 Deployment Guide](https://github.com/rmems/Eagle-Lander/tree/main/HARDWARE)
-- **Training Pipeline**: [Hybrid Julia-Rust Guide](https://github.com/rmems/Eagle-Lander/tree/main/CORE)
-- **V1 Dataset**: [Spikenaut v1 Telemetry](https://huggingface.co/datasets/rmems/Spikenaut-v1-Telemetry-Data)
-
-
----
-
-## 🧠 Additional Data Sources (NEW!)
-
-### **Training Data** (`training/`)
-- **Real SNN training** with 16-neuron spike patterns
-- **Reward signals** and stimuli for reinforcement learning
-- **Market-specific** and mind telemetry training
-- **Total**: 43KB across 3 training datasets
-
-### **Mining Operations** (`mining/`)
-- **55MB of real mining logs** from BzMiner v24.0.1
-- **Hashrate metrics**, temperature readings, GPU monitoring
-- **Hardware performance** data for correlation studies
-- **Production-tested** mining operation telemetry
-
-### **System Operations** (`operations/`)
-- **Supervisor telemetry** with system monitoring events
-- **Process lifecycle** tracking and status updates
-- **Timestamped operations** from March 2026
-
-### **Research Dataset** (`research/`)
-- **380MB neuromorphic dataset** for advanced research
-- **Massive spike-based** data patterns
-- **Time-series neuromorphic** records
-
----
-
-## 📊 Enhanced Dataset Statistics
-
-| **Component** | **Size** | **Records** | **Description** |
-|---------------|----------|-------------|-----------------|
-| Core Dataset | ~200MB | 8 samples | Enhanced telemetry + parameters |
-| Training Data | 43KB | ~40K records | Real SNN spike training |
-| Mining Logs | 55MB | Millions | BzMiner operation data |
-| Operations | 1KB | 7 events | Supervisor telemetry |
-| Research Data | 380MB | ~400K est | Neuromorphic research |
-| **TOTAL** | **~635MB** | **~440K+** | **Complete ecosystem** |
-
----
-
-## 🚀 Usage with Additional Data
-
-### **Load Training Data**
-```python
-import json
-import pandas as pd
-
-# Load SNN training data
-with open('training/snn_training_all.jsonl', 'r') as f:
-    training_data = [json.loads(line) for line in f]
-
-print(f"Training records: {len(training_data):,}")
-print(f"Neuron patterns: {len(training_data[0]['expected_spikes'])}")
-```
-
-### **Analyze Mining Performance**
-```python
-# Mining log analysis
-import re
-
-hashrates = []
-temperatures = []
-
-with open('mining/miner.log', 'r') as f:
-    for line in f:
-        if 'MH/s' in line:
-            # Extract hashrate values
-            hr_match = re.search(r'(\d+\.?\d*)\s*MH/s', line)
-            if hr_match:
-                hashrates.append(float(hr_match.group(1)))
-
-print(f"Mining hashrate samples: {len(hashrates)}")
-print(f"Average hashrate: {np.mean(hashrates):.2f} MH/s")
-```
-
-### **System Monitoring**
-```python
-# Load supervisor events
-with open('operations/supervisor_telemetry.jsonl', 'r') as f:
-    events = [json.loads(line) for line in f]
-
-print(f"System events: {len(events)}")
-for event in events[:5]:
-    print(f"  {event['timestamp']}: {event['status']}")
-```
-
----
-
-## 🎯 Complete Research Pipeline
-
-With all data sources, you can now:
-
-1. **Train SNN** with real spike patterns from `training/`
-2. **Correlate Performance** between mining logs and SNN metrics
-3. **Monitor Operations** with supervisor telemetry
-4. **Advanced Research** with massive neuromorphic dataset
-5. **Deploy to FPGA** using your real trained parameters
-
-**This is the most comprehensive neuromorphic blockchain dataset available!**
-
-
-
-
----
-
-## 🧠 Additional Data Sources (NEW!)
-
-### **Training Data** (`training/`)
-- **Real SNN training** with 16-neuron spike patterns
-- **Reward signals** and stimuli for reinforcement learning
-- **Market-specific** and mind telemetry training
-- **Total**: 43KB across 3 training datasets
-
-### **Mining Operations** (`mining/`)
-- **55MB of real mining logs** from BzMiner v24.0.1
-- **Hashrate metrics**, temperature readings, GPU monitoring
-- **Hardware performance** data for correlation studies
-- **Production-tested** mining operation telemetry
-
-### **System Operations** (`operations/`)
-- **Supervisor telemetry** with system monitoring events
-- **Process lifecycle** tracking and status updates
-- **Timestamped operations** from March 2026
-
-### **Research Dataset** (`research/`)
-- **380MB neuromorphic dataset** for advanced research
-- **Massive spike-based** data patterns
-- **Time-series neuromorphic** records
-
----
-
-## 📊 Enhanced Dataset Statistics
-
-| **Component** | **Size** | **Records** | **Description** |
-|---------------|----------|-------------|-----------------|
-| Core Dataset | ~200MB | 8 samples | Enhanced telemetry + parameters |
-| Training Data | 43KB | ~40K records | Real SNN spike training |
-| Mining Logs | 55MB | Millions | BzMiner operation data |
-| Operations | 1KB | 7 events | Supervisor telemetry |
-| Research Data | 380MB | ~400K est | Neuromorphic research |
-| **TOTAL** | **~635MB** | **~440K+** | **Complete ecosystem** |
-
----
-
-## 🚀 Usage with Additional Data
-
-### **Load Training Data**
-```python
-import json
-import pandas as pd
-
-# Load SNN training data
-with open('training/snn_training_all.jsonl', 'r') as f:
-    training_data = [json.loads(line) for line in f]
-
-print(f"Training records: {len(training_data):,}")
-print(f"Neuron patterns: {len(training_data[0]['expected_spikes'])}")
-```
-
-### **Analyze Mining Performance**
-```python
-# Mining log analysis
-import re
-
-hashrates = []
-temperatures = []
-
-with open('mining/miner.log', 'r') as f:
-    for line in f:
-        if 'MH/s' in line:
-            # Extract hashrate values
-            hr_match = re.search(r'(\d+\.?\d*)\s*MH/s', line)
-            if hr_match:
-                hashrates.append(float(hr_match.group(1)))
-
-print(f"Mining hashrate samples: {len(hashrates)}")
-print(f"Average hashrate: {np.mean(hashrates):.2f} MH/s")
-```
-
-### **System Monitoring**
-```python
-# Load supervisor events
-with open('operations/supervisor_telemetry.jsonl', 'r') as f:
-    events = [json.loads(line) for line in f]
-
-print(f"System events: {len(events)}")
-for event in events[:5]:
-    print(f"  {event['timestamp']}: {event['status']}")
-```
-
----
-
-## 🎯 Complete Research Pipeline
-
-With all data sources, you can now:
-
-1. **Train SNN** with real spike patterns from `training/`
-2. **Correlate Performance** between mining logs and SNN metrics
-3. **Monitor Operations** with supervisor telemetry
-4. **Advanced Research** with massive neuromorphic dataset
-5. **Deploy to FPGA** using your real trained parameters
-
-**This is the most comprehensive neuromorphic blockchain dataset available!**
-
-
-
-## 📄 License
-
-GPL-3.0 - Same as main Spikenaut project. See LICENSE file for details.
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit changes (`git commit -m 'Add amazing feature'`)
-4. Push to branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
-
-### Data Contributions Welcome!
-
-- Additional blockchain telemetry
-- New spike encoding methods
-- Performance benchmarking results
-- FPGA deployment examples
-
-## 📞 Contact
-
-**Author**: Raul Montoya Cardenas  
-**Affiliation**: Texas State University Electrical Engineering  
-**Email**: rmems@texasstate.edu  
-**Built**: Ship of Theseus workstation, Texas 2026
-
----
-
-> 🦁 **Spikenaut-SNN-v2** is proof that recovery, engineering, and sovereignty can be achieved independently—one spike at a time.

dataset/spikenaut_snn_v2_complete_enhanced/dataset_card.json

@@ -1,65 +0,0 @@
-{
-  "license": "gpl-3.0",
-  "language": [
-    "python",
-    "rust",
-    "julia",
-    "verilog"
-  ],
-  "tags": [
-    "spiking-neural-networks",
-    "neuromorphic-computing",
-    "time-series-forecasting",
-    "blockchain",
-    "kaspa",
-    "monero",
-    "qubic",
-    "fpga",
-    "julia",
-    "rust",
-    "telemetry",
-    "hybrid-training",
-    "crypto-mining",
-    "hft",
-    "edge-ai",
-    "neuro-rehabilitation",
-    "q8.8-fixed-point",
-    "mining-operations",
-    "system-monitoring",
-    "neuromorphic-research"
-  ],
-  "pretty_name": "Spikenaut SNN v2 - Complete Neuromorphic Blockchain Ecosystem",
-  "dataset_summary": "The world's most comprehensive neuromorphic blockchain dataset: 635MB with real telemetry, SNN training data, mining operations, system monitoring, and neuromorphic research data.",
-  "description": "🦁 **MASSIVE ENHANCEMENT ALERT** 🦁\n\n**Spikenaut SNN v2** is now the **most comprehensive neuromorphic blockchain dataset ever created** with **635MB** of production-ready data across **5 complete data collections**.\n\n## 🎯 **What's Inside (NEW v2.1)**\n\n### **📊 Core Dataset** (200MB)\n- **Real Blockchain Telemetry**: Kaspa (8-13 blocks/sec) + Monero (~9.27 blocks/sec)\n- **Enhanced Features**: 20+ engineered features including spike encodings\n- **FPGA Parameters**: Q8.8 fixed-point weights for Artix-7 deployment\n- **Time Series Ready**: Train/validation/test splits for forecasting\n- **Your Real Weights**: 95.2% accurate trained parameters\n\n### **🧠 Training Data** (43KB)\n- **Real SNN Training**: 16-neuron spike patterns with reward signals\n- **Market Training**: Market-specific spike training data\n- **Mind Telemetry**: Cognitive training patterns\n- **40K+ Training Records**: Complete SNN training pipeline\n\n### **⛏️ Mining Operations** (55MB)\n- **BzMiner v24.0.1 Logs**: Real mining operation telemetry\n- **Hardware Performance**: Hashrate, temperature, GPU metrics\n- **Millions of Records**: Complete mining operation history\n- **Performance Correlation**: Mining vs SNN performance data\n\n### **👨‍💼 System Operations** (1KB)\n- **Supervisor Telemetry**: System monitoring and lifecycle events\n- **Process Tracking**: Complete operation monitoring\n- **Timestamped Events**: March 2026 system operations\n\n### **🧬 Research Dataset** (380MB)\n- **Neuromorphic Data**: Massive neuromorphic research dataset\n- **Advanced Patterns**: Complex spike-based data structures\n- **Research-Ready**: 400K+ estimated neuromorphic records\n\n## 🚀 **Key Capabilities**\n\n### **Complete Research Pipeline**:\n1. **Raw Telemetry** → **Spike Encoding** → **SNN Training** → **FPGA Deployment**\n2. **Hardware Correlation**: Mining performance vs neuromorphic processing\n3. **System Monitoring**: Full operation lifecycle tracking\n4. **Advanced Research**: Massive neuromorphic dataset\n\n### **Production Ready**:\n- **Sub-50µs Processing**: 35µs/tick achieved\n- **FPGA Deployment**: Q8.8 parameters ready\n- **Real Training Data**: Actual spike patterns from production\n- **System Monitoring**: Complete operational telemetry\n\n## 📈 **Dataset Statistics**\n\n| **Collection** | **Size** | **Records** | **Type** |\n|---------------|----------|-------------|----------|\n| Core Dataset | 200MB | 8 samples | Enhanced telemetry |\n| Training Data | 43KB | ~40K | SNN spike training |\n| Mining Logs | 55MB | Millions | Operation data |\n| Operations | 1KB | 7 events | System monitoring |\n| Research Data | 380MB | ~400K | Neuromorphic research |\n| **TOTAL** | **~635MB** | **~1.4M+** | **Complete ecosystem** |\n\n## 🎯 **Use Cases**\n\n### **Neuromorphic Computing**:\n- **SNN Training**: Real spike patterns with reward signals\n- **Hardware Deployment**: FPGA-ready Q8.8 parameters\n- **Performance Analysis**: Sub-50µs processing benchmarks\n\n### **Blockchain Applications**:\n- **Mining Optimization**: Real mining operation data\n- **Performance Monitoring**: Hardware correlation studies\n- **Network Analysis**: Real-time telemetry processing\n\n### **Research Applications**:\n- **Advanced Studies**: 380MB neuromorphic dataset\n- **System Monitoring**: Complete operation lifecycle\n- **Cross-Domain**: Mining + neuromorphic correlation\n\n### **Edge AI & Robotics**:\n- **Low-Power Deployment**: FPGA implementation\n- **Real-Time Processing**: Sub-50µs capability\n- **Sensorimotor Processing**: Spike-based learning\n\n## 🔗 **Ecosystem Integration**\n\n- **🤖 Model**: [Spikenaut-SNN-v2](https://huggingface.co/rmems/Spikenaut-SNN-v2) - 262k-neuron teacher brain\n- **⚙️ Rust Crate**: [neuromod](https://crates.io/crates/neuromod) - Production backend\n- **🦅 Main Repo**: [Eagle-Lander](https://github.com/rmems/Eagle-Lander) - Complete system\n\n## 🏆 **What Makes This Special**\n\n### **World's First**:\n- **Complete neuromorphic blockchain ecosystem** with all data types\n- **Real SNN training data** with actual spike patterns\n- **Mining operation correlation** with neuromorphic processing\n- **System monitoring** for complete lifecycle tracking\n\n### **Production Tested**:\n- **95.2% Accuracy**: Your real trained parameters\n- **35µs Processing**: Sub-50µs target achieved\n- **FPGA Ready**: Q8.8 parameters for hardware deployment\n- **Real Mining Data**: 55MB of production operation logs\n\n### **Research Grade**:\n- **380MB Research Dataset**: Advanced neuromorphic data\n- **Multiple Data Types**: Training, mining, operations, research\n- **Complete Pipeline**: From raw telemetry to deployment\n- **Cross-Domain**: Blockchain + neuromorphic integration\n\n## 🎊 **Impact & Discoverability**\n\n**Expected Impact**: **+500-800%** discoverability increase\n\n**Why**:\n- **Training Data**: +200% ML researcher interest\n- **Mining Data**: +150% blockchain/mining community\n- **Neuromorphic**: +300% research interest\n- **Complete Ecosystem**: +150% industry adoption\n\n## 📚 **Usage Examples**\n\n### **Load Complete Dataset**:\n```python\nfrom datasets import load_dataset\n\n# Load enhanced core dataset\nds = load_dataset(\"rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters\")\nprint(f\"Core samples: {len(ds['train'])}\")\n\n# Load training data\nwith open('training/snn_training_all.jsonl', 'r') as f:\n    training_data = [json.loads(line) for line in f]\nprint(f\"Training records: {len(training_data):,}\")\n\n# Load mining data\nwith open('mining/miner.log', 'r') as f:\n    mining_lines = f.readlines()\nprint(f\"Mining log lines: {len(mining_lines):,}\")\n```\n\n### **Complete Research Pipeline**:\n```python\n# 1. Load real training spikes\ntraining_spikes = load_training_spikes()\n\n# 2. Load your trained parameters\nyour_weights = torch.load('your_real_parameters/spikenaut_your_weights.pth')\n\n# 3. Correlate with mining performance\nmining_metrics = analyze_mining_logs()\n\n# 4. Deploy to FPGA\nfpga_ready = load_q8_8_parameters()\n```\n\n---\n\n> 🦁 **Spikenaut SNN v2**: The world's most comprehensive neuromorphic blockchain dataset.\n> \n> *635MB of production-ready data across training, mining, operations, and research.*",
-  "version": "2.1.0",
-  "annotations_creators": [
-    "machine-generated",
-    "expert-annotated"
-  ],
-  "source_datasets": [],
-  "size_categories": [
-    "100K-1M",
-    "10K-100K",
-    "1K-10K"
-  ],
-  "task_categories": [
-    "time-series-forecasting",
-    "tabular-classification",
-    "neuromorphic-computing",
-    "blockchain-analysis",
-    "hardware-performance-monitoring"
-  ],
-  "multilinguality": [
-    "monolingual"
-  ],
-  "paper": {
-    "title": "Spikenaut SNN v2: Complete Neuromorphic Blockchain Ecosystem with Real Training Data and Mining Operations"
-  },
-  "author": {
-    "name": "Raul Montoya Cardenas",
-    "email": "rmems@texasstate.edu"
-  },
-  "organization": {
-    "name": "Texas State University Electrical Engineering"
-  }
-}

dataset/spikenaut_snn_v2_complete_enhanced/examples/fpga_deployment_guide.ipynb

@@ -1,1010 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 🔧 Spikenaut SNN v2 - FPGA Deployment Guide\n",
-    "\n",
-    "Complete guide for deploying Spikenaut SNN v2 to Xilinx Artix-7 Basys3 FPGA.\n",
-    "\n",
-    "## What you'll learn:\n",
-    "- Understanding Q8.8 fixed-point format\n",
-    "- Loading parameters into FPGA memory\n",
-    "- Verilog implementation basics\n",
-    "- Hardware verification\n",
-    "- Performance optimization"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Hardware Requirements"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Hardware specifications\n",
-    "hardware_specs = {\n",
-    "    'fpga_board': 'Xilinx Artix-7 Basys3',\n",
-    "    'target_device': 'XC7A35T-1CPG236C',\n",
-    "    'logic_cells': 5200,\n",
-    "    'bram': 1800,  # 18Kb blocks\n",
-    "    'dsp_slices': 90,\n",
-    "    'clock_speed': '1kHz (1ms resolution)',\n",
-    "    'power_consumption': '~97mW dynamic',\n",
-    "    'interface': 'UART, GPIO, PMOD'\n",
-    "}\n",
-    "\n",
-    "print(\"🔧 Hardware Requirements:\")\n",
-    "for key, value in hardware_specs.items():\n",
-    "    print(f\"  {key}: {value}\")\n",
-    "\n",
-    "# Memory requirements\n",
-    "memory_requirements = {\n",
-    "    'neuron_thresholds': 16 * 2,  # 16 neurons, 2 bytes each\n",
-    "    'synaptic_weights': 16 * 8 * 2,  # 16x8 matrix, 2 bytes each\n",
-    "    'decay_constants': 16 * 2,  # 16 decay values\n",
-    "    'input_buffer': 8 * 2,  # 8 input features\n",
-    "    'output_buffer': 3 * 2,  # 3 output classes\n",
-    "    'total_memory_kb': (16 * 2 + 16 * 8 * 2 + 16 * 2 + 8 * 2 + 3 * 2) / 1024\n",
-    "}\n",
-    "\n",
-    "print(f\"\\n💾 Memory Requirements:\")\n",
-    "print(f\"  Total memory needed: {memory_requirements['total_memory_kb']:.2f} KB\")\n",
-    "print(f\"  Available BRAM: {hardware_specs['bram']} * 18Kb = {hardware_specs['bram'] * 18 / 1024:.1f} MB\")\n",
-    "print(f\"  Memory utilization: {(memory_requirements['total_memory_kb'] / (hardware_specs['bram'] * 18 / 1024) * 100):.1f}%\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Q8.8 Fixed-Point Format"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "def float_to_q8_8(value):\n",
-    "    \"\"\"Convert float to Q8.8 fixed-point format\"\"\"\n",
-    "    # Clamp to Q8.8 range\n",
-    "    value = np.clip(value, -128, 127.996)\n",
-    "    # Convert to fixed-point\n",
-    "    q8_8 = int(value * 256)\n",
-    "    return q8_8\n",
-    "\n",
-    "def q8_8_to_float(q8_8):\n",
-    "    \"\"\"Convert Q8.8 fixed-point to float\"\"\"\n",
-    "    # Convert to signed integer\n",
-    "    if q8_8 >= 32768:  # Negative number in two's complement\n",
-    "        q8_8 = q8_8 - 65536\n",
-    "    # Convert to float\n",
-    "    return q8_8 / 256.0\n",
-    "\n",
-    "# Demonstrate Q8.8 conversion\n",
-    "test_values = [-1.0, -0.5, 0.0, 0.5, 1.0, 2.5, 10.0, 100.0]\n",
-    "\n",
-    "print(\"🔢 Q8.8 Fixed-Point Conversion Examples:\")\n",
-    "print(\"Float -> Q8.8 (Hex) -> Back to Float\")\n",
-    "print(\"-\" * 50)\n",
-    "\n",
-    "for val in test_values:\n",
-    "    q8_8 = float_to_q8_8(val)\n",
-    "    back_to_float = q8_8_to_float(q8_8)\n",
-    "    error = abs(back_to_float - val)\n",
-    "    \n",
-    "    print(f\"{val:6.2f} -> {q8_8:04X} -> {back_to_float:6.2f} (error: {error:.6f})\")\n",
-    "\n",
-    "# Show precision characteristics\n",
-    "print(\"\\n📊 Q8.8 Precision Characteristics:\")\n",
-    "print(f\"  Range: [-128.0, +127.996]\")\n",
-    "print(f\"  Resolution: 1/256 ≈ 0.0039\")\n",
-    "print(f\"  Dynamic range: ~128/0.0039 ≈ 32768:1\")\n",
-    "print(f\"  Quantization step: 0.00390625\")\n",
-    "\n",
-    "# Visualize quantization error\n",
-    "fine_values = np.linspace(-2, 2, 1000)\n",
-    "quantized = [q8_8_to_float(float_to_q8_8(val)) for val in fine_values]\n",
-    "quantization_error = np.array(quantized) - fine_values\n",
-    "\n",
-    "plt.figure(figsize=(12, 4))\n",
-    "\n",
-    "plt.subplot(1, 2, 1)\n",
-    "plt.plot(fine_values, quantized, 'b-', alpha=0.7, label='Quantized')\n",
-    "plt.plot(fine_values, fine_values, 'r--', alpha=0.5, label='Original')\n",
-    "plt.xlabel('Input Value')\n",
-    "plt.ylabel('Output Value')\n",
-    "plt.title('Q8.8 Quantization Characteristic')\n",
-    "plt.legend()\n",
-    "plt.grid(True, alpha=0.3)\n",
-    "\n",
-    "plt.subplot(1, 2, 2)\n",
-    "plt.plot(fine_values, quantization_error, 'g-', alpha=0.7)\n",
-    "plt.xlabel('Input Value')\n",
-    "plt.ylabel('Quantization Error')\n",
-    "plt.title('Q8.8 Quantization Error')\n",
-    "plt.grid(True, alpha=0.3)\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Loading FPGA Parameters"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "from pathlib import Path\n",
-    "\n",
-    "# Check if parameter files exist\n",
-    "parameter_files = {\n",
-    "    'thresholds': 'parameters/parameters.mem',\n",
-    "    'weights': 'parameters/parameters_weights.mem',\n",
-    "    'decay': 'parameters/parameters_decay.mem'\n",
-    "}\n",
-    "\n",
-    "print(\"📂 Checking Parameter Files:\")\n",
-    "for name, filepath in parameter_files.items():\n",
-    "    if os.path.exists(filepath):\n",
-    "        print(f\"  ✅ {name}: {filepath}\")\n",
-    "    else:\n",
-    "        print(f\"  ❌ {name}: {filepath} (not found)\")\n",
-    "\n",
-    "# Load and display parameters if files exist\n",
-    "def load_mem_file(filepath, max_lines=10):\n",
-    "    \"\"\"Load parameters from .mem file\"\"\"\n",
-    "    if not os.path.exists(filepath):\n",
-    "        return None\n",
-    "    \n",
-    "    parameters = []\n",
-    "    with open(filepath, 'r') as f:\n",
-    "        for line_num, line in enumerate(f):\n",
-    "            if line_num >= max_lines:\n",
-    "                break\n",
-    "            line = line.strip()\n",
-    "            if line:\n",
-    "                # Convert hex to integer, then to float\n",
-    "                hex_val = int(line, 16)\n",
-    "                float_val = q8_8_to_float(hex_val)\n",
-    "                parameters.append(float_val)\n",
-    "    \n",
-    "    return parameters\n",
-    "\n",
-    "# Load and display sample parameters\n",
-    "print(\"\\n🔍 Sample Parameters:\")\n",
-    "for name, filepath in parameter_files.items():\n",
-    "    params = load_mem_file(filepath, max_lines=5)\n",
-    "    if params:\n",
-    "        print(f\"\\n{name.upper()} (first 5 values):\")\n",
-    "        for i, val in enumerate(params):\n",
-    "            print(f\"  [{i}]: {val:.6f}\")\n",
-    "    else:\n",
-    "        print(f\"\\n{name.upper()}: File not found\")\n",
-    "\n",
-    "# Create sample parameters if files don't exist\n",
-    "if not all(os.path.exists(f) for f in parameter_files.values()):\n",
-    "    print(\"\\n🔧 Creating sample parameter files...\")\n",
-    "    \n",
-    "    os.makedirs('parameters', exist_ok=True)\n",
-    "    \n",
-    "    # Sample thresholds (16 neurons)\n",
-    "    with open('parameters/parameters.mem', 'w') as f:\n",
-    "        for i in range(16):\n",
-    "            threshold = 0.5 + i * 0.1  # 0.5 to 2.0\n",
-    "            q8_8 = float_to_q8_8(threshold)\n",
-    "            f.write(f\"{q8_8:04X}\\n\")\n",
-    "    \n",
-    "    # Sample weights (16x8 matrix)\n",
-    "    with open('parameters/parameters_weights.mem', 'w') as f:\n",
-    "        for i in range(16):\n",
-    "            for j in range(8):\n",
-    "                weight = np.random.randn() * 0.2  # Small random weights\n",
-    "                q8_8 = float_to_q8_8(weight)\n",
-    "                f.write(f\"{q8_8:04X}\\n\")\n",
-    "    \n",
-    "    # Sample decay constants (16 neurons)\n",
-    "    with open('parameters/parameters_decay.mem', 'w') as f:\n",
-    "        for i in range(16):\n",
-    "            decay = 0.8 + i * 0.01  # 0.8 to 0.95\n",
-    "            q8_8 = float_to_q8_8(decay)\n",
-    "            f.write(f\"{q8_8:04X}\\n\")\n",
-    "    \n",
-    "    print(\"✅ Sample parameter files created in 'parameters/' directory\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Verilog Implementation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Generate Verilog code for SNN implementation\n",
-    "verilog_code = '''\n",
-    "// Spikenaut SNN v2 - FPGA Implementation\n",
-    "// Xilinx Artix-7 Basys3 Target\n",
-    "// 16-neuron spiking neural network with Q8.8 fixed-point arithmetic\n",
-    "\n",
-    "module spikenaut_snn_v2 (\n",
-    "    // Clock and reset\n",
-    "    input wire clk,\n",
-    "    input wire rst_n,\n",
-    "    \n",
-    "    // Input interface (8 features)\n",
-    "    input wire [15:0] input_feature_0,\n",
-    "    input wire [15:0] input_feature_1,\n",
-    "    input wire [15:0] input_feature_2,\n",
-    "    input wire [15:0] input_feature_3,\n",
-    "    input wire [15:0] input_feature_4,\n",
-    "    input wire [15:0] input_feature_5,\n",
-    "    input wire [15:0] input_feature_6,\n",
-    "    input wire [15:0] input_feature_7,\n",
-    "    \n",
-    "    // Control signals\n",
-    "    input wire start_computation,\n",
-    "    output reg computation_done,\n",
-    "    \n",
-    "    // Output interface (3 classes)\n",
-    "    output reg [15:0] output_class_0,\n",
-    "    output reg [15:0] output_class_1,\n",
-    "    output reg [15:0] output_class_2,\n",
-    "    \n",
-    "    // Debug signals\n",
-    "    output reg [3:0] active_neuron,\n",
-    "    output reg [15:0] membrane_potential\n",
-    ");\n",
-    "\n",
-    "// Parameters\n",
-    "parameter NEURONS = 16;\n",
-    "parameter INPUTS = 8;\n",
-    "parameter OUTPUTS = 3;\n",
-    "parameter FIXED_POINT_SHIFT = 8;\n",
-    "\n",
-    "// Memory arrays for parameters\n",
-    "reg [15:0] neuron_thresholds [0:NEURONS-1];\n",
-    "reg [15:0] synaptic_weights [0:NEURONS-1] [0:INPUTS-1];\n",
-    "reg [15:0] decay_constants [0:NEURONS-1];\n",
-    "\n",
-    "// Internal state\n",
-    "reg [15:0] membrane_potentials [0:NEURONS-1];\n",
-    "reg spike_outputs [0:NEURONS-1];\n",
-    "reg [31:0] weighted_sum;\n",
-    "reg [3:0] neuron_index;\n",
-    "reg [2:0] input_index;\n",
-    "reg [1:0] state;\n",
-    "\n",
-    "// States\n",
-    "localparam IDLE = 2'b00;\n",
-    "localparam COMPUTE = 2'b01;\n",
-    "localparam OUTPUT = 2'b10;\n",
-    "\n",
-    "// Input feature array\n",
-    "wire [15:0] input_features [0:INPUTS-1];\n",
-    "assign input_features[0] = input_feature_0;\n",
-    "assign input_features[1] = input_feature_1;\n",
-    "assign input_features[2] = input_feature_2;\n",
-    "assign input_features[3] = input_feature_3;\n",
-    "assign input_features[4] = input_feature_4;\n",
-    "assign input_features[5] = input_feature_5;\n",
-    "assign input_features[6] = input_feature_6;\n",
-    "assign input_features[7] = input_feature_7;\n",
-    "\n",
-    "// Main state machine\n",
-    "always @(posedge clk or negedge rst_n) begin\n",
-    "    if (!rst_n) begin\n",
-    "        // Reset state\n",
-    "        state <= IDLE;\n",
-    "        computation_done <= 0;\n",
-    "        neuron_index <= 0;\n",
-    "        input_index <= 0;\n",
-    "        \n",
-    "        // Clear membrane potentials\n",
-    "        for (integer i = 0; i < NEURONS; i = i + 1) begin\n",
-    "            membrane_potentials[i] <= 16'h0000;\n",
-    "            spike_outputs[i] <= 0;\n",
-    "        end\n",
-    "        \n",
-    "        // Clear outputs\n",
-    "        output_class_0 <= 16'h0000;\n",
-    "        output_class_1 <= 16'h0000;\n",
-    "        output_class_2 <= 16'h0000;\n",
-    "        active_neuron <= 4'h0;\n",
-    "        membrane_potential <= 16'h0000;\n",
-    "    \n",
-    "    end else begin\n",
-    "        case (state)\n",
-    "            IDLE: begin\n",
-    "                computation_done <= 0;\n",
-    "                if (start_computation) begin\n",
-    "                    state <= COMPUTE;\n",
-    "                    neuron_index <= 0;\n",
-    "                    input_index <= 0;\n",
-    "                end\n",
-    "            end\n",
-    "            \n",
-    "            COMPUTE: begin\n",
-    "                // Compute weighted sum for current neuron\n",
-    "                if (input_index < INPUTS) begin\n",
-    "                    // Multiply-accumulate (Q8.8 fixed-point)\n",
-    "                    weighted_sum <= weighted_sum + \n",
-    "                        ($signed(input_features[input_index]) * $signed(synaptic_weights[neuron_index][input_index]));\n",
-    "                    input_index <= input_index + 1;\n",
-    "                end else begin\n",
-    "                    // Update membrane potential with decay\n",
-    "                    membrane_potentials[neuron_index] <= \n",
-    "                        ($signed(membrane_potentials[neuron_index] * decay_constants[neuron_index]) >>> FIXED_POINT_SHIFT) + \n",
-    "                        ($signed(weighted_sum) >>> FIXED_POINT_SHIFT);\n",
-    "                    \n",
-    "                    // Generate spike\n",
-    "                    if ($signed(membrane_potentials[neuron_index]) >= $signed(neuron_thresholds[neuron_index])) begin\n",
-    "                        spike_outputs[neuron_index] <= 1;\n",
-    "                        membrane_potentials[neuron_index] <= 16'h0000; // Reset\n",
-    "                    end else begin\n",
-    "                        spike_outputs[neuron_index] <= 0;\n",
-    "                    end\n",
-    "                    \n",
-    "                    // Move to next neuron\n",
-    "                    if (neuron_index < NEURONS - 1) begin\n",
-    "                        neuron_index <= neuron_index + 1;\n",
-    "                        input_index <= 0;\n",
-    "                        weighted_sum <= 32'h00000000;\n",
-    "                    end else begin\n",
-    "                        state <= OUTPUT;\n",
-    "                    end\n",
-    "                end\n",
-    "            end\n",
-    "            \n",
-    "            OUTPUT: begin\n",
-    "                // Compute output classes (simple weighted sum of spikes)\n",
-    "                // Class 0: Neurons 0-5 (Kaspa)\n",
-    "                // Class 1: Neurons 6-10 (Monero)\n",
-    "                // Class 2: Neurons 11-15 (Other)\n",
-    "                \n",
-    "                output_class_0 <= spike_outputs[0] + spike_outputs[1] + spike_outputs[2] + \n",
-    "                                 spike_outputs[3] + spike_outputs[4] + spike_outputs[5];\n",
-    "                output_class_1 <= spike_outputs[6] + spike_outputs[7] + spike_outputs[8] + \n",
-    "                                 spike_outputs[9] + spike_outputs[10];\n",
-    "                output_class_2 <= spike_outputs[11] + spike_outputs[12] + spike_outputs[13] + \n",
-    "                                 spike_outputs[14] + spike_outputs[15];\n",
-    "                \n",
-    "                // Update debug signals\n",
-    "                active_neuron <= neuron_index;\n",
-    "                membrane_potential <= membrane_potentials[neuron_index];\n",
-    "                \n",
-    "                state <= IDLE;\n",
-    "                computation_done <= 1;\n",
-    "            end\n",
-    "        endcase\n",
-    "    end\n",
-    "end\n",
-    "\n",
-    "// Initialize parameters from memory files (in simulation)\n",
-    "initial begin\n",
-    "    // Load thresholds\n",
-    "    $readmemh(\"parameters/parameters.mem\", neuron_thresholds);\n",
-    "    // Load weights\n",
-    "    $readmemh(\"parameters/parameters_weights.mem\", synaptic_weights);\n",
-    "    // Load decay constants\n",
-    "    $readmemh(\"parameters/parameters_decay.mem\", decay_constants);\n",
-    "end\n",
-    "\n",
-    "endmodule\n",
-    "'''\n",
-    "\n",
-    "# Save Verilog code\n",
-    "with open('spikenaut_snn_v2.v', 'w') as f:\n",
-    "    f.write(verilog_code)\n",
-    "\n",
-    "print(\"✅ Verilog module generated: spikenaut_snn_v2.v\")\n",
-    "print(\"\\n📝 Key Features:\")\n",
-    "print(\"  • 16 neurons, 8 inputs, 3 outputs\")\n",
-    "print(\"  • Q8.8 fixed-point arithmetic\")\n",
-    "print(\"  • Parallel weighted sum computation\")\n",
-    "print(\"  • Configurable thresholds and decay\")\n",
-    "print(\"  • Debug signals for monitoring\")\n",
-    "print(\"  • Memory initialization from .mem files\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Testbench for Verification"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Generate testbench for FPGA verification\n",
-    "testbench_code = '''\n",
-    "// Testbench for Spikenaut SNN v2\n",
-    "// Verifies correct operation of the FPGA implementation\n",
-    "\n",
-    "`timescale 1ns / 1ps\n",
-    "\n",
-    "module spikenaut_snn_v2_tb;\n",
-    "\n",
-    "// Test signals\n",
-    "reg clk;\n",
-    "reg rst_n;\n",
-    "reg [15:0] input_features [0:7];\n",
-    "reg start_computation;\n",
-    "wire computation_done;\n",
-    "wire [15:0] output_classes [0:2];\n",
-    "wire [3:0] active_neuron;\n",
-    "wire [15:0] membrane_potential;\n",
-    "\n",
-    "// Device Under Test\n",
-    "spikenaut_snn_v2 dut (\n",
-    "    .clk(clk),\n",
-    "    .rst_n(rst_n),\n",
-    "    .input_feature_0(input_features[0]),\n",
-    "    .input_feature_1(input_features[1]),\n",
-    "    .input_feature_2(input_features[2]),\n",
-    "    .input_feature_3(input_features[3]),\n",
-    "    .input_feature_4(input_features[4]),\n",
-    "    .input_feature_5(input_features[5]),\n",
-    "    .input_feature_6(input_features[6]),\n",
-    "    .input_feature_7(input_features[7]),\n",
-    "    .start_computation(start_computation),\n",
-    "    .computation_done(computation_done),\n",
-    "    .output_class_0(output_classes[0]),\n",
-    "    .output_class_1(output_classes[1]),\n",
-    "    .output_class_2(output_classes[2]),\n",
-    "    .active_neuron(active_neuron),\n",
-    "    .membrane_potential(membrane_potential)\n",
-    ");\n",
-    "\n",
-    "// Clock generation (1kHz)\n",
-    "initial begin\n",
-    "    clk = 0;\n",
-    "    forever #500000 clk = ~clk; // 1ms period\n",
-    "end\n",
-    "\n",
-    "// Test stimulus\n",
-    "initial begin\n",
-    "    // Initialize inputs\n",
-    "    rst_n = 0;\n",
-    "    start_computation = 0;\n",
-    "    for (integer i = 0; i < 8; i = i + 1) begin\n",
-    "        input_features[i] = 16'h0000;\n",
-    "    end\n",
-    "    \n",
-    "    // Release reset\n",
-    "    #1000000; // 1ms\n",
-    "    rst_n = 1;\n",
-    "    #1000000; // 1ms\n",
-    "    \n",
-    "    // Test Case 1: Kaspa telemetry\n",
-    "    $display(\"Test Case 1: Kaspa telemetry\");\n",
-    "    input_features[0] = 16'h0066; // hashrate_spike = 1 (0.4 in Q8.8)\n",
-    "    input_features[1] = 16'h0000; // power_spike = 0\n",
-    "    input_features[2] = 16'h0000; // temp_spike = 0\n",
-    "    input_features[3] = 16'h00CC; // qubic_spike = 1 (0.8 in Q8.8)\n",
-    "    input_features[4] = 16'h0066; // hashrate_normalized = 0.4\n",
-    "    input_features[5] = 16'h0000; // power_efficiency = 0\n",
-    "    input_features[6] = 16'h0000; // thermal_efficiency = 0\n",
-    "    input_features[7] = 16'h00CC; // composite_reward = 0.8\n",
-    "    \n",
-    "    start_computation = 1;\n",
-    "    #2000000; // 2ms\n",
-    "    start_computation = 0;\n",
-    "    \n",
-    "    // Wait for completion\n",
-    "    wait(computation_done);\n",
-    "    #1000000; // 1ms\n",
-    "    \n",
-    "    $display(\"Results:\");\n",
-    "    $display(\"  Class 0 (Kaspa): %d\", output_classes[0]);\n",
-    "    $display(\"  Class 1 (Monero): %d\", output_classes[1]);\n",
-    "    $display(\"  Class 2 (Other): %d\", output_classes[2]);\n",
-    "    \n",
-    "    // Test Case 2: Monero telemetry\n",
-    "    $display(\"Test Case 2: Monero telemetry\");\n",
-    "    input_features[0] = 16'h0000; // hashrate_spike = 0\n",
-    "    input_features[1] = 16'h00CC; // power_spike = 1 (0.8 in Q8.8)\n",
-    "    input_features[2] = 16'h0066; // temp_spike = 1 (0.4 in Q8.8)\n",
-    "    input_features[3] = 16'h0000; // qubic_spike = 0\n",
-    "    input_features[4] = 16'h0033; // hashrate_normalized = 0.2\n",
-    "    input_features[5] = 16'h0066; // power_efficiency = 0.4\n",
-    "    input_features[6] = 16'h0033; // thermal_efficiency = 0.2\n",
-    "    input_features[7] = 16'h0066; // composite_reward = 0.4\n",
-    "    \n",
-    "    start_computation = 1;\n",
-    "    #2000000; // 2ms\n",
-    "    start_computation = 0;\n",
-    "    \n",
-    "    // Wait for completion\n",
-    "    wait(computation_done);\n",
-    "    #1000000; // 1ms\n",
-    "    \n",
-    "    $display(\"Results:\");\n",
-    "    $display(\"  Class 0 (Kaspa): %d\", output_classes[0]);\n",
-    "    $display(\"  Class 1 (Monero): %d\", output_classes[1]);\n",
-    "    $display(\"  Class 2 (Other): %d\", output_classes[2]);\n",
-    "    \n",
-    "    // Test Case 3: No activity\n",
-    "    $display(\"Test Case 3: No activity\");\n",
-    "    for (integer i = 0; i < 8; i = i + 1) begin\n",
-    "        input_features[i] = 16'h0000;\n",
-    "    end\n",
-    "    \n",
-    "    start_computation = 1;\n",
-    "    #2000000; // 2ms\n",
-    "    start_computation = 0;\n",
-    "    \n",
-    "    // Wait for completion\n",
-    "    wait(computation_done);\n",
-    "    #1000000; // 1ms\n",
-    "    \n",
-    "    $display(\"Results:\");\n",
-    "    $display(\"  Class 0 (Kaspa): %d\", output_classes[0]);\n",
-    "    $display(\"  Class 1 (Monero): %d\", output_classes[1]);\n",
-    "    $display(\"  Class 2 (Other): %d\", output_classes[2]);\n",
-    "    \n",
-    "    // Finish simulation\n",
-    "    $display(\"All tests completed\");\n",
-    "    $finish;\n",
-    "end\n",
-    "\n",
-    "// Monitor changes\n",
-    "initial begin\n",
-    "    $monitor(\"Time: %0t | State: %s | Active Neuron: %d | Membrane: %d\",\n",
-    "             $time, dut.state, active_neuron, membrane_potential);\n",
-    "end\n",
-    "\n",
-    "endmodule\n",
-    "'''\n",
-    "\n",
-    "# Save testbench\n",
-    "with open('spikenaut_snn_v2_tb.v', 'w') as f:\n",
-    "    f.write(testbench_code)\n",
-    "\n",
-    "print(\"✅ Testbench generated: spikenaut_snn_v2_tb.v\")\n",
-    "print(\"\\n🧪 Test Cases:\")\n",
-    "print(\"  1. Kaspa telemetry (should activate Class 0)\")\n",
-    "print(\"  2. Monero telemetry (should activate Class 1)\")\n",
-    "print(\"  3. No activity (baseline test)\")\n",
-    "print(\"\\n⚡ Simulation Commands:\")\n",
-    "print(\"  vlog spikenaut_snn_v2.v spikenaut_snn_v2_tb.v\")\n",
-    "print(\"  vsim -t ps spikenaut_snn_v2_tb\")\n",
-    "print(\"  run -all\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Performance Analysis"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Performance estimation\n",
-    "performance_metrics = {\n",
-    "    'clock_frequency': '1 kHz',\n",
-    "    'computation_cycles': 16 * 8 + 16,  # 16 neurons * 8 inputs + overhead\n",
-    "    'latency_ms': (16 * 8 + 16) / 1000,  # At 1kHz clock\n",
-    "    'throughput_samples_per_second': 1000 / ((16 * 8 + 16) / 1000),\n",
-    "    'power_consumption_mw': 97,\n",
-    "    'energy_per_inference_uj': 97 / 1000,  # μJ per inference\n",
-    "    'logic_utilization_percent': 15,  # Estimated\n",
-    "    'bram_utilization_percent': 5,  # Estimated\n",
-    "    'dsp_utilization_percent': 10  # Estimated\n",
-    "}\n",
-    "\n",
-    "print(\"⚡ Performance Analysis:\")\n",
-    "for metric, value in performance_metrics.items():\n",
-    "    print(f\"  {metric}: {value}\")\n",
-    "\n",
-    "# Compare with software implementation\n",
-    "software_comparison = {\n",
-    "    'CPU (Python)': {'latency_ms': 50, 'power_mw': 15000},\n",
-    "    'GPU (CUDA)': {'latency_ms': 5, 'power_mw': 250000},\n",
-    "    'FPGA (Spikenaut)': {'latency_ms': performance_metrics['latency_ms'], 'power_mw': performance_metrics['power_consumption_mw']}\n",
-    "}\n",
-    "\n",
-    "print(\"\\n🔄 Performance Comparison:\")\n",
-    "for platform, metrics in software_comparison.items():\n",
-    "    print(f\"  {platform}:\")\n",
-    "    print(f\"    Latency: {metrics['latency_ms']} ms\")\n",
-    "    print(f\"    Power: {metrics['power_mw']} mW\")\n",
-    "    print(f\"    Energy: {metrics['latency_ms'] * metrics['power_mw'] / 1000:.2f} μJ\")\n",
-    "\n",
-    "# Calculate speedup and efficiency\n",
-    "fpga_energy = performance_metrics['latency_ms'] * performance_metrics['power_consumption_mw'] / 1000\n",
-    "cpu_energy = software_comparison['CPU (Python)']['latency_ms'] * software_comparison['CPU (Python)']['power_mw'] / 1000\n",
-    "gpu_energy = software_comparison['GPU (CUDA)']['latency_ms'] * software_comparison['GPU (CUDA)']['power_mw'] / 1000\n",
-    "\n",
-    "print(f\"\\n🚀 Efficiency Improvements:\")\n",
-    "print(f\"  FPGA vs CPU: {cpu_energy / fpga_energy:.1f}x more energy efficient\")\n",
-    "print(f\"  FPGA vs GPU: {gpu_energy / fpga_energy:.1f}x more energy efficient\")\n",
-    "print(f\"  Latency improvement vs CPU: {software_comparison['CPU (Python)']['latency_ms'] / performance_metrics['latency_ms']:.1f}x\")\n",
-    "print(f\"  Latency improvement vs GPU: {software_comparison['GPU (CUDA)']['latency_ms'] / performance_metrics['latency_ms']:.1f}x\")\n",
-    "\n",
-    "# Visualize performance comparison\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "platforms = list(software_comparison.keys())\n",
-    "latencies = [software_comparison[p]['latency_ms'] for p in platforms]\n",
-    "powers = [software_comparison[p]['power_mw'] for p in platforms]\n",
-    "energies = [l * p / 1000 for l, p in zip(latencies, powers)]\n",
-    "\n",
-    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 4))\n",
-    "\n",
-    "# Latency comparison\n",
-    "ax1.bar(platforms, latencies, color=['blue', 'red', 'green'])\n",
-    "ax1.set_ylabel('Latency (ms)')\n",
-    "ax1.set_title('Latency Comparison')\n",
-    "ax1.set_yscale('log')\n",
-    "\n",
-    "# Power comparison\n",
-    "ax2.bar(platforms, powers, color=['blue', 'red', 'green'])\n",
-    "ax2.set_ylabel('Power (mW)')\n",
-    "ax2.set_title('Power Comparison')\n",
-    "ax2.set_yscale('log')\n",
-    "\n",
-    "# Energy comparison\n",
-    "ax3.bar(platforms, energies, color=['blue', 'red', 'green'])\n",
-    "ax3.set_ylabel('Energy per Inference (μJ)')\n",
-    "ax3.set_title('Energy Comparison')\n",
-    "ax3.set_yscale('log')\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Deployment Checklist"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Deployment checklist\n",
-    "deployment_checklist = {\n",
-    "    'Hardware': [\n",
-    "        '✅ Basys3 FPGA board connected',\n",
-    "        '✅ USB-JTAG programmer configured',\n",
-    "        '✅ Power supply stable',\n",
-    "        '✅ Clock source verified'\n",
-    "    ],\n",
-    "    'Software': [\n",
-    "        '✅ Vivado installed and licensed',\n",
-    "        '✅ Verilog testbench passing',\n",
-    "        '✅ Synthesis completed without errors',\n",
-    "        '✅ Implementation successful'\n",
-    "    ],\n",
-    "    'Parameters': [\n",
-    "        '✅ Q8.8 conversion verified',\n",
-    "        '✅ Parameter files generated',\n",
-    "        '✅ Memory initialization tested',\n",
-    "        '✅ Weight loading confirmed'\n",
-    "    ],\n",
-    "    'Verification': [\n",
-    "        '✅ Simulation results match expectations',\n",
-    "        '✅ Timing constraints met',\n",
-    "        '✅ Power analysis within budget',\n",
-    "        '✅ Resource utilization acceptable'\n",
-    "    ],\n",
-    "    'Integration': [\n",
-    "        '✅ UART interface configured',\n",
-    "        '✅ GPIO connections verified',\n",
-    "        '✅ Real-time telemetry input tested',\n",
-    "        '✅ Output format validated'\n",
-    "    ]\n",
-    "}\n",
-    "\n",
-    "print(\"🚀 FPGA Deployment Checklist:\")\n",
-    "for category, items in deployment_checklist.items():\n",
-    "    print(f\"\\n{category}:\")\n",
-    "    for item in items:\n",
-    "        print(f\"  {item}\")\n",
-    "\n",
-    "# Generate deployment script\n",
-    "deployment_script = '''#!/bin/bash\n",
-    "# Spikenaut SNN v2 FPGA Deployment Script\n",
-    "\n",
-    "echo \"🦁 Spikenaut SNN v2 - FPGA Deployment\"\n",
-    "echo \"=========================================\"\n",
-    "\n",
-    "# Check prerequisites\n",
-    "echo \"📋 Checking prerequisites...\"\n",
-    "if ! command -v vivado &> /dev/null; then\n",
-    "    echo \"❌ Vivado not found. Please install Xilinx Vivado.\"\n",
-    "    exit 1\n",
-    "fi\n",
-    "echo \"✅ Vivado found\"\n",
-    "\n",
-    "# Check parameter files\n",
-    "echo \"📂 Checking parameter files...\"\n",
-    "for file in parameters/parameters.mem parameters/parameters_weights.mem parameters/parameters_decay.mem; do\n",
-    "    if [ ! -f \"$file\" ]; then\n",
-    "        echo \"❌ Missing file: $file\"\n",
-    "        exit 1\n",
-    "    fi\n",
-    "done\n",
-    "echo \"✅ All parameter files found\"\n",
-    "\n",
-    "# Run synthesis\n",
-    "echo \"🔨 Running synthesis...\"\n",
-    "vivado -mode batch -source synthesis_script.tcl\n",
-    "if [ $? -ne 0 ]; then\n",
-    "    echo \"❌ Synthesis failed\"\n",
-    "    exit 1\n",
-    "fi\n",
-    "echo \"✅ Synthesis completed\"\n",
-    "\n",
-    "# Run implementation\n",
-    "echo \"🏗️ Running implementation...\"\n",
-    "vivado -mode batch -source implementation_script.tcl\n",
-    "if [ $? -ne 0 ]; then\n",
-    "    echo \"❌ Implementation failed\"\n",
-    "    exit 1\n",
-    "fi\n",
-    "echo \"✅ Implementation completed\"\n",
-    "\n",
-    "# Generate bitstream\n",
-    "echo \"💾 Generating bitstream...\"\n",
-    "vivado -mode batch -source bitstream_script.tcl\n",
-    "if [ $? -ne 0 ]; then\n",
-    "    echo \"❌ Bitstream generation failed\"\n",
-    "    exit 1\n",
-    "fi\n",
-    "echo \"✅ Bitstream generated\"\n",
-    "\n",
-    "# Program FPGA\n",
-    "echo \"🔌 Programming FPGA...\"\n",
-    "vivado -mode batch -source program_script.tcl\n",
-    "if [ $? -ne 0 ]; then\n",
-    "    echo \"❌ FPGA programming failed\"\n",
-    "    exit 1\n",
-    "fi\n",
-    "echo \"✅ FPGA programmed successfully\"\n",
-    "\n",
-    "echo \"🎉 Deployment completed successfully!\"\n",
-    "echo \"🦁 Spikenaut SNN v2 is running on FPGA!\"\n",
-    "'''\n",
-    "\n",
-    "# Save deployment script\n",
-    "with open('deploy_fpga.sh', 'w') as f:\n",
-    "    f.write(deployment_script)\n",
-    "\n",
-    "print(f\"\\n📜 Deployment script generated: deploy_fpga.sh\")\n",
-    "print(f\"\\n🔧 Usage:\")\n",
-    "print(f\"  chmod +x deploy_fpga.sh\")\n",
-    "print(f\"  ./deploy_fpga.sh\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. Troubleshooting Guide"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Common issues and solutions\n",
-    "troubleshooting_guide = {\n",
-    "    'Synthesis Errors': {\n",
-    "        'Problem': 'Verilog synthesis fails',\n",
-    "        'Solutions': [\n",
-    "            'Check for syntax errors in Verilog code',\n",
-    "            'Verify all signals are properly declared',\n",
-    "            'Ensure memory initialization syntax is correct',\n",
-    "            'Check clock domain crossing issues'\n",
-    "        ]\n",
-    "    },\n",
-    "    'Timing Violations': {\n",
-    "        'Problem': 'Timing constraints not met',\n",
-    "        'Solutions': [\n",
-    "            'Reduce clock frequency',\n",
-    "            'Add pipeline stages',\n",
-    "            'Optimize critical paths',\n",
-    "            'Use DSP slices for multiplication'\n",
-    "        ]\n",
-    "    },\n",
-    "    'Memory Issues': {\n",
-    "        'Problem': 'Parameter loading fails',\n",
-    "        'Solutions': [\n",
-    "            'Verify .mem file format (hex values)',\n",
-    "            'Check file paths in $readmemh',\n",
-    "            'Ensure memory dimensions match',\n",
-    "            'Test with known good values'\n",
-    "        ]\n",
-    "    },\n",
-    "    'Incorrect Results': {\n",
-    "        'Problem': 'FPGA output differs from simulation',\n",
-    "        'Solutions': [\n",
-    "            'Check Q8.8 precision handling',\n",
-    "            'Verify signed arithmetic',\n",
-    "            'Test with known input patterns',\n",
-    "            'Compare intermediate values'\n",
-    "        ]\n",
-    "    },\n",
-    "    'Power Issues': {\n",
-    "        'Problem': 'Power consumption too high',\n",
-    "        'Solutions': [\n",
-    "            'Reduce clock frequency',\n",
-    "            'Optimize logic utilization',\n",
-    "            'Use clock gating',\n",
-    "            'Enable power saving modes'\n",
-    "        ]\n",
-    "    }\n",
-    "}\n",
-    "\n",
-    "print(\"🔧 Troubleshooting Guide:\")\n",
-    "for issue, details in troubleshooting_guide.items():\n",
-    "    print(f\"\\n{issue}:\")\n",
-    "    print(f\"  Problem: {details['Problem']}\")\n",
-    "    print(f\"  Solutions:\")\n",
-    "    for solution in details['Solutions']:\n",
-    "        print(f\"    • {solution}\")\n",
-    "\n",
-    "# Debug commands\n",
-    "debug_commands = '''\n",
-    "# Vivado debug commands\n",
-    "# Open implemented design\n",
-    "open_project spikenaut_snn_v2.xpr\n",
-    "open_run impl_1\n",
-    "\n",
-    "# Check timing\n",
-    "report_timing_summary\n",
-    "report_timing -delay_type max -max_paths 10\n",
-    "\n",
-    "# Check utilization\n",
-    "report_utilization\n",
-    "report_utilization -hierarchical\n",
-    "\n",
-    "# Check power\n",
-    "report_power\n",
-    "\n",
-    "# Debug signals (add to constraints)\n",
-    "# In XDC file:\n",
-    "# set_property DEBUG_TRUE [get_nets neuron_*]\n",
-    "# set_property DEBUG_TRUE [get_nets membrane_*]\n",
-    "\n",
-    "# Simulation debug\n",
-    "# Add to testbench:\n",
-    "# $display(\"Neuron %d: membrane=%d, spike=%d\", i, membrane[i], spike[i]);\n",
-    "# $strobe(\"Time=%0t, State=%s\", $time, state);\n",
-    "'''\n",
-    "\n",
-    "print(f\"\\n💻 Debug Commands:\")\n",
-    "print(debug_commands)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 9. Summary and Next Steps"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(\"🔧 Spikenaut SNN v2 FPGA Deployment Guide Complete!\")\n",
-    "print(\"=\" * 60)\n",
-    "print()\n",
-    "print(\"🎯 What You've Accomplished:\")\n",
-    "print(\"  ✅ Understood Q8.8 fixed-point format\")\n",
-    "print(\"  ✅ Generated Verilog implementation\")\n",
-    "print(\"  ✅ Created comprehensive testbench\")\n",
-    "print(\"  ✅ Analyzed performance characteristics\")\n",
-    "print(\"  ✅ Prepared deployment checklist\")\n",
-    "print(\"  ✅ Generated troubleshooting guide\")\n",
-    "print()\n",
-    "print(\"📁 Generated Files:\")\n",
-    "files_generated = [\n",
-    "    'spikenaut_snn_v2.v - Main Verilog module',\n",
-    "    'spikenaut_snn_v2_tb.v - Testbench',\n",
-    "    'deploy_fpga.sh - Deployment script',\n",
-    "    'parameters/ - FPGA parameter files'\n",
-    "]\n",
-    "for file in files_generated:\n",
-    "    print(f\"  📄 {file}\")\n",
-    "print()\n",
-    "print(\"⚡ Key Performance Metrics:\")\n",
-    "print(f\"  • Latency: {performance_metrics['latency_ms']:.1f} ms\")\n",
-    "print(f\"  • Power: {performance_metrics['power_consumption_mw']} mW\")\n",
-    "print(f\"  • Energy: {fpga_energy:.2f} μJ per inference\")\n",
-    "print(f\"  • Efficiency: {cpu_energy / fpga_energy:.1f}x vs CPU\")\n",
-    "print()\n",
-    "print(\"🚀 Next Steps:\")\n",
-    "next_steps = [\n",
-    "    \"1. Run synthesis and implementation in Vivado\",\n",
-    "    \"2. Verify timing constraints are met\",\n",
-    "    \"3. Program Basys3 FPGA with generated bitstream\",\n",
-    "    \"4. Test with real telemetry data\",\n",
-    "    \"5. Integrate with Rust telemetry system\",\n",
-    "    \"6. Optimize for lower power consumption\",\n",
-    "    \"7. Scale to larger neural networks\"\n",
-    "]\n",
-    "for step in next_steps:\n",
-    "    print(f\"  {step}\")\n",
-    "print()\n",
-    "print(\"🔗 Related Resources:\")\n",
-    "resources = [\n",
-    "    \"• Dataset: https://huggingface.co/datasets/rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters\",\n",
-    "    \"• Main repo: https://github.com/rmems/Eagle-Lander\",\n",
-    "    \"• Basys3 documentation: https://reference.digilentinc.com/learn/programmable-logic/tutorials/basys-3-getting-started-with-xilinx-fpga-design-tools\",\n",
-    "    \"• Vivado documentation: https://docs.xilinx.com/v/u/en-US/ug953-vivado-tutorial\"\n",
-    "]\n",
-    "for resource in resources:\n",
-    "    print(f\"  {resource}\")\n",
-    "print()\n",
-    "print(\"🦁 Happy FPGA deployment!\")\n",
-    "print(\"Your Spikenaut SNN v2 is ready for neuromorphic computing on hardware!\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

dataset/spikenaut_snn_v2_complete_enhanced/examples/snn_training_demo.ipynb

@@ -1,871 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 🧠 Spikenaut SNN v2 - Training Demo\n",
-    "\n",
-    "Complete training pipeline for Spiking Neural Networks using the Spikenaut dataset.\n",
-    "\n",
-    "## What you'll learn:\n",
-    "- Setting up SNN architecture\n",
-    "- Training with spike-encoded data\n",
-    "- E-prop learning implementation\n",
-    "- Performance evaluation\n",
-    "- Model export for FPGA"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Setup and Dependencies"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install required packages\n",
-    "!pip install torch torchvision datasets numpy matplotlib seaborn tqdm -q\n",
-    "\n",
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
-    "from torch.utils.data import DataLoader, TensorDataset\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "from datasets import load_dataset\n",
-    "from tqdm import tqdm\n",
-    "import json\n",
-    "import time\n",
-    "from datetime import datetime\n",
-    "\n",
-    "print(f\"PyTorch version: {torch.__version__}\")\n",
-    "print(f\"CUDA available: {torch.cuda.is_available()}\")\n",
-    "if torch.cuda.is_available():\n",
-    "    print(f\"CUDA device: {torch.cuda.get_device_name()}\")\n",
-    "\n",
-    "# Set device\n",
-    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-    "print(f\"Using device: {device}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Load and Prepare Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load the Spikenaut dataset\n",
-    "print(\"🦁 Loading Spikenaut SNN v2 dataset...\")\n",
-    "ds = load_dataset(\"rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters\")\n",
-    "\n",
-    "# Extract spike-encoded features\n",
-    "def extract_spikes(dataset_split):\n",
-    "    \"\"\"Extract spike features from dataset\"\"\"\n",
-    "    spike_cols = [\n",
-    "        'spike_hashrate', 'spike_power', 'spike_temp', 'spike_qubic',\n",
-    "        'hashrate_normalized', 'power_efficiency', 'thermal_efficiency',\n",
-    "        'composite_reward'\n",
-    "    ]\n",
-    "    \n",
-    "    # Filter available columns\n",
-    "    available_cols = [col for col in spike_cols if col in dataset_split.column_names]\n",
-    "    print(f\"Available spike columns: {available_cols}\")\n",
-    "    \n",
-    "    # Convert to tensors\n",
-    "    data = []\n",
-    "    labels = []\n",
-    "    \n",
-    "    for i in range(len(dataset_split)):\n",
-    "        sample = dataset_split[i]\n",
-    "        \n",
-    "        # Create feature vector\n",
-    "        features = []\n",
-    "        for col in available_cols:\n",
-    "            if 'spike_' in col:\n",
-    "                features.append(float(sample[col]))  # Binary spikes\n",
-    "            else:\n",
-    "                features.append(float(sample[col]))  # Continuous features\n",
-    "        \n",
-    "        # Create label (blockchain type)\n",
-    "        blockchain = sample['blockchain']\n",
-    "        if blockchain == 'kaspa':\n",
-    "            label = 0\n",
-    "        elif blockchain == 'monero':\n",
-    "            label = 1\n",
-    "        else:\n",
-    "            label = 2\n",
-    "        \n",
-    "        data.append(features)\n",
-    "        labels.append(label)\n",
-    "    \n",
-    "    return torch.tensor(data, dtype=torch.float32), torch.tensor(labels, dtype=torch.long)\n",
-    "\n",
-    "# Prepare training data\n",
-    "X_train, y_train = extract_spikes(ds['train'])\n",
-    "X_val, y_val = extract_spikes(ds['validation'])\n",
-    "X_test, y_test = extract_spikes(ds['test'])\n",
-    "\n",
-    "print(f\"📊 Data shapes:\")\n",
-    "print(f\"  Train: {X_train.shape}, Labels: {y_train.shape}\")\n",
-    "print(f\"  Val: {X_val.shape}, Labels: {y_val.shape}\")\n",
-    "print(f\"  Test: {X_test.shape}, Labels: {y_test.shape}\")\n",
-    "\n",
-    "# Create DataLoaders\n",
-    "batch_size = 2  # Small batch due to small dataset\n",
-    "\n",
-    "train_dataset = TensorDataset(X_train, y_train)\n",
-    "val_dataset = TensorDataset(X_val, y_val)\n",
-    "test_dataset = TensorDataset(X_test, y_test)\n",
-    "\n",
-    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
-    "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
-    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
-    "\n",
-    "print(f\"🔄 DataLoaders created with batch size {batch_size}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. SNN Architecture"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LIFNeuron(nn.Module):\n",
-    "    \"\"\"Leaky Integrate-and-Fire Neuron\"\"\"\n",
-    "    \n",
-    "    def __init__(self, input_size, hidden_size, threshold=1.0, decay=0.9):\n",
-    "        super(LIFNeuron, self).__init__()\n",
-    "        self.input_size = input_size\n",
-    "        self.hidden_size = hidden_size\n",
-    "        self.threshold = threshold\n",
-    "        self.decay = decay\n",
-    "        \n",
-    "        # Weight matrix\n",
-    "        self.weight = nn.Parameter(torch.randn(input_size, hidden_size) * 0.1)\n",
-    "        \n",
-    "        # Membrane potential\n",
-    "        self.register_buffer('membrane', torch.zeros(1, hidden_size))\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        batch_size = x.size(0)\n",
-    "        \n",
-    "        # Initialize membrane potential for new batch\n",
-    "        if self.membrane.size(0) != batch_size:\n",
-    "            self.membrane = torch.zeros(batch_size, self.hidden_size, device=x.device)\n",
-    "        \n",
-    "        # Input current\n",
-    "        current = torch.matmul(x, self.weight)\n",
-    "        \n",
-    "        # Update membrane potential\n",
-    "        self.membrane = self.membrane * self.decay + current\n",
-    "        \n",
-    "        # Generate spikes\n",
-    "        spikes = (self.membrane > self.threshold).float()\n",
-    "        \n",
-    "        # Reset membrane potential after spike\n",
-    "        self.membrane = self.membrane * (1 - spikes)\n",
-    "        \n",
-    "        return spikes, self.membrane\n",
-    "\n",
-    "class SpikenautSNN(nn.Module):\n",
-    "    \"\"\"Spikenaut SNN v2 Architecture\"\"\"\n",
-    "    \n",
-    "    def __init__(self, input_size, hidden_size, num_classes, time_steps=10):\n",
-    "        super(SpikenautSNN, self).__init__()\n",
-    "        self.input_size = input_size\n",
-    "        self.hidden_size = hidden_size\n",
-    "        self.num_classes = num_classes\n",
-    "        self.time_steps = time_steps\n",
-    "        \n",
-    "        # Layers\n",
-    "        self.hidden_layer = LIFNeuron(input_size, hidden_size, threshold=0.5, decay=0.9)\n",
-    "        self.output_layer = nn.Linear(hidden_size, num_classes)\n",
-    "        \n",
-    "        # For E-prop learning\n",
-    "        self.register_buffer('eligibility_trace', torch.zeros(hidden_size, input_size))\n",
-    "        \n",
-    "    def forward(self, x):\n",
-    "        batch_size = x.size(0)\n",
-    "        \n",
-    "        # Store outputs for each time step\n",
-    "        spike_outputs = []\n",
-    "        membrane_outputs = []\n",
-    "        \n",
-    "        # Repeat input for time steps (simulation of temporal processing)\n",
-    "        for t in range(self.time_steps):\n",
-    "            # Add small noise to simulate temporal variation\n",
-    "            x_t = x + torch.randn_like(x) * 0.01\n",
-    "            \n",
-    "            # Forward through hidden layer\n",
-    "            hidden_spikes, hidden_membrane = self.hidden_layer(x_t)\n",
-    "            \n",
-    "            # Output layer (readout)\n",
-    "            output = self.output_layer(hidden_spikes)\n",
-    "            \n",
-    "            spike_outputs.append(output)\n",
-    "            membrane_outputs.append(hidden_membrane)\n",
-    "        \n",
-    "        # Average over time steps\n",
-    "        final_output = torch.mean(torch.stack(spike_outputs), dim=0)\n",
-    "        \n",
-    "        return final_output, torch.stack(membrane_outputs)\n",
-    "    \n",
-    "    def reset_state(self):\n",
-    "        \"\"\"Reset membrane potentials and traces\"\"\"\n",
-    "        self.hidden_layer.membrane.zero_()\n",
-    "        self.eligibility_trace.zero_()\n",
-    "\n",
-    "# Initialize SNN\n",
-    "input_size = X_train.shape[1]\n",
-    "hidden_size = 16  # Matching Spikenaut architecture\n",
-    "num_classes = 3   # kaspa, monero, other\n",
-    "time_steps = 10\n",
-    "\n",
-    "snn = SpikenautSNN(input_size, hidden_size, num_classes, time_steps).to(device)\n",
-    "\n",
-    "print(f\"🧠 SNN Architecture:\")\n",
-    "print(f\"  Input size: {input_size}\")\n",
-    "print(f\"  Hidden neurons: {hidden_size}\")\n",
-    "print(f\"  Output classes: {num_classes}\")\n",
-    "print(f\"  Time steps: {time_steps}\")\n",
-    "print(f\"  Total parameters: {sum(p.numel() for p in snn.parameters())}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. E-prop Learning Implementation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class EPropLoss(nn.Module):\n",
-    "    \"\"\"E-prop loss function with surrogate gradients\"\"\"\n",
-    "    \n",
-    "    def __init__(self, surrogate='fast_sigmoid'):\n",
-    "        super(EPropLoss, self).__init__()\n",
-    "        self.surrogate = surrogate\n",
-    "        \n",
-    "    def fast_sigmoid(self, x):\n",
-    "        \"\"\"Fast sigmoid surrogate gradient\"\"\"\n",
-    "        return 1.0 / (1.0 + torch.abs(x))\n",
-    "    \n",
-    "    def forward(self, output, target, membrane_potentials):\n",
-    "        \"\"\"Compute E-prop loss\"\"\"\n",
-    "        # Standard cross-entropy loss\n",
-    "        ce_loss = F.cross_entropy(output, target)\n",
-    "        \n",
-    "        # Add regularization term for spike activity\n",
-    "        spike_activity = torch.mean(membrane_potentials ** 2)\n",
-    "        regularization = 0.01 * spike_activity\n",
-    "        \n",
-    "        total_loss = ce_loss + regularization\n",
-    "        \n",
-    "        return total_loss, ce_loss, regularization\n",
-    "\n",
-    "class EPropOptimizer:\n",
-    "    \"\"\"Custom optimizer for E-prop learning\"\"\"\n",
-    "    \n",
-    "    def __init__(self, model, lr=0.001, beta=0.9):\n",
-    "        self.model = model\n",
-    "        self.lr = lr\n",
-    "        self.beta = beta\n",
-    "        \n",
-    "        # Initialize momentum\n",
-    "        self.momentum = {}\n",
-    "        for name, param in model.named_parameters():\n",
-    "            self.momentum[name] = torch.zeros_like(param)\n",
-    "    \n",
-    "    def step(self, loss):\n",
-    "        \"\"\"Perform E-prop optimization step\"\"\"\n",
-    "        # Backward pass\n",
-    "        loss.backward()\n",
-    "        \n",
-    "        # Update parameters with momentum\n",
-    "        for name, param in self.model.named_parameters():\n",
-    "            if param.grad is not None:\n",
-    "                # Update momentum\n",
-    "                self.momentum[name] = self.beta * self.momentum[name] + (1 - self.beta) * param.grad\n",
-    "                \n",
-    "                # Update parameters\n",
-    "                param.data = param.data - self.lr * self.momentum[name]\n",
-    "                \n",
-    "                # Clip gradients\n",
-    "                param.grad.data.clamp_(-1.0, 1.0)\n",
-    "        \n",
-    "        # Clear gradients\n",
-    "        self.model.zero_grad()\n",
-    "    \n",
-    "    def zero_grad(self):\n",
-    "        \"\"\"Zero gradients\"\"\"\n",
-    "        self.model.zero_grad()\n",
-    "\n",
-    "# Initialize loss and optimizer\n",
-    "criterion = EPropLoss()\n",
-    "optimizer = EPropOptimizer(snn, lr=0.01, beta=0.9)\n",
-    "\n",
-    "print(\"🔬 E-prop learning components initialized\")\n",
-    "print(f\"  Loss function: E-prop with fast sigmoid surrogate\")\n",
-    "print(f\"  Optimizer: Custom E-prop with momentum (lr=0.01, beta=0.9)\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Training Loop"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def train_epoch(model, train_loader, criterion, optimizer, device):\n",
-    "    \"\"\"Train for one epoch\"\"\"\n",
-    "    model.train()\n",
-    "    total_loss = 0\n",
-    "    total_ce_loss = 0\n",
-    "    total_reg_loss = 0\n",
-    "    correct = 0\n",
-    "    total = 0\n",
-    "    \n",
-    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
-    "        data, target = data.to(device), target.to(device)\n",
-    "        \n",
-    "        # Reset SNN state\n",
-    "        model.reset_state()\n",
-    "        \n",
-    "        # Forward pass\n",
-    "        output, membrane_potentials = model(data)\n",
-    "        \n",
-    "        # Compute loss\n",
-    "        loss, ce_loss, reg_loss = criterion(output, target, membrane_potentials)\n",
-    "        \n",
-    "        # Backward pass\n",
-    "        optimizer.step(loss)\n",
-    "        \n",
-    "        # Statistics\n",
-    "        total_loss += loss.item()\n",
-    "        total_ce_loss += ce_loss.item()\n",
-    "        total_reg_loss += reg_loss.item()\n",
-    "        \n",
-    "        # Accuracy\n",
-    "        pred = output.argmax(dim=1)\n",
-    "        correct += pred.eq(target).sum().item()\n",
-    "        total += target.size(0)\n",
-    "    \n",
-    "    avg_loss = total_loss / len(train_loader)\n",
-    "    avg_ce_loss = total_ce_loss / len(train_loader)\n",
-    "    avg_reg_loss = total_reg_loss / len(train_loader)\n",
-    "    accuracy = 100. * correct / total\n",
-    "    \n",
-    "    return avg_loss, avg_ce_loss, avg_reg_loss, accuracy\n",
-    "\n",
-    "def validate(model, val_loader, criterion, device):\n",
-    "    \"\"\"Validate the model\"\"\"\n",
-    "    model.eval()\n",
-    "    total_loss = 0\n",
-    "    correct = 0\n",
-    "    total = 0\n",
-    "    \n",
-    "    with torch.no_grad():\n",
-    "        for data, target in val_loader:\n",
-    "            data, target = data.to(device), target.to(device)\n",
-    "            \n",
-    "            # Reset SNN state\n",
-    "            model.reset_state()\n",
-    "            \n",
-    "            # Forward pass\n",
-    "            output, membrane_potentials = model(data)\n",
-    "            \n",
-    "            # Compute loss\n",
-    "            loss, ce_loss, reg_loss = criterion(output, target, membrane_potentials)\n",
-    "            \n",
-    "            total_loss += loss.item()\n",
-    "            \n",
-    "            # Accuracy\n",
-    "            pred = output.argmax(dim=1)\n",
-    "            correct += pred.eq(target).sum().item()\n",
-    "            total += target.size(0)\n",
-    "    \n",
-    "    avg_loss = total_loss / len(val_loader)\n",
-    "    accuracy = 100. * correct / total\n",
-    "    \n",
-    "    return avg_loss, accuracy\n",
-    "\n",
-    "print(\"🏃 Training functions defined\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Run Training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Training configuration\n",
-    "num_epochs = 50\n",
-    "print(f\"🚀 Starting training for {num_epochs} epochs...\")\n",
-    "print(f\"📊 Training samples: {len(train_loader.dataset)}\")\n",
-    "print(f\"📊 Validation samples: {len(val_loader.dataset)}\")\n",
-    "print()\n",
-    "\n",
-    "# Training history\n",
-    "train_losses = []\n",
-    "train_accuracies = []\n",
-    "val_losses = []\n",
-    "val_accuracies = []\n",
-    "\n",
-    "best_val_acc = 0\n",
-    "best_model_state = None\n",
-    "\n",
-    "start_time = time.time()\n",
-    "\n",
-    "for epoch in range(num_epochs):\n",
-    "    # Train\n",
-    "    train_loss, train_ce_loss, train_reg_loss, train_acc = train_epoch(\n",
-    "        snn, train_loader, criterion, optimizer, device\n",
-    "    )\n",
-    "    \n",
-    "    # Validate\n",
-    "    val_loss, val_acc = validate(snn, val_loader, criterion, device)\n",
-    "    \n",
-    "    # Record history\n",
-    "    train_losses.append(train_loss)\n",
-    "    train_accuracies.append(train_acc)\n",
-    "    val_losses.append(val_loss)\n",
-    "    val_accuracies.append(val_acc)\n",
-    "    \n",
-    "    # Save best model\n",
-    "    if val_acc > best_val_acc:\n",
-    "        best_val_acc = val_acc\n",
-    "        best_model_state = snn.state_dict().copy()\n",
-    "    \n",
-    "    # Print progress\n",
-    "    if epoch % 10 == 0 or epoch == num_epochs - 1:\n",
-    "        print(f\"Epoch {epoch:3d}/{num_epochs:3d} | \"\n",
-    "              f\"Train Loss: {train_loss:.4f} (CE: {train_ce_loss:.4f}, Reg: {train_reg_loss:.4f}) | \"\n",
-    "              f\"Train Acc: {train_acc:5.2f}% | \"\n",
-    "              f\"Val Loss: {val_loss:.4f} | \"\n",
-    "              f\"Val Acc: {val_acc:5.2f}% | \"\n",
-    "              f\"Best Val Acc: {best_val_acc:5.2f}%\")\n",
-    "\n",
-    "training_time = time.time() - start_time\n",
-    "print(f\"\\n✅ Training completed in {training_time:.2f} seconds\")\n",
-    "print(f\"🏆 Best validation accuracy: {best_val_acc:.2f}%\")\n",
-    "\n",
-    "# Load best model\n",
-    "snn.load_state_dict(best_model_state)\n",
-    "print(\"📦 Best model loaded\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Training Visualization"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create training visualization\n",
-    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\n",
-    "\n",
-    "# Loss curves\n",
-    "ax1.plot(train_losses, label='Train Loss', color='blue', alpha=0.8)\n",
-    "ax1.plot(val_losses, label='Validation Loss', color='red', alpha=0.8)\n",
-    "ax1.set_xlabel('Epoch')\n",
-    "ax1.set_ylabel('Loss')\n",
-    "ax1.set_title('🦁 Spikenaut SNN v2 - Training Loss')\n",
-    "ax1.legend()\n",
-    "ax1.grid(True, alpha=0.3)\n",
-    "\n",
-    "# Accuracy curves\n",
-    "ax2.plot(train_accuracies, label='Train Accuracy', color='blue', alpha=0.8)\n",
-    "ax2.plot(val_accuracies, label='Validation Accuracy', color='red', alpha=0.8)\n",
-    "ax2.set_xlabel('Epoch')\n",
-    "ax2.set_ylabel('Accuracy (%)')\n",
-    "ax2.set_title('🦁 Spikenaut SNN v2 - Training Accuracy')\n",
-    "ax2.legend()\n",
-    "ax2.grid(True, alpha=0.3)\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "\n",
-    "# Print final statistics\n",
-    "print(f\"📈 Final Training Statistics:\")\n",
-    "print(f\"  Final train loss: {train_losses[-1]:.4f}\")\n",
-    "print(f\"  Final train accuracy: {train_accuracies[-1]:.2f}%\")\n",
-    "print(f\"  Final validation loss: {val_losses[-1]:.4f}\")\n",
-    "print(f\"  Final validation accuracy: {val_accuracies[-1]:.2f}%\")\n",
-    "print(f\"  Best validation accuracy: {best_val_acc:.2f}%\")\n",
-    "print(f\"  Training time: {training_time:.2f} seconds\")\n",
-    "print(f\"  Samples per second: {len(train_loader.dataset) * num_epochs / training_time:.1f}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. Model Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Test the model\n",
-    "print(\"🧪 Testing the trained SNN...\")\n",
-    "\n",
-    "test_loss, test_acc = validate(snn, test_loader, criterion, device)\n",
-    "print(f\"Test Loss: {test_loss:.4f}\")\n",
-    "print(f\"Test Accuracy: {test_acc:.2f}%\")\n",
-    "\n",
-    "# Detailed evaluation\n",
-    "snn.eval()\n",
-    "all_predictions = []\n",
-    "all_targets = []\n",
-    "all_outputs = []\n",
-    "\n",
-    "with torch.no_grad():\n",
-    "    for data, target in test_loader:\n",
-    "        data, target = data.to(device), target.to(device)\n",
-    "        \n",
-    "        # Reset SNN state\n",
-    "        snn.reset_state()\n",
-    "        \n",
-    "        # Forward pass\n",
-    "        output, membrane_potentials = snn(data)\n",
-    "        \n",
-    "        # Store results\n",
-    "        pred = output.argmax(dim=1)\n",
-    "        all_predictions.extend(pred.cpu().numpy())\n",
-    "        all_targets.extend(target.cpu().numpy())\n",
-    "        all_outputs.extend(output.cpu().numpy())\n",
-    "\n",
-    "# Convert to numpy arrays\n",
-    "all_predictions = np.array(all_predictions)\n",
-    "all_targets = np.array(all_targets)\n",
-    "all_outputs = np.array(all_outputs)\n",
-    "\n",
-    "# Class names\n",
-    "class_names = ['kaspa', 'monero', 'other']\n",
-    "\n",
-    "# Print classification report\n",
-    "from sklearn.metrics import classification_report, confusion_matrix\n",
-    "print(\"\\n📊 Classification Report:\")\n",
-    "print(classification_report(all_targets, all_predictions, target_names=class_names))\n",
-    "\n",
-    "# Confusion matrix\n",
-    "cm = confusion_matrix(all_targets, all_predictions)\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n",
-    "            xticklabels=class_names, yticklabels=class_names)\n",
-    "plt.title('🦁 Spikenaut SNN v2 - Confusion Matrix')\n",
-    "plt.xlabel('Predicted')\n",
-    "plt.ylabel('Actual')\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 9. Model Export for FPGA"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def export_to_safetensors(model, filepath):\n",
-    "    \"\"\"Export model to safetensors format\"\"\"\n",
-    "    try:\n",
-    "        from safetensors.torch import save_file\n",
-    "        \n",
-    "        # Extract parameters\n",
-    "        state_dict = model.state_dict()\n",
-    "        \n",
-    "        # Save to safetensors\n",
-    "        save_file(state_dict, filepath)\n",
-    "        print(f\"✅ Model exported to {filepath}\")\n",
-    "        \n",
-    "    except ImportError:\n",
-    "        print(\"⚠️ safetensors not installed. Install with: pip install safetensors\")\n",
-    "        # Fallback to PyTorch format\n",
-    "        torch.save(model.state_dict(), filepath.replace('.safetensors', '.pth'))\n",
-    "        print(f\"✅ Model exported to {filepath.replace('.safetensors', '.pth')} (PyTorch format)\")\n",
-    "\n",
-    "def export_to_q8_8_format(model, filepath_prefix):\n",
-    "    \"\"\"Export model weights to Q8.8 format for FPGA\"\"\"\n",
-    "    \n",
-    "    def float_to_q8_8(value):\n",
-    "        \"\"\"Convert float to Q8.8 fixed-point\"\"\"\n",
-    "        # Clamp to Q8.8 range\n",
-    "        value = np.clip(value, -128, 127.996)\n",
-    "        # Convert to fixed-point\n",
-    "        q8_8 = int(value * 256)\n",
-    "        return q8_8\n",
-    "    \n",
-    "    # Extract weights\n",
-    "    hidden_weights = model.hidden_layer.weight.data.cpu().numpy()\n",
-    "    output_weights = model.output_layer.weight.data.cpu().numpy()\n",
-    "    \n",
-    "    # Convert to Q8.8\n",
-    "    hidden_weights_q8_8 = [[float_to_q8_8(w) for w in row] for row in hidden_weights]\n",
-    "    output_weights_q8_8 = [[float_to_q8_8(w) for w in row] for row in output_weights]\n",
-    "    \n",
-    "    # Write to .mem files\n",
-    "    with open(f\"{filepath_prefix}_hidden_weights.mem\", 'w') as f:\n",
-    "        for row in hidden_weights_q8_8:\n",
-    "            for weight in row:\n",
-    "                f.write(f\"{weight:04X}\\n\")\n",
-    "    \n",
-    "    with open(f\"{filepath_prefix}_output_weights.mem\", 'w') as f:\n",
-    "        for row in output_weights_q8_8:\n",
-    "            for weight in row:\n",
-    "                f.write(f\"{weight:04X}\\n\")\n",
-    "    \n",
-    "    # Thresholds and decay parameters\n",
-    "    with open(f\"{filepath_prefix}_parameters.mem\", 'w') as f:\n",
-    "        # Hidden layer threshold\n",
-    "        threshold_q8_8 = float_to_q8_8(model.hidden_layer.threshold)\n",
-    "        f.write(f\"{threshold_q8_8:04X}\\n\")\n",
-    "        \n",
-    "        # Hidden layer decay\n",
-    "        decay_q8_8 = float_to_q8_8(model.hidden_layer.decay)\n",
-    "        f.write(f\"{decay_q8_8:04X}\\n\")\n",
-    "        \n",
-    "        # Output layer parameters (if needed)\n",
-    "        for i in range(16):  # Pad to 16 parameters\n",
-    "            f.write(f\"0000\\n\")\n",
-    "    \n",
-    "    print(f\"✅ Weights exported to Q8.8 format:\")\n",
-    "    print(f\"  - {filepath_prefix}_hidden_weights.mem\")\n",
-    "    print(f\"  - {filepath_prefix}_output_weights.mem\")\n",
-    "    print(f\"  - {filepath_prefix}_parameters.mem\")\n",
-    "\n",
-    "# Export model\n",
-    "print(\"📤 Exporting trained model...\")\n",
-    "\n",
-    "# Export to safetensors\n",
-    "export_to_safetensors(snn, 'spikenaut_snn_v2.safetensors')\n",
-    "\n",
-    "# Export to Q8.8 for FPGA\n",
-    "export_to_q8_8_format(snn, 'spikenaut_snn_v2')\n",
-    "\n",
-    "# Save training metadata\n",
-    "metadata = {\n",
-    "    'model_architecture': 'SpikenautSNN',\n",
-    "    'input_size': input_size,\n",
-    "    'hidden_size': hidden_size,\n",
-    "    'num_classes': num_classes,\n",
-    "    'time_steps': time_steps,\n",
-    "    'training_accuracy': float(train_accuracies[-1]),\n",
-    "    'validation_accuracy': float(best_val_acc),\n",
-    "    'test_accuracy': float(test_acc),\n",
-    "    'training_time_seconds': training_time,\n",
-    "    'num_epochs': num_epochs,\n",
-    "    'dataset': 'Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters',\n",
-    "    'export_timestamp': datetime.now().isoformat()\n",
-    "}\n",
-    "\n",
-    "with open('spikenaut_snn_v2_metadata.json', 'w') as f:\n",
-    "    json.dump(metadata, f, indent=2)\n",
-    "\n",
-    "print(f\"✅ Training metadata saved to spikenaut_snn_v2_metadata.json\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 10. Inference Demo"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def predict_blockchain(sample_features, model, device):\n",
-    "    \"\"\"Predict blockchain type from telemetry features\"\"\"\n",
-    "    model.eval()\n",
-    "    \n",
-    "    with torch.no_grad():\n",
-    "        # Convert to tensor\n",
-    "        if isinstance(sample_features, (list, np.ndarray)):\n",
-    "            sample_tensor = torch.tensor(sample_features, dtype=torch.float32).unsqueeze(0)\n",
-    "        else:\n",
-    "            sample_tensor = sample_features.unsqueeze(0)\n",
-    "        \n",
-    "        sample_tensor = sample_tensor.to(device)\n",
-    "        \n",
-    "        # Reset SNN state\n",
-    "        model.reset_state()\n",
-    "        \n",
-    "        # Forward pass\n",
-    "        output, membrane_potentials = model(sample_tensor)\n",
-    "        \n",
-    "        # Get prediction\n",
-    "        probabilities = F.softmax(output, dim=1)\n",
-    "        predicted_class = torch.argmax(probabilities, dim=1).item()\n",
-    "        confidence = probabilities[0][predicted_class].item()\n",
-    "        \n",
-    "        return {\n",
-    "            'predicted_class': predicted_class,\n",
-    "            'predicted_blockchain': class_names[predicted_class],\n",
-    "            'confidence': confidence,\n",
-    "            'probabilities': {\n",
-    "                class_names[i]: prob.item() \n",
-    "                for i, prob in enumerate(probabilities[0])\n",
-    "            },\n",
-    "            'membrane_potentials': membrane_potentials[0].cpu().numpy()\n",
-    "        }\n",
-    "\n",
-    "# Test with sample data\n",
-    "print(\"🔮 Running inference demo...\")\n",
-    "\n",
-    "# Test with a few samples\n",
-    "for i in range(min(3, len(X_test))):\n",
-    "    sample_features = X_test[i]\n",
-    "    true_label = y_test[i].item()\n",
-    "    true_blockchain = class_names[true_label]\n",
-    "    \n",
-    "    result = predict_blockchain(sample_features, snn, device)\n",
-    "    \n",
-    "    print(f\"\\nSample {i+1}:\")\n",
-    "    print(f\"  True blockchain: {true_blockchain}\")\n",
-    "    print(f\"  Predicted: {result['predicted_blockchain']}\")\n",
-    "    print(f\"  Confidence: {result['confidence']:.3f}\")\n",
-    "    print(f\"  Probabilities: {result['probabilities']}\")\n",
-    "    print(f\"  Correct: {'✅' if result['predicted_class'] == true_label else '❌'}\")\n",
-    "\n",
-    "# Visualize membrane potentials\n",
-    "if len(result['membrane_potentials']) > 0:\n",
-    "    plt.figure(figsize=(10, 4))\n",
-    "    plt.plot(result['membrane_potentials'], marker='o', linestyle='-')\n",
-    "    plt.title('🧠 Membrane Potentials During Inference')\n",
-    "    plt.xlabel('Hidden Neuron Index')\n",
-    "    plt.ylabel('Membrane Potential')\n",
-    "    plt.grid(True, alpha=0.3)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 11. Summary and Next Steps"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(\"🦁 Spikenaut SNN v2 Training Demo Complete!\")\n",
-    "print(\"=\" * 50)\n",
-    "print()\n",
-    "print(\"🏆 Results Summary:\")\n",
-    "print(f\"  ✅ Trained {hidden_size}-neuron SNN for {num_epochs} epochs\")\n",
-    "print(f\"  ✅ Final test accuracy: {test_acc:.2f}%\")\n",
-    "print(f\"  ✅ Training time: {training_time:.2f} seconds\")\n",
-    "print(f\"  ✅ Model exported to multiple formats\")\n",
-    "print()\n",
-    "print(\"📁 Generated Files:\")\n",
-    "print(\"  📄 spikenaut_snn_v2.safetensors - PyTorch model\")\n",
-    "print(\"  📄 spikenaut_snn_v2_hidden_weights.mem - FPGA weights\")\n",
-    "print(\"  📄 spikenaut_snn_v2_output_weights.mem - FPGA weights\")\n",
-    "print(\"  📄 spikenaut_snn_v2_parameters.mem - FPGA parameters\")\n",
-    "print(\"  📄 spikenaut_snn_v2_metadata.json - Training metadata\")\n",
-    "print()\n",
-    "print(\"🔬 Key Insights:\")\n",
-    "print(f\"  • E-prop learning achieved {best_val_acc:.1f}% validation accuracy\")\n",
-    "print(f\"  • SNN processes {input_size} features through {hidden_size} hidden neurons\")\n",
-    "print(f\"  • Temporal processing over {time_steps} time steps\")\n",
-    "print(f\"  • Q8.8 format ready for FPGA deployment\")\n",
-    "print()\n",
-    "print(\"🚀 Next Steps:\")\n",
-    "print(\"  1. Deploy Q8.8 weights to Basys3 FPGA\")\n",
-    "print(\"  2. Test with real-time telemetry data\")\n",
-    "print(\"  3. Implement online learning/adaptation\")\n",
-    "print(\"  4. Scale to larger datasets\")\n",
-    "print(\"  5. Integrate with Julia-Rust hybrid pipeline\")\n",
-    "print()\n",
-    "print(\"📚 Related Resources:\")\n",
-    "print(\"  • Dataset: https://huggingface.co/datasets/rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters\")\n",
-    "print(\"  • FPGA deployment: See parameters/ folder\")\n",
-    "print(\"  • Main repository: https://github.com/rmems/Eagle-Lander\")\n",
-    "print()\n",
-    "print(\"🦁 Happy neuromorphic computing!\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

dataset/spikenaut_snn_v2_complete_enhanced/examples/spike_encoding_demo.ipynb

@@ -1,679 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 🦁 Spikenaut SNN v2 - Spike Encoding Demo\n",
-    "\n",
-    "This notebook demonstrates how to load the Spikenaut SNN v2 dataset and create spike encodings for neuromorphic computing.\n",
-    "\n",
-    "## What you'll learn:\n",
-    "- Loading the Hugging Face dataset\n",
-    "- Understanding the data structure\n",
-    "- Creating custom spike encodings\n",
-    "- Visualizing spike trains\n",
-    "- Preparing data for SNN training"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Setup and Imports"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install required packages\n",
-    "!pip install datasets numpy matplotlib seaborn scipy -q\n",
-    "\n",
-    "import json\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "from datasets import load_dataset\n",
-    "from datetime import datetime\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "\n",
-    "# Set style for better plots\n",
-    "plt.style.use('seaborn-v0_8')\n",
-    "sns.set_palette(\"husl\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Load the Dataset"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load the Spikenaut SNN v2 dataset\n",
-    "print(\"🦁 Loading Spikenaut SNN v2 dataset...\")\n",
-    "ds = load_dataset(\"rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters\")\n",
-    "\n",
-    "# Examine the dataset structure\n",
-    "print(f\"Dataset splits: {list(ds.keys())}\")\n",
-    "print(f\"Training samples: {len(ds['train'])}\")\n",
-    "print(f\"Validation samples: {len(ds['validation'])}\")\n",
-    "print(f\"Test samples: {len(ds['test'])}\")\n",
-    "\n",
-    "# Show available features\n",
-    "print(f\"\\nFeatures: {list(ds['train'].features.keys())}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Explore the Data Structure"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Get a sample from the training set\n",
-    "sample = ds['train'][0]\n",
-    "print(\"Sample data structure:\")\n",
-    "print(json.dumps(sample, indent=2, default=str))\n",
-    "\n",
-    "# Extract telemetry data\n",
-    "telemetry = sample['telemetry']\n",
-    "print(f\"\\n📊 Telemetry Summary:\")\n",
-    "print(f\"  Hashrate: {telemetry['hashrate_mh']} MH/s\")\n",
-    "print(f\"  Power: {telemetry['power_w']} W\")\n",
-    "print(f\"  Temperature: {telemetry['gpu_temp_c']} °C\")\n",
-    "print(f\"  Qubic Trace: {telemetry['qubic_tick_trace']}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Basic Data Analysis"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Convert to pandas for easier analysis\n",
-    "train_df = ds['train'].to_pandas()\n",
-    "\n",
-    "# Extract telemetry into separate columns\n",
-    "telemetry_df = pd.json_normalize(train_df['telemetry'])\n",
-    "full_df = pd.concat([train_df.drop('telemetry', axis=1), telemetry_df], axis=1)\n",
-    "\n",
-    "print(\"📈 Dataset Statistics:\")\n",
-    "print(full_df.describe())\n",
-    "\n",
-    "# Show blockchain distribution\n",
-    "print(f\"\\n🔗 Blockchain distribution:\")\n",
-    "print(full_df['blockchain'].value_counts())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Visualize Telemetry Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create subplots for telemetry visualization\n",
-    "fig, axes = plt.subplots(2, 3, figsize=(15, 10))\n",
-    "fig.suptitle('🦁 Spikenaut SNN v2 - Telemetry Data Overview', fontsize=16)\n",
-    "\n",
-    "# Hashrate distribution\n",
-    "axes[0, 0].hist(full_df['hashrate_mh'], bins=20, alpha=0.7, color='blue')\n",
-    "axes[0, 0].set_title('Hashrate Distribution (MH/s)')\n",
-    "axes[0, 0].set_xlabel('Hashrate (MH/s)')\n",
-    "axes[0, 0].set_ylabel('Frequency')\n",
-    "\n",
-    "# Power consumption\n",
-    "axes[0, 1].hist(full_df['power_w'], bins=20, alpha=0.7, color='red')\n",
-    "axes[0, 1].set_title('Power Consumption (W)')\n",
-    "axes[0, 1].set_xlabel('Power (W)')\n",
-    "axes[0, 1].set_ylabel('Frequency')\n",
-    "\n",
-    "# GPU temperature\n",
-    "axes[0, 2].hist(full_df['gpu_temp_c'], bins=20, alpha=0.7, color='orange')\n",
-    "axes[0, 2].set_title('GPU Temperature (°C)')\n",
-    "axes[0, 2].set_xlabel('Temperature (°C)')\n",
-    "axes[0, 2].set_ylabel('Frequency')\n",
-    "\n",
-    "# Qubic trace\n",
-    "axes[1, 0].hist(full_df['qubic_tick_trace'], bins=20, alpha=0.7, color='green')\n",
-    "axes[1, 0].set_title('Qubic Tick Trace')\n",
-    "axes[1, 0].set_xlabel('Qubic Trace')\n",
-    "axes[1, 0].set_ylabel('Frequency')\n",
-    "\n",
-    "# Blockchain types\n",
-    "blockchain_counts = full_df['blockchain'].value_counts()\n",
-    "axes[1, 1].pie(blockchain_counts.values, labels=blockchain_counts.index, autopct='%1.1f%%')\n",
-    "axes[1, 1].set_title('Blockchain Distribution')\n",
-    "\n",
-    "# Time series (if timestamps available)\n",
-    "if 'timestamp' in full_df.columns:\n",
-    "    timestamps = pd.to_datetime(full_df['timestamp'])\n",
-    "    axes[1, 2].plot(timestamps, full_df['hashrate_mh'], marker='o', linestyle='-', alpha=0.7)\n",
-    "    axes[1, 2].set_title('Hashrate Over Time')\n",
-    "    axes[1, 2].set_xlabel('Time')\n",
-    "    axes[1, 2].set_ylabel('Hashrate (MH/s)')\n",
-    "    axes[1, 2].tick_params(axis='x', rotation=45)\n",
-    "else:\n",
-    "    axes[1, 2].text(0.5, 0.5, 'Time series data\\nnot available', ha='center', va='center', transform=axes[1, 2].transAxes)\n",
-    "    axes[1, 2].set_title('Hashrate Over Time')\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Custom Spike Encoding"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class SpikenautSpikeEncoder:\n",
-    "    \"\"\"Custom spike encoder for Spikenaut SNN v2 telemetry data\"\"\"\n",
-    "    \n",
-    "    def __init__(self):\n",
-    "        # Adaptive thresholds based on data statistics\n",
-    "        self.thresholds = {\n",
-    "            'hashrate': 0.9,  # MH/s\n",
-    "            'power': 390,     # Watts\n",
-    "            'temp': 43,       # Celsius\n",
-    "            'qubic': 0.95     # Normalized\n",
-    "        }\n",
-    "        \n",
-    "        # Channel mapping for 16-neuron architecture\n",
-    "        self.channels = [\n",
-    "            'kaspa_hashrate', 'kaspa_power', 'kaspa_temp', 'kaspa_qubic',\n",
-    "            'monero_hashrate', 'monero_power', 'monero_temp', 'monero_qubic',\n",
-    "            'qubic_hashrate', 'qubic_power', 'qubic_temp', 'qubic_qubic',\n",
-    "            'thermal_stress', 'power_efficiency', 'network_health', 'composite_reward'\n",
-    "        ]\n",
-    "    \n",
-    "    def encode_telemetry(self, telemetry, blockchain):\n",
-    "        \"\"\"Encode telemetry data into 16-channel spike vector\"\"\"\n",
-    "        spikes = np.zeros(16)\n",
-    "        \n",
-    "        # Basic telemetry spikes\n",
-    "        spikes[0] = 1 if telemetry['hashrate_mh'] > self.thresholds['hashrate'] else 0\n",
-    "        spikes[1] = 1 if telemetry['power_w'] > self.thresholds['power'] else 0\n",
-    "        spikes[2] = 1 if telemetry['gpu_temp_c'] > self.thresholds['temp'] else 0\n",
-    "        spikes[3] = 1 if telemetry['qubic_tick_trace'] > self.thresholds['qubic'] else 0\n",
-    "        \n",
-    "        # Blockchain-specific mapping\n",
-    "        if blockchain == 'kaspa':\n",
-    "            spikes[0:4] = [spikes[0], spikes[1], spikes[2], spikes[3]]\n",
-    "        elif blockchain == 'monero':\n",
-    "            spikes[4:8] = [spikes[0], spikes[1], spikes[2], spikes[3]]\n",
-    "        elif blockchain == 'qubic':\n",
-    "            spikes[8:12] = [spikes[0], spikes[1], spikes[2], spikes[3]]\n",
-    "        \n",
-    "        # Derived spikes\n",
-    "        thermal_stress = max(0, (telemetry['gpu_temp_c'] - 40) / 6)\n",
-    "        spikes[12] = 1 if thermal_stress > 0.5 else 0\n",
-    "        \n",
-    "        power_efficiency = telemetry['hashrate_mh'] / (telemetry['power_w'] / 1000)\n",
-    "        spikes[13] = 1 if power_efficiency > 2.5 else 0\n",
-    "        \n",
-    "        network_health = (telemetry['qubic_tick_trace'] + telemetry['qubic_epoch_progress']) / 2\n",
-    "        spikes[14] = 1 if network_health > 0.95 else 0\n",
-    "        \n",
-    "        composite_reward = telemetry['reward_hint']\n",
-    "        spikes[15] = 1 if composite_reward > 0.95 else 0\n",
-    "        \n",
-    "        return spikes\n",
-    "    \n",
-    "    def encode_dataset(self, dataset):\n",
-    "        \"\"\"Encode entire dataset\"\"\"\n",
-    "        spike_trains = []\n",
-    "        \n",
-    "        for i in range(len(dataset)):\n",
-    "            sample = dataset[i]\n",
-    "            spikes = self.encode_telemetry(sample['telemetry'], sample['blockchain'])\n",
-    "            \n",
-    "            spike_trains.append({\n",
-    "                'timestamp': sample.get('timestamp', f'sample_{i}'),\n",
-    "                'blockchain': sample['blockchain'],\n",
-    "                'spike_vector': spikes,\n",
-    "                'spike_count': int(np.sum(spikes))\n",
-    "            })\n",
-    "        \n",
-    "        return spike_trains\n",
-    "\n",
-    "# Initialize encoder\n",
-    "encoder = SpikenautSpikeEncoder()\n",
-    "print(\"🔸 Spike encoder initialized\")\n",
-    "print(f\"Channels: {encoder.channels}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Generate Spike Trains"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Generate spike trains for training data\n",
-    "print(\"🦁 Generating spike trains...\")\n",
-    "spike_trains = encoder.encode_dataset(ds['train'])\n",
-    "\n",
-    "# Convert to numpy for analysis\n",
-    "spike_matrix = np.array([train['spike_vector'] for train in spike_trains])\n",
-    "\n",
-    "print(f\"Generated {len(spike_trains)} spike trains\")\n",
-    "print(f\"Spike matrix shape: {spike_matrix.shape}\")\n",
-    "print(f\"Average spikes per sample: {spike_matrix.mean():.3f}\")\n",
-    "print(f\"Spike rate: {spike_matrix.mean() * 1000:.1f} Hz\")\n",
-    "\n",
-    "# Show first few spike trains\n",
-    "print(\"\\nFirst 5 spike trains:\")\n",
-    "for i, train in enumerate(spike_trains[:5]):\n",
-    "    active_channels = np.where(train['spike_vector'] == 1)[0]\n",
-    "    print(f\"  Sample {i}: {train['spike_count']} spikes -> channels {active_channels}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. Visualize Spike Trains"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create spike raster plot\n",
-    "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))\n",
-    "\n",
-    "# Raster plot\n",
-    "for i in range(spike_matrix.shape[1]):  # For each channel\n",
-    "    spike_times = np.where(spike_matrix[:, i] == 1)[0]\n",
-    "    ax1.scatter(spike_times, np.ones_like(spike_times) * i, \n",
-    "               s=20, alpha=0.8, label=encoder.channels[i] if i < 4 else \"\")\n",
-    "\n",
-    "ax1.set_xlabel('Time (samples)')\n",
-    "ax1.set_ylabel('Channel')\n",
-    "ax1.set_title('🦁 Spikenaut SNN v2 - Spike Raster Plot')\n",
-    "ax1.grid(True, alpha=0.3)\n",
-    "ax1.set_ylim(-0.5, 15.5)\n",
-    "\n",
-    "# Spike rate per channel\n",
-    "spike_rates = spike_matrix.mean(axis=0)\n",
-    "channel_labels = [f\"{i}: {name}\" for i, name in enumerate(encoder.channels)]\n",
-    "\n",
-    "bars = ax2.bar(range(16), spike_rates, alpha=0.7)\n",
-    "ax2.set_xlabel('Channel')\n",
-    "ax2.set_ylabel('Spike Rate')\n",
-    "ax2.set_title('Spike Rate per Channel')\n",
-    "ax2.set_xticks(range(16))\n",
-    "ax2.set_xticklabels([f\"{i}\" for i in range(16)], rotation=45)\n",
-    "ax2.grid(True, alpha=0.3)\n",
-    "\n",
-    "# Add channel labels on top of bars\n",
-    "for i, (bar, rate) in enumerate(zip(bars, spike_rates)):\n",
-    "    if rate > 0:\n",
-    "        ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, \n",
-    "                f'{rate:.2f}', ha='center', va='bottom', fontsize=8)\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 9. Correlation Analysis"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compute spike correlation matrix\n",
-    "correlation_matrix = np.corrcoef(spike_matrix.T)\n",
-    "\n",
-    "# Create heatmap\n",
-    "plt.figure(figsize=(10, 8))\n",
-    "sns.heatmap(correlation_matrix, \n",
-    "            xticklabels=encoder.channels,\n",
-    "            yticklabels=encoder.channels,\n",
-    "            annot=True, \n",
-    "            cmap='coolwarm', \n",
-    "            center=0,\n",
-    "            fmt='.2f')\n",
-    "plt.title('🦁 Spikenaut SNN v2 - Spike Correlation Matrix')\n",
-    "plt.xticks(rotation=45, ha='right')\n",
-    "plt.yticks(rotation=0)\n",
-    "plt.tight_layout()\n",
-    "plt.show()\n",
-    "\n",
-    "# Find most correlated channel pairs\n",
-    "correlation_pairs = []\n",
-    "for i in range(16):\n",
-    "    for j in range(i+1, 16):\n",
-    "        corr = correlation_matrix[i, j]\n",
-    "        if abs(corr) > 0.3:  # Only show significant correlations\n",
-    "            correlation_pairs.append({\n",
-    "                'channel1': encoder.channels[i],\n",
-    "                'channel2': encoder.channels[j],\n",
-    "                'correlation': corr\n",
-    "            })\n",
-    "\n",
-    "print(\"🔗 Significant channel correlations (|r| > 0.3):\")\n",
-    "for pair in sorted(correlation_pairs, key=lambda x: abs(x['correlation']), reverse=True):\n",
-    "    print(f\"  {pair['channel1']} ↔ {pair['channel2']}: r = {pair['correlation']:.3f}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 10. Prepare Data for SNN Training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class SNNTrainingData:\n",
-    "    \"\"\"Prepare data for Spiking Neural Network training\"\"\"\n",
-    "    \n",
-    "    def __init__(self, spike_trains, window_size=5):\n",
-    "        self.spike_trains = spike_trains\n",
-    "        self.window_size = window_size\n",
-    "        \n",
-    "    def create_sequences(self):\n",
-    "        \"\"\"Create sequences for time-series SNN training\"\"\"\n",
-    "        sequences = []\n",
-    "        targets = []\n",
-    "        \n",
-    "        spike_matrix = np.array([train['spike_vector'] for train in self.spike_trains])\n",
-    "        \n",
-    "        for i in range(len(spike_matrix) - self.window_size):\n",
-    "            # Input sequence\n",
-    "            sequence = spike_matrix[i:i + self.window_size]\n",
-    "            \n",
-    "            # Target (next timestep)\n",
-    "            target = spike_matrix[i + self.window_size]\n",
-    "            \n",
-    "            sequences.append(sequence)\n",
-    "            targets.append(target)\n",
-    "        \n",
-    "        return np.array(sequences), np.array(targets)\n",
-    "    \n",
-    "    def create_classification_dataset(self):\n",
-    "        \"\"\"Create dataset for classification tasks\"\"\"\n",
-    "        X = np.array([train['spike_vector'] for train in self.spike_trains])\n",
-    "        \n",
-    "        # Create labels based on blockchain type\n",
-    "        labels = []\n",
-    "        for train in self.spike_trains:\n",
-    "            if train['blockchain'] == 'kaspa':\n",
-    "                labels.append(0)\n",
-    "            elif train['blockchain'] == 'monero':\n",
-    "                labels.append(1)\n",
-    "            else:\n",
-    "                labels.append(2)\n",
-    "        \n",
-    "        return X, np.array(labels)\n",
-    "\n",
-    "# Prepare training data\n",
-    "snn_data = SNNTrainingData(spike_trains, window_size=3)\n",
-    "\n",
-    "# Create sequences for time-series prediction\n",
-    "X_seq, y_seq = snn_data.create_sequences()\n",
-    "print(f\"🔄 Sequential data:\")\n",
-    "print(f\"  Sequences shape: {X_seq.shape}\")\n",
-    "print(f\"  Targets shape: {y_seq.shape}\")\n",
-    "\n",
-    "# Create classification dataset\n",
-    "X_cls, y_cls = snn_data.create_classification_dataset()\n",
-    "print(f\"\\n🎯 Classification data:\")\n",
-    "print(f\"  Features shape: {X_cls.shape}\")\n",
-    "print(f\"  Labels shape: {y_cls.shape}\")\n",
-    "print(f\"  Class distribution: {np.bincount(y_cls)}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 11. Simple SNN Example"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class SimpleSNN:\n",
-    "    \"\"\"Simple Spiking Neural Network for demonstration\"\"\"\n",
-    "    \n",
-    "    def __init__(self, n_inputs=16, n_hidden=32, n_outputs=3):\n",
-    "        self.n_inputs = n_inputs\n",
-    "        self.n_hidden = n_hidden\n",
-    "        self.n_outputs = n_outputs\n",
-    "        \n",
-    "        # Initialize weights (small random values)\n",
-    "        self.W_in = np.random.randn(n_inputs, n_hidden) * 0.1\n",
-    "        self.W_out = np.random.randn(n_hidden, n_outputs) * 0.1\n",
-    "        \n",
-    "        # Neuron parameters\n",
-    "        self.threshold = 0.5\n",
-    "        self.decay = 0.9\n",
-    "        \n",
-    "    def forward(self, X):\n",
-    "        \"\"\"Forward pass through the SNN\"\"\"\n",
-    "        batch_size = X.shape[0]\n",
-    "        seq_len = X.shape[1] if len(X.shape) > 2 else 1\n",
-    "        \n",
-    "        # Reshape if needed\n",
-    "        if len(X.shape) == 2:\n",
-    "            X = X.reshape(batch_size, 1, -1)\n",
-    "            seq_len = 1\n",
-    "        \n",
-    "        # Initialize membrane potentials\n",
-    "        membrane_hidden = np.zeros((batch_size, self.n_hidden))\n",
-    "        membrane_out = np.zeros((batch_size, self.n_outputs))\n",
-    "        \n",
-    "        # Process sequence\n",
-    "        for t in range(seq_len):\n",
-    "            # Input to hidden\n",
-    "            hidden_input = np.dot(X[:, t, :], self.W_in)\n",
-    "            membrane_hidden = membrane_hidden * self.decay + hidden_input\n",
-    "            hidden_spikes = (membrane_hidden > self.threshold).astype(float)\n",
-    "            \n",
-    "            # Hidden to output\n",
-    "            out_input = np.dot(hidden_spikes, self.W_out)\n",
-    "            membrane_out = membrane_out * self.decay + out_input\n",
-    "            \n",
-    "        return membrane_out, hidden_spikes\n",
-    "\n",
-    "# Initialize and test SNN\n",
-    "snn = SimpleSNN()\n",
-    "print(\"🧠 Simple SNN initialized\")\n",
-    "print(f\"  Input neurons: {snn.n_inputs}\")\n",
-    "print(f\"  Hidden neurons: {snn.n_hidden}\")\n",
-    "print(f\"  Output neurons: {snn.n_outputs}\")\n",
-    "\n",
-    "# Test with sample data\n",
-    "if len(X_seq) > 0:\n",
-    "    sample_input = X_seq[:1]  # Take first sample\n",
-    "    output, hidden_spikes = snn.forward(sample_input)\n",
-    "    \n",
-    "    print(f\"\\n🔬 Test forward pass:\")\n",
-    "    print(f\"  Input shape: {sample_input.shape}\")\n",
-    "    print(f\"  Hidden spikes: {hidden_spikes.sum()} active\")\n",
-    "    print(f\"  Output shape: {output.shape}\")\n",
-    "    print(f\"  Output values: {output[0]}")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 12. Save Processed Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Save processed spike data for future use\n",
-    "import pickle\n",
-    "\n",
-    "processed_data = {\n",
-    "    'spike_trains': spike_trains,\n",
-    "    'spike_matrix': spike_matrix,\n",
-    "    'sequences': (X_seq, y_seq),\n",
-    "    'classification': (X_cls, y_cls),\n",
-    "    'encoder_channels': encoder.channels,\n",
-    "    'thresholds': encoder.thresholds\n",
-    "}\n",
-    "\n",
-    "# Save to pickle file\n",
-    "with open('spikenaut_processed_data.pkl', 'wb') as f:\n",
-    "    pickle.dump(processed_data, f)\n",
-    "\n",
-    "print(\"💾 Processed data saved to 'spikenaut_processed_data.pkl'\")\n",
-    "print(\"\\n📁 Files created:\")\n",
-    "print(\"  - spikenaut_processed_data.pkl (processed spike data)\")\n",
-    "\n",
-    "# Also save as JSON for compatibility\n",
-    "json_data = {\n",
-    "    'spike_trains': spike_trains,\n",
-    "    'channels': encoder.channels,\n",
-    "    'thresholds': encoder.thresholds,\n",
-    "    'statistics': {\n",
-    "        'total_samples': len(spike_trains),\n",
-    "        'avg_spikes_per_sample': float(spike_matrix.mean()),\n",
-    "        'spike_rate_hz': float(spike_matrix.mean() * 1000),\n",
-    "        'most_active_channel': int(np.argmax(spike_matrix.mean(axis=0))),\n",
-    "        'channel_correlation_avg': float(np.mean(np.abs(correlation_matrix)))\n",
-    "    }\n",
-    "}\n",
-    "\n",
-    "with open('spike_analysis_results.json', 'w') as f:\n",
-    "    json.dump(json_data, f, indent=2)\n",
-    "\n",
-    "print(\"  - spike_analysis_results.json (summary statistics)\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 13. Summary and Next Steps"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(\"🦁 Spikenaut SNN v2 - Spike Encoding Demo Complete!\")\n",
-    "print(\"=\" * 50)\n",
-    "print()\n",
-    "print(\"📊 What we accomplished:\")\n",
-    "print(f\"  ✅ Loaded {len(ds['train'])} training samples\")\n",
-    "print(f\"  ✅ Generated {len(spike_trains)} spike trains\")\n",
-    "print(f\"  ✅ Created {len(X_seq)} sequential samples\")\n",
-    "print(f\"  ✅ Built classification dataset with {len(X_cls)} samples\")\n",
-    "print(f\"  ✅ Analyzed spike correlations across 16 channels\")\n",
-    "print(f\"  ✅ Demonstrated simple SNN forward pass\")\n",
-    "print()\n",
-    "print(\"🔬 Key insights:\")\n",
-    "print(f\"  • Average spike rate: {spike_matrix.mean() * 1000:.1f} Hz\")\n",
-    "print(f\"  • Most active channel: {encoder.channels[np.argmax(spike_matrix.mean(axis=0))]}\")\n",
-    "print(f\"  • Spike correlation avg: {np.mean(np.abs(correlation_matrix)):.3f}\")\n",
-    "print()\n",
-    "print(\"🚀 Next steps for your research:\")\n",
-    "print(\"  1. Train a full SNN using the sequential data\")\n",
-    "print(\"  2. Experiment with different spike encoding thresholds\")\n",
-    "print(\"  3. Try STDP learning rules on the spike trains\")\n",
-    "print(\"  4. Deploy to FPGA using the provided parameters\")\n",
-    "print(\"  5. Extend with real-time telemetry collection\")\n",
-    "print()\n",
-    "print(\"📚 Related resources:\")\n",
-    "print(\"  • Dataset: https://huggingface.co/datasets/rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters\")\n",
-    "print(\"  • Main repo: https://github.com/rmems/Eagle-Lander\")\n",
-    "print(\"  • FPGA deployment: See parameters/ folder\")\n",
-    "print()\n",
-    "print(\"🦁 Happy spiking!\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

dataset/spikenaut_snn_v2_complete_enhanced/hf_dataset/test/dataset_info.json

@@ -1,122 +0,0 @@
-{
-  "citation": "",
-  "description": "",
-  "features": {
-    "timestamp": {
-      "dtype": "timestamp[ns]",
-      "_type": "Value"
-    },
-    "blockchain": {
-      "dtype": "string",
-      "_type": "Value"
-    },
-    "event": {
-      "dtype": "string",
-      "_type": "Value"
-    },
-    "blocks_accepted": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "block_rate": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "telemetry": {
-      "gpu_temp_c": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "hashrate_mh": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "power_w": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "qubic_epoch_progress": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "qubic_tick_trace": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "reward_hint": {
-        "dtype": "float64",
-        "_type": "Value"
-      }
-    },
-    "timestamp_unix": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "hour_of_day": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "day_of_week": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "hashrate_normalized": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "power_efficiency": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "thermal_efficiency": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "spike_hashrate": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_power": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_temp": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_qubic": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "composite_reward": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "target_hashrate_change": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "target_power_change": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "current_height": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "total_height": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "sync_percent": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "remaining_blocks": {
-      "dtype": "float64",
-      "_type": "Value"
-    }
-  },
-  "homepage": "",
-  "license": ""
-}

dataset/spikenaut_snn_v2_complete_enhanced/hf_dataset/test/state.json

@@ -1,13 +0,0 @@
-{
-  "_data_files": [
-    {
-      "filename": "data-00000-of-00001.arrow"
-    }
-  ],
-  "_fingerprint": "9cb98d72dda4546e",
-  "_format_columns": null,
-  "_format_kwargs": {},
-  "_format_type": null,
-  "_output_all_columns": false,
-  "_split": null
-}

dataset/spikenaut_snn_v2_complete_enhanced/hf_dataset/train/dataset_info.json

@@ -1,122 +0,0 @@
-{
-  "citation": "",
-  "description": "",
-  "features": {
-    "timestamp": {
-      "dtype": "timestamp[ns]",
-      "_type": "Value"
-    },
-    "blockchain": {
-      "dtype": "string",
-      "_type": "Value"
-    },
-    "event": {
-      "dtype": "string",
-      "_type": "Value"
-    },
-    "blocks_accepted": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "block_rate": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "telemetry": {
-      "gpu_temp_c": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "hashrate_mh": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "power_w": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "qubic_epoch_progress": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "qubic_tick_trace": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "reward_hint": {
-        "dtype": "float64",
-        "_type": "Value"
-      }
-    },
-    "timestamp_unix": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "hour_of_day": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "day_of_week": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "hashrate_normalized": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "power_efficiency": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "thermal_efficiency": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "spike_hashrate": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_power": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_temp": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_qubic": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "composite_reward": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "target_hashrate_change": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "target_power_change": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "current_height": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "total_height": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "sync_percent": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "remaining_blocks": {
-      "dtype": "float64",
-      "_type": "Value"
-    }
-  },
-  "homepage": "",
-  "license": ""
-}

dataset/spikenaut_snn_v2_complete_enhanced/hf_dataset/train/state.json

@@ -1,13 +0,0 @@
-{
-  "_data_files": [
-    {
-      "filename": "data-00000-of-00001.arrow"
-    }
-  ],
-  "_fingerprint": "1e013cbd1d5223a3",
-  "_format_columns": null,
-  "_format_kwargs": {},
-  "_format_type": null,
-  "_output_all_columns": false,
-  "_split": null
-}

dataset/spikenaut_snn_v2_complete_enhanced/hf_dataset/validation/dataset_info.json

@@ -1,122 +0,0 @@
-{
-  "citation": "",
-  "description": "",
-  "features": {
-    "timestamp": {
-      "dtype": "timestamp[ns]",
-      "_type": "Value"
-    },
-    "blockchain": {
-      "dtype": "string",
-      "_type": "Value"
-    },
-    "event": {
-      "dtype": "string",
-      "_type": "Value"
-    },
-    "blocks_accepted": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "block_rate": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "telemetry": {
-      "gpu_temp_c": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "hashrate_mh": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "power_w": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "qubic_epoch_progress": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "qubic_tick_trace": {
-        "dtype": "float64",
-        "_type": "Value"
-      },
-      "reward_hint": {
-        "dtype": "float64",
-        "_type": "Value"
-      }
-    },
-    "timestamp_unix": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "hour_of_day": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "day_of_week": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "hashrate_normalized": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "power_efficiency": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "thermal_efficiency": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "spike_hashrate": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_power": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_temp": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "spike_qubic": {
-      "dtype": "int64",
-      "_type": "Value"
-    },
-    "composite_reward": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "target_hashrate_change": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "target_power_change": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "current_height": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "total_height": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "sync_percent": {
-      "dtype": "float64",
-      "_type": "Value"
-    },
-    "remaining_blocks": {
-      "dtype": "float64",
-      "_type": "Value"
-    }
-  },
-  "homepage": "",
-  "license": ""
-}

dataset/spikenaut_snn_v2_complete_enhanced/hf_dataset/validation/state.json

@@ -1,13 +0,0 @@
-{
-  "_data_files": [
-    {
-      "filename": "data-00000-of-00001.arrow"
-    }
-  ],
-  "_fingerprint": "6ae7d2aa69715653",
-  "_format_columns": null,
-  "_format_kwargs": {},
-  "_format_type": null,
-  "_output_all_columns": false,
-  "_split": null
-}

dataset/spikenaut_snn_v2_complete_enhanced/hybrid_training_results.json

@@ -1,31 +0,0 @@
-{
-  "architecture": "Julia-Rust Hybrid",
-  "training_date": "2026-03-22T19:35:24.226080",
-  "data_sources": [
-    "Kaspa mainnet (March 21, 2026)",
-    "Monero mainnet (March 22, 2026)"
-  ],
-  "total_samples": 8,
-  "performance_metrics": {
-    "training_speed_us_per_tick": 35.0,
-    "ipc_overhead_us": 0.8,
-    "memory_usage_kb": 1.6,
-    "accuracy_percent": 95.2,
-    "convergence_epochs": 20
-  },
-  "algorithm": {
-    "name": "E-prop + OTTT",
-    "features": [
-      "Eligibility traces",
-      "Surrogate gradients (fast-sigmoid)",
-      "Reward modulation",
-      "L1 normalization"
-    ]
-  },
-  "fpga_parameters": {
-    "thresholds_file": "parameters.mem",
-    "weights_file": "parameters_weights.mem",
-    "decay_file": "parameters_decay.mem",
-    "format": "Q8.8 fixed-point"
-  }
-}

dataset/spikenaut_snn_v2_complete_enhanced/legacy_enhanced_data/compare_legacy_vs_v2.py

@@ -1,68 +0,0 @@
-
-# Compare YOUR legacy data with v2 telemetry data
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-def compare_legacy_vs_v2():
-    """Compare legacy trading data with v2 telemetry"""
-    
-    # Load legacy data
-    legacy_df = load_legacy_data()
-    
-    # Load v2 data (current dataset)
-    from datasets import load_dataset
-    try:
-        v2_ds = load_dataset("rmems/Spikenaut-SNN-v2-Telemetry-Data-Weights-Parameters")
-        v2_df = v2_ds['train'].to_pandas()
-        print("✅ V2 dataset loaded")
-    except:
-        print("⚠️ V2 dataset not available, using sample")
-        v2_df = None
-    
-    print("\n🔍 Dataset Comparison:")
-    print(f"Legacy: {len(legacy_df):,} records (trading focus)")
-    if v2_df is not None:
-        print(f"V2: {len(v2_df)} records (telemetry focus)")
-    
-    # Compare time ranges
-    if 'timestamp' in legacy_df.columns:
-        legacy_df['timestamp'] = pd.to_datetime(legacy_df['timestamp'])
-        print(f"\n⏰ Time Coverage:")
-        print(f"Legacy: {legacy_df['timestamp'].min()} to {legacy_df['timestamp'].max()}")
-        print(f"Duration: {legacy_df['timestamp'].max() - legacy_df['timestamp'].min()}")
-    
-    # Compare data types
-    print(f"\n📋 Data Types:")
-    print(f"Legacy focus: Trading actions, portfolio management, blockchain metrics")
-    if v2_df is not None:
-        print(f"V2 focus: Blockchain telemetry, spike encodings, SNN features")
-    
-    # Visualize portfolio evolution (legacy)
-    if 'portfolio_value' in legacy_df.columns:
-        plt.figure(figsize=(12, 4))
-        
-        plt.subplot(1, 2, 1)
-        # Sample every 1000th point for performance
-        sample_legacy = legacy_df.iloc[::1000]
-        plt.plot(sample_legacy.index, sample_legacy['portfolio_value'], alpha=0.7)
-        plt.title('🦁 Legacy Portfolio Evolution')
-        plt.xlabel('Record Index')
-        plt.ylabel('Portfolio Value ($)')
-        plt.grid(True, alpha=0.3)
-        
-        # Action distribution
-        plt.subplot(1, 2, 2)
-        action_counts = legacy_df['action'].value_counts()
-        plt.pie(action_counts.values, labels=action_counts.index, autopct='%1.1f%%')
-        plt.title('Legacy Action Distribution')
-        
-        plt.tight_layout()
-        plt.show()
-    
-    print("\n🎯 Key Insights:")
-    print("• Legacy: Rich trading history with 200K+ records")
-    print("• V2: Focused telemetry with spike encodings")
-    print("• Combined: Complete picture of Spikenaut evolution")
-
-# Run comparison
-compare_legacy_vs_v2()

dataset/spikenaut_snn_v2_complete_enhanced/legacy_enhanced_data/legacy_summary_statistics.json

@@ -1,41 +0,0 @@
-{
-  "legacy_dataset_info": {
-    "total_records": 223020,
-    "file_size_mb": 182.3,
-    "date_range": {
-      "start": "2026-03-12T06:31:49.460483249+00:00",
-      "end": "2026-03-15T14:08:16.650911711+00:00"
-    },
-    "processing_date": "2026-03-23T07:13:53.008746"
-  },
-  "data_quality": {
-    "valid_json_rate": 100.0,
-    "completeness": {
-      "timestamp": 100.0,
-      "action": 100.0,
-      "portfolio_value": 100.0,
-      "price_usd": 100.0
-    }
-  },
-  "trading_metrics": {
-    "total_actions": 10000,
-    "observe_actions": 9936,
-    "buy_actions": 29,
-    "sell_actions": 35,
-    "portfolio_value_range": {
-      "min": 500.0,
-      "max": 1102.5507,
-      "mean": 990.2608183219999
-    }
-  },
-  "blockchain_metrics": {
-    "quai_block_utilization": {
-      "mean": 0.65,
-      "std": 0.0
-    },
-    "quai_gas_price": {
-      "mean": 10.0,
-      "std": 0.0
-    }
-  }
-}

dataset/spikenaut_snn_v2_complete_enhanced/legacy_enhanced_data/load_legacy_data.py

@@ -1,59 +0,0 @@
-
-# Load and analyze YOUR massive legacy Spikenaut dataset
-import json
-import pandas as pd
-import numpy as np
-from pathlib import Path
-
-def load_legacy_data(chunk_dir="legacy_enhanced_data"):
-    """Load your enhanced legacy dataset"""
-    all_data = []
-    
-    chunk_dir = Path(chunk_dir)
-    chunk_files = sorted(chunk_dir.glob("legacy_chunk_*.jsonl"))
-    
-    print(f"🦁 Loading {len(chunk_files)} legacy data chunks...")
-    
-    for chunk_file in chunk_files:
-        with open(chunk_file, 'r') as f:
-            for line in f:
-                if line.strip():
-                    record = json.loads(line)
-                    all_data.append(record)
-    
-    df = pd.DataFrame(all_data)
-    print(f"✅ Loaded {len(df):,} records from legacy dataset")
-    
-    return df
-
-# Load your legacy data
-legacy_df = load_legacy_data()
-
-print("\n📊 Legacy Dataset Overview:")
-print(f"  Records: {len(legacy_df):,}")
-print(f"  Columns: {list(legacy_df.columns)}")
-print(f"  Date range: {legacy_df['timestamp'].min()} to {legacy_df['timestamp'].max()}")
-
-# Analyze trading patterns
-print("\n💰 Trading Analysis:")
-action_counts = legacy_df['action'].value_counts()
-for action, count in action_counts.items():
-    print(f"  {action}: {count:,} ({count/len(legacy_df)*100:.1f}%)")
-
-# Portfolio performance over time
-if 'portfolio_value' in legacy_df.columns:
-    portfolio_stats = legacy_df['portfolio_value'].describe()
-    print(f"\n📈 Portfolio Performance:")
-    print(f"  Initial: ${portfolio_stats['min']:.2f}")
-    print(f"  Final: ${portfolio_stats['max']:.2f}")
-    print(f"  Mean: ${portfolio_stats['mean']:.2f}")
-    print(f"  Return: {(portfolio_stats['max']/500 - 1)*100:.2f}%")
-
-# Blockchain health analysis
-if 'blockchain_health_score' in legacy_df.columns:
-    health_stats = legacy_df['blockchain_health_score'].describe()
-    print(f"\n⛓️ Blockchain Health:")
-    print(f"  Mean score: {health_stats['mean']:.3f}")
-    print(f"  Health trend: {'Improving' if health_stats['mean'] > 0.6 else 'Stable' if health_stats['mean'] > 0.4 else 'Declining'}")
-
-print("\n🎉 Your legacy dataset shows rich trading and blockchain telemetry!")

dataset/spikenaut_snn_v2_complete_enhanced/mining/mining_summary.json

@@ -1,14 +0,0 @@
-{
-  "file_size_mb": 52.7899751663208,
-  "total_lines_sampled": 2000,
-  "metrics": {
-    "hashrate_mentions": 0,
-    "temperature_mentions": 31,
-    "error_mentions": 1477,
-    "gpu_mentions": 1477,
-    "sample_lines": []
-  },
-  "miner_version": "BzMiner v24.0.1",
-  "integration_date": "2026-03-23T07:26:53.373138",
-  "description": "Real mining operation logs with hashrate, temperature, and GPU metrics"
-}

dataset/spikenaut_snn_v2_complete_enhanced/operations/operations_summary.json

@@ -1,10 +0,0 @@
-{
-  "total_events": 6,
-  "event_types": {
-    "starting": 6
-  },
-  "time_range": "2026-03-22 04:31:17+00:00 to 2026-03-22 06:08:44+00:00",
-  "file_size_kb": 0.65625,
-  "integration_date": "2026-03-23T07:26:53.373483",
-  "description": "System monitoring and process lifecycle events"
-}

dataset/spikenaut_snn_v2_complete_enhanced/package_info.json

@@ -1,25 +0,0 @@
-{
-  "name": "spikenaut_snn_v2_complete_enhanced",
-  "version": "2.1.0",
-  "created": "2026-03-23T07:32:30.332554",
-  "total_size_mb": 635,
-  "total_records": 1400000,
-  "data_collections": 5,
-  "description": "Most comprehensive neuromorphic blockchain dataset ever created",
-  "contents": {
-    "core_dataset": "Enhanced telemetry with 20+ features",
-    "training_data": "Real SNN training with spike patterns",
-    "mining_data": "55MB BzMiner operation logs",
-    "operations_data": "System monitoring telemetry",
-    "research_data": "380MB neuromorphic dataset",
-    "parameters": "Your real trained weights (95.2% accuracy)",
-    "examples": "Complete tutorials and documentation"
-  },
-  "ready_for": [
-    "neuromorphic_research",
-    "blockchain_analysis",
-    "fpga_deployment",
-    "system_monitoring",
-    "advanced_research"
-  ]
-}

dataset/spikenaut_snn_v2_complete_enhanced/parameters/README.md

@@ -1,112 +0,0 @@
-# FPGA Parameters - Q8.8 Fixed-Point Format
-
-## Overview
-
-These parameter files are exported from the Spikenaut SNN v2 hybrid Julia-Rust training system and are ready for FPGA deployment.
-
-## File Descriptions
-
-- **parameters.mem**: Neuron thresholds and bias values
-- **parameters_weights.mem**: Synaptic weight matrix (sparse format)
-- **parameters_decay.mem**: Time constants and decay factors
-
-## Q8.8 Fixed-Point Format
-
-Each value is stored in Q8.8 fixed-point format:
-- 8 bits for integer part (including sign)
-- 8 bits for fractional part
-- Range: -128.0 to +127.996
-
-### Conversion Examples
-
-```rust
-// Rust: Convert Q8.8 to f32
-fn q8_8_to_f32(q8_8: u16) -> f32 {
-    let raw = q8_8 as i16;
-    raw as f32 / 256.0
-}
-
-// Julia: Convert Q8.8 to Float32
-function q8_8_to_float(q8_8::UInt16)
-    raw = Int16(q8_8)
-    raw / 256.0f0
-end
-```
-
-## FPGA Loading (Verilog)
-
-```verilog
-// Load parameters into FPGA memory
-reg [15:0] param_mem [0:1023];
-initial begin
-    $readmemh("parameters.mem", param_mem);
-end
-
-// Convert Q8.8 to fixed-point arithmetic
-wire signed [15:0] threshold = param_mem[neuron_id];
-wire signed [31:0] weighted_sum = input * weight + threshold;
-```
-
-## Hardware Target
-
-- **Board**: Xilinx Artix-7 Basys3
-- **Memory**: 1024×16-bit BRAM configuration
-- **Clock**: 1kHz (1ms resolution)
-- **Power**: ~97mW dynamic
-
-## Performance Specifications
-
-- **Neurons**: 16 (4 per node group)
-- **Synapses**: Sparse connectivity (1% density)
-- **Update Rate**: 1kHz (sub-millisecond latency)
-- **Precision**: Q8.8 (sufficient for neuromorphic computing)
-
-## Loading in Different Languages
-
-### Python (for simulation)
-```python
-import numpy as np
-
-def load_q8_8_params(filename):
-    with open(filename, 'r') as f:
-        hex_values = [line.strip() for line in f if line.strip()]
-    return np.array([int(hex_val, 16) / 256.0 for hex_val in hex_values], dtype=np.float32)
-```
-
-### C/C++
-```c
-#include <stdint.h>
-#include <stdio.h>
-
-float q8_8_to_float(uint16_t q8_8) {
-    int16_t raw = (int16_t)q8_8;
-    return (float)raw / 256.0f;
-}
-
-void load_parameters(const char* filename, float* buffer, size_t count) {
-    FILE* file = fopen(filename, "r");
-    for (size_t i = 0; i < count; i++) {
-        unsigned int hex_val;
-        fscanf(file, "%x", &hex_val);
-        buffer[i] = q8_8_to_float((uint16_t)hex_val);
-    }
-    fclose(file);
-}
-```
-
-## Validation
-
-The parameters have been validated on:
-- **Software**: Julia-Rust hybrid training (95%+ accuracy)
-- **Hardware**: Basys3 FPGA synthesis (921K LUTs, 0 errors)
-- **Simulation**: Verilog testbench with real telemetry data
-
-## Integration with Spikenaut SNN v2
-
-These parameters represent a trained model that:
-- Processes 16-channel blockchain telemetry
-- Implements E-prop + OTTT learning rules
-- Provides sub-millisecond inference latency
-- Operates at 97mW power consumption
-
-For more details, see the main Spikenaut SNN v2 documentation.

dataset/spikenaut_snn_v2_complete_enhanced/parameters/parameters.mem

@@ -1,16 +0,0 @@
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100

dataset/spikenaut_snn_v2_complete_enhanced/parameters/parameters_decay.mem

@@ -1,16 +0,0 @@
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA
-00DA

dataset/spikenaut_snn_v2_complete_enhanced/parameters/parameters_weights.mem

@@ -1,256 +0,0 @@
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0000
-0033
-0049
-0019
-004F
-0003
-0019

dataset/spikenaut_snn_v2_complete_enhanced/research/research_summary.json

@@ -1,10 +0,0 @@
-{
-  "file_size_mb": 362.7253694534302,
-  "sample_records_analyzed": 1000,
-  "estimated_total_records": 380345,
-  "sample_fields": [
-    "telemetry"
-  ],
-  "integration_date": "2026-03-23T07:26:53.490440",
-  "description": "Massive neuromorphic dataset for advanced research"
-}

dataset/spikenaut_snn_v2_complete_enhanced/training/training_analysis.json

@@ -1,23 +0,0 @@
-{
-  "training_datasets": {
-    "snn_training_all.jsonl": {
-      "records": 73,
-      "size_kb": 26.384765625,
-      "time_range": "2026-02-26 22:52:58.034645-06:00 to 2026-03-12 06:34:59.588891+00:00"
-    },
-    "snn_training_market.jsonl": {
-      "records": 39,
-      "size_kb": 13.890625,
-      "time_range": "2026-03-12 06:31:49.460483+00:00 to 2026-03-12 06:34:59.588891+00:00"
-    },
-    "snn_training_mind.jsonl": {
-      "records": 5,
-      "size_kb": 1.884765625,
-      "time_range": "2026-02-26 22:52:58.034645-06:00 to 2026-03-10 16:04:20.573922-05:00"
-    }
-  },
-  "total_records": 117,
-  "neuron_count": 16,
-  "integration_date": "2026-03-23T07:26:53.333352",
-  "description": "Real SNN training data with spike patterns, reward signals, and stimuli"
-}

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/spikenaut_real_weights_analysis.json

@@ -1,55 +0,0 @@
-{
-  "model_info": {
-    "architecture": "SpikenautSNN",
-    "source": "YOUR trained parameters",
-    "input_size": 16,
-    "hidden_size": 16,
-    "output_size": 3,
-    "training_date": "2026-03-22",
-    "format": "Q8.8_fixed_point",
-    "export_timestamp": "2026-03-23T07:10:35.133180"
-  },
-  "your_trained_parameters": {
-    "hidden_layer": {
-      "weight_shape": [
-        16,
-        16
-      ],
-      "threshold_count": 16,
-      "decay_count": 16,
-      "weight_statistics": {
-        "mean": 0.896484375,
-        "std": 0.07424444705247879,
-        "min": 0.75,
-        "max": 1.04296875,
-        "non_zero_percentage": 100.0
-      },
-      "threshold_statistics": {
-        "mean": 1.359375,
-        "std": 0.14405538141727448,
-        "min": 1.125,
-        "max": 1.59375
-      },
-      "decay_statistics": {
-        "mean": 0.3359375,
-        "std": 0.0,
-        "min": 0.3359375,
-        "max": 0.3359375
-      }
-    }
-  },
-  "training_insights": {
-    "sparsity": 1.0,
-    "weight_distribution": "learned",
-    "threshold_range": "adaptive",
-    "decay_range": "stable",
-    "training_quality": "high"
-  },
-  "performance_metrics": {
-    "training_speed_us_per_tick": 35.0,
-    "ipc_overhead_us": 0.8,
-    "memory_usage_kb": 1.6,
-    "accuracy_percent": 95.2,
-    "convergence_epochs": 20
-  }
-}

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/spikenaut_real_weights_output_weights.mem

@@ -1,48 +0,0 @@
-FFF9
-001E
-FFFC
-0042
-000E
-0025
-FFE3
-0025
-FFD9
-0007
-FFD6
-000C
-001A
-0018
-0009
-FFF0
-FFE6
-FFF1
-FFF8
-0005
-FFEC
-0003
-0006
-FFF4
-FFEE
-0017
-0000
-FFFD
-FFF2
-FFF8
-0024
-0004
-0015
-FFF4
-FFFF
-001C
-001E
-FFE2
-FFFF
-FFEF
-FFF5
-FFED
-FFF2
-0012
-FFEF
-0026
-0016
-FFF3

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/spikenaut_real_weights_trained_decay.mem

@@ -1,16 +0,0 @@
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/spikenaut_real_weights_trained_thresholds.mem

@@ -1,16 +0,0 @@
-0120
-0128
-0130
-0138
-0140
-0148
-0150
-0158
-0160
-0168
-0170
-0178
-0180
-0188
-0190
-0198

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/spikenaut_real_weights_trained_weights.mem

@@ -1,256 +0,0 @@
-00C0
-00C1
-00C2
-00C3
-00C4
-00C5
-00C6
-00C7
-00C8
-00C9
-00CA
-00CB
-00CC
-00CD
-00CE
-00CF
-00C4
-00C5
-00C6
-00C7
-00C8
-00C9
-00CA
-00CB
-00CC
-00CD
-00CE
-00CF
-00D0
-00D1
-00D2
-00D3
-00C8
-00C9
-00CA
-00CB
-00CC
-00CD
-00CE
-00CF
-00D0
-00D1
-00D2
-00D3
-00D4
-00D5
-00D6
-00D7
-00CC
-00CD
-00CE
-00CF
-00D0
-00D1
-00D2
-00D3
-00D4
-00D5
-00D6
-00D7
-00D8
-00D9
-00DA
-00DB
-00D0
-00D1
-00D2
-00D3
-00D4
-00D5
-00D6
-00D7
-00D8
-00D9
-00DA
-00DB
-00DC
-00DD
-00DE
-00DF
-00D4
-00D5
-00D6
-00D7
-00D8
-00D9
-00DA
-00DB
-00DC
-00DD
-00DE
-00DF
-00E0
-00E1
-00E2
-00E3
-00D8
-00D9
-00DA
-00DB
-00DC
-00DD
-00DE
-00DF
-00E0
-00E1
-00E2
-00E3
-00E4
-00E5
-00E6
-00E7
-00DC
-00DD
-00DE
-00DF
-00E0
-00E1
-00E2
-00E3
-00E4
-00E5
-00E6
-00E7
-00E8
-00E9
-00EA
-00EB
-00E0
-00E1
-00E2
-00E3
-00E4
-00E5
-00E6
-00E7
-00E8
-00E9
-00EA
-00EB
-00EC
-00ED
-00EE
-00EF
-00E4
-00E5
-00E6
-00E7
-00E8
-00E9
-00EA
-00EB
-00EC
-00ED
-00EE
-00EF
-00F0
-00F1
-00F2
-00F3
-00E8
-00E9
-00EA
-00EB
-00EC
-00ED
-00EE
-00EF
-00F0
-00F1
-00F2
-00F3
-00F4
-00F5
-00F6
-00F7
-00EC
-00ED
-00EE
-00EF
-00F0
-00F1
-00F2
-00F3
-00F4
-00F5
-00F6
-00F7
-00F8
-00F9
-00FA
-00FB
-00F0
-00F1
-00F2
-00F3
-00F4
-00F5
-00F6
-00F7
-00F8
-00F9
-00FA
-00FB
-00FC
-00FD
-00FE
-00FF
-00F4
-00F5
-00F6
-00F7
-00F8
-00F9
-00FA
-00FB
-00FC
-00FD
-00FE
-00FF
-0100
-0101
-0102
-0103
-00F8
-00F9
-00FA
-00FB
-00FC
-00FD
-00FE
-00FF
-0100
-0101
-0102
-0103
-0104
-0105
-0106
-0107
-00FC
-00FD
-00FE
-00FF
-0100
-0101
-0102
-0103
-0104
-0105
-0106
-0107
-0108
-0109
-010A
-010B

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/your_original_decay.mem

@@ -1,16 +0,0 @@
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056
-0056

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/your_original_thresholds.mem

@@ -1,16 +0,0 @@
-0120
-0128
-0130
-0138
-0140
-0148
-0150
-0158
-0160
-0168
-0170
-0178
-0180
-0188
-0190
-0198

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/your_original_weights.mem

@@ -1,256 +0,0 @@
-00C0
-00C1
-00C2
-00C3
-00C4
-00C5
-00C6
-00C7
-00C8
-00C9
-00CA
-00CB
-00CC
-00CD
-00CE
-00CF
-00C4
-00C5
-00C6
-00C7
-00C8
-00C9
-00CA
-00CB
-00CC
-00CD
-00CE
-00CF
-00D0
-00D1
-00D2
-00D3
-00C8
-00C9
-00CA
-00CB
-00CC
-00CD
-00CE
-00CF
-00D0
-00D1
-00D2
-00D3
-00D4
-00D5
-00D6
-00D7
-00CC
-00CD
-00CE
-00CF
-00D0
-00D1
-00D2
-00D3
-00D4
-00D5
-00D6
-00D7
-00D8
-00D9
-00DA
-00DB
-00D0
-00D1
-00D2
-00D3
-00D4
-00D5
-00D6
-00D7
-00D8
-00D9
-00DA
-00DB
-00DC
-00DD
-00DE
-00DF
-00D4
-00D5
-00D6
-00D7
-00D8
-00D9
-00DA
-00DB
-00DC
-00DD
-00DE
-00DF
-00E0
-00E1
-00E2
-00E3
-00D8
-00D9
-00DA
-00DB
-00DC
-00DD
-00DE
-00DF
-00E0
-00E1
-00E2
-00E3
-00E4
-00E5
-00E6
-00E7
-00DC
-00DD
-00DE
-00DF
-00E0
-00E1
-00E2
-00E3
-00E4
-00E5
-00E6
-00E7
-00E8
-00E9
-00EA
-00EB
-00E0
-00E1
-00E2
-00E3
-00E4
-00E5
-00E6
-00E7
-00E8
-00E9
-00EA
-00EB
-00EC
-00ED
-00EE
-00EF
-00E4
-00E5
-00E6
-00E7
-00E8
-00E9
-00EA
-00EB
-00EC
-00ED
-00EE
-00EF
-00F0
-00F1
-00F2
-00F3
-00E8
-00E9
-00EA
-00EB
-00EC
-00ED
-00EE
-00EF
-00F0
-00F1
-00F2
-00F3
-00F4
-00F5
-00F6
-00F7
-00EC
-00ED
-00EE
-00EF
-00F0
-00F1
-00F2
-00F3
-00F4
-00F5
-00F6
-00F7
-00F8
-00F9
-00FA
-00FB
-00F0
-00F1
-00F2
-00F3
-00F4
-00F5
-00F6
-00F7
-00F8
-00F9
-00FA
-00FB
-00FC
-00FD
-00FE
-00FF
-00F4
-00F5
-00F6
-00F7
-00F8
-00F9
-00FA
-00FB
-00FC
-00FD
-00FE
-00FF
-0100
-0101
-0102
-0103
-00F8
-00F9
-00FA
-00FB
-00FC
-00FD
-00FE
-00FF
-0100
-0101
-0102
-0103
-0104
-0105
-0106
-0107
-00FC
-00FD
-00FE
-00FF
-0100
-0101
-0102
-0103
-0104
-0105
-0106
-0107
-0108
-0109
-010A
-010B

dataset/spikenaut_snn_v2_complete_enhanced/your_real_parameters/your_training_analysis.json

@@ -1,14 +0,0 @@
-{
-  "source": "YOUR real trained parameters",
-  "architecture": "16x16",
-  "training_quality": {
-    "non_zero_weights_percent": 100.0,
-    "weights_std": 0.07424444705247879,
-    "thresholds_std": 0.14405538141727448,
-    "decay_stability": 0.0
-  },
-  "performance": {
-    "accuracy_percent": 95.2,
-    "training_speed_us_per_tick": 35.0
-  }
-}