菜单
Learning Hybrid Biophysical Neuron Models with Neural ODEs — combining mechanistic biophysical models with machine learning for accurate and efficient neuron dynamics modeling
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/hiyenwong/ai_collection --skill hybrid-biophysical-neuron-models-neural-odes命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| name | hybrid-biophysical-neuron-models-neural-odes |
| trigger_words | ["biophysical neuron model","neural ODE","hybrid model","neuron dynamics","Hodgkin-Huxley","conductance-based model","neural ordinary differential equations","parameter inference","neuron model fitting","mechanistic model","data-driven neuron","neuron simulation"] |
| activation_score | 0.85 |
| description | Learning Hybrid Biophysical Neuron Models with Neural ODEs — combining mechanistic biophysical models with machine learning for accurate and efficient neuron dynamics modeling |
| authors | Jonas Beck, Michael Deistler, Dóra Viktória Molnár, Jakob H. Macke, Philipp Berens |
| date_added | 2026-06-17T00:00:00.000Z |
| arxiv_id | 2606.16693 |
| source | arXiv q-bio.NC |
| tags | ["computational neuroscience","neural ODE","biophysical modeling","parameter inference","neuron dynamics","machine learning","simulation","Hodgkin-Huxley"] |
Learning Hybrid Biophysical Neuron Models with Neural ODEs methodology — integrating mechanistic biophysical neuron models with neural ordinary differential equations for accurate, efficient, and interpretable neuron dynamics simulation and parameter inference.
This approach bridges the gap between:
Key Insight: Biophysical neuron models (Hodgkin-Huxley type) can be formulated as Neural ODEs, enabling:
Model Components:
# Hybrid biophysical neuron model structure
class HybridBiophysicalNeuron(nn.Module):
"""
Biophysical neuron model parameterized as Neural ODE
Combines mechanistic equations with data-driven flexibility
"""
def __init__(self, model_type='HH', num_channels=4):
super().__init__()
# Biophysical parameters (interpretable)
# - Membrane capacitance C_m
# - Channel conductances g_Na, g_K, g_L
# - Reversal potentials E_Na, E_K, E_L
# - Gating kinetics parameters
if model_type == 'Hodgkin-Huxley':
self.params = nn.ParameterDict({
'C_m': nn.Parameter(torch.tensor(1.0)),
'g_Na': nn.Parameter(torch.tensor()),
: nn.Parameter(torch.tensor()),
: nn.Parameter(torch.tensor()),
: nn.Parameter(torch.tensor()),
: nn.Parameter(torch.tensor(-)),
: nn.Parameter(torch.tensor(-))
})
Advantages of Neural ODE formulation:
from torchdiffeq import odeint_adjoint
class NeuronODENetwork(nn.Module):
"""
Neural ODE network for biophysical neuron simulation
"""
def __init__(self, neuron_model, solver='dopri5', rtol=1e-3, atol=1e-6):
super().__init__()
self.neuron = neuron_model
self.solver = solver
self.rtol = rtol
self.atol = atol
def simulate(self, initial_state, t_span, I_inj):
"""
Simulate neuron dynamics over time span
Args:
initial_state: Initial [V, m, h, n] values
t_span: Time points to evaluate
I_inj: Injected current (can be time-varying)
Returns:
state_trajectory: Neuron state at each time point
"""
# Use adjoint method for gradient computation
trajectory = odeint_adjoint(
self.neuron,
initial_state,
t_span,
method=self.solver,
options={'rtol': self.rtol, 'atol': self.atol}
)
return trajectory
Key Innovation: Gradient-based optimization of biophysical parameters
class ParameterInference:
"""
Gradient-based parameter inference for hybrid neuron models
"""
def __init__(self, model, optimizer='Adam', lr=0.01):
self.model = model
self.optimizer = optim.Adam(model.parameters(), lr=lr)
def fit(self, data_voltage, data_time, I_inj, num_epochs=1000):
"""
Infer biophysical parameters from voltage recordings
Args:
data_voltage: Observed membrane voltage trace
data_time: Time points of observations
I_inj: Applied current during recording
Returns:
inferred_params: Optimized biophysical parameters
"""
initial_state = self._estimate_initial_state(data_voltage)
for epoch in range(num_epochs):
self.optimizer.zero_grad()
# Simulate with current parameters
trajectory = self.model.simulate(initial_state, data_time, I_inj)
simulated_voltage = trajectory[:, 0]
# Loss: match simulated to observed voltage
loss = F.mse_loss(simulated_voltage, data_voltage)
# Optional: regularization on parameter ranges
loss += self._parameter_regularization()
loss.backward()
self.optimizer.step()
# Enforce biophysical constraints
self._apply_constraints()
return self.model.params
Combining mechanistic and data-driven components:
class HybridFlexibleNeuron(nn.Module):
"""
Truly hybrid model: mechanistic core + data-driven corrections
"""
def __init__(self, base_model='HH', correction_network='MLP'):
super().__init__()
# Mechanistic biophysical model
self.biophysical = HodgkinHuxleyModel()
# Data-driven correction network
# Captures dynamics not captured by mechanistic model
self.correction = nn.Sequential(
nn.Linear(4, 32), # V, m, h, n
nn.Tanh(),
nn.Linear(32, 32),
nn.Tanh(),
nn.Linear(32, 4) # Correction to dV, dm, dh, dn
)
# Balancing parameter (mechanistic vs data-driven)
self.alpha = nn.Parameter(torch.tensor(0.8)) # Start with 80% mechanistic
Use Case: Identify neuron type from electrophysiological recordings
# Infer parameters and classify neuron type
params = inference.fit(voltage_trace, time, current)
# Parameter signatures for different neuron types
neuron_signatures = {
'pyramidal': {'g_Na': 120, 'g_K': 36, 'g_L': 0.3},
'interneuron': {'g_Na': 100, 'g_K': 40, 'g_L': 0.2},
'Purkinje': {'g_Na': 150, 'g_K': 50, 'g_L': 0.4}
}
# Match inferred parameters to signatures
neuron_type = match_parameters(params, neuron_signatures)
Use Case: Predict drug effects on neuron dynamics
# Drug effects as parameter modifications
drug_effects = {
'TTX': {'target': 'g_Na', 'effect': 'block', 'factor': 0.0},
'TEA': {'target': 'g_K', 'effect': 'block', 'factor': 0.5},
'4-AP': {'target': 'g_K', 'effect': 'block', 'factor': 0.3}
}
# Simulate drug effect
def apply_drug(model, drug_name, concentration):
effect = drug_effects[drug_name]
original_value = model.params[effect['target']].data
if effect['effect'] == 'block':
modified_value = original_value * effect['factor'] * (1 - concentration)
model.params[effect['target']].data = modified_value
return model.simulate(initial_state, t_span, I_inj)
Use Case: Build networks with heterogeneous neurons
class NeuronNetwork:
"""
Network of hybrid biophysical neurons
"""
def __init__(self, num_neurons, connectivity_matrix):
# Create heterogeneous neurons
self.neurons = [
HybridBiophysicalNeuron(randomize_params=True)
for _ in range(num_neurons)
]
self.connectivity = connectivity_matrix
def simulate_network(self, duration, inputs):
"""
Simulate network dynamics
Key advantage: each neuron has interpretable parameters
but gradient-based fitting for connectivity
"""
states = torch.zeros(num_neurons, 4)
for t in time_points:
# Compute synaptic inputs from connectivity
synaptic_currents = self.connectivity @ spike_output(states)
# Update each neuron
for i, neuron in enumerate(self.neurons):
I_total = inputs[i] + synaptic_currents[i]
states[i] = neuron.step(states[i], I_total)
return states
# Core libraries
import torch
import torch.nn as nn
import torch.optim as optim
from torchdiffeq import odeint, odeint_adjoint
# Specialized packages
import jax.numpy as jnp # JAX version for faster gradients
from jax.experimental.ode import odeint
# Neuroscience packages
import neuron # NEURON simulator for validation
import brian2 # Brian2 for network simulations
| Framework | Pros | Cons |
|---|---|---|
| torchdiffeq | Easy PyTorch integration | Slower for large networks |
| JAX odeint | Fast gradients, JIT compilation | More setup complexity |
| NEURON | Biophysical detail, validated | No gradient support |
| Brian2 | Network simulation, code generation | Limited ODE flexibility |
Activation: Use this skill when modeling neuron dynamics, fitting neuron models to data, combining biophysical and data-driven approaches, or need interpretable neuron parameters with gradient-based optimization.