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