def objective(hyperparams): tauRise = hyperparams['tauRise'] tauFall = hyperparams['tauFall'] dt = hyperparams['dt'] dtSample = hyperparams['dtSample'] f = DoubleExp(tauRise, tauFall) spikes = np.load('data/%s_spikes.npz' % hyperparams['name'])['spikes'] targets = np.load('data/%s_target.npz' % hyperparams['name'])['target'] A = np.zeros((0, spikes.shape[2])) Y = np.zeros((0, targets.shape[2])) for n in range(hyperparams['nTrain']): A = np.append(A, f.filt(spikes[n], dt=dt), axis=0) Y = np.append(Y, targets[n], axis=0) if dt != dtSample: A = A[::int(dtSample / dt)] Y = Y[::int(dtSample / dt)] d, _ = LstsqL2(reg=hyperparams['reg'])(A, Y) X = np.dot(A, d) loss = rmse(X, Y) loss += penalty * (10 * tauRise + tauFall) return { 'loss': loss, 'd': d, 'tauRise': tauRise, 'tauFall': tauFall, 'status': STATUS_OK }
def decode(spikes, targets, nTrain, dt=0.001, dtSample=0.001, reg=1e-3, penalty=0, evals=100, name="default", tauRiseMax=3e-2, tauFallMax=3e-1): d, tauRise, tauFall = dfOpt(spikes, targets, nTrain, name=name, evals=evals, reg=reg, penalty=penalty, dt=dt, dtSample=dtSample, tauRiseMax=tauRiseMax, tauFallMax=tauFallMax) print("tauRise: %.3f, tauFall: %.3f" % (tauRise, tauFall)) f = DoubleExp(tauRise, tauFall) A = np.zeros((0, spikes.shape[2])) Y = np.zeros((0, targets.shape[2])) for n in range(nTrain): A = np.append(A, f.filt(spikes[n], dt=dt), axis=0) Y = np.append(Y, targets[n], axis=0) X = np.dot(A, d) error = rmse(X, Y) d = d.reshape((-1, targets.shape[2])) return d, f, tauRise, tauFall, X, Y, error
def df_opt_hx(x, ens, name='default', df_evals=100, seed=0, dt=0.001, dt_sample=0.001, tau_rise=1e-3, tau_fall=[3e-2, 3e-1], penalty=0.25, algo=tpe.suggest): # rand.suggest):# np.savez_compressed('data/%s_ens.npz'%name, ens=ens) np.savez_compressed('data/%s_x.npz'%name, x=x) del(ens) del(x) hyperparams = {} hyperparams['name'] = name hyperparams['dt'] = dt hyperparams['dt_sample'] = dt_sample hyperparams['tau_rise'] = tau_rise # hyperparams['ens'] = hp.loguniform('ens', np.log10(tau_fall[0]), np.log10(tau_fall[1])) # hyperparams['x'] = hp.loguniform('x', np.log10(tau_fall[0]), np.log10(tau_fall[1])) hyperparams['ens'] = hp.uniform('ens', tau_fall[0], tau_fall[1]) hyperparams['x'] = hp.uniform('x', tau_fall[0], tau_fall[1]) def objective(hyperparams): taus_ens = [hyperparams['tau_rise'], hyperparams['ens']] taus_x = [hyperparams['tau_rise'], hyperparams['x']] h_ens = DoubleExp(taus_ens[0], taus_ens[1]) h_x = DoubleExp(taus_x[0], taus_x[1]) A = h_ens.filt(np.load('data/%s_ens.npz'%hyperparams['name'])['ens'], dt=hyperparams['dt_sample']) x = h_x.filt(np.load('data/%s_x.npz'%hyperparams['name'])['x'], dt=hyperparams['dt_sample']) if dt != dt_sample: A = A[::int(dt_sample/dt)] x = x[::int(dt_sample/dt)] d_ens = Lstsq()(A, x)[0] xhat = np.dot(A, d_ens) loss = rmse(xhat, x) loss += penalty * taus_ens[1] return {'loss': loss, 'taus_ens': taus_ens, 'taus_x': taus_x, 'd_ens': d_ens, 'status': STATUS_OK} trials = Trials() fmin(objective, rstate=np.random.RandomState(seed=seed), space=hyperparams, algo=algo, max_evals=df_evals, trials=trials) best_idx = np.argmin(trials.losses()) best = trials.trials[best_idx] taus_ens = best['result']['taus_ens'] taus_x = best['result']['taus_x'] d_ens = best['result']['d_ens'] h_ens = DoubleExp(taus_ens[0], taus_ens[1]) h_x = DoubleExp(taus_x[0], taus_x[1]) return d_ens, h_ens, taus_ens, h_x, taus_x
def go(d_ens, f_ens, n_neurons=3000, t=100, L=False, neuron_type=LIF(), m=Uniform(30, 40), i=Uniform(-1, 1), r=40, IC=np.array([1,1,1]), seed=0, dt=0.001, dt_sample=0.001, f=DoubleExp(1e-3, 1e-1)): with nengo.Network(seed=seed) as model: # Ensembles u = nengo.Node(lambda t: IC*(t<=1.0)) x = nengo.Ensemble(1, 3, neuron_type=nengo.Direct()) ens = nengo.Ensemble(n_neurons, 3, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=r) dss = nengo.Node(DownsampleNode(size_in=n_neurons, size_out=n_neurons, dt=dt, dt_sample=dt_sample), size_in=n_neurons, size_out=n_neurons) # Connections nengo.Connection(u, x, synapse=None) nengo.Connection(x, x, function=feedback, synapse=~s) if L: supv = nengo.Ensemble(n_neurons, 3, neuron_type=SpikingRectifiedLinear(), radius=r, seed=seed) nengo.Connection(x, supv, synapse=None) nengo.Connection(supv, ens, synapse=f, seed=seed) else: nengo.Connection(ens, ens, synapse=f_ens, solver=NoSolver(d_ens), seed=seed) # Probes nengo.Connection(ens.neurons, dss, synapse=None) p_x = nengo.Probe(x, synapse=None, sample_every=dt_sample) p_ens = nengo.Probe(dss, synapse=None, sample_every=dt_sample) with nengo.Simulator(model, seed=seed, dt=dt) as sim: sim.run(t) return dict( times=sim.trange(), x=sim.data[p_x], ens=sim.data[p_ens])
def objective(hyperparams): taus_ens = [hyperparams['tau_rise'], hyperparams['tau_fall']] h_ens = DoubleExp(taus_ens[0], taus_ens[1]) A = h_ens.filt(np.load('data/%s_ens.npz'%hyperparams['name'])['ens'], dt=hyperparams['dt']) x = np.load('data/%s_x.npz'%hyperparams['name'])['x'] if dt != dt_sample: A = A[::int(dt_sample/dt)] x = x[::int(dt_sample/dt)] if hyperparams['reg']: d_ens = LstsqL2(reg=hyperparams['reg'])(A, x)[0] else: d_ens = Lstsq()(A, x)[0] xhat = np.dot(A, d_ens) loss = rmse(xhat, x) loss += penalty * (10*taus_ens[0] + taus_ens[1]) return {'loss': loss, 'taus_ens': taus_ens, 'd_ens': d_ens, 'status': STATUS_OK}
def objective(hyperparams): taus_ens = [hyperparams['tau_rise'], hyperparams['ens']] taus_x = [hyperparams['tau_rise'], hyperparams['x']] h_ens = DoubleExp(taus_ens[0], taus_ens[1]) h_x = DoubleExp(taus_x[0], taus_x[1]) A = h_ens.filt(np.load('data/%s_ens.npz'%hyperparams['name'])['ens'], dt=hyperparams['dt_sample']) x = h_x.filt(np.load('data/%s_x.npz'%hyperparams['name'])['x'], dt=hyperparams['dt_sample']) if dt != dt_sample: A = A[::int(dt_sample/dt)] x = x[::int(dt_sample/dt)] d_ens = Lstsq()(A, x)[0] xhat = np.dot(A, d_ens) loss = rmse(xhat, x) loss += penalty * taus_ens[1] return {'loss': loss, 'taus_ens': taus_ens, 'taus_x': taus_x, 'd_ens': d_ens, 'status': STATUS_OK}
def go(t=10, m=Uniform(30, 30), i=Uniform(0, 0), seed=0, dt=0.001, f=DoubleExp(1e-3, 1e-1), fS=DoubleExp(1e-3, 1e-1), d1=None, f1=None, e1=None, l1=False, stim=lambda t: np.sin(t)): if not f1: f1=f with nengo.Network(seed=seed) as model: # Stimulus and Nodes inpt = nengo.Node(stim) tar = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) pre = nengo.Ensemble(100, 1, max_rates=m, seed=seed, neuron_type=LIF()) lif = nengo.Ensemble(1, 1, max_rates=m, intercepts=i, encoders=Choice([[1]]), neuron_type=LIF(), seed=seed) wilson = nengo.Ensemble(1, 1, max_rates=m, intercepts=i, encoders=Choice([[1]]), neuron_type=Wilson(), seed=seed) bio = nengo.Ensemble(1, 1, max_rates=m, intercepts=i, encoders=Choice([[1]]), neuron_type=Bio("Pyramidal"), seed=seed) nengo.Connection(inpt, pre, synapse=None, seed=seed) cLif = nengo.Connection(pre, lif, synapse=f1, seed=seed, solver=NoSolver(d1)) cWilson = nengo.Connection(pre, wilson, synapse=f1, seed=seed, solver=NoSolver(d1)) cBio = nengo.Connection(pre, bio, synapse=f1, seed=seed, solver=NoSolver(d1)) pInpt = nengo.Probe(inpt, synapse=None) pPre = nengo.Probe(pre.neurons, synapse=None) pLif = nengo.Probe(lif.neurons, synapse=None) pWilson = nengo.Probe(wilson.neurons, synapse=None) pBio = nengo.Probe(bio.neurons, synapse=None) if l1: learnEncoders(cBio, lif, fS, alpha=3e-7) # Encoder Learning (Bio) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: setWeights(cBio, d1, e1) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) e1 = cBio.e if l1 else e1 return dict( times=sim.trange(), inpt=sim.data[pInpt], pre=sim.data[pPre], lif=sim.data[pLif], wilson=sim.data[pWilson], bio=sim.data[pBio], e1=e1, )
def go(NPre=100, N=100, t=10, m=Uniform(30, 30), i=Uniform(-0.8, 0.8), neuron_type=LIF(), seed=0, dt=0.001, fPre=None, fEns=None, fS=DoubleExp(2e-2, 2e-1), dPreA=None, dPreB=None, dEns=None, ePreA=None, ePreB=None, eBio=None, stage=None, alpha=1e-6, eMax=1e0, stimA=lambda t: np.sin(t), stimB=lambda t: 0): with nengo.Network(seed=seed) as model: inptA = nengo.Node(stimA) inptB = nengo.Node(stimB) preInptA = nengo.Ensemble(NPre, 1, radius=3, max_rates=m, seed=seed) preInptB = nengo.Ensemble(NPre, 1, max_rates=m, seed=seed) ens = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed) tarEns = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed) cpa = nengo.Connection(inptA, preInptA, synapse=None, seed=seed) cpb = nengo.Connection(inptB, preInptB, synapse=None, seed=seed) pInptA = nengo.Probe(inptA, synapse=None) pInptB = nengo.Probe(inptB, synapse=None) pPreInptA = nengo.Probe(preInptA.neurons, synapse=None) pPreInptB = nengo.Probe(preInptB.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) if stage == 1: c0b = nengo.Connection(preInptB, tarEns, synapse=fPre, solver=NoSolver(dPreB), seed=seed + 1) c1b = nengo.Connection(preInptB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed + 1) learnEncoders(c1b, tarEns, fS, alpha=alpha, eMax=eMax) if stage == 2: c0a = nengo.Connection(preInptA, tarEns, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c0b = nengo.Connection(preInptB, tarEns, synapse=fPre, solver=NoSolver(dPreB), seed=seed + 1) c1a = nengo.Connection(preInptA, ens, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c1b = nengo.Connection(preInptB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed + 1) learnEncoders(c1a, tarEns, fS, alpha=alpha, eMax=eMax) if stage == 3: c1a = nengo.Connection(preInptA, ens, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c1b = nengo.Connection(preInptB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed + 1) if stage == 4: preInptC = nengo.Ensemble(NPre, 1, max_rates=m, seed=seed) ens2 = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed) ens3 = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed) nengo.Connection(inptB, preInptC, synapse=fEns, seed=seed) c1a = nengo.Connection(preInptA, ens, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2b = nengo.Connection(preInptB, ens2, synapse=fPre, solver=NoSolver(dPreB), seed=seed + 1) c3 = nengo.Connection(ens2, ens, synapse=fEns, solver=NoSolver(dEns), seed=seed) c4a = nengo.Connection(preInptA, ens3, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c4b = nengo.Connection(preInptC, ens3, synapse=fPre, solver=NoSolver(dPreB), seed=seed) learnEncoders(c3, ens3, fS, alpha=alpha / 10, eMax=eMax) pTarEns = nengo.Probe(ens3.neurons, synapse=None) if stage == 5: c1a = nengo.Connection(preInptA, ens, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c5 = nengo.Connection(ens, ens, synapse=fEns, solver=NoSolver(dEns), seed=seed) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: if isinstance(neuron_type, Bio): if stage == 1: setWeights(c1b, dPreB, ePreB) if stage == 2: setWeights(c1a, dPreA, ePreA) setWeights(c1b, dPreB, ePreB) if stage == 3: setWeights(c1a, dPreA, ePreA) setWeights(c1b, dPreB, ePreB) if stage == 4: setWeights(c1a, dPreA, ePreA) setWeights(c2b, dPreB, ePreB) setWeights(c4a, dPreA, ePreA) setWeights(c4b, dPreB, ePreB) setWeights(c3, dEns, eBio) if stage == 5: setWeights(c1a, dPreA, ePreA) setWeights(c5, dEns, eBio) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) else: sim.run(t, progress_bar=True) ePreB = c1b.e if stage == 1 else ePreB ePreA = c1a.e if stage == 2 else ePreA eBio = c3.e if stage == 4 else eBio return dict( times=sim.trange(), inptA=sim.data[pInptA], inptB=sim.data[pInptB], preInptA=sim.data[pPreInptA], preInptB=sim.data[pPreInptB], ens=sim.data[pEns], tarEns=sim.data[pTarEns], ePreA=ePreA, ePreB=ePreB, eBio=eBio, )
def run(NPre=100, N=30, t=10, nTrain=5, nEnc=5, nTest=10, dt=0.001, neuron_type=LIF(), fPre=DoubleExp(1e-3, 1e-1), fS=DoubleExp(2e-2, 2e-1), Tff=0.3, reg=1e-1, tauRiseMax=1e-1, tauFallMax=3e-1, load=[], file="data/integrate"): print('\nNeuron Type: %s' % neuron_type) file = file + f"{neuron_type}.npz" if 0 in load: dPreA = np.load(file)['dPreA'] # fix indexing of decoders dPreB = np.load(file)['dPreB'] else: print('readout decoders for preInptA and preInptB') spikesInptA = np.zeros((nTrain, int(t / 0.001), NPre)) spikesInptB = np.zeros((nTrain, int(t / 0.001), NPre)) targetsInptA = np.zeros((nTrain, int(t / 0.001), 1)) targetsInptB = np.zeros((nTrain, int(t / 0.001), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, dt=0.001, seed=n) data = go(NPre=NPre, N=N, t=t, dt=0.001, neuron_type=neuron_type, fPre=fPre, fS=fS, stimA=stimA, stimB=stimB) spikesInptA[n] = data['preInptA'] spikesInptB[n] = data['preInptB'] targetsInptA[n] = fPre.filt(Tff * data['inptA'], dt=0.001) targetsInptB[n] = fPre.filt(data['inptB'], dt=0.001) dPreA, X1a, Y1a, error1a = decodeNoF(spikesInptA, targetsInptA, nTrain, fPre, dt=0.001, reg=reg) dPreB, X1b, Y1b, error1b = decodeNoF(spikesInptB, targetsInptB, nTrain, fPre, dt=0.001, reg=reg) np.savez(file, dPreA=dPreA, dPreB=dPreB) times = np.arange(0, t * nTrain, 0.001) plotState(times, X1a, Y1a, error1a, "integrate", "%s_preInptA" % neuron_type, t * nTrain) plotState(times, X1b, Y1b, error1b, "integrate", "%s_preInptB" % neuron_type, t * nTrain) if 1 in load: ePreB = np.load(file)['ePreB'] elif isinstance(neuron_type, Bio): print("encoders for preInptB-to-ens") ePreB = np.zeros((NPre, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, dt=dt, seed=n) data = go(dPreA=dPreA, dPreB=dPreB, ePreB=ePreB, NPre=NPre, N=N, t=t, dt=dt, neuron_type=neuron_type, fPre=fPre, fS=fS, stimA=stimA, stimB=stimB, stage=1) ePreB = data['ePreB'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrate", "preIntgToEns") np.savez(file, dPreA=dPreA, dPreB=dPreB, ePreB=ePreB) else: ePreB = np.zeros((NPre, N, 1)) if 2 in load: ePreA = np.load(file)['ePreA'] elif isinstance(neuron_type, Bio): print("encoders for preInptA-to-ens") ePreA = np.zeros((NPre, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, dt=dt, seed=n) data = go(dPreA=dPreA, dPreB=dPreB, ePreA=ePreA, ePreB=ePreB, fPre=fPre, NPre=NPre, N=N, t=t, dt=dt, neuron_type=neuron_type, fS=fS, stimA=stimA, stimB=stimB, stage=2) ePreA = data['ePreA'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrate", "preInptToEns") np.savez(file, dPreA=dPreA, dPreB=dPreB, ePreA=ePreA, ePreB=ePreB) else: ePreA = np.zeros((NPre, N, 1)) if 3 in load: dEns = np.load(file)['dEns'] tauRiseEns = np.load(file)['tauRiseEns'] tauFallEns = np.load(file)['tauFallEns'] fEns = DoubleExp(tauRiseEns, tauFallEns) else: print('readout decoders for ens') spikes = np.zeros((nTrain, int(t / dt), N)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, dt=dt, seed=n) data = go(dPreA=dPreA, dPreB=dPreB, ePreA=ePreA, ePreB=ePreB, NPre=NPre, N=N, t=t, dt=dt, neuron_type=neuron_type, fPre=fPre, fS=fS, stimA=stimA, stimB=stimB, stage=3) spikes[n] = data['ens'] targets[n] = fPre.filt(data['inptB'], dt=dt) dEns, fEns, tauRiseEns, tauFallEns, X2, Y2, error2 = decode( spikes, targets, nTrain, dt=dt, reg=reg, tauRiseMax=tauRiseMax, tauFallMax=tauFallMax, name="integrate") np.savez(file, dPreA=dPreA, dPreB=dPreB, ePreA=ePreA, ePreB=ePreB, dEns=dEns, tauRiseEns=tauRiseEns, tauFallEns=tauFallEns) times = np.arange(0, t * nTrain, dt) plotState(times, X2, Y2, error2, "integrate", "%s_ens" % neuron_type, t * nTrain) if 4 in load: eBio = np.load(file)['eBio'] elif isinstance(neuron_type, Bio): print("encoders from ens2 to ens") eBio = np.zeros((N, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, dt=dt, seed=n) data = go(dPreA=dPreA, dPreB=dPreB, dEns=dEns, ePreA=ePreA, ePreB=ePreB, eBio=eBio, NPre=NPre, N=N, t=t, dt=dt, neuron_type=neuron_type, fPre=fPre, fEns=fEns, fS=fS, stimA=stimA, stimB=stimB, stage=4) eBio = data['eBio'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrate", "Ens2Ens") np.savez(file, dPreA=dPreA, dPreB=dPreB, ePreA=ePreA, ePreB=ePreB, dEns=dEns, tauRiseEns=tauRiseEns, tauFallEns=tauFallEns, eBio=eBio) else: eBio = np.zeros((N, N, 1)) print("testing") errors = np.zeros((nTest)) for test in range(nTest): stimA, stimB = makeSignal(t, fPre, dt=dt, seed=200 + test) data = go(dPreA=dPreA, dEns=dEns, ePreA=ePreA, eBio=eBio, NPre=NPre, N=N, t=t, dt=dt, neuron_type=neuron_type, fPre=fPre, fEns=fEns, fS=fS, stimA=stimA, stimB=stimB, stage=5) A = fEns.filt(data['ens'], dt=dt) X = np.dot(A, dEns) Y = fPre.filt(data['inptB'], dt=dt) U = fPre.filt(Tff * data['inptA'], dt=dt) error = rmse(X, Y) errorU = rmse(X, U) errors[test] = error fig, ax = plt.subplots() # ax.plot(data['times'], U, label="input") ax.plot(data['times'], X, label="estimate") ax.plot(data['times'], Y, label="target") ax.set(xlabel='time', ylabel='state', title='rmse=%.3f' % error, xlim=((0, t)), ylim=((-1, 1))) ax.legend(loc='upper left') sns.despine() fig.savefig("plots/integrate_%s_test%s.pdf" % (neuron_type, test)) plt.close('all') # print('errors:', errors) # np.savez(file, errors=errors, dPreA=dPreA, dPreB=dPreB, ePreA=ePreA, ePreB=ePreB, dEns=dEns, tauRiseEns=tauRiseEns, tauFallEns=tauFallEns, eBio=eBio) return data['times'], X, Y
def run(n_neurons=30, t=10, t_test=10, tDA=5, dt=0.001, n_encodes=10, n_tests=1, reg=0, f_NMDA=DoubleExp(1.06e-2, 2.85e-1), f_GABA=DoubleExp(5e-4, 1.5e-3), f_AMPA=DoubleExp(5.5e-4, 2.2e-3), f_s=DoubleExp(1e-2, 2e-1), load_w=None, load_fd=None, data_file="data/dale2.npz"): # Stage 1 DA = lambda t: 0 if load_w: ePExc = np.load(data_file)['ePExc'] wPExc = np.load(data_file)['wPExc'] eIExc = np.load(data_file)['eIExc'] wIExc = np.load(data_file)['wIExc'] ePInh = np.load(data_file)['ePInh'] wPInh = np.load(data_file)['wPInh'] eIInh = np.load(data_file)['eIInh'] wIInh = np.load(data_file)['wIInh'] else: ePExc = None eIExc = None ePInh = None eIInh = None print('Optimizing pre-ens encoders') for nenc in range(n_encodes): print("encoding trial %s"%nenc) s = make_signal(t=t, dt=dt, f=f_AMPA, seed=nenc) stim = lambda t: s[int(t/dt)] data = go(ePExc=ePExc, eIExc=eIExc, ePInh=ePInh, eIInh=eIInh, f_NMDA=f_NMDA, f_AMPA=f_AMPA, f_GABA=f_GABA, f_s=f_s, n_neurons=n_neurons, t=t, stim=stim, stage=1) ePExc = data['ePExc'] wPExc = data['wPExc'] eIExc = data['eIExc'] wIExc = data['wIExc'] ePInh = data['ePInh'] wPInh = data['wPInh'] eIInh = data['eIInh'] wIInh = data['wIInh'] np.savez('data/dale2.npz', ePExc=ePExc, wPExc=wPExc, eIExc=eIExc, wIExc=wIExc, ePInh=ePInh, wPInh=wPInh, eIInh=eIInh, wIInh=wIInh) aSupv = f_s.filt(data['supv']) aP = f_s.filt(data['P']) aI = f_s.filt(data['I']) for n in range(n_neurons): fig, ax = plt.subplots(1, 1) ax.plot(data['times'], aSupv[:,n], alpha=0.5, label='supv') ax.plot(data['times'], aP[:,n], alpha=0.5, label='P') ax.plot(data['times'], aI[:,n], alpha=0.5, label='I') ax.set(ylim=((0, 40))) plt.legend() plt.savefig('plots/tuning/dale_eFF_%s.pdf'%n) plt.close('all') # Stage 2 if load_fd: dNMDA = np.load(data_file)['dNMDA'] dAMPA = np.load(data_file)['dAMPA'] dGABA = np.load(data_file)['dGABA'] else: print("Optimizing decoders") s = make_signal(t=t, dt=dt, f=f_AMPA, seed=0) stim = lambda t: s[int(t/dt)] data = go( wPExc=wPExc, wIExc=wIExc, wPInh=wPInh, wIInh=wIInh, f_NMDA=f_NMDA, f_AMPA=f_AMPA, f_GABA=f_GABA, f_s=f_s, n_neurons=n_neurons, t=t, stim=stim, stage=2) aNMDA = f_NMDA.filt(data['P']) xFB = f_NMDA.filt(data['u']) dNMDA, _ = nengo.solvers.LstsqL2(reg=1e-2)(aNMDA, xFB) # positive w fron mixed dFB enforced by learning node in stage 3 aAMPA = f_AMPA.filt(data['P']) aGABA = f_GABA.filt(data['I']) xOut = data['u'] aOut = np.hstack((aAMPA, -aGABA)) dBoth, _ = nnls(aOut, np.ravel(xOut)) dAMPA = dBoth[:n_neurons].reshape((n_neurons, 1)) dGABA = -dBoth[n_neurons:].reshape((n_neurons, 1)) np.savez('data/dale2.npz', ePExc=ePExc, wPExc=wPExc, eIExc=eIExc, wIExc=wIExc, ePInh=ePInh, wPInh=wPInh, eIInh=eIInh, wIInh=wIInh, dNMDA=dNMDA, dAMPA=dAMPA, dGABA=dGABA) xhatFB = np.dot(aNMDA, dNMDA) xhatOut = np.dot(aAMPA, dAMPA) + np.dot(aGABA, dGABA) xhatFB_rmse = rmse(np.ravel(xhatFB), np.ravel(xFB)) xhatOut_rmse = rmse(np.ravel(xhatOut), np.ravel(xOut)) fig, ax = plt.subplots() ax.plot(data['times'], xFB, alpha=0.5, linestyle="--", label='xFB') ax.plot(data['times'], xhatFB, label='xhatFB, rmse=%.3f' %xhatFB_rmse) # ax.plot(data['times'], xOut, alpha=0.5, linestyle="--", label='xOut') # ax.plot(data['times'], xhatOut, label='xhatOut, rmse=%.3f' %xhatOut_rmse) ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="train decoders") plt.legend(loc='upper right') plt.savefig("plots/dale2_train_decoders.pdf") # Stage 3 # dGABAFb = np.random.RandomState(seed=0).uniform(-1e-4, 0, size=(n_neurons, 1)) dGABAFb = -3e-4*np.ones((n_neurons, 1)) if load_w: ePP = np.load(data_file)['ePP'] wPP = np.load(data_file)['wPP'] ePI = np.load(data_file)['ePI'] wPI = np.load(data_file)['wPI'] eIP = np.load(data_file)['eIP'] wIP = np.load(data_file)['wIP'] eII = np.load(data_file)['eII'] wII = np.load(data_file)['wII'] else: print('Optimizing ePP, ePI, eIP, eII') ePP = None ePI = None eIP = None eII = None DA = lambda t: 0 if t<tDA else 0.5 for nenc in range(n_encodes): print("encoding trial %s"%nenc) s = make_signal(t=t, dt=dt, f=f_NMDA, seed=nenc) stim = lambda t: s[int(t/dt)] data = go( wPExc=wPExc, wIExc=wIExc, wPInh=wPInh, wIInh=wIInh, ePP=ePP, ePI=ePI, eIP=eIP, eII=eII, dNMDA=dNMDA, dAMPA=dAMPA, dGABA=dGABAFb, f_NMDA=f_NMDA, f_AMPA=f_AMPA, f_GABA=f_GABA, f_s=f_s, n_neurons=n_neurons, t=t, stim=stim, DA=DA, stage=3) ePP = data['ePP'] wPP = data['wPP'] ePI = data['ePI'] wPI = data['wPI'] eIP = data['eIP'] wIP = data['wIP'] eII = data['eII'] wII = data['wII'] np.savez('data/dale2.npz', ePExc=ePExc, wPExc=wPExc, eIExc=eIExc, wIExc=wIExc, ePInh=ePInh, wPInh=wPInh, eIInh=eIInh, wIInh=wIInh, dNMDA=dNMDA, dAMPA=dAMPA, dGABA=dGABA, ePP=ePP, wPP=wPP, ePI=ePI, wPI=wPI, eIP=eIP, wIP=wIP, eII=eII, wII=wII) aP = f_s.filt(data['P']) aI = f_s.filt(data['I']) aBuffer = f_s.filt(data['buffer']) for n in range(n_neurons): fig, (ax, ax2) = plt.subplots(nrows=1, ncols=2, sharey=True) ax.plot(data['times'], aBuffer[:,n], alpha=0.5, label='buffer') ax.plot(data['times'], aP[:,n], alpha=0.5, label='P') ax2.plot(data['times'], aBuffer[:,n], alpha=0.5, label='buffer') ax2.plot(data['times'], aI[:,n], alpha=0.5, label='I') ax.set(ylim=((0, 40))) ax.legend() ax2.legend() plt.savefig('plots/tuning/dale_eFB_%s.pdf'%n) plt.close('all') # confirm gated integrator (which generates targets) is working in state-space fig, ax = plt.subplots() ax.plot(data['times'], data['uDA'], label="DA") ax.plot(data['times'], data['gate_x'], label="gate") ax.plot(data['times'], data['buffer_x'], label="buffer") ax.plot(data['times'], data['fdbk_x'], label="fdbk") ax.legend() fig.savefig("plots/dale2_train_gatedIntegrator.pdf") # Stage 4 checkWeights(wPExc, wIExc, wPInh, wIInh, wPP, wPI, wIP, wII, dAMPA, dGABA) DA = lambda t: 0 if t < tDA else 1.0 dGABAFb = np.random.RandomState(seed=0).uniform(-1e-4, 0, size=(n_neurons, 1)) for test in range(n_tests): print("Test %s"%test) s = make_signal(t=t, dt=dt, f=f_NMDA, seed=test) stim = lambda t: s[int(t/dt)] data = go( wPExc=wPExc, wIExc=wIExc, wPInh=wPInh, wIInh=wIInh, wPP=wPP, wPI=wPI, wIP=wIP, wII=wII, dNMDA=dNMDA, dAMPA=dAMPA, dGABA=dGABAFb, f_NMDA=f_NMDA, f_AMPA=f_AMPA, f_GABA=f_GABA, f_s=f_s, n_neurons=n_neurons, t=t, stim=stim, DA=DA, stage=4) aNMDA = f_NMDA.filt(data['P']) aAMPA = f_AMPA.filt(data['P']) aGABA = f_GABA.filt(data['I']) u = data['u'] da = data['uDA'] gate = data['gate_x'] buffer = data['buffer_x'] fdbk = data['fdbk_x'] xhat = np.dot(aNMDA, dNMDA) xhat_rmse = rmse(xhat, buffer) fig, ax = plt.subplots() ax.plot(data['times'], u, linestyle="--", label='u') ax.plot(data['times'], da, linestyle="--", label='DA') ax.plot(data['times'], gate, label="gate") ax.plot(data['times'], buffer, label="buffer") ax.plot(data['times'], fdbk, label="fdbk") ax.plot(data['times'], xhat, label='xhat, rmse=%.3f' %xhat_rmse) ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="test") plt.legend(loc='upper right') plt.savefig("plots/dale2_test_DA1_%s.pdf"%test)
def run(NPre=300, NBias=100, N=30, t=10, nTrain=10, nTest=5, nEnc=10, dt=0.001, fPre=DoubleExp(1e-3, 1e-1), fNMDA=DoubleExp(10.6e-3, 285e-3), fGABA=DoubleExp(0.5e-3, 1.5e-3), fS=DoubleExp(2e-2, 1e-1), DATrain=lambda t: 0, DATest=lambda t: 0, Tff=0.3, reg=1e-2, load=[], file=None): if 0 in load: dPre = np.load(file)['dPre'] else: print('readout decoders for [preA, preB, preC]') spikesInpt = np.zeros((nTrain, int(t / dt), NPre)) targetsInpt = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, stimB=stimB, stage=0) spikesInpt[n] = data['preA'] targetsInpt[n] = fPre.filt(data['inptA'], dt=dt) dPre, X, Y, error = decodeNoF(spikesInpt, targetsInpt, nTrain, fPre, dt=dt, reg=reg) np.savez( "data/integrateNMDAbias2.npz", dPre=dPre, ) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "integrateNMDAbias2", "pre", t * nTrain) if 1 in load: ePreFdfw = np.load(file)['ePreFdfw'] ePreBias = np.load(file)['ePreBias'] else: print("encoders for [preA, preC] to [fdfw, bias]") ePreFdfw = np.zeros((NPre, N, 1)) ePreBias = np.zeros((NPre, NBias, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, stimB=stimB, dPre=dPre, ePreFdfw=ePreFdfw, ePreBias=ePreBias, stage=1) ePreFdfw = data['ePreFdfw'] ePreBias = data['ePreBias'] plotActivity(t, dt, fS, data['times'], data['fdfw'], data['tarFdfw'], "integrateNMDAbias2", "pre_fdfw") plotActivity(t, dt, fS, data['times'], data['bias'], data['tarBias'], "integrateNMDAbias2", "pre_bias") np.savez("data/integrateNMDAbias2.npz", dPre=dPre, ePreFdfw=ePreFdfw, ePreBias=ePreBias) if 2 in load: dFdfw = np.load(file)['dFdfw'] dBias = np.load(file)['dBias'] else: print('readout decoders for fdfw and bias') spikesFdfw = np.zeros((nTrain, int(t / dt), N)) spikesBias = np.zeros((nTrain, int(t / dt), NBias)) targetsFdfw = np.zeros((nTrain, int(t / dt), 1)) targetsBias = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stimA, _ = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, dPre=dPre, ePreFdfw=ePreFdfw, ePreBias=ePreBias, stage=2) spikesFdfw[n] = data['fdfw'] spikesBias[n] = data['bias'] targetsFdfw[n] = fNMDA.filt(Tff * fPre.filt(data['inptA'], dt=dt)) targetsBias[n] = fGABA.filt(fPre.filt(data['inptC'], dt=dt)) dFdfw, X1, Y1, error1 = decodeNoF(spikesFdfw, targetsFdfw, nTrain, fNMDA, dt=dt, reg=reg) dBias, X2, Y2, error2 = decodeNoF(spikesBias, targetsBias, nTrain, fGABA, dt=dt, reg=reg) np.savez("data/integrateNMDAbias2.npz", dPre=dPre, ePreFdfw=ePreFdfw, ePreBias=ePreBias, dFdfw=dFdfw, dBias=dBias) times = np.arange(0, t * nTrain, dt) plotState(times, X1, Y1, error1, "integrateNMDAbias2", "fdfw", t * nTrain) plotState(times, X2, Y2, error2, "integrateNMDAbias2", "bias", t * nTrain) if 3 in load: eBiasEns = np.load(file)['eBiasEns'] else: print("encoders for [bias] to ens") eBiasEns = np.zeros((NBias, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, dPre=dPre, dBias=dBias, ePreBias=ePreBias, eBiasEns=eBiasEns, stage=3) eBiasEns = data['eBiasEns'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNMDAbias2", "bias_ens") np.savez( "data/integrateNMDAbias2.npz", dPre=dPre, ePreFdfw=ePreFdfw, ePreBias=ePreBias, dFdfw=dFdfw, dBias=dBias, eBiasEns=eBiasEns, ) if 4 in load: ePreEns = np.load(file)['ePreEns'] else: print("encoders for [preB] to [ens]") ePreEns = np.zeros((NPre, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, stimB=stimB, dPre=dPre, dBias=dBias, ePreBias=ePreBias, eBiasEns=eBiasEns, ePreEns=ePreEns, stage=4) ePreEns = data['ePreEns'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNMDAbias2", "pre_ens") np.savez( "data/integrateNMDAbias2.npz", dPre=dPre, ePreFdfw=ePreFdfw, ePreBias=ePreBias, dFdfw=dFdfw, dBias=dBias, eBiasEns=eBiasEns, ePreEns=ePreEns, ) if 5 in load: eFdfwEns = np.load(file)['eFdfwEns'] else: print("encoders for [fdfw] to ens") eFdfwEns = np.zeros((N, N, 1)) for n in range(nEnc): # stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) stimA, stimB = makeCarrier(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, Tff=Tff, dPre=dPre, dFdfw=dFdfw, dBias=dBias, ePreFdfw=ePreFdfw, ePreEns=ePreEns, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, stage=5) eFdfwEns = data['eFdfwEns'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNMDAbias2", "fdfw_ens") np.savez( "data/integrateNMDAbias2.npz", dPre=dPre, ePreFdfw=ePreFdfw, ePreEns=ePreEns, ePreBias=ePreBias, dFdfw=dFdfw, dBias=dBias, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, ) if 6 in load: dEns = np.load(file)['dEns'] else: print('readout decoders for ens') spikes = np.zeros((nTrain, int(t / dt), N)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): # stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) stimA, stimB = makeCarrier(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, stimB=stimB, dPre=dPre, dFdfw=dFdfw, dBias=dBias, ePreFdfw=ePreFdfw, ePreEns=ePreEns, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, stage=6) spikes[n] = data['ens'] targets[n] = fNMDA.filt(fPre.filt(data['inptB'])) dEns, X, Y, error = decodeNoF(spikes, targets, nTrain, fNMDA, dt=dt, reg=reg) np.savez("data/integrateNMDAbias2.npz", dPre=dPre, ePreFdfw=ePreFdfw, ePreEns=ePreEns, ePreBias=ePreBias, dFdfw=dFdfw, dBias=dBias, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, dEns=dEns) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "integrateNMDAbias2", "ens", t * nTrain) if 7 in load: eEnsEns = np.load(file)['eEnsEns'] else: print("encoders from ens to ens") eEnsEns = np.zeros((N, N, 1)) for n in range(nEnc): # stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) stimA, stimB = makeCarrier(t, fPre, fNMDA, dt=dt, seed=n) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATrain, stimA=stimA, stimB=stimB, dPre=dPre, dFdfw=dFdfw, dBias=dBias, dEns=dEns, ePreFdfw=ePreFdfw, ePreEns=ePreEns, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, eEnsEns=eEnsEns, stage=7) eEnsEns = data['eEnsEns'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNMDAbias2", "ens_ens") np.savez("data/integrateNMDAbias2.npz", dPre=dPre, ePreFdfw=ePreFdfw, ePreEns=ePreEns, ePreBias=ePreBias, dFdfw=dFdfw, dBias=dBias, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, dEns=dEns, eEnsEns=eEnsEns) print("testing") vals = np.linspace(-1, 1, nTest) for test in range(nTest): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=200 + test) data = go(NPre=NPre, NBias=NBias, N=N, t=t, dt=dt, DA=DATest, stimA=stimA, stimB=stimB, Tff=Tff, dPre=dPre, dFdfw=dFdfw, dBias=dBias, dEns=dEns, ePreFdfw=ePreFdfw, ePreEns=ePreEns, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, eEnsEns=eEnsEns, stage=8) aFdfw = fNMDA.filt(data['fdfw'], dt=dt) aBio = fNMDA.filt(data['ens'], dt=dt) xhatFdfw = np.dot(aFdfw, dFdfw) xhatEns = np.dot(aBio, dEns) xFdfw = fNMDA.filt(fPre.filt(data['inptA'], dt=dt), dt=dt) xEns = fNMDA.filt(fPre.filt(data['inptB'], dt=dt), dt=dt) errorBio = rmse(xhatEns, xEns) fig, ax = plt.subplots() ax.plot(data['times'], xhatFdfw, alpha=0.5, label="fdfw") ax.plot(data['times'], Tff * xFdfw, alpha=0.5, label="input") ax.plot(data['times'], xEns, label="target") ax.plot(data['times'], xhatEns, alpha=0.5, label="ens, rmse=%.3f" % errorBio) ax.set(xlabel='time', ylabel='state', xlim=((0, t)), ylim=((-1.5, 1.5))) ax.legend(loc='upper left') sns.despine() fig.savefig("plots/integrateNMDAbias2_testWhite%s.pdf" % test) plt.close('all')
def run(NPre=200, N=100, N2=100, t=10, nTrain=10, nEnc=20, nTest=10, neuron_type=LIF(), dt=0.001, f=DoubleExp(1e-3, 1e-1), fS=DoubleExp(1e-3, 1e-1), tauRiseMax=1e-2, load=False, file=None): print('\nNeuron Type: %s' % neuron_type) if load: d1 = np.load(file)['d1'] tauRise1 = np.load(file)['tauRise1'] tauFall1 = np.load(file)['tauFall1'] f1 = DoubleExp(tauRise1, tauFall1) else: print('readout decoders for pre') spikes = np.zeros((nTrain, int(t / 0.001), NPre)) targets = np.zeros((nTrain, int(t / 0.001), 2)) for n in range(nTrain): stim = makeSignal(t, f, dt=0.001, seed=n) data = go(NPre=NPre, N=N, N2=N2, t=t, dt=0.001, f=f, fS=fS, neuron_type=LIF(), stim=stim) spikes[n] = data['pre'] targets[n] = f.filt(data['inpt'], dt=0.001) d1, f1, tauRise1, tauFall1, X, Y, error = decode(spikes, targets, nTrain, dt=0.001, tauRiseMax=tauRiseMax, name="multiplyNew") np.savez("data/multiplyNew_%s.npz" % neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1) times = np.arange(0, t * nTrain, 0.001) plotState(times, X, Y, error, "multiplyNew", "%s_pre" % neuron_type, t * nTrain) if load: e1 = np.load(file)['e1'] elif isinstance(neuron_type, Bio): print("ens1 encoders") e1 = np.zeros((NPre, N, 2)) for n in range(nEnc): stim = makeSignal(t, f, dt=dt, seed=n) data = go(d1=d1, e1=e1, f1=f1, NPre=NPre, N=N, N2=N2, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim, l1=True) e1 = data['e1'] np.savez("data/multiplyNew_%s.npz" % neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1) plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "multiplyNew", "ens") else: e1 = np.zeros((NPre, N, 2)) if load: d2 = np.load(file)['d2'] tauRise2 = np.load(file)['tauRise2'] tauFall2 = np.load(file)['tauFall2'] f2 = DoubleExp(tauRise2, tauFall2) else: print('readout decoders for ens') spikes = np.zeros((nTrain, int(t / dt), N)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stim = makeSignal(t, f, dt=dt, seed=n) data = go(d1=d1, e1=e1, f1=f1, NPre=NPre, N=N, N2=N2, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim) spikes[n] = data['ens'] targets[n] = f.filt(data['tar'][:, 0] * data['tar'][:, 1], dt=dt).reshape(-1, 1) d2, f2, tauRise2, tauFall2, X, Y, error = decode(spikes, targets, nTrain, dt=dt, tauRiseMax=tauRiseMax, name="multiplyNew") np.savez("data/multiplyNew_%s.npz" % neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "multiplyNew", "%s_ens" % neuron_type, t * nTrain) if load: e2 = np.load(file)['e2'] elif isinstance(neuron_type, Bio): print("ens2 encoders") e2 = np.zeros((N, N2, 1)) for n in range(nEnc): stim = makeSignal(t, f, dt=dt, seed=n) data = go(d1=d1, e1=e1, f1=f1, d2=d2, e2=e2, f2=f2, NPre=NPre, N=N, N2=N2, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim, l2=True) e2 = data['e2'] np.savez("data/multiplyNew_%s.npz" % neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2) plotActivity(t, dt, fS, data['times'], data['ens2'], data['tarEns2'], "multiplyNew", "ens2") else: e2 = np.zeros((N, N2, 1)) if load: d3 = np.load(file)['d3'] tauRise3 = np.load(file)['tauRise3'] tauFall3 = np.load(file)['tauFall3'] f3 = DoubleExp(tauRise3, tauFall3) else: print('readout decoders for ens2') spikes = np.zeros((nTrain, int(t / dt), N2)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stim = makeSignal(t, f, dt=dt, seed=n) data = go(d1=d1, e1=e1, f1=f1, d2=d2, e2=e2, f2=f2, NPre=NPre, N=N, N2=N2, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim) spikes[n] = data['ens2'] targets[n] = f.filt(data['tar2'], dt=dt) d3, f3, tauRise3, tauFall3, X, Y, error = decode(spikes, targets, nTrain, dt=dt, name="multiplyNew") np.savez("data/multiplyNew_%s.npz" % neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2, d3=d3, tauRise3=tauRise3, tauFall3=tauFall3) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "multiplyNew", "%s_ens2" % neuron_type, t * nTrain) errors = np.zeros((nTest)) print("testing") for test in range(nTest): stim = makeSignal(t, f, dt=dt, seed=100 + test) data = go(d1=d1, e1=e1, f1=f1, d2=d2, e2=e2, f2=f2, NPre=NPre, N=N, N2=N2, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim) A = f3.filt(data['ens2'], dt=dt) X = np.dot(A, d3) Y = f.filt(data['tar2'], dt=dt) error = rmse(X, Y) errors[test] = error plotState(data['times'], X, Y, error, "multiplyNew", "%s_test%s" % (neuron_type, test), t) A = f2.filt(data['ens'], dt=dt) X = np.dot(A, d2) Y = f.filt(data['tar'][:, 0] * data['tar'][:, 1], dt=dt).reshape(-1, 1) plotState(data['times'], X, Y, rmse(X, Y), "multiplyNew", "%s_pretest%s" % (neuron_type, test), t) print('%s errors:' % neuron_type, errors) np.savez("data/multiplyNew_%s.npz" % neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2, d3=d3, tauRise3=tauRise3, tauFall3=tauFall3, errors=errors) return errors
def go(NPre=100, N=30, t=10, m=Uniform(30, 30), i=Uniform(-0.8, 0.8), seed=0, dt=0.001, f=DoubleExp(1e-3, 1e-1), fS=DoubleExp(1e-3, 1e-1), neuron_type=LIF(), d1=None, d2=None, f1=None, f2=None, e1=None, e2=None, l1=False, l2=False, test=False, freq=1, phase=0, tDrive=0.2): A = [[1, 1e-1*2*np.pi*freq], [-1e-1*2*np.pi*freq, 1]] # tau*A + I if isinstance(neuron_type, Bio) and not f1: f1=DoubleExp(1e-3, 1e-1) if isinstance(neuron_type, Bio) and not f2: f2=DoubleExp(1e-3, 1e-1) stim = lambda t: [np.sin(2*np.pi*freq*t+phase), np.cos(2*np.pi*freq*t+phase)] with nengo.Network(seed=seed) as model: inpt = nengo.Node(stim) tar = nengo.Ensemble(1, 2, neuron_type=nengo.Direct()) pre = nengo.Ensemble(NPre, 2, max_rates=m, neuron_type=nengo.SpikingRectifiedLinear(), radius=2, seed=seed) ens = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, radius=2, seed=seed) nengo.Connection(inpt, tar, synapse=None, transform=A, seed=seed) nengo.Connection(inpt, pre, synapse=None, seed=seed) c1 = nengo.Connection(pre, ens, synapse=f1, seed=seed, solver=NoSolver(d1)) pInpt = nengo.Probe(inpt, synapse=None) pTar = nengo.Probe(tar, synapse=None) pPre = nengo.Probe(pre.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) # Encoder Learning (Bio) if l1: tarEns = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed) nengo.Connection(inpt, tarEns, synapse=None, seed=seed) learnEncoders(c1, tarEns, fS) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) if l2: pre2 = nengo.Ensemble(NPre, 2, max_rates=m, neuron_type=nengo.LIF(), seed=seed, radius=2) tarEns2 = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed) ens2 = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=2) # ens3 = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=2) # nengo.Connection(tar, pre2, synapse=f) # c3 = nengo.Connection(ens, ens2, synapse=f2, seed=seed) # c4 = nengo.Connection(pre2, ens3, synapse=f1, seed=seed) # learnEncoders(c3, ens3, fS) # pTarEns2 = nengo.Probe(ens3.neurons, synapse=None) # pEns2 = nengo.Probe(ens2.neurons, synapse=None) nengo.Connection(inpt, pre2, synapse=f) nengo.Connection(pre2, tarEns2, synapse=f, seed=seed) c3 = nengo.Connection(ens, ens2, synapse=f2, seed=seed) learnEncoders(c3, tarEns2, fS, alpha=3e-7) pTarEns2 = nengo.Probe(tarEns2.neurons, synapse=None) pEns2 = nengo.Probe(ens2.neurons, synapse=None) if test: c2 = nengo.Connection(ens, ens, synapse=f2, seed=seed, solver=NoSolver(d2)) off = nengo.Node(lambda t: 1 if t>tDrive else 0) nengo.Connection(off, pre.neurons, synapse=None, transform=-1e4*np.ones((NPre, 1))) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: if isinstance(neuron_type, Bio): setWeights(c1, d1, e1) if l2: setWeights(c3, d2, e2) # if l2: setWeights(c4, d1, e1) if test: setWeights(c2, d2, e2) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) else: sim.run(t, progress_bar=True) e1 = c1.e if l1 else e1 e2 = c3.e if l2 else e2 return dict( times=sim.trange(), inpt=sim.data[pInpt], tar=sim.data[pTar], pre=sim.data[pPre], ens=sim.data[pEns], tarEns=sim.data[pTarEns] if l1 else None, tarEns2=sim.data[pTarEns2] if l2 else None, ens2=sim.data[pEns2] if l2 else None, e1=e1, e2=e2, )
def goLIF(N=100, t=10, dt=0.001, stim=lambda t: 0, m=Uniform(30, 30), i=Uniform(0, 0.8), e=Choice([[1]]), i2=Uniform(0.4, 1), dFdfwEnsAMPA=None, dFdfwEnsNMDA=None, dEnsEnsAMPA=None, dEnsEnsNMDA=None, dEnsInhAMPA=None, dEnsInhNMDA=None, dInhFdfwGABA=None, dInhEnsGABA=None, fAMPA=DoubleExp(0.55e-3, 2.2e-3), fNMDA=DoubleExp(2.3e-3, 95.0e-3), fGABA=DoubleExp(0.5e-3, 1.5e-3), x0=0, seed=0): with nengo.Network(seed=seed) as model: inpt = nengo.Node(stim) intg = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) fdfw = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, seed=seed) inh = nengo.Ensemble(N, 1, encoders=e, max_rates=m, intercepts=i2, neuron_type=LIF(), seed=seed) ens = nengo.Ensemble(N, 1, encoders=e, max_rates=m, intercepts=i, neuron_type=LIF(), seed=seed) nengo.Connection(inpt, intg, synapse=1 / s) nengo.Connection(inpt, fdfw, synapse=None) nengo.Connection(fdfw, ens, synapse=fAMPA, solver=NoSolver(dFdfwEnsAMPA)) nengo.Connection(fdfw, ens, synapse=fNMDA, solver=NoSolver(dFdfwEnsNMDA)) nengo.Connection(ens, ens, synapse=fAMPA, solver=NoSolver(dEnsEnsAMPA)) nengo.Connection(ens, ens, synapse=fNMDA, solver=NoSolver(dEnsEnsNMDA)) nengo.Connection(ens, inh, synapse=fAMPA, solver=NoSolver(dEnsInhAMPA)) nengo.Connection(ens, inh, synapse=fNMDA, solver=NoSolver(dEnsInhNMDA)) nengo.Connection(inh, fdfw, synapse=fGABA, solver=NoSolver(dInhFdfwGABA)) nengo.Connection(inh, ens, synapse=fGABA, solver=NoSolver(dInhEnsGABA)) pInpt = nengo.Probe(inpt, synapse=None) pIntg = nengo.Probe(intg, synapse=None) pFdfw = nengo.Probe(fdfw.neurons, synapse=None) pInh = nengo.Probe(inh.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) with nengo.Simulator(model, seed=seed, progress_bar=False) as sim: # init_lif(sim, ens, x0=x0) sim.run(t, progress_bar=True) return dict(times=sim.trange(), inpt=sim.data[pInpt], intg=sim.data[pIntg], fdfw=sim.data[pFdfw], inh=sim.data[pInh], ens=sim.data[pEns])
def go(d_ens, f_ens, n_neurons=100, t=10, m=Uniform(30, 40), i=Uniform(-1, 0.6), seed=0, dt=0.001, neuron_type=nengo.LIF(), f=DoubleExp(1e-2, 2e-1), f_smooth=DoubleExp(1e-2, 2e-1), freq=1, w_ff=None, w_fb=None, e_ff=None, e_fb=None, L_ff=False, L_fb=False, L_fd=False, supervised=False): w = 2 * np.pi * freq A = [[0, -w], [w, 0]] B = [[1], [0]] C = [[1, 0]] D = [[0]] sys = LinearSystem((A, B, C, D)) with nengo.Network(seed=seed) as model: u = nengo.Node(lambda t: [np.sin(w * t), np.cos(w * t)]) # Ensembles pre = nengo.Ensemble(300, 2, neuron_type=SpikingRectifiedLinear(), seed=seed, radius=2) ens = nengo.Ensemble(n_neurons, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=2) nengo.Connection(u, pre, synapse=None, seed=seed) pre_ens = nengo.Connection(pre, ens, synapse=f, seed=seed) if L_ff: supv = nengo.Ensemble(n_neurons, 2, max_rates=m, intercepts=i, neuron_type=LIF(), seed=seed, radius=2) nengo.Connection(pre, supv, synapse=f, seed=seed) node = LearningNode2(n_neurons, pre.n_neurons, pre_ens, k=3e-6) nengo.Connection(pre.neurons, node[0:pre.n_neurons], synapse=f) nengo.Connection(ens.neurons, node[pre.n_neurons:pre.n_neurons + n_neurons], synapse=f_smooth) nengo.Connection(supv.neurons, node[pre.n_neurons + n_neurons:pre.n_neurons + 2 * n_neurons], synapse=f_smooth) nengo.Connection(u, node[-2:], synapse=f) p_supv = nengo.Probe(supv.neurons, synapse=None) if L_fb or supervised: supv = nengo.Ensemble(n_neurons, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=2) # supv2 = nengo.Ensemble(n_neurons, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=2) # pre2 = nengo.Ensemble(300, 2, neuron_type=SpikingRectifiedLinear(), seed=seed, radius=2) # nengo.Connection(u, pre2, synapse=f, seed=seed) pre_supv = nengo.Connection(pre, supv, synapse=f, seed=seed) # pre2_supv2 = nengo.Connection(pre2, supv2, synapse=f, seed=seed) supv_ens = nengo.Connection(supv, ens, synapse=f_ens, seed=seed, solver=NoSolver(d_ens)) p_supv = nengo.Probe(supv.neurons, synapse=None) # p_supv2 = nengo.Probe(supv2.neurons, synapse=None) if L_fb: node = LearningNode2(n_neurons, n_neurons, supv_ens, k=3e-6) nengo.Connection(supv.neurons, node[0:n_neurons], synapse=f_ens) nengo.Connection(ens.neurons, node[n_neurons:2 * n_neurons], synapse=f_smooth) # nengo.Connection(supv2.neurons, node[2*n_neurons: 3*n_neurons], synapse=f_smooth) nengo.Connection(supv.neurons, node[2 * n_neurons:3 * n_neurons], synapse=f_smooth) nengo.Connection(u, node[-2:], synapse=f) if not L_ff and not L_fb and not L_fd and not supervised: off = nengo.Node(lambda t: (t > 1.0)) nengo.Connection(off, pre.neurons, synapse=None, transform=-1e3 * np.ones((pre.n_neurons, 1))) ens_ens = nengo.Connection(ens, ens, synapse=f_ens, seed=seed, solver=NoSolver(d_ens)) # Probes p_u = nengo.Probe(u, synapse=None) p_ens = nengo.Probe(ens.neurons, synapse=None) with nengo.Simulator(model, seed=seed, dt=dt) as sim: if np.any(w_ff): for pre in range(pre.n_neurons): for post in range(n_neurons): if L_fb or supervised: pre_supv.weights[pre, post] = w_ff[pre, post] pre_supv.netcons[pre, post].weight[0] = np.abs(w_ff[pre, post]) pre_supv.netcons[ pre, post].syn().e = 0 if w_ff[pre, post] > 0 else -70 # pre2_supv2.weights[pre, post] = w_ff[pre, post] # pre2_supv2.netcons[pre, post].weight[0] = np.abs(w_ff[pre, post]) # pre2_supv2.netcons[pre, post].syn().e = 0 if w_ff[pre, post] > 0 else -70 else: pre_ens.weights[pre, post] = w_ff[pre, post] pre_ens.netcons[pre, post].weight[0] = np.abs(w_ff[pre, post]) pre_ens.netcons[ pre, post].syn().e = 0 if w_ff[pre, post] > 0 else -70 if np.any(e_ff) and L_ff: pre_ens.e = e_ff if np.any(w_fb): for pre in range(n_neurons): for post in range(n_neurons): if L_fb or supervised: supv_ens.weights[pre, post] = w_fb[pre, post] supv_ens.netcons[pre, post].weight[0] = np.abs(w_fb[pre, post]) supv_ens.netcons[ pre, post].syn().e = 0 if w_fb[pre, post] > 0 else -70 else: ens_ens.weights[pre, post] = w_fb[pre, post] ens_ens.netcons[pre, post].weight[0] = np.abs(w_fb[pre, post]) ens_ens.netcons[ pre, post].syn().e = 0 if w_fb[pre, post] > 0 else -70 if np.any(e_fb) and L_fb: supv_ens.e = e_fb neuron.h.init() sim.run(t) reset_neuron(sim, model) if L_ff and hasattr(pre_ens, 'weights'): w_ff = pre_ens.weights e_ff = pre_ens.e if L_fb and hasattr(supv_ens, 'weights'): w_fb = supv_ens.weights e_fb = supv_ens.e return dict( times=sim.trange(), u=sim.data[p_u], ens=sim.data[p_ens], supv=sim.data[p_supv] if L_ff or L_fb or supervised else None, # supv2=sim.data[p_supv2] if L_fb or supervised else None, w_ff=w_ff, w_fb=w_fb, e_ff=e_ff, e_fb=e_fb, )
def go(NPre=300, NBias=100, N=30, t=10, seed=1, dt=0.001, Tff=0.3, tTrans=0.01, stage=None, alpha=3e-7, eMax=1e-1, fPre=DoubleExp(1e-3, 1e-1), fNMDA=DoubleExp(10.6e-3, 285e-3), fGABA=DoubleExp(0.5e-3, 1.5e-3), fS=DoubleExp(1e-3, 1e-1), dPre=None, dFdfw=None, dEns=None, dBias=None, ePreFdfw=None, ePreEns=None, ePreBias=None, eFdfwEns=None, eBiasEns=None, eEnsEns=None, stimA=lambda t: 0, stimB=lambda t: 0, stimC=lambda t: 0.01, DA=lambda t: 0): with nengo.Network(seed=seed) as model: inptA = nengo.Node(stimA) inptB = nengo.Node(stimB) inptC = nengo.Node(stimC) preA = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) preB = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) preC = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) fdfw = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed) ens = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed + 1) bias = nengo.Ensemble(NBias, 1, neuron_type=Bio("Interneuron", DA=DA), seed=seed + 2) tarFdfw = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, 0.8), seed=seed) tarEns = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, 0.8), seed=seed + 1) tarBias = nengo.Ensemble(NBias, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, -0.2), encoders=Choice([[1]]), seed=seed + 2) cA = nengo.Connection(inptA, preA, synapse=None, seed=seed) cB = nengo.Connection(inptB, preB, synapse=None, seed=seed) cC = nengo.Connection(inptC, preC, synapse=None, seed=seed) pInptA = nengo.Probe(inptA, synapse=None) pInptB = nengo.Probe(inptB, synapse=None) pInptC = nengo.Probe(inptC, synapse=None) pPreA = nengo.Probe(preA.neurons, synapse=None) pPreB = nengo.Probe(preB.neurons, synapse=None) pPreC = nengo.Probe(preC.neurons, synapse=None) pFdfw = nengo.Probe(fdfw.neurons, synapse=None) pTarFdfw = nengo.Probe(tarFdfw.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) pBias = nengo.Probe(bias.neurons, synapse=None) pTarBias = nengo.Probe(tarBias.neurons, synapse=None) if stage == 0: # readout decoders for [preA, preB, preC] pass if stage == 1: # encoders for [preA, preC] to [fdfw, bias] nengo.Connection(inptA, tarFdfw, synapse=fPre, seed=seed) nengo.Connection(inptC, tarBias, synapse=fPre, seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) learnEncoders(c1, tarFdfw, fS, alpha=3 * alpha, eMax=3 * eMax, tTrans=tTrans) learnEncoders(c2, tarBias, fS, alpha=alpha, eMax=eMax, tTrans=tTrans) if stage == 2: # readout decoders for fdfw and bias c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) if stage == 3: # encoders for [bias] to ens # nengo.Connection(inptC, tarBias, synapse=fPre, seed=seed) nengo.Connection(inptC, tarEns, synapse=fGABA, seed=seed) c1 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(bias, ens, synapse=GABA(), solver=NoSolver(dBias), seed=seed) learnEncoders(c2, tarEns, fS, alpha=1e3 * alpha, eMax=1e3 * eMax, tTrans=tTrans) if stage == 4: # encoders for [preB] to [ens] # nengo.Connection(inptC, tarBias, synapse=fPre, seed=seed) nengo.Connection(inptC, tarEns, synapse=fGABA, seed=seed) nengo.Connection(inptB, tarEns, synapse=fPre, seed=seed) c1 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(bias, ens, synapse=GABA(), solver=NoSolver(dBias), seed=seed) c3 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPre), seed=seed) learnEncoders(c3, tarEns, fS, alpha=3 * alpha, eMax=3 * eMax, tTrans=tTrans) if stage == 5: # encoders for [fdfw] to ens cB.synapse = fNMDA tarPreA = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) tarPreB = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) tarPreC = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) nengo.Connection(inptA, tarPreA, synapse=fPre, seed=seed) nengo.Connection(inptB, tarPreB, synapse=fNMDA, seed=seed) nengo.Connection(inptC, tarPreC, synapse=fPre, seed=seed) nengo.Connection(tarPreA, tarEns, synapse=fNMDA, transform=Tff, seed=seed) nengo.Connection(tarPreB, tarEns, synapse=fPre, seed=seed) nengo.Connection(tarPreC, tarEns, synapse=fGABA, seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPre), seed=seed) c3 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) c4 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c5 = nengo.Connection(bias, ens, synapse=GABA(), solver=NoSolver(dBias), seed=seed) learnEncoders(c4, tarEns, fS, alpha=3 * alpha, eMax=3 * eMax, tTrans=tTrans) if stage == 6: # readout decoders for ens cB.synapse = fNMDA c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPre), seed=seed) c3 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) c4 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c5 = nengo.Connection(bias, ens, synapse=GABA(), solver=NoSolver(dBias), seed=seed) if stage == 7: # encoders from ens to ens preB2 = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) ens2 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed + 1) # acts as preB input to ens ens3 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed + 1) # acts as tarEns nengo.Connection(inptB, preB2, synapse=fNMDA, seed=seed) pTarEns = nengo.Probe(ens3.neurons, synapse=None) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(preB, ens2, synapse=fPre, solver=NoSolver(dPre), seed=seed) c3 = nengo.Connection(preB2, ens3, synapse=fPre, solver=NoSolver(dPre), seed=seed) c4 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) c5 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c6 = nengo.Connection(fdfw, ens3, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c7 = nengo.Connection(bias, ens, synapse=GABA(), solver=NoSolver(dBias), seed=seed) c8 = nengo.Connection(bias, ens2, synapse=GABA(), solver=NoSolver(dBias), seed=seed) c9 = nengo.Connection(bias, ens3, synapse=GABA(), solver=NoSolver(dBias), seed=seed) c10 = nengo.Connection(ens2, ens, synapse=NMDA(), solver=NoSolver(dEns), seed=seed) learnEncoders(c10, ens3, fS, alpha=alpha, eMax=eMax, tTrans=tTrans) if stage == 8: # test c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPre), seed=seed) c2 = nengo.Connection(preC, bias, synapse=fPre, solver=NoSolver(dPre), seed=seed) c3 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c4 = nengo.Connection(bias, ens, synapse=GABA(), solver=NoSolver(dBias), seed=seed) c5 = nengo.Connection(ens, ens, synapse=NMDA(), solver=NoSolver(dEns), seed=seed) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: if stage == 0: pass if stage == 1: setWeights(c1, dPre, ePreFdfw) setWeights(c2, dPre, ePreBias) if stage == 2: setWeights(c1, dPre, ePreFdfw) setWeights(c2, dPre, ePreBias) if stage == 3: setWeights(c1, dPre, ePreBias) setWeights(c2, dBias, eBiasEns) if stage == 4: setWeights(c1, dPre, ePreBias) setWeights(c2, dBias, eBiasEns) setWeights(c3, dPre, ePreEns) if stage == 5: setWeights(c1, dPre, ePreFdfw) setWeights(c2, dPre, ePreEns) setWeights(c3, dPre, ePreBias) setWeights(c4, dFdfw, eFdfwEns) setWeights(c5, dBias, eBiasEns) if stage == 6: setWeights(c1, dPre, ePreFdfw) setWeights(c2, dPre, ePreEns) setWeights(c3, dPre, ePreBias) setWeights(c4, dFdfw, eFdfwEns) setWeights(c5, dBias, eBiasEns) if stage == 7: setWeights(c1, dPre, ePreFdfw) setWeights(c2, dPre, ePreEns) setWeights(c3, dPre, ePreEns) setWeights(c4, dPre, ePreBias) setWeights(c5, dFdfw, eFdfwEns) setWeights(c6, dFdfw, eFdfwEns) setWeights(c7, dBias, eBiasEns) setWeights(c8, dBias, eBiasEns) setWeights(c9, dBias, eBiasEns) setWeights(c10, dEns, eEnsEns) if stage == 8: setWeights(c1, dPre, ePreFdfw) setWeights(c2, dPre, ePreBias) setWeights(c3, dFdfw, eFdfwEns) setWeights(c4, dBias, eBiasEns) setWeights(c5, dEns, eEnsEns) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) ePreFdfw = c1.e if stage == 1 else ePreFdfw ePreBias = c2.e if stage == 1 else ePreBias eBiasEns = c2.e if stage == 3 else eBiasEns ePreEns = c3.e if stage == 4 else ePreEns eFdfwEns = c4.e if stage == 5 else eFdfwEns eEnsEns = c10.e if stage == 7 else eEnsEns return dict( times=sim.trange(), inptA=sim.data[pInptA], inptB=sim.data[pInptB], inptC=sim.data[pInptC], preA=sim.data[pPreA], fdfw=sim.data[pFdfw], ens=sim.data[pEns], bias=sim.data[pBias], tarFdfw=sim.data[pTarFdfw], tarEns=sim.data[pTarEns], tarBias=sim.data[pTarBias], ePreFdfw=ePreFdfw, ePreEns=ePreEns, ePreBias=ePreBias, eFdfwEns=eFdfwEns, eBiasEns=eBiasEns, eEnsEns=eEnsEns, )
def go(NPre=100, N=100, t=10, m=Uniform(30, 30), i=Uniform(-0.8, 0.8), seed=0, dt=0.001, f=DoubleExp(1e-3, 1e-2), fS=DoubleExp(1e-3, 1e-1), neuron_type=LIF(), d1a=None, d1b=None, d2=None, f1a=None, f1b=None, f2=None, e1a=None, e1b=None, e2=None, l1a=False, l1b=False, l2=False, l3=False, test=False, stim=lambda t: np.sin(t), stim2=lambda t: 0): with nengo.Network(seed=seed) as model: inpt = nengo.Node(stim) intg = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) preInpt = nengo.Ensemble(NPre, 1, radius=3, max_rates=m, seed=seed) preIntg = nengo.Ensemble(NPre, 1, max_rates=m, seed=seed) ens = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed) nengo.Connection(inpt, intg, synapse=1 / s, seed=seed) c0a = nengo.Connection(inpt, preInpt, synapse=None, seed=seed) c0b = nengo.Connection(intg, preIntg, synapse=None, seed=seed) c1a = nengo.Connection(preInpt, ens, synapse=f1a, solver=NoSolver(d1a), seed=seed) pInpt = nengo.Probe(inpt, synapse=None) pIntg = nengo.Probe(intg, synapse=None) pPreInpt = nengo.Probe(preInpt.neurons, synapse=None) pPreIntg = nengo.Probe(preIntg.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) if l1b: # preIntg-to-ens tarEns = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed) nengo.Connection(preIntg, tarEns, synapse=f1b, solver=NoSolver(d1b), seed=seed + 1) c1b = nengo.Connection(preIntg, ens, synapse=f1b, solver=NoSolver(d1b), seed=seed + 1) learnEncoders(c1b, tarEns, fS) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) if l1a: # preInpt-to-ens, given preIntg-to-ens inpt2 = nengo.Node(stim2) tarEns = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed) nengo.Connection(preInpt, tarEns, synapse=f1a, solver=NoSolver(d1a), seed=seed) c0b.transform = 0 nengo.Connection(inpt2, preIntg, synapse=None, seed=seed) nengo.Connection(preIntg, tarEns, synapse=f1b, solver=NoSolver(d1b), seed=seed + 1) c1b = nengo.Connection(preIntg, ens, synapse=f1b, solver=NoSolver(d1b), seed=seed + 1) learnEncoders(c1a, tarEns, fS) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) if l2: # ens readout, given preIntg and preInpt c1b = nengo.Connection(preIntg, ens, synapse=f1b, solver=NoSolver(d1b), seed=seed + 1) if l3: # ens2-to-ens, given preInpt-ens and preIntg-ens2 ens2 = nengo.Ensemble(N, 1, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed) c0a.synapse = f c2a = nengo.Connection(preInpt, ens2, synapse=f1a, solver=NoSolver(d1a), seed=seed) c2b = nengo.Connection(preIntg, ens2, synapse=f1b, solver=NoSolver(d1b), seed=seed + 1) c3 = nengo.Connection(ens2, ens, synapse=f2, solver=NoSolver(d2), seed=seed) learnEncoders(c3, ens2, fS) pTarEns2 = nengo.Probe(ens2.neurons, synapse=None) if test: c5 = nengo.Connection(ens, ens, synapse=f2, solver=NoSolver(d2), seed=seed) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: if isinstance(neuron_type, Bio): if l1b: setWeights(c1b, d1b, e1b) if l1a: setWeights(c1a, d1a, e1a) setWeights(c1b, d1b, e1b) if l2: setWeights(c1a, d1a, e1a) setWeights(c1b, d1b, e1b) if l3: setWeights(c1a, d1a, e1a) setWeights(c2a, d1a, e1a) setWeights(c2b, d1b, e1b) setWeights(c3, d2, e2) if test: setWeights(c1a, d1a, e1a) setWeights(c5, d2, e2) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) else: sim.run(t, progress_bar=True) e1a = c1a.e if l1a else e1a e1b = c1b.e if l1b else e1b e2 = c3.e if l3 else e2 return dict( times=sim.trange(), inpt=sim.data[pInpt], intg=sim.data[pIntg], preInpt=sim.data[pPreInpt], preIntg=sim.data[pPreIntg], ens=sim.data[pEns], tarEns=sim.data[pTarEns] if l1a or l1b else None, tarEns2=sim.data[pTarEns2] if l3 else None, e1a=e1a, e1b=e1b, e2=e2, )
def run(NPre=100, N=100, t=10, nTrain=10, nTest=30, nEnc=10, neuron_type=LIF(), dt=0.001, f=DoubleExp(1e-3, 1e-1), fS=DoubleExp(1e-3, 1e-1), Tff=0.1, Tfb=1.0, reg=1e-3, tauRiseMax=5e-2, tauFallMax=3e-1, load=False, file=None): print('\nNeuron Type: %s' % neuron_type) if load: d1a = np.load(file)['d1a'] d1b = np.load(file)['d1b'] tauRise1a = np.load(file)['tauRise1a'] tauRise1b = np.load(file)['tauRise1b'] tauFall1a = np.load(file)['tauFall1a'] tauFall1b = np.load(file)['tauFall1b'] f1a = DoubleExp(tauRise1a, tauFall1a) f1b = DoubleExp(tauRise1b, tauFall1b) else: print('readout decoders for preInpt and preIntg') spikesInpt = np.zeros((nTrain, int(t / 0.001), NPre)) spikesIntg = np.zeros((nTrain, int(t / 0.001), NPre)) targetsInpt = np.zeros((nTrain, int(t / 0.001), 1)) targetsIntg = np.zeros((nTrain, int(t / 0.001), 1)) for n in range(nTrain): stim = makeSignal(t, f, dt=0.001, seed=n) data = go(NPre=NPre, N=N, t=t, dt=0.001, f=f, fS=fS, neuron_type=LIF(), stim=stim) spikesInpt[n] = data['preInpt'] spikesIntg[n] = data['preIntg'] targetsInpt[n] = f.filt(Tff * data['inpt'], dt=0.001) targetsIntg[n] = f.filt(data['intg'], dt=0.001) d1a, f1a, tauRise1a, tauFall1a, X1a, Y1a, error1a = decode( spikesInpt, targetsInpt, nTrain, dt=0.001, reg=reg, name="integrateNew", tauRiseMax=tauRiseMax, tauFallMax=tauFallMax) d1b, f1b, tauRise1b, tauFall1b, X1b, Y1b, error1b = decode( spikesIntg, targetsIntg, nTrain, dt=0.001, reg=reg, name="integrateNew", tauRiseMax=tauRiseMax, tauFallMax=tauFallMax) np.savez("data/integrateNew_%s.npz" % neuron_type, d1a=d1a, d1b=d1b, tauRise1a=tauRise1a, tauRise1b=tauRise1b, tauFall1a=tauFall1a, tauFall1b=tauFall1b) times = np.arange(0, t * nTrain, 0.001) plotState(times, X1a, Y1a, error1a, "integrateNew", "%s_preInpt" % neuron_type, t * nTrain) plotState(times, X1b, Y1b, error1b, "integrateNew", "%s_preIntg" % neuron_type, t * nTrain) if load: e1a = np.load(file)['e1a'] e1b = np.load(file)['e1b'] elif isinstance(neuron_type, Bio): e1a = np.zeros((NPre, N, 1)) e1b = np.zeros((NPre, N, 1)) print("encoders for preIntg-to-ens") for n in range(nEnc): stim = makeSignal(t, f, dt=dt, seed=n) data = go(d1a=d1a, d1b=d1b, e1a=e1a, e1b=e1b, f1a=f1a, f1b=f1b, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim, l1b=True) e1b = data['e1b'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNew", "preIntgToEns") np.savez("data/integrateNew_%s.npz" % neuron_type, d1a=d1a, d1b=d1b, tauRise1a=tauRise1a, tauRise1b=tauRise1b, tauFall1a=tauFall1a, tauFall1b=tauFall1b, e1a=e1a, e1b=e1b) print("encoders for preInpt-to-ens") for n in range(nEnc): stim = makeSignal(t, f, dt=dt, seed=n) # stim2 = makeSignal(t, f, dt=dt, seed=n, value=0.5) # stim2 = makeSignal(t, f, dt=dt, norm='u', freq=0.25, value=0.8, seed=100+n) stim2 = makeSin(t, f, dt=dt, seed=n) data = go(d1a=d1a, d1b=d1b, e1a=e1a, e1b=e1b, f1a=f1a, f1b=f1b, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim, l1a=True, stim2=stim2) e1a = data['e1a'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNew", "preInptToEns") np.savez("data/integrateNew_%s.npz" % neuron_type, d1a=d1a, d1b=d1b, tauRise1a=tauRise1a, tauRise1b=tauRise1b, tauFall1a=tauFall1a, tauFall1b=tauFall1b, e1a=e1a, e1b=e1b) else: e1a = np.zeros((NPre, N, 1)) e1b = np.zeros((NPre, N, 1)) if load: d2 = np.load(file)['d2'] tauRise2 = np.load(file)['tauRise2'] tauFall2 = np.load(file)['tauFall2'] f2 = DoubleExp(tauRise2, tauFall2) else: print('readout decoders for ens') spikes = np.zeros((nTrain, int(t / dt), N)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stim = makeSignal(t, f, dt=dt, seed=n) data = go(d1a=d1a, d1b=d1b, e1a=e1a, e1b=e1b, f1a=f1a, f1b=f1b, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim, l2=True) spikes[n] = data['ens'] targets[n] = f.filt(Tfb * data['intg'], dt=dt) d2, f2, tauRise2, tauFall2, X, Y, error = decode(spikes, targets, nTrain, dt=dt, reg=reg, tauRiseMax=tauRiseMax, tauFallMax=tauFallMax, name="integrateNew") np.savez("data/integrateNew_%s.npz" % neuron_type, d1a=d1a, d1b=d1b, tauRise1a=tauRise1a, tauRise1b=tauRise1b, tauFall1a=tauFall1a, tauFall1b=tauFall1b, e1a=e1a, e1b=e1b, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "integrateNew", "%s_ens" % neuron_type, t * nTrain) if load: e2 = np.load(file)['e2'] elif isinstance(neuron_type, Bio): print("encoders from ens2 to ens") e2 = np.zeros((N, N, 1)) for n in range(nEnc): stim = makeSignal(t, f, dt=dt, seed=n) #stim = makeSin(t, f, dt=dt, seed=n) data = go(d1a=d1a, d1b=d1b, d2=d2, e1a=e1a, e1b=e1b, e2=e2, f1a=f1a, f1b=f1b, f2=f2, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim, l3=True) e2 = data['e2'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns2'], "integrateNew", "Ens2Ens") np.savez("data/integrateNew_%s.npz" % neuron_type, d1a=d1a, d1b=d1b, tauRise1a=tauRise1a, tauRise1b=tauRise1b, tauFall1a=tauFall1a, tauFall1b=tauFall1b, e1a=e1a, e1b=e1b, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2) else: e2 = np.zeros((N, N, 1)) print("testing") errors = np.zeros((nTest)) for test in range(nTest): stim = makeSignal(t, f, dt=dt, seed=200 + test) data = go(d1a=d1a, d2=d2, e1a=e1a, e2=e2, f1a=f1a, f2=f2, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, stim=stim, test=True) A = f2.filt(data['ens'], dt=dt) X = np.dot(A, d2) Y = f.filt(data['intg'], dt=dt) U = f.filt(f.filt(Tff * data['inpt'], dt=dt)) error = rmse(X, Y) errorU = rmse(X, U) errors[test] = error plotState(data['times'], X, Y, error, "integrateNew", "%s_test%s" % (neuron_type, test), t) #plotState(data['times'], X, U, errorU, "integrateNew", "%s_inpt%s"%(neuron_type, test), t) print('%s errors:' % neuron_type, errors) np.savez("data/integrateNew_%s.npz" % neuron_type, d1a=d1a, d1b=d1b, tauRise1a=tauRise1a, tauRise1b=tauRise1b, tauFall1a=tauFall1a, tauFall1b=tauFall1b, e1a=e1a, e1b=e1b, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2, errors=errors) return errors
def run(n_neurons=100, t=20, t_test=10, t_enc=30, dt=0.001, f=DoubleExp(1e-2, 2e-1), penalty=0, reg=1e-1, freq=1, tt=5.0, tt_test=5.0, neuron_type=LIF(), load_fd=False, load_w=None, supervised=False): d_ens = np.zeros((n_neurons, 2)) f_ens = f w_ff = None w_fb = None e_ff = None e_fb = None f_smooth = DoubleExp(1e-2, 2e-1) print('Neuron Type: %s' % neuron_type) if isinstance(neuron_type, DurstewitzNeuron): if load_w: w_ff = np.load(load_w)['w_ff'] e_ff = np.load(load_w)['e_ff'] else: print('optimizing encoders from pre to ens') data = go(d_ens, f_ens, n_neurons=n_neurons, t=t_enc + tt, f=f, dt=dt, neuron_type=neuron_type, w_ff=w_ff, e_ff=e_ff, L_ff=True) w_ff = data['w_ff'] e_ff = data['e_ff'] np.savez('data/oscillate_w.npz', w_ff=w_ff, e_ff=e_ff) fig, ax = plt.subplots() sns.distplot(np.ravel(w_ff), ax=ax, kde=False) ax.set(xlabel='weights', ylabel='frequency') plt.savefig("plots/tuning/oscillate_%s_w_ff.pdf" % (neuron_type)) a_ens = f_smooth.filt(data['ens'], dt=dt) a_supv = f_smooth.filt(data['supv'], dt=dt) for n in range(n_neurons): fig, ax = plt.subplots(1, 1) ax.plot(data['times'], a_supv[:, n], alpha=0.5, label='supv') ax.plot(data['times'], a_ens[:, n], alpha=0.5, label='ens') ax.set(ylim=((0, 40))) plt.legend() plt.savefig('plots/tuning/oscillate_pre_ens_activity_%s.pdf' % (n)) plt.close('all') if load_fd: load = np.load(load_fd) d_ens = load['d_ens'] taus_ens = load['taus_ens'] f_ens = DoubleExp(taus_ens[0], taus_ens[1]) else: print('gathering filter/decoder training data for ens') data = go(d_ens, f_ens, n_neurons=n_neurons, t=t + tt, f=f, dt=dt, neuron_type=neuron_type, w_ff=w_ff, L_fd=True) trans = int(tt / dt) d_ens, f_ens, taus_ens = df_opt(data['u'][trans:], data['ens'][trans:], f, dt=dt, name='oscillate_%s' % neuron_type, reg=reg, penalty=penalty) np.savez('data/oscillate_%s_fd.npz' % neuron_type, d_ens=d_ens, taus_ens=taus_ens) times = np.arange(0, 1, 0.0001) fig, ax = plt.subplots() ax.plot(times, f.impulse(len(times), dt=0.0001), label=r"$f^x, \tau_1=%.3f, \tau_2=%.3f$" % (-1. / f.poles[0], -1. / f.poles[1])) ax.plot(times, f_ens.impulse(len(times), dt=0.0001), label=r"$f^{ens}, \tau_1=%.3f, \tau_2=%.3f, d: %s/%s$" % (-1. / f_ens.poles[0], -1. / f_ens.poles[1], np.count_nonzero(d_ens), n_neurons)) ax.set(xlabel='time (seconds)', ylabel='impulse response', ylim=((0, 10))) ax.legend(loc='upper right') plt.tight_layout() plt.savefig("plots/oscillate_%s_filters_ens.pdf" % neuron_type) a_ens = f_ens.filt(data['ens'], dt=dt) x = f.filt(data['u'], dt=dt) xhat_ens = np.dot(a_ens, d_ens) rmse_ens = rmse(xhat_ens, x) fig, ax = plt.subplots() ax.plot(data['times'], x, linestyle="--", label='x') ax.plot(data['times'], xhat_ens, label='ens, rmse=%.3f' % rmse_ens) ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="pre_ens") plt.legend(loc='upper right') plt.savefig("plots/oscillate_%s_pre_ens_train.pdf" % neuron_type) if isinstance(neuron_type, DurstewitzNeuron): if load_w: w_fb = np.load(load_w)['w_fb'] e_fb = np.load(load_w)['e_fb'] else: print('optimizing encoders from supv to ens') data = go(d_ens, f_ens, n_neurons=n_neurons, t=t_enc + tt, f=f, dt=dt, neuron_type=neuron_type, w_ff=w_ff, w_fb=w_fb, e_fb=e_fb, L_fb=True) w_fb = data['w_fb'] e_fb = data['e_fb'] np.savez('data/oscillate_w.npz', w_ff=w_ff, e_ff=e_ff, w_fb=w_fb, e_fb=e_fb) fig, ax = plt.subplots() sns.distplot(np.ravel(w_fb), ax=ax, kde=False) ax.set(xlabel='weights', ylabel='frequency') plt.savefig("plots/tuning/oscillate_%s_w_fb.pdf" % (neuron_type)) a_ens = f_smooth.filt(data['ens'], dt=dt) a_supv = f_smooth.filt(data['supv'], dt=dt) # a_supv2 = f_smooth.filt(data['supv2'], dt=dt) for n in range(n_neurons): fig, ax = plt.subplots(1, 1) ax.plot(data['times'], a_supv[:, n], alpha=0.5, label='supv') # ax.plot(data['times'], a_supv2[:,n], alpha=0.5, label='supv2') ax.plot(data['times'], a_ens[:, n], alpha=0.5, label='ens') ax.set(ylim=((0, 40))) plt.legend() plt.savefig('plots/tuning/oscillate_supv_ens_activity_%s.pdf' % (n)) plt.close('all') print("Testing") if supervised: data = go(d_ens, f_ens, n_neurons=n_neurons, t=t_test + tt_test, f=f, dt=dt, neuron_type=neuron_type, w_ff=w_ff, w_fb=w_fb, supervised=True) a_ens = f_ens.filt(data['ens'], dt=dt) a_supv = f_ens.filt(data['supv'], dt=dt) # a_supv2 = f_ens.filt(data['supv2'], dt=dt) xhat_ens_0 = np.dot(a_ens, d_ens)[:, 0] xhat_ens_1 = np.dot(a_ens, d_ens)[:, 1] xhat_supv_0 = np.dot(a_supv, d_ens)[:, 0] xhat_supv_1 = np.dot(a_supv, d_ens)[:, 1] # xhat_supv2_0 = np.dot(a_supv2, d_ens)[:,0] # xhat_supv2_1 = np.dot(a_supv2, d_ens)[:,1] x_0 = f.filt(data['u'], dt=dt)[:, 0] x_1 = f.filt(data['u'], dt=dt)[:, 1] x2_0 = f.filt(x_0, dt=dt) x2_1 = f.filt(x_1, dt=dt) times = data['times'] fig, ax = plt.subplots() ax.plot(times, x_0, linestyle="--", label='x_0') ax.plot(times, x2_0, linestyle="--", label='x2_0') ax.plot(times, xhat_supv_0, label='supv') ax.plot(times, xhat_ens_0, label='ens') # ax.plot(times, xhat_supv2_0, label='supv2') ax.set(xlim=((0, t_test)), ylim=((-1, 1)), xlabel='time (s)', ylabel=r'$\mathbf{x}$') plt.legend(loc='upper right') plt.savefig("plots/oscillate_%s_supervised_0.pdf" % neuron_type) fig, ax = plt.subplots() ax.plot(times, x_1, linestyle="--", label='x_1') ax.plot(times, x2_1, linestyle="--", label='x2_1') ax.plot(times, xhat_supv_1, label='supv') ax.plot(times, xhat_ens_1, label='ens') # ax.plot(times, xhat_supv2_1, label='supv2') ax.set(xlim=((0, t_test)), ylim=((-1, 1)), xlabel='time (s)', ylabel=r'$\mathbf{x}$') plt.legend(loc='upper right') plt.savefig("plots/oscillate_%s_supervised_1.pdf" % neuron_type) else: data = go(d_ens, f_ens, n_neurons=n_neurons, t=t_test + tt_test, f=f, dt=dt, neuron_type=neuron_type, w_ff=w_ff, w_fb=w_fb) a_ens = f_ens.filt(data['ens'], dt=dt) xhat_ens_0 = np.dot(a_ens, d_ens)[:, 0] xhat_ens_1 = np.dot(a_ens, d_ens)[:, 1] x_0 = f.filt(data['u'], dt=dt)[:, 0] x_1 = f.filt(data['u'], dt=dt)[:, 1] x2_0 = f.filt(x_0, dt=dt) x2_1 = f.filt(x_1, dt=dt) times = data['times'] # fig, ax = plt.subplots() # ax.plot(times, x_0, linestyle="--", label='x0') # # ax.plot(times, sinusoid_0, label='best fit sinusoid_0') # ax.plot(times, xhat_ens_0, label='ens') # ax.set(xlim=((0, t_test)), ylim=((-1, 1)), xlabel='time (s)', ylabel=r'$\mathbf{x}$') # plt.legend(loc='upper right') # plt.savefig("plots/oscillate_%s_test_0.pdf"%neuron_type) # fig, ax = plt.subplots() # ax.plot(times, x_1, linestyle="--", label='x1') # # ax.plot(times, sinusoid_1, label='best fit sinusoid_1') # ax.plot(times, xhat_ens_1, label='ens') # ax.set(xlim=((0, t_test)), ylim=((-1, 1)), xlabel='time (s)', ylabel=r'$\mathbf{x}$') # plt.legend(loc='upper right') # plt.savefig("plots/oscillate_%s_test_1.pdf"%neuron_type) # curve fit to a sinusoid of arbitrary frequency, phase, magnitude print('Curve fitting') trans = int(tt_test / dt) step = int(0.001 / dt) def sinusoid(t, freq, phase, mag, dt=dt): # mag return f.filt(mag * np.sin(t * 2 * np.pi * freq + 2 * np.pi * phase), dt=dt) p0 = [1, 0, 1] param_0, _ = curve_fit(sinusoid, times[trans:], xhat_ens_0[trans:], p0=p0) param_1, _ = curve_fit(sinusoid, times[trans:], xhat_ens_1[trans:], p0=p0) print('param0', param_0) print('param1', param_1) sinusoid_0 = sinusoid(times, param_0[0], param_0[1], param_0[2]) sinusoid_1 = sinusoid(times, param_1[0], param_1[1], param_1[2]) # error is rmse of xhat and best fit sinusoid times freq error of best fit sinusoid to x freq_error_0 = np.abs(freq - param_0[1]) freq_error_1 = np.abs(freq - param_1[1]) rmse_0 = rmse(xhat_ens_0[trans::step], sinusoid_0[trans::step]) rmse_1 = rmse(xhat_ens_1[trans::step], sinusoid_1[trans::step]) scaled_rmse_0 = (1 + freq_error_0) * rmse_0 scaled_rmse_1 = (1 + freq_error_1) * rmse_1 fig, ax = plt.subplots() ax.plot(times, x_0, linestyle="--", label='x0') ax.plot(times, sinusoid_0, label='best fit sinusoid_0') ax.plot(times, xhat_ens_0, label='ens, scaled rmse=%.3f' % scaled_rmse_0) ax.axvline(tt_test, label=r"$t_{transient}$") ax.set(ylim=((-1, 1)), xlabel='time (s)', ylabel=r'$\mathbf{x}$') plt.legend(loc='upper right') plt.savefig("plots/oscillate_%s_test_0.pdf" % neuron_type) fig, ax = plt.subplots() ax.plot(times, x_1, linestyle="--", label='x1') ax.plot(times, sinusoid_1, label='best fit sinusoid_1') ax.plot(times, xhat_ens_1, label='ens, scaled rmse=%.3f' % scaled_rmse_1) ax.axvline(tt_test, label=r"$t_{transient}$") ax.set(ylim=((-1, 1)), xlabel='time (s)', ylabel=r'$\mathbf{x}$') plt.legend(loc='upper right') plt.savefig("plots/oscillate_%s_test_1.pdf" % neuron_type) print('scaled rmses: ', scaled_rmse_0, scaled_rmse_1) mean = np.mean([scaled_rmse_0, scaled_rmse_1]) fig, ax = plt.subplots() sns.barplot(data=np.array([mean])) ax.set(ylabel='Scaled RMSE', title="mean=%.3f" % mean) plt.xticks() plt.savefig("plots/oscillate_%s_scaled_rmse.pdf" % neuron_type) np.savez('data/oscillate_%s_results.npz' % neuron_type, scaled_rmse_0=scaled_rmse_0, scaled_rmse_1=scaled_rmse_1) return mean
def run(NPre=100, N=100, t=10, nTrain=10, nTest=3, nEnc=10, dt=0.001, c=None, fPre=DoubleExp(1e-3, 1e-1), fNMDA=DoubleExp(10.6e-3, 285e-3), fGABA=DoubleExp(0.5e-3, 1.5e-3), fS=DoubleExp(1e-3, 1e-1), Tff=0.3, Tneg=-1, reg=1e-2, load=[], file=None, DATest=lambda t: 0): if not c: c = t if 0 in load: dPreA = np.load(file)['dPreA'] dPreB = np.load(file)['dPreB'] dPreC = np.load(file)['dPreC'] else: print('readout decoders for pre[A,B,C]') spikesInptA = np.zeros((nTrain, int(t/dt), NPre)) spikesInptB = np.zeros((nTrain, int(t/dt), NPre)) spikesInptC = np.zeros((nTrain, int(t/dt), NPre)) targetsInptA = np.zeros((nTrain, int(t/dt), 1)) targetsInptB = np.zeros((nTrain, int(t/dt), 1)) targetsInptC = np.zeros((nTrain, int(t/dt), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimB, stage=0) spikesInptA[n] = data['preA'] spikesInptB[n] = data['preB'] spikesInptC[n] = data['preC'] targetsInptA[n] = fPre.filt(data['inptA'], dt=dt) targetsInptB[n] = fPre.filt(data['inptB'], dt=dt) targetsInptC[n] = fPre.filt(data['inptC'], dt=dt) dPreA, XA, YA, errorA = decodeNoF(spikesInptA, targetsInptA, nTrain, fPre, dt=dt, reg=reg) dPreB, XB, YB, errorB = decodeNoF(spikesInptB, targetsInptB, nTrain, fPre, dt=dt, reg=reg) dPreC, XC, YC, errorC = decodeNoF(spikesInptC, targetsInptC, nTrain, fPre, dt=dt, reg=reg) np.savez("data/integrateNMDA.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC) times = np.arange(0, t*nTrain, dt) plotState(times, XA, YA, errorA, "integrateNMDA", "preA", t*nTrain) plotState(times, XB, YB, errorB, "integrateNMDA", "preB", t*nTrain) plotState(times, XC, YC, errorC, "integrateNMDA", "preC", t*nTrain) if 1 in load: ePreA = np.load(file)['ePreA'] ePreB = np.load(file)['ePreB'] ePreC = np.load(file)['ePreC'] else: print("encoders for pre[A,B,C] to [fdfw, ens, inh]") ePreA = np.zeros((NPre, N, 1)) ePreB = np.zeros((NPre, N, 1)) ePreC = np.zeros((NPre, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimB, dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, stage=1) ePreA = data['ePreA'] ePreB = data['ePreB'] ePreC = data['ePreC'] plotActivity(t, dt, fS, data['times'], data['fdfw'], data['tarFdfw'], "integrateNMDA", "preAFdfw") plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNMDA", "preBEns") plotActivity(t, dt, fS, data['times'], data['inh'], data['tarInh'], "integrateNMDA", "preCInh") np.savez("data/integrateNMDA.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC) if 2 in load: dFdfw = np.load(file)['dFdfw'] dInh = np.load(file)['dInh'] else: print('readout decoders for fdfw and inh') spikesFdfw = np.zeros((nTrain, int(t/dt), N)) spikesInh = np.zeros((nTrain, int(t/dt), N)) targetsFdfw = np.zeros((nTrain, int(t/dt), 1)) targetsInh = np.zeros((nTrain, int(t/dt), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) stimC = lambda x: 0.5+0.5*np.sin(2*np.pi*x/t) data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimC, dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, stage=2) spikesFdfw[n] = data['fdfw'] spikesInh[n] = data['inh'] targetsFdfw[n] = fNMDA.filt(Tff*fPre.filt(data['inptA'], dt=dt)) targetsInh[n] = fGABA.filt(fPre.filt(data['inptC'], dt=dt)) dFdfw, X1, Y1, error1 = decodeNoF(spikesFdfw, targetsFdfw, nTrain, fNMDA, dt=dt, reg=reg) dInh, X2, Y2, error2 = decodeNoF(spikesInh, targetsInh, nTrain, fGABA, dt=dt, reg=reg) np.savez("data/integrateNMDA.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dFdfw=dFdfw, dInh=dInh, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC) times = np.arange(0, t*nTrain, dt) plotState(times, X1, Y1, error1, "integrateNMDA", "fdfw", t*nTrain) plotState(times, X2, Y2, error2, "integrateNMDA", "inh", t*nTrain) if 3 in load: eFdfw = np.load(file)['eFdfw'] else: print("encoders for fdfw-to-ens") eFdfw = np.zeros((N, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, Tff=Tff, dPreA=dPreA, dPreB=dPreB, dFdfw=dFdfw, ePreA=ePreA, ePreB=ePreB, eFdfw=eFdfw, stage=3) eFdfw = data['eFdfw'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNMDA", "fdfwEns") np.savez("data/integrateNMDA.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dFdfw=dFdfw, dInh=dInh, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, eFdfw=eFdfw) if 4 in load: dBio = np.load(file)['dBio'] dNeg = np.load(file)['dNeg'] # dNeg = -np.array(dBio) else: print('readout decoders for ens') spikes = np.zeros((nTrain, int(t/dt), N)) targets = np.zeros((nTrain, int(t/dt), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, dPreA=dPreA, dPreB=dPreB, dFdfw=dFdfw, ePreA=ePreA, ePreB=ePreB, eFdfw=eFdfw, stage=4) spikes[n] = data['ens'] targets[n] = fNMDA.filt(fPre.filt(data['inptB'])) # targets[n] = fNMDA.filt( # fPre.filt(fNMDA.filt(data['inptB'])) + # fNMDA.filt(Tff*fPre.filt(data['inptA']))) dBio, X, Y, error = decodeNoF(spikes, targets, nTrain, fNMDA, dt=dt, reg=reg) dNeg = -np.array(dBio) np.savez("data/integrateNMDA.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dFdfw=dFdfw, dInh=dInh, dBio=dBio, dNeg=dNeg, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, eFdfw=eFdfw) times = np.arange(0, t*nTrain, dt) plotState(times, X, Y, error, "integrateNMDA", "ens", t*nTrain) if 5 in load: eBio = np.load(file)['eBio'] else: print("encoders from ens to ens") eBio = np.zeros((N, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, dPreA=dPreA, dPreB=dPreB, dFdfw=dFdfw, dBio=dBio, ePreA=ePreA, ePreB=ePreB, eFdfw=eFdfw, eBio=eBio, stage=5) eBio = data['eBio'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateNMDA", "ensEns") np.savez("data/integrateNMDA.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dFdfw=dFdfw, dBio=dBio, dInh=dInh, dNeg=dNeg, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, eFdfw=eFdfw, eBio=eBio) if 6 in load: eNeg = np.load(file)['eNeg'] eInh = np.load(file)['eInh'] else: print("encoders from [ens, inh] to fdfw") eNeg = np.zeros((N, N, 1)) eInh = np.zeros((N, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=n) stimC = lambda t: 0 if t<c else 1 data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimC, dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dFdfw=dFdfw, dBio=dBio, dNeg=dNeg, dInh=dInh, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, eFdfw=eFdfw, eBio=eBio, eNeg=eNeg, eInh=eInh, stage=6) eNeg = data['eNeg'] eInh = data['eInh'] plotActivity(t, dt, fS, data['times'], data['fdfw2'], data['tarFdfw2'], "integrateNMDA", "ensFdfw") plotActivity(t, dt, fS, data['times'], data['fdfw4'], data['tarFdfw4'], "integrateNMDA", "inhFdfw") np.savez("data/integrateNMDA.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dFdfw=dFdfw, dBio=dBio, dNeg=dNeg, dInh=dInh, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, eFdfw=eFdfw, eBio=eBio, eNeg=eNeg, eInh=eInh) # eNeg = None # eInh = None print("testing") vals = np.linspace(-1, 1, nTest) for test in range(nTest): stimA = lambda t: vals[test] if t<c else 0 stimC = lambda t: 0 if t<c else 1 data = go( NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimC=stimC, dPreA=dPreA, dPreC=dPreC, dFdfw=dFdfw, dBio=dBio, dNeg=Tneg*dNeg, dInh=dInh, ePreA=ePreA, ePreC=ePreC, eFdfw=eFdfw, eBio=eBio, eNeg=eNeg, eInh=eInh, stage=7, c=c, DA=DATest) aFdfw = fNMDA.filt(data['fdfw'], dt=dt) aBio = fNMDA.filt(data['ens'], dt=dt) aInh = fGABA.filt(data['inh'], dt=dt) xhatFdfw = np.dot(aFdfw, dFdfw)/Tff xhatBio = np.dot(aBio, dBio) xhatInh = np.dot(aInh, dInh) xFdfw = fNMDA.filt(fNMDA.filt(fPre.filt(data['inptA'], dt=dt), dt=dt), dt=dt) xBio = xFdfw[int(c/dt)] * np.ones_like(data['times']) errorBio = rmse(xhatBio[int(c/dt):], xBio[int(c/dt):]) fig, ax = plt.subplots() ax.plot(data['times'], xFdfw, alpha=0.5, label="input (filtered)") ax.plot(data['times'], xhatFdfw, alpha=0.5, label="fdfw") ax.plot(data['times'], xBio, label="target") ax.plot(data['times'], xhatBio, alpha=0.5, label="ens, rmse=%.3f"%errorBio) ax.plot(data['times'], xhatInh, alpha=0.5, label="inh") ax.axvline(c, label="cutoff") ax.set(xlabel='time', ylabel='state', xlim=((0, t)), ylim=((-1.5, 1.5))) ax.legend(loc='upper left') sns.despine() fig.savefig("plots/integrateNMDA_testFlat%s.pdf"%test) stimA, stimB = makeSignal(t, fPre, fNMDA, dt=dt, seed=200+test) stimC = lambda t: 0 data = go(NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimC, Tff=Tff, dPreA=dPreA, dPreC=dPreC, dFdfw=dFdfw, dBio=dBio, dNeg=None, dInh=dInh, ePreA=ePreA, ePreC=ePreC, eFdfw=eFdfw, eBio=eBio, eNeg=None, eInh=eInh, stage=7, DA=DATest) aFdfw = fNMDA.filt(data['fdfw'], dt=dt) aBio = fNMDA.filt(data['ens'], dt=dt) xhatFdfw = np.dot(aFdfw, dFdfw) xhatBio = np.dot(aBio, dBio) xhatNeg = np.dot(aBio, dNeg) xFdfw = fNMDA.filt(fPre.filt(data['inptA'], dt=dt), dt=dt) xBio = fNMDA.filt(fPre.filt(data['inptB'], dt=dt), dt=dt) errorBio = rmse(xhatBio, xBio) fig, ax = plt.subplots() ax.plot(data['times'], xhatFdfw, alpha=0.5, label="fdfw") ax.plot(data['times'], fNMDA.filt(Tff*xFdfw, dt=dt), alpha=0.5, label="input (filtered)") ax.plot(data['times'], xBio, label="target") ax.plot(data['times'], xhatBio, alpha=0.5, label="ens, rmse=%.3f"%errorBio) ax.set(xlabel='time', ylabel='state', xlim=((0, t)), ylim=((-1.5, 1.5))) ax.legend(loc='upper left') sns.despine() fig.savefig("plots/integrateNMDA_testWhite%s.pdf"%test) plt.close('all')
def medium(N=300, t=10, dt=0.001, nTrain=5, nTest=5, fAMPA=DoubleExp(0.55e-3, 2.2e-3), fNMDA=DoubleExp(2.3e-3, 95.0e-3), fGABA=DoubleExp(0.5e-3, 1.5e-3), daAMPA=0.8, daNMDA=0.7, daGABA=0.8, kEnsEnsAMPA=0.2, kEnsEnsNMDA=0.85, kEnsInhAMPA=0.1, kEnsInhNMDA=1.0, kGABAFdfw=-4.0, kGABAEns=-1e-3, T=0.05): print("readout decoders for fdfw") targetsAMPA = np.zeros((1, 1)) targetsNMDA = np.zeros((1, 1)) asAMPA = np.zeros((1, N)) asNMDA = np.zeros((1, N)) for n in range(nTrain): stim = makeSignalEven(t, dt=dt, value=(n + 1) / nTrain) # stim = makeSignalPos(t, fNMDA, dt=dt, seed=n) data = goLIF(N=N, stim=stim, t=t, dt=dt, fAMPA=fAMPA, fNMDA=fNMDA, fGABA=fGABA) asAMPA = np.append(asAMPA, fAMPA.filt(data['fdfw']), axis=0) asNMDA = np.append(asNMDA, fNMDA.filt(data['fdfw']), axis=0) targetsAMPA = np.append(targetsAMPA, fAMPA.filt(data['inpt']), axis=0) targetsNMDA = np.append(targetsNMDA, fNMDA.filt(data['inpt']), axis=0) # dFdfwEnsAMPA, _ = LstsqL2(reg=1e-1)(asAMPA, np.ravel(targetsAMPA)) # dFdfwEnsNMDA, _ = LstsqL2(reg=1e-1)(asNMDA, np.ravel(targetsNMDA)) dFdfwEnsAMPA, _ = nnls(asAMPA, np.ravel(targetsAMPA)) dFdfwEnsNMDA, _ = nnls(asNMDA, np.ravel(targetsNMDA)) dFdfwEnsAMPA = dFdfwEnsAMPA.reshape((N, 1)) dFdfwEnsNMDA = dFdfwEnsNMDA.reshape((N, 1)) xhatFFAMPA = np.dot(asAMPA, dFdfwEnsAMPA) xhatFFNMDA = np.dot(asNMDA, dFdfwEnsNMDA) fig, ax = plt.subplots() ax.plot(targetsAMPA, linestyle="--", label='target (AMPA)') ax.plot(targetsNMDA, linestyle="--", label='target (NMDA)') ax.plot(xhatFFAMPA, alpha=0.5, label='fdfw (AMPA)') ax.plot(xhatFFNMDA, alpha=0.5, label='fdfw (NMDA)') ax.legend(loc="upper right") ax.set(ylim=((0, 1)), xlabel="time (s)", ylabel=r"$\mathbf{\hat{x}}(t)$") fig.savefig("plots/gatedMemory_goLIF_fdfw.pdf") print( "readout decoders for ens, given AMPA and NMDA from fdfw in high DA condition" ) targetsAMPA = np.zeros((1, 1)) targetsNMDA = np.zeros((1, 1)) asAMPA = np.zeros((1, N)) asNMDA = np.zeros((1, N)) for n in range(nTrain): stim = makeSignalEven(t, dt=dt, value=(n + 1) / nTrain) # stim = makeSignalPos(t, fNMDA, dt=dt, seed=n) data = goLIF(N=N, stim=stim, t=t, dt=dt, fAMPA=fAMPA, fNMDA=fNMDA, fGABA=fGABA, dFdfwEnsAMPA=0 * dFdfwEnsAMPA, dFdfwEnsNMDA=dFdfwEnsNMDA) asAMPA = np.append(asAMPA, fAMPA.filt(data['ens']), axis=0) asNMDA = np.append(asNMDA, fNMDA.filt(data['ens']), axis=0) targetsAMPA = np.append(targetsAMPA, fAMPA.filt(fNMDA.filt(data['inpt'])), axis=0) targetsNMDA = np.append(targetsNMDA, fNMDA.filt(fNMDA.filt(data['inpt'])), axis=0) # dEnsEnsAMPA, _ = LstsqL2(reg=1e-1)(asAMPA, kAMPA*np.ravel(targetsAMPA)) # dEnsEnsNMDA, _ = LstsqL2(reg=1e-1)(asNMDA, kNMDA*np.ravel(targetsNMDA)) dEnsEnsAMPA, _ = nnls(asAMPA, kEnsEnsAMPA * np.ravel(targetsAMPA)) dEnsEnsNMDA, _ = nnls(asNMDA, kEnsEnsNMDA * np.ravel(targetsNMDA)) dEnsEnsAMPA = dEnsEnsAMPA.reshape((N, 1)) dEnsEnsNMDA = dEnsEnsNMDA.reshape((N, 1)) dEnsInhAMPA, _ = nnls(asAMPA, kEnsInhAMPA * np.ravel(targetsAMPA)) dEnsInhNMDA, _ = nnls(asNMDA, kEnsInhNMDA * np.ravel(targetsNMDA)) dEnsInhAMPA = dEnsInhAMPA.reshape((N, 1)) dEnsInhNMDA = dEnsInhNMDA.reshape((N, 1)) xhatFBAMPA = np.dot(asAMPA, dEnsEnsAMPA) xhatFBNMDA = np.dot(asNMDA, dEnsEnsNMDA) xhatConstAMPA = np.dot(asAMPA, dEnsInhAMPA) xhatConstNMDA = np.dot(asNMDA, dEnsInhNMDA) fig, ax = plt.subplots() ax.plot(kEnsEnsAMPA * targetsAMPA, linestyle="--", label='target (AMPA)') ax.plot(kEnsEnsNMDA * targetsNMDA, linestyle="--", label='target (NMDA)') ax.plot(xhatFBAMPA, alpha=0.5, label='ens (AMPA)') ax.plot(xhatFBNMDA, alpha=0.5, label='ens (NMDA)') ax.legend(loc="upper right") ax.set(ylim=((0, 1)), xlabel="time (s)", ylabel=r"$\mathbf{\hat{x}}(t)$") fig.savefig("plots/gatedMemory_goLIF_ens.pdf") print( "readout decoders for inh, given ff and fb AMPA and NMDA and high DA") targetsGABA = np.zeros((1, 1)) asGABA = np.zeros((1, N)) for n in range(nTrain): stim = makeSignalEven(t, dt=dt, value=(n + 1) / nTrain) # stim = makeSignalPos(t, fNMDA, dt=dt, seed=n) data = goLIF(N=N, stim=stim, t=t, dt=dt, fAMPA=fAMPA, fNMDA=fNMDA, fGABA=fGABA, dFdfwEnsAMPA=daAMPA * dFdfwEnsAMPA, dFdfwEnsNMDA=dFdfwEnsNMDA, dEnsInhAMPA=daAMPA * dEnsInhAMPA, dEnsInhNMDA=dEnsInhNMDA) asGABA = np.append(asGABA, fGABA.filt(data['inh']), axis=0) targetsGABA = np.append(targetsGABA, fGABA.filt(fNMDA.filt(data['inpt'])), axis=0) dInhEnsGABA, _ = nnls(-asGABA, kGABAEns * np.ravel(targetsGABA)) dInhFdfwGABA, _ = nnls(-asGABA, kGABAFdfw * np.ravel(targetsGABA)) dInhEnsGABA = -dInhEnsGABA.reshape((N, 1)) dInhFdfwGABA = -dInhFdfwGABA.reshape((N, 1)) xhatInhEns = np.dot(asGABA, dInhEnsGABA) xhatInhFdfw = np.dot(asGABA, dInhFdfwGABA) fig, ax = plt.subplots() ax.plot(kGABAEns * targetsGABA, linestyle="--", label='target (ens)') ax.plot(kGABAFdfw * targetsGABA, linestyle="--", label='target (fdfw)') ax.plot(xhatInhEns, alpha=0.5, label='inh (ens)') ax.plot(xhatInhFdfw, alpha=0.5, label='inh (fdfw)') ax.legend(loc="upper right") ax.set(ylim=((-1, 0)), xlabel="time (s)", ylabel=r"$\mathbf{\hat{x}}(t)$") fig.savefig("plots/gatedMemory_goLIF_inh.pdf") # Test in high and low DA print('testing with high and low DA') for n in range(nTest): stim = makeSignalSquare(t, dt=dt, seed=100 + n) # data = goLIF(N=N, stim=lambda t: 0, x0=n/nTest, t=t, dt=dt, data = goLIF(N=N, stim=stim, t=t, dt=dt, fAMPA=fAMPA, fNMDA=fNMDA, fGABA=fGABA, dFdfwEnsAMPA=daAMPA * T * dFdfwEnsAMPA, dFdfwEnsNMDA=T * dFdfwEnsNMDA, dEnsEnsAMPA=daAMPA * dEnsEnsAMPA, dEnsEnsNMDA=dEnsEnsNMDA, dEnsInhAMPA=daAMPA * dEnsInhAMPA, dEnsInhNMDA=dEnsInhNMDA, dInhEnsGABA=dInhEnsGABA, dInhFdfwGABA=dInhFdfwGABA) aFdfwNMDA = fNMDA.filt(data['fdfw']) targetFdfwNMDA = fNMDA.filt(data['inpt']) xhatFdfwNMDA = np.dot(aFdfwNMDA, dFdfwEnsNMDA) aEnsNMDA = fNMDA.filt(data['ens']) targetIntgNMDA = fNMDA.filt(data['intg']) # targetFlatNMDA = n/nTest*np.ones((aEnsNMDA.shape[0])) xhatIntgNMDA = np.dot(aEnsNMDA, dEnsEnsNMDA) fig, (ax, ax2) = plt.subplots(ncols=1, nrows=2, sharex=True) ax.plot(data['times'], targetFdfwNMDA, linestyle="--", label='input (NMDA)') ax.plot(data['times'], xhatFdfwNMDA, alpha=0.5, label='fdfw (NMDA)') ax.plot(data['times'], targetIntgNMDA, linestyle="--", label='integral (NMDA)') # ax.plot(data['times'], targetFlatNMDA, linestyle="--", label='flat (NMDA)') ax.plot(data['times'], xhatIntgNMDA, alpha=0.5, label='ens (NMDA)') ax.legend(loc="upper right") ax.set(ylim=((0, 1)), ylabel=r"$\mathbf{\hat{x}}(t)$", title="high DA") stim = makeSignalSquare(t, dt=dt, seed=100 + n) data = goLIF(N=N, stim=stim, t=t, dt=dt, fAMPA=fAMPA, fNMDA=fNMDA, fGABA=fGABA, dFdfwEnsAMPA=T * dFdfwEnsAMPA, dFdfwEnsNMDA=daNMDA * T * dFdfwEnsNMDA, dEnsEnsAMPA=dEnsEnsAMPA, dEnsEnsNMDA=daNMDA * dEnsEnsNMDA, dEnsInhAMPA=dEnsInhAMPA, dEnsInhNMDA=daNMDA * dEnsInhNMDA, dInhEnsGABA=daGABA * dInhEnsGABA, dInhFdfwGABA=daGABA * dInhFdfwGABA) aFdfwNMDA = fNMDA.filt(data['fdfw']) targetFdfwNMDA = fNMDA.filt(data['inpt']) xhatFdfwNMDA = np.dot(aFdfwNMDA, dFdfwEnsNMDA) aEnsNMDA = fNMDA.filt(data['ens']) targetIntgNMDA = fNMDA.filt(data['intg']) # targetFlatNMDA = n/nTest*np.ones((aEnsNMDA.shape[0])) xhatIntgNMDA = np.dot(aEnsNMDA, dEnsEnsNMDA) # fig, ax = plt.subplots() ax2.plot(data['times'], targetFdfwNMDA, linestyle="--", label='input (NMDA)') ax2.plot(data['times'], xhatFdfwNMDA, alpha=0.5, label='fdfw (NMDA)') ax2.plot(data['times'], targetIntgNMDA, linestyle="--", label='integral (NMDA)') # ax2.plot(data['times'], targetFlatNMDA, linestyle="--", label='flat (NMDA)') ax2.plot(data['times'], xhatIntgNMDA, alpha=0.5, label='ens (NMDA)') ax2.legend(loc="upper right") ax2.set(ylim=((0, 1)), xlabel="time (s)", ylabel=r"$\mathbf{\hat{x}}(t)$", title="low DA") fig.savefig("plots/gatedMemory_goLIF_test%s.pdf" % n)
def go(NPre=100, N=100, t=10, c=None, seed=0, dt=0.001, Tff=0.3, tTrans=0.01, stage=None, alpha=3e-7, eMax=1e-1, fPre=DoubleExp(1e-3, 1e-1), fNMDA=DoubleExp(10.6e-3, 285e-3), fS=DoubleExp(1e-3, 1e-1), dPreA=None, dPreB=None, dPreC=None, dFdfw=None, dBio=None, dNeg=None, dInh=None, ePreA=None, ePreB=None, ePreC=None, eFdfw=None, eBio=None, eNeg=None, eInh=None, stimA=lambda t: 0, stimB=lambda t: 0, stimC=lambda t: 0, DA=lambda t: 0): if not c: c = t with nengo.Network(seed=seed) as model: inptA = nengo.Node(stimA) inptB = nengo.Node(stimB) inptC = nengo.Node(stimC) preA = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) preB = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) preC = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) fdfw = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed) ens = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed+1) inh = nengo.Ensemble(N, 1, neuron_type=Bio("Interneuron", DA=DA), seed=seed+2) tarFdfw = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, 0.8), neuron_type=nengo.LIF(), seed=seed) tarEns = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, 0.8), neuron_type=nengo.LIF(), seed=seed+1) tarInh = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(0.2, 0.8), encoders=Choice([[1]]), neuron_type=nengo.LIF(), seed=seed+2) cA = nengo.Connection(inptA, preA, synapse=None, seed=seed) cB = nengo.Connection(inptB, preB, synapse=None, seed=seed) cC = nengo.Connection(inptC, preC, synapse=None, seed=seed) pInptA = nengo.Probe(inptA, synapse=None) pInptB = nengo.Probe(inptB, synapse=None) pInptC = nengo.Probe(inptC, synapse=None) pPreA = nengo.Probe(preA.neurons, synapse=None) pPreB = nengo.Probe(preB.neurons, synapse=None) pPreC = nengo.Probe(preC.neurons, synapse=None) pFdfw = nengo.Probe(fdfw.neurons, synapse=None) pTarFdfw = nengo.Probe(tarFdfw.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) pInh = nengo.Probe(inh.neurons, synapse=None) pTarInh = nengo.Probe(tarInh.neurons, synapse=None) if stage==1: nengo.Connection(inptA, tarFdfw, synapse=fPre, seed=seed) nengo.Connection(inptB, tarEns, synapse=fPre, seed=seed) nengo.Connection(inptC, tarInh, synapse=fPre, seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c3 = nengo.Connection(preC, inh, synapse=fPre, solver=NoSolver(dPreC), seed=seed) learnEncoders(c1, tarFdfw, fS, alpha=alpha, eMax=eMax, tTrans=tTrans) learnEncoders(c2, tarEns, fS, alpha=3*alpha, eMax=10*eMax, tTrans=tTrans) learnEncoders(c3, tarInh, fS, alpha=alpha/3, eMax=eMax, tTrans=tTrans) if stage==2: c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preC, inh, synapse=fPre, solver=NoSolver(dPreC), seed=seed) if stage==3: cB.synapse = fNMDA nengo.Connection(inptA, tarFdfw, synapse=fPre, seed=seed) nengo.Connection(inptB, tarEns, synapse=fPre, seed=seed) nengo.Connection(tarFdfw, tarEns, synapse=fNMDA, transform=Tff, seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c3 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) learnEncoders(c3, tarEns, fS, alpha=alpha, eMax=eMax, tTrans=tTrans) if stage==4: cB.synapse = fNMDA c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c3 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) if stage==5: preB2 = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) ens2 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed+1) ens3 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed+1) nengo.Connection(inptB, preB2, synapse=fNMDA, seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c3 = nengo.Connection(preB, ens2, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c4 = nengo.Connection(ens2, ens, synapse=NMDA(), solver=NoSolver(dBio), seed=seed) c5 = nengo.Connection(fdfw, ens3, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c6 = nengo.Connection(preB2, ens3, synapse=fPre, solver=NoSolver(dPreB), seed=seed) learnEncoders(c4, ens3, fS, alpha=alpha, eMax=eMax, tTrans=tTrans) pTarEns = nengo.Probe(ens3.neurons, synapse=None) if stage==6: preA2 = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) fdfw2 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed) fdfw3 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed) fdfw4 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed) tarFdfw4 = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, 0.8), neuron_type=nengo.LIF(), seed=seed) nengo.Connection(inptA, tarFdfw4, synapse=fPre, seed=seed) nengo.Connection(inptB, preA2, synapse=fNMDA, seed=seed) nengo.Connection(inptC, tarInh, synapse=fPre, seed=seed) nengo.Connection(tarInh, tarFdfw4.neurons, synapse=None, transform=-1e2*np.ones((N, 1)), seed=seed) c1 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c2 = nengo.Connection(ens, fdfw2, synapse=NMDA(), solver=NoSolver(dNeg), seed=seed) c3 = nengo.Connection(preA2, fdfw3, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c4 = nengo.Connection(preA, fdfw4, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c5 = nengo.Connection(preC, inh, synapse=fPre, solver=NoSolver(dPreC), seed=seed) c6 = nengo.Connection(inh, fdfw4, synapse=GABA(), solver=NoSolver(dInh), seed=seed) learnEncoders(c2, fdfw3, fS, alpha=alpha, eMax=eMax, tTrans=tTrans) learnEncoders(c6, tarFdfw4, fS, alpha=1e3*alpha, eMax=1e3*eMax, tTrans=tTrans, inh=True) pFdfw2 = nengo.Probe(fdfw2.neurons, synapse=None) pFdfw4 = nengo.Probe(fdfw4.neurons, synapse=None) pTarFdfw2 = nengo.Probe(fdfw3.neurons, synapse=None) pTarFdfw4 = nengo.Probe(tarFdfw4.neurons, synapse=None) if stage==7: c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c3 = nengo.Connection(ens, ens, synapse=NMDA(), solver=NoSolver(dBio), seed=seed) c4 = nengo.Connection(ens, fdfw, synapse=NMDA(), solver=NoSolver(dNeg), seed=seed) c5 = nengo.Connection(preC, inh, synapse=fPre, solver=NoSolver(dPreC), seed=seed) c6 = nengo.Connection(inh, fdfw, synapse=GABA(), solver=NoSolver(dInh), seed=seed) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: if stage==1: setWeights(c1, dPreA, ePreA) setWeights(c2, dPreB, ePreB) setWeights(c3, dPreC, ePreC) if stage==2: setWeights(c1, dPreA, ePreA) setWeights(c2, dPreC, ePreC) if stage==3: setWeights(c1, dPreA, ePreA) setWeights(c2, dPreB, ePreB) setWeights(c3, dFdfw, eFdfw) if stage==4: setWeights(c1, dPreA, ePreA) setWeights(c2, dPreB, ePreB) setWeights(c3, dFdfw, eFdfw) if stage==5: setWeights(c1, dPreA, ePreA) setWeights(c2, dFdfw, eFdfw) setWeights(c3, dPreB, ePreB) setWeights(c4, dBio, eBio) setWeights(c5, dFdfw, eFdfw) setWeights(c6, dPreB, ePreB) if stage==6: setWeights(c1, dPreB, ePreB) setWeights(c2, dNeg, eNeg) setWeights(c3, dPreA, ePreA) setWeights(c4, dPreA, ePreA) setWeights(c5, dPreC, ePreC) setWeights(c6, dInh, eInh) if stage==7: setWeights(c1, dPreA, ePreA) setWeights(c2, dFdfw, eFdfw) setWeights(c3, dBio, eBio) setWeights(c4, dNeg, eNeg) setWeights(c5, dPreC, ePreC) setWeights(c6, dInh, eInh) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) ePreA = c1.e if stage==1 else ePreA ePreB = c2.e if stage==1 else ePreB ePreC = c3.e if stage==1 else ePreC eFdfw = c3.e if stage==3 else eFdfw eBio = c4.e if stage==5 else eBio eNeg = c2.e if stage==6 else eNeg eInh = c6.e if stage==6 else eInh return dict( times=sim.trange(), inptA=sim.data[pInptA], inptB=sim.data[pInptB], inptC=sim.data[pInptC], preA=sim.data[pPreA], preB=sim.data[pPreB], preC=sim.data[pPreC], fdfw=sim.data[pFdfw], ens=sim.data[pEns], inh=sim.data[pInh], tarFdfw=sim.data[pTarFdfw], tarEns=sim.data[pTarEns], tarInh=sim.data[pTarInh], fdfw2=sim.data[pFdfw2] if stage==6 else None, fdfw4=sim.data[pFdfw4] if stage==6 else None, tarFdfw2=sim.data[pTarFdfw2] if stage==6 else None, tarFdfw4=sim.data[pTarFdfw4] if stage==6 else None, ePreA=ePreA, ePreB=ePreB, ePreC=ePreC, eFdfw=eFdfw, eBio=eBio, eNeg=eNeg, eInh=eInh, )
def go(NPre=100, N=100, N2=30, t=10, m=Uniform(30, 30), i=Uniform(-0.8, 0.8), seed=0, dt=0.001, f=DoubleExp(1e-3, 1e-1), fS=DoubleExp(1e-3, 1e-1), neuron_type=LIF(), d1=None, d2=None, f1=None, f2=None, e1=None, e2=None, l1=False, l2=False, stim=lambda t: [0, 0]): if not f1: f1 = f if not f2: f2 = f if not np.any(d2): d2 = np.zeros((N, 1)) with nengo.Network(seed=seed) as model: # Stimulus and Nodes inpt = nengo.Node(stim) tar = nengo.Ensemble(1, 2, neuron_type=nengo.Direct()) tar2 = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) pre = nengo.Ensemble(NPre, 2, radius=2, max_rates=m, seed=seed, neuron_type=LIF()) ens = nengo.Ensemble(N, 2, radius=2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed) ens2 = nengo.Ensemble(N2, 1, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed + 1) nengo.Connection(inpt, pre, synapse=None, seed=seed) nengo.Connection(inpt, tar, synapse=f, seed=seed) nengo.Connection(tar, tar2, synapse=f, function=multiply, seed=seed + 1) c1 = nengo.Connection(pre, ens, synapse=f1, seed=seed, solver=NoSolver(d1)) if isinstance(neuron_type, Bio): c2 = nengo.Connection(ens, ens2, synapse=f2, seed=seed + 1, function=multiply) else: c2 = nengo.Connection(ens.neurons, ens2, synapse=f2, seed=seed + 1, transform=d2.T) pInpt = nengo.Probe(inpt, synapse=None) pPre = nengo.Probe(pre.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) pEns2 = nengo.Probe(ens2.neurons, synapse=None) pTar = nengo.Probe(tar, synapse=None) pTar2 = nengo.Probe(tar2, synapse=None) # Encoder Learning (Bio) if l1: tarEns = nengo.Ensemble(N, 2, radius=2, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed) nengo.Connection(tar, tarEns, synapse=None, seed=seed) learnEncoders(c1, tarEns, fS, alpha=3e-8) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) if l2: tarEns2 = nengo.Ensemble(N2, 1, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed + 1) nengo.Connection(tar2, tarEns2, synapse=None) # nengo.Connection(ens.neurons, tarEns2, synapse=f2, transform=d2.T, seed=seed+1) learnEncoders(c2, tarEns2, fS, alpha=1e-7) pTarEns2 = nengo.Probe(tarEns2.neurons, synapse=None) pTarState = nengo.Probe(tarEns2, synapse=f) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: if isinstance(neuron_type, Bio): setWeights(c1, d1, e1) setWeights(c2, d2, e2) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) else: sim.run(t, progress_bar=True) e1 = c1.e if l1 else e1 e2 = c2.e if l2 else e2 return dict( times=sim.trange(), inpt=sim.data[pInpt], pre=sim.data[pPre], ens=sim.data[pEns], ens2=sim.data[pEns2], tar=sim.data[pTar], tar2=sim.data[pTar2], tarEns=sim.data[pTarEns] if l1 else None, tarEns2=sim.data[pTarEns2] if l2 else None, tarState=sim.data[pTarState] if l2 else None, e1=e1, e2=e2, )
def run(N=3000, neuron_type=LIF(), tTrain=200, tTest=100, tTransTrain=20, tTransTest=20, nTrain=1, nTest=10, dt=0.001, dtSampleTrain=0.003, dtSampleTest=0.01, seed=0, f2=10, reg=1e-3, reg2=1e-3, evals=100, r=30, load=False, file=None, tauRiseMin=3e-2, tauRiseMax=6e-2, tauFallMin=2e-1, tauFallMax=3e-1): print('\nNeuron Type: %s'%neuron_type) rng = np.random.RandomState(seed=seed) timeStepsTrain = int((tTrain-tTransTrain)/dtSampleTrain) tStart = int(tTransTrain/dtSampleTrain) tFlat = int((tTrain-tTransTrain)/dtSampleTrain)*nTrain if load: d = np.load(file)['d'] d2 = np.load(file)['d2'] tauRise = np.load(file)['tauRise'] tauFall = np.load(file)['tauFall'] f = DoubleExp(tauRise, tauFall) else: print('decoders for ens') spikes = np.zeros((nTrain, timeStepsTrain, N)) spikes2 = np.zeros((nTrain, timeStepsTrain, N)) targets = np.zeros((nTrain, timeStepsTrain, 3)) targets2 = np.zeros((nTrain, timeStepsTrain, 3)) for n in range(nTrain): # IC = np.array([rng.uniform(-15, 15), rng.uniform(-20, 20), rng.uniform(10, 35)]) IC = np.array([rng.uniform(-5, 5), rng.uniform(-5, 5), rng.uniform(20, 25)]) data = go(N=N, neuron_type=neuron_type, l=True, t=tTrain, r=r, dt=dt, dtSample=dtSampleTrain, seed=seed, IC=IC) spikes[n] = data['ens'][-timeStepsTrain:] spikes2[n] = gaussian_filter1d(data['ens'], sigma=f2, axis=0)[-timeStepsTrain:] targets[n] = data['tar'][-timeStepsTrain:] targets2[n] = gaussian_filter1d(data['tar'], sigma=f2, axis=0)[-timeStepsTrain:] d, f, tauRise, tauFall, X, Y, error = decode( spikes, targets, nTrain, dt=dtSampleTrain, dtSample=dtSampleTrain, name="lorenzNew", evals=evals, reg=reg, tauRiseMin=tauRiseMin, tauRiseMax=tauRiseMax, tauFallMin=tauFallMin, tauFallMax=tauFallMax) spikes2 = spikes2.reshape((tFlat, N)) targets2 = targets2.reshape((tFlat, 3)) A2 = gaussian_filter1d(spikes2, sigma=f2, axis=0)[-timeStepsTrain:] Y2 = gaussian_filter1d(targets2, sigma=f2, axis=0)[-timeStepsTrain:] d2, _ = nengo.solvers.LstsqL2(reg=reg2)(spikes2, targets2) np.savez("data/lorenzNew_%s.npz"%neuron_type, d=d, d2=d2, tauRise=tauRise, tauFall=tauFall, f2=f2) X2 = np.dot(A2, d2)[-timeStepsTrain:] error = plotLorenz(X, X2, Y2, neuron_type, "train") print("testing") tStart = int(tTransTest/dtSampleTest) errors = np.zeros((nTest)) rng = np.random.RandomState(seed=100+seed) for test in range(nTest): # IC = np.array([rng.uniform(-15, 15), rng.uniform(-20, 20), rng.uniform(10, 35)]) IC = np.array([rng.uniform(-5, 5), rng.uniform(-5, 5), rng.uniform(20, 25)]) data = go(d=d, f=f, N=N, neuron_type=neuron_type, t=tTest, r=r, dt=dt, dtSample=dtSampleTest, seed=seed, IC=IC) A = f.filt(data['ens'], dt=dtSampleTest) A2 = gaussian_filter1d(data['ens'], sigma=f2, axis=0)[tStart:] X = np.dot(A, d)[tStart:] X2 = np.dot(A2, d2)[tStart:] Y = data['tar'][tStart:] Y2 = gaussian_filter1d(data['tar'], sigma=f2, axis=0)[tStart:] error = plotLorenz(X, X2, Y2, neuron_type, test) errors[test] = error _ = plotLorenz(Y, Y2, Y2, 'target', '') print('errors: ', errors) np.savez("data/lorenzNew_%s.npz"%neuron_type, d=d, d2=d2, tauRise=tauRise, tauFall=tauFall, f2=f2, errors=errors) return errors
def run(NPre=300, N=100, t=20, tTrans=2, nTrain=1, nEnc=10, nTest=10, neuron_type=LIF(), dt=0.001, f=DoubleExp(1e-3, 1e-1), fS=DoubleExp(1e-3, 1e-1), freq=1, muFreq=1.0, sigmaFreq=0.1, reg=1e-1, tauRiseMax=5e-2, tDrive=0.2, base=False, load=False, file=None): print('\nNeuron Type: %s'%neuron_type) rng = np.random.RandomState(seed=0) if load: d1 = np.load(file)['d1'] tauRise1 = np.load(file)['tauRise1'] tauFall1 = np.load(file)['tauFall1'] f1 = DoubleExp(tauRise1, tauFall1) else: print('readout decoders for pre') spikes = np.zeros((nTrain, int(t/0.001), NPre)) targets = np.zeros((nTrain, int(t/0.001), 2)) for n in range(nTrain): data = go(NPre=NPre, N=N, t=t, dt=0.001, f=f, fS=fS, neuron_type=LIF(), freq=freq, phase=2*np.pi*(n/nTrain)) spikes[n] = data['pre'] targets[n] = f.filt(data['inpt'], dt=0.001) d1, f1, tauRise1, tauFall1, X, Y, error = decode(spikes, targets, nTrain, dt=0.001, tauRiseMax=tauRiseMax, name="oscillateNew") np.savez("data/oscillateNew_%s.npz"%neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1) times = np.arange(0, t*nTrain, 0.001) plotState(times, X, Y, error, "oscillateNew", "%s_pre"%neuron_type, t*nTrain) if load: e1 = np.load(file)['e1'] elif isinstance(neuron_type, Bio): print("ens1 encoders") e1 = np.zeros((NPre, N, 2)) for n in range(nEnc): data = go(d1=d1, e1=e1, f1=f1, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, freq=freq, phase=2*np.pi*(n/nEnc), l1=True) e1 = data['e1'] np.savez("data/oscillateNew_%s.npz"%neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1) plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "oscillateNew", "ens") else: e1 = np.zeros((NPre, N, 2)) if load: d2 = np.load(file)['d2'] tauRise2 = np.load(file)['tauRise2'] tauFall2 = np.load(file)['tauFall2'] f2 = DoubleExp(tauRise2, tauFall2) else: print('readout decoders for ens') spikes = np.zeros((nTrain, int((t-tTrans)/dt), N)) targets = np.zeros((nTrain, int((t-tTrans)/dt), 2)) for n in range(nTrain): data = go(d1=d1, e1=e1, f1=f1, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, freq=freq, phase=2*np.pi*(n/nTrain)) spikes[n] = data['ens'][int(tTrans/dt):] targets[n] = f.filt(f.filt(data['tar'], dt=dt), dt=dt)[int(tTrans/dt):] d2, f2, tauRise2, tauFall2, X, Y, error = decode(spikes, targets, nTrain, dt=dt, name="oscillateNew", reg=reg, tauRiseMax=tauRiseMax) np.savez("data/oscillateNew_%s.npz"%neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2) times = np.arange(0, t*nTrain, dt)[:len(X)] plotState(times, X, Y, error, "oscillateNew", "%s_ens"%neuron_type, (t-tTrans)*nTrain) if load: e2 = np.load(file)['e2'] #elif isinstance(neuron_type, Bio): print("ens2 encoders") #e2 = np.zeros((N, N, 2)) for n in range(nEnc): data = go(d1=d1, e1=e1, f1=f1, d2=d2, e2=e2, NPre=NPre, N=N, t=t, dt=dt, f=f, fS=fS, neuron_type=neuron_type, freq=freq, phase=2*np.pi*(n/nEnc), l2=True) e2 = data['e2'] np.savez("data/oscillateNew_%s.npz"%neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2) plotActivity(t, dt, fS, data['times'], data['ens2'], data['tarEns2'], "oscillateNew", "ens2") else: e2 = np.zeros((N, N, 2)) np.savez("data/oscillateNew_%s.npz"%neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2) print("testing") errors = np.zeros((nTest)) for test in range(nTest): data = go(d1=d1, e1=e1, f1=f1, d2=d2, e2=e2, f2=f2, NPre=NPre, N=N, t=t+tTrans, dt=dt, f=f, fS=fS, neuron_type=neuron_type, freq=freq, phase=2*np.pi*(test/nTest), tDrive=tDrive, test=True) # curve fit to a sinusoid of arbitrary frequency, phase, magnitude times = data['times'] A = f2.filt(data['ens'], dt=dt) X = np.dot(A, d2) freq0, phase0, mag0, base0 = fitSinusoid(times, X[:,0], freq, int(tTrans/dt), muFreq=muFreq, sigmaFreq=sigmaFreq, base=base) freq1, phase1, mag1, base1 = fitSinusoid(times, X[:,1], freq, int(tTrans/dt), muFreq=muFreq, sigmaFreq=sigmaFreq, base=base) s0 = base0+mag0*np.sin(times*2*np.pi*freq0+phase0) s1 = base1+mag1*np.sin(times*2*np.pi*freq1+phase1) # freqError0 = np.abs(freq-freq0) # freqError1 = np.abs(freq-freq1) rmseError0 = rmse(X[int(tTrans/dt):,0], s0[int(tTrans/dt):]) rmseError1 = rmse(X[int(tTrans/dt):,1], s1[int(tTrans/dt):]) # error0 = (1+freqError0) * rmseError0 # error1 = (1+freqError1) * rmseError1 error0 = rmseError0 error1 = rmseError1 errors[test] = (error0 + error1)/2 fig, (ax, ax2) = plt.subplots(nrows=2, ncols=1, sharex=True) ax.plot(times, X[:,0], label="estimate (dim 0)") ax.plot(times, s0, label="target (dim 0)") ax.set(ylabel='state', title='freq=%.3f, rmse=%.3f'%(freq0, error0), xlim=((0, t)), ylim=((-1.2, 1.2))) ax.legend(loc='upper left') ax2.plot(times, X[:,1], label="estimate (dim 1)") ax2.plot(times, s1, label="target (dim 1)") ax2.set(xlabel='time', ylabel='state', title='freq=%.3f, rmse=%.3f'%(freq1, error1), xlim=((0, t)), ylim=((-1.2, 1.2))) ax2.legend(loc='upper left') sns.despine() fig.savefig("plots/oscillateNew_%s_test%s.pdf"%(neuron_type, test)) plt.close('all') print('%s errors:'%neuron_type, errors) np.savez("data/oscillateNew_%s.npz"%neuron_type, d1=d1, tauRise1=tauRise1, tauFall1=tauFall1, e1=e1, d2=d2, tauRise2=tauRise2, tauFall2=tauFall2, e2=e2, errors=errors) return errors
def run(NPre=100, N=100, t=10, nTrain=10, nTest=3, nAttr=5, nEnc=10, dt=0.001, c=None, fPre=DoubleExp(1e-3, 1e-1), fNMDA=DoubleExp(10.6e-3, 285e-3), fGABA=DoubleExp(0.5e-3, 1.5e-3), fS=DoubleExp(2e-2, 1e-1), Tff=0.3, reg=1e-2, load=[], file=None): if not c: c = t if 0 in load: dPreA = np.load(file)['dPreA'] dPreB = np.load(file)['dPreB'] dPreC = np.load(file)['dPreC'] dPreD = np.load(file)['dPreD'] else: print('readout decoders for pre') spikesInptA = np.zeros((nTrain, int(t / dt), NPre)) spikesInptB = np.zeros((nTrain, int(t / dt), NPre)) spikesInptC = np.zeros((nTrain, int(t / dt), NPre)) spikesInptD = np.zeros((nTrain, int(t / dt), NPre)) targetsInptA = np.zeros((nTrain, int(t / dt), 1)) targetsInptB = np.zeros((nTrain, int(t / dt), 1)) targetsInptC = np.zeros((nTrain, int(t / dt), 1)) targetsInptD = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stimA, _ = makeSignal(t, fPre, fNMDA, nAttr, dt=dt, seed=n) stimB = stimA stimC = lambda t: 0 if t < c else 1 stimD = lambda t: 1e-1 data = go(NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimC, stimD=stimD, stage=None) spikesInptA[n] = data['preA'] spikesInptB[n] = data['preB'] spikesInptC[n] = data['preC'] spikesInptD[n] = data['preD'] targetsInptA[n] = fPre.filt(data['inptA'], dt=dt) targetsInptB[n] = fPre.filt(data['inptB'], dt=dt) targetsInptC[n] = fPre.filt(data['inptC'], dt=dt) targetsInptD[n] = fPre.filt(data['inptD'], dt=dt) dPreA, XA, YA, errorA = decodeNoF(spikesInptA, targetsInptA, nTrain, fPre, dt=dt, reg=reg) dPreB, XB, YB, errorB = decodeNoF(spikesInptB, targetsInptB, nTrain, fPre, dt=dt, reg=reg) dPreC, XC, YC, errorC = decodeNoF(spikesInptC, targetsInptC, nTrain, fPre, dt=dt, reg=reg) dPreD, XD, YD, errorD = decodeNoF(spikesInptD, targetsInptD, nTrain, fPre, dt=dt, reg=reg) np.savez("data/integrateAttractors.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD) times = np.arange(0, t * nTrain, dt) plotState(times, XA, YA, errorA, "integrateAttractors", "preA", t * nTrain) plotState(times, XB, YB, errorB, "integrateAttractors", "preB", t * nTrain) plotState(times, XC, YC, errorC, "integrateAttractors", "preC", t * nTrain) plotState(times, XD, YD, errorD, "integrateAttractors", "preD", t * nTrain) if 0 in load: ePreDEns = np.load(file)['ePreDEns'] else: print("encoders for preD to ens") ePreDEns = np.zeros((NPre, N, 1)) for n in range(nEnc): data = go(NPre=NPre, N=N, t=t, dt=dt, dPreD=dPreD, ePreDEns=ePreDEns, stage=0) ePreDEns = data['ePreDEns'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateAttractors", "preDEns") np.savez("data/integrateAttractors.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, ePreDEns=ePreDEns) if 1 in load: ePreAFdfw = np.load(file)['ePreAFdfw'] ePreBEns = np.load(file)['ePreBEns'] ePreCOff = np.load(file)['ePreCOff'] else: print("encoders for [preA, preB, preC] to [fdfw, ens, off]") ePreAFdfw = np.zeros((NPre, N, 1)) ePreBEns = np.zeros((NPre, N, 1)) ePreCOff = np.zeros((NPre, N, 1)) for n in range(nEnc): stimA, _ = makeSignal(t, fPre, fNMDA, nAttr, dt=dt, seed=n) stimB = stimA stimC = lambda t: 0 if t < c else 1 data = go(NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimB, dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff, ePreDEns=ePreDEns, stage=1) ePreAFdfw = data['ePreAFdfw'] ePreBEns = data['ePreBEns'] ePreCOff = data['ePreCOff'] plotActivity(t, dt, fS, data['times'], data['fdfw'], data['tarFdfw'], "integrateAttractors", "preAFdfw") plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateAttractors", "preBEns") plotActivity(t, dt, fS, data['times'], data['off'], data['tarOff'], "integrateAttractors", "preCOff") np.savez("data/integrateAttractors.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, ePreDEns=ePreDEns, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff) if 2 in load: dFdfw = np.load(file)['dFdfw'] dOff = np.load(file)['dOff'] else: print('readout decoders for fdfw and off') spikesFdfw = np.zeros((nTrain, int(t / dt), N)) spikesOff = np.zeros((nTrain, int(t / dt), N)) targetsFdfw = np.zeros((nTrain, int(t / dt), 1)) targetsOff = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, fNMDA, nAttr, dt=dt, seed=n) stimC = lambda t: 0 if t < c else 1 data = go(NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimC, dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff, ePreDEns=ePreDEns, stage=2) spikesFdfw[n] = data['fdfw'] spikesOff[n] = data['off'] targetsFdfw[n] = fNMDA.filt(Tff * fPre.filt(data['inptA'])) # targetsFdfw[n] = fNMDA.filt(fPre.filt(data['inptB'])) targetsOff[n] = fGABA.filt(fPre.filt(data['inptC'])) dFdfw, X1, Y1, error1 = decodeNoF(spikesFdfw, targetsFdfw, nTrain, fNMDA, dt=dt, reg=reg) dOff, X2, Y2, error2 = decodeNoF(spikesOff, targetsOff, nTrain, fGABA, dt=dt, reg=reg) np.savez("data/integrateAttractors.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, dFdfw=dFdfw, dOff=dOff, ePreDEns=ePreDEns, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff) times = np.arange(0, t * nTrain, dt) plotState(times, X1, Y1, error1, "integrateAttractors", "fdfw", t * nTrain) plotState(times, X2, Y2, error2, "integrateAttractors", "off", t * nTrain) if 3 in load: eFdfwEns = np.load(file)['eFdfwEns'] else: print("encoders for fdfw-to-ens") eFdfwEns = np.zeros((N, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, nAttr, dt=dt, seed=n) data = go(NPre=NPre, N=N, t=t, dt=dt, Tff=Tff, stimA=stimA, stimB=stimB, dPreA=dPreA, dPreB=dPreB, dPreD=dPreD, dFdfw=dFdfw, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreDEns=ePreDEns, eFdfwEns=eFdfwEns, stage=3) eFdfwEns = data['eFdfwEns'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateAttractors", "fdfwEns") np.savez("data/integrateAttractors.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, dFdfw=dFdfw, dOff=dOff, ePreDEns=ePreDEns, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff, eFdfwEns=eFdfwEns) if 4 in load: dEns = np.load(file)['dEns'] else: print('readout decoders for ens') spikes = np.zeros((nTrain, int(t / dt), N)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stimA, stimB = makeSignal(t, fPre, fNMDA, nAttr, dt=dt, seed=n) data = go(NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, dPreA=dPreA, dPreB=dPreB, dPreD=dPreD, dFdfw=dFdfw, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreDEns=ePreDEns, eFdfwEns=eFdfwEns, stage=4) spikes[n] = data['ens'] # targets[n] = data['inptB'] # stimA rounded to nearest attractor targets[n] = fNMDA.filt(fPre.filt( data['inptB'])) # stimA rounded to nearest attractor dEns, X, Y, error = decodeNoF(spikes, targets, nTrain, fNMDA, dt=dt, reg=reg) np.savez("data/integrateAttractors.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, dFdfw=dFdfw, dOff=dOff, dEns=dEns, ePreDEns=ePreDEns, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff, eFdfwEns=eFdfwEns) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "integrateAttractors", "ens", t * nTrain) if 5 in load: eEnsEns = np.load(file)['eEnsEns'] else: print("encoders from ens to ens") eEnsEns = np.zeros((N, N, 1)) for n in range(nEnc): stimA, stimB = makeSignal(t, fPre, fNMDA, nAttr, dt=dt, seed=n) data = go(NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, dPreA=dPreA, dPreB=dPreB, dPreD=dPreD, dFdfw=dFdfw, dEns=dEns, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreDEns=ePreDEns, eFdfwEns=eFdfwEns, eEnsEns=eEnsEns, stage=5) eEnsEns = data['eEnsEns'] plotActivity(t, dt, fS, data['times'], data['ens'], data['tarEns'], "integrateAttractors", "ensEns") np.savez("data/integrateAttractors.npz", dPreA=dPreA, dPreB=dPreB, dPreC=dPreC, dPreD=dPreD, dFdfw=dFdfw, dOff=dOff, dEns=dEns, ePreDEns=ePreDEns, ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff, eFdfwEns=eFdfwEns, eEnsEns=eEnsEns) print("testing") eOffFdfw = -1e2 * np.ones((N, N, 1)) vals = np.linspace(-1, 1, nTest) att = np.linspace(-1, 1, nAttr) for test in range(nTest): stimA = lambda t: vals[test] if t < c else 0 stimB = lambda t: closestAttractor(vals[test], att) stimC = lambda t: 0 if t < c else 1 DATest = lambda t: 0 data = go(NPre=NPre, N=N, t=t, dt=dt, stimA=stimA, stimB=stimB, stimC=stimC, dPreA=dPreA, dPreC=dPreC, dPreD=dPreD, dFdfw=dFdfw, dEns=dEns, dOff=dOff, ePreAFdfw=ePreAFdfw, ePreCOff=ePreCOff, ePreDEns=ePreDEns, eFdfwEns=eFdfwEns, eEnsEns=eEnsEns, eOffFdfw=eOffFdfw, stage=9, c=c, DA=DATest) aFdfw = fNMDA.filt(data['fdfw']) aEns = fNMDA.filt(data['ens']) aOff = fGABA.filt(data['off']) xhatFdfw = np.dot(aFdfw, dFdfw) / Tff xhatEns = np.dot(aEns, dEns) xhatOff = np.dot(aOff, dOff) xFdfw = fNMDA.filt(fPre.filt(data['inptA'])) # xEns = xFdfw[int(c/dt)] * np.ones_like(data['times']) xEns = fNMDA.filt(fPre.filt(data['inptB'])) # xEns = data['inptB'] errorEns = rmse(xhatEns[int(c / dt):], xEns[int(c / dt):]) fig, ax = plt.subplots() ax.plot(data['times'], xFdfw, alpha=0.5, label="input (filtered)") ax.plot(data['times'], xhatFdfw, alpha=0.5, label="fdfw") ax.plot(data['times'], xEns, label="target") ax.plot(data['times'], xhatEns, alpha=0.5, label="ens, rmse=%.3f" % errorEns) ax.plot(data['times'], xhatOff, alpha=0.5, label="off") ax.axvline(c, label="cutoff") ax.set(xlabel='time', ylabel='state', xlim=((0, t)), ylim=((-1.5, 1.5))) ax.legend(loc='upper left') sns.despine() fig.savefig("plots/integrateAttractors_testFlat%s.pdf" % test)
def run(n_neurons=10000, neuron_type=LIF(), t_train=200, t=200, f=DoubleExp(1e-3, 1e-1), dt=0.001, dt_sample=0.003, tt=1.0, seed=0, smooth=30, reg=1e-1, penalty=0, df_evals=20, load_fd=False): d_ens = np.zeros((n_neurons, 3)) f_ens = f if load_fd: load = np.load(load_fd) d_ens = load['d_ens'] taus_ens = load['taus_ens'] f_ens = DoubleExp(taus_ens[0], taus_ens[1]) d_ens_gauss = load['d_ens_gauss'] else: print('Optimizing ens filters and decoders') data = go(d_ens, f_ens, neuron_type=neuron_type, n_neurons=n_neurons, L=True, t=t_train, f=f, dt=dt, dt_sample=dt_sample, seed=seed) d_ens, f_ens, taus_ens = df_opt(data['x'], data['ens'], f, df_evals=df_evals, reg=reg, penalty=penalty, dt=dt_sample, dt_sample=dt_sample, name='lorenz_%s'%neuron_type) all_targets_gauss = gaussian_filter1d(data['x'], sigma=smooth, axis=0) all_spikes_gauss = gaussian_filter1d(data['ens'], sigma=smooth, axis=0) d_ens_gauss = nengo.solvers.LstsqL2(reg=reg)(all_spikes_gauss, all_targets_gauss)[0] np.savez('data/lorenz_%s_fd.npz'%neuron_type, d_ens=d_ens, taus_ens=taus_ens, d_ens_gauss=d_ens_gauss) f_times = np.arange(0, 1, 0.0001) fig, ax = plt.subplots() ax.plot(f_times, f.impulse(len(f_times), dt=0.0001), label=r"$f^x, \tau_1=%.3f, \tau_2=%.3f$" %(-1./f.poles[0], -1./f.poles[1])) ax.plot(f_times, f_ens.impulse(len(f_times), dt=0.0001), label=r"$f^{ens}, \tau_1=%.3f, \tau_2=%.3f, d: %s/%s$" %(-1./f_ens.poles[0], -1./f_ens.poles[1], np.count_nonzero(d_ens), n_neurons)) ax.set(xlabel='time (seconds)', ylabel='impulse response', ylim=((0, 10))) ax.legend(loc='upper right') plt.tight_layout() plt.savefig("plots/lorenz_%s_filters_ens.pdf"%neuron_type) tar = f.filt(data['x'], dt=dt_sample) a_ens = f_ens.filt(data['ens'], dt=dt_sample) ens = np.dot(a_ens, d_ens) z_tar_peaks, _ = find_peaks(tar[:,2], height=0) # gives time indices of z-component-peaks z_ens_peaks, _ = find_peaks(ens[:,2], height=0) fig = plt.figure() ax = fig.add_subplot(121, projection='3d') ax2 = fig.add_subplot(122, projection='3d') ax.plot(*tar.T, linewidth=0.25) # ax.scatter(*tar[z_tar_peaks].T, color='r', s=1) ax2.plot(*ens.T, linewidth=0.25) # ax2.scatter(*ens[z_ens_peaks].T, color='r', s=1, marker='v') ax.set(xlabel="x", ylabel="y", zlabel="z", xlim=((-20, 20)), ylim=((-10, 30)), zlim=((0, 40))) ax.xaxis.pane.fill = False ax.yaxis.pane.fill = False ax.zaxis.pane.fill = False ax.xaxis.pane.set_edgecolor('w') ax.yaxis.pane.set_edgecolor('w') ax.zaxis.pane.set_edgecolor('w') ax.grid(False) ax2.set(xlabel="x", ylabel="y", zlabel="z", xlim=((-20, 20)), ylim=((-10, 30)), zlim=((0, 40))) ax2.xaxis.pane.fill = False ax2.yaxis.pane.fill = False ax2.zaxis.pane.fill = False ax2.xaxis.pane.set_edgecolor('w') ax2.yaxis.pane.set_edgecolor('w') ax2.zaxis.pane.set_edgecolor('w') ax2.grid(False) plt.savefig("plots/lorenz_%s_train_3D.pdf"%neuron_type) fig, (ax1, ax2, ax3) = plt.subplots(1, 3) ax1.plot(tar[:,0], tar[:,1], linestyle="--", linewidth=0.25) ax2.plot(tar[:,1], tar[:,2], linestyle="--", linewidth=0.25) ax3.plot(tar[:,0], tar[:,2], linestyle="--", linewidth=0.25) # ax2.scatter(tar[z_tar_peaks, 1], tar[z_tar_peaks, 2], s=3, color='r') # ax3.scatter(tar[z_tar_peaks, 0], tar[z_tar_peaks, 2], s=3, color='g') ax1.plot(ens[:,0], ens[:,1], linewidth=0.25) ax2.plot(ens[:,1], ens[:,2], linewidth=0.25) ax3.plot(ens[:,0], ens[:,2], linewidth=0.25) # ax2.scatter(ens[z_ens_peaks, 1], ens[z_ens_peaks, 2], s=3, color='r', marker='v') # ax3.scatter(ens[z_ens_peaks, 0], ens[z_ens_peaks, 2], s=3, color='g', marker='v') ax1.set(xlabel='x', ylabel='y') ax2.set(xlabel='y', ylabel='z') ax3.set(xlabel='x', ylabel='z') plt.tight_layout() plt.savefig("plots/lorenz_%s_train_pairwise.pdf"%neuron_type) plt.close('all') # Plot tent map and fit the data to a gaussian print('Plotting tent map') trans = int(tt/dt) tar_gauss = gaussian_filter1d(data['x'][trans:], sigma=smooth, axis=0) a_ens_gauss = gaussian_filter1d(data['ens'][trans:], sigma=smooth, axis=0) ens_gauss = np.dot(a_ens_gauss, d_ens_gauss) z_tar_peaks = find_peaks(tar_gauss[:,2], height=0)[0][1:] z_tar_values_horz = np.ravel(tar_gauss[z_tar_peaks, 2][:-1]) z_tar_values_vert = np.ravel(tar_gauss[z_tar_peaks, 2][1:]) z_ens_peaks = find_peaks(ens_gauss[:,2], height=0)[0][1:] z_ens_values_horz = np.ravel(ens_gauss[z_ens_peaks, 2][:-1]) z_ens_values_vert = np.ravel(ens_gauss[z_ens_peaks, 2][1:]) # def gaussian(x, mu, sigma, mag): # return mag * np.exp(-0.5*(np.square((x-mu)/sigma))) # p0 = [36, 2, 40] # param_ens, _ = curve_fit(gaussian, z_ens_values_horz, z_ens_values_vert, p0=p0) # param_tar, _ = curve_fit(gaussian, z_tar_values_horz, z_tar_values_vert, p0=p0) # horzs_tar = np.linspace(np.min(z_tar_values_horz), np.max(z_tar_values_horz), 100) # gauss_tar = gaussian(horzs_tar, param_tar[0], param_tar[1], param_tar[2]) # horzs_ens = np.linspace(np.min(z_ens_values_horz), np.max(z_ens_values_horz), 100) # gauss_ens = gaussian(horzs_ens, param_ens[0], param_ens[1], param_ens[2]) # error = entropy(gauss_ens, gauss_tar) fig, ax = plt.subplots() ax.scatter(z_tar_values_horz, z_tar_values_vert, alpha=0.5, color='r', label='target') # ax.plot(horzs_tar, gauss_tar, color='r', linestyle='--', label='target fit') ax.scatter(z_ens_values_horz, z_ens_values_vert, alpha=0.5, color='b', label='ens') # ax.plot(horzs_ens, gauss_ens, color='b', linestyle='--', label='ens fit') ax.set(xlabel=r'$\mathrm{max}_n (z)$', ylabel=r'$\mathrm{max}_{n+1} (z)$')#, title='error=%.5f'%error) plt.legend(loc='upper right') plt.savefig("plots/lorenz_%s_train_tent.pdf"%(neuron_type)) print("testing") data = go(d_ens, f_ens, neuron_type=neuron_type, n_neurons=n_neurons, L=False, t=t, f=f, dt=dt, dt_sample=dt_sample, seed=seed) tar = f.filt(data['x'], dt=dt_sample) a_ens = f_ens.filt(data['ens'], dt=dt_sample) ens = np.dot(a_ens, d_ens) z_tar_peaks, _ = find_peaks(tar[:,2], height=0) # gives time indices of z-component-peaks z_ens_peaks, _ = find_peaks(ens[:,2], height=0) fig = plt.figure() ax = fig.add_subplot(121, projection='3d') ax2 = fig.add_subplot(122, projection='3d') ax.plot(*tar.T, linewidth=0.25) # ax.scatter(*tar[z_tar_peaks].T, color='r', s=1) ax2.plot(*ens.T, linewidth=0.25) # ax2.scatter(*ens[z_ens_peaks].T, color='r', s=1, marker='v') ax.set(xlabel="x", ylabel="y", zlabel="z", xlim=((-20, 20)), ylim=((-10, 30)), zlim=((0, 40))) ax.xaxis.pane.fill = False ax.yaxis.pane.fill = False ax.zaxis.pane.fill = False ax.xaxis.pane.set_edgecolor('w') ax.yaxis.pane.set_edgecolor('w') ax.zaxis.pane.set_edgecolor('w') ax.grid(False) ax2.set(xlabel="x", ylabel="y", zlabel="z", xlim=((-20, 20)), ylim=((-10, 30)), zlim=((0, 40))) ax2.xaxis.pane.fill = False ax2.yaxis.pane.fill = False ax2.zaxis.pane.fill = False ax2.xaxis.pane.set_edgecolor('w') ax2.yaxis.pane.set_edgecolor('w') ax2.zaxis.pane.set_edgecolor('w') ax2.grid(False) plt.savefig("plots/lorenz_%s_test_3D.pdf"%neuron_type) fig, (ax1, ax2, ax3) = plt.subplots(1, 3) ax1.plot(tar[:,0], tar[:,1], linestyle="--", linewidth=0.25) ax2.plot(tar[:,1], tar[:,2], linestyle="--", linewidth=0.25) ax3.plot(tar[:,0], tar[:,2], linestyle="--", linewidth=0.25) # ax2.scatter(tar[z_tar_peaks, 1], tar[z_tar_peaks, 2], s=3, color='r') # ax3.scatter(tar[z_tar_peaks, 0], tar[z_tar_peaks, 2], s=3, color='g') ax1.plot(ens[:,0], ens[:,1], linewidth=0.25) ax2.plot(ens[:,1], ens[:,2], linewidth=0.25) ax3.plot(ens[:,0], ens[:,2], linewidth=0.25) # ax2.scatter(ens[z_ens_peaks, 1], ens[z_ens_peaks, 2], s=3, color='r', marker='v') # ax3.scatter(ens[z_ens_peaks, 0], ens[z_ens_peaks, 2], s=3, color='g', marker='v') ax1.set(xlabel='x', ylabel='y') ax2.set(xlabel='y', ylabel='z') ax3.set(xlabel='x', ylabel='z') plt.tight_layout() plt.savefig("plots/lorenz_%s_test_pairwise.pdf"%neuron_type) plt.close('all') # Plot tent map and fit the data to a gaussian print('Plotting tent map') trans = int(tt/dt) tar_gauss = gaussian_filter1d(data['x'][trans:], sigma=smooth, axis=0) a_ens_gauss = gaussian_filter1d(data['ens'][trans:], sigma=smooth, axis=0) ens_gauss = np.dot(a_ens_gauss, d_ens_gauss) z_tar_peaks = find_peaks(tar_gauss[:,2], height=0)[0][1:] z_tar_values_horz = np.ravel(tar_gauss[z_tar_peaks, 2][:-1]) z_tar_values_vert = np.ravel(tar_gauss[z_tar_peaks, 2][1:]) z_ens_peaks = find_peaks(ens_gauss[:,2], height=0)[0][1:] z_ens_values_horz = np.ravel(ens_gauss[z_ens_peaks, 2][:-1]) z_ens_values_vert = np.ravel(ens_gauss[z_ens_peaks, 2][1:]) # def gaussian(x, mu, sigma, mag): # return mag * np.exp(-0.5*(np.square((x-mu)/sigma))) # p0 = [36, 2, 40] # param_ens, _ = curve_fit(gaussian, z_ens_values_horz, z_ens_values_vert, p0=p0) # param_tar, _ = curve_fit(gaussian, z_tar_values_horz, z_tar_values_vert, p0=p0) # horzs_tar = np.linspace(np.min(z_tar_values_horz), np.max(z_tar_values_horz), 100) # gauss_tar = gaussian(horzs_tar, param_tar[0], param_tar[1], param_tar[2]) # horzs_ens = np.linspace(np.min(z_ens_values_horz), np.max(z_ens_values_horz), 100) # gauss_ens = gaussian(horzs_ens, param_ens[0], param_ens[1], param_ens[2]) # error = entropy(gauss_ens, gauss_tar) fig, ax = plt.subplots() ax.scatter(z_tar_values_horz, z_tar_values_vert, alpha=0.5, color='r', label='target') # ax.plot(horzs_tar, gauss_tar, color='r', linestyle='--', label='target fit') ax.scatter(z_ens_values_horz, z_ens_values_vert, alpha=0.5, color='b', label='ens') # ax.plot(horzs_ens, gauss_ens, color='b', linestyle='--', label='ens fit') ax.set(xlabel=r'$\mathrm{max}_n (z)$', ylabel=r'$\mathrm{max}_{n+1} (z)$')#, title='error=%.5f'%error) plt.legend(loc='upper right') plt.savefig("plots/lorenz_%s_test_tent.pdf"%(neuron_type))
def go(NPre=100, N=100, t=10, c=None, seed=1, dt=0.001, tTrans=0.01, stage=None, alpha=3e-7, eMax=1e-1, Tff=0.3, fPre=DoubleExp(1e-3, 1e-1), fNMDA=DoubleExp(10.6e-3, 285e-3), fGABA=DoubleExp(0.5e-3, 1.5e-3), fS=DoubleExp(1e-3, 1e-1), dPreA=None, dPreB=None, dPreC=None, dPreD=None, dFdfw=None, dEns=None, dOff=None, ePreAFdfw=None, ePreBEns=None, ePreCOff=None, eFdfwEns=None, eEnsEns=None, ePreDEns=None, eOffFdfw=None, stimA=lambda t: 0, stimB=lambda t: 0, stimC=lambda t: 0, stimD=lambda t: 0, DA=lambda t: 0): if not c: c = t with nengo.Network(seed=seed) as model: inptA = nengo.Node(stimA) inptB = nengo.Node(stimB) inptC = nengo.Node(stimC) inptD = nengo.Node(stimD) preA = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) preB = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) preC = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) preD = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) fdfw = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed) ens = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed + 1) off = nengo.Ensemble(N, 1, neuron_type=Bio("Interneuron", DA=DA), seed=seed + 3) tarFdfw = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, 0.8), seed=seed) tarEns = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(-0.8, 0.8), seed=seed + 1) tarOff = nengo.Ensemble(N, 1, max_rates=Uniform(30, 30), intercepts=Uniform(0.2, 0.8), encoders=Choice([[1]]), seed=seed + 3) cA = nengo.Connection(inptA, preA, synapse=None, seed=seed) cB = nengo.Connection(inptB, preB, synapse=None, seed=seed) cC = nengo.Connection(inptC, preC, synapse=None, seed=seed) cD = nengo.Connection(inptD, preD, synapse=None, seed=seed) pInptA = nengo.Probe(inptA, synapse=None) pInptB = nengo.Probe(inptB, synapse=None) pInptC = nengo.Probe(inptC, synapse=None) pInptD = nengo.Probe(inptD, synapse=None) pPreA = nengo.Probe(preA.neurons, synapse=None) pPreB = nengo.Probe(preB.neurons, synapse=None) pPreC = nengo.Probe(preC.neurons, synapse=None) pPreD = nengo.Probe(preD.neurons, synapse=None) pFdfw = nengo.Probe(fdfw.neurons, synapse=None) pTarFdfw = nengo.Probe(tarFdfw.neurons, synapse=None) pEns = nengo.Probe(ens.neurons, synapse=None) pTarEns = nengo.Probe(tarEns.neurons, synapse=None) pOff = nengo.Probe(off.neurons, synapse=None) pTarOff = nengo.Probe(tarOff.neurons, synapse=None) if stage == 0: nengo.Connection(preD, tarEns, synapse=fPre, seed=seed) c0 = nengo.Connection(preD, ens, synapse=fPre, solver=NoSolver(dPreD), seed=seed) learnEncoders(c0, tarEns, fS, alpha=10 * alpha, eMax=10 * eMax, tTrans=tTrans) if stage == 1: nengo.Connection(inptA, tarFdfw, synapse=fPre, seed=seed) nengo.Connection(inptB, tarEns, synapse=fPre, seed=seed) nengo.Connection(inptC, tarOff, synapse=fPre, seed=seed) c0 = nengo.Connection(preD, ens, synapse=fPre, solver=NoSolver(dPreD), seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c3 = nengo.Connection(preC, off, synapse=fPre, solver=NoSolver(dPreC), seed=seed) learnEncoders(c1, tarFdfw, fS, alpha=3 * alpha, eMax=3 * eMax, tTrans=tTrans) learnEncoders(c2, tarEns, fS, alpha=10 * alpha, eMax=10 * eMax, tTrans=tTrans) learnEncoders(c3, tarOff, fS, alpha=3 * alpha, eMax=3 * eMax, tTrans=tTrans) if stage == 2: c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preC, off, synapse=fPre, solver=NoSolver(dPreC), seed=seed) if stage == 3: cB.synapse = fNMDA ff = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) fb = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) nengo.Connection(inptA, ff, synapse=fPre, seed=seed) nengo.Connection(inptB, fb, synapse=fNMDA, seed=seed) nengo.Connection(fb, tarEns, synapse=fPre, seed=seed) nengo.Connection(ff, tarEns, synapse=fNMDA, transform=Tff, seed=seed) c0 = nengo.Connection(preD, ens, synapse=fPre, solver=NoSolver(dPreD), seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c3 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) learnEncoders(c3, tarEns, fS, alpha=3 * alpha, eMax=3 * eMax, tTrans=tTrans) if stage == 4: cB.synapse = fNMDA c0 = nengo.Connection(preD, ens, synapse=fPre, solver=NoSolver(dPreD), seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(preB, ens, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c3 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) if stage == 5: preB2 = nengo.Ensemble(NPre, 1, max_rates=Uniform(30, 30), seed=seed) ens2 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed + 1) ens3 = nengo.Ensemble(N, 1, neuron_type=Bio("Pyramidal", DA=DA), seed=seed + 1) nengo.Connection(inptB, preB2, synapse=fNMDA, seed=seed) c0a = nengo.Connection(preD, ens, synapse=fPre, solver=NoSolver(dPreD), seed=seed) c0b = nengo.Connection(preD, ens2, synapse=fPre, solver=NoSolver(dPreD), seed=seed) c0c = nengo.Connection(preD, ens3, synapse=fPre, solver=NoSolver(dPreD), seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c3 = nengo.Connection(preB, ens2, synapse=fPre, solver=NoSolver(dPreB), seed=seed) c4 = nengo.Connection(ens2, ens, synapse=NMDA(), solver=NoSolver(dEns), seed=seed) c5 = nengo.Connection(fdfw, ens3, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c6 = nengo.Connection(preB2, ens3, synapse=fPre, solver=NoSolver(dPreB), seed=seed) learnEncoders(c4, ens3, fS, alpha=alpha, eMax=eMax, tTrans=tTrans) pTarEns = nengo.Probe(ens3.neurons, synapse=None) if stage == 9: c0 = nengo.Connection(preD, ens, synapse=fPre, solver=NoSolver(dPreD), seed=seed) c1 = nengo.Connection(preA, fdfw, synapse=fPre, solver=NoSolver(dPreA), seed=seed) c2 = nengo.Connection(fdfw, ens, synapse=NMDA(), solver=NoSolver(dFdfw), seed=seed) c3 = nengo.Connection(ens, ens, synapse=NMDA(), solver=NoSolver(dEns), seed=seed) c6 = nengo.Connection(preC, off, synapse=fPre, solver=NoSolver(dPreC), seed=seed) c7 = nengo.Connection(off, fdfw, synapse=GABA(), solver=NoSolver(dOff), seed=seed) with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim: if stage == 0: setWeights(c0, dPreD, ePreDEns) if stage == 1: setWeights(c0, dPreD, ePreDEns) setWeights(c1, dPreA, ePreAFdfw) setWeights(c2, dPreB, ePreBEns) setWeights(c3, dPreC, ePreCOff) if stage == 2: setWeights(c1, dPreA, ePreAFdfw) setWeights(c2, dPreC, ePreCOff) if stage == 3: setWeights(c0, dPreD, ePreDEns) setWeights(c1, dPreA, ePreAFdfw) setWeights(c2, dPreB, ePreBEns) setWeights(c3, dFdfw, eFdfwEns) if stage == 4: setWeights(c0, dPreD, ePreDEns) setWeights(c1, dPreA, ePreAFdfw) setWeights(c2, dPreB, ePreBEns) setWeights(c3, dFdfw, eFdfwEns) if stage == 5: setWeights(c0a, dPreD, ePreDEns) setWeights(c0b, dPreD, ePreDEns) setWeights(c0c, dPreD, ePreDEns) setWeights(c1, dPreA, ePreAFdfw) setWeights(c2, dFdfw, eFdfwEns) setWeights(c3, dPreB, ePreBEns) setWeights(c4, dEns, eEnsEns) setWeights(c5, dFdfw, eFdfwEns) setWeights(c6, dPreB, ePreBEns) if stage == 9: setWeights(c0, dPreD, ePreDEns) setWeights(c1, dPreA, ePreAFdfw) setWeights(c2, dFdfw, eFdfwEns) setWeights(c3, dEns, eEnsEns) setWeights(c6, dPreC, ePreCOff) setWeights(c7, dOff, eOffFdfw) neuron.h.init() sim.run(t, progress_bar=True) reset_neuron(sim, model) ePreDEns = c0.e if stage == 0 else ePreDEns ePreAFdfw = c1.e if stage == 1 else ePreAFdfw ePreBEns = c2.e if stage == 1 else ePreBEns ePreCOff = c3.e if stage == 1 else ePreCOff eFdfwEns = c3.e if stage == 3 else eFdfwEns eEnsEns = c4.e if stage == 5 else eEnsEns return dict( times=sim.trange(), inptA=sim.data[pInptA], inptB=sim.data[pInptB], inptC=sim.data[pInptC], inptD=sim.data[pInptD], preA=sim.data[pPreA], preB=sim.data[pPreB], preC=sim.data[pPreC], preD=sim.data[pPreD], fdfw=sim.data[pFdfw], ens=sim.data[pEns], off=sim.data[pOff], tarFdfw=sim.data[pTarFdfw], tarEns=sim.data[pTarEns], tarOff=sim.data[pTarOff], ePreAFdfw=ePreAFdfw, ePreBEns=ePreBEns, ePreCOff=ePreCOff, ePreDEns=ePreDEns, eFdfwEns=eFdfwEns, eEnsEns=eEnsEns, eOffFdfw=eOffFdfw, )
def run(t=60, tTrans=30, dt=1e-4, maxRate=30, intercept=-0.25, f=DoubleExp(1e-3, 3e-2), fS=DoubleExp(1e-2, 1e-1), nBins=21): print('training readout decoders for pre') stim = makeSignal(t, f, dt=0.001, seed=0) data = go(t=t, m=Uniform(maxRate, maxRate), i=Uniform(intercept, intercept), dt=0.001, f=f, fS=fS, stim=stim) spikes = np.array([data['pre']]) targets = np.array([f.filt(data['inpt'], dt=0.001)]) d1, f1, tauRise1, tauFall1, X, Y, error = decode(spikes, targets, 1, dt=0.001, name="tuneNew") print("training encoders") e1 = np.zeros((100, 1, 1)) stim = makeSignal(t, f, dt=dt, seed=0) data = go(d1=d1, e1=e1, f1=f1, t=t, dt=dt, f=f, fS=fS, stim=stim, l1=True) x = fS.filt(data['inpt'], dt=dt) times = data['times'] aLif = fS.filt(data['lif'], dt=dt) aWilson = fS.filt(data['wilson'], dt=dt) aBio = fS.filt(data['bio'], dt=dt) fig, (ax, ax2) = plt.subplots(nrows=2, ncols=1, sharex=True) ax.plot(times, x, label="input") ax.axhline(intercept, color='k', alpha=0.5, label="intercept") ax2.plot(times, aLif, alpha=0.5, label='LIF') ax2.plot(times, aWilson, alpha=0.5, label='Wilson') ax2.plot(times, aBio, alpha=0.5, label='bio') ax.set(xlim=((0, tTrans)), ylim=((-1, 1)), ylabel=r"$\mathbf{x}$(t)") ax2.set(xlim=((0, tTrans)), ylim=((0, 40)), xlabel='time (s)', ylabel=r"$a(t)$") ax.legend(loc='upper left') ax2.legend(loc='upper left') plt.savefig('plots/tuneNew.pdf') plt.close('all') x = fS.filt(data['inpt'], dt=dt)[int(tTrans/dt):] times = data['times'][int(tTrans/dt):] aLif = fS.filt(data['lif'], dt=dt)[int(tTrans/dt):] aWilson = fS.filt(data['wilson'], dt=dt)[int(tTrans/dt):] aBio = fS.filt(data['bio'], dt=dt)[int(tTrans/dt):] bins = np.linspace(-1, 1, nBins) bLif, bWilson, bBio = [], [], [] for b in range(len(bins)): bLif.append([]) bWilson.append([]) bBio.append([]) for t in range(len(times)): idx = (np.abs(bins - x[t])).argmin() bLif[idx].append(aLif[t][0]) bWilson[idx].append(aWilson[t][0]) bBio[idx].append(aBio[t][0]) mLif, mBio, mWilson = np.zeros_like(bins), np.zeros_like(bins), np.zeros_like(bins) ci1Lif, ci1Bio, ci1Wilson = np.zeros_like(bins), np.zeros_like(bins), np.zeros_like(bins) ci2Lif, ci2Bio, ci2Wilson = np.zeros_like(bins), np.zeros_like(bins), np.zeros_like(bins) for b in range(len(bins)): mLif[b] = np.mean(bLif[b]) mWilson[b] = np.mean(bWilson[b]) mBio[b] = np.mean(bBio[b]) ci1Lif[b] = sns.utils.ci(np.array(bLif[b]), which=95)[0] ci1Wilson[b] = sns.utils.ci(np.array(bWilson[b]), which=95)[0] ci1Bio[b] = sns.utils.ci(np.array(bBio[b]), which=95)[0] ci2Lif[b] = sns.utils.ci(np.array(bLif[b]), which=95)[1] ci2Wilson[b] = sns.utils.ci(np.array(bWilson[b]), which=95)[1] ci2Bio[b] = sns.utils.ci(np.array(bBio[b]), which=95)[1] fig, ax = plt.subplots() ax.plot(bins, mLif, label="LIF") ax.fill_between(bins, ci1Lif, ci2Lif, alpha=0.1) ax.plot(bins, mWilson, label="Wilson") ax.fill_between(bins, ci1Wilson, ci2Wilson, alpha=0.1) ax.plot(bins, mBio, label="Bio") ax.fill_between(bins, ci1Bio, ci2Bio, alpha=0.1) ax.axhline(maxRate, color='k', linestyle="--", label="target max rate") ax.axvline(intercept, color='k', label="target intercept") ax.set(xlim=((-1, 1)), ylim=((0, maxRate+1)), xlabel=r"$\mathbf{x}$", ylabel="firing rate (Hz)") ax.legend() fig.savefig("plots/tuneNew2.pdf")
def run(NPre=100, N=100, t=10, c=None, nTrain=10, nTest=5, dt=0.001, neuron_type=LIF(), fPre=DoubleExp(1e-3, 1e-1), fNMDA=DoubleExp(10.6e-3, 285e-3), reg=1e-2, load=[], file=None, neg=True): if not c: c = t if 0 in load: dPre = np.load(file)['dPre'] else: print('readout decoders for pre') spikesInpt = np.zeros((nTrain, int(t / dt), NPre)) targetsInpt = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stim = makeSignal(t, fPre, fNMDA, seed=n) data = go(NPre=NPre, N=N, t=t, fPre=fPre, fNMDA=fNMDA, neuron_type=neuron_type, stim=stim) spikesInpt[n] = data['pre'] targetsInpt[n] = fPre.filt(data['inpt'], dt=dt) dPre, X, Y, error = decodeNoF(spikesInpt, targetsInpt, nTrain, fPre, reg=reg) np.savez("data/diffMemory_%s.npz" % neuron_type, dPre=dPre) times = np.arange(0, t * nTrain, 0.001) plotState(times, X, Y, error, "diffMemory_%s" % neuron_type, "pre", t * nTrain) if 1 in load: dDiff = np.load(file)['dDiff'] else: print('readout decoders for diff') spikes = np.zeros((nTrain, int(t / dt), N)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stim = makeSignal(t, fPre, fNMDA, seed=n) data = go(NPre=NPre, N=N, t=t, fPre=fPre, fNMDA=fNMDA, neuron_type=neuron_type, stim=stim, dPre=dPre) spikes[n] = data['diff'] targets[n] = fNMDA.filt(fPre.filt(data['inpt'], dt=dt), dt=dt) dDiff, X, Y, error = decodeNoF(spikes, targets, nTrain, fNMDA, reg=reg) np.savez("data/diffMemory_%s.npz" % neuron_type, dPre=dPre, dDiff=dDiff) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "diffMemory_%s" % neuron_type, "diff", t * nTrain) if 2 in load: dEns = np.load(file)['dEns'] dNeg = np.load(file)['dNeg'] else: print('readout decoders for ens') spikes = np.zeros((nTrain, int(t / dt), N)) targets = np.zeros((nTrain, int(t / dt), 1)) for n in range(nTrain): stim = makeSignal(t, fPre, fNMDA, seed=n) # data = go(NPre=NPre, N=N, t=t, fPre=fPre, fNMDA=fNMDA, neuron_type=neuron_type, stim=stim, dPre=dPre, dDiff=dDiff) data = go(NPre=NPre, N=N, t=t, fPre=fPre, fNMDA=fNMDA, neuron_type=neuron_type, stim=stim, dPre=dPre, dDiff=dDiff, train=True, Tff=0.3) spikes[n] = data['ens'] # targets[n] = fNMDA.filt(fNMDA.filt(fPre.filt(data['inpt'], dt=dt), dt=dt), dt=dt) targets[n] = fNMDA.filt(fPre.filt(data['intg'], dt=dt), dt=dt) dEns, X, Y, error = decodeNoF(spikes, targets, nTrain, fNMDA, reg=reg) dNeg = -np.array(dEns) np.savez("data/diffMemory_%s.npz" % neuron_type, dPre=dPre, dDiff=dDiff, dEns=dEns, dNeg=dNeg) times = np.arange(0, t * nTrain, dt) plotState(times, X, Y, error, "diffMemory_%s" % neuron_type, "ens", t * nTrain) print('testing') vals = np.linspace(-1, 1, nTest) for test in range(nTest): if neg: stim = lambda t: vals[test] if t < c else 0 data = go(NPre=NPre, N=N, t=t, fPre=fPre, fNMDA=fNMDA, neuron_type=neuron_type, stim=stim, dPre=dPre, dDiff=dDiff, dEns=dEns, dNeg=dNeg, c=c) else: stim = makeSignal(t, fPre, fNMDA, seed=test) data = go(NPre=NPre, N=N, t=t, fPre=fPre, fNMDA=fNMDA, neuron_type=neuron_type, stim=stim, dPre=dPre, dDiff=dDiff, dEns=dEns, dNeg=None, c=None, Tff=0.3) aDiff = fNMDA.filt(fPre.filt(data['diff'], dt=dt), dt=dt) aEns = fNMDA.filt(fNMDA.filt(fPre.filt(data['ens'], dt=dt), dt=dt), dt=dt) xhatDiff = np.dot(aDiff, dDiff) xhatEns = np.dot(aEns, dEns) u = fNMDA.filt(fPre.filt(data['inpt'], dt=dt), dt=dt) u2 = fNMDA.filt(fNMDA.filt(fPre.filt(data['inpt'], dt=dt), dt=dt), dt=dt) x = fNMDA.filt(fNMDA.filt(fPre.filt(data['intg'], dt=dt), dt=dt), dt=dt) error = rmse(xhatEns, x) fig, ax = plt.subplots() if neg: ax.plot(data['times'], u2, alpha=0.5, label="input (delayed)") ax.axvline(c, label="cutoff") else: # ax.plot(data['times'], 0.3*u2, alpha=0.5, label="input") ax.plot(data['times'], x, alpha=0.5, label="integral") # ax.plot(data['times'], xhatDiff, label="diff") ax.plot(data['times'], xhatEns, label="ens") ax.set(xlabel='time', ylabel='state', title="rmse=%.3f" % error, xlim=((0, t)), ylim=((-1, 1))) ax.legend(loc='upper left') sns.despine() fig.savefig("plots/diffMemory_%s_test%s.pdf" % (neuron_type, test))