Skip to main content Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/hiyenwong/ai_collection --skill hybrid-biophysical-neuron-models-neural-odesDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... Mehr aus diesem Repository
Verwandte Berufe SOC
Basierend auf der SOC-Berufsklassifikation
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
Overview
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:
Mechanistic models : Hodgkin-Huxley type models with interpretable parameters but computationally expensiveData-driven models : Neural networks that are flexible but lack interpretabilityHybrid models : Combine the best of both worlds
Core Methodology
1. Hybrid Biophysical Neuron Model Architecture
Key Insight : Biophysical neuron models (Hodgkin-Huxley type) can be formulated as Neural ODEs, enabling:
Gradient-based parameter inference
Efficient simulation via adaptive solvers
Integration with deep learning frameworks
Preserved interpretability of biophysical parameters
Model Components :
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__()
if model_type == 'Hodgkin-Huxley' :
self .params = nn.ParameterDict({
'C_m' : nn.Parameter(torch.tensor(1.0 )),
'g_Na' : nn.Parameter(torch.tensor(120.0
'g_K'
36.0
'g_L'
0.3
'E_Na'
50.0
'E_K'
77.0
'E_L'
54.4
2. Neural ODE Solver Integration Advantages of Neural ODE formulation :
Adaptive timestep : ODE solvers adapt to dynamics complexityMemory efficient : No need to store intermediate statesGradient computation : Adjoint sensitivity method for gradientsFlexible integration : Works with any ODE solver (RK4, Dormand-Prince, etc.) 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
"""
trajectory = odeint_adjoint(
self .neuron,
initial_state,
t_span,
method=self .solver,
options={'rtol' : self .rtol, 'atol' : self .atol}
)
return trajectory
3. Parameter Inference via Gradient Descent 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()
trajectory = self .model.simulate(initial_state, data_time, I_inj)
simulated_voltage = trajectory[:, 0 ]
loss = F.mse_loss(simulated_voltage, data_voltage)
loss += self ._parameter_regularization()
loss.backward()
self .optimizer.step()
self ._apply_constraints()
return self .model.params
4. Hybrid Flexibility: Data-Driven Extensions 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__()
self .biophysical = HodgkinHuxleyModel()
self .correction = nn.Sequential(
nn.Linear(4 , 32 ),
nn.Tanh(),
nn.Linear(32 , 32 ),
nn.Tanh(),
nn.Linear(32 , 4 )
)
self .alpha = nn.Parameter(torch.tensor(0.8 ))
Application Scenarios
1. Neuron Type Classification Use Case : Identify neuron type from electrophysiological recordings
params = inference.fit(voltage_trace, time, current)
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 }
}
neuron_type = match_parameters(params, neuron_signatures)
2. Drug Effect Modeling Use Case : Predict drug effects on neuron dynamics
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 }
}
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)
3. Multi-Neuron Network Simulation Use Case : Build networks with heterogeneous neurons
class NeuronNetwork :
"""
Network of hybrid biophysical neurons
"""
def __init__ (self, num_neurons, connectivity_matrix ):
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:
synaptic_currents = self .connectivity @ spike_output(states)
for i, neuron in enumerate (self .neurons):
I_total = inputs[i] + synaptic_currents[i]
states[i] = neuron.step(states[i], I_total)
return states
Key Advantages
1. Interpretability Preserved
Biophysical meaning : Parameters have clear biological interpretationMechanistic insights : Can explain dynamics in terms of ion channelsValidation : Parameters can be compared to literature values
2. Computational Efficiency
Adaptive solvers : ODE solvers adapt to dynamics complexityGPU acceleration : Neural ODE frameworks support GPUMemory efficient : Adjoint method doesn't store intermediate states
3. Flexibility
Data-driven corrections : Add neural network for missing dynamicsMulti-scale : Can model single neuron or networksDrug modeling : Parameters can be modified for drug effects
4. Gradient-Based Inference
Faster fitting : Gradient descent vs manual parameter searchUncertainty : Can use Bayesian extensions for parameter uncertaintyInverse problems : Solve for parameters from observed dynamics
Pitfalls and Best Practices
Pitfalls
Parameter unidentifiability : Multiple parameter sets may produce similar dynamicsNumerical instability : Fast dynamics may require small timestepsOverfitting correction network : Data-driven part may dominate mechanisticInitialization sensitivity : Poor initial parameters may trap optimization
Best Practices
Regularization : Add constraints on parameter rangesMulti-objective fitting : Fit multiple voltage traces simultaneouslyParameter bounds : Enforce biophysical constraints after each updateValidation : Compare inferred parameters to literature valuesStart simple : Begin with standard HH model before adding complexity
Implementation Libraries
Python Packages
import torch
import torch.nn as nn
import torch.optim as optim
from torchdiffeq import odeint, odeint_adjoint
import jax.numpy as jnp
from jax.experimental.ode import odeint
import neuron
import brian2
Framework Comparison 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
References and Further Reading
Key Papers
Chen et al. (2018) : "Neural Ordinary Differential Equations" - Foundation of Neural ODEsHodgkin & Huxley (1952) : Original HH model - Basis for biophysical modelsBeck et al. (2026) : This paper - Hybrid methodology
Related Methodologies
Neural ODEs : Continuous-depth neural networksConductance-based models : HH and extensionsParameter inference : Gradient-based and Bayesian methodsNeuron simulation : NEURON, Brian2, NEST simulators
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.
