def test_spike_empty(): st1 = SpikeTrain([], edges=(0.0, 1.0)) st2 = SpikeTrain([], edges=(0.0, 1.0)) d = spk.spike_distance(st1, st2) assert_allclose(d, 0.0) prof = spk.spike_profile(st1, st2) assert_allclose(d, prof.avrg()) assert_array_equal(prof.x, [0.0, 1.0]) assert_array_equal(prof.y1, [ 0.0, ]) assert_array_equal(prof.y2, [ 0.0, ]) st1 = SpikeTrain([], edges=(0.0, 1.0)) st2 = SpikeTrain([ 0.4, ], edges=(0.0, 1.0)) d = spk.spike_distance(st1, st2) d_expect = 2 * 0.4 * 0.4 * 1.0 / (0.4 + 1.0)**2 + 2 * 0.6 * 0.4 * 1.0 / ( 0.6 + 1.0)**2 assert_almost_equal(d, d_expect, decimal=15) prof = spk.spike_profile(st1, st2) assert_allclose(d, prof.avrg()) assert_array_equal(prof.x, [0.0, 0.4, 1.0]) assert_array_almost_equal( prof.y1, [2 * 0.4 * 1.0 / (0.4 + 1.0)**2, 2 * 0.4 * 1.0 / (0.6 + 1.0)**2], decimal=15) assert_array_almost_equal( prof.y2, [2 * 0.4 * 1.0 / (0.4 + 1.0)**2, 2 * 0.4 * 1.0 / (0.6 + 1.0)**2], decimal=15) st1 = SpikeTrain([ 0.6, ], edges=(0.0, 1.0)) st2 = SpikeTrain([ 0.4, ], edges=(0.0, 1.0)) d = spk.spike_distance(st1, st2) s1 = np.array([0.2, 0.2, 0.2, 0.2]) s2 = np.array([0.2, 0.2, 0.2, 0.2]) isi1 = np.array([0.6, 0.6, 0.4]) isi2 = np.array([0.4, 0.6, 0.6]) expected_y1 = (s1[:-1] * isi2 + s2[:-1] * isi1) / (0.5 * (isi1 + isi2)**2) expected_y2 = (s1[1:] * isi2 + s2[1:] * isi1) / (0.5 * (isi1 + isi2)**2) expected_times = np.array([0.0, 0.4, 0.6, 1.0]) expected_spike_val = sum((expected_times[1:] - expected_times[:-1]) * (expected_y1 + expected_y2) / 2) expected_spike_val /= (expected_times[-1] - expected_times[0]) assert_almost_equal(d, expected_spike_val, decimal=15) prof = spk.spike_profile(st1, st2) assert_allclose(d, prof.avrg()) assert_array_almost_equal(prof.x, [0.0, 0.4, 0.6, 1.0], decimal=15) assert_array_almost_equal(prof.y1, expected_y1, decimal=15) assert_array_almost_equal(prof.y2, expected_y2, decimal=15)
def distance_spike(spike_train_a, spike_train_b, interval): """ SPIKE-distance (Kreutz) using pyspike """ spike_train_1 = pyspike.SpikeTrain(spike_train_a, interval) spike_train_2 = pyspike.SpikeTrain(spike_train_b, interval) return pyspike.spike_distance(spike_train_1, spike_train_2, interval)
def synchronyCalculation( t0, t1): #counter is to name the file for easy processing later one_to_one_synchrony = pd.DataFrame( columns=['Ch_A', 'Ch_B', 'SyncVal']) #print(one_to_one_synchrony) dataframelist = [[]] #looking at first 20 spike trains for i in range(4096): data[i] = data[i][:-1] #print (data[i]) NumberOfNeighbors = len(data[i]) #print(NumberOfNeighbors) for j in range(NumberOfNeighbors): #print(data[i][j]) #print ("source channel: {}, Neighbor channels: {}".format(i,data[i][j])) SyncVal = spk.spike_distance(spike_trains[i], spike_trains[int(data[i][j])], interval=(t0, t1)) #print(SyncVal) data_input = [i, int(data[i][j]), SyncVal] dataframelist.append(data_input) #one_to_one_synchrony.append({'Ch_A':i, 'Ch_B':data[i][j], 'SyncVal':SyncVal}, ignore_index = True) del dataframelist[0] df = pd.DataFrame(dataframelist, columns=['Ch_A', 'Ch_B', 'SyncVal']) df = df.loc[(df['SyncVal'] > 0.2) & (df['SyncVal'] < 1)] #print(df) df.to_csv('SynchronyDataframes/{}.csv'.format(t0))
def calc_stimuli_distance(stimulus_a: np.array, stimulus_b: np.array, stimulus_duration: float) -> object: """ This function computes the average distance between neurons in two stimuli using the spike-distance metric (see: http://www.scholarpedia.org/article/SPIKE-distance) :param stimulus_a: numpy array where each element is a single neurons spike times, specified in milliseconds :param stimulus_b: numpy array where each element is a single neurons spike times, specified in milliseconds :param stimulus_duration: Maximal stimulus_duration of the stimulus, units: Sec """ # Verify stimuli are comparable if stimulus_a.size != stimulus_b.size: raise Exception('Stimuli must consist of same number of neurons') distances = [] # Placeholder for distances between each pair of neurons for neuron_a, neuron_b in zip(stimulus_a, stimulus_b): # Converting to pyspike SpikeTrain object for calculation neuron_a = spk.SpikeTrain(neuron_a, edges=[0, stimulus_duration * 1000]) neuron_b = spk.SpikeTrain(neuron_b, edges=[0, stimulus_duration * 1000]) # Compute distance distance = spk.spike_distance(neuron_a, neuron_b) distances.append(distance) mean_distance = np.mean(distance) return mean_distance
def test_regression_spiky(): # standard example st1 = SpikeTrain(np.arange(100, 1201, 100), 1300) st2 = SpikeTrain(np.arange(100, 1201, 110), 1300) isi_dist = spk.isi_distance(st1, st2) assert_almost_equal(isi_dist, 9.0909090909090939e-02, decimal=15) isi_profile = spk.isi_profile(st1, st2) assert_equal(isi_profile.y, 0.1/1.1 * np.ones_like(isi_profile.y)) spike_dist = spk.spike_distance(st1, st2) assert_equal(spike_dist, 2.1105878248735391e-01) spike_sync = spk.spike_sync(st1, st2) assert_equal(spike_sync, 8.6956521739130432e-01) # multivariate check spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt", (0.0, 4000.0)) isi_dist = spk.isi_distance_multi(spike_trains) # get the full precision from SPIKY assert_almost_equal(isi_dist, 0.17051816816999129656, decimal=15) spike_profile = spk.spike_profile_multi(spike_trains) assert_equal(len(spike_profile.y1)+len(spike_profile.y2), 1252) spike_dist = spk.spike_distance_multi(spike_trains) # get the full precision from SPIKY assert_almost_equal(spike_dist, 2.4432433330596512e-01, decimal=15) spike_sync = spk.spike_sync_multi(spike_trains) # get the full precision from SPIKY assert_equal(spike_sync, 0.7183531505298066)
def test_spike_empty(): st1 = SpikeTrain([], edges=(0.0, 1.0)) st2 = SpikeTrain([], edges=(0.0, 1.0)) d = spk.spike_distance(st1, st2) assert_equal(d, 0.0) prof = spk.spike_profile(st1, st2) assert_equal(d, prof.avrg()) assert_array_equal(prof.x, [0.0, 1.0]) assert_array_equal(prof.y1, [0.0, ]) assert_array_equal(prof.y2, [0.0, ]) st1 = SpikeTrain([], edges=(0.0, 1.0)) st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0)) d = spk.spike_distance(st1, st2) assert_almost_equal(d, 0.4*0.4*1.0/(0.4+1.0)**2 + 0.6*0.4*1.0/(0.6+1.0)**2, decimal=15) prof = spk.spike_profile(st1, st2) assert_equal(d, prof.avrg()) assert_array_equal(prof.x, [0.0, 0.4, 1.0]) assert_array_almost_equal(prof.y1, [0.0, 2*0.4*1.0/(0.6+1.0)**2], decimal=15) assert_array_almost_equal(prof.y2, [2*0.4*1.0/(0.4+1.0)**2, 0.0], decimal=15) st1 = SpikeTrain([0.6, ], edges=(0.0, 1.0)) st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0)) d = spk.spike_distance(st1, st2) s1 = np.array([0.0, 0.4*0.2/0.6, 0.2, 0.0]) s2 = np.array([0.0, 0.2, 0.2*0.4/0.6, 0.0]) isi1 = np.array([0.6, 0.6, 0.4]) isi2 = np.array([0.4, 0.6, 0.6]) expected_y1 = (s1[:-1]*isi2+s2[:-1]*isi1) / (0.5*(isi1+isi2)**2) expected_y2 = (s1[1:]*isi2+s2[1:]*isi1) / (0.5*(isi1+isi2)**2) expected_times = np.array([0.0, 0.4, 0.6, 1.0]) expected_spike_val = sum((expected_times[1:] - expected_times[:-1]) * (expected_y1+expected_y2)/2) expected_spike_val /= (expected_times[-1]-expected_times[0]) assert_almost_equal(d, expected_spike_val, decimal=15) prof = spk.spike_profile(st1, st2) assert_equal(d, prof.avrg()) assert_array_almost_equal(prof.x, [0.0, 0.4, 0.6, 1.0], decimal=15) assert_array_almost_equal(prof.y1, expected_y1, decimal=15) assert_array_almost_equal(prof.y2, expected_y2, decimal=15)
def test_regression_spiky(): # standard example st1 = SpikeTrain(np.arange(100, 1201, 100), 1300) st2 = SpikeTrain(np.arange(100, 1201, 110), 1300) isi_dist = spk.isi_distance(st1, st2) assert_almost_equal(isi_dist, 9.0909090909090939e-02, decimal=15) isi_profile = spk.isi_profile(st1, st2) assert_equal(isi_profile.y, 0.1 / 1.1 * np.ones_like(isi_profile.y)) spike_dist = spk.spike_distance(st1, st2) assert_equal(spike_dist, 0.211058782487353908) spike_sync = spk.spike_sync(st1, st2) assert_equal(spike_sync, 8.6956521739130432e-01) # multivariate check spike_trains = spk.load_spike_trains_from_txt( os.path.join(TEST_PATH, "PySpike_testdata.txt"), (0.0, 4000.0)) isi_dist = spk.isi_distance_multi(spike_trains) # get the full precision from SPIKY assert_almost_equal(isi_dist, 0.17051816816999129656, decimal=15) spike_profile = spk.spike_profile_multi(spike_trains) assert_equal(len(spike_profile.y1) + len(spike_profile.y2), 1252) spike_dist = spk.spike_distance_multi(spike_trains) # get the full precision from SPIKY assert_almost_equal(spike_dist, 0.25188056475463755, decimal=15) spike_sync = spk.spike_sync_multi(spike_trains) # get the full precision from SPIKY assert_equal(spike_sync, 0.7183531505298066) # Eero's edge correction example st1 = SpikeTrain([0.5, 1.5, 2.5], 6.0) st2 = SpikeTrain([3.5, 4.5, 5.5], 6.0) f = spk.spike_profile(st1, st2) expected_times = np.array([0.0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.0]) y_all = np.array([ 0.271604938271605, 0.271604938271605, 0.271604938271605, 0.617283950617284, 0.617283950617284, 0.444444444444444, 0.285714285714286, 0.285714285714286, 0.444444444444444, 0.617283950617284, 0.617283950617284, 0.271604938271605, 0.271604938271605, 0.271604938271605 ]) expected_y1 = y_all[::2] expected_y2 = y_all[1::2] assert_equal(f.x, expected_times) assert_array_almost_equal(f.y1, expected_y1, decimal=14) assert_array_almost_equal(f.y2, expected_y2, decimal=14)
def spikey(train, song, condition): songset = np.unique(song) dist = [] for s, stim in enumerate(songset): subset = np.where(np.asarray(song) == stim)[0] trainsub = [train[x] for x in subset if train[x] is not np.nan] labels = [condition[x] for x in subset if train[x] is not np.nan] pairs = np.zeros((len(trainsub), len(trainsub))) for i in range(len(trainsub)): for j in range(len(trainsub)): pairs[i, j] = spk.spike_distance(trainsub[i], trainsub[j]) df = pd.DataFrame(pairs, columns=labels, index=labels) if trainsub: dist.append(compute_dist(df)) else: dist.append([ 0, 0, 0, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan ]) return dist
spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt", edges=(0, 4000)) t_loading = time.clock() print("Number of spike trains: %d" % len(spike_trains)) num_of_spikes = sum([len(spike_trains[i]) for i in range(len(spike_trains))]) print("Number of spikes: %d" % num_of_spikes) # calculate the multivariate spike distance f = spk.spike_profile(spike_trains) t_spike = time.clock() # print the average avrg = f.avrg() print("Spike distance from average: %.8f" % avrg) t_avrg = time.clock() # compute average distance directly, should give the same result as above spike_dist = spk.spike_distance(spike_trains) print("Spike distance directly: %.8f" % spike_dist) t_dist = time.clock() print("Loading: %9.1f ms" % time_diff_in_ms(t_start, t_loading)) print("Computing profile: %9.1f ms" % time_diff_in_ms(t_loading, t_spike)) print("Averaging: %9.1f ms" % time_diff_in_ms(t_spike, t_avrg)) print("Computing distance: %9.1f ms" % time_diff_in_ms(t_avrg, t_dist)) print("Total: %9.1f ms" % time_diff_in_ms(t_start, t_dist))
def test_spike(): # generate two spike trains: t1 = SpikeTrain([0.0, 2.0, 5.0, 8.0], 10.0) t2 = SpikeTrain([0.0, 1.0, 5.0, 9.0], 10.0) expected_times = np.array([0.0, 1.0, 2.0, 5.0, 8.0, 9.0, 10.0]) f = spk.spike_profile(t1, t2) assert_equal(f.x, expected_times) # from SPIKY: y_all = np.array([ 0.000000000000000000, 0.555555555555555580, 0.222222222222222210, 0.305555555555555580, 0.255102040816326536, 0.000000000000000000, 0.000000000000000000, 0.255102040816326536, 0.255102040816326536, 0.285714285714285698, 0.285714285714285698, 0.285714285714285698 ]) #assert_array_almost_equal(f.y1, y_all[::2]) assert_array_almost_equal(f.y2, y_all[1::2]) assert_almost_equal(f.avrg(), 0.186309523809523814, decimal=15) assert_equal(spk.spike_distance(t1, t2), f.avrg()) t1 = SpikeTrain([0.2, 0.4, 0.6, 0.7], 1.0) t2 = SpikeTrain([0.3, 0.45, 0.8, 0.9, 0.95], 1.0) # pen&paper calculation of the spike distance expected_times = [0.0, 0.2, 0.3, 0.4, 0.45, 0.6, 0.7, 0.8, 0.9, 0.95, 1.0] s1 = np.array([ 0.1, 0.1, (0.1 * 0.1 + 0.05 * 0.1) / 0.2, 0.05, (0.05 * 0.15 * 2) / 0.2, 0.15, 0.1, (0.1 * 0.1 + 0.1 * 0.2) / 0.3, (0.1 * 0.2 + 0.1 * 0.1) / 0.3, (0.1 * 0.05 + 0.1 * 0.25) / 0.3, 0.1 ]) s2 = np.array([ 0.1, (0.1 * 0.2 + 0.1 * 0.1) / 0.3, 0.1, (0.1 * 0.05 * 2) / .15, 0.05, (0.05 * 0.2 + 0.1 * 0.15) / 0.35, (0.05 * 0.1 + 0.1 * 0.25) / 0.35, 0.1, 0.1, 0.05, 0.05 ]) isi1 = np.array([0.2, 0.2, 0.2, 0.2, 0.2, 0.1, 0.3, 0.3, 0.3, 0.3]) isi2 = np.array([0.3, 0.3, 0.15, 0.15, 0.35, 0.35, 0.35, 0.1, 0.05, 0.05]) expected_y1 = (s1[:-1] * isi2 + s2[:-1] * isi1) / (0.5 * (isi1 + isi2)**2) expected_y2 = (s1[1:] * isi2 + s2[1:] * isi1) / (0.5 * (isi1 + isi2)**2) expected_times = np.array(expected_times) expected_y1 = np.array(expected_y1) expected_y2 = np.array(expected_y2) expected_spike_val = sum((expected_times[1:] - expected_times[:-1]) * (expected_y1 + expected_y2) / 2) expected_spike_val /= (expected_times[-1] - expected_times[0]) print("SPIKE value:", expected_spike_val) f = spk.spike_profile(t1, t2) assert_equal(f.x, expected_times) assert_array_almost_equal(f.y1, expected_y1, decimal=15) assert_array_almost_equal(f.y2, expected_y2, decimal=15) assert_almost_equal(f.avrg(), expected_spike_val, decimal=15) assert_almost_equal(spk.spike_distance(t1, t2), expected_spike_val, decimal=15) # check with some equal spike times t1 = SpikeTrain([0.2, 0.4, 0.6], [0.0, 1.0]) t2 = SpikeTrain([0.1, 0.4, 0.5, 0.6], [0.0, 1.0]) expected_times = [0.0, 0.1, 0.2, 0.4, 0.5, 0.6, 1.0] # due to the edge correction in the beginning, s1 and s2 are different # for left and right values s1_r = np.array( [0.1, (0.1 * 0.1 + 0.1 * 0.1) / 0.2, 0.1, 0.0, 0.0, 0.0, 0.0]) s1_l = np.array( [0.1, (0.1 * 0.1 + 0.1 * 0.1) / 0.2, 0.1, 0.0, 0.0, 0.0, 0.0]) # s2_r = np.array([0.1*0.1/0.3, 0.1*0.3/0.3, 0.1*0.2/0.3, # 0.0, 0.1, 0.0, 0.0]) # s2_l = np.array([0.1*0.1/0.3, 0.1*0.1/0.3, 0.1*0.2/0.3, 0.0, # 0.1, 0.0, 0.0]) # eero's edge correction: s2_r = np.array( [0.1, 0.1 * 0.3 / 0.3, 0.1 * 0.2 / 0.3, 0.0, 0.1, 0.0, 0.0]) s2_l = np.array( [0.1, 0.1 * 0.3 / 0.3, 0.1 * 0.2 / 0.3, 0.0, 0.1, 0.0, 0.0]) isi1 = np.array([0.2, 0.2, 0.2, 0.2, 0.2, 0.4]) isi2 = np.array([0.3, 0.3, 0.3, 0.1, 0.1, 0.4]) expected_y1 = (s1_r[:-1] * isi2 + s2_r[:-1] * isi1) / (0.5 * (isi1 + isi2)**2) expected_y2 = (s1_l[1:] * isi2 + s2_l[1:] * isi1) / (0.5 * (isi1 + isi2)**2) expected_times = np.array(expected_times) expected_y1 = np.array(expected_y1) expected_y2 = np.array(expected_y2) expected_spike_val = sum((expected_times[1:] - expected_times[:-1]) * (expected_y1 + expected_y2) / 2) expected_spike_val /= (expected_times[-1] - expected_times[0]) f = spk.spike_profile(t1, t2) assert_equal(f.x, expected_times) assert_array_almost_equal(f.y1, expected_y1, decimal=14) assert_array_almost_equal(f.y2, expected_y2, decimal=14) assert_almost_equal(f.avrg(), expected_spike_val, decimal=16) assert_almost_equal(spk.spike_distance(t1, t2), expected_spike_val, decimal=16)
def spikey(fp): events = glob.glob(os.path.join(fp,'*.pprox')) events.sort() #For new recordings: syll = pd.read_csv('../restoration_syllables.csv') #For old recordings: #syll = pd.read_csv('../syllables.csv') for eventfile in events: with open(eventfile) as fl: data = json.load(fl) song = [] condition = [] train = [] gapon = {} gapoff = {} spikes = [] for t in range(len(data['pprox'])): #For new recordings: if data['pprox'][t]['condition'] == 'continuous': song.append(data['pprox'][t]['stimulus']+'-1') song.append(data['pprox'][t]['stimulus']+'-2') condition.append(data['pprox'][t]['condition']+'1') condition.append(data['pprox'][t]['condition']+'2') spikes.append(data['pprox'][t]['event']) spikes.append(data['pprox'][t]['event']) else: songid = data['pprox'][t]['stimulus']+'-'+data['pprox'][t]['condition'][-1] song.append(data['pprox'][t]['stimulus']+'-'+data['pprox'][t]['condition'][-1]) condition.append(data['pprox'][t]['condition']) spikes.append(data['pprox'][t]['event']) if 'gap_on' in data['pprox'][t].keys(): gapon[songid] = data['pprox'][t]['gap_on'] gapoff[songid] = data['pprox'][t]['gap_off'] #For old recordings: #song.append(data['pprox'][t]['stimulus']) #condition.append(data['pprox'][t]['condition']) #spikes.append(data['pprox'][t]['event']) #if 'gap_on' in data['pprox'][t].keys(): #gapon[song[t]] = data['pprox'][t]['gap_on'][0]/40 #gapoff[song[t]] = data['pprox'][t]['gap_off'][0]/40 songset = np.unique(song) x = [] y = [] for s in song: x.append(gapon[s]) y.append(gapoff[s]) gapon = x gapoff = y for t in range(len(spikes)): #For new recordings: syllstart = syll['start'][syll['songid'] == song[t][:-2]][syll['start'] <= gapon[t]/1000+0.001][syll['end'] >= gapoff[t]/1000-0.001].values[0] * 1000 index = syll[syll['songid'] == song[t][:-2]][syll['start'] <= gapon[t]/1000+0.001][syll['end'] >= gapoff[t]/1000-0.001].index.values[0] + 1 #For old recordings: #syllstart = syll['start'][syll['songid'] == song[t]][syll['start'] <= gapon[t]/1000+0.001][syll['end'] >= gapoff[t]/1000-0.001].values[0] * 1000 #index = syll[syll['songid'] == song[t]][syll['start'] <= gapon[t]/1000+0.001][syll['end'] >= gapoff[t]/1000-0.001].index.values[0] + 1 nextsyllend = syll['end'].at[index] * 1000 spikes[t] = [spike for spike in spikes[t] if spike >= syllstart and spike <= nextsyllend] train.append(spk.SpikeTrain(spikes[t],[syllstart,nextsyllend])) for s,stim in enumerate(songset): pairs = np.zeros((len(train)//len(songset),len(train)//len(songset))) subset = np.where(np.asarray(song) == stim) trainsub = [train[x] for x in subset[0]] for i in range(len(trainsub)): for j in range(len(trainsub)): pairs[i,j] = spk.spike_distance(trainsub[i], trainsub[j]) labels = [condition[x] for x in range(len(condition)) if x in subset[0]] df = pd.DataFrame(pairs, columns = labels, index = labels) df.to_csv(os.path.splitext(eventfile)[0]+'_'+stim+'.csv')
def test_spike(): # generate two spike trains: t1 = SpikeTrain([0.0, 2.0, 5.0, 8.0], 10.0) t2 = SpikeTrain([0.0, 1.0, 5.0, 9.0], 10.0) expected_times = np.array([0.0, 1.0, 2.0, 5.0, 8.0, 9.0, 10.0]) f = spk.spike_profile(t1, t2) assert_equal(f.x, expected_times) assert_almost_equal(f.avrg(), 1.6624149659863946e-01, decimal=15) assert_almost_equal(f.y2[-1], 0.1394558, decimal=6) t1 = SpikeTrain([0.2, 0.4, 0.6, 0.7], 1.0) t2 = SpikeTrain([0.3, 0.45, 0.8, 0.9, 0.95], 1.0) # pen&paper calculation of the spike distance expected_times = [0.0, 0.2, 0.3, 0.4, 0.45, 0.6, 0.7, 0.8, 0.9, 0.95, 1.0] s1 = np.array([0.1, 0.1, (0.1*0.1+0.05*0.1)/0.2, 0.05, (0.05*0.15 * 2)/0.2, 0.15, 0.1, (0.1*0.1+0.1*0.2)/0.3, (0.1*0.2+0.1*0.1)/0.3, (0.1*0.05+0.1*0.25)/0.3, 0.1]) s2 = np.array([0.1, (0.1*0.2+0.1*0.1)/0.3, 0.1, (0.1*0.05 * 2)/.15, 0.05, (0.05*0.2+0.1*0.15)/0.35, (0.05*0.1+0.1*0.25)/0.35, 0.1, 0.1, 0.05, 0.05]) isi1 = np.array([0.2, 0.2, 0.2, 0.2, 0.2, 0.1, 0.3, 0.3, 0.3, 0.3]) isi2 = np.array([0.3, 0.3, 0.15, 0.15, 0.35, 0.35, 0.35, 0.1, 0.05, 0.05]) expected_y1 = (s1[:-1]*isi2+s2[:-1]*isi1) / (0.5*(isi1+isi2)**2) expected_y2 = (s1[1:]*isi2+s2[1:]*isi1) / (0.5*(isi1+isi2)**2) expected_times = np.array(expected_times) expected_y1 = np.array(expected_y1) expected_y2 = np.array(expected_y2) expected_spike_val = sum((expected_times[1:] - expected_times[:-1]) * (expected_y1+expected_y2)/2) expected_spike_val /= (expected_times[-1]-expected_times[0]) f = spk.spike_profile(t1, t2) assert_equal(f.x, expected_times) assert_array_almost_equal(f.y1, expected_y1, decimal=15) assert_array_almost_equal(f.y2, expected_y2, decimal=15) assert_almost_equal(f.avrg(), expected_spike_val, decimal=15) assert_almost_equal(spk.spike_distance(t1, t2), expected_spike_val, decimal=15) # check with some equal spike times t1 = SpikeTrain([0.2, 0.4, 0.6], [0.0, 1.0]) t2 = SpikeTrain([0.1, 0.4, 0.5, 0.6], [0.0, 1.0]) expected_times = [0.0, 0.1, 0.2, 0.4, 0.5, 0.6, 1.0] # due to the edge correction in the beginning, s1 and s2 are different # for left and right values s1_r = np.array([0.1, (0.1*0.1+0.1*0.1)/0.2, 0.1, 0.0, 0.0, 0.0, 0.0]) s1_l = np.array([0.1, (0.1*0.1+0.1*0.1)/0.2, 0.1, 0.0, 0.0, 0.0, 0.0]) s2_r = np.array([0.1*0.1/0.3, 0.1*0.3/0.3, 0.1*0.2/0.3, 0.0, 0.1, 0.0, 0.0]) s2_l = np.array([0.1*0.1/0.3, 0.1*0.1/0.3, 0.1*0.2/0.3, 0.0, 0.1, 0.0, 0.0]) isi1 = np.array([0.2, 0.2, 0.2, 0.2, 0.2, 0.4]) isi2 = np.array([0.3, 0.3, 0.3, 0.1, 0.1, 0.4]) expected_y1 = (s1_r[:-1]*isi2+s2_r[:-1]*isi1) / (0.5*(isi1+isi2)**2) expected_y2 = (s1_l[1:]*isi2+s2_l[1:]*isi1) / (0.5*(isi1+isi2)**2) expected_times = np.array(expected_times) expected_y1 = np.array(expected_y1) expected_y2 = np.array(expected_y2) expected_spike_val = sum((expected_times[1:] - expected_times[:-1]) * (expected_y1+expected_y2)/2) expected_spike_val /= (expected_times[-1]-expected_times[0]) f = spk.spike_profile(t1, t2) assert_equal(f.x, expected_times) assert_array_almost_equal(f.y1, expected_y1, decimal=14) assert_array_almost_equal(f.y2, expected_y2, decimal=14) assert_almost_equal(f.avrg(), expected_spike_val, decimal=16) assert_almost_equal(spk.spike_distance(t1, t2), expected_spike_val, decimal=16)
edges=(0, 4000)) t_loading = time.clock() print("Number of spike trains: %d" % len(spike_trains)) num_of_spikes = sum([len(spike_trains[i]) for i in range(len(spike_trains))]) print("Number of spikes: %d" % num_of_spikes) # calculate the multivariate spike distance f = spk.spike_profile(spike_trains) t_spike = time.clock() # print the average avrg = f.avrg() print("Spike distance from average: %.8f" % avrg) t_avrg = time.clock() # compute average distance directly, should give the same result as above spike_dist = spk.spike_distance(spike_trains) print("Spike distance directly: %.8f" % spike_dist) t_dist = time.clock() print("Loading: %9.1f ms" % time_diff_in_ms(t_start, t_loading)) print("Computing profile: %9.1f ms" % time_diff_in_ms(t_loading, t_spike)) print("Averaging: %9.1f ms" % time_diff_in_ms(t_spike, t_avrg)) print("Computing distance: %9.1f ms" % time_diff_in_ms(t_avrg, t_dist)) print("Total: %9.1f ms" % time_diff_in_ms(t_start, t_dist))
run(runTime*ms) #code below calculates and stores the pyspike metrics firingValuesWithUnits = Sp1.spike_trains().values() firingValues = [] for i in range(len(firingValuesWithUnits)): firingValues.append(array(firingValuesWithUnits[i])) fV = open('fv.txt','w') for item in firingValues: item = (" ".join(map(str,item))) fV.write("%s\n" % item) fV.close() spikeTrains = psp.load_spike_trains_from_txt("fv.txt",edges=(0,runTime/1000.0)) qvalues.iloc[currentLine,0] = tc qvalues.iloc[currentLine,1] = delay qvalues.iloc[currentLine,2] = psyn qvalues.iloc[currentLine,3] = synw qvalues.iloc[currentLine,4] = psp.spike_distance(spikeTrains) qvalues.iloc[currentLine,5] = psp.isi_distance(spikeTrains) qvalues.iloc[currentLine,6] = psp.spike_sync(spikeTrains) currentLine += 1 del G1 del S1 del Sp1 del firingValuesWithUnits del firingValues del spikeTrains qvalues.to_excel('qvalues.xlsx', sheet_name='Sheet1')