def Jeff_t(Wrr, Wrh, Whr, Whh, phi_h):
import numpy as np
par = params_Gaussian.params_Gaussian()
N = par.N
Nhid = par.Nhid
Nrec = par.Nrec
tau = par.tau
Tmax = 20. * tau
dt = 0.1*tau # doesn't have to be same dt as simulation dt.
wmax = 10. / tau
dw = 1. / Tmax
t = np.arange(0,Tmax,dt)
w = np.arange(-wmax, wmax, dw) * math.pi
dw = dw * math.pi
Nw = w.size
Nt = t.size
Jsum = np.zeros((Nrec, Nrec, Nw), dtype=complex)
Expiwt = np.zeros((Nw,Nt), dtype=complex)
for o in range(Nw): # first compute Fbar over dummy frequency
Jsum[:, :, o] = Jeff_w(w[o], Wrr, Wrh, Whr, Whh, phi_h)
for tt in range(Nt):
Expiwt[o,tt] = np.exp(1j*w[o]*t[tt])
# Jeff_t = np.zeros((Nrec, Nrec, Nt), dtype=complex)
Jeff_t = np.dot(Jsum,Expiwt) * dw / 2 / math.pi # integrate over frequency
Jeff_t = Jeff_t.real
return Jeff_t
def rates_ss(W): # set inputs here
'''
compute steady-state mean field rates through Euler step
:param W: weight matrix
:return: steady-state rates with transfer functions and cellular/synaptic parameters defined in params.py and phi.py
'''
par = params_Gaussian.params_Gaussian()
b = par.b
gain = par.gain
tau = par.tau
N = par.N
dt = .02 * tau
Tmax = int(50 * tau / dt)
a = 1. / tau
a2 = a ** 2
r = np.zeros(N)
s_dummy = np.zeros(N)
s = np.zeros(N)
r_vec = np.zeros((N, Tmax))
for i in range(Tmax):
s_dummy += dt * (-2 * a * s_dummy - a2 * s) + r * a2 * dt # r * a2 for unit norm alpha function
s += dt * s_dummy
g = W.dot(s) + b
r = phi(g, gain)
r_vec[:, i] = r
return r
def linear_response_hiddenrate_fun(w, Whh, Whr, phi_h):
import numpy as np
par = params_Gaussian.params_Gaussian()
N = par.N
Nhid = par.Nhid
Delta = linear_response_fun_hid(w, Whh, phi_h)
filter = g_fun(w) * Delta.dot(Whr)
return filter
def linear_response_fun(w, W, phi_r):
import numpy as np
par = params_Gaussian.params_Gaussian()
N = par.N
s = np.multiply(phi_r,W)
Gamma = g_fun(w) * s
Delta1 = np.linalg.inv(np.eye(N) - Gamma)
Delta = np.multiply(Delta1,phi_r)
return Delta
def linear_response_fun_hid(w, Whh, phi_h):
import numpy as np
par = params_Gaussian.params_Gaussian()
N = par.N
Nhid = par.Nhid
s = np.multiply(phi_h,Whh)
Gamma = g_fun(w) * s
Delta1 = np.linalg.inv(np.eye(Nhid) - Gamma)
# Delta = np.linalg.inv(np.multiply(phi_h,np.eye(Nhid)) - g_fun(w) * Whh)
Delta = np.multiply(Delta1,phi_h)
return Delta
def spiketrain_FT_hiddenrate(spktimes,neuronind,dt,dt_ccg,tstop,trans):
import numpy as np
par = params_Gaussian.params_Gaussian()
N = par.N
Nhid = par.Nhid
spikes = bin_spiketrain(spktimes,neuronind,dt,dt_ccg,tstop,trans)
spkfft_temp = np.fft.fft(spikes,axis=1)
spkfft = np.fft.fftshift(spkfft_temp,axis=1)
freqs = np.fft.fftfreq(spikes.size(1,),d=dt)
return spkfft, freqs
def Jeff_w(w, Wrr, Wrh, Whr, Whh, phi_h):
import numpy as np
par = params_Gaussian.params_Gaussian()
N = par.N
Nhid = par.Nhid
Jdirect = g_fun(w) * Wrr
Delta = linear_response_fun_hid(w, Whh, phi_h)
dJ = g_fun(w)*g_fun(w)*Wrh.dot(Delta.dot(Whr))
Jeff = Jdirect + dJ
return Jeff
import numpy as np
from phi import phi
from phi import phi_prime
from rates_linear_response_hiddenlinearrates_GaussianER import rates_ss
from rates_linear_response_hiddenlinearrates_GaussianER import hidrates_ss
from rates_linear_response_hiddenlinearrates_GaussianER import rates_timeavgapprox_linearhiddenrates
from rates_linear_response_hiddenlinearrates_GaussianER import linear_response_hiddenrate_fun
from rates_linear_response_hiddenlinearrates_GaussianER import empavg_pop
from rates_linear_response_hiddenlinearrates_GaussianER import Jeff_w
import params_hiddenlinearrates_Gaussian as params
from generate_adj_signedER import generate_adj_signedER as gen_adj
from correlation_functions import bin_pop_spiketrain, auto_covariance_pop
if __name__ == '__main__':
par = params.params_Gaussian()
N = par.N
Nhid = par.Nhid
Nrec = par.Nrec
p = par.p
J0 = 1.0 # typical stdev of Gaussian weights
weights = J0 * np.random.randn(N, N) / np.sqrt(p * N)
tau = par.tau
b = par.b
mu = par.mu
gain = par.gain
seed = 1
trans = 5. * tau # simulation transient
tstop = 4000. * tau + trans # simulation time
def sim_poisson(W, tstop, trans, dt):
'''
:param W: weight matrix
:param tstop: total simulation time (including initial transient)
:param trans: initial transient (don't record spikes until trans milliseconds)
:param dt: Euler step
:return:
'''
# unpackage parameters
par = params.params_Gaussian()
N = par.N
tau = par.tau
b = par.b
gain = par.gain
# sim variables
Nt = int(tstop / dt)
t = 0
numspikes = 0
maxspikes = 500 * N * tstop / 1000 # 500 Hz / neuron
spktimes = np.zeros((maxspikes, 2)) # store spike times and neuron labels
g_vec = np.zeros((Nt, N))
# alpha function synaptic variables
s = np.zeros((N, ))
s0 = np.zeros((N, ))
s_dummy = np.zeros((N, ))
a = 1. / tau
a2 = a**2
for i in range(0, Nt, 1):
t += dt
# update each neuron's output and plasticity traces
s_dummy += dt * (-2 * a * s_dummy - a2 * s)
s += dt * s_dummy
# compute each neuron's input
g = np.dot(W, s) + b
g_vec[i] = g
# decide if each neuron spikes, update synaptic output of spiking neurons
# each neurons's rate is phi(g)
r = phi(g, gain)
try:
spiket = np.random.poisson(r * dt, size=(N, ))
except:
break
s_dummy += spiket * a2 # a for non-unit norm alpha function (& dimensionless Wij)
# keep as s_dummy += spiket*a2 for unit norm alpha function, but then Wij has units of time
### store spike times and counts
if t > trans:
for j in range(N):
if spiket[j] >= 1 and numspikes < maxspikes:
spktimes[numspikes, 0] = t
spktimes[numspikes, 1] = j
numspikes += 1
# truncate spike time array
spktimes = spktimes[0:numspikes, :]
return spktimes, g_vec
