模拟两个神经元的连接，突触前神经元分别传递兴奋性和抑制性信号给突触后神经元（神经元模型使用HH方程）

一、实验内容

模拟两个神经元的连接，突触前神经元分别传递兴奋性和抑制性信号给突触后神经元。

二、实验结果：

兴奋性：

​​​​​​​

 

图 1 兴奋性

抑制性：

 

图 2 抑制性

• 代码

运行mimi.py，其中type为0是抑制性，type为1是兴奋性

Neuron.py

# -*- coding: utf-8 -*-
"""
Created on Thu Sep 29 19:19:23 2022

@author: dell2
"""
import numpy as np
import matplotlib.pyplot as plt
from Synapsis import Synapsis as Syn
 
class Neuron():
    def __init__(self, I):
        self.gl = 0.3
        self.gk = 36.0
        self.gna = 120.0
        self.El = -54.4
        self.Ek = -77.0
        self.Ena = 50.0
        self.Cm = 1.0
        self.V0 = -65.0
 
        self.step = 0.01
        self.iter = int(100/self.step)
        self.I = I
        self.t = np.zeros(int(self.iter)+1)
        self.V = np.zeros(int(self.iter)+1)
        self.V[0] = self.V0
        self.am = 0.1 * (self.V[0] + 40) / (1 - np.exp(-(self.V[0] + 40) / 10))
        self.bm = 4 * np.exp(-(self.V[0] + 65) / 18)
        self.ah = 0.07 * np.exp(-(self.V[0] + 65) / 20)
        self.bh = 1 / (np.exp(-(self.V[0] + 35) / 10) + 1)
        self.an = 0.01 * (self.V[0] + 55) / (1 - np.exp(-(self.V[0] + 55) / 10))
        self.bn = 0.125 * np.exp(-(self.V[0] + 65) / 80)
 
        self.m = self.am / (self.am + self.bm)
        self.h = self.ah / (self.ah + self.bh)
        self.n = self.an / (self.an + self.bn)
 
    def oula(self):
        for i in range(int(self.iter)):
            self.t[i] = i * self.step  
            self.V[i + 1] = self.V[i] + self.step * (
                        (-self.gl * (self.V[i] - self.El) - self.gna * self.m ** 3 * self.h * (self.V[i] - self.Ena)
                         - self.gk * self.n ** 4 * (self.V[i] - self.Ek) + self.I[i]) / self.Cm)
            
            self.am = 0.1 * (self.V[i + 1] + 40) / (1 - np.exp(-(self.V[i + 1] + 40) / 10))
            self.bm = 4 * np.exp(-(self.V[i + 1] + 65) / 18)
            self.ah = 0.07 * np.exp(-(self.V[i + 1] + 65) / 20)
            self.bh = 1 / (np.exp(-(self.V[i + 1] + 35) / 10) + 1)
            self.an = 0.01 * (self.V[i + 1] + 55) / (1 - np.exp(-(self.V[i + 1] + 55) / 10))
            self.bn = 0.125 * np.exp(-(self.V[i + 1] + 65) / 80)
            
            self.m = self.m + self.step * (self.am * (1 - self.m) - self.bm * self.m)
            self.h = self.h + self.step * (self.ah * (1 - self.h) - self.bh * self.h)
            self.n = self.n + self.step * (self.an * (1 - self.n) - self.bn * self.n)
 
        return self.t[0:self.iter], self.V[0:self.iter]
 
       
 
    def spike(self,type):
        ts = []
        for i in range(int(self.iter)):
            self.t[i] = i * self.step  
            self.V[i + 1] = self.V[i] + self.step * (
                        (-self.gl * (self.V[i] - self.El) - self.gna * self.m ** 3 * self.h * (self.V[i] - self.Ena)
                         - self.gk * self.n ** 4 * (self.V[i] - self.Ek) + self.I[i]) / self.Cm)
            self.am = 0.1 * (self.V[i + 1] + 40) / (1 - np.exp(-(self.V[i + 1] + 40) / 10))
            self.bm = 4 * np.exp(-(self.V[i + 1] + 65) / 18)
            self.ah = 0.07 * np.exp(-(self.V[i + 1] + 65) / 20)
            self.bh = 1 / (np.exp(-(self.V[i + 1] + 35) / 10) + 1)
            self.an = 0.01 * (self.V[i + 1] + 55) / (1 - np.exp(-(self.V[i + 1] + 55) / 10))
            self.bn = 0.125 * np.exp(-(self.V[i + 1] + 65) / 80)
            self.m = self.m + self.step * (self.am * (1 - self.m) - self.bm * self.m)
            self.h = self.h + self.step * (self.ah * (1 - self.h) - self.bh * self.h)
            self.n = self.n + self.step * (self.an * (1 - self.n) - self.bn * self.n)
 
            
            if i != 0:
                if self.V[i] > self.V[i-1] and self.V[i] > self.V[i+1]:
                    ts.append(self.t[i])
        I,g,t = Syn(type, ts, self.step).oula()
        return I,g,t
        

Synapsis.py

# -*- coding: utf-8 -*-
"""
Created on Fri Sep 30 15:47:51 2022

@author: dell2
"""
import numpy as np
 
class Synapsis():
    def __init__(self, type, ts, step):
        self.type = type
        self.ts = ts
        if type == 1:
            self.Esyn = 0 # 抑制性的为-50 兴奋性的为0
        else:
            self.Esyn = -80
 
        self.V0 = -65 # 突触受体公式上的V要与后面神经元的V相等，这在生物学上也是成立的
        self.step = step # 步长0.01 ms
        self.iter = int(100/self.step) # 计算1ms的时间
 
        self.t = np.zeros(self.iter + 1)
        self.g = np.zeros(self.iter + 1)
        self.g[0] = 0
        self.I = np.zeros(self.iter + 1)
        self.I[0] = 0
    def oula(self):
        g_result = []
        for j in range(len(self.ts)):
            for i in range(self.iter):
                self.t[i] = i * self.step
                self.g[i+1] = 0.1 * (self.t[i] - self.ts[j]) / 5 * np.exp(-(self.t[i] - self.ts[j]) / 5)
            for i in range(self.iter):
                if self.g[i] < 0:
                    self.g[i] = 0
            import copy
            g_result.append(copy.deepcopy(self.g))
        gl = g_result[0]
        for i in range(len(g_result)):
            if i == 0:
                continue
            gl += g_result[i]
            self.g = gl
        for i in range(self.iter):
            self.I[i] = -self.g[i]*(self.V0 - self.Esyn) * 10
        return self.I[0:self.iter],self.g[0:self.iter],self.t[0:self.iter]

mimi.py

# -*- coding: utf-8 -*-
"""
Created on Fri Sep 30 15:49:12 2022

@author: dell2
"""
import Neuron
import matplotlib.pyplot as plt
import numpy as np
 
type = 0
I = [30] * 10000
neuron1 = Neuron.Neuron(I)
t1,v1 = neuron1.oula()
I,g,t = neuron1.spike(type)
neuron2 = Neuron.Neuron(I)
t2,v2 = neuron2.oula()

fig, ax = plt.subplots(4,1)
plt.subplots_adjust(hspace=1)
ax[0].plot(t1,v1)
ax[0].set_title('First')
ax[0].set_xlabel('t(ms)')
ax[0].set_ylabel('v(mV)')

if type == 1:
    v2[0:500] = v2[501]
ax[1].plot(t2,v2)
ax[1].set_title('Second')
ax[1].set_xlabel('t(ms)')
ax[1].set_ylabel('v(mV)')
ax[2].plot(t,g)
ax[2].set_title('Conductive')
ax[2].set_xlabel('t(ms)')
ax[2].set_ylabel('g(s/m)')
ax[3].plot(t,I)
ax[3].set_title('Isyn')
ax[3].set_xlabel('t(ms)')
ax[3].set_ylabel('I(mA)')
plt.show()