def generate(Ntrial, duration):
'''
Inputs:
Ntrial: Number of trials
duration: Trial duration in (ms)
Outputs:
parameters: Simulation parameters values
train_ref0: Reference spike trains with synapse off
train_targ0: Target spike trains with synapse off
train_ref: Reference spike trains with synapse on
train_targ: Target spike trains with synapse on
'''
#--------------------------------------------------------------------------
# Define model parameters
#--------------------------------------------------------------------------
# Simulation parameters
time_step = 0.1 #-in (ms)
defaultclock.dt = time_step * ms
Fs = 1 / (time_step * .001) #-in (Hz)
# Neuron parameters
cm = 250 * pF # membrane capacitance
gm = 25 * nS # membrane conductance
tau = cm / gm # membrane time constant
El = -70 * mV # resting potential
Vt = El + 20 * mV # spike threshold
Vr = El + 10 * mV # reset value
refractory_period = 0 * ms # refractory period
# Background input parameters
tauI = 10 * ms # Auto-correlation time constant
sigmaI = 1. * mvolt # Noise standard-deviation
muI = Vt - .5 * mV
xmin = muI - .5 * mV # Minimal amplitude of the nonstationary input
xmax = muI + .5 * mV # Maximal amplitude
period = 50. # Duration of the piecewise constant intervals in (ms)
print("background input time constant: ", tauI / ms, "(ms)",
"Input average amplitude: ", muI / mV, "(mV)",
"Input amplitude range:", .1 * floor(
(xmax - xmin) / mV / .1), "(mV)", "Input standard-deviation",
sigmaI / mV, "(mV)", "Interval duration: ", period, "(ms)")
# Monosynapse parameters
tauS = 3 * ms # Synaptic time constant
Esyn = 0 * mV # Synaptic reversal potential
PSC = 25 * pA # Postsynaptic current ammplitude
g0 = PSC / (Esyn - muI)
latency = 1.5 * ms # Spike transmission delay
Nphase = 10
phase = duration / Nphase # Duration of session with fixed synaptic weight
wmin = .5 # Minimal synaptic weight
wmax = 4. # Maximal synaptic weight
print("Monosynaptic peak conductance: ", g0 / nsiemens, "(siemens)")
#--------------------------------------------------------------------------
# Define model
#--------------------------------------------------------------------------
# Define neurons equations
# -- Reference neuron (synapse turned on)
eqs_ref = Equations('''
dV/dt = (-V+mu+sigmaI*I)/tau : volt
I : 1 (linked)
mu : volt
''')
# -- Reference neuron (synapse turned off)
eqs_ref0 = Equations('''
dV/dt = (-V+mu+sigmaI*I)/tau : volt
I : 1 (linked)
mu : volt (linked)
''')
# -- Input noise to reference neuron (same for synapse on/off)
eqs_refnoise = Equations('''
dx/dt = -x/tauI+(2/tauI)**.5*xi : 1
''')
# -- Target neuron (synapse turned on)
eqs_targ = Equations('''
dV/dt = (-V+mu+sigmaI*I-g0/gm*gsyn*(V-Esyn))/tau : volt
I : 1 (linked)
mu : volt (linked)
#-Monosynaptic input
dgsyn/dt = -gsyn/tauS : 1
''')
# -- Input noise to target neuron (same for synapse on/off)
eqs_targnoise = Equations('''
dx/dt = -x/tauI+(2/tauI)**.5*xi : 1
''')
# 'Synapse on' model
# -- Constrain the model
reference = NeuronGroup(Ntrial,
model=eqs_ref,
threshold='V>Vt',
reset='V=Vr',
refractory=refractory_period,
method='euler')
target = NeuronGroup(Ntrial,
model=eqs_targ,
threshold='V>Vt',
reset='V=Vr',
refractory=refractory_period,
method='euler')
reference.run_regularly('''mu = xmin+(xmax-xmin)*rand()''', dt=period * ms)
target.mu = linked_var(reference, 'mu')
ref_noise = NeuronGroup(Ntrial,
model=eqs_refnoise,
threshold='x>10**6',
reset='x=0',
method='euler')
targ_noise = NeuronGroup(Ntrial,
model=eqs_targnoise,
threshold='x>10**6',
reset='x=0',
method='euler')
reference.I = linked_var(ref_noise, 'x')
target.I = linked_var(targ_noise, 'x')
# -- Parameter initialization
reference.V = (Vt - .1 * mV - Vr) * rand(Ntrial) + Vr
target.V = (Vt - .1 * mV - Vr) * rand(Ntrial) + Vr
target.gsyn = 0
ref_noise.x = 2 * rand(Ntrial) - 1
targ_noise.x = 2 * rand(Ntrial) - 1
# -- Synaptic connection
weight_value = np.random.permutation(linspace(wmin, wmax, Nphase))
weight = TimedArray(weight_value, dt=phase * ms)
synaptic = Synapses(reference,
target,
'''w = weight(t) : 1''',
on_pre='''
gsyn += w
''')
synaptic.connect(i=arange(Ntrial), j=arange(Ntrial))
synaptic.delay = latency
#--Record variables
Sref = SpikeMonitor(reference)
Starg = SpikeMonitor(target)
Msyn = StateMonitor(synaptic, 'w', record=0)
# 'Synapse off' model
# -- Constrain the model
reference0 = NeuronGroup(Ntrial,
model=eqs_ref0,
threshold='V>Vt',
reset='V=Vr',
refractory=refractory_period,
method='euler')
target0 = NeuronGroup(Ntrial,
model=eqs_targ,
threshold='V>Vt',
reset='V=Vr',
refractory=refractory_period,
method='euler')
reference0.mu = linked_var(reference, 'mu')
target0.mu = linked_var(reference, 'mu')
reference0.I = linked_var(ref_noise, 'x')
target0.I = linked_var(targ_noise, 'x')
# -- Parameter initialization
reference0.V = reference.V
target0.V = target.V
target0.gsyn = 0
#--Record variables
Sref0 = SpikeMonitor(reference0)
Starg0 = SpikeMonitor(target0)
run(duration * ms)
#--------------------------------------------------------------------------
# Check the resulting spike trains
#--------------------------------------------------------------------------
# Represent some of the recorded variables
FigW = figure()
xlabel('Time (ms)')
ylabel('Synaptic weight')
title('Target cell')
plot(Msyn.t / ms, Msyn.w[0], 'k')
# Organize the spike times into two long spike trains
# -- Synapse on
train_ref = sort(Sref.t / ms + floor(Sref.t / (ms * phase)) *
(-1 + Ntrial) * phase + Sref.i * phase)
train_targ = sort(Starg.t / ms + floor(Starg.t / (ms * phase)) *
(-1 + Ntrial) * phase + Starg.i * phase)
train = append(train_ref, train_targ)
cell = int64(append(zeros(len(train_ref)), ones(len(train_targ))))
# -- Synapse off
train_ref0 = sort(Sref0.t / ms + floor(Sref0.t / (ms * phase)) *
(-1 + Ntrial) * phase + Sref0.i * phase)
train_targ0 = sort(Starg0.t / ms + floor(Starg0.t / (ms * phase)) *
(-1 + Ntrial) * phase + Starg0.i * phase)
train0 = append(train_ref0, train_targ0)
cell0 = int64(append(zeros(len(train_ref0)), ones(len(train_targ0))))
# Basic firing parameters
print("SYNAPSE ON")
print("-- Reference train:")
print("# spikes: ", len(train_ref), "Average firing rate",
len(train_ref) / (Ntrial * duration * 1.), "CV",
std(diff(train_ref)) / mean(diff(train_ref)))
print("-- Target train:")
print("# spikes: ", len(train_targ), "Average firing rate",
len(train_targ) / (Ntrial * duration * 1.), "CV",
std(diff(train_targ)) / mean(diff(train_targ)))
print("SYNAPSE OFF")
print("-- Target train:")
print("# spikes: ", len(train_targ0), "Average firing rate",
len(train_targ0) / (Ntrial * duration * 1.), "CV",
std(diff(train_targ0)) / mean(diff(train_targ0)))
# Compute the correlogram matrix between the two long trains
lagmax = 100. # Correlogram window in (ms)
bine = 1. # Correlogram time bin in (ms)
#--WITH SYNAPSE--
ind_sort = np.argsort(train)
st = train[ind_sort] * .001
sc = cell[ind_sort]
Craw = correlograms(st,
sc,
sample_rate=Fs,
bin_size=bine / 1000.,
window_size=lagmax / 1000.)
lag = (np.arange(len(Craw[0, 1])) - len(Craw[0, 1]) / 2) * bine
#--WITHOUT SYNAPSE--
ind_sort = np.argsort(train0)
st = train0[ind_sort] * .001
sc = cell0[ind_sort]
Craw0 = correlograms(st,
sc,
sample_rate=Fs,
bin_size=bine / 1000.,
window_size=lagmax / 1000.)
# Represent the auto- and the cross-correlograms
FigACG = figure()
title('Auto-correlograms', fontsize=18)
xlim(-lagmax / 2., lagmax / 2.)
xlabel('Time lag (ms)', fontsize=18)
ylabel('Firing rate (Hz)', fontsize=18)
xticks(fontsize=18)
yticks(fontsize=18)
plot(lag, Craw[0, 0] / (len(train_ref) * bine * .001), '.-k')
plot(lag, Craw[1, 1] / (len(train_targ) * bine * .001), '.-b')
plot(lag, Craw0[1, 1] / (len(train_targ0) * bine * .001), '.-c')
FigCCG = figure()
xlim(-lagmax / 2., lagmax / 2.)
title('Cross-correlograms', fontsize=18)
xlabel('Time lag (ms)', fontsize=18)
ylabel('Firing rate (Hz)', fontsize=18)
xticks(fontsize=18)
yticks(fontsize=18)
plot(lag, Craw[0, 1] / (len(train_ref) * bine * .001), '.-k')
plot(lag, Craw0[0, 1] / (len(train_ref0) * bine * .001), '.-c')
#show()
# Save the relevant model parameters and the resulting spike trains
parameters = np.array([Ntrial, duration, period, Fs, Nphase])
return parameters, weight_value, train_ref, train_targ
# Define the target train
train = sort(S.i*duration+S.t/ms)
# Basic firing parameters
print("# spikes: ",len(train),
"Average firing rate",len(train)/(Ntrial*duration*.001),"(Hz)",
"CV",std(diff(train))/mean(diff(train)))
# Compute the ACG of the spike train
lagmax = 50.
bine = .1
ind_sort = np.argsort(train)
st = train[ind_sort]*.001
cell = int64(zeros(len(train)))
sc = cell[ind_sort]
Araw = correlograms(st,sc,sample_rate=Fs,bin_size=bine/1000.,window_size=lagmax/1000.)
lag = (np.arange(len(Araw[0,0]))-len(Araw[0,0])/2)*bine
FigACG = figure()
xlim(-lagmax/2.,lagmax/2.)
title('Auto-correlogram of Pyramidal Cell',fontsize=18)
xlabel('Time lag (ms)',fontsize=18)
ylabel('Firing rate (Hz)',fontsize=18)
xticks(fontsize=18)
yticks(fontsize=18)
bar(lag,Araw[0,0]/(len(train)*bine*.001),bine,align='center',color='k',edgecolor='k')
# Show Vm STA
def STA(T,Vm,lag_max,duration,time_step):
#--cut the part of the spike train that cannot be used for the STA
i = 0
while T[i] < lag_max:
def generate(Ntrial,duration,period):
'''
Inputs:
Ntrial: Number of pairs
duration: Trial duration in (ms)
period: Duration of the piecewise constant intervals in (ms)
Outputs:
train_ref0: Collection of reference spike trains
train_targ0: Collection of target spike trains
params: Simulation parameters values
'''
#--------------------------------------------------------------------------
# Define model parameters
#--------------------------------------------------------------------------
# Simulation parameters
time_step = 0.1
defaultclock.dt = time_step*ms # Time step of equations integration
Fs = 1/(time_step*.001)
# Neuron parameters
cm = 250*pF # Membrane capacitance
gm = 25*nS # Membrane conductance
tau = cm/gm # Membrane time constant
El = -70*mV # Resting potential
Vt = El+20*mV # Spike threshold
Vr = El+10*mV # Reset voltage
refractory_period = 0*ms # Refractory period
print("Spike threshold: ",Vt/mV,"(mV)",
"Refractory period: ",refractory_period/ms,"(ms)")
# Background input parameters
tauI = 10*ms # Auto-correlation time constant
sigmaI = 1.*mvolt # Noise standard-deviation
muI = Vt-.5*mV
xmin = muI-.5*mV # Minimal amplitude of the nonstationary input
xmax = muI+.5*mV # Maximal amplitude
print("background input time constant: ",tauI/ms,"(ms)",
"Input average amplitude: ",muI/mV,"(mV)",
"Input amplitude range:",.1*floor((xmax-xmin)/mV/.1),"(mV)",
"Input standard-deviation",sigmaI/mV,"(mV)")
#--------------------------------------------------------------------------
# Define model
#--------------------------------------------------------------------------
# Define neurons equations
# -- Reference neuron
eqs_ref = Equations('''
dV/dt = (-V+mu+sigmaI*I)/tau : volt
dI/dt = -I/tauI+(2/tauI)**.5*xi : 1
mu : volt
''')
# -- Target neuron
eqs_targ = Equations('''
dV/dt = (-V+mu+sigmaI*I)/tau : volt
dI/dt = -I/tauI+(2/tauI)**.5*xi : 1
mu : volt (linked)
''')
# Constrain the model
reference = NeuronGroup(Ntrial,model=eqs_ref,threshold='V>Vt',reset='V=Vr',
refractory=refractory_period,method='euler')
target = NeuronGroup(Ntrial,model=eqs_targ,threshold='V>Vt',reset='V=Vr',
refractory=refractory_period,method='euler')
reference.run_regularly('''mu = xmin+(xmax-xmin)*rand()''',dt=period*ms)
target.mu = linked_var(reference,'mu')
# Initialize variables
reference.V = (Vt-.1*mV-Vr)*rand(Ntrial)+Vr
reference.I = 2*rand(Ntrial)-1
reference.mu = xmin+(xmax-xmin)*rand(Ntrial)
target.V = (Vt-.1*mV-Vr)*rand(Ntrial)+Vr
target.I = 2*rand(Ntrial)-1
# Record variables
Sref = SpikeMonitor(reference)
Starg = SpikeMonitor(target)
# Integrate equations
run(duration*ms)
#--------------------------------------------------------------------------
# Check the resulting spike trains
#--------------------------------------------------------------------------
# Organize the collection of spike train pairs into two long spike trains
train_ref0 = unique(Sref.i*duration+Sref.t/ms)
train_targ0 = unique(Starg.i*duration+Starg.t/ms)
train0 = append(train_ref0,train_targ0)
cell0 = int64(append(zeros(len(train_ref0)),ones(len(train_targ0))))
# Basic statistical measure of firing
print("Reference train: # spikes/trial",len(train_ref0)/Ntrial*1.,
"firing rate",len(train_ref0)/(Ntrial*duration*.001),"(Hz)",
"CV",std(diff(train_ref0))/mean(diff(train_ref0)))
print("Target train: # spikes/trial",len(train_targ0)/Ntrial*1.,
"firing rate",len(train_targ0)/(Ntrial*duration*.001),"(Hz)",
"CV",std(diff(train_targ0))/mean(diff(train_targ0)))
# Compute the correlogram matrix between the two long trains
lagmax = 100. # Correlogram window in (ms)
bine = 1. # Correlogram time bin in (ms)
ind_sort = np.argsort(train0)
st = train0[ind_sort]*.001
sc = cell0[ind_sort]
Craw = correlograms(st,sc,sample_rate=Fs,bin_size=bine/1000.,
window_size=lagmax/1000.)
lag = (np.arange(len(Craw[0,1]))-len(Craw[0,1])/2)*bine
# Represent the auto- and the cross-correlograms
FigACG = figure()
title('Auto-correlograms',fontsize=18)
xlim(-lagmax/2.,lagmax/2.)
xlabel('Time lag (ms)',fontsize=18)
ylabel('Firing rate (Hz)',fontsize=18)
xticks(fontsize=18)
yticks(fontsize=18)
plot(lag,Craw[0,0]/(len(train_ref0)*bine*.001),'.-k')
plot(lag,Craw[1,1]/(len(train_targ0)*bine*.001),'.-b')
FigCCG = figure()
xlim(-lagmax/2.,lagmax/2.)
title('Cross-correlogram',fontsize=18)
xlabel('Time lag (ms)',fontsize=18)
ylabel('Firing rate (Hz)',fontsize=18)
xticks(fontsize=18)
yticks(fontsize=18)
plot(lag,Craw[0,1]/(len(train_ref0)*bine*.001),'.-k')
#show()
# Save the relevant model parameters and the resulting spike trains
parameters = np.array([Ntrial,duration,period,Fs])
return parameters,train_ref0,train_targ0
def analyze(parameters, train_ref0, train_targ0):
'''
Inputs:
parameters: Generative simulation parameters
train_ref0: Reference train set
train_targ0: Target train set
Outputs:
Figure 1: ROC curve for monosynapse detection
Figure 2: Area under the curve for various jitter interval lenghts
'''
#--------------------------------------------------------------------------
# Extract the spike data
#--------------------------------------------------------------------------
Ntrial = int(parameters[0]) # Number of pairs
duration = parameters[1] # Trial duration in (ms)
interval_true = parameters[2] # Nonstationarity timescale in (ms)
Fs = parameters[3] # Sampling frequency
train0 = np.append(train_ref0, train_targ0)
cell0 = np.int64(
np.append(np.zeros(len(train_ref0)), np.ones(len(train_targ0))))
#--------------------------------------------------------------------------
# Define analysis parameters
#--------------------------------------------------------------------------
inject_count = 10 # Number of injected synchronies
Ninjectedtrial = int(Ntrial / 2.) # Number of pairs to be injected
synch_width = 1. # Width of synchrony window
latency = 0. # Synaptic delay (for visual purpose)
Njitter = 110 # Number of jitter surrogates
Ndelta = 20 # Number of tested jitter timescales
Ntest = 100 # Number of detection threshold
#--------------------------------------------------------------------------
# Inject synchronous spikes
#--------------------------------------------------------------------------
# Inject spikes at random times avoiding present spikes
Nwidth = int(duration / synch_width)
allwidths = np.arange(int(Ntrial * duration / synch_width))
include_index = np.int64(np.floor(train0 / synch_width))
include_idx = list(set(include_index))
mask = np.zeros(allwidths.shape, dtype=bool)
mask[include_idx] = True
wheretoinject = synch_width * allwidths[~mask]
alreadythere = synch_width * allwidths[mask]
widths = np.append(wheretoinject, alreadythere)
tags = np.append(np.zeros(len(wheretoinject)), np.ones(len(alreadythere)))
ind_sort = np.argsort(widths)
widths = widths[ind_sort]
tags = tags[ind_sort]
widths = widths[:Ninjectedtrial * Nwidth]
tags = tags[:Ninjectedtrial * Nwidth]
widths = np.reshape(widths, (Ninjectedtrial, Nwidth))
tags = np.reshape(tags, (Ninjectedtrial, Nwidth))
ind_perm = np.transpose(
np.random.permutation(np.mgrid[:Nwidth, :Ninjectedtrial][0]))
widths = widths[np.arange(np.shape(widths)[0])[:, np.newaxis], ind_perm]
tags = tags[np.arange(np.shape(tags)[0])[:, np.newaxis], ind_perm]
ind_sort = np.argsort(tags, axis=1)
widths = widths[np.arange(np.shape(widths)[0])[:, np.newaxis], ind_sort]
tags = tags[np.arange(np.shape(tags)[0])[:, np.newaxis], ind_sort]
train_inject = np.ravel(widths[:, :inject_count]) # Injected spike trains
train_ref = np.sort(np.append(train_ref0, train_inject))
train_targ = np.sort(np.append(train_targ0, train_inject + latency))
train = np.append(train_ref, train_targ)
cell = np.int64(
np.append(np.zeros(len(train_ref)), np.ones(len(train_targ))))
#--------------------------------------------------------------------------
# Check the impact of injection
#--------------------------------------------------------------------------
lagmax = 100. # Correlogram window in (ms)
bine = 1. # Correlogram time bin in (ms)
# Select one pair of reference-target trains (without and with injection)
ind_sort = np.argsort(train0)
T0 = train0[ind_sort]
G0 = cell0[ind_sort]
ind_sort = np.argsort(train)
T = train[ind_sort]
G = cell[ind_sort]
i = 0
j = 0
while T0[i] < duration or T[j] < duration:
if T0[i] < duration:
i += 1
if T[j] < duration:
j += 1
T0 = T0[:i]
G0 = G0[:i]
T = T[:j]
G = G[:j]
# Compute the correlogram matrix for the chosen pairs
ind_sort = np.argsort(T0)
st = T0[ind_sort] * .001
sc = G0[ind_sort]
C0 = correlograms(st,
sc,
sample_rate=Fs,
bin_size=bine / 1000.,
window_size=lagmax / 1000.)
lag = (np.arange(len(C0[0, 1])) - len(C0[0, 1]) / 2.) * bine
ind_sort = np.argsort(T)
st = T[ind_sort] * .001
sc = G[ind_sort]
C = correlograms(st,
sc,
sample_rate=Fs,
bin_size=bine / 1000.,
window_size=lagmax / 1000.)
# Represent the cross-correlograms
FigCCG = plt.figure()
plt.xlim(-lagmax / 2., lagmax / 2.)
plt.title('Cross-Correlogram', fontsize=18)
plt.xlabel('Time lag (ms)', fontsize=18)
plt.ylabel('Firing rate (Hz)', fontsize=18)
plt.xticks(fontsize=18)
plt.yticks(fontsize=18)
plt.plot(lag, C[0, 1] / (len(train_ref) * bine * .001), '.-k')
plt.plot(lag, C0[0, 1] / (len(train_ref) * bine * .001), '--c')
#--------------------------------------------------------------------------
# Compute Receiver Operating Characteristic curve
#--------------------------------------------------------------------------
# Remove the synaptic delay for synchrony computation
train_targ = np.sort(np.append(train_targ0, train_inject))
train = np.append(train_ref, train_targ)
cell = np.int64(
np.append(np.zeros(len(train_ref)), np.ones(len(train_targ))))
# Count the number of total observed synchronies per pair
Tref = synch_width * np.floor(train_ref / synch_width)
Ttarg = synch_width * np.floor(train_targ / synch_width)
Tsynch = np.array(list(set(Tref) & set(Ttarg)))
synch_count = np.bincount(np.int64(np.floor(Tsynch / duration)),
minlength=Ntrial)
# Compute the true positive and false positive rates for a range of detection thresholds
delta_range = np.concatenate((np.linspace(5, 100, int(Ndelta / 2.)),
np.linspace(100, 500, int(Ndelta / 2.))))
pvalue_inj = np.zeros((Ndelta, Ninjectedtrial))
pvalue_noinj = np.zeros((Ndelta, Ntrial - Ninjectedtrial))
threshold_range = np.linspace(0, 1., Ntest)
proba_truepositive = np.zeros((Ndelta, Ntest))
proba_falsepositive = np.zeros((Ndelta, Ntest))
for k in range(Ndelta):
print('Tested timescale no: ', k + 1)
interval = delta_range[k]
# Jitter the target trains
Tjitter = (np.tile(train_targ, Njitter) +
np.sort(np.tile(np.arange(Njitter), len(train_targ))) *
Ntrial * duration)
Tjitter = (interval * np.floor(Tjitter / interval) +
np.random.uniform(0, interval, len(Tjitter)))
Tjitter = synch_width * np.floor(Tjitter / synch_width)
# Compute the p-values under the jitter null
Tref_jitter = (np.tile(Tref, Njitter) +
np.sort(np.tile(np.arange(Njitter), len(Tref))) *
Ntrial * duration)
Tsynch_jitter = np.array(list(set(Tref_jitter) & set(Tjitter)))
jitter_synchrony = np.bincount(np.int64(
np.floor(Tsynch_jitter / duration)),
minlength=Ntrial * Njitter)
observed_synchrony = np.tile(synch_count, Njitter)
comparison = np.reshape(
np.sign(np.sign(jitter_synchrony - observed_synchrony) + 1),
(Njitter, Ntrial))
pvalue = (1 + np.sum(comparison, axis=0)) / (Njitter + 1.)
pvalue_inj[
k, :] = pvalue[:Ninjectedtrial] # Correspond to injected trains
pvalue_noinj[k, :] = pvalue[
Ninjectedtrial:] # Correspond to non-injected trains
# Compute the detection probabilities for each threshold value
th = np.reshape(np.tile(threshold_range, Ninjectedtrial),
(Ninjectedtrial, Ntest))
pval = np.tile(np.reshape(pvalue_inj[k, :], (Ninjectedtrial, 1)),
Ntest)
proba_truepositive[k, :] = np.sum(np.sign(np.sign(th - pval) + 1),
axis=0)
pval = np.tile(np.reshape(pvalue_noinj[k, :], (Ninjectedtrial, 1)),
Ntest)
proba_falsepositive[k, :] = np.sum(np.sign(np.sign(th - pval) + 1),
axis=0)
proba_truepositive = proba_truepositive / Ninjectedtrial
proba_falsepositive = proba_falsepositive / (Ntrial - Ninjectedtrial)
#--------------------------------------------------------------------------
# Represent the classification result
#--------------------------------------------------------------------------
cm = plt.get_cmap('gist_rainbow')
FigROC = plt.figure()
ax = FigROC.add_subplot(111)
ax.set_color_cycle([cm(1. * i / Ndelta) for i in range(Ndelta)])
plt.title('ROC curve', fontsize=18)
plt.xlabel('False positive rate', fontsize=18)
plt.ylabel('True positive rate', fontsize=18)
plt.xticks(fontsize=18)
plt.yticks(fontsize=18)
plt.xlim(-.1, 1.1)
plt.ylim(-.1, 1.1)
clr = np.linspace(0, .5, Ndelta)
x = np.arange(0, 1, .01)
y = np.zeros((Ndelta, Ntest))
area = np.zeros(Ndelta)
for i in range(Ndelta):
ax.plot(proba_falsepositive[i, :], proba_truepositive[i, :], '.-')
# Compute the area under the ROC curve
Fx = interpolate.interp1d(proba_falsepositive[i, :],
proba_truepositive[i, :],
bounds_error=False,
fill_value=0.,
kind='nearest')
y_interp = Fx(x)
area[i] = np.sum(y_interp) * (x[1] - x[0])
plt.plot([0, 1], [0, 1], '--b')
plt.plot(.5 * np.ones(2), [0, 1], '--b')
plt.plot([0, 1], .5 * np.ones(2), '--b')
FigDroc = plt.figure()
plt.title('Injection Classifier Quantification', fontsize=18)
plt.xlabel('Jitter interval length (ms)', fontsize=18)
plt.ylabel('Area under the ROC curve', fontsize=18)
plt.xticks(fontsize=18)
plt.yticks(fontsize=18)
plt.plot(interval_true * np.ones(2), [np.amin(area), np.amax(area)], '--r')
plt.plot(delta_range, area, 'o-k')
plt.show()
def compute(
self,
ref,
event,
quantparam=None,
binsize=0.01,
window=1,
fs=1250,
nQuantiles=10,
period=None,
):
"""psth of 'event' with respect to 'ref'
Args:
ref (array): 1-D array of timings of reference event in seconds
event (1D array): timings of events whose psth will be calculated
quantparam (1D array): values used to divide 'ref' into quantiles
binsize (float, optional): [description]. Defaults to 0.01.
window (int, optional): [description]. Defaults to 1.
nQuantiles (int, optional): [description]. Defaults to 10.
Returns:
[type]: [description]
"""
# --- parameters----------
if period is not None:
event = event[(event > period[0]) & (event < period[1])]
if quantparam is not None:
quantparam = quantparam[(ref > period[0]) & (ref < period[1])]
ref = ref[(ref > period[0]) & (ref < period[1])]
if quantparam is not None:
assert len(event) == len(quantparam), print("length must be same")
quantiles = pd.qcut(quantparam, nQuantiles, labels=False)
quants, eventid = [], []
for category in range(nQuantiles):
indx = np.where(quantiles == category)[0]
quants.append(ref[indx])
eventid.append(category * np.ones(len(indx)).astype(int))
quants.append(event)
eventid.append(
((nQuantiles + 1) * np.ones(len(event))).astype(int))
quants = np.concatenate(quants)
eventid = np.concatenate(eventid)
else:
quants = np.concatenate((ref, event))
eventid = np.concatenate(
[np.ones(len(ref)), 2 * np.ones(len(event))]).astype(int)
sort_ind = np.argsort(quants)
ccg = correlograms(
quants[sort_ind],
eventid[sort_ind],
sample_rate=fs,
bin_size=binsize,
window_size=window,
)
self.psth = ccg[:-1, -1, :]
return self.psth
