菜单
Spiking Temporal Memory (sTM) model for learning sequence timing and control of replay speed in networks of spiking neurons
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/hiyenwong/ai_collection --skill spiking-temporal-memory-stm-sequence-timing命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| name | spiking-temporal-memory-stm-sequence-timing |
| description | Spiking Temporal Memory (sTM) model for learning sequence timing and control of replay speed in networks of spiking neurons |
| version | 1.0.0 |
| author | Neuroscience Cron Job |
| created | 2026-06-09T00:00:00.000Z |
| arxiv_id | 2605.22523v1 |
| paper_title | Learning sequence timing and control of replay speed in networks of spiking neurons |
| paper_date | 2026-05-21T00:00:00.000Z |
| activation_keywords | ["spiking temporal memory","sTM model","sequence timing","replay speed control","oscillatory clock signal","working memory","spiking neural network","sequence processing","time representation"] |
该方法论扩展了 Spiking Temporal Memory (sTM) 模型，使其能够学习序列元素的精确时序，并通过振荡背景输入灵活控制序列重放速度。核心创新在于提出了一种机制：序列元素的持续时间通过元素特异性神经元群体的顺序激活表示，实现了跨广泛时间尺度的序列编码和重放。
序列元素表示：
原始模型的局限：
关键洞察：
机制示意：
序列元素 A (持续时间 = 3个时间单位):
- 子状态 A_1: 神经群体 G1 发放
- 子状态 A_2: 神经群体 G2 发放
- 子状态 A_3: 神经群体 G3 发放
序列元素 B (持续时间 = 2个时间单位):
- 子状态 B_1: 神经群体 G4 发放
- 子状态 B_2: 神经群体 G5 发放
神经网络架构：
import nest # NEST simulator for spiking neural networks
class STMWithTiming:
"""
扩展的 sTM 模型支持时序编码
Attributes:
element_neurons: 元素识别神经元群体
timing_neurons: 时序编码神经元群体
sequence_memory: 序列记忆连接矩阵
"""
def __init__(self, n_elements, max_duration=10):
"""
Args:
n_elements: 序列元素数量
max_duration: 最大持续时间单位
"""
self.n_elements = n_elements
self.max_duration = max_duration
# 创建神经元群体
self.element_neurons = nest.Create(
'iaf_psc_alpha',
n=n_elements * max_duration # 每个元素有 max_duration 个时序神经元
)
# 连接模式：顺序激活
.setup_timing_connections()
():
elem_idx (.n_elements):
base_idx = elem_idx * .max_duration
t (.max_duration - ):
nest.Connect(
.element_neurons[base_idx + t],
.element_neurons[base_idx + t + ],
syn_spec={: , : }
)
():
idx, (elem_id, duration) (sequence):
t (duration):
neuron_idx = elem_id * .max_duration + t
nest.SetStatus(
.element_neurons[neuron_idx],
{: -}
)
核心发现：
振荡输入建模：
import numpy as np
def oscillatory_clock_signal(frequency, amplitude, duration):
"""
生成振荡时钟信号
Args:
frequency: 振荡频率 (Hz)
amplitude: 振荡幅度
duration: 信号持续时间 (s)
Returns:
signal: 振荡信号时间序列
"""
time = np.linspace(0, duration, int(duration * 1000))
# 正弦振荡
signal = amplitude * np.sin(2 * np.pi * frequency * time)
return signal
def inject_oscillation(neurons, oscillation_params):
"""
向神经元群体注入振荡背景输入
Args:
neurons: NEST 神经元群体
oscillation_params: {
'frequency': 振荡频率,
'amplitude': 幅度,
'phase': 相位
}
"""
# 创建振荡输入发生器
oscillation_generator = nest.Create(
'ac_generator',
params={
'amplitude': oscillation_params['amplitude'],
'frequency': oscillation_params['frequency'],
'phase': oscillation_params['phase']
}
)
# 连接到神经元群体
nest.Connect(
oscillation_generator,
neurons,
syn_spec={'weight': 1.0}
)
速度控制原理：
生物对应：
学习阶段：
def learn_sequence_with_timing(sequence_data, stm_model):
"""
学习带时序的序列
Args:
sequence_data: 输入序列数据（包含元素和持续时间）
stm_model: sTM 模型实例
Returns:
learned_weights: 学习到的连接权重
"""
# 阶段 1: 元素顺序学习
for i in range(len(sequence_data) - 1):
current_elem = sequence_data[i][0]
next_elem = sequence_data[i + 1][0]
# 建立元素间的预测连接
stm_model.connect_elements(current_elem, next_elem)
# 阶段 2: 时序编码学习
for elem_id, duration in sequence_data:
# 学习持续时间表示
stm_model.encode_duration(elem_id, duration)
# 阶段 3: 通过 STDP 优化连接
stm_model.optimize_connections(stdp_rule='stdp')
return stm_model.get_weights()
重放阶段：
def replay_sequence(stm_model, speed_factor=1.0):
"""
以指定速度重放序列
Args:
stm_model: 已学习的 sTM 模型
speed_factor: 重放速度倍率 (0.5x, 1x, 2x, etc.)
Returns:
replay_pattern: 重放的脉冲模式
"""
# 计算振荡频率
base_frequency = 40.0 # Hz (gamma band)
oscillation_frequency = base_frequency * speed_factor
# 注入振荡时钟信号
stm_model.inject_clock_signal(
frequency=oscillation_frequency,
amplitude=1.0
)
# 触发序列重放（从第一个元素开始）
stm_model.trigger_replay(start_element=0)
# 记录脉冲活动
spike_recorder = nest.Create('spike_recorder')
nest.Connect(stm_model.element_neurons, spike_recorder)
# 运行模拟
nest.Simulate(1000.0) # 1秒
# 获取重放模式
spikes = nest.GetStatus(spike_recorder, 'events')[0]
return spikes
关键特性：
时空模式可视化：
import matplotlib.pyplot as plt
def visualize_spatiotemporal_pattern(spike_events, n_neurons):
"""
可视化稀疏时空发放模式
Args:
spike_events: NEST spike_recorder events
n_neurons: 神经元数量
"""
times = spike_events['times']
neurons = spike_events['senders']
# 创建 raster plot
plt.figure(figsize=(12, 8))
plt.scatter(times, neurons, s=1, c='black', marker='.')
plt.xlabel('Time (ms)')
plt.ylabel('Neuron ID')
plt.title('Sparse Spatiotemporal Pattern: Time Encoding')
plt.grid(True, alpha=0.3)
plt.show()
def analyze_pattern_sparsity(spike_events, time_window):
"""
分析时空模式的稀疏度
Returns:
sparsity_ratio: 稀疏度比例
"""
times = spike_events['times']
# 计算每个时间窗口的活跃神经元比例
window_activity = []
for t_start in range(0, max(times), time_window):
window_spikes = [s for s in times if t_start <= s < t_start + time_window]
activity_ratio = len(window_spikes) / n_neurons
window_activity.append(activity_ratio)
sparsity_ratio = 1 - np.mean(window_activity)
return sparsity_ratio
测试任务：
评估指标：
def evaluate_timing_accuracy(learned_sequence, target_sequence):
"""
评估时序学习准确度
Returns:
timing_error: 时序误差 (ms)
order_accuracy: 顺序准确度
"""
timing_errors = []
for i in range(len(target_sequence)):
target_duration = target_sequence[i][1]
learned_duration = learned_sequence[i][1]
error = abs(target_duration - learned_duration)
timing_errors.append(error)
return {
'mean_timing_error': np.mean(timing_errors),
'max_timing_error': np.max(timing_errors),
'order_accuracy': evaluate_order(learned_sequence, target_sequence)
}
测试条件：
预期结果：
测试范围：
验证维度：
完整模型代码：
import nest
import numpy as np
class STMCompleteModel:
"""
完整的 sTM 时序模型实现
"""
def __init__(self, config):
# 初始化 NEST
nest.ResetKernel()
nest.SetKernelStatus({
'resolution': 0.1, # 0.1 ms
'local_num_threads': 4
})
# 网络参数
self.n_elements = config['n_elements']
self.max_duration = config['max_duration']
# 创建神经元
self.create_neurons()
# 创建连接
self.create_connections()
# 创建记录器
self.create_recorders()
def create_neurons(self):
"""
创建神经元群体
"""
# 时序编码神经元
self.timing_neurons = nest.Create(
'iaf_psc_alpha',
n=self.n_elements * self.max_duration,
params={
'V_th': -50.0,
'V_reset': -70.0,
'tau_m': 20.0,
'C_m': 250.0
}
)
# 振荡时钟输入
self.clock_generator = nest.Create(
'ac_generator',
params={'amplitude': 1.0, 'frequency': 40.0}
)
def create_connections(self):
"""
建立网络连接
"""
# 时序顺序连接
for elem in range(self.n_elements):
for t in range(self.max_duration - 1):
nest.Connect(
self.timing_neurons[elem * self.max_duration + t],
self.timing_neurons[elem * self.max_duration + t + 1],
syn_spec={'weight': 2.0, 'delay': 1.0}
)
# 振荡时钟注入
nest.Connect(
self.clock_generator,
self.timing_neurons,
syn_spec={'weight': 1.0}
)
def create_recorders(self):
"""
创建记录设备
"""
self.spike_recorder = nest.Create('spike_recorder')
nest.Connect(self.timing_neurons, self.spike_recorder)
def run_simulation(self, duration):
"""
运行模拟
"""
nest.Simulate(duration)
spikes = nest.GetStatus(self.spike_recorder, 'events')[0]
return spikes
<!-- NeuroML 定义 -->
<neuroml xmlns="http://www.neuroml.org/schema/neuroml2">
<network id="STMWithTiming">
<population id="timing_neurons" component="iaf" size="100"/>
<continuousConnection id="timing_chain">
<!-- 时序顺序连接 -->
<from population="timing_neurons" cell="0"/>
<to population="timing_neurons" cell="1"/>
<synapse component="excitatory"/>
</continuousConnection>
<inputList id="oscillatory_clock">
<input id="clock_0" target="timing_neurons[0]" component="oscillation"/>
</inputList>
</network>
</neuroml>