def make_spk(rate, duration_ms, n=1, dt=1 * ms, uniform_freq=True):
# Set uniform_freq to False to obtain trains with mean Rate instead of exact Rate
if type(rate) == b2.units.fundamentalunits.Quantity:
comp_rate = rate / Hz
else:
comp_rate = rate
trains = brian_poisson(rate, duration_ms, n=n, dt=dt)
if n > 1:
if uniform_freq:
trains = np.array(trains)
actual_rates = [tr.size for tr in trains]
rate_match = np.equal(actual_rates, comp_rate)
trains = trains[rate_match]
real_N = trains.size
while real_N < n:
new_trains = np.array(
brian_poisson(rate, duration_ms, n=n, dt=dt))
new_rates = [tr.size for tr in new_trains]
rate_match = np.equal(new_rates, comp_rate)
new_trains = new_trains[rate_match]
trains = np.append(trains, new_trains)
real_N = trains.size
tr_spk = [spk.SpikeTrain(train, duration_ms) for train in trains[0:n]]
else:
rate_match = trains.size == comp_rate
while not (rate_match):
trains = brian_poisson(rate, duration_ms, n=n, dt=dt)
rate_match = trains.size == comp_rate
tr_spk = spk.SpikeTrain(trains, duration_ms)
return tr_spk
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 sync_test():
import pyspike
spkt_train = []
empty_train = [[] for i in range(801)]
for i in range(len(empty_train)):
if i < 200:
empty_train[i] = random.sample(xrange(0, 1500), 0)
spkt_train.append(pyspike.SpikeTrain(empty_train[i], timeRange))
elif (i >= 200 and i < 400):
empty_train[i] = random.sample(xrange(0, 1500), 1)
spkt_train.append(pyspike.SpikeTrain(empty_train[i], timeRange))
elif (i >= 400 and i < 600):
empty_train[i] = random.sample(xrange(0, 1500), 5)
spkt_train.append(pyspike.SpikeTrain(empty_train[i], timeRange))
elif i >= 600:
empty_train[i] = random.sample(xrange(0, 1500), 50)
spkt_train.append(pyspike.SpikeTrain(empty_train[i], timeRange))
spike_sync = pyspike.spike_sync_matrix(spkt_train)
for i in range(len(spkt_train)):
if i < 400:
for v in range(400):
empty_array[i][v] = 1.0
getmat['2'] = spike_sync - empty_array
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 distance_isi(spike_train_a, spike_train_b, interval):
"""
ISI-distance (Kreutz) using pyspike
"""
spike_train_1 = pyspike.SpikeTrain(spike_train_a, interval)
spike_train_2 = pyspike.SpikeTrain(spike_train_b, interval)
return pyspike.isi_distance(spike_train_1, spike_train_2, interval)
def Synchro(spikes1, spikes2):
synchs = []
for i in range(len(spikes1)):
sp1 = pyspike.SpikeTrain(np.where(spikes1[i] > 0)[0], len(spikes1[i]))
sp2 = pyspike.SpikeTrain(np.where(spikes2[i] > 0)[0], len(spikes2[i]))
synchs.append(pyspike.spike_sync(sp1, sp2))
return np.array(synchs)
def make_spk(rate, duration_ms, n=1, dt=1 * ms, exact_freq=True):
"""
Creates a stimulus with n neurons of a desired frequency.
This function returns each neuron as a PySpike object which can be used
for evaluating distance between neurons, and uses brian internally for sample generation.
:param rate: Desired rate of fire for neurons in the sample
:param duration_ms: Length of a "trial" in milliseconds
:param n: Number of neurons in the sample
:param dt: The shortest time interval between spikes in the sample
:param exact_freq: Whether frequency should be Exactly "rate" for each neuron, or "rate" on average.
:return:
"""
# Making sure the variable used for rate comparison is of the correct type
if type(rate) == b2.units.fundamentalunits.Quantity:
comp_rate = rate / Hz
else:
comp_rate = rate
# Generating the spike-trains using brian
trains = brian_poisson(rate, duration_ms, n=n, dt=dt)
# Handling single or multiple train generation as well as exact or average frequency
if n > 1:
if exact_freq:
trains = np.array(trains)
actual_rates = [tr.size for tr in trains]
# ToDO: Handle the actual rates considering the stimulus_duration of the stimulus
rate_match = np.equal(actual_rates, comp_rate)
trains = trains[rate_match]
real_N = trains.size
while real_N < n:
new_trains = np.array(
brian_poisson(rate, duration_ms, n=n, dt=dt))
new_rates = [tr.size for tr in new_trains]
rate_match = np.equal(new_rates, comp_rate)
new_trains = new_trains[rate_match]
trains = np.append(trains, new_trains)
real_N = trains.size
tr_spk = [spk.SpikeTrain(train, duration_ms) for train in trains[0:n]]
else:
rate_match = trains.size == comp_rate
while not (rate_match):
trains = brian_poisson(rate, duration_ms, n=n, dt=dt)
rate_match = trains.size == comp_rate
tr_spk = spk.SpikeTrain(trains, duration_ms)
return tr_spk
def check_single_spike_train_set(index):
""" Debuging function """
np.set_printoptions(precision=15)
spike_file = "regression_random_spikes.mat"
spikes_name = "spikes"
result_name = "Distances"
result_file = "regression_random_results_cSPIKY.mat"
spike_train_sets = loadmat(spike_file)[spikes_name][0]
results_cSPIKY = loadmat(result_file)[result_name]
spike_train_data = spike_train_sets[index]
spike_trains = []
N = 0
for spikes in spike_train_data[0]:
N += len(spikes.flatten())
print("Spikes:", len(spikes.flatten()))
spikes_array = spikes.flatten()
if len(spikes_array > 0) and (spikes_array[-1] > 100.0):
spikes_array[-1] = 100.0
spike_trains.append(spk.SpikeTrain(spikes_array, 100.0))
print(spike_trains[-1].spikes)
print(N)
print(spk.spike_sync_multi(spike_trains))
print(spk.spike_sync_profile_multi(spike_trains).integral())
def cluster_spike_trains(spike_trains, tstart, tend, interval=None, eps=0.01, measure='SPIKE_distance'):
"""Cluster a list of spike trains by SPIKE distance measure.
tstart and tend are the start and end time of recording (used for creating SpikeTrain object from PySpike.
interval is (t0, t1) the time interval during which to compute
SPIKE_distance. If None, (tstart, tend) is used.
eps: epsilon parameter for DBSCAN algorithm. This is the maximum
distance between two samples for them to be considered in the same
neighborhood.
All spike trains should be nonempty.
Return (cluster_info, spike_distance_matrix)
where
cluster_info: the result of applying DBSCAN. This gives
spike_distance_matrix: an NxN distance matrix for N spike trains.
"""
if interval is None:
interval = (tstart, tend)
st_list = [spk.SpikeTrain(st, (tstart, tend)) for st in spike_trains]
print('Interval:', interval)
print('tstart: {} tend: {}'.format(tstart, tend))
print('Number of spike trains:', len(st_list))
dist = spk.spike_distance_matrix(st_list, interval=interval)
clus = skc.DBSCAN(eps=eps, metric='precomputed').fit(dist)
return clus, dist
def test_merge_empty_spike_trains():
# first load the data
spike_trains = spk.load_spike_trains_from_txt(TEST_DATA, edges=(0, 4000))
# take two non-empty trains, and one empty one
empty = spk.SpikeTrain([],[spike_trains[0].t_start,spike_trains[0].t_end])
merged_spikes = spk.merge_spike_trains([spike_trains[0], empty, spike_trains[1]])
# test if result is sorted
assert((merged_spikes.spikes == np.sort(merged_spikes.spikes)).all())
def shift_main(src):
spiketimes = src.spikes[:, np.newaxis]
num_shifts = len(shifts)
num_fracshift = len(frac_shifts)
num_spikes = spiketimes.size
# Finding edges
left_edge = np.where(spiketimes < shifts)
right_edge = np.where((spiketimes + shifts) > duration)
# Create the shift matrices
shifts_bottom = np.tile(shifts, reps=(num_spikes, n, num_fracshift, 1))
shifts_top = shifts_bottom.copy()
shifts_bottom[left_edge[0], :, :, left_edge[1]] = \
spiketimes[left_edge[0]][:, np.newaxis]
shifts_top[right_edge[0], :, :, right_edge[1]] = \
((duration) - spiketimes[right_edge[0]][:, np.newaxis])
shifts_range = shifts_top + shifts_bottom
# boolean matrix for fractional shifting - MAY REQUIRE CHANGING AFTER FRAC_FIRE IS INTEGRATED
bool_frac_mat = np.random.rand(num_spikes, n, num_fracshift,
num_shifts)
bool_frac_mat = bool_frac_mat <= frac_shifts[:, np.newaxis]
# Draw!
shiftvals = np.random.rand(num_spikes, n, num_fracshift, num_shifts)
# Fix edges!
shiftvals = (
(shiftvals * shifts_range) - shifts_bottom) * bool_frac_mat
shiftvals.round(out=shiftvals)
# Shift!
shifted = shiftvals + spiketimes[:, np.newaxis, np.newaxis]
shifted.sort()
# Find uniques!
uniques = [
np.unique(shifted[:, i, j, k]) for i in range(n)
for j in range(num_fracshift) for k in range(num_shifts)
]
# pyspike!
shifted_spk = [
spk.SpikeTrain(shifted_times, duration)
for shifted_times in uniques
]
return shifted_spk
def _similarity(self, v1, v2, method='isi', **kwargs):
assert v1.shape == v2.shape
assert v1.ndim == 1
if method == 'isi':
thresh = kwargs.pop('thresh', 10)
spikes1 = np.diff((v1 > thresh).astype('int'))
spikes2 = np.diff((v2 > thresh).astype('int'))
spike_times_1 = np.where(spikes1 > 0)[0]
spike_times_2 = np.where(spikes2 > 0)[0]
# spike_train_1 = pyspike.SpikeTrain(spike_times_1, 5500, 14500)
# spike_train_2 = pyspike.SpikeTrain(spike_times_2, 5500, 14500)
spike_train_1 = pyspike.SpikeTrain(spike_times_1, 9000 *
.02) # TODO: need # timebins
spike_train_2 = pyspike.SpikeTrain(spike_times_2, 9000 * .02)
return np.abs(pyspike.isi_distance(spike_train_1, spike_train_2))
elif method == 'efel':
trace1 = self._make_efel_trace(v1)
trace2 = self._make_efel_trace(v2)
efel1, efel2 = efel.getFeatureValues([trace1, trace2],
['mean_frequency'])
return np.abs(efel1['mean_frequency'] - efel2['mean_frequency'])[0]
try:
y = np.abs(
[efel1[feat] - efel2[feat] for feat in EFEL_FEATURES])
except:
import matplotlib.pyplot as plt
plt.plot(v1)
plt.plot(v2)
plt.show()
return y
else:
raise ValueError("unknown similarity metric")
def make_spike_trains(spike_times, time_range):
spike_trains = [[] for i in range(len(spike_times))]
for index, times in enumerate(spike_times):
spike_times[index] = [
time for time in times
if (time > time_range[0] and time < time_range[1])
]
spike_trains[index] = spk.SpikeTrain(np.array(spike_times[index]),
edges=time_range)
return spike_trains
def calculate_spike_synchrony_pyspike(ts, gids, interval=None):
if interval is None:
tmin = np.min(ts)
tmax = np.max(ts)
interval = [tmin, tmax]
s = spike_trains_list_of_list(ts, gids)
spike_trains = []
for i in range(len(s)):
spike_trains.append(spk.SpikeTrain(s[i], interval, is_sorted=False))
spk_sync = spk.spike_sync(spike_trains, interval=interval, max_tau=0.1)
return spk_sync
def test_regression_random():
spike_file = "test/numeric/regression_random_spikes.mat"
spikes_name = "spikes"
result_name = "Distances"
result_file = "test/numeric/regression_random_results_cSPIKY.mat"
spike_train_sets = loadmat(spike_file)[spikes_name][0]
results_cSPIKY = loadmat(result_file)[result_name]
for i, spike_train_data in enumerate(spike_train_sets):
spike_trains = []
for spikes in spike_train_data[0]:
spike_trains.append(spk.SpikeTrain(spikes.flatten(), 100.0))
isi = spk.isi_distance_multi(spike_trains)
isi_prof = spk.isi_profile_multi(spike_trains).avrg()
spike = spk.spike_distance_multi(spike_trains)
spike_prof = spk.spike_profile_multi(spike_trains).avrg()
spike_sync = spk.spike_sync_multi(spike_trains)
spike_sync_prof = spk.spike_sync_profile_multi(spike_trains).avrg()
assert_almost_equal(isi,
results_cSPIKY[i][0],
decimal=14,
err_msg="Index: %d, ISI" % i)
assert_almost_equal(isi_prof,
results_cSPIKY[i][0],
decimal=14,
err_msg="Index: %d, ISI" % i)
assert_almost_equal(spike,
results_cSPIKY[i][1],
decimal=14,
err_msg="Index: %d, SPIKE" % i)
assert_almost_equal(spike_prof,
results_cSPIKY[i][1],
decimal=14,
err_msg="Index: %d, SPIKE" % i)
assert_almost_equal(spike_sync,
spike_sync_prof,
decimal=14,
err_msg="Index: %d, SPIKE-Sync" % i)
def check_regression_dataset(spike_file="benchmark.mat",
spikes_name="spikes",
result_file="results_cSPIKY.mat",
result_name="Distances"):
""" Debuging function """
np.set_printoptions(precision=15)
spike_train_sets = loadmat(spike_file)[spikes_name][0]
results_cSPIKY = loadmat(result_file)[result_name]
err_max = 0.0
err_max_ind = -1
err_count = 0
for i, spike_train_data in enumerate(spike_train_sets):
spike_trains = []
for spikes in spike_train_data[0]:
spike_trains.append(spk.SpikeTrain(spikes.flatten(), 100.0))
isi = spk.isi_distance_multi(spike_trains)
spike = spk.spike_distance_multi(spike_trains)
# spike_sync = spk.spike_sync_multi(spike_trains)
if abs(isi - results_cSPIKY[i][0]) > 1E-14:
print("Error in ISI:", i, isi, results_cSPIKY[i][0])
print("Spike trains:")
for st in spike_trains:
print(st.spikes)
err = abs(spike - results_cSPIKY[i][1])
if err > 1E-14:
err_count += 1
if err > err_max:
err_max = err
err_max_ind = i
print("Total Errors:", err_count)
if err_max_ind > -1:
print("Max SPIKE distance error:", err_max, "at index:", err_max_ind)
spike_train_data = spike_train_sets[err_max_ind]
for spikes in spike_train_data[0]:
print(spikes.flatten())
def get_data():
print 'Starting analysis of spike times per cell: ' + str(label_network)
sync_data = [[[[] for i in range(2)] for x in range(len(gids))]
for p in range(len(stats))]
spktsRange = [
spkt for spkt in spkts if timeRange[0] <= spkt <= timeRange[1]
]
for i, stat in enumerate(stats):
for ii, subset in enumerate(gids):
spkmat = [
pyspike.SpikeTrain([
spkt for spkind, spkt in zip(spkinds, spkts)
if (spkind == gid and spkt in spktsRange)
], timeRange) for gid in set(subset)
]
if stat == 'spike_sync_profile':
print str(stat) + ", subset: " + str(
ii) + ", number of trains: " + str(len(spkmat))
syncMat1 = pyspike.spike_sync_profile(spkmat)
x, y = syncMat1.get_plottable_data()
sync_data[i][ii][0] = x
sync_data[i][ii][1] = y
elif stat == 'spike_profile':
print str(stat) + ", subset: " + str(
ii) + ", number of trains: " + str(len(spkmat))
syncMat2 = pyspike.spike_profile(spkmat)
x, y = syncMat2.get_plottable_data()
sync_data[i][ii][0] = x
sync_data[i][ii][1] = y
elif stat == 'isi_profile':
print str(stat) + ", subset: " + str(
ii) + ", number of trains: " + str(len(spkmat))
syncMat3 = pyspike.isi_profile(spkmat)
x, y = syncMat3.get_plottable_data()
sync_data[i][ii][0] = x
sync_data[i][ii][1] = y
def check_single_spike_train_set(index):
""" Debuging function """
np.set_printoptions(precision=15)
spike_file = "regression_random_spikes.mat"
spikes_name = "spikes"
result_name = "Distances"
result_file = "regression_random_results_cSPIKY.mat"
spike_train_sets = loadmat(spike_file)[spikes_name][0]
results_cSPIKY = loadmat(result_file)[result_name]
spike_train_data = spike_train_sets[index]
spike_trains = []
for spikes in spike_train_data[0]:
print("Spikes:", spikes.flatten())
spike_trains.append(spk.SpikeTrain(spikes.flatten(), 100.0))
print(spk.spike_distance_multi(spike_trains))
print(results_cSPIKY[index][1])
print(spike_trains[1].spikes)
g = arg
if opt in ('-v'):
v = arg
for s in range(1):
try:
d = np.load('save/brunel_inp={}_g={}_seed_{}.npy'.format(inp, g,
s)).item()
# synchronicity
sp = d['sp']
spike_list = []
for train in sp:
spike_list.append(
spk.SpikeTrain(list(sp[train]), (0, 50), is_sorted=False))
sync_dist = spk.spike_sync_matrix(spike_list,
indices=None,
interval=(1, 20))
spike_dist = spk.spike_distance_matrix(spike_list,
indices=None,
interval=(1, 20))
for i in range(sync_dist.shape[0]):
sync_dist[i, i] = 1
utils.Weight2txt(
1 - sync_dist,
'txt/brunel_inp={}_g={}_seed_{}_sync.txt'.format(inp, g, s))
utils.Weight2txt(
spike_dist,
'txt/brunel_inp={}_g={}_seed_{}_dist.txt'.format(inp, g, s))
def rate_select(path):
with open(path, 'r') as fp:
px = json.load(fp)
#syll = pd.read_csv('../restoration_syllables.csv')
song = []
condition = []
rate = []
gapon = {}
#gapoff = {}
spikes = []
for t in range(len(px['pprox'])):
#For new recordings:
if px['pprox'][t]['condition'] == 'continuous':
song.append(px['pprox'][t]['stimulus'] + '-1')
song.append(px['pprox'][t]['stimulus'] + '-2')
condition.append(px['pprox'][t]['condition'] + '1')
condition.append(px['pprox'][t]['condition'] + '2')
spikes.append(px['pprox'][t]['event'])
spikes.append(px['pprox'][t]['event'])
else:
songid = px['pprox'][t]['stimulus'] + '-' + px['pprox'][t][
'condition'][-1]
song.append(px['pprox'][t]['stimulus'] + '-' +
px['pprox'][t]['condition'][-1])
condition.append(px['pprox'][t]['condition'])
spikes.append(px['pprox'][t]['event'])
if 'gap_on' in px['pprox'][t].keys():
gapon[songid] = px['pprox'][t]['gap_on']
#gapoff[songid] = px['pprox'][t]['gap_off']
x = []
#y = []
for s in song:
x.append(gapon[s])
#y.append(gapoff[s])
gapon = x
#gapoff = y
lag = []
train = []
gaps = difference_psth(song, condition, spikes, gapon)
songset = np.unique(song)
for t in range(len(spikes)):
windowstart = gaps[np.where(songset == song[t])[0][0]][0]
windowstop = gaps[np.where(songset == song[t])[0][0]][1]
interval = (windowstop / 1000) - (windowstart / 1000)
if windowstart != 0:
numspikes = len([
spike for spike in spikes[t]
if spike >= windowstart and spike <= windowstop
])
rate.append(numspikes / interval)
lag.append(windowstart - gapon[t])
train.append(
spk.SpikeTrain([
spike for spike in spikes[t]
if spike >= windowstart and spike <= windowstop
], [windowstart, windowstop]))
else:
rate.append(np.nan)
lag.append(np.nan)
train.append(np.nan)
ziplist = list(zip(song, condition, rate, lag))
df = pd.DataFrame(ziplist, columns=["Song", "Condition", "Rate", "Lag"])
avgrate = df.groupby(['Song', 'Condition']).mean()
avgrate = [(avgrate.iloc[x].name + (avgrate.iloc[x].values[0], ))
for x in range(len(avgrate))]
sdrate = df.groupby(['Song', 'Condition']).std().values
lag = df.groupby(['Song', 'Condition']).mean().values
ri = df[(df['Condition'] == 'continuous1') |
(df['Condition'] == 'continuous2')].groupby(['Song',
'Condition']).mean()
count = 16
selectivity = (1 - ((np.sum(ri / count))**2) / (np.sum(
(ri**2) / count))) / (1 - (1 / count))
selectivity = [selectivity] * len(avgrate)
bird = [px['bird']] * len(avgrate)
recording = [px['recording']] * len(avgrate)
channel = [px['channel']] * len(avgrate)
cluster = [px['cluster']] * len(avgrate)
k = 5
window = [gap for gap in gaps for i in range(k)]
confusion = spikey(train, song, condition)
confusion = [dist for dist in confusion for i in range(k)]
records = list(
zip(bird, recording, channel, cluster, avgrate, sdrate, selectivity,
lag, window, confusion))
return [(a, b, c, d, e, f, g, h[0], i.values[0], j[1], k, l, m, n, o, p, q,
r, s, t, u, v, w, x, y) for a, b, c, d, (e, f, g), h, i, j, (
k, l), [m, n, o, p, q, r, s, t, u, v, w, x, y] in records]
import pyspike as spk
import matplotlib.pyplot as plt
a = np.random.rand(10) * 10
b = spk.SpikeTrain(a, [0, 10], is_sorted=False)
print b.spikes
spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt",
edges=(0, 4000))
# compute the two spike trains and multivariate ISI profile
f = spk.isi_profile(spike_trains[0], spike_trains[1])
f = spk.isi_profile(spike_trains)
# t = [900, 1100, 2000, 3100]
# print("ISI value at t =", t, ":", f(t))
# print("Average ISI distance:", f.avrg())
# compute the two spike trains and multivariate SPIKE profile
f = spk.spike_profile(spike_trains[0], spike_trains[1])
f = spk.spike_profile(spike_trains)
# t = [900, 1100, 2000, 3100]
# print("Multivariate SPIKE value at t =", t, ":", f(t))
# print("Average multivariate SPIKE distance:", f.avrg())
# plot the spike times
for (i, spike_train) in enumerate(spike_trains):
plt.scatter(spike_train, i * np.ones_like(spike_train), marker='|')
# print np.asarray(spike_train)
def Synchronization_analysis(sim_duration,specify_targets,no_of_groups,exp_specify,spike_plot_parameters,general_plot_parameters):
cell_no_array=[]
for exp_id in range(0,len(exp_specify[0]) ):
if exp_specify[1][1]==True:
for cell_group in range(0,no_of_groups):
cell_group_positions=np.loadtxt('simulations/%s/Golgi_pop%d.txt'%(exp_specify[0][exp_id],cell_group))
dim_array=np.shape(cell_group_positions)
cell_no_array.append(dim_array[0])
else:
for cell_group in range(0,no_of_groups):
cell_group_positions=np.loadtxt('simulations/%s/sim0/Golgi_pop%d.txt'%(exp_specify[0][exp_id],cell_group))
dim_array=np.shape(cell_group_positions)
cell_no_array.append(dim_array[0])
n_trials=exp_specify[2]
lines = []
lines_sep=[]
experiment_seed=random.sample(range(0,15000),1)[0]
for exp_id in range(0,len(exp_specify[0])):
#get target ids
experiment_parameters=[]
experiment_parameters.append(exp_specify[0][exp_id])
experiment_parameters.append(exp_specify[1])
experiment_parameters.append(exp_specify[2])
target_cell_array=get_cell_ids_for_sync_analysis(specify_targets,no_of_groups,experiment_parameters,experiment_seed)
test_array=target_cell_array
if exp_id==0:
if "save sync plot to a separate file" in spike_plot_parameters:
fig_sync, ax_sync=plt.subplots(figsize=(2,1.5),ncols=1,nrows=1)
if spike_plot_parameters[0]=="2D raster plots":
trial_indicator_target=False
if n_trials >1:
target_cell_array_target_trial=target_cell_array[spike_plot_parameters[1]]
no_of_rasters=0
if target_cell_array_target_trial != []:
test_non_empty_target_array=True
trial_indicator_target=True
no_of_rasters=len(target_cell_array_target_trial)
rows=1+no_of_rasters
columns=1
fig_stack, ax_stack = plt.subplots(figsize=(4,rows+1),ncols=columns,nrows=rows, sharex=True)
ax_stack=ax_stack.ravel()
else:
no_of_rasters=0
if target_cell_array != []:
trial_indicator=True
no_of_rasters=len(target_cell_array)
rows=1+no_of_rasters
columns=1
fig_stack, ax_stack = plt.subplots(figsize=(4,rows),ncols=columns,nrows=rows, sharex=True)
ax_stack=ax_stack.ravel()
if "save all trials to separate files" in spike_plot_parameters:
raster_fig_array=[]
raster_ax_array=[]
pop_no_array=[]
trial_indicator=False
if n_trials >1:
non_empty_trial_indices=[]
for trial in range(0,n_trials):
if target_cell_array[trial] !=[]:
non_empty_trial_indices.append(trial)
test_indices=non_empty_trial_indices
for trial in range(0,len(non_empty_trial_indices)):
target_trial=target_cell_array[non_empty_trial_indices[trial]]
columns=1
rows=len(target_trial)
pop_no_array.append(rows)
plot_rows=rows+1
fig, ax = plt.subplots(figsize=(4,plot_rows),ncols=columns,nrows=rows, sharex=True)
if len(target_trial) >1 :
ax=ax.ravel()
raster_fig_array.append(fig)
raster_ax_array.append(ax)
else:
no_of_rasters=0
if target_cell_array != []:
trial_indicator=True
no_of_rasters=len(target_cell_array)
rows=no_of_rasters
pop_no_array.append(rows)
columns=1
plot_rows=rows+1
fig_stack_one_trial, ax_stack_one_trial= plt.subplots(figsize=(4,plot_rows),ncols=columns,nrows=rows, sharex=True)
if no_of_rasters > 1:
ax_stack_one_trial=ax_stack.ravel()
if "save all trials to one separate file" in spike_plot_parameters:
pop_no_array=[]
if n_trials >1:
non_empty_trial_indices=[]
for trial in range(0,n_trials):
if target_cell_array[trial] !=[]:
non_empty_trial_indices.append(trial)
total_no_of_rows=0
for trial in range(0,len(non_empty_trial_indices)):
target_trial=target_cell_array[non_empty_trial_indices[trial]]
rows=len(target_trial)
pop_no_array.append(rows)
total_no_of_rows=total_no_of_rows + rows
fig_all_trials, ax_all_trials = plt.subplots(figsize=(4,total_no_of_rows),ncols=1,nrows=total_no_of_rows, sharex=True)
if total_no_of_rows >1 :
ax_all_trials=ax_all_trials.ravel()
non_empty_non_unitary_trial_counter=0
distances = []
color = sns.color_palette()[exp_id+1]
row_counter=0
target_pop_index_array=[]
if spike_plot_parameters[0]=="2D raster plots":
if "save all trials to one separate file" in spike_plot_parameters:
row_array=range(0,total_no_of_rows)
if spike_plot_parameters[0]=="2D raster plots":
if "save all trials to separate files" in spike_plot_parameters:
raster_ax_row_counter=0
for trial in range(0,n_trials):
sim_dir = 'simulations/' + exp_specify[0][exp_id]+'/sim%d'%trial+'/txt'
######
if n_trials > 1:
target_cell_array_per_trial=target_cell_array[trial]
else:
target_cell_array_per_trial=target_cell_array
if target_cell_array_per_trial !=[]:
spike_trains = []
target_pop_index_array_per_trial=[]
print(" Trial %d is not empty"%(trial))
for target_pop in range(0,len(target_cell_array_per_trial)):
for pop in range(0,no_of_groups):
if ('pop%d'%(pop)) in target_cell_array_per_trial[target_pop]:
target_pop_index_array_per_trial.append(pop)
target_cells = [x for x in target_cell_array_per_trial[target_pop] if isinstance(x,int)]
print target_cells
for cell in range(0,len(target_cells)):
#create target txt file containing spike times
if not os.path.isfile('%s/Golgi_pop%d_cell%d.txt'%(sim_dir,pop,target_cells[cell])):
get_spike_times('Golgi_pop%d_cell%d'%(pop,target_cells[cell]),exp_specify[0][exp_id],trial)
spikes = np.loadtxt('%s/Golgi_pop%d_cell%d.txt'%(sim_dir,pop,target_cells[cell]))
spike_train=pyspike.SpikeTrain(spikes,[0,sim_duration])
spike_trains.append(spike_train)
print spike_trains
if spike_plot_parameters[0]=="2D raster plots":
if spike_plot_parameters[1]==trial:
ax_stack[target_pop].scatter(spikes,np.zeros_like(spikes)+target_cells[cell]+exp_id*(cell_no_array[pop]+1) ,marker='|',s=2,c=color)
if "save all trials to separate files" in spike_plot_parameters:
if n_trials >1:
if len(target_cell_array_per_trial) > 1:
raster_ax_array[raster_ax_row_counter][target_pop].scatter(spikes,np.zeros_like(spikes)+target_cells[cell]+exp_id*(cell_no_array[pop]+1) ,marker='|',s=2,c=color)
else:
raster_ax_array[raster_ax_row_counter].scatter(spikes,np.zeros_like(spikes)+target_cells[cell]+exp_id*(cell_no_array[pop]+1) ,marker='|',s=2,c=color)
else:
if len(target_cell_array_per_trial) >1:
ax_stack_one_trial[target_pop].scatter(spikes,np.zeros_like(spikes)+target_cells[cell]+exp_id*(cell_no_array[pop]+1) ,marker='|',s=2,c=color)
else:
ax_stack_one_trial.scatter(spikes,np.zeros_like(spikes)+target_cells[cell]+exp_id*(cell_no_array[pop]+1) ,marker='|',s=2,c=color)
if "save all trials to one separate file" in spike_plot_parameters:
if n_trials >1:
if total_no_of_rows >1 :
ax_all_trials[row_array[row_counter]].scatter(spikes,np.zeros_like(spikes)+target_cells[cell]+exp_id*(cell_no_array[pop]+1) ,marker='|',s=2,c=color)
else:
ax_all_trials.scatter(spikes,np.zeros_like(spikes)+target_cells[cell]+exp_id*(cell_no_array[pop]+1) ,marker='|',s=2,c=color)
if spike_plot_parameters[0]=="2D raster plots":
if "save all trials to one separate file" in spike_plot_parameters:
row_counter=row_counter+1
if spike_plot_parameters[0]=="2D raster plots":
if "save all trials to separate files" in spike_plot_parameters:
raster_ax_row_counter+=1
if spike_plot_parameters[1]==trial:
target_trial_index=target_pop_index_array.index(target_pop_index_array_per_trial)
target_pop_index_array.append(target_pop_index_array_per_trial)
########
print("Length of spike_trains is %d"%len(spike_trains))
if len(spike_trains) >1:
print("Trial %d contains more than one cell; Synchrony metric will be computed for this trial"%(trial))
non_empty_non_unitary_trial_counter+=1
print non_empty_non_unitary_trial_counter
distances.append(pyspike.spike_profile_multi(spike_trains))
else:
print("Trial %d contains one cell; Synchrony metric will not be computed for this trial"%(trial))
########
# average synchrony index across "non empty" trials
average_distance = distances[0]
for distance in distances[1:]:
average_distance.add(distance)
average_distance.mul_scalar(1./non_empty_non_unitary_trial_counter)
# below blocks for saving synchrony and spike raster plots
mark_steps=sim_duration/50
marks=[]
for mark in range(0,mark_steps+1):
Mark=50*mark
marks.append(Mark)
xmin = 50
right_shaded_region=50
if sim_duration >=1000:
right_shaded_region=100
xmax = sim_duration-right_shaded_region
x, y = average_distance.get_plottable_data()
ximin = np.searchsorted(x, xmin)
ximax = np.searchsorted(x, xmax)
if spike_plot_parameters[0]=="2D raster plots":
if target_cell_array_target_trial != []:
target_cell_array_target_trial_indicator=True
lines.append(ax_stack[no_of_rasters].plot(x[ximin:ximax+1], 1-y[ximin:ximax+1], lw=2, c=color)[0])
ax_stack[no_of_rasters].plot(x[:ximin+1], 1-y[:ximin+1], lw=2, c=color, alpha=0.4)
ax_stack[no_of_rasters].plot(x[ximax:], 1-y[ximax:], lw=2, c=color, alpha=0.4)
if "save sync plot to a separate file" in spike_plot_parameters:
lines_sep.append(ax_sync.plot(x[ximin:ximax+1], 1-y[ximin:ximax+1], lw=2, c=color)[0])
ax_sync.plot(x[:ximin+1], 1-y[:ximin+1], lw=2, c=color, alpha=0.4)
ax_sync.plot(x[ximax:], 1-y[ximax:], lw=2, c=color, alpha=0.4)
if "save sync plot to a separate file" in spike_plot_parameters:
print("save sync plot to a separate file is specified")
for tick in ax_sync.xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in ax_sync.yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
ax_sync.locator_params(axis='y', tight=True, nbins=10)
ax_sync.set_xlabel('Time (ms)',fontsize=4)
ax_sync.set_ylabel('Synchrony index',size=4)
ax_sync.set_ylim(0,1)
ax_sync.set_xticks(marks)
ax_sync.set_title('Synchronization between %s'%general_plot_parameters[1],size=4)
fig_sync.tight_layout()
fig_sync.subplots_adjust(top=0.90)
fig_sync.subplots_adjust(bottom=0.55)
l=fig_sync.legend(lines_sep,general_plot_parameters[3],title=general_plot_parameters[2],loc='center',ncol=len(general_plot_parameters[3]),bbox_to_anchor=(0.52, 0.25),prop={'size':4})
plt.setp(l.get_title(),fontsize=4)
fig_sync.savefig('simulations/sync_only_%s.%s'%(general_plot_parameters[0],spike_plot_parameters[-1]))
print("saved %s in simulations"%'sync_only_%s.%s'%(general_plot_parameters[0],spike_plot_parameters[-1]))
if spike_plot_parameters[0]=="2D raster plots":
print("Intend to plot a main figure with representative 2D raster plots")
#create label array
if trial_indicator_target:
print("2D raster plot procedures started")
for pop in range(0,no_of_rasters):
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[target_trial_index][pop]]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[target_trial_index][pop]]-1)
left_value=cell_no_array[target_pop_index_array[target_trial_index][pop]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[target_trial_index][pop]])
left_value=left_value+2+cell_no_array[target_pop_index_array[target_trial_index][pop]]
print label_array
print ytick_array
ax_stack[pop].set_yticks(ytick_array)
fig_stack.canvas.draw()
ax_stack[pop].set_ylim(0,(cell_no_array[target_pop_index_array[target_trial_index][pop]]+1)*len(general_plot_parameters[3]) )
ax_stack[pop].set_ylabel('Cell ids, population %d'%pop,size=4)
ax_stack[pop].set_yticks([cell_no_array[target_pop_index_array[target_trial_index][pop]]+(cell_no_array[target_pop_index_array[target_trial_index][pop]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
ax_stack[pop].yaxis.grid(False, which='major')
ax_stack[pop].yaxis.grid(True, which='minor')
labels = [x.get_text() for x in ax_stack[pop].get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
ax_stack[pop].set_yticklabels(labels)
if pop==0:
ax_stack[pop].set_title('Raster plots for target Golgi cell populations (trial id=%d)'%spike_plot_parameters[1],size=6)
for pop in range(0,no_of_rasters+1):
for tick in ax_stack[pop].xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in ax_stack[pop].yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
ax_stack[no_of_rasters].locator_params(axis='y', tight=True, nbins=10)
ax_stack[no_of_rasters].set_xlabel('Time (ms)',fontsize=6)
ax_stack[no_of_rasters].set_ylabel('Synchrony index',size=4)
ax_stack[no_of_rasters].set_ylim(0,1)
ax_stack[no_of_rasters].set_xticks(marks)
ax_stack[no_of_rasters].set_title('Synchronization between %s'%general_plot_parameters[1],size=6)
fig_stack.tight_layout()
fig_stack.subplots_adjust(top=0.80)
fig_stack.subplots_adjust(bottom=0.15)
fig_stack.subplots_adjust(hspace=.4)
l=fig_stack.legend(lines,general_plot_parameters[3],title=general_plot_parameters[2], loc='upper center',ncol=len(general_plot_parameters[3]),bbox_to_anchor=(0.55, 1.0))
plt.setp(l.get_title(),fontsize=6)
plt.setp(l.get_texts(), fontsize=6)
fig_stack.savefig('simulations/%s.%s'%(general_plot_parameters[0],spike_plot_parameters[-1]))
else:
print("Intended to plot raster plots for trial %d, but specified region-specific selection of cells produces an empty target array.\nThus a main figure with a representative raster will not be produced.\nHowever, synchrony plot can be saved in a separate file.\nAlternatively, plot a non-empty trial"%(spike_plot_parameters[1]))
if "save all trials to one separate file" in spike_plot_parameters:
print target_pop_index_array
if total_no_of_rows >1:
row_counter=0
for trial in range(0,len(non_empty_trial_indices)):
if len(target_pop_index_array[trial]) >1:
for pop in range(0,len(target_pop_index_array[trial])):
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[trial][pop] ]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[trial][pop]]-1)
left_value=cell_no_array[target_pop_index_array[trial][pop]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[trial][pop]] )
left_value=left_value+2+cell_no_array[target_pop_index_array[trial][pop]]
ax_all_trials[row_counter].set_yticks(ytick_array)
#ax_all_trials[row_counter].canvas.draw()
ax_all_trials[row_counter].set_ylim(0,(cell_no_array[target_pop_index_array[trial][pop]]+1)*len(general_plot_parameters[3]) )
ax_all_trials[row_counter].set_ylabel('Cell ids for pop %d\ntrial %d'%(target_pop_index_array[trial][pop],non_empty_trial_indices[trial]),size=4)
ax_all_trials[row_counter].set_yticks([cell_no_array[target_pop_index_array[trial][pop]]+( cell_no_array[target_pop_index_array[trial][pop]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
ax_all_trials[row_counter].yaxis.grid(False, which='major')
ax_all_trials[row_counter].yaxis.grid(True, which='minor')
if row_counter==total_no_of_rows-1:
ax_all_trials[row_counter].set_xlabel('Time (ms)',fontsize=4)
labels = [x.get_text() for x in ax_all_trials[row_counter].get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
ax_all_trials[row_counter].set_yticklabels(labels)
for tick in ax_all_trials[row_counter].xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in ax_all_trials[row_counter].yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
row_counter+=1
else:
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[trial][0]]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[trial][0]]-1)
left_value=cell_no_array[target_pop_index_array[trial][0]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[trial][0]] )
left_value=left_value+2+cell_no_array[target_pop_index_array[trial][0]]
ax_all_trials[row_counter].set_yticks(ytick_array)
ax_all_trials[row_counter].set_ylim(0,(cell_no_array[target_pop_index_array[trial][0]]+1)*len(general_plot_parameters[3]) )
ax_all_trials[row_counter].set_ylabel('Cell ids for pop %d\ntrial %d'%(target_pop_index_array[trial][0],non_empty_trial_indices[trial]),size=4)
ax_all_trials[row_counter].set_yticks([cell_no_array[target_pop_index_array[trial][0]]+( cell_no_array[target_pop_index_array[trial][0]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
ax_all_trials[row_counter].yaxis.grid(False, which='major')
ax_all_trials[row_counter].yaxis.grid(True, which='minor')
if row_counter==total_no_of_rows-1:
ax_all_trials[row_counter].set_xlabel('Time (ms)',fontsize=4)
labels = [x.get_text() for x in ax_all_trials[row_counter].get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
ax_all_trials[row_counter].set_yticklabels(labels)
for tick in ax_all_trials[row_counter].xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in ax_all_trials[row_counter].yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
row_counter+=1
else:
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[0][0]]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[0][pop]]-1)
left_value=cell_no_array[target_pop_index_array[0][0]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[0][0]] )
left_value=left_value+2+cell_no_array[target_pop_index_array[0][0]]
ax_all_trials.set_yticks(ytick_array)
ax_all_trials.canvas.draw()
ax_all_trials.set_ylim(0,(cell_no_array[target_pop_index_array[0][0]]+1)*len(general_plot_parameters[3]) )
ax_all_trials.set_ylabel('Cell ids for pop %d\ntrial %d'%(target_pop_index_array[trial][pop],non_empty_trial_indices[trial]),size=4)
ax_all_trials.set_yticks([cell_no_array[target_pop_index_array[0][0]]+( cell_no_array[target_pop_index_array[0][0]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
ax_all_trials.yaxis.grid(False, which='major')
ax_all_trials.yaxis.grid(True, which='minor')
ax_all_trials.set_xlabel('Time (ms)',fontsize=4)
labels = [x.get_text() for x in ax_all_trials.get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
ax_all_trials.set_yticklabels(labels)
for tick in ax_all_trials.xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in ax_all_trials.yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
fig_all_trials.subplots_adjust(hspace=0.1)
fig_all_trials.subplots_adjust(top=0.95)
fig_all_trials.subplots_adjust(bottom=0.1)
l=fig_all_trials.legend(lines,general_plot_parameters[3],title=general_plot_parameters[2],loc='center',ncol=len(general_plot_parameters[3]),bbox_to_anchor=(0.52, 0.98),prop={'size':4})
plt.setp(l.get_title(),fontsize=4)
fig_all_trials.savefig('simulations/all_trials_%s.%s'%(general_plot_parameters[0],spike_plot_parameters[-1]))
plt.clf()
if "save all trials to separate files" in spike_plot_parameters:
if n_trials >1:
for trial in range(0,len(non_empty_trial_indices)):
print("started ploting non-empty trials")
if pop_no_array[trial] >1:
for pop in range(0,pop_no_array[trial]):
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[trial][pop]]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[trial][pop]]-1)
left_value=cell_no_array[target_pop_index_array[trial][pop]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[trial][pop]] )
left_value=left_value+2+cell_no_array[target_pop_index_array[trial][pop]]
raster_ax_array[trial][pop].set_yticks(ytick_array)
raster_fig_array[trial].canvas.draw()
raster_ax_array[trial][pop].set_ylim(0,(cell_no_array[target_pop_index_array[trial][pop]]+1)*len(general_plot_parameters[3]) )
raster_ax_array[trial][pop].set_ylabel('Cell ids, population %d'%target_pop_index_array[trial][pop],size=4)
raster_ax_array[trial][pop].set_yticks([cell_no_array[target_pop_index_array[trial][pop]]+( cell_no_array[target_pop_index_array[trial][pop]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
raster_ax_array[trial][pop].yaxis.grid(False, which='major')
raster_ax_array[trial][pop].yaxis.grid(True, which='minor')
labels = [x.get_text() for x in raster_ax_array[trial][pop].get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
raster_ax_array[trial][pop].set_yticklabels(labels)
if pop==0:
raster_ax_array[trial][pop].set_title('Raster plot for Golgi cell populations (trial id=%d)'%non_empty_trial_indices[trial],size=6)
if pop==pop_no_array[trial]-1:
raster_ax_array[trial][pop].set_xlabel('Time (ms)',fontsize=6)
for tick in raster_ax_array[trial][pop].xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in raster_ax_array[trial][pop].yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
else:
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[trial][0]]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[trial][0]]-1)
left_value=cell_no_array[target_pop_index_array[trial][0]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[trial][0]] )
left_value=left_value+2+cell_no_array[target_pop_index_array[trial][0]]
raster_ax_array[trial].set_yticks(ytick_array)
raster_fig_array[trial].canvas.draw()
raster_ax_array[trial].set_ylim(0,(cell_no_array[target_pop_index_array[trial][0]]+1)*len(general_plot_parameters[3]) )
raster_ax_array[trial].set_ylabel('Cell ids, population %d'% target_pop_index_array[trial][0],size=4)
raster_ax_array[trial].set_yticks([cell_no_array[target_pop_index_array[trial][0]]+( cell_no_array[target_pop_index_array[trial][0]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
raster_ax_array[trial].yaxis.grid(False, which='major')
raster_ax_array[trial].yaxis.grid(True, which='minor')
labels = [x.get_text() for x in raster_ax_array[trial].get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
raster_ax_array[trial].set_yticklabels(labels)
raster_ax_array[trial].set_title('Raster plot for Golgi cell populations (trial id=%d)'%non_empty_trial_indices[trial],size=6)
raster_ax_array[trial].set_xlabel('Time (ms)',fontsize=6)
for tick in raster_ax_array[trial].xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in raster_ax_array[trial].yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
raster_fig_array[trial].subplots_adjust(top=0.90)
raster_fig_array[trial].subplots_adjust(bottom=0.3)
l=raster_fig_array[trial].legend(lines,general_plot_parameters[3],title=general_plot_parameters[2],loc='center',ncol=len(general_plot_parameters[3]),bbox_to_anchor=(0.52, 0.1),prop={'size':4})
plt.setp(l.get_title(),fontsize=4)
raster_fig_array[trial].savefig('simulations/sim%d_rasters_%s.%s'%(non_empty_trial_indices[trial],general_plot_parameters[0],spike_plot_parameters[-1]))
else:
if trial_indicator:
if pop_no_array[0] >1:
for pop in range(0,pop_no_array[0]):
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[0][pop]]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[0][pop]]-1)
left_value=cell_no_array[target_pop_index_array[0][pop]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[0][pop]] )
left_value=left_value+2+cell_no_array[target_pop_index_array[0][pop]]
ax_stack_one_trial[pop].set_yticks(ytick_array)
fig_stack_one_trial.canvas.draw()
ax_stack_one_trial[pop].set_ylim(0,(cell_no_array[target_pop_index_array[0][pop]]+1)*len(general_plot_parameters[3]) )
ax_stack_one_trial[pop].set_ylabel('Cell ids, population %d'%target_pop_index_array[0][pop],size=4)
ax_stack_one_trial[pop].set_yticks([cell_no_array[target_pop_index_array[0][pop]]+( cell_no_array[target_pop_index_array[0][pop]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
ax_stack_one_trial[pop].yaxis.grid(False, which='major')
ax_stack_one_trial[pop].yaxis.grid(True, which='minor')
labels = [x.get_text() for x in ax_stack_one_trial[pop].get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
ax_stack_one_trial[pop].set_yticklabels(labels)
if pop==0:
ax_stack_one_trial[pop].set_title('Raster plot for Golgi cell populations (trial id=%d)'%spike_plot_parameters[1],size=6)
if pop==pop_no_array[0]-1:
ax_stack_one_trial[pop].set_xlabel('Time (ms)',fontsize=6)
for tick in ax_stack_one_trial[pop].xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in ax_stack_one_trial[pop].yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
else:
label_array=[]
ytick_array=[]
for exp in range(0,len(general_plot_parameters[3])):
label_array.append("%d"%0)
label_array.append("%d"%(cell_no_array[target_pop_index_array[0][0]]-1))
if exp==0:
ytick_array.append(exp)
ytick_array.append(cell_no_array[target_pop_index_array[0][0]]-1)
left_value=cell_no_array[target_pop_index_array[0][0]]-1
else:
ytick_array.append(left_value+2)
ytick_array.append(left_value+1+cell_no_array[target_pop_index_array[0][0]] )
left_value=left_value+2+cell_no_array[target_pop_index_array[0][0]]
ax_stack_one_trial.set_yticks(ytick_array)
fig_stack_one_trial.canvas.draw()
ax_stack_one_trial.set_ylim(0,(cell_no_array[target_pop_index_array[0][0]]+1)*len(general_plot_parameters[3]) )
ax_stack_one_trial.set_ylabel('Cell ids, population %d'%target_pop_index_array[0][0],size=4)
ax_stack_one_trial.set_yticks([cell_no_array[target_pop_index_array[0][0]]+( cell_no_array[target_pop_index_array[0][0]]+2)*k for k in range(0,len(general_plot_parameters[3]))],minor=True)
ax_stack_one_trial.yaxis.grid(False, which='major')
ax_stack_one_trial.yaxis.grid(True, which='minor')
labels = [x.get_text() for x in ax_stack_one_trial.get_yticklabels()]
for label in range(0,len(labels)):
labels[label] =label_array[label]
ax_stack_one_trial.set_yticklabels(labels)
ax_stack_one_trial.set_title('Raster plot for Golgi cell populations (trial id=%d)'%spike_plot_parameters[1],size=6)
ax_stack_one_trial.set_xlabel('Time (ms)',fontsize=6)
for tick in ax_stack_one_trial.xaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[4])
for tick in ax_stack_one_trial.yaxis.get_major_ticks():
tick.label.set_fontsize(general_plot_parameters[5])
fig_stack_one_trial.subplots_adjust(top=0.90)
fig_stack_one_trial.subplots_adjust(bottom=0.3)
l=fig_stack_one_trial.legend(lines,general_plot_parameters[3],title=general_plot_parameters[2],loc='center',ncol=len(general_plot_parameters[3]),bbox_to_anchor=(0.52, 0.1),prop={'size':4})
plt.setp(l.get_title(),fontsize=4)
fig_stack_one_trial.savefig('simulations/sim%d_rasters_%s.%s'%(spike_plot_parameters[1],general_plot_parameters[0],spike_plot_parameters[-1]))
plt.clf()
with open('pickles/membrane_dynamics_balanced_file.p', 'rb') as f:
mdf0 = pickle.load(f)
print(mdf0)
except:
pass
# first load the data, interval ending time = 4000, start=0 (default)
#spike_trains_txt = spk.load_spike_trains_from_txt("PySpike_testdata.txt", 4000)
wrangled_trains = []
for spiketrain in mdf1.spiketrains:
y = np.ones_like(spiketrain) * spiketrain.annotations['source_id']
pspikes = pyspike.SpikeTrain(spiketrain,edges=(0,4000))
wrangled_trains.append(pspikes)
print(pspikes)
""" Class representing spike trains for the PySpike Module.
def __init__(self, spike_times, edges, is_sorted=True):
Constructs the SpikeTrain.
:param spike_times: ordered array of spike times.
:param edges: The edges of the spike train. Given as a pair of floats
(T0, T1) or a single float T1, where then T0=0 is
assumed.
:param is_sorted: If `False`, the spike times will sorted by `np.sort`.
"""
def multi_shift(source,
shifts,
n,
frac_shifts=[1],
increase=False,
jitter=False):
### FRAC_FIRE IS CURRENTLY IGNORED!!!!, implemented in shift_fwd ###
if not (isinstance(frac_shifts, np.ndarray)):
frac_shifts = np.array(frac_shifts)
if not (isinstance(shifts, np.ndarray)):
shifts = np.array(shifts)
duration = source.t_end
def shift_main(src):
spiketimes = src.spikes[:, np.newaxis]
num_shifts = len(shifts)
num_fracshift = len(frac_shifts)
num_spikes = spiketimes.size
# Finding edges
left_edge = np.where(spiketimes < shifts)
right_edge = np.where((spiketimes + shifts) > duration)
# Create the shift matrices
shifts_bottom = np.tile(shifts, reps=(num_spikes, n, num_fracshift, 1))
shifts_top = shifts_bottom.copy()
shifts_bottom[left_edge[0], :, :, left_edge[1]] = \
spiketimes[left_edge[0]][:, np.newaxis]
shifts_top[right_edge[0], :, :, right_edge[1]] = \
((duration) - spiketimes[right_edge[0]][:, np.newaxis])
shifts_range = shifts_top + shifts_bottom
# boolean matrix for fractional shifting - MAY REQUIRE CHANGING AFTER FRAC_FIRE IS INTEGRATED
bool_frac_mat = np.random.rand(num_spikes, n, num_fracshift,
num_shifts)
bool_frac_mat = bool_frac_mat <= frac_shifts[:, np.newaxis]
# Draw!
shiftvals = np.random.rand(num_spikes, n, num_fracshift, num_shifts)
# Fix edges!
shiftvals = (
(shiftvals * shifts_range) - shifts_bottom) * bool_frac_mat
shiftvals.round(out=shiftvals)
# Shift!
shifted = shiftvals + spiketimes[:, np.newaxis, np.newaxis]
shifted.sort()
# Find uniques!
uniques = [
np.unique(shifted[:, i, j, k]) for i in range(n)
for j in range(num_fracshift) for k in range(num_shifts)
]
# pyspike!
shifted_spk = [
spk.SpikeTrain(shifted_times, duration)
for shifted_times in uniques
]
return shifted_spk
if increase:
slots = np.setdiff1d(np.arange(source.t_start, source.t_end),
source.spikes,
assume_unique=True)
sources = {0: source}
for inc in increase:
new_spikes = np.random.choice(slots, inc)
sources[inc] = spk.SpikeTrain(
np.sort(np.append(source.spikes, new_spikes)), duration)
shifted = []
for src in sources.values():
shifted.extend(shift_main(src))
else:
shifted = shift_main(source)
return shifted
def get_matrix(select='subset',
min_spike_number=0,
save=None,
analysis=['SPIKE-Sync'],
network=[0]):
import pyspike
load_data(network)
getmat = {}
empty_dict_array = {}
no_empty_dict_array = {}
spkts = {}
spkinds = {}
spktsRange = {}
spkt_train = {}
spike_sync = {}
for f, p in enumerate(data_files):
if f in network:
spkts[f] = d[p]['simData']['spkt'] #list
spkinds[f] = d[p]['simData']['spkid'] #list
print 'Starting analysis of spike times per ' + str(
select) + ': ' + str(p)
for t, y in enumerate(timeRange):
spktsRange = [
spkt for spkt in spkts[f]
if timeRange[t][0] <= spkt <= timeRange[t][1]
]
spkt_train[str(f) + str(t)] = []
if select == 'subset':
print 'Time Range: ' + str(y)
empty_array = np.zeros(
((len(net_labels) * 2), (len(net_labels) * 2)))
no_empty_array = np.zeros(
((len(net_labels) * 2), (len(net_labels) * 2)))
array_ii = np.zeros(
((len(net_labels) * 2), (len(net_labels) * 2)))
empty_gids = []
gids_included = []
for k, v in enumerate(gids):
train = []
for i, gid in enumerate(v):
for spkind, spkt in zip(spkinds[f], spkts[f]):
if (spkind == gid and spkt in spktsRange):
train.append(spkt)
spkt_train[str(f) + str(t)].append(
pyspike.SpikeTrain(train, timeRange[t]))
if len(train) < min_spike_number:
empty_gids.append(k)
else:
gids_included.append(k)
for i in range(len(spkt_train[str(f) + str(t)])):
if i in gids_included:
for k, v in enumerate(gids_included):
no_empty_array[i][v] = 1.0
for l in range(len(array_ii)):
array_ii[l][l] = 1.0
no_empty_dict_array[str(f) + str(t)] = no_empty_array
elif select == 'cell':
print 'Time Range: ' + str(y)
empty_array = np.zeros(
((len(net_labels) * 80), (len(net_labels) * 80)))
no_empty_array = np.zeros(
((len(net_labels) * 80), (len(net_labels) * 80)))
empty_gids = []
spkmat2 = []
gids_included = []
#sync = np.zeros(((len(net_labels)*80),(len(net_labels)*80)))
for ii, subset in enumerate(gids):
spkmat = [
pyspike.SpikeTrain([
spkt
for spkind, spkt in zip(spkinds[f], spkts[f])
if (spkind == gid and spkt in spktsRange)
], timeRange[t]) for gid in set(subset)
]
spkt_train[str(f) + str(t)].extend(spkmat)
for gid in set(subset):
list_spkt = [
spkt
for spkind, spkt in zip(spkinds[f], spkts[f])
if (spkind == gid and spkt in spktsRange)
]
if len(list_spkt) < min_spike_number:
empty_gids.append(gid)
else:
spkmat2.append(
pyspike.SpikeTrain(list_spkt,
timeRange[t]))
gids_included.append(gid)
pos_labels.append(len(gids_included))
#print gids_included
empty_gids[:] = [x - 200 for x in empty_gids]
gids_included[:] = [x - 200 for x in gids_included]
#print empty_gids
for i in range(len(spkt_train[str(f) + str(t)])):
if i in empty_gids:
for k, v in enumerate(empty_gids):
empty_array[i][v] = 1.0
for i in range(len(spkt_train[str(f) + str(t)])):
if i in gids_included:
for k, v in enumerate(gids_included):
no_empty_array[i][v] = 1.0
#print empty_array
empty_dict_array[str(f) + str(t)] = empty_array
no_empty_dict_array[str(f) + str(t)] = no_empty_array
#print spkt_train
for l, mat in enumerate(mats):
#spike_sync
if (mat == 'ISI-distance' and mat in analysis):
print str(mat) + ", number of trains: " + str(
len(spkt_train[str(f) + str(t)]))
isi_distance = pyspike.isi_distance_matrix(
spkt_train[str(f) + str(t)])
getmat[str(f) + str(t) + str(l)] = isi_distance
elif (mat in analysis and mat == 'SPIKE-distance'):
print str(mat) + ", number of trains: " + str(
len(spkt_train[str(f) + str(t)]))
spike_distance = pyspike.spike_distance_matrix(
spkt_train[str(f) + str(t)])
getmat[str(f) + str(t) + str(l)] = spike_distance
elif (mat in analysis and mat == 'SPIKE-Sync'):
print str(mat) + ", number of trains: " + str(
len(spkt_train[str(f) + str(t)]))
spike_sync[str(f) +
str(t)] = pyspike.spike_sync_matrix(
spkt_train[str(f) + str(t)])
#if select == 'subset':
getmat[str(f) + str(t) + str(l)] = (
spike_sync[str(f) + str(t)] *
no_empty_dict_array[str(f) + str(t)]) + array_ii
#elif select == 'cell':
#getmat[str(f)+str(t)+str(l)] = spike_sync[str(f)+str(t)] * no_empty_dict_array[str(f)+str(t)]
empty_array = np.zeros(
((len(net_labels) * 80), (len(net_labels) * 80)))
else:
pass
if save == True:
with open(str(path) + 'data1.pkl', 'wb') as output:
pickle.dump(getmat, output)
return getmat
print 'finished getting data for matrix plotting'
pl.ylim(0, N + 1)
pl.xlim(0, duration * runs)
pl.show(block=False)
########## measure synchrony ##################################################
slices = []
for run in range(runs):
section = []
for n in range(N):
section.append([])
subint = [
x for x in spikes[n]
if x >= ((run - 1) * duration) and x <= (run * duration)
]
section[n] = spk.SpikeTrain(subint, (0, duration))
slices.append(section)
pl.figure(3)
sync = []
for c in range(len(slices)):
# sync.append(np.var(spk.spike_sync_matrix(slices[c])))
sync.append(np.linalg.norm(spk.spike_sync_matrix(slices[c])))
# sync.append(np.sum(spk.spike_sync_matrix(slices[c])))
pl.plot(sync, linestyle="-", marker="o", markersize="7")
# pl.hlines(15, 0, len(homXS), linewidth=0.3)
pl.grid(which='both', axis='y')
# pl.xlim(xmin=-0.5,xmax=len(homXS)+1.5)
def df_to_spike_train(df, t_start, edges):
return spk.SpikeTrain(
np.unique([(i - t_start).total_seconds() for i in df.index]), edges)
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 iter_plot0(md):
import seaborn as sns
import pickle
with open('cell_indexs.p', 'rb') as f:
returned_list = pickle.load(f)
index_exc = returned_list[0]
index_inh = returned_list[1]
index, mdf1 = md
#wgf = {0.025:None,0.05:None,0.125:None,0.25:None,0.3:None,0.4:None,0.5:None,1.0:None,1.5:None,2.0:None,2.5:None,3.0:None}
wgf = {
0.0025: None,
0.0125: None,
0.025: None,
0.05: None,
0.125: None,
0.25: None,
0.3: None,
0.4: None,
0.5: None,
1.0: None,
1.5: None,
2.0: None,
2.5: None,
3.0: None
}
weight_gain_factors = {k: v for k, v in enumerate(wgf.keys())}
print(len(weight_gain_factors))
print(weight_gain_factors.keys())
#weight_gain_factors = {0:0.5,1:1.0,2:1.5,3:2.0,4:2.5,5:3}
#weight_gain_factors = {:None,1.0:None,1.5:None,2.0:None,2.5:None}
k = weight_gain_factors[index]
#print(len(mdf1.segments),'length of block')
ass = mdf1.analogsignals[0]
time_points = ass.times
avg = np.mean(ass, axis=0) # Average over signals of Segment
#maxx = np.max(ass, axis=0) # Average over signals of Segment
std = np.std(ass, axis=0) # Average over signals of Segment
#avg_minus =
plt.figure()
plt.plot([i for i in range(0, len(avg))], avg)
plt.plot([i for i in range(0, len(std))], std)
plt.title("Mean and Standard Dev of $V_{m}$ amplitude per neuron ")
plt.xlabel('time $(ms)$')
plt.xlabel('Voltage $(mV)$')
plt.savefig(str(index) + 'prs.png')
vm_spiking = []
vm_not_spiking = []
spike_trains = []
binary_trains = []
max_spikes = 0
vms = np.array(mdf1.analogsignals[0].as_array().T)
#print(data)
#for i,vm in enumerate(data):
cnt = 0
for spiketrain in mdf1.spiketrains:
#spiketrain = mdf1.spiketrains[index]
y = np.ones_like(spiketrain) * spiketrain.annotations['source_id']
#import sklearn
#sklearn.decomposition.NMF(y)
# argument edges is the time interval you want to be considered.
pspikes = pyspike.SpikeTrain(spiketrain, edges=(0, len(ass)))
spike_trains.append(pspikes)
if len(spiketrain) > max_spikes:
max_spikes = len(spiketrain)
if np.max(ass[spiketrain.annotations['source_id']]) > 0.0:
vm_spiking.append(vms[spiketrain.annotations['source_id']])
else:
vm_not_spiking.append(vms[spiketrain.annotations['source_id']])
cnt += 1
for spiketrain in mdf1.spiketrains:
x = conv.BinnedSpikeTrain(spiketrain,
binsize=1 * pq.ms,
t_start=0 * pq.s)
binary_trains.append(x)
end_floor = np.floor(float(mdf1.t_stop))
dt = float(mdf1.t_stop) % end_floor
mdf1.t_start
#v = mdf1.take_slice_of_analogsignalarray_by_unit()
t_axis = np.arange(float(mdf1.t_start), float(mdf1.t_stop), dt)
plt.figure()
plt.clf()
plt.figure()
plt.clf()
cleaned = []
data = np.array(mdf1.analogsignals[0].as_array().T)
#print(data)
for i, vm in enumerate(data):
if np.max(vm) > 900.0 or np.min(vm) < -900.0:
pass
else:
plt.plot(ass.times, vm) #,label='neuron identifier '+str(i)))
cleaned.append(vm)
#vm = s#.as_array()[:,i]
assert len(cleaned) < len(ass)
print(len(cleaned))
plt.title('neuron $V_{m}$')
#plt.legend(loc="upper left")
plt.savefig(str('weight_') + str(k) + 'analogsignals' + '.png')
plt.xlabel('Time $(ms)$')
plt.ylabel('Voltage $(mV)$')
plt.close()
#pass
plt.figure()
plt.clf()
plt.title('Single Neuron $V_{m}$ trace')
plt.plot(ass.times[0:int(len(ass.times) / 10)],
vm_not_spiking[index_exc[0]][0:int(len(ass.times) / 10)])
plt.xlabel('$ms$')
plt.ylabel('$mV$')
plt.xlabel('Time $(ms)$')
plt.ylabel('Voltage $(mV)$')
plt.savefig(str('weight_') + str(k) + 'eespecific_analogsignals' + '.png')
plt.close()
plt.figure()
plt.clf()
plt.title('Single Neuron $V_{m}$ trace')
plt.plot(ass.times[0:int(len(ass.times) / 10)],
vm_not_spiking[index_inh[0]][0:int(len(ass.times) / 10)])
plt.xlabel('$ms$')
plt.ylabel('$mV$')
plt.savefig(str('weight_') + str(k) + 'inhibitory_analogsignals' + '.png')
plt.close()
cvs = [0 for i in range(0, len(spike_trains))]
cvsd = {}
cvs = []
cvsi = []
rates = [] # firing rates per cell. in spikes a second.
for i, j in enumerate(spike_trains):
rates.append(float(len(j) / 2.0))
cva = cv(j)
if np.isnan(cva) or cva == 0:
pass
#cvs[i] = 0
#cvsd[i] = 0
else:
pass
#cvs[i] = cva
#cvsd[i] = cva
cvs.append(cva)
#import pickle
#with open(str('weight_')+str(k)+'coefficients_of_variation.p','wb') as f:
# pickle.dump([cvs,cvsd],f)
import numpy
a = numpy.asarray(cvs)
numpy.savetxt('pickles/' + str('weight_') + str(k) +
'coefficients_of_variation.csv',
a,
delimiter=",")
import numpy
a = numpy.asarray(rates)
numpy.savetxt('pickles/' + str('weight_') + str(k) + 'firing_of_rate.csv',
a,
delimiter=",")
cvs = [i for i in cvs if i != 0]
cells = [i for i in range(0, len(cvs))]
plt.clf()
fig, axes = plt.subplots()
axes.set_title('Coefficient of Variation Versus Neuron')
axes.set_xlabel('Neuron number')
axes.set_ylabel('CV estimate')
mcv = np.mean(cvs)
#plt.scatter(cells,cvs)
cvs = np.array(cvs)
plt.scatter(index_inh, cvs[index_inh], label="inhibitory cells")
plt.scatter(index_exc, cvs[index_exc], label="excitatory cells")
plt.legend(loc="upper left")
fig.tight_layout()
plt.savefig(str('weight_') + str(k) + 'cvs_mean_' + str(mcv) + '.png')
plt.close()
plt.clf()
#frequencies, power = elephant.spectral.welch_psd(ass)
#mfreq = frequencies[np.where(power==np.max(power))[0][0]]
#fig, axes = plt.subplots()
axes.set_title('Firing Rate Versus Neuron Number at mean f=' +
str(np.mean(rates)) + str('(Spike Per Second)'))
axes.set_xlabel('Neuron number')
axes.set_ylabel('Spikes per second')
rates = np.array(rates)
plt.scatter(index_inh, rates[index_inh], label="inhibitory cells")
plt.scatter(index_exc, rates[index_exc], label="excitatory cells")
plt.legend(loc="upper left")
fig.tight_layout()
plt.savefig(str('firing_rates_per_cell_') + str(k) + str(mcv) + '.png')
plt.close()
'''
import pandas as pd
d = {'coefficent_of_variation': cvs, 'cells': cells}
df = pd.DataFrame(data=d)
ax = sns.regplot(x='cells', y='coefficent_of_variation', data=df)#, fit_reg=False)
plt.savefig(str('weight_')+str(k)+'cvs_regexp_'+str(mcv)+'.png');
plt.close()
'''
spike_trains = []
ass = mdf1.analogsignals[0]
tstop = mdf1.t_stop
np.max(ass.times) == mdf1.t_stop
#assert tstop == 2000
tstop = 2000
vm_spiking = []
for spiketrain in mdf1.spiketrains:
vm_spiking.append(
mdf1.analogsignals[0][spiketrain.annotations['source_id']])
y = np.ones_like(spiketrain) * spiketrain.annotations['source_id']
# argument edges is the time interval you want to be considered.
pspikes = pyspike.SpikeTrain(spiketrain, edges=(0, tstop))
spike_trains.append(pspikes)
# plot the spike times
plt.clf()
for (i, spike_train) in enumerate(spike_trains):
plt.scatter(spike_train, i * np.ones_like(spike_train), marker='.')
plt.xlabel('Time (ms)')
plt.ylabel('Cell identifier')
plt.title('Raster Plot for weight strength:' + str(k))
plt.savefig(str('weight_') + str(k) + 'raster_plot' + '.png')
plt.close()
f = spk.isi_profile(spike_trains, indices=[0, 1])
x, y = f.get_plottable_data()
#text_file.close()
text_file = open(str('weight_') + str(index) + 'net_out.txt', 'w')
plt.figure()
plt.plot(x, np.abs(y), '--k', label="ISI-profile")
print("ISI-distance: %.8f" % f.avrg())
f = spk.spike_profile(spike_trains, indices=[0, 1])
x, y = f.get_plottable_data()
plt.plot(x, y, '-b', label="SPIKE-profile")
#print("SPIKE-distance: %.8f" % f.avrg())
string_to_write = str("ISI-distance:") + str(f.avrg()) + str("\n\n")
plt.title(string_to_write)
plt.xlabel('Time $(ms)$')
plt.ylabel('ISI distance')
plt.legend(loc="upper left")
plt.savefig(str('weight_') + str(k) + 'ISI_distance_bivariate' + '.png')
plt.close()
text_file.write(string_to_write)
#text_file.write("SPIKE-distance: %.8f" % f.avrg())
#text_file.write("\n\n")
plt.figure()
f = spk.spike_sync_profile(spike_trains[0], spike_trains[1])
x, y = f.get_plottable_data()
plt.plot(x, y, '--ok', label="SPIKE-SYNC profile")
print(f, f.avrg())
print("Average:" + str(f.avrg()))
#print(len(f.avrg()),f.avrg())
string_to_write = str("instantaneous synchrony:") + str(
f.avrg()) + 'weight: ' + str(index)
plt.title(string_to_write)
plt.xlabel('Time $(ms)$')
plt.ylabel('instantaneous synchrony')
text_file.write(string_to_write)
#text_file.write(list())
f = spk.spike_profile(spike_trains[0], spike_trains[1])
x, y = f.get_plottable_data()
plt.plot(x, y, '-b', label="SPIKE-profile")
plt.axis([0, 4000, -0.1, 1.1])
plt.legend(loc="center right")
plt.clf()
plt.figure()
plt.subplot(211)
f = spk.spike_sync_profile(spike_trains)
x, y = f.get_plottable_data()
plt.plot(x, y, '-b', alpha=0.7, label="SPIKE-Sync profile")
x1, y1 = f.get_plottable_data(averaging_window_size=50)
plt.plot(x1, y1, '-k', lw=2.5, label="averaged SPIKE-Sync profile")
plt.subplot(212)
f_psth = spk.psth(spike_trains, bin_size=50.0)
x, y = f_psth.get_plottable_data()
plt.plot(x, y, '-k', alpha=1.0, label="PSTH")
plt.savefig(str('weight_') + str(k) + 'multivariate_PSTH' + '.png')
plt.close()
plt.xlabel('Time $(ms)$')
plt.ylabel('Spikes per bin')
plt.clf()
plt.figure()
f_psth = spk.psth(spike_trains, bin_size=50.0)
x, y = f_psth.get_plottable_data()
plt.plot(x, y, '-k', alpha=1.0, label="PSTH")
plt.savefig(str('weight_') + str(k) + 'exclusively_PSTH' + '.png')
plt.close()
plt.figure()
isi_distance = spk.isi_distance_matrix(spike_trains)
plt.imshow(isi_distance, interpolation='none')
plt.title('Pairwise ISI distance, T=0-2000')
plt.xlabel('post-synaptic neuron number')
plt.ylabel('pre-synaptic neuron number')
plt.title("ISI-distance")
plt.savefig(str('weight_') + str(k) + 'ISI_distance' + '.png')
plt.close()
#plt.show()
plt.figure()
plt.clf()
import seaborn as sns
sns.set()
sns.clustermap(isi_distance) #,vmin=-,vmax=1);
plt.savefig(str('weight_') + str(k) + 'cluster_isi_distance' + '.png')
plt.close()
plt.figure()
spike_distance = spk.spike_distance_matrix(spike_trains,
interval=(0, float(tstop)))
import pickle
with open('spike_distance_matrix.p', 'wb') as f:
pickle.dump(spike_distance, f)
plt.imshow(spike_distance, interpolation='none')
plt.title("Pairwise SPIKE-distance, T=0-2000")
plt.xlabel('post-synaptic neuron number')
plt.ylabel('pre-synaptic neuron number')
plt.savefig(str('weight_') + str(k) + 'spike_distance_matrix' + '.png')
plt.close()
plt.figure()
plt.clf()
sns.set()
sns.clustermap(spike_distance)
plt.savefig(str('weight_') + str(k) + 'cluster_spike_distance' + '.png')
plt.close()
plt.figure()
spike_sync = spk.spike_sync_matrix(spike_trains,
interval=(0, float(tstop)))
plt.imshow(spike_sync, interpolation='none')
plt.title('Pairwise Spike Synchony, T=0-2000')
plt.xlabel('post-synaptic neuron number')
plt.ylabel('pre-synaptic neuron number')
import numpy
a = numpy.asarray(spike_sync)
numpy.savetxt("spike_sync_matrix.csv", a, delimiter=",")
plt.figure()
plt.clf()
sns.clustermap(spike_sync)
plt.savefig(
str('weight_') + str(k) + 'cluster_spike_sync_distance' + '.png')
plt.close()
def iter_plot1(md):
index, mdf1 = md
wgf = {
0.025: None,
0.05: None,
0.125: None,
0.25: None,
0.3: None,
0.4: None,
0.5: None,
1.0: None,
1.5: None,
2.0: None,
2.5: None,
3.0: None
}
weight_gain_factors = {k: v for k, v in enumerate(wgf.keys())}
k = weight_gain_factors[index]
ass = mdf1.analogsignals[0]
vm_spiking = []
vm_not_spiking = []
spike_trains = []
binary_trains = []
max_spikes = 0
cnt = 0
for spiketrain in mdf1.spiketrains:
#spiketrain = mdf1.spiketrains[index]
y = np.ones_like(spiketrain) * spiketrain.annotations['source_id']
# argument edges is the time interval you want to be considered.
pspikes = pyspike.SpikeTrain(spiketrain, edges=(0, len(ass)))
spike_trains.append(pspikes)
if len(spiketrain) > max_spikes:
max_spikes = len(spiketrain)
if np.max(ass[spiketrain.annotations['source_id']]) > 0.0:
vm_spiking.append(ass[spiketrain.annotations['source_id']])
else:
vm_not_spiking.append(ass[spiketrain.annotations['source_id']])
cnt += 1
import elephant
from scipy.signal import periodogram
#dt = 0.0025
#frequencies, power = periodogram(ass,fs=1/dt)
frequencies, power = elephant.spectral.welch_psd(ass)
mfreq = frequencies[np.where(power == np.max(power))[0][0]]
import pickle
with open(str(k) + '_' + str(mfreq) + '_' + 'mfreq.p', 'wb') as f:
pickle.dump(mfreq, f)
def plot_periodogram(frequencies, power):
plt.figure(figsize=(10, 4))
sns.heatmap(power)
plt.xlabel('Frequency ($Hz$)')
plt.ylabel('Power pre neuron ($V^2/Hz$)') # Note that power is now
# a normalized density
plt.savefig(
str('weight_') + str(k) + 'multi_variate_periodogram' + '.png')
plt.close()
plt.plot(frequencies, power[0])
plt.savefig(
str('weight_') + str(k) + '_single_neuron_periodogram' + '.png')
return
plot_periodogram(frequencies, power)
lens = np.shape(ass.as_array())[1]
coherance_matrix = np.zeros(shape=(lens, lens), dtype=float)
for i in range(0, lens):
for j in range(0, lens):
if i != j:
x = ass.as_array()[i]
y = ass.as_array()[j]
coh = welch_cohere(x, y)
if np.mean(coh) != 0:
coherance_matrix[i, j] = np.mean(coh)
plt.figure()
plt.clf()
from matplotlib.colors import LogNorm
#plt.imshow(coherance_matrix, interpolation='none',norm=cbar_kws)
sns.heatmap(coherance_matrix) #,cbar_kws=cbar_kws)
plt.title("Coherance Matrix")
plt.xlabel('pre-synaptic cell')
plt.ylabel('post-synaptic cell')
plt.savefig(
str('Coherance_matrix_weight_') + str(k) + str('freq_') + str(mfreq) +
'.png')
plt.close()
import numpy
a = numpy.asarray(coherance_matrix)
numpy.savetxt("coherance_matrix.csv", a, delimiter=",")
mdf1 = None
coh = None
