用python模拟神经元尖峰序列

我正在研究的模型有一个神经元（由霍奇金-赫胥黎方程建模），神经元本身接收来自其他神经元的一系列突触输入，因为它在一个网络中。对输入进行建模的标准方法是使用由一束以指定速率到达的δ函数脉冲组成的尖峰序列，作为泊松过程。一些脉冲向神经元提供兴奋性反应，一些脉冲提供抑制性脉冲。所以突触电流应该是这样的：

在这里，Ne是兴奋性神经元的数量，Ni是抑制性的，h是0或1（概率p为1），表示是否成功传输了一个峰值，δ函数中的$t_k^l$是第k个神经元的第l个峰值的放电时间（与$t_m^n$相同）。所以我们尝试编码的基本思想是假设首先我有100个神经元向我的HH神经元提供脉冲（80个是兴奋性的，20个是抑制性的）。然后我们形成了一个数组，其中一列列出了神经元（因此，神经元#0-79是兴奋性的，而#80-99是抑制性的）。然后我们检查在某个时间间隔内是否有尖峰，如果有，选择一个0-1之间的随机数，如果它低于我指定的概率p，则将其指定为数字1，否则将其设置为0。然后，我们将电压绘制为时间的函数，以观察神经元何时出现峰值

我认为代码是可行的，但问题是，只要我在网络中添加更多的神经元（一篇论文称他们总共使用了5000个神经元），它就永远无法运行，这对于进行数值模拟来说是不可行的。我的问题是：有没有更好的方法来模拟脉冲进入神经元的尖峰序列，从而使网络中大量神经元的计算速度大大加快？下面是我们尝试的代码：（有点长，因为HH方程非常详细）：

将scipy作为sp导入
将numpy作为np导入
导入pylab作为plt
#常数
C_m=1.0#膜电容，单位为uF/cm^2“”
g_Na=120.0钠（Na）最大电导，单位为mS/cm^2“
g_K=36.0#后硅（K）最大电导，单位为mS/cm^2“”
g_L=0.3#泄漏最大电导，单位为mS/cm^2“”
E_Na=50.0钠（Na）能斯特反转电位，单位为mV
E_K=-77.0#后（K）能斯特反转电位，单位为mV
E_L=-54.387#泄漏能斯特反转电位，单位为mV“”
def泊松峰值（t，N=100，速率=1.0）：
spks=[]
dt=t[1]-t[0]
对于范围内的n（n）：
spkt=t[np.random.rand（len（t））0：
附加（spkn）
spks=np。连接（spks，轴=0）
返回SPK
N=100
N_ex=80（0..79）
N_in=20（80..99）
G_ex=1.0
K=4
dt=0.01
t=sp.arange（0.0，300.0，dt）#积分超过“”的时间
ic=[-65,0.05,0.6,0.32]
spks=泊松峰（t，N，速率=10。）
defαm（V）：
返回0.1*（V+40.0）/（1.0-sp.exp（-（V+40.0）/10.0））
def beta_m（V）：
返回4.0*sp.exp（-V+65.0）/18.0）
def alpha_h（V）：
返回0.07*sp.exp（-V+65.0）/20.0）
def beta_h（V）：
回报率1.0/（1.0+sp.exp（-（V+35.0）/10.0））
defαn（V）：
返回0.01*（V+55.0）/（1.0-sp.exp（-（V+55.0）/10.0））
defβn（V）：
返回0.125*sp.exp（-V+65）/80.0）
定义I_Na（V，m，h）：
返回g_Na*m**3*h*（V-E_Na）
定义I_K（V，n）：
返回g_K*n**4*（V-E_K）
定义I_L（V）：
返回g_L*（V-E_L）
def I_应用程序（t）：
返回3
def I_syn（spks，t）：
"""
突触电流
spks=[[synid，t]，]
"""
exspk=spks[spks[：，0]0:
h_k=np.random.rand（len（delta_k））<0.5#p=0.5
其他：
h_k=0
inspk=spks[spks[：，0]>=N#u ex]#检查剩余神经元是否存在抑制性尖峰
delta#m=inspk[：，1]==t#抑制神经元的delta功能
如果总和（δm）>0：
h_m=np.random.rand（len（delta_m））<0.5#p=0.5
其他：
h_m=0
isyn=C_m*G_ex*（np.sum（h_k*delta_k）-k*np.sum（h_m*delta_m））
返回isyn
def dALLdt（X，t）：
五、 m，h，n=X
dVdt=（I_app（t）+I_syn（spk，t）-I_Na（V，m，h）-I_K（V，n）-I_L（V））/cm
dmdt=αμm（V）*（1.0-m）-βμm（V）*m
dhdt=αh（V）*（1.0-h）-βh（V）*h
dndt=αn（V）*（1.0-n）-βn（V）*n
返回np.数组（[dVdt，dmdt，dhdt，dndt]）
X=[ic]
对于t[1:]中的i：
dx=（dALLdt（X[-1]，i））
x=x[-1]+dt*dx
X.append（X）
X=np.数组（X）
V=X[：，0]
m=X[：，1]
h=X[：，2]
n=X[：，3]
ina=I_Na（V，m，h）
ik=I_K（V，n）
il=I_L（V）
plt.图（）
plt.子地块（3,1,1）
plt.title（‘霍奇金-赫胥黎神经元’）
plt.绘图（t，V，'k'）
plt.ylabel（'V（mV）'
plt.子地块（3,1,2）
plt.plot（t，ina，'c'，label='I{Na}$'）
plt.plot（t，ik，'y'，label='I{K}$'）
plt.plot（t，il，'m'，label='I{L}$'）
plt.ylabel（'当前'）
plt.legend（）
plt.子地块（3,1,3）
plt.plot（t，m，'r'，label='m'）
plt.plot（t，h，'g'，label='h'）
plt.绘图（t，n，'b'，label='n'）
plt.ylabel（'选通值'）
plt.legend（）
plt.show（）

---

我不熟悉其他专门为神经网络设计的软件包，但我想写我自己的，主要是因为我计划做随机分析，这需要相当多的数学细节，我不知道这些软件包是否提供了这样的细节。

分析表明，您的大部分时间都花在这两行上：

    if sum(delta_k) > 0:

及

将其中每一项更改为：

    if np.any(...)

将所有速度提高10倍。如果您想进行更多逐行分析，请查看kernprof：

---

作为对welch答案的补充，您可以使用

scipy.integrate.odeint

加速集成：替换

X = [ic]
for i in t[1:]:
    dx = (dALLdt(X[-1],i))
    x = X[-1]+dt*dx
    X.append(x)

借

在我的计算机上，计算速度提高10以上。

如果您有NVidia g

    if np.any(...)

X = [ic]
for i in t[1:]:
    dx = (dALLdt(X[-1],i))
    x = X[-1]+dt*dx
    X.append(x)

from scipy.integrate import odeint
X=odeint(dALLdt,ic,t)