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_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])