Delete dataset/examples

dataset/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/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/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
-}