def compute_percent_freezing(session_index, bin_length=100, plot_flag=False): session = load_ff(session_index) _, t = ca_events.load_events(session_index) t = d_pp.trim_session(t, 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) # Elapsed time in minutes. t -= t.min() t /= 60 t_binned = (bins - bins.min()) / 1200 t_binned = np.append(t_binned, t.max()) binned_freezing = d_pp.bin_time_series(freezing, bins) percent_freezing = np.zeros((len(binned_freezing))) for epoch_number, epoch in enumerate(binned_freezing): percent_freezing[epoch_number] = np.sum(epoch) / len(epoch) if plot_flag: plt.figure() plt.plot(t_binned, percent_freezing) return percent_freezing, t_binned
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 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 find_most_active(session_index, percentile): session = ff.load_session(session_index) events, _ = ca_events.load_events(session_index) events = d_pp.trim_session(events, session.mouse_in_cage) events = events > 0 n_events = [] for event in events: n_events.append(np.sum(event)) threshold = np.percentile(n_events, percentile) neurons_above_threshold = [neuron for neuron, n in enumerate(n_events) if n >= threshold] return neurons_above_threshold
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 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 detect_ramping_cells(session_index, bin_length=300): events = ca_events.load_events(session_index) session = ff.load_session(session_index) n_neurons = len(events) t = d_pp.trim_session(session.imaging_t,session.mouse_in_cage) events = d_pp.trim_session(events, session.mouse_in_cage) samples_per_bin = bin_length * 20 bins = d_pp.make_bins(t,samples_per_bin) n_samples = len(bins) + 1 binned_events = np.zeros([n_neurons, n_samples]) for n, event in enumerate(events): binned = d_pp.bin_time_series(event, bins) binned_events[n, :] = [np.sum(chunk > 0) for chunk in binned] ScrollPlot(plot_funcs.plot_traces, t=np.arange(0, len(bins) + 1), traces=binned_events) pass
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 #')