def load_events(session_index):
directory = session_list[session_index]["Location"]
file_path = path.join(directory, "EventMatrix.pkl")
try:
with open(file_path, 'rb') as file:
events = load(file)
_, t = ca_traces.load_traces(session_index)
except:
event_times, event_values = load_event_times(session_index)
traces, t = ca_traces.load_traces(session_index)
events = np.zeros(traces.shape)
for cell, timestamps in enumerate(event_times):
for i, this_time in enumerate(timestamps):
_, idx = find_closest(t, this_time)
events[cell, idx] = event_values[cell][i]
with open(file_path, 'wb') as file:
dump(events, file, protocol=4)
return events, t
def __init__(self, session_index, window=[-1, 10]):
self.session_index = session_index
self.frame_rate = 20
window.sort()
self.window = np.asarray(window)
assert len(self.window) is 2, "Window length must be 2."
assert any(self.window < 0), "One input must be positive."
assert any(self.window > 0), "One input must be negative."
self.ref_time = np.arange(self.window[0], self.window[1],
1 / self.frame_rate)
self.footshock_times = [698, 778, 858, 938]
traces, self.t = \
ca_traces.load_traces(session_index)
self.events, _ = ca_events.load_events(session_index)
self.traces = zscore(traces, axis=1)
self.n_neurons = len(traces)
try:
self.shock_modulated_cells, self.aligned_traces, \
self.aligned_events = load_aligned_data(session_index)
self.make_tuning_curves()
except:
self.align_neurons()
self.create_shuffle_tuning_curve()
self.find_modulated_cells()
self.order = self.organize_sequence()
def overlay_events(session_index, neurons):
"""
Plot events on top of traces.
:param
session_index: Number corresponding to a session.
neurons: List of neurons.
:return
f: ScrollPlot class.
"""
# Load events and traces.
event_times, event_values = load_event_times(session_index)
traces, t = ca_traces.load_traces(session_index)
# Plot and scroll.
titles = neuron_number_title(neurons)
f = ScrollPlot(plot_funcs.overlay_events,
t=t,
traces=traces[neurons],
event_times=event_times[neurons],
event_values=event_values[neurons],
xlabel='Time (s)',
ylabel='% DF/F',
titles=titles)
return f
def concatenate_sessions(sessions,
include_homecage=False,
dtype='traces',
global_cell_idx=None):
# Load cell map.
mouse = session_list[sessions[0]]['Animal']
match_map = cell_reg.load_cellreg_results(mouse)
if global_cell_idx is not None:
match_map = match_map[global_cell_idx]
match_map = cell_reg.trim_match_map(match_map, sessions)
neural_data = []
all_t = []
all_days = []
all_freezing = []
for idx, session in enumerate(sessions):
# Only get these neurons.
neurons = match_map[:, idx]
if not include_homecage:
data, t = load_and_trim(session, dtype=dtype, neurons=neurons)
freezing, _ = load_and_trim(session, dtype='freezing')
t -= t.min()
else:
if dtype == 'traces':
data, t = ca_traces.load_traces(session)
data = zscore(data, axis=1)
elif dtype == 'events':
data, t = ca_events.load_events(session)
else:
raise ValueError('Invalid data type.')
ff_session = ff.load_session(session)
freezing = ff_session.imaging_freezing
data = data[neurons]
all_freezing.extend(freezing)
# Day index.
day_idx = np.ones(t.size) * idx
all_days.extend(day_idx)
# Time stamps.
all_t.extend(t)
# Neural data.
neural_data.append(data)
neural_data = np.column_stack(neural_data)
all_days = np.asarray(all_days)
all_t = np.asarray(all_t)
all_freezing = np.asarray(all_freezing)
return neural_data, all_days, all_t, all_freezing
def plot_prefreezing_traces(session_index,
neurons=None,
dtype='events',
window=1):
# Load data and get freezing timestamps.
session = ff.load_session(session_index)
freeze_epochs = session.get_freezing_epochs_imaging_framerate()
if dtype == 'traces':
data, _ = ca_traces.load_traces(session_index)
data = zscore(data, axis=1)
elif dtype == 'events':
data, _ = ca_events.load_events(session_index)
data[data > 0] = 1
else:
raise ValueError("Invalid data type.")
if neurons is not None:
data = data[neurons]
titles = neuron_number_title(neurons)
else:
titles = neuron_number_title(range(len(data)))
n_neurons = len(data)
n_freezes = freeze_epochs.shape[0]
freeze_duration = np.ceil(window * 20).astype(int)
prefreezing_traces = np.zeros((n_neurons, n_freezes, freeze_duration))
for n, trace in enumerate(data):
for i, epoch in enumerate(freeze_epochs):
start = epoch[0] - freeze_duration
stop = epoch[0]
prefreezing_traces[n, i, :] = trace[start:stop]
if dtype == 'events':
events = [[(np.where(bout)[0] - freeze_duration) / 20 for bout in cell]
for cell in prefreezing_traces]
f = ScrollPlot(plot_funcs.plot_raster,
events=events,
window=window,
xlabel='Time from start of freezing (s)',
ylabel='Freezing bout #',
titles=titles)
elif dtype == 'traces':
f = ScrollPlot(plot_funcs.plot_heatmap,
heatmap=prefreezing_traces,
xlabel='Time from start of freezing (s)',
ylabel='Freezing bout #',
titles=titles)
else:
raise ValueError("Invalid data type.")
def plot_sequences_across_days(session_1, session_2, dtype='event',
mat_file='seqNMF_results.mat'):
# Get mouse name and ensure that you're matching correct animals.
mouse = session_list[session_1]["Animal"]
assert mouse == session_list[session_2]["Animal"], \
"Animal names do not match."
# Get sequence information from session 1 and traces from session 2.
s1_sequence = seqNMF(session_1, mat_file=mat_file)
if dtype == 'trace':
data, t = ca_traces.load_traces(session_2)
data = zscore(data, axis=1)
elif dtype == 'event':
data,t = ca_events.load_events(session_2)
data[data > 0] = 1
else:
raise ValueError('Wrong dtype value.')
session = ff.load_session(session_2)
# Trim and process trace information and freezing/velocity.
traces = d_pp.trim_session(data, session.mouse_in_cage)
if dtype == 'event':
events = []
for cell in traces:
events.append(np.where(cell)[0]/20)
# Get statistically significant cells in sequence and their rank.
significant_cells = s1_sequence.get_sequential_cells()
sequence_orders = s1_sequence.get_sequence_order()
# Load cell matching map.
cell_map = load_cellreg_results(mouse)
map_idx = find_match_map_index([session_1, session_2])
# For each sequence from seqNMF...
for cells, order in zip(significant_cells, sequence_orders):
# Get cell index and sort them.
global_cell_idx = find_cell_in_map(cell_map, map_idx[0], cells)
local_s2_cells = cell_map[global_cell_idx, map_idx[1]]
sorted_s2_cells = local_s2_cells[order]
# Delete cells that didn't match.
sorted_s2_cells = sorted_s2_cells[sorted_s2_cells > -1]
n_cells = len(sorted_s2_cells)
plot_ordered_cells(session_2, sorted_s2_cells, range(n_cells),
dtype=dtype)
def PCA_session(session_index, bin_length=1, dtype='traces'):
session = FF.load_session(session_index)
# Get accepted neurons.
if dtype == 'traces':
traces, t = ca_traces.load_traces(session_index)
traces = zscore(traces, axis=1)
scaler = StandardScaler()
traces = scaler.fit_transform(traces)
elif dtype == 'events':
traces, t = ca_events.load_events(session_index)
else:
raise ValueError('Wrong dtype input.')
n_neurons = len(traces)
# Trim the traces to only include instances where mouse is in the chamber.
t = d_pp.trim_session(t, session.mouse_in_cage)
traces = d_pp.trim_session(traces, session.mouse_in_cage)
freezing = d_pp.trim_session(session.imaging_freezing,
session.mouse_in_cage)
samples_per_bin = bin_length * 20
bins = d_pp.make_bins(t, samples_per_bin)
n_samples = len(bins) + 1
X = np.zeros([n_samples, n_neurons])
for n, trace in enumerate(traces):
binned_activity = d_pp.bin_time_series(trace, bins)
avg_activity = [np.mean(chunk) for chunk in binned_activity]
X[:, n] = avg_activity
binned_freezing = d_pp.bin_time_series(freezing, bins)
binned_freezing = [i.any() for i in binned_freezing]
# lda = LinearDiscriminantAnalysis(solver='eigen',n_components=2,shrinkage='auto')
# lda.fit(X,binned_freezing)
# Y = lda.transform(X)
pca = PCA(n_components=3)
pca.fit(X)
Y = pca.transform(X)
fig = plt.figure()
ax = Axes3D(fig)
s = ax.scatter(Y[:, 0], Y[:, 1], Y[:, 2], c=binned_freezing)
fig.show()
def __init__(self, session_index, dtype='event'):
self.session_index = session_index
self.dtype = dtype
if dtype == 'event':
self.events, _ = load_events(session_index)
self.events[self.events > 0] = 1
elif dtype == 'trace':
self.events, _ = load_traces(session_index)
self.session = ff.load_session(session_index)
self.freezing_epochs = \
self.session.get_freezing_epochs_imaging_framerate()
self.non_freezing_idx = self.get_non_freezing_epochs()
self.n_neurons = self.events.shape[0]
def interpolate(self):
"""
Match timestamps and position to imaging.
"""
_, imaging_t = ca_traces.load_traces(self.session_index)
x = np.interp(imaging_t, self.video_t, self.position[:, 0])
y = np.interp(imaging_t, self.video_t, self.position[:, 1])
imaging_v = np.interp(imaging_t, self.video_t, self.velocity)
imaging_freezing = np.zeros(imaging_t.shape, dtype=bool)
freezing_epochs = self.get_freezing_epochs()
# Interpolate the freezing bouts.
for this_epoch in freezing_epochs:
_, start_idx = find_closest(imaging_t, self.video_t[this_epoch[0]])
_, end_idx = find_closest(imaging_t,
self.video_t[this_epoch[1] - 1])
imaging_freezing[start_idx:end_idx] = True
return x, y, imaging_t, imaging_freezing, imaging_v
def load_and_trim(session_index, dtype='traces', neurons=None):
session = ff.load_session(session_index)
if dtype == 'traces':
data, t = ca_traces.load_traces(session_index)
data = zscore(data, axis=1)
elif dtype == 'events':
data, t = ca_events.load_events(session_index)
elif dtype == 'freezing':
data = session.imaging_freezing
t = session.imaging_t
else:
raise ValueError('Wrong data type.')
if neurons is not None:
data = data[neurons]
data = trim_session(data, session.mouse_in_cage)
t = trim_session(t, session.mouse_in_cage)
return data, t
def __init__(self, session_index, xcorr_window=[-15, 15]):
self.session_index = session_index
# Load shock-aligned cells, traces, and events.
try:
shock_cells, self.aligned_traces, self.aligned_events = \
load_aligned_data(session_index)
self.shock_cells = np.asarray(shock_cells)
except:
print("Shock-aligned traces not detected.")
# Load full traces.
traces, _ = ca_traces.load_traces(session_index)
self.n_neurons = len(traces)
# Get mouse in chamber indices.
session = ff.load_session(session_index)
self.traces = d_pp.trim_session(traces, session.mouse_in_cage)
mouse = session_list[session_index]["Animal"]
self.map = load_cellreg_results(mouse)
xcorr_window.sort()
self.xcorr_window = np.asarray(xcorr_window)
assert len(self.xcorr_window) is 2, "Window length must be 2."
assert any(self.xcorr_window < 0), "One input must be positive."
assert any(self.xcorr_window > 0), "One input must be negative."
directory = session_list[session_index]["Location"]
xcorr_file = path.join(directory, 'CrossCorrelations.pkl')
try:
with open(xcorr_file, 'rb') as file:
self.xcorrs, self.best_lags, self.window = load(file)
except:
self.xcorrs, self.best_lags, self.window = \
xcorr_all_neurons(self.traces, self.xcorr_window)
self.save_xcorrs()
def preprocess_NB(session_index, bin_length=2, predictor='traces'):
session = ff.load_session(session_index)
# Get accepted neurons.
if predictor == 'traces':
predictor_var, t = ca_traces.load_traces(session_index)
predictor_var = zscore(predictor_var, axis=1)
elif predictor == 'events':
predictor_var, t = ca_events.load_events(session_index)
predictor_var[predictor_var > 0] = 1
else:
raise ValueError('Predictor incorrectly defined.')
# Trim the traces to only include instances where mouse is in the chamber.
t = d_pp.trim_session(t, session.mouse_in_cage)
predictor_var = d_pp.trim_session(predictor_var, session.mouse_in_cage)
freezing = d_pp.trim_session(session.imaging_freezing,
session.mouse_in_cage)
# Define bin limits.
samples_per_bin = bin_length * 20
bins = d_pp.make_bins(t, samples_per_bin)
binned_activity = d_pp.bin_time_series(predictor_var, bins)
if predictor == 'traces':
X = np.mean(np.asarray(binned_activity[0:-1]), axis=2)
X = np.append(X, np.mean(binned_activity[-1], axis=1)[None, :], axis=0)
elif predictor == 'events':
X = np.sum(np.asarray(binned_activity[0:-1]), axis=2)
X = np.append(X, np.sum(binned_activity[-1], axis=1)[None, :], axis=0)
else:
raise ValueError('Invalid data type.')
# Bin freezing vector.
binned_freezing = d_pp.bin_time_series(freezing, bins)
Y = [i.any() for i in binned_freezing]
return X, Y
def plot_sequence_over_days(FC_session, test_session):
FC = ShockSequence(FC_session)
mouse = session_list[FC_session]["Animal"]
assert mouse == session_list[test_session]["Animal"], \
"Mice in sessions you're comparing are different!"
match_map = load_cellreg_results(mouse)
map_idx = find_match_map_index([FC.session_index, test_session])
shock_cells_global = find_cell_in_map(match_map, map_idx[0],
FC.shock_modulated_cells)
shock_cells_local = match_map[shock_cells_global, map_idx[1]]
shock_cells_local_sorted = shock_cells_local[FC.order]
shock_cells_local_sorted = \
shock_cells_local_sorted[shock_cells_local_sorted > 0]
traces, _ = ca_traces.load_traces(test_session)
traces = zscore(traces, axis=1)
plt.imshow(traces[shock_cells_local_sorted])
pass
def trim_and_bin(session_index,
dtype='trace',
neurons=None,
samples_per_bin=200):
session = ff.load_session(session_index)
if dtype == 'trace':
data, t = ca_traces.load_traces(session_index)
data = zscore(data, axis=1)
if neurons is not None:
data = data[neurons]
# Trim away home cage epochs.
t = trim_session(t, session.mouse_in_cage)
data = trim_session(data, session.mouse_in_cage)
# Bin time series.
bins = make_bins(t, samples_per_bin)
t = bin_time_series(t, bins)
data = bin_time_series(data, bins)
return data, t, bins
def plot_ordered_cells(session_index, cells, order=None, dtype='event'):
if order is None:
order = range(len(cells))
session = ff.load_session(session_index)
n_cells = len(cells)
if type(cells) is list:
cells = np.asarray(cells)
if dtype == 'trace':
data, t = ca_traces.load_traces(session_index)
data = zscore(data, axis=1)
elif dtype == 'event':
data, t = ca_events.load_events(session_index)
data[data > 0] = 1
else:
raise ValueError('Wrong dtype value.')
# Trim all the time series.
traces = d_pp.trim_session(data, session.mouse_in_cage)
t = d_pp.trim_session(t, session.mouse_in_cage)
t -= min(t)
v = d_pp.trim_session(session.imaging_v, session.mouse_in_cage)
freezing = d_pp.trim_session(session.imaging_freezing,
session.mouse_in_cage)
if dtype == 'event':
events = []
for cell in traces:
events.append(np.where(cell)[0]/20)
# Plot.
gs = gridspec.GridSpec(4, 1)
fig = plt.figure()
# Velocity plot.
velocity_plot = fig.add_subplot(gs[0,:])
plt.plot(t, v, 'k')
velocity_plot.set_ylabel('Velocity',color='k')
velocity_plot.fill_between(t, 0, v.max(), freezing,
facecolor='r')
plt.setp(velocity_plot.get_xticklabels(), visible=False)
# Raster plot.
event_plot = fig.add_subplot(gs[1:,0], sharex=velocity_plot)
if dtype == 'trace':
plt.imshow(traces[cells[order]],
extent=[t[0], t[-1], n_cells, 0])
elif dtype == 'event':
plt.eventplot([events[x] for
x in cells[order]])
event_plot.fill_between(t, -0.5, n_cells+0.5, freezing,
facecolor='r', alpha=0.4)
event_plot.invert_yaxis()
plt.axis('tight')
plt.xlabel('Time (s)')
plt.ylabel('Cell #')