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_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 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 test_load_time_series():
spike_trains = spk.import_spike_trains_from_time_series(TIME_SERIES_DATA,
start_time=0,
time_bin=1)
assert len(spike_trains) == 40
spike_trains_check = spk.load_spike_trains_from_txt(TIME_SERIES_SPIKES,
edges=(0, 4000))
# check spike trains
for n in range(len(spike_trains)):
assert_equal(spike_trains[n].spikes, spike_trains_check[n].spikes)
assert_equal(spike_trains[n].t_start, 0)
assert_equal(spike_trains[n].t_end, 4000)
def raster_plot(file, show_plot=False):
spike_trains = spk.load_spike_trains_from_txt(file)
f = plt.figure()
for (i, spikes) in enumerate(spike_trains):
plt.plot(spikes, (i + 1) * np.ones_like(spikes), 'b|')
plt.xlabel("Time (ms)")
plt.ylabel("Neuron ID")
if show_plot:
plt.show()
return f
def test_multi_spike_sync():
# some basic multivariate check
spikes1 = SpikeTrain(
[100, 300, 400, 405, 410, 500, 700, 800, 805, 810, 815, 900], 1000)
spikes2 = SpikeTrain(
[100, 200, 205, 210, 295, 350, 400, 510, 600, 605, 700, 910], 1000)
spikes3 = SpikeTrain(
[100, 180, 198, 295, 412, 420, 510, 640, 695, 795, 820, 920], 1000)
assert_almost_equal(spk.spike_sync(spikes1, spikes2), 0.5, decimal=15)
assert_almost_equal(spk.spike_sync(spikes1, spikes3), 0.5, decimal=15)
assert_almost_equal(spk.spike_sync(spikes2, spikes3), 0.5, decimal=15)
f = spk.spike_sync_profile_multi([spikes1, spikes2, spikes3])
# hands on definition of the average multivariate spike synchronization
# expected = (f1.integral() + f2.integral() + f3.integral()) / \
# (np.sum(f1.mp[1:-1])+np.sum(f2.mp[1:-1])+np.sum(f3.mp[1:-1]))
expected = 0.5
assert_almost_equal(f.avrg(), expected, decimal=15)
assert_almost_equal(spk.spike_sync_multi([spikes1, spikes2, spikes3]),
expected,
decimal=15)
# multivariate regression test
spike_trains = spk.load_spike_trains_from_txt(os.path.join(
TEST_PATH, "SPIKE_Sync_Test.txt"),
edges=[0, 4000])
# extract all spike times
spike_times = np.array([])
for st in spike_trains:
spike_times = np.append(spike_times, st.spikes)
spike_times = np.unique(np.sort(spike_times))
f = spk.spike_sync_profile_multi(spike_trains)
assert_equal(spike_times, f.x[1:-1])
assert_equal(len(f.x), len(f.y))
assert_equal(np.sum(f.y[1:-1]), 39932)
assert_equal(np.sum(f.mp[1:-1]), 85554)
# example with 2 empty spike trains
sts = []
sts.append(SpikeTrain([1, 9], [0, 10]))
sts.append(SpikeTrain([1, 3], [0, 10]))
sts.append(SpikeTrain([], [0, 10]))
sts.append(SpikeTrain([], [0, 10]))
assert_almost_equal(spk.spike_sync_multi(sts), 1.0 / 6.0, decimal=15)
assert_almost_equal(spk.spike_sync_profile_multi(sts).avrg(),
1.0 / 6.0,
decimal=15)
def test_load_from_txt():
spike_trains = spk.load_spike_trains_from_txt(TEST_DATA, edges=(0, 4000))
assert len(spike_trains) == 40
# check the first spike train
spike_times = [64.886, 305.81, 696, 937.77, 1059.7, 1322.2, 1576.1,
1808.1, 2121.5, 2381.1, 2728.6, 2966.9, 3223.7, 3473.7,
3644.3, 3936.3]
assert_allclose(spike_times, spike_trains[0].spikes)
# check auxiliary spikes
for spike_train in spike_trains:
assert spike_train.t_start == 0.0
assert spike_train.t_end == 4000
def test_load_from_txt():
spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
edges=(0, 4000))
assert len(spike_trains) == 40
# check the first spike train
spike_times = [64.886, 305.81, 696, 937.77, 1059.7, 1322.2, 1576.1,
1808.1, 2121.5, 2381.1, 2728.6, 2966.9, 3223.7, 3473.7,
3644.3, 3936.3]
assert_equal(spike_times, spike_trains[0].spikes)
# check auxiliary spikes
for spike_train in spike_trains:
assert spike_train.t_start == 0.0
assert spike_train.t_end == 4000
def test_regression_15_isi():
# load spike trains
spike_trains = spk.load_spike_trains_from_txt(TEST_DATA, edges=[0, 4000])
N = len(spike_trains)
dist_mat = spk.isi_distance_matrix(spike_trains)
assert_allclose(dist_mat.shape, (N, N))
ind = np.arange(N // 2)
dist_mat = spk.isi_distance_matrix(spike_trains, ind)
assert_allclose(dist_mat.shape, (N // 2, N // 2))
ind = np.arange(N // 2, N)
dist_mat = spk.isi_distance_matrix(spike_trains, ind)
assert_allclose(dist_mat.shape, (N // 2, N // 2))
def test_regression_15_sync():
# load spike trains
spike_trains = spk.load_spike_trains_from_txt(TEST_DATA, edges=[0, 4000])
N = len(spike_trains)
dist_mat = spk.spike_sync_matrix(spike_trains)
assert_equal(dist_mat.shape, (N, N))
ind = np.arange(N // 2)
dist_mat = spk.spike_sync_matrix(spike_trains, ind)
assert_equal(dist_mat.shape, (N // 2, N // 2))
ind = np.arange(N // 2, N)
dist_mat = spk.spike_sync_matrix(spike_trains, ind)
assert_equal(dist_mat.shape, (N // 2, N // 2))
def test_multi_variate_subsets():
spike_trains = spk.load_spike_trains_from_txt(
os.path.join(TEST_PATH, "PySpike_testdata.txt"), (0.0, 4000.0))
sub_set = [1, 3, 5, 7]
spike_trains_sub_set = [spike_trains[i] for i in sub_set]
v1 = spk.isi_distance_multi(spike_trains_sub_set)
v2 = spk.isi_distance_multi(spike_trains, sub_set)
assert_equal(v1, v2)
v1 = spk.spike_distance_multi(spike_trains_sub_set)
v2 = spk.spike_distance_multi(spike_trains, sub_set)
assert_equal(v1, v2)
v1 = spk.spike_sync_multi(spike_trains_sub_set)
v2 = spk.spike_sync_multi(spike_trains, sub_set)
assert_equal(v1, v2)
def test_multi_variate_subsets():
spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
(0.0, 4000.0))
sub_set = [1, 3, 5, 7]
spike_trains_sub_set = [spike_trains[i] for i in sub_set]
v1 = spk.isi_distance_multi(spike_trains_sub_set)
v2 = spk.isi_distance_multi(spike_trains, sub_set)
assert_equal(v1, v2)
v1 = spk.spike_distance_multi(spike_trains_sub_set)
v2 = spk.spike_distance_multi(spike_trains, sub_set)
assert_equal(v1, v2)
v1 = spk.spike_sync_multi(spike_trains_sub_set)
v2 = spk.spike_sync_multi(spike_trains, sub_set)
assert_equal(v1, v2)
def test_merge_spike_trains():
# first load the data
spike_trains = spk.load_spike_trains_from_txt(TEST_DATA, edges=(0, 4000))
merged_spikes = spk.merge_spike_trains([spike_trains[0], spike_trains[1]])
# test if result is sorted
assert ((merged_spikes.spikes == np.sort(merged_spikes.spikes)).all())
# check merging
check_merged_spikes(merged_spikes.spikes,
[spike_trains[0].spikes, spike_trains[1].spikes])
merged_spikes = spk.merge_spike_trains(spike_trains)
# test if result is sorted
assert ((merged_spikes.spikes == np.sort(merged_spikes.spikes)).all())
# check merging
check_merged_spikes(merged_spikes.spikes,
[st.spikes for st in spike_trains])
def test_merge_spike_trains():
# first load the data
spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
edges=(0, 4000))
merged_spikes = spk.merge_spike_trains([spike_trains[0], spike_trains[1]])
# test if result is sorted
assert((merged_spikes.spikes == np.sort(merged_spikes.spikes)).all())
# check merging
check_merged_spikes(merged_spikes.spikes, [spike_trains[0].spikes,
spike_trains[1].spikes])
merged_spikes = spk.merge_spike_trains(spike_trains)
# test if result is sorted
assert((merged_spikes.spikes == np.sort(merged_spikes.spikes)).all())
# check merging
check_merged_spikes(merged_spikes.spikes,
[st.spikes for st in spike_trains])
def test_save_load():
file_name = os.path.join(tempfile.mkdtemp(prefix='pyspike_'),
"save_load.txt")
N = 10
# generate some spike trains
spike_trains = []
for n in range(N):
spike_trains.append(spk.generate_poisson_spikes(1.0, [0, 100]))
# save them into txt file
spk.save_spike_trains_to_txt(spike_trains, file_name, precision=17)
# load again
spike_trains_loaded = spk.load_spike_trains_from_txt(file_name, [0, 100])
for n in range(N):
assert_array_equal(spike_trains[n].spikes,
spike_trains_loaded[n].spikes)
def test_multi_spike_sync():
# some basic multivariate check
spikes1 = SpikeTrain([100, 300, 400, 405, 410, 500, 700, 800,
805, 810, 815, 900], 1000)
spikes2 = SpikeTrain([100, 200, 205, 210, 295, 350, 400, 510,
600, 605, 700, 910], 1000)
spikes3 = SpikeTrain([100, 180, 198, 295, 412, 420, 510, 640,
695, 795, 820, 920], 1000)
assert_almost_equal(spk.spike_sync(spikes1, spikes2),
0.5, decimal=15)
assert_almost_equal(spk.spike_sync(spikes1, spikes3),
0.5, decimal=15)
assert_almost_equal(spk.spike_sync(spikes2, spikes3),
0.5, decimal=15)
f = spk.spike_sync_profile_multi([spikes1, spikes2, spikes3])
# hands on definition of the average multivariate spike synchronization
# expected = (f1.integral() + f2.integral() + f3.integral()) / \
# (np.sum(f1.mp[1:-1])+np.sum(f2.mp[1:-1])+np.sum(f3.mp[1:-1]))
expected = 0.5
assert_almost_equal(f.avrg(), expected, decimal=15)
assert_almost_equal(spk.spike_sync_multi([spikes1, spikes2, spikes3]),
expected, decimal=15)
# multivariate regression test
spike_trains = spk.load_spike_trains_from_txt("test/SPIKE_Sync_Test.txt",
edges=[0, 4000])
# extract all spike times
spike_times = np.array([])
for st in spike_trains:
spike_times = np.append(spike_times, st.spikes)
spike_times = np.unique(np.sort(spike_times))
f = spk.spike_sync_profile_multi(spike_trains)
assert_equal(spike_times, f.x[1:-1])
assert_equal(len(f.x), len(f.y))
assert_equal(np.sum(f.y[1:-1]), 39932)
assert_equal(np.sum(f.mp[1:-1]), 85554)
# Author: Robin van Emden, http://pavlov.tech
# Affiliation: Jheronimus Academy of Data Science, http://jads.nl
#
##############################################################################################################
from __future__ import print_function
import matplotlib.pyplot as plt
import pyspike as spk
import csv
def t(l):
return [list(i) for i in zip(*l)]
spike_trains = spk.load_spike_trains_from_txt("../export/spikes.txt",
edges=(0, 420))
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.x)
# print(f.y)
# print(f.mp)
print("Average:", f.avrg())
with open('../export/spike_sync.csv', 'w') as fw:
writer = csv.writer(fw)
writer.writerows(zip(x, y))
recall = TP / (TP + FN)
F1 = 2 * (precision * recall) / (precision + recall)
#%%
sys.path.insert(0, "/home/nel/Code/VolPy/PySpike/pyspike")
sys.path.insert(0, "/home/nel/Code/VolPy/PySpike")
sys.path.insert(0, "/home/nel/Code/VolPy/PySpike/examples")
import matplotlib.pyplot as plt
import pyspike as spk
spike_trains = spk.load_spike_trains_from_txt('/home/nel/Code/VolPy/PySpike/examples/PySpike_testdata.txt',
edges=(0, 4000))
isi_profile = spk.isi_profile(spike_trains[0], spike_trains[1])
x, y = isi_profile.get_plottable_data()
plt.plot(x, y, '--k')
print("ISI distance: %.8f" % isi_profile.avrg())
plt.show()
spike_profile = spk.spike_profile(spike_trains[0], spike_trains[1])
x, y = spike_profile.get_plottable_data()
plt.plot(x, y, '--k')
print("SPIKE distance: %.8f" % spike_profile.avrg())
plt.show()
import numpy as np
from matplotlib import pyplot as plt
import pyspike as spk
from __future__ import print_function
import matplotlib.pyplot as plt
import pyspike as spk
spike_trains = spk.load_spike_trains_from_txt("../test/SPIKE_Sync_Test.txt",
edges=(0, 4000))
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.x)
print(f.y)
print(f.mp)
print("Average:", f.avrg())
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.figure()
""" averages.py
Simple example showing how to compute averages of distance profiles
Copyright 2014, Mario Mulansky <*****@*****.**>
Distributed under the BSD License
"""
from __future__ import print_function
import pyspike as spk
spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt",
time_interval=(0, 4000))
f = spk.isi_profile(spike_trains[0], spike_trains[1])
print("ISI-distance: %.8f" % f.avrg())
isi1 = f.avrg(interval=(0, 1000))
isi2 = f.avrg(interval=(1000, 2000))
isi3 = f.avrg(interval=[(0, 1000), (2000, 3000)])
isi4 = f.avrg(interval=[(1000, 2000), (3000, 4000)])
print("ISI-distance (0-1000): %.8f" % isi1)
print("ISI-distance (1000-2000): %.8f" % isi2)
print("ISI-distance (0-1000) and (2000-3000): %.8f" % isi3)
print("ISI-distance (1000-2000) and (3000-4000): %.8f" % isi4)
print()
from __future__ import print_function
import matplotlib.pyplot as plt
import pyspike as spk
spike_trains = spk.load_spike_trains_from_txt("../test/SPIKE_Sync_Test.txt",
edges=(0, 4000))
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.x)
print(f.y)
print(f.mp)
print("Average:", f.avrg())
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.figure()
plt.subplot(211)
""" averages.py
Simple example showing how to compute averages of distance profiles
Copyright 2014, Mario Mulansky <*****@*****.**>
Distributed under the BSD License
"""
from __future__ import print_function
import pyspike as spk
spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt",
edges=(0, 4000))
f = spk.isi_profile(spike_trains[0], spike_trains[1])
print("ISI-distance: %.8f" % f.avrg())
isi1 = f.avrg(interval=(0, 1000))
isi2 = f.avrg(interval=(1000, 2000))
isi3 = f.avrg(interval=[(0, 1000), (2000, 3000)])
isi4 = f.avrg(interval=[(1000, 2000), (3000, 4000)])
print("ISI-distance (0-1000): %.8f" % isi1)
print("ISI-distance (1000-2000): %.8f" % isi2)
print("ISI-distance (0-1000) and (2000-3000): %.8f" % isi3)
print("ISI-distance (1000-2000) and (3000-4000): %.8f" % isi4)
print()
S1 = createSynapses(G1,populationSize,synw,psyn,delay)
Sp1 = SpikeMonitor(G1)
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
from __future__ import print_function
import time
import pyspike as spk
def time_diff_in_ms(start, end):
""" Returns the time difference end-start in ms.
"""
return (end-start)*1000
t_start = time.clock()
# load the data
time_loading = time.clock()
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].spikes)
for i in xrange(len(spike_trains))])
print("Number of spikes: %d" % num_of_spikes)
# calculate the multivariate spike distance
f = spk.spike_profile_multi(spike_trains)
t_spike = time.clock()
# print the average
avrg = f.avrg()
print("Spike distance from average: %.8f" % avrg)
Distributed under the BSD License
"""
from __future__ import print_function
import numpy as np
import matplotlib.pyplot as plt
import pyspike as spk
import os
FOLDER_PATH = "C:\\Users\\jonat\\PycharmProjects\\PySpike\\examples\\data from brewer's lab"
DATA_PATH = os.path.join(FOLDER_PATH, "PySpike_testdata - Copy.txt")
spike_trains = spk.load_spike_trains_from_txt(DATA_PATH,
edges=(0, 4000))
print(spike_trains)
# plot the spike times
'''for (i, spike_train) in enumerate(spike_trains):
plt.scatter(spike_train, i*np.ones_like(spike_train), marker='|')'''
# profile of the first two spike trains
f = spk.isi_profile(spike_trains, indices=[0, 2])
x, y = f.get_plottable_data()
plt.figure()
plt.plot(x, np.abs(y), '-k')
print(x, y)
we want to limit the the bi-variate analysis only to neighboring electrodes from each electrode.
The electrodes are laid out in a 64x64 grid with co-ordinates as (0,0),(0,1), (0,2).....(0,63)
(1,0),(1,1),(1,2)......(1,63)
............................
The co-ordinates to number mapping is as 0,1,2,3,............63,
64,65...............127
Please see the excel sheet in the folder to get better sense of how the neighbors are selected.
'''
start_time = time.time()
spike_trains = spk.load_spike_trains_from_txt("final_interpolated.txt",
5000,
separator=" ",
is_sorted=True,
ignore_empty_lines=False)
#spike_trains = spk.load_spike_trains_from_txt("final_interpolated.txt", edges = (0,5000))
#spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt", 4000)
#print (spike_trains)
#lets load neighbor matrix and for each channel, we will only perform bi-variate isi_distance to the neighboring channels
neighbor_biocam_location = "NeighborListNew_5.csv"
row_counter = 0
with open(neighbor_biocam_location, "r") as f:
reader = csv.reader(f, delimiter=",")
data = list(reader)
#print(row_counter)
row_counter = row_counter + 1
def raster_plot(file):
spike_trains = spk.load_spike_trains_from_txt(file)
plt.figure()
for (i, spikes) in enumerate(spike_trains):
plt.plot(spikes, i * np.ones_like(spikes), 'b|')
plt.show()
