nbox-memristor-visuotactile-snn

name	nbox-memristor-visuotactile-snn
version	1.0
description	Self-oscillating NbOx memristor neuron for ultra-low-latency visuotactile perception. NbOx devices leverage intrinsic Mott metal-insulator transition and parasitic capacitance for simultaneous TTFS (time-to-first-spike) + rate encoding with 260 ns first-spike latency. Use when: neuromorphic hardware design, memristive spiking neurons, tactile/visual sensor fusion, embodied intelligence hardware, low-latency spike encoding circuits.
tags	["memristor","NbOx","neuromorphic-hardware","visuotactile","spiking-neuron","TTFS","rate-coding","Mott-insulator","metal-insulator-transition","embodied-intelligence"]
activation_keywords	["NbOx memristor","self-oscillating neuron","Mott transition","metal-insulator transition","visuotactile","low latency spike","TTFS encoding","time-to-first-spike hardware","memristive spiking"]
source	{"pmid":"42183948","journal":"Small","year":2026,"title":"Low-Latency Visuotactile Neuron Using Self-Oscillating Memristor","authors":["Li Pengzhan","Huang Anping","Huang Jiangshun","Yang Qiaofeng"]}

NbOx Memristor Visuotactile SNN Neuron

Overview

This skill covers the design and modeling of self-oscillating NbOx memristor neurons that achieve ultra-low-latency (260 ns first spike) simultaneous encoding of visual and tactile stimuli. The core innovation is eliminating external capacitors by leveraging intrinsic parasitic capacitance of the NbOx device — simplifying circuit integration while achieving biologically plausible TTFS + rate encoding.

Key contribution: A single NbOx memristor device functions as a complete integrate-and-fire neuron with:

• Self-oscillating threshold via Mott metal-insulator transition
• 260 ns time-to-first-spike latency
• Simultaneous TTFS and firing rate encoding
• Multimodal (visual + pressure) input fusion

NbOx Mott Transition Physics

Metal-Insulator Transition (MIT)

NbOx (typically Nb₂O₄·₅ → NbO₂) undergoes a thermally-driven Mott transition:

NbO₂ (insulator, R_high ~ MΩ) ←→ NbO (metal, R_low ~ kΩ)
         ↑                              ↑  
   T < T_MIT (~1080 K)         T > T_MIT (Joule heating)

Self-oscillation mechanism:

1. Apply voltage → current flows → Joule heating
2. Local temperature rises → MIT occurs (resistance drops)
3. Lower resistance → more current → runaway heating avoided by LC/RC circuit
4. Device cools → resistance rises → cycle repeats
5. → Intrinsic oscillation at frequency determined by thermal RC time constant

Circuit Model

V_supply
   │
   R_load
   │
   ├── Parasitic C (device capacitance ~1-10 fF)
   │
   NbOx device (R_MIT, thermal model)
   │
  GND

The device's threshold switching replaces the need for external capacitors in standard RC integrate-and-fire circuits.

Spike Encoding Modes

1. Time-to-First-Spike (TTFS) Encoding

• Stronger stimulus → faster Joule heating → shorter time to reach T_MIT → earlier first spike
• Maps stimulus intensity to spike latency
• Enables population coding with relative timing

def ttfs_model(I_stimulus, R_load, C_parasitic, T_ambient=300):
    """
    Simplified TTFS model for NbOx self-oscillating neuron.
    Returns estimated time-to-first-spike in seconds.
    """
    # Thermal capacitance and resistance of NbOx
    C_thermal = 1e-12  # J/K (estimated)
    R_thermal = 1e4    # K/W (estimated)
    T_mit = 1080       # K (Mott transition temperature for NbO2)
    
    # Heating rate at initial resistance (insulating state)
    R_device_initial = 1e6  # Ω (insulating state)
    P_initial = I_stimulus**2 * R_device_initial
    
    # Time to reach MIT temperature (simplified RC thermal model)
    delta_T = T_mit - T_ambient
    tau_thermal = C_thermal * R_thermal
    
    # t = -tau * ln(1 - delta_T / (P * R_thermal))
    import math
    if P_initial * R_thermal <= delta_T:
        return float('inf')  # never reaches MIT
    
    t_first_spike = -tau_thermal * math.log(1 - delta_T / (P_initial * R_thermal))
    return t_first_spike

2. Rate Encoding

• After first spike: oscillation frequency scales with stimulus amplitude
• Rate encoding for sustained stimuli
• Combined with TTFS for temporal precision at onset + rate for sustained response

def oscillation_frequency(I_stimulus, device_params):
    """
    Estimate NbOx oscillation frequency from stimulus current.
    """
    R_on = device_params['R_on']    # ~1 kΩ (metallic state)
    R_off = device_params['R_off']  # ~1 MΩ (insulating state)
    C_par = device_params['C_par']  # parasitic capacitance
    V_th = device_params['V_th']    # threshold voltage
    
    # Charging time (insulating state)
    tau_charge = R_off * C_par
    # Discharging time (metallic state)  
    tau_discharge = R_on * C_par
    
    # Simplified: frequency dominated by charging time
    # In practice, need to solve full thermal + electrical ODE
    f = 1.0 / (tau_charge * -np.log(1 - V_th / (I_stimulus * R_off)))
    return f

Multimodal Sensor Integration

Visual (Photodetector) + Pressure Sensor Architecture

Visual Input (photodetector)        Pressure Input (piezoresistive)
        │                                    │
   I_photo                              I_pressure
        │                                    │
        └────────────┬─────────────────────┘
                     │
            I_total = I_photo + I_pressure
                     │
              NbOx Neuron
              (TTFS + Rate encoder)
                     │
             Spike output to SNN

Key advantage: Single NbOx device integrates multimodal currents without separate ADC/preprocessing — the spike pattern naturally encodes combined stimulus.

Temporal Encoding for Sensor Fusion

class NbOxVisuotactileNeuron:
    """
    Simplified model of NbOx self-oscillating multimodal neuron.
    """
    def __init__(self):
        self.state = "OFF"  # "OFF" = insulating, "ON" = metallic
        self.T_device = 300.0  # temperature in K
        self.V_device = 0.0
        
        # Device parameters (approximate for NbO2)
        self.T_mit = 1080.0      # MIT transition temperature
        self.R_off = 1e6         # Insulating resistance (Ω)
        self.R_on = 1e3          # Metallic resistance (Ω)
        self.C_thermal = 5e-13   # Thermal capacitance (J/K)
        self.R_thermal = 1e4     # Thermal resistance (K/W)
        self.T_ambient = 300.0   # Ambient temperature
        self.C_parasitic = 5e-15 # Parasitic electrical capacitance (F)
        
    def step(self, I_in, dt=1e-9):
        """Advance neuron state by dt nanoseconds."""
        # Current resistance
        R = self.R_on if .state ==   .R_off
        
        
        P = I_in** * R
        
        
        dT = (P - (.T_device - .T_ambient) / .R_thermal) / .C_thermal
        .T_device += dT * dt
        
        
        spiked = 
         .state ==   .T_device >= .T_mit:
            .state = 
            spiked =   
         .state ==   .T_device < .T_mit:
            .state = 
        
         spiked, .T_device
    
     ():
        
        I_total = I_visual + I_pressure
        spikes = []
        T_trace = []
        
         t  (duration_ns):
            spiked, T = .step(I_total, dt=)
             spiked:
                spikes.append(t)  
            T_trace.append(T)
        
         spikes, T_trace

Key Performance Metrics

Metric	NbOx Neuron	Standard CMOS IF	Biological Neuron
First spike latency	260 ns	~μs	~1–10 ms
Operating voltage	~1–3 V	1.8–3.3 V	~70 mV
Energy/spike	~10 pJ	~1–100 pJ	~10 pJ
Footprint	~μm²	~10 μm²	~10 μm soma
Multimodal integration	Native	External ADC needed	Via dendrites

Integration with SNN Frameworks

Interfacing Hardware Spikes with SpikingJelly

import spikingjelly.activation_based as sj
import torch

class NbOxSpikeTrain(torch.utils.data.Dataset):
    """
    Wraps NbOx hardware spike output as input to SNN layers.
    """
    def __init__(self, raw_spike_times_ns, T_steps=100, dt_ms=1.0):
        """
        raw_spike_times_ns: list of spike times in nanoseconds
        T_steps: number of simulation timesteps
        dt_ms: timestep duration in ms
        """
        self.T = T_steps
        self.dt_ms = dt_ms
        self.spike_times_ms = [t * 1e-6 for t in raw_spike_times_ns]
        
    def to_binary_tensor(self):
        """Convert spike times to binary spike train tensor."""
        spike_train = torch.zeros(self.T)
        for t_ms in self.spike_times_ms:
            t_idx = int(t_ms / self.dt_ms)
            if 0 <= t_idx < self.T:
                spike_train[t_idx] = 1.0
        return spike_train

Design Guidelines

Choosing NbOx Device Parameters

1. R_off / R_on ratio: Higher ratio → sharper threshold switching → cleaner TTFS
2. Thermal capacitance: Lower C_thermal → faster response (lower latency) but less stability
3. Parasitic capacitance: Must be large enough to sustain oscillation; can be tuned via device geometry
4. Load resistance: Set R_load to ~√(R_on × R_off) for optimal oscillation amplitude

Multi-layer Integration

Input layer: NbOx neurons (analog sensor → spikes)
     ↓ spike trains
Hidden layer: Digital SNN (e.g., LIF neurons on-chip)
     ↓ classified features
Output layer: Decision / actuation

Pitfalls

1. Temperature-dependent variability: NbOx MIT temperature varies with oxide stoichiometry; device-to-device variation requires calibration
2. Endurance: Repeated phase transitions degrade NbOx — typical cycling endurance is 10⁷–10⁸ cycles
3. Thermal crosstalk: Densely packed devices may influence neighboring device temperature → spurious spikes
4. Stochastic switching: Threshold switching has inherent stochasticity — consider probabilistic spike models
5. TTFS decoding: Network must be designed to decode relative spike times, not just rate — requires careful SNN architecture choice

Related Skills

• vo2-mott-oscillator-spiking-neurons — VO2-based Mott oscillator spiking neurons (closely related physics)
• inhibitory-neuristor-mit — inhibitory neuristor based on MIT
• neuromorphic-spiking-ring-attractor-v2 — hardware neuromorphic ring attractor
• spiking-neural-network-analysis — general SNN paper analysis
• analog-neuromorphic-plasticity — analog neuromorphic hardware plasticity