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')
