def test_parameters_3d(self):
# test min_spikes parameter
output_msip_min_spikes = spade.spade(
self.msip,
self.bin_size,
self.winlen,
min_spikes=self.min_spikes,
approx_stab_pars=dict(
n_subsets=self.n_subset),
n_surr=self.n_surr,
spectrum='3d#',
alpha=self.alpha,
psr_param=self.psr_param,
stat_corr='no',
output_format='patterns')['patterns']
# collecting spade output
elements_msip_min_spikes = []
for out in output_msip_min_spikes:
elements_msip_min_spikes.append(out['neurons'])
elements_msip_min_spikes = sorted(
elements_msip_min_spikes, key=len)
lags_msip_min_spikes = []
for out in output_msip_min_spikes:
lags_msip_min_spikes.append(list(out['lags'].magnitude))
lags_msip_min_spikes = sorted(
lags_msip_min_spikes, key=len)
# check the lags
assert_array_equal(lags_msip_min_spikes, [
l for l in self.lags_msip if len(l) + 1 >= self.min_spikes])
# check the neurons in the patterns
assert_array_equal(elements_msip_min_spikes, [
el for el in self.elements_msip if len(el) >= self.min_neu and len(
el) >= self.min_spikes])
# test min_occ parameter
output_msip_min_occ = spade.spade(
self.msip,
self.bin_size,
self.winlen,
min_occ=self.min_occ,
approx_stab_pars=dict(
n_subsets=self.n_subset),
n_surr=self.n_surr,
spectrum='3d#',
alpha=self.alpha,
psr_param=self.psr_param,
stat_corr='no',
output_format='patterns')['patterns']
# collect spade output
occ_msip_min_occ = []
for out in output_msip_min_occ:
occ_msip_min_occ.append(list(out['times'].magnitude))
occ_msip_min_occ = sorted(occ_msip_min_occ, key=len)
# test occurrences time
assert_array_equal(occ_msip_min_occ, [
occ for occ in self.occ_msip if len(occ) >= self.min_occ])
def test_spade_msip_3d(self):
output_msip = spade.spade(self.msip,
self.bin_size,
self.winlen,
approx_stab_pars=dict(
n_subsets=self.n_subset,
stability_thresh=self.stability_thresh),
n_surr=self.n_surr,
spectrum='3d#',
alpha=self.alpha,
psr_param=self.psr_param,
stat_corr='no',
output_format='patterns')['patterns']
elements_msip = []
occ_msip = []
lags_msip = []
# collecting spade output
for out in output_msip:
elements_msip.append(out['neurons'])
occ_msip.append(list(out['times'].magnitude))
lags_msip.append(list(out['lags'].magnitude))
elements_msip = sorted(elements_msip, key=len)
occ_msip = sorted(occ_msip, key=len)
lags_msip = sorted(lags_msip, key=len)
# check neurons in the patterns
assert_array_equal(elements_msip, self.elements_msip)
# check the occurrences time of the patters
assert_array_equal(occ_msip, self.occ_msip)
# check the lags
assert_array_equal(lags_msip, self.lags_msip)
def test_spade_msip(self):
output_msip = spade.spade(self.msip, self.binsize,
self.winlen,
n_subsets=self.n_subset,
stability_thresh=self.stability_thresh,
n_surr=self.n_surr, alpha=self.alpha,
psr_param=self.psr_param,
output_format='patterns')['patterns']
elements_msip = []
occ_msip = []
lags_msip = []
# collecting spade output
for out in output_msip:
elements_msip.append(out['neurons'])
occ_msip.append(list(out['times'].magnitude))
lags_msip.append(list(out['lags'].magnitude))
elements_msip = sorted(elements_msip, key=lambda d: len(d))
occ_msip = sorted(occ_msip, key=lambda d: len(d))
lags_msip = sorted(lags_msip, key=lambda d: len(d))
# check neurons in the patterns
assert_array_equal(elements_msip, self.elements_msip)
# check the occurrences time of the patters
assert_array_equal(occ_msip, self.occ_msip)
# check the lags
assert_array_equal(lags_msip, self.lags_msip)
def test_pattern_set_reduction(self):
output_msip = spade.spade(self.patt_psr,
self.binsize,
self.winlen,
n_subsets=self.n_subset,
stability_thresh=self.stability_thresh,
n_surr=self.n_surr,
spectrum='3d#',
alpha=self.alpha,
psr_param=self.psr_param,
output_format='patterns')['patterns']
elements_msip = []
occ_msip = []
lags_msip = []
# collecting spade output
for out in output_msip:
elements_msip.append(sorted(out['neurons']))
occ_msip.append(list(out['times'].magnitude))
lags_msip.append(list(out['lags'].magnitude))
elements_msip = sorted(elements_msip, key=lambda d: len(d))
occ_msip = sorted(occ_msip, key=lambda d: len(d))
lags_msip = sorted(lags_msip, key=lambda d: len(d))
# check neurons in the patterns
assert_array_equal(elements_msip, [range(len(self.lags3) + 1)])
# check the occurrences time of the patters
assert_array_equal(len(occ_msip[0]), self.n_occ3)
def test_spade_msip(self):
output_msip = spade.spade(self.msip,
self.binsize,
self.winlen,
n_subsets=self.n_subset,
stability_thresh=self.stability_thresh,
n_surr=self.n_surr,
alpha=self.alpha,
psr_param=self.psr_param,
output_format='patterns')['patterns']
elements_msip = []
occ_msip = []
lags_msip = []
# collecting spade output
for out in output_msip:
elements_msip.append(out['neurons'])
occ_msip.append(list(out['times'].magnitude))
lags_msip.append(list(out['lags'].magnitude))
elements_msip = sorted(elements_msip, key=lambda d: len(d))
occ_msip = sorted(occ_msip, key=lambda d: len(d))
lags_msip = sorted(lags_msip, key=lambda d: len(d))
# check neurons in the patterns
assert_array_equal(elements_msip, self.elements_msip)
# check the occurrences time of the patters
assert_array_equal(occ_msip, self.occ_msip)
# check the lags
assert_array_equal(lags_msip, self.lags_msip)
def test_parameters(self):
# test min_spikes parameter
output_msip_min_spikes = spade.spade(self.msip, self.binsize,
self.winlen,
n_subsets=self.n_subset,
n_surr=self.n_surr, alpha=self.alpha,
min_spikes=self.min_spikes,
psr_param=self.psr_param,
output_format='patterns')['patterns']
# collecting spade output
elements_msip_min_spikes= []
for out in output_msip_min_spikes:
elements_msip_min_spikes.append(out['neurons'])
elements_msip_min_spikes = sorted(elements_msip_min_spikes, key=lambda d: len(d))
lags_msip_min_spikes= []
for out in output_msip_min_spikes:
lags_msip_min_spikes.append(list(out['lags'].magnitude))
lags_msip_min_spikes = sorted(lags_msip_min_spikes, key=lambda d: len(d))
# check the lags
assert_array_equal(lags_msip_min_spikes, [
l for l in self.lags_msip if len(l)+1>=self.min_spikes])
# check the neurons in the patterns
assert_array_equal(elements_msip_min_spikes, [
el for el in self.elements_msip if len(el)>=self.min_neu and len(
el)>=self.min_spikes])
# test min_occ parameter
output_msip_min_occ = spade.spade(self.msip, self.binsize,
self.winlen,
n_subsets=self.n_subset,
n_surr=self.n_surr, alpha=self.alpha,
min_occ=self.min_occ,
psr_param=self.psr_param,
output_format='patterns')['patterns']
# collect spade output
occ_msip_min_occ= []
for out in output_msip_min_occ:
occ_msip_min_occ.append(list(out['times'].magnitude))
occ_msip_min_occ = sorted(occ_msip_min_occ, key=lambda d: len(d))
# test occurrences time
assert_array_equal(occ_msip_min_occ, [
occ for occ in self.occ_msip if len(occ)>=self.min_occ])
def test_spade_cpp(self):
output_cpp = spade.spade(self.cpp, self.binsize, 1,
n_subsets=self.n_subset,
stability_thresh=self.stability_thresh,
n_surr=self.n_surr, alpha=self.alpha,
psr_param=self.psr_param,
output_format='patterns')['patterns']
elements_cpp = []
lags_cpp = []
# collecting spade output
for out in output_cpp:
elements_cpp.append(sorted(out['neurons']))
lags_cpp.append(list(out['lags'].magnitude))
# check neurons in the patterns
assert_array_equal(elements_cpp, [range(self.n_neu)])
# check the lags
assert_array_equal(lags_cpp, [np.array([0] * (self.n_neu - 1))])
'max_spikes': max_spikes
}
# Check MPI parameters
comm = MPI.COMM_WORLD # create MPI communicator
rank = comm.Get_rank() # get rank of current MPI task
size = comm.Get_size() # Get the total number of MPI processes
print('Number of processes:{}'.format(size))
# Compute spade res
print('Running spade')
spade_res = spade.spade(data,
binsize=binsize,
winlen=winlen,
n_surr=n_surr,
min_spikes=min_spikes,
max_spikes=max_spikes,
spectrum=spectrum,
alpha=1,
min_occ=10,
min_neu=10,
output_format='concepts',
psr_param=None)
# Storing data
res_path = '../results/{}/winlen{}'.format(sess_id, winlen)
spectrum = '3d#'
# Create path if not already existing
path_temp = './'
for folder in split_path(res_path):
path_temp = path_temp + '/' + folder
mkdirp(path_temp)
def test_parameters(self):
"""
Test under different configuration of parameters than the default one
"""
# test min_spikes parameter
with self.assertWarns(UserWarning):
# n_surr=0 and alpha=0.05 spawns expected UserWarning
output_msip_min_spikes = spade.spade(
self.msip,
self.bin_size,
self.winlen,
min_spikes=self.min_spikes,
approx_stab_pars=dict(n_subsets=self.n_subset),
n_surr=0,
alpha=self.alpha,
psr_param=self.psr_param,
stat_corr='no',
output_format='patterns')['patterns']
# collecting spade output
elements_msip_min_spikes = []
for out in output_msip_min_spikes:
elements_msip_min_spikes.append(out['neurons'])
elements_msip_min_spikes = sorted(elements_msip_min_spikes, key=len)
lags_msip_min_spikes = []
for out in output_msip_min_spikes:
lags_msip_min_spikes.append(list(out['lags'].magnitude))
pvalue = out['pvalue']
lags_msip_min_spikes = sorted(lags_msip_min_spikes, key=len)
# check the lags
assert_array_equal(
lags_msip_min_spikes,
[l for l in self.lags_msip if len(l) + 1 >= self.min_spikes])
# check the neurons in the patterns
assert_array_equal(elements_msip_min_spikes, [
el for el in self.elements_msip
if len(el) >= self.min_neu and len(el) >= self.min_spikes
])
# check that the p-values assigned are equal to -1 (n_surr=0)
assert_array_equal(-1, pvalue)
# test min_occ parameter
output_msip_min_occ = spade.spade(
self.msip,
self.bin_size,
self.winlen,
min_occ=self.min_occ,
approx_stab_pars=dict(n_subsets=self.n_subset),
n_surr=self.n_surr,
alpha=self.alpha,
psr_param=self.psr_param,
stat_corr='no',
output_format='patterns')['patterns']
# collect spade output
occ_msip_min_occ = []
for out in output_msip_min_occ:
occ_msip_min_occ.append(list(out['times'].magnitude))
occ_msip_min_occ = sorted(occ_msip_min_occ, key=len)
# test occurrences time
assert_array_equal(
occ_msip_min_occ,
[occ for occ in self.occ_msip if len(occ) >= self.min_occ])
# test max_spikes parameter
output_msip_max_spikes = spade.spade(
self.msip,
self.bin_size,
self.winlen,
max_spikes=self.max_spikes,
approx_stab_pars=dict(n_subsets=self.n_subset),
n_surr=self.n_surr,
alpha=self.alpha,
psr_param=self.psr_param,
stat_corr='no',
output_format='patterns')['patterns']
# collecting spade output
elements_msip_max_spikes = []
for out in output_msip_max_spikes:
elements_msip_max_spikes.append(out['neurons'])
elements_msip_max_spikes = sorted(elements_msip_max_spikes, key=len)
lags_msip_max_spikes = []
for out in output_msip_max_spikes:
lags_msip_max_spikes.append(list(out['lags'].magnitude))
lags_msip_max_spikes = sorted(lags_msip_max_spikes, key=len)
# check the lags
assert_array_equal(
[len(lags) < self.max_spikes for lags in lags_msip_max_spikes],
[True] * len(lags_msip_max_spikes))
# test max_occ parameter
output_msip_max_occ = spade.spade(
self.msip,
self.bin_size,
self.winlen,
max_occ=self.max_occ,
approx_stab_pars=dict(n_subsets=self.n_subset),
n_surr=self.n_surr,
alpha=self.alpha,
psr_param=self.psr_param,
stat_corr='no',
output_format='patterns')['patterns']
# collect spade output
occ_msip_max_occ = []
for out in output_msip_max_occ:
occ_msip_max_occ.append(list(out['times'].magnitude))
occ_msip_max_occ = sorted(occ_msip_max_occ, key=len)
# test occurrences time
assert_array_equal(
occ_msip_max_occ,
[occ for occ in self.occ_msip if len(occ) <= self.max_occ])
comm = MPI.COMM_WORLD # create MPI communicator
rank = comm.Get_rank() # get rank of current MPI task
size = comm.Get_size() # get tot number of MPI tasks
print(size)
# Analyzing the 100 realization of data
for rep in range(100):
print(("Doing rep", rep))
# Selecting data
spikedata = datafile['sts_%iocc_%ixi' % (occ, xi)][rep]
# SPADE analysis
if xi == 0 and occ == 0 and rep == 0:
output = spade.spade(spikedata,
binsize,
winlen,
dither=dither,
n_surr=n_surr,
min_spikes=min_spikes,
min_occ=min_occ,
spectrum=spectrum)
else:
output = spade.spade(spikedata,
binsize,
winlen,
dither=dither,
n_surr=0,
min_spikes=min_spikes,
min_occ=min_occ,
spectrum=spectrum)
# Storing data
if rank == 0:
results[rep] = output
'min_spikes': min_spikes,
'max_spikes': max_spikes
}
# Check MPI parameters
comm = MPI.COMM_WORLD # create MPI communicator
rank = comm.Get_rank() # get rank of current MPI task
size = comm.Get_size() # Get the total number of MPI processes
print('Number of processes:{}'.format(size))
# Compute spade res
print('Running spade')
spade_res = spade.spade(data,
binsize=binsize,
winlen=winlen,
n_surr=n_surr,
min_spikes=min_spikes,
max_spikes=max_spikes,
spectrum=spectrum,
alpha=1,
psr_param=None)
# Storing data
res_path = '../results/{}/winlen{}'.format(spectrum, winlen)
# Create path if not already existing
path_temp = './'
for folder in split_path(res_path):
path_temp = path_temp + '/' + folder
mkdirp(path_temp)
np.save(res_path + '/art_data_results.npy', [spade_res, param])
