メニュー
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コマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？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 | 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>