菜单
Sparsity-aware event-driven impulse radio transceivers for reliable wireless neuromorphic inference. Activation: neuromorphic wireless, sparsity-aware radio, event-driven impulse, spike transmission.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/hiyenwong/ai_collection --skill sparsity-neuromorphic-impulse-radio命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Graph-native Python reimplementation of the Information Dynamics of Music (IDyOM) model that represents predictive memories as explicit graph objects for musical expectation modeling and network analysis.
Physics-aware end-to-end deep reinforcement learning methodology for quadcopter control with actuator dynamics modeling.
Reinforced Dreamer methodology for asymmetric reinforcement learning using latent guidance to improve world model representations and behaviors in model-based RL.
基于 SOC 职业分类
正在显示 SKILL.md
| name | sparsity-neuromorphic-impulse-radio |
| description | Sparsity-aware event-driven impulse radio transceivers for reliable wireless neuromorphic inference. Activation: neuromorphic wireless, sparsity-aware radio, event-driven impulse, spike transmission. |
A complete system design for wireless neuromorphic computing that leverages spike sparsity to optimize radio transmission, enabling efficient and reliable communication between distributed neuromorphic devices.
Traditional wireless communication protocols are inefficient for neuromorphic systems because they:
This work proposes sparsity-aware event-driven impulse radio that:
1. Event-Driven Transmission
Traditional: Periodic sampling → Continuous transmission
Proposed: Spike detection → Impulse transmission → Silent otherwise
2. Impulse Radio Architecture
3. Sparsity-Adaptive Modulation
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Spike │───→│ Pulse │───→│ UWB │
│ Detector │ │ Generator │ │ Antenna │
└─────────────┘ └─────────────┘ └─────────────┘
↑
│ ┌─────────────┐
└───←│ Sparsity │
│ Monitor │
└─────────────┘
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ UWB │───→│ Energy │───→│ Spike │
│ Antenna │ │ Detector │ │ Reconstructor│
└─────────────┘ └─────────────┘ └─────────────┘
↓
┌─────────────┐
│ Neuromorphic│
│ Core │
└─────────────┘
Step 1: Spike Event Encoding
import numpy as np
class SpikeEncoder:
"""
Encode spike events for impulse radio transmission
"""
def __init__(self, time_resolution=1e-6, max_spikes_per_packet=64):
self.dt = time_resolution
self.max_spikes = max_spikes_per_packet
def encode(self, spike_times, neuron_ids):
"""
Encode spikes into transmission packet
spike_times: array of spike timestamps (seconds)
neuron_ids: array of neuron indices
"""
# Group spikes into packets
packets = []
for i in range(0, len(spike_times), self.max_spikes):
packet = {
'timestamps': spike_times[i:i+self.max_spikes],
'neuron_ids': neuron_ids[i:i+self.max_spikes],
'base_time': spike_times[i]
}
packets.append(packet)
return packets
Step 2: Impulse Radio Transmitter
class ImpulseTransmitter:
"""
UWB impulse radio transmitter for neuromorphic spikes
"""
def __init__(self, center_freq=4.0e9, pulse_width=2e-9):
self.fc = center_freq # 4 GHz center frequency
self.Tp = pulse_width # 2 ns pulse width
self.chip_rate = 1e6 # 1 Mcps
def generate_pulse(self, time_hop_code):
"""Generate UWB impulse with time hopping"""
t = np.arange(0, self.Tp, 1/self.fc/10)
# Gaussian monocycle pulse
pulse = (1 - 4*np.pi*(t/self.Tp - 0.5)**2) * \
np.exp(-2*np.pi*(t/self.Tp - 0.5)**2)
# Apply time hopping
delay = time_hop_code / self.chip_rate
return pulse, delay
def transmit_packet(self, packet):
"""Transmit encoded spike packet"""
signal = []
for ts, nid in zip(packet['timestamps'], packet['neuron_ids']):
th_code = (nid) %
pulse, delay = .generate_pulse(th_code)
tx_time = ts - packet[] + delay
signal.append((tx_time, pulse))
signal
Step 3: Energy Detection Receiver
class EnergyDetectorReceiver:
"""
Non-coherent energy detector for impulse radio
"""
def __init__(self, integration_window=10e-9, threshold=0.5):
self.Ti = integration_window # Integration window
self.thresh = threshold
def detect(self, received_signal, sampling_rate=20e9):
"""Detect spikes from received signal"""
dt = 1 / sampling_rate
window_samples = int(self.Ti / dt)
# Square-law detection
squared = np.abs(received_signal) ** 2
# Sliding window integration
energy = np.convolve(squared, np.ones(window_samples)/window_samples, mode='same')
# Threshold detection
spike_indices = np.where(energy > self.thresh)[0]
spike_times = spike_indices * dt
return spike_times, energy
Step 4: Sparsity-Aware Rate Control
class SparsityController:
"""
Adapt transmission parameters based on spike sparsity
"""
def __init__(self):
self.spike_history = []
self.window_size = 100 # ms
def measure_sparsity(self, recent_spikes):
"""Calculate spike density in recent window"""
self.spike_history.extend(recent_spikes)
# Keep only spikes in window
cutoff = self.spike_history[-1] - self.window_size/1000 if self.spike_history else 0
self.spike_history = [s for s in self.spike_history if s > cutoff]
# Calculate sparsity (spikes per second)
sparsity = len(self.spike_history) / self.window_size * 1000
return sparsity
def adapt_parameters(self, sparsity):
"""Adapt transmission based on sparsity"""
if sparsity < 10: # Very sparse
# Reduce power, increase integration time
return {: , : }
sparsity < :
{: , : }
:
{: , : , : }
| Metric | Traditional Radio | Sparsity-Aware IR | Improvement |
|---|---|---|---|
| Power (sparse) | 10 mW | 0.5 mW | 20x |
| Power (dense) | 10 mW | 12 mW | Similar |
| Latency | 10 ms | 1 μs | 10000x |
| Range | 100 m | 10 m | Trade-off |
| Bandwidth | 1 Mbps | 10 Mbps | 10x |
Multi-Path Interference
Synchronization
Packet Loss Impact
Regulatory Compliance
@article{wang2026sparsity,
title={Sparsity-Aware Event-Driven Impulse Radio Transceivers for Reliable Neuromorphic Inference},
author={Wang, Yuanxun and Hamed, Ahmed and El-Hadedy, Mohamed and Zhong, Zhanwei},
journal={arXiv preprint arXiv:2604.23559},
year={2026}
}