def computeAngularVelocityTuningCurves(spikes,
angle,
ep,
nb_bins=20,
bin_size=100000):
tmp = pd.Series(index=angle.index.values, data=np.unwrap(angle.values))
tmp2 = tmp.rolling(window=100,
win_type='gaussian',
center=True,
min_periods=1).mean(std=30.0)
time_bins = np.arange(tmp.index[0], tmp.index[-1] + bin_size,
bin_size) # assuming microseconds
index = np.digitize(tmp2.index.values, time_bins)
tmp3 = tmp2.groupby(index).mean()
tmp3.index = time_bins[np.unique(index) - 1] + 50000
tmp3 = nts.Tsd(tmp3)
tmp4 = np.diff(tmp3.values) / np.diff(tmp3.as_units('s').index.values)
velocity = nts.Tsd(t=tmp3.index.values[1:], d=tmp4)
velocity = velocity.restrict(ep)
bins = np.linspace(-3 * np.pi / 2, 3 * np.pi / 2, nb_bins)
idx = bins[0:-1] + np.diff(bins) / 2
velo_curves = pd.DataFrame(index=idx, columns=np.arange(len(spikes)))
for k in spikes:
spks = spikes[k]
spks = spks.restrict(ep)
speed_spike = velocity.realign(spks)
spike_count, bin_edges = np.histogram(speed_spike, bins)
occupancy, _ = np.histogram(velocity, bins)
spike_count = spike_count / (occupancy + 1)
velo_curves[k] = spike_count * (1 / (bin_size * 1e-6))
return velo_curves
def getPeaksandTroughs(lfp, min_points):
"""
At 250Hz (1250/5), 2 troughs cannont be closer than 20 (min_points) points (if theta reaches 12Hz);
"""
import neuroseries as nts
import scipy.signal
if isinstance(lfp, nts.time_series.Tsd):
troughs = nts.Tsd(lfp.as_series().iloc[scipy.signal.argrelmin(
lfp.values, order=min_points)[0]],
time_units='us')
peaks = nts.Tsd(lfp.as_series().iloc[scipy.signal.argrelmax(
lfp.values, order=min_points)[0]],
time_units='us')
tmp = nts.Tsd(
troughs.realign(peaks, align='next').as_series().drop_duplicates(
'first')) # eliminate double peaks
peaks = peaks[tmp.index]
tmp = nts.Tsd(
peaks.realign(troughs, align='prev').as_series().drop_duplicates(
'first')) # eliminate double troughs
troughs = troughs[tmp.index]
return (peaks, troughs)
elif isinstance(lfp, nts.time_series.TsdFrame):
peaks = nts.TsdFrame(lfp.index.values, np.zeros(lfp.shape))
troughs = nts.TsdFrame(lfp.index.values, np.zeros(lfp.shape))
for i in lfp.keys():
peaks[i], troughs[i] = getPeaksandTroughs(lfp[i], min_points)
return (peaks, troughs)
def hilbert(lfp, deg=False):
"""
lfp : lfp as an nts.Tsd
return
power : nts.Tsd
phase : nts.Tsd
"""
xa = scipy.signal.hilbert(lfp)
power = nts.Tsd(np.array(lfp.index), np.abs(xa)**2)
phase = nts.Tsd(np.array(lfp.index), np.angle(xa, deg=deg))
return power, phase
def aucorr_plot(data, nbins, binsize, epochstr, path2save):
"""Plot autocorrelogram"""
from matplotlib.pyplot import hlines as hlines
plt.figure(figsize=(12, 8))
#plt.plot(aucorr) # Plot the raw version
times = np.arange(0, binsize *
(nbins + 1), binsize) - (nbins * binsize) / 2
data = nts.Tsd(t=times, d=data, time_units='ms')
plt.plot(data.as_units('ms')) # Plot the smoothed version
plt.title("Autocorrelogram")
plt.xlabel("time (ms)")
#middle horizontal line
#hlines (meanfiring, 0, nbins, 'g', label = 'mean firing rate')
hlines(data.max() / 2,
0 - nbins * binsize / 2,
nbins * binsize / 2,
'r',
label='half point')
if path2save == 'a':
autocorrelogram = './plots/' + 'autocorrelogram_' + str(
neuro_num) + '_' + epochstr + '.pdf'
elif path2save == 'b':
autocorrelogram = r'cd /home/grvite/Dropbox (Peyrache Lab)/Peyrache Lab Team Folder/Projects/DreamSpeed - Gilberto/figs/' + 'autocorrelogram_' + str(
neuro_num) + '_' + epochstr + '.pdf'
plt.savefig(autocorrelogram)
def smooth_corr(aucorr,
nbins,
binsize,
meanfiring,
window=7,
stdv=5.0,
plot=False):
aucorr = aucorr - meanfiring
dfa = aucorr[0:int(nbins / 2)]
dfa = pd.DataFrame(dfa).rolling(window=window,
win_type='gaussian',
center=True,
min_periods=1).mean(std=stdv)
dfb = np.flipud(aucorr[int(nbins / 2) + 1::])
dfb = pd.DataFrame(dfb).rolling(window=window,
win_type='gaussian',
center=True,
min_periods=1).mean(std=stdv)
#array = np.append((dfa.values),0)
arrayt = np.append(np.append((dfa.values), 0), np.flipud(dfb.values))
if plot == True:
#Make a Tsd
times = np.arange(0, binsize *
(nbins + 1), binsize) - (nbins * binsize) / 2
ndf = nts.Tsd(t=times, d=arrayt / meanfiring)
ndf.plot()
return arrayt
def lfp(start,
stop,
n_channels=90,
channel=64,
frequency=1250.0,
precision='int16',
verbose=False):
p = session + ".lfp"
if verbose:
print('Load LFP from ' + p)
# From Guillaume viejo
import neuroseries as nts
bytes_size = 2
start_index = int(start * frequency * n_channels * bytes_size)
stop_index = int(stop * frequency * n_channels * bytes_size)
#In order not to read after the file
if stop_index > os.path.getsize(p): stop_index = os.path.getsize(p)
fp = np.memmap(p,
np.int16,
'r',
start_index,
shape=(stop_index - start_index) // bytes_size)
data = np.array(fp).reshape(len(fp) // n_channels, n_channels)
if type(channel) is not list:
timestep = np.arange(0, len(data)) / frequency + start
return nts.Tsd(timestep, data[:, channel], time_units='s')
elif type(channel) is list:
timestep = np.arange(0, len(data)) / frequency + start
return nts.TsdFrame(timestep, data[:, channel], time_units='s')
def computeSpeedTuningCurves(spikes,
position,
ep,
bin_size=0.1,
nb_bins=20,
speed_max=0.4):
time_bins = np.arange(position.index[0],
position.index[-1] + bin_size * 1e6, bin_size * 1e6)
index = np.digitize(position.index.values, time_bins)
tmp = position.groupby(index).mean()
tmp.index = time_bins[np.unique(index) - 1] + (bin_size * 1e6) / 2
distance = np.sqrt(
np.power(np.diff(tmp['x']), 2) + np.power(np.diff(tmp['z']), 2))
speed = nts.Tsd(t=tmp.index.values[0:-1] + bin_size / 2,
d=distance / bin_size)
speed = speed.restrict(ep)
bins = np.linspace(0, speed_max, nb_bins)
idx = bins[0:-1] + np.diff(bins) / 2
speed_curves = pd.DataFrame(index=idx, columns=np.arange(len(spikes)))
for k in spikes:
spks = spikes[k]
spks = spks.restrict(ep)
speed_spike = speed.realign(spks)
spike_count, bin_edges = np.histogram(speed_spike, bins)
occupancy, _ = np.histogram(speed, bins)
spike_count = spike_count / (occupancy + 1)
speed_curves[k] = spike_count / bin_size
return speed_curves
def loadLFP(path,
n_channels=90,
channel=64,
frequency=1250.0,
precision='int16'):
import neuroseries as nts
if type(channel) is not list:
f = open(path, 'rb')
startoffile = f.seek(0, 0)
endoffile = f.seek(0, 2)
bytes_size = 2
n_samples = int((endoffile - startoffile) / n_channels / bytes_size)
duration = n_samples / frequency
interval = 1 / frequency
f.close()
with open(path, 'rb') as f:
data = np.fromfile(f, np.int16).reshape(
(n_samples, n_channels))[:, channel]
timestep = np.arange(0, len(data)) / frequency
return nts.Tsd(timestep, data, time_units='s')
elif type(channel) is list:
f = open(path, 'rb')
startoffile = f.seek(0, 0)
endoffile = f.seek(0, 2)
bytes_size = 2
n_samples = int((endoffile - startoffile) / n_channels / bytes_size)
duration = n_samples / frequency
f.close()
with open(path, 'rb') as f:
data = np.fromfile(f, np.int16).reshape(
(n_samples, n_channels))[:, channel]
timestep = np.arange(0, len(data)) / frequency
return nts.TsdFrame(timestep, data, time_units='s')
def computeAngularVelocity(spikes, angle, ep, nb_bins=20, bin_size=100000):
tmp = pd.Series(index=angle.index.values, data=np.unwrap(angle.values))
tmp2 = tmp.rolling(window=100,
win_type='gaussian',
center=True,
min_periods=1).mean(std=30.0)
time_bins = np.arange(tmp.index[0], tmp.index[-1] + bin_size,
bin_size) # assuming microseconds
index = np.digitize(tmp2.index.values, time_bins)
tmp3 = tmp2.groupby(index).mean()
tmp3.index = time_bins[np.unique(index) - 1] + 50000
tmp3 = nts.Tsd(tmp3)
tmp4 = np.diff(tmp3.values) / np.diff(tmp3.as_units('s').index.values)
velocity = nts.Tsd(t=tmp3.index.values[1:], d=tmp4)
velocity = velocity.restrict(ep)
return velocity
def computeFrateAng(spikes, angle, ep, nb_bins=180, frequency=120.0):
'''Computes the ang tcurves without normalising to occupancy.
It will essentiall give you the total spike count for each angular position
'''
bins = np.linspace(0, 2 * np.pi, nb_bins)
idx = bins[0:-1] + np.diff(bins) / 2
tuning_curves = pd.DataFrame(index=idx, columns=np.arange(len(spikes)))
angle = angle.restrict(ep)
# Smoothing the angle here
tmp = pd.Series(index=angle.index.values, data=np.unwrap(angle.values))
tmp2 = tmp.rolling(window=50,
win_type='gaussian',
center=True,
min_periods=1).mean(std=10.0)
angle = nts.Tsd(tmp2 % (2 * np.pi))
for k in spikes:
spks = spikes[k]
# true_ep = nts.IntervalSet(start = np.maximum(angle.index[0], spks.index[0]), end = np.minimum(angle.index[-1], spks.index[-1]))
spks = spks.restrict(ep)
angle_spike = angle.restrict(ep).realign(spks)
spike_count, bin_edges = np.histogram(angle_spike, bins)
occupancy, _ = np.histogram(angle, bins)
tuning_curves[k] = spike_count
return tuning_curves
def nts_smooth(y, m, std):
g = scipy.signal.gaussian(m, std)
g = g / g.sum()
conv = np.convolve(y.values, g, 'same')
y = nts.Tsd(y.index.values, conv)
return y
def smoothAngle(tsd, sd):
tmp = pd.Series(index=tsd.index.values, data=np.unwrap(tsd.values))
tmp2 = tmp.rolling(window=100,
win_type='gaussian',
center=True,
min_periods=1).mean(std=sd)
newtsd = nts.Tsd(tmp2 % (2 * np.pi))
return newtsd
def computeAngularTuningCurves_dat(spikes,
angle,
ep,
nb_bins=180,
frequency=120.0,
bin_size=100):
tmp = pd.Series(index=angle.index.values, data=np.unwrap(angle.values))
tmp2 = tmp.rolling(window=50,
win_type='gaussian',
center=True,
min_periods=1).mean(std=10.0)
bin_size = bin_size * 1000
time_bins = np.arange(tmp.index[0], tmp.index[-1] + bin_size,
bin_size) # assuming microseconds
index = np.digitize(tmp2.index.values, time_bins)
tmp3 = tmp2.groupby(index).mean()
tmp3.index = time_bins[np.unique(index) - 1] + bin_size / 2
tmp3 = nts.Tsd(tmp3)
tmp4 = np.diff(tmp3.values) / np.diff(tmp3.as_units('s').index.values)
newangle = nts.Tsd(t=tmp3.index.values, d=tmp3.values % (2 * np.pi))
velocity = nts.Tsd(t=tmp3.index.values[1:], d=tmp4)
velocity = velocity.restrict(ep)
velo_spikes = {}
#for k in spikes: velo_spikes[k] = velocity.realign(spikes[k].restrict(ep))
#bins_velocity = np.array([velocity.min(), -2*np.pi/3, -np.pi/6, np.pi/6, 2*np.pi/3, velocity.max()+0.001])
#idx_velocity = {k:np.digitize(velo_spikes[k].values, bins_velocity)-1 for k in spikes}
bins = np.linspace(0, 2 * np.pi, nb_bins)
idx = bins[0:-1] + np.diff(bins) / 2
tuning_curves = {
i: pd.DataFrame(index=idx, columns=np.arange(len(spikes)))
for i in range(3)
}
for i, j in zip(range(3), range(0, 6, 2)):
for k in spikes:
spks = spikes[k].restrict(ep)
#spks = spks[idx_velocity[k] == j]
angle_spike = newangle.restrict(ep).realign(spks)
spike_count, bin_edges = np.histogram(angle_spike, bins)
#tmp = newangle.loc[velocity.index[np.logical_and(velocity.values>bins_velocity[j], velocity.values<bins_velocity[j+1])]]
occupancy, _ = np.histogram(tmp, bins)
spike_count = spike_count / occupancy
tuning_curves[i][k] = spike_count * (1 / (bin_size * 1e-6))
return tuning_curves, velocity, bins_velocity
def firetdisco(hd_spikes, neuro_num, epoch):
"""
# epoch means we need to use the object nts.IntervalSet
# The interval are contained in the file : Mouse12-120806_ArenaEpoch.txt
new_data = np.genfromtxt(data_directory+'Mouse12-120806_ArenaEpoch.txt')
# We can integrate it in nts:
exploration = nts.IntervalSet(start = new_data[:,0], end = new_data[:,1], time_units = 's')
"""
# Next step is to compute an average firing rate for one neuron
# Let's take neuron
my_neuron = hd_spikes[neuro_num]
# To speed up computation, we can restrict the time of spikes
my_neuron = my_neuron.restrict(epoch)
first_spike = my_neuron.index[0]
last_spike = my_neuron.index[-1]
#Determine bin size in us
bin_size = 1000000 # = 1s
# Observe the -1 for the value at the end of an array
duration = last_spike - first_spike
# it's the time of the last spike
# with a bin size of 1 second, the number of points is
nb_points = duration / bin_size
nb_points = int(nb_points)
#Determine the bins of your data and apply digitize to get a classification index
bins = np.arange(first_spike, last_spike, bin_size)
index = np.digitize(my_neuron.index.values, bins, right=False)
#Create a pd
df_n = pd.DataFrame(index=index)
df_n['firing_time'] = my_neuron.index.values
#count the number of spikes per bin
df_n_grouped = df_n.groupby(df_n.index).size().reset_index(name='counts')
df_n_grouped.set_index('index', inplace=True)
#generate the real index
df_comp = pd.DataFrame(index=range(1, np.unique(index)[-1] + 1))
#put that index in your df
df_cn = df_comp.combine_first(df_n_grouped)
df_cn.set_index(bins, inplace=True)
#fill with 0 for the na values
df_cn.fillna(0, inplace=True)
#generate a Tsd with the data
spike_count = nts.Tsd(t=bins + (bin_size / 2.), d=df_cn['counts'].values)
#change units to spikes per second = firing rate
firing_rate = nts.Tsd(t=bins + (bin_size / 2.),
d=spike_count.values / (bin_size / 1000. / 1000.))
return first_spike, last_spike, bin_size, bins, firing_rate
def lfp(
channel,
start=0,
stop=1e8,
fs=1250.0,
n_channels_local=None,
precision=np.int16,
dat=False,
verbose=False,
memmap=False,
p=None,
volt_step=0.195,
):
if (np.isnan(channel)) or (channel is None):
return None
if p is None:
p = session + ".lfp"
if dat:
p = session + ".dat"
if n_channels_local is None:
n_channels = xml()["nChannels"]
else:
n_channels = n_channels_local
if verbose:
print("Load data from " + p)
print(f"File contains {n_channels} channels")
# From Guillaume viejo
import neuroseries as nts
bytes_size = 2
start_index = int(start * fs * n_channels * bytes_size)
stop_index = int(stop * fs * n_channels * bytes_size)
# In order not to read after the file
if stop_index > os.path.getsize(p):
stop_index = os.path.getsize(p)
fp = np.memmap(p,
precision,
"r",
start_index,
shape=(stop_index - start_index) // bytes_size)
if memmap == True:
print("/!\ memmap is not compatible with volt_step /!\ ")
return fp.reshape(-1, n_channels)[:, channel]
data = np.array(fp).reshape(len(fp) // n_channels, n_channels) * volt_step
if type(channel) is not list:
timestep = np.arange(0, len(data)) / fs + start
return nts.Tsd(timestep, data[:, channel], time_units="s")
elif type(channel) is list:
timestep = np.arange(0, len(data)) / fs + start
return nts.TsdFrame(timestep, data[:, channel], time_units="s")
def compute_score(ep_pop, eigen):
ep_pop = ep_pop - ep_pop.mean(0)
ep_pop = ep_pop / (ep_pop.std(0) + 1e-8)
a = ep_pop.values
score = np.zeros(len(ep_pop))
for i in range(len(eigen)):
score += np.dot(a, eigen[i])**2.0 - np.dot(
a**2.0, eigen[i]**2.0)
score = nts.Tsd(t=ep_pop.index.values, d=score)
return score
def old_speed(pos,value_gaussian_filter,pixel = 0.43):
x_speed = np.diff(pos.as_units('s')['x'])/np.diff(pos.as_units('s').index)
y_speed = np.diff(pos.as_units('s')['y'])/np.diff(pos.as_units('s').index)
v = np.sqrt(x_speed**2 + y_speed**2)*pixel
v = scipy.ndimage.gaussian_filter1d(v,value_gaussian_filter,axis=0)
v = nts.Tsd(t = pos.index.values[:-1],d = v)
return v
def getPhase(lfp, fmin, fmax, nbins, fsamp, power=False):
""" Continuous Wavelets Transform
return phase of lfp in a Tsd array
"""
import neuroseries as nts
from Wavelets import MyMorlet as Morlet
if isinstance(lfp, nts.time_series.TsdFrame):
allphase = nts.TsdFrame(lfp.index.values, np.zeros(lfp.shape))
allpwr = nts.TsdFrame(lfp.index.values, np.zeros(lfp.shape))
for i in lfp.keys():
allphase[i], allpwr[i] = getPhase(lfp[i],
fmin,
fmax,
nbins,
fsamp,
power=True)
if power:
return allphase, allpwr
else:
return allphase
elif isinstance(lfp, nts.time_series.Tsd):
cw = Morlet(lfp.values, fmin, fmax, nbins, fsamp)
cwt = cw.getdata()
cwt = np.flip(cwt, axis=0)
wave = np.abs(cwt)**2.0
phases = np.arctan2(np.imag(cwt), np.real(cwt)).transpose()
cwt = None
index = np.argmax(wave, 0)
# memory problem here, need to loop
phase = np.zeros(len(index))
for i in range(len(index)):
phase[i] = phases[i, index[i]]
phases = None
if power:
pwrs = cw.getpower()
pwr = np.zeros(len(index))
for i in range(len(index)):
pwr[i] = pwrs[index[i], i]
return nts.Tsd(lfp.index.values,
phase), nts.Tsd(lfp.index.values, pwr)
else:
return nts.Tsd(lfp.index.values, phase)
def loadTheta(path):
import scipy.io
import neuroseries as nts
thetaInfo = scipy.io.loadmat(path)
troughs = nts.Tsd(thetaInfo['thetaTrghs'][0][0][2].flatten(),
thetaInfo['thetaTrghs'][0][0][3].flatten(),
time_units='s')
peaks = nts.Tsd(thetaInfo['thetaPks'][0][0][2].flatten(),
thetaInfo['thetaPks'][0][0][3].flatten(),
time_units='s')
good_ep = nts.IntervalSet(thetaInfo['goodEp'][0][0][1],
thetaInfo['goodEp'][0][0][2],
time_units='s')
tmp = (good_ep.as_units('s')['end'].iloc[-1] -
good_ep.as_units('s')['start'].iloc[0])
if (tmp / 60.) / 60. > 20.: # VERY BAD
good_ep = nts.IntervalSet(good_ep.as_units('s')['start'] * 0.0001,
good_ep.as_units('s')['end'] * 0.0001,
time_units='s')
return good_ep
def computeSpeed(position, ep, bin_size=0.1):
time_bins = np.arange(position.index[0],
position.index[-1] + bin_size * 1e6, bin_size * 1e6)
index = np.digitize(position.index.values, time_bins)
tmp = position.groupby(index).mean()
tmp.index = time_bins[np.unique(index) - 1] + (bin_size * 1e6) / 2
distance = np.sqrt(
np.power(np.diff(tmp['x']), 2) + np.power(np.diff(tmp['z']), 2))
speed = nts.Tsd(t=tmp.index.values[0:-1] + bin_size / 2,
d=distance / bin_size)
speed = speed.restrict(ep)
return speed
def getFiringRate(tsd_spike, bins):
"""bins shoud be in us
"""
import neuroseries as nts
frate = nts.Tsd(bins, np.zeros(len(bins)))
bins_size = (bins[1] - bins[0]) * 1.e-6 # convert to s for Hz
if type(tsd_spike) is dict:
for n in tsd_spike.keys():
index = np.digitize(tsd_spike[n].index.values, bins)
for i in index:
frate[bins[i]] += 1.0
frate = nts.Tsd(bins + (bins[1] - bins[0]) / 2,
frate.values / len(tsd_spike) / bins_size)
return frate
else:
index = np.digitize(tsd_spike.index.values, bins)
for i in index:
frate[bins[i]] += 1.0
frate = nts.Tsd(bins + (bins[1] - bins[0]) / 2,
frate.values / bins_size)
return frate
def downsample(tsd, up, down):
import scipy.signal
import neuroseries as nts
dtsd = scipy.signal.resample_poly(tsd.values, up, down)
dt = tsd.as_units('s').index.values[np.arange(0, tsd.shape[0], down)]
if len(tsd.shape) == 1:
return nts.Tsd(dt, dtsd, time_units='s')
elif len(tsd.shape) == 2:
return nts.TsdFrame(dt,
dtsd,
time_units='s',
columns=list(tsd.columns))
def test_times_data(self):
"""
tests the times and data properties
"""
a = np.random.randint(0, 10000000, 100)
a.sort()
b = np.random.randn(100)
t = nts.Tsd(a, b)
np.testing.assert_array_almost_equal_nulp(b, t.data())
np.testing.assert_array_almost_equal_nulp(a, t.times())
np.testing.assert_array_almost_equal_nulp(a/1000., t.times(units=nts.milliseconds))
np.testing.assert_array_almost_equal_nulp(a/1.0e6, t.times(units=nts.seconds))
with self.assertRaises(ValueError):
t.times(units=nts.TimeUnits('banana'))
def decodeHD(tuning_curves, spikes, ep, bin_size=200, px=None):
"""
See : Zhang, 1998, Interpreting Neuronal Population Activity by Reconstruction: Unified Framework With Application to Hippocampal Place Cells
tuning_curves: pd.DataFrame with angular position as index and columns as neuron
spikes : dictionnary of spike times
ep : nts.IntervalSet, the epochs for decoding
bin_size : in ms (default:200ms)
px : Occupancy. If None, px is uniform
"""
if len(ep) == 1:
bins = np.arange(
ep.as_units('ms').start.iloc[0],
ep.as_units('ms').end.iloc[-1], bin_size)
else:
print("TODO, more than one epoch")
sys.exit()
spike_counts = pd.DataFrame(index=bins[0:-1] + np.diff(bins) / 2,
columns=spikes.keys())
for k in spikes:
spks = spikes[k].restrict(ep).as_units('ms').index.values
spike_counts[k], _ = np.histogram(spks, bins)
print(spike_counts.columns.values)
print(tuning_curves.columns.values)
tcurves_array = tuning_curves.values
spike_counts_array = spike_counts.values
proba_angle = np.zeros((spike_counts.shape[0], tuning_curves.shape[0]))
part1 = np.exp(-(bin_size / 1000) * tcurves_array.sum(1))
if px is not None:
part2 = px
else:
part2 = np.ones(tuning_curves.shape[0])
# part2 = np.histogram(position['ry'], np.linspace(0, 2*np.pi, 61), weights = np.ones_like(position['ry'])/float(len(position['ry'])))[0]
for i in range(len(proba_angle)):
part3 = np.prod(tcurves_array**spike_counts_array[i], 1)
p = part1 * part2 * part3
proba_angle[i] = p / p.sum() # Normalization process here
proba_angle = pd.DataFrame(index=spike_counts.index.values,
columns=tuning_curves.index.values,
data=proba_angle)
proba_angle = proba_angle.astype('float')
decoded = nts.Tsd(t=proba_angle.index.values,
d=proba_angle.idxmax(1).values,
time_units='ms')
return decoded, proba_angle
def setUp(self):
from scipy.io import loadmat
self.mat_data1 = loadmat(
os.path.join(nts.get_test_data_dir(), 'interval_set_data_1.mat'))
self.a1 = self.mat_data1['a1'].ravel()
self.b1 = self.mat_data1['b1'].ravel()
self.int1 = nts.IntervalSet(self.a1, self.b1, expect_fix=True)
self.a2 = self.mat_data1['a2'].ravel()
self.b2 = self.mat_data1['b2'].ravel()
self.int2 = nts.IntervalSet(self.a2, self.b2, expect_fix=True)
self.tsd_t = self.mat_data1['t'].ravel()
self.tsd_d = self.mat_data1['d'].ravel()
self.tsd = nts.Tsd(self.tsd_t, self.tsd_d)
def lfp_in_intervals(channel, intervals):
t = np.array([])
lfps = np.array([])
for start, stop in zip(
intervals.as_units("s").start,
intervals.as_units("s").end):
start = np.round(start, decimals=1)
stop = np.round(stop, decimals=1)
lfp = bk.load.lfp(channel, start, stop)
t = np.append(t, lfp.index)
lfps = np.append(lfps, lfp.values)
lfps = nts.Tsd(t, lfps)
return lfps
def refineSleepFromAccel(acceleration, sleep_ep):
vl = acceleration[0].restrict(sleep_ep)
vl = vl.as_series().diff().abs().dropna()
a, _ = scipy.signal.find_peaks(vl, 0.025)
peaks = nts.Tsd(vl.iloc[a])
duration = np.diff(peaks.as_units('s').index.values)
interval = nts.IntervalSet(start=peaks.index.values[0:-1],
end=peaks.index.values[1:])
newsleep_ep = interval.iloc[duration > 15.0]
newsleep_ep = newsleep_ep.reset_index(drop=True)
newsleep_ep = newsleep_ep.merge_close_intervals(100000, time_units='us')
#newsleep_ep = sleep_ep.intersect(newsleep_ep)
return newsleep_ep
def computeAngularTuningCurves(spikes,
angle,
ep,
nb_bins=180,
frequency=120.0):
bins = np.linspace(0, 2 * np.pi, nb_bins)
idx = bins[0:-1] + np.diff(bins) / 2
tuning_curves = pd.DataFrame(index=idx, columns=np.arange(len(spikes)))
angle = angle.restrict(ep)
# Smoothing the angle here
tmp = pd.Series(index=angle.index.values, data=np.unwrap(angle.values))
tmp2 = tmp.rolling(window=50,
win_type='gaussian',
center=True,
min_periods=1).mean(std=10.0)
angle = nts.Tsd(tmp2 % (2 * np.pi))
for k in spikes:
spks = spikes[k]
# true_ep = nts.IntervalSet(start = np.maximum(angle.index[0], spks.index[0]), end = np.minimum(angle.index[-1], spks.index[-1]))
spks = spks.restrict(ep)
angle_spike = angle.restrict(ep).realign(spks)
spike_count, bin_edges = np.histogram(angle_spike, bins)
occupancy, _ = np.histogram(angle, bins)
spike_count = spike_count / occupancy
tuning_curves[k] = spike_count * frequency
tcurves = tuning_curves[k]
padded = pd.Series(index=np.hstack(
(tcurves.index.values - (2 * np.pi), tcurves.index.values,
tcurves.index.values + (2 * np.pi))),
data=np.hstack((tcurves.values, tcurves.values,
tcurves.values)))
smoothed = padded.rolling(window=20,
win_type='gaussian',
center=True,
min_periods=1).mean(std=3.0)
tuning_curves[k] = smoothed[tcurves.index]
return tuning_curves
def decoding_overlap(tuning_curves, bin_size, spikes, neuron_order, t, px):
#My way of defining overlapping bins
#bin_size = 40 # ms
bins = np.arange(0, 2000+2*bin_size, bin_size) - 1000 - bin_size/2
obins = np.vstack((bins-bin_size/2,bins)).T.flatten()
obins = np.vstack((obins,obins+bin_size)).T
times = obins[:,0]+(np.diff(obins)/2).flatten()
# My function to compute the histogram
def histo(spk, obins):
n = len(obins)
count = np.zeros(n)
for i in range(n):
count[i] = np.sum((spk>obins[i,0]) * (spk < obins[i,1]))
return count
# When I do the binning for one SWR time t
spike_counts = pd.DataFrame(index = times, columns = neuron_order)
tbins = t + obins
for k in neuron_order:
spike_counts[k] = histo(spikes[k].as_units('ms').index.values, tbins)
tcurves_array = tuning_curves.values
spike_counts_array = spike_counts.values
proba_angle = np.zeros((spike_counts.shape[0], tuning_curves.shape[0]))
part1 = np.exp(-(bin_size/1000)*tcurves_array.sum(1))
part2 = px
for i in range(len(proba_angle)):
part3 = np.prod(tcurves_array**spike_counts_array[i], 1)
p = part1 * part2 * part3
proba_angle[i] = p/p.sum() #Normalization process here
#print(spike_counts)
proba_angle = pd.DataFrame(index = spike_counts.index.values, columns = tuning_curves.index.values, data= proba_angle)
# proba_angle = proba_angle.astype('float')
decoded = nts.Tsd(t = proba_angle.index.values, d = proba_angle.idxmax(1).values, time_units = 'ms')
return decoded, proba_angle
def loadLFP(path,
n_channels=90,
channel=64,
frequency=1250.0,
precision="int16"):
"""
LEGACY
"""
# From Guillaume Viejo
import neuroseries as nts
if type(channel) is not list:
f = open(path, "rb")
startoffile = f.seek(0, 0)
endoffile = f.seek(0, 2)
bytes_size = 2
n_samples = int((endoffile - startoffile) / n_channels / bytes_size)
duration = n_samples / frequency
interval = 1 / frequency
f.close()
with open(path, "rb") as f:
print("opening")
data = np.fromfile(f, np.int16).reshape(
(n_samples, n_channels))[:, channel]
timestep = np.arange(0, len(data)) / frequency
return nts.Tsd(timestep, data, time_units="s")
elif type(channel) is list:
f = open(path, "rb")
startoffile = f.seek(0, 0)
endoffile = f.seek(0, 2)
bytes_size = 2
n_samples = int((endoffile - startoffile) / n_channels / bytes_size)
duration = n_samples / frequency
f.close()
with open(path, "rb") as f:
data = np.fromfile(f, np.int16).reshape(
(n_samples, n_channels))[:, channel]
timestep = np.arange(0, len(data)) / frequency
return nts.TsdFrame(timestep, data, time_units="s")
