def sync_bursts(self, a0, f, k, var=1e-3): """Create synchronous bursts (1 ms variance) of thalamic-ish spike Params ------ f : numeric Oscillation frequency (Hz) k : numeric Number of neuron to spike at a time """ if k > self.n: raise ValueError("k is larger than N") if f < 0: raise ValueError("f must be greater then 0") if k < 0: raise ValueError("k must be greater then 0") # Locate about where the pulses of spikes will go, at f, wl = 1 / float(f) n_pulses = int(self.t * f) pulses = [] t_p = 0 for _ in range(n_pulses): t_p += wl # Gaurd against negative ts if t_p > (3 * var): pulses.append(t_p) # and fill in the pulses with Gaussin distributed spikes. Ns = range(self.n) ts = [] ns = [] for t in pulses: ts += list(t + self.prng.normal(0, var, k)) # Assign spikes to random neurons, at most # one spike / neuron self.prng.shuffle(Ns) ns += list(Ns)[0:k] ts = np.array(ts) ns = np.array(ns) # Just in case any negative time any slipped trough mask = ts > 0 ts = ts[mask] ns = ns[mask] spikes = to_spikes(ns, ts, self.t, self.n, self.dt) # Create baseline firing base = self.poisson(constant(self.times, a0)) spikes = base + spikes spikes[spikes > 1] = 1 return spikes
def _run(n, n_b, t, Iosc, f, g, Istim, Sstim, Ipri, dt, back_type, stim_seed=None): # rate = 1.0 / dt # -- SIM --------------------------------------------------------------------- # Init spikers backspikes = neurons.Spikes(n_b, t, dt=dt) pacspikes = neurons.Spikes(n, t, dt=dt, private_stdev=Ipri) drivespikes = neurons.Spikes(n, t, dt=dt, private_stdev=Ipri) times = pacspikes.times # brevity # -- # Create biases d_bias = {} if back_type == 'constant': d_bias['back'] = rates.constant(times, 2) elif back_type == 'stim': d_bias['back'] = rates.stim(times, Istim, Sstim, seed=stim_seed) else: raise ValueError("pac_type not understood") # Drive and osc d_bias['osc'] = rates.osc(times, Iosc, f) d_bias['stim'] = rates.stim(times, Istim, Sstim, seed=stim_seed) # PAC math d_bias['gain'] = d_bias['stim'] * (g * d_bias['osc']) d_bias['summed'] = d_bias['stim'] + (g * d_bias['osc']) d_bias['silenced'] = d_bias['stim'] - (g * d_bias['osc']) # -- # Simulate spiking # Create the background pool. b_spks = backspikes.poisson(d_bias['back']) # Create a non-PAC stimulus pattern for MI inqualities stim_sp = np.hstack([ drivespikes.poisson(d_bias['stim']), b_spks ]) # and then create PAC spikes. d_spikes = {} for k in d_bias.keys(): d_spikes[k + "_p"] = np.hstack([ pacspikes.poisson(d_bias[k]), b_spks ]) # -- LFP ------------------------------------------------------------------ d_lfps = {} for k in d_spikes.keys(): d_lfps[k] = lfp.create_synaptic_lfps(d_spikes[k]) # -- I -------------------------------------------------------------------- to_calc = ('HX', 'HY', 'HXY') m = 8 # Per Ince's advice d_infos = {} for k in d_spikes.keys(): d_infos[k] = en.DiscreteSystem( en.quantise_discrete(stim_sp.sum(1), m), (1, m), en.quantise_discrete(d_spikes[k].sum(1), m), (1, m) ) d_infos[k].calculate_entropies(method='pt', calc=to_calc) # MI d_mis = {} for k, mi in d_infos.items(): d_mis[k] = mi.I() # H d_hs = {} for k, mi in d_infos.items(): d_hs[k] = mi.H # -- PAC ------------------------------------------------------------------ low_f = (f-2, f+2) high_f = (80, 250) d_pacs = {} for k in d_lfps.keys(): d_pacs[k] = pacfn(d_lfps[k], d_lfps[k], low_f, high_f) return { 'MI' : d_mis, 'H' : d_hs, 'PAC' : d_pacs, 'spikes' : d_spikes, 'lfps' : d_lfps, 'times' : times }
def oscillatory_coupling(num_pop=50, num_background=5, t=5, osc_rate=6, f=6, g=1, g_max=1, q=0.5, stim_rate=12, frac_std=.01, m=8, priv_std=0, dt=0.001, squelch=False, save=None, stim_seed=None, seed=None): """Run a single OC simulation.""" # -- Safety ------------------------------------------------------------- if g > g_max: raise ValueError("g must be < g_max") min_rate = 2 if stim_rate <= min_rate: raise ValueError(f"stim_rate must be greater {min_rate}") if f < 3: raise ValueError("f (freq) must be greater then 2") # q can't be exactly 0 q += EPS # -- Init --------------------------------------------------------------- # Poisson neurons backspikes = neurons.Spikes(num_background, t, dt=dt, seed=seed) ocspikes = neurons.Spikes(num_pop, t, dt=dt, private_stdev=priv_std, seed=seed) times = ocspikes.times # brevity # Set stim std. It must be relative to stim_rate stim_std = frac_std * stim_rate # -- Drives ------------------------------------------------------------- # Create biases/drives d_bias = {} # Background is 2 Hz d_bias['back'] = rates.constant(times, 2) # Drives proper: # 1. O d_bias['osc'] = rates.osc(times, osc_rate, f) if squelch: d_bias['osc'] = rates.constant(times, osc_rate) # 2. S d_bias['stim'] = rates.stim(times, stim_rate, stim_std, seed=stim_seed, min_rate=min_rate) # - # Linear modulatons d_bias['mult'] = d_bias['stim'] * ((g_max - g + 1) * d_bias['osc']) d_bias['add'] = d_bias['stim'] + (g * d_bias['osc']) d_bias['sub'] = d_bias['stim'] - (g * d_bias['osc']) div = d_bias['stim'] / (g * d_bias['osc']) sub = d_bias['stim'] - (g * d_bias['osc']) d_bias['div_sub'] = (q * div) + ((1 - q) * sub) # - # Nonlinear transform (RELU) for k, v in d_bias.items(): d_bias[k] = phi(v) # -- Simulate spiking --------------------------------------------------- # Create a ref stimulus stim_ref = d_bias["stim"] # Create the background pool. b_spks = backspikes.poisson(d_bias['back']) # Create OC outputs. This includes a null op stimulus, our baseline. d_spikes = {} for k in d_bias.keys(): d_spikes[k + "_p"] = np.hstack([ocspikes.poisson(d_bias[k]), b_spks]) # -- I ------------------------------------------------------------------ # Scale stim y_ref = normalize(stim_ref) d_rescaled = {} d_rescaled["stim_ref"] = y_ref if not squelch: d_rescaled["osc_ref"] = normalize(d_bias["osc"]) else: # Can't norm a single number d_rescaled["osc_ref"] = np.zeros_like(d_bias["osc"]) # Calc MI and H d_mis = {} d_deltas = {} d_hs = {} d_py = {} # Save ref H and dist d_py["stim_ref"] = discrete_dist(y_ref, m) d_hs["stim_ref"] = discrete_entropy(y_ref, m) # p(y), H, MI following rate norm for k in d_spikes.keys(): y = normalize(d_spikes[k].sum(1)) d_rescaled[k] = y d_py[k] = discrete_dist(y, m) d_mis[k] = discrete_mutual_information(y_ref, y, m) d_hs[k] = discrete_entropy(y, m) # Change in MI for k in d_mis.keys(): d_deltas[k] = d_mis[k] - d_mis["stim_p"] # -- LFP ---------------------------------------------------------------- d_lfps = {} for k in d_spikes.keys(): d_lfps[k] = create_lfps(d_spikes[k], tau=0.002, dt=.001) # -- Extract peak power ------------------------------------------------- d_powers = {} d_centers = {} for k in d_lfps.keys(): freq, spectrum = welch(d_lfps[k], fs=1000, scaling='spectrum', average='median') max_i = np.argmax(spectrum) d_powers[k] = spectrum[max_i] d_centers[k] = freq[max_i] # -- Measure OC using PAC ----------------------------------------------- low_f = (int(f - 2), int(f + 2)) high_f = (80, 250) d_pacs = {} for k in d_lfps.keys(): d_pacs[k] = pacfn(d_lfps['osc_p'], d_lfps[k], low_f, high_f) # - result = { 'MI': d_mis, 'dMI': d_deltas, 'H': d_hs, 'PAC': d_pacs, 'power': d_powers, 'center': d_centers, 'p_y': d_py, 'bias': d_bias, 'spikes': d_spikes, 'rescaled': d_rescaled, 'lfp': d_lfps, 'times': times } if save is not None: save_result(save, result) return result
f = 1 # Freq of oscillation Iback = 10 # Avg rate of the background noise # Timing dt = 0.001 rate = 1 / dt # -- SIM --------------------------------------------------------------------- # Init spikers nrns = neurons.Spikes(n, t, dt=dt, seed=42) times = nrns.times # brevity # Create biases osc = rates.osc(times, Iosc, f) stim = rates.stim(times, Istim, Sstim, seed) noise = rates.constant(times, Iback) # Simulate spiking spks_osc = nrns.poisson(osc) spks_stim = nrns.poisson(stim) spks_noise = nrns.poisson(noise) # Reformat and plot a raster spks = np.hstack([spks_osc, spks_stim, spks_noise]) # Stack 'em for plotting ns, ts = util.to_spiketimes(times, spks) plt.plot(ts, ns, 'o') # and their summed rates plt.figure() plt.subplot(311)
f = 1 # Freq of oscillation Iback = 10 # Avg rate of the background noise # Timing dt = 0.001 rate = 1 / dt # -- SIM --------------------------------------------------------------------- # Init spikers nrns = neurons.Spikes(n, t, dt=dt, seed=42) times = nrns.times # brevity # Create biases osc = rates.osc(times, Iosc, f) stim = rates.stim(times, Istim, Sstim, seed) noise = rates.constant(times, Iback) # Simulate spiking spks_osc = nrns.poisson(osc) spks_stim = nrns.poisson(stim) spks_noise = nrns.poisson(noise) # Reformat and plot a raster spks = np.hstack([spks_osc, spks_stim, spks_noise]) # Stack 'em for plotting ns, ts = util.to_spiketimes(times, spks) plt.plot(ts, ns, 'o') # and their summed rates plt.figure() plt.subplot(311) plt.plot(times, spks_osc.sum(1), label='osc')