def detect_epoch_ripples(epoch_key, animals, sampling_frequency, brain_areas=_BRAIN_AREAS): '''Returns a list of tuples containing the start and end times of ripples. Candidate ripples are computed via the ripple detection function and then filtered to exclude ripples where the animal was still moving. ''' logger.info('Detecting ripples') tetrode_info = make_tetrode_dataframe(animals).xs(epoch_key, drop_level=False) brain_areas = [brain_areas] if isinstance(brain_areas, str) else brain_areas is_brain_areas = tetrode_info.area.isin(brain_areas) if 'CA1' in brain_areas: is_brain_areas = is_brain_areas & (tetrode_info.descrip.isin( ['riptet']) | tetrode_info.validripple) logger.debug( tetrode_info[is_brain_areas].loc[:, ['area', 'depth', 'descrip']]) tetrode_keys = tetrode_info[is_brain_areas].index.tolist() LFPs = get_LFPs(tetrode_keys, animals) speed = get_interpolated_position_dataframe(epoch_key, animals, max_distance_from_well=5).speed not_null = np.any(pd.notnull(LFPs), axis=1) & pd.notnull(speed) return Kay_ripple_detector(LFPs.index[not_null], LFPs.values[not_null], speed.values[not_null], sampling_frequency, minimum_duration=pd.Timedelta(milliseconds=15), zscore_threshold=3)
def get_theta_times(epoch_key, sampling_frequency=1500): THETA_BAND = (6, 12) TIME_WINDOW_STEP = TIME_WINDOW_DURATION = 0.300 TIME_HALFBANDWIDTH_PRODUCT = 1 position_info = (get_interpolated_position_dataframe( epoch_key, ANIMALS).dropna(subset=['linear_position', 'speed'])) time = position_info.index tetrode_info = make_tetrode_dataframe(ANIMALS, epoch_key=epoch_key) tetrode_keys = tetrode_info.loc[tetrode_info.area == 'Reference'].index lfps = get_LFPs(tetrode_keys, ANIMALS).reindex(time) multitaper_params = dict( time_halfbandwidth_product=TIME_HALFBANDWIDTH_PRODUCT, time_window_duration=TIME_WINDOW_DURATION, time_window_step=TIME_WINDOW_STEP, start_time=(time.values / np.timedelta64(1, 's')).min(), ) df, model = detect_spectral_rhythm(time=time.values / np.timedelta64(1, 's'), lfps=lfps.values, sampling_frequency=sampling_frequency, multitaper_params=multitaper_params, frequency_band=THETA_BAND) return df.is_spectral_rhythm
def load_data(epoch_key, brain_areas=None): if brain_areas is None: brain_areas = BRAIN_AREAS time = get_trial_time(epoch_key, ANIMALS) time = (pd.Series(np.ones_like(time, dtype=np.float), index=time).resample('2ms').mean().index) def _time_function(*args, **kwargs): return time position_info = (get_interpolated_position_dataframe( epoch_key, ANIMALS, _time_function).dropna(subset=['linear_position', 'speed'])) time = position_info.index tetrode_info = make_tetrode_dataframe(ANIMALS, epoch_key=epoch_key) is_brain_areas = ( tetrode_info.area.astype(str).str.upper().isin(brain_areas)) tetrode_keys = tetrode_info.loc[is_brain_areas].index lfps = get_LFPs(tetrode_keys, ANIMALS) lfps = lfps.resample('2ms').mean().fillna(method='pad').reindex(time) try: neuron_info = make_neuron_dataframe(ANIMALS).xs(epoch_key, drop_level=False) neuron_info = neuron_info.loc[(neuron_info.numspikes > 100) & neuron_info.area.isin(brain_areas) & (neuron_info.type == 'principal')] spikes = get_all_spike_indicators(neuron_info.index, ANIMALS, _time_function).reindex(time) except KeyError: spikes = None tetrode_info = tetrode_info.loc[is_brain_areas] multiunit = (get_all_multiunit_indicators( tetrode_info.index, ANIMALS, _time_function).sel(features=_MARKS).reindex({'time': time})) multiunit_spikes = (np.any(~np.isnan(multiunit.values), axis=1)).astype(np.float) multiunit_firing_rate = pd.DataFrame(get_multiunit_population_firing_rate( multiunit_spikes, SAMPLING_FREQUENCY, smoothing_sigma=0.020), index=time, columns=['firing_rate']) return { 'position_info': position_info, 'spikes': spikes, 'multiunit': multiunit, 'lfps': lfps, 'tetrode_info': tetrode_info, 'multiunit_firing_rate': multiunit_firing_rate, 'sampling_frequency': SAMPLING_FREQUENCY, }
def load_data(epoch_key): logger.info('Loading data...') time = get_trial_time(epoch_key, ANIMALS) time = (pd.Series(np.ones_like(time, dtype=np.float), index=time).resample('2ms').mean().index) def _time_function(*args, **kwargs): return time position_info = (get_interpolated_position_dataframe( epoch_key, ANIMALS, _time_function).dropna(subset=['linear_position', 'speed'])) time = position_info.index speed = position_info['speed'] position_boundaries = get_position_boundaries(position_info) neuron_info = make_neuron_dataframe(ANIMALS).xs(epoch_key, drop_level=False) spikes = get_spikes(neuron_info, _time_function) tetrode_info = make_tetrode_dataframe(ANIMALS, epoch_key=epoch_key) track_graph, _ = make_track_graph(epoch_key, ANIMALS) logger.info('Finding multiunit high synchrony events...') adhoc_multiunit = get_adhoc_multiunit(speed, tetrode_info, _time_function) logger.info('Finding ripple times...') adhoc_ripple = get_adhoc_ripple(epoch_key, tetrode_info, time) logger.info('Estimating gamma power...') gamma_power = estimate_gamma_power(time, tetrode_info) logger.info('Estimating theta power...') theta_power = estimate_theta_power(time, tetrode_info) return { 'position_info': position_info, 'tetrode_info': tetrode_info, 'neuron_info': neuron_info, 'spikes': spikes, 'track_graph': track_graph, 'sampling_frequency': SAMPLING_FREQUENCY, **position_boundaries, **adhoc_ripple, **adhoc_multiunit, **gamma_power, **theta_power, }
def get_adhoc_ripple(epoch_key, tetrode_info, position_time): LFP_SAMPLING_FREQUENCY = 1500 position_info = ( get_interpolated_position_dataframe(epoch_key, ANIMALS) .dropna(subset=['linear_position', 'speed'])) speed = position_info['speed'] time = position_info.index if ~np.all(np.isnan(tetrode_info.validripple.astype(float))): tetrode_keys = tetrode_info.loc[ (tetrode_info.validripple == 1)].index else: is_brain_areas = ( tetrode_info.area.astype(str).str.upper().isin(BRAIN_AREAS)) tetrode_keys = tetrode_info.loc[is_brain_areas].index ripple_lfps = get_LFPs(tetrode_keys, ANIMALS).reindex(time) ripple_filtered_lfps = pd.DataFrame( np.stack([filter_ripple_band( ripple_lfps.values[:, ind], sampling_frequency=1500) for ind in np.arange(ripple_lfps.shape[1])], axis=1), index=ripple_lfps.index) ripple_times = Kay_ripple_detector( time, ripple_lfps.values, speed.values, LFP_SAMPLING_FREQUENCY, zscore_threshold=2.0, close_ripple_threshold=np.timedelta64(0, 'ms'), minimum_duration=np.timedelta64(15, 'ms')) ripple_times.index = ripple_times.index.rename('replay_number') ripple_labels = get_labels(ripple_times, position_time) is_ripple = ripple_labels > 0 ripple_times = ripple_times.assign( duration=lambda df: (df.end_time - df.start_time).dt.total_seconds()) ripple_power = estimate_ripple_band_power( ripple_lfps, LFP_SAMPLING_FREQUENCY) interpolated_ripple_power = ripple_power.interpolate() ripple_power_change = interpolated_ripple_power.transform( lambda df: df / df.mean()) ripple_power_zscore = np.log(interpolated_ripple_power).transform( lambda df: (df - df.mean()) / df.std()) return dict(ripple_times=ripple_times, ripple_labels=ripple_labels, ripple_filtered_lfps=ripple_filtered_lfps, ripple_power=ripple_power, ripple_lfps=ripple_lfps, ripple_power_change=ripple_power_change, ripple_power_zscore=ripple_power_zscore, is_ripple=is_ripple)
def get_ripple_times(epoch_key, sampling_frequency=1500, brain_areas=['CA1', 'CA2', 'CA3']): position_info = ( get_interpolated_position_dataframe(epoch_key, ANIMALS) .dropna(subset=['linear_position', 'speed'])) speed = position_info['speed'] time = position_info.index tetrode_info = make_tetrode_dataframe(ANIMALS).xs( epoch_key, drop_level=False) if ~np.all(np.isnan(tetrode_info.validripple.astype(float))): tetrode_keys = tetrode_info.loc[ (tetrode_info.validripple == 1)].index else: is_brain_areas = ( tetrode_info.area.astype(str).str.upper().isin(brain_areas)) tetrode_keys = tetrode_info.loc[is_brain_areas].index ripple_lfps = get_LFPs(tetrode_keys, ANIMALS).reindex(time) ripple_filtered_lfps = pd.DataFrame( filter_ripple_band(np.asarray(ripple_lfps)), index=ripple_lfps.index) ripple_times = Kay_ripple_detector( time, ripple_lfps.values, speed.values, sampling_frequency, zscore_threshold=2.0, close_ripple_threshold=np.timedelta64(0, 'ms'), minimum_duration=np.timedelta64(15, 'ms')) ripple_consensus_trace = pd.DataFrame( get_ripple_consensus_trace( ripple_filtered_lfps, sampling_frequency), index=ripple_filtered_lfps.index, columns=['ripple_consensus_trace']) ripple_consensus_trace_zscore = pd.DataFrame( zscore(ripple_consensus_trace, nan_policy='omit'), index=ripple_filtered_lfps.index, columns=['ripple_consensus_trace_zscore']) return (ripple_times, ripple_filtered_lfps, ripple_lfps, ripple_consensus_trace_zscore)
def get_ripple_times(epoch_key, sampling_frequency=1500, brain_areas=BRAIN_AREAS): position_info = (get_interpolated_position_dataframe( epoch_key, ANIMALS).dropna(subset=['linear_position', 'speed'])) speed = position_info['speed'] time = position_info.index tetrode_info = make_tetrode_dataframe(ANIMALS, epoch_key=epoch_key) if ~np.all(np.isnan(tetrode_info.validripple.astype(float))): tetrode_keys = tetrode_info.loc[(tetrode_info.validripple == 1)].index else: is_brain_areas = ( tetrode_info.area.astype(str).str.upper().isin(brain_areas)) tetrode_keys = tetrode_info.loc[is_brain_areas].index lfps = get_LFPs(tetrode_keys, ANIMALS).reindex(time) return Kay_ripple_detector(time, lfps.values, speed.values, sampling_frequency, zscore_threshold=2.0, close_ripple_threshold=np.timedelta64(0, 'ms'), minimum_duration=np.timedelta64(15, 'ms'))
def get_position_occupancy(epoch_key, animals, extent=(0, 300, 0, 300), gridsize=(30, 30)): position_info = get_interpolated_position_dataframe( epoch_key, animals, max_distance_from_well=5) occupancy = plt.hexbin(position_info.x_position, position_info.y_position, extent=extent, gridsize=gridsize) occupancy_count = pd.DataFrame({ 'occupancy_count': occupancy.get_array(), 'center_x': occupancy.get_offsets()[:, 0], 'center_y': occupancy.get_offsets()[:, 1], 'environment': str(make_epochs_dataframe(animals).xs(epoch_key).environment) }) (occupancy_count['animal'], occupancy_count['day'], occupancy_count['epoch']) = epoch_key return occupancy_count
def get_ripple_times2(epoch_key, sampling_frequency=1500, brain_areas=BRAIN_AREAS): RIPPLE_BAND = (150, 250) TIME_WINDOW_STEP = TIME_WINDOW_DURATION = 0.020 TIME_HALFBANDWIDTH_PRODUCT = 1 position_info = (get_interpolated_position_dataframe( epoch_key, ANIMALS).dropna(subset=['linear_distance', 'linear_speed'])) time = position_info.index tetrode_info = make_tetrode_dataframe(ANIMALS).xs(epoch_key, drop_level=False) if ~np.all(np.isnan(tetrode_info.validripple.astype(float))): tetrode_keys = tetrode_info.loc[(tetrode_info.validripple == 1)].index else: is_brain_areas = ( tetrode_info.area.astype(str).str.upper().isin(brain_areas)) tetrode_keys = tetrode_info.loc[is_brain_areas].index lfps = get_LFPs(tetrode_keys, ANIMALS).reindex(time) multitaper_params = dict( time_halfbandwidth_product=TIME_HALFBANDWIDTH_PRODUCT, time_window_duration=TIME_WINDOW_DURATION, time_window_step=TIME_WINDOW_STEP, start_time=(time.values / np.timedelta64(1, 's')).min(), ) df, model = detect_spectral_rhythm(time=time.values / np.timedelta64(1, 's'), lfps=lfps.values, sampling_frequency=sampling_frequency, multitaper_params=multitaper_params, frequency_band=RIPPLE_BAND) return df.is_spectral_rhythm
make_epochs_dataframe, make_neuron_dataframe, make_tetrode_dataframe) from src.parameters import ANIMALS epoch_info = make_epochs_dataframe(ANIMALS) epoch_key = ('HPa', 3, 2) tetrode_info = make_tetrode_dataframe(ANIMALS).xs(epoch_key, drop_level=False) tetrode_key = ('HPa', 3, 2, 4) neuron_info = make_neuron_dataframe(ANIMALS).xs(epoch_key, drop_level=False) neuron_key = ('HPa', 3, 2, 4, 3) spike = get_spike_indicator_dataframe(neuron_key, ANIMALS) position_info = get_interpolated_position_dataframe(epoch_key, ANIMALS) linear_distance = position_info['linear_distance'] x_pos = position_info['x_position'] y_pos = position_info['y_position'] speed = position_info['speed'] head_direction = position_info['head_direction'] eeg = get_LFP_dataframe(tetrode_key, ANIMALS) spike = spike.to_frame('is_spike') spike_position = spike.assign(linear_pos=linear_distance, x_position=x_pos, y_position=y_pos, speed=speed, head_direction=head_direction) spike_pos = spike_position[spike['is_spike'] == 1]
def load_data(epoch_key, brain_areas=['CA1', 'CA2', 'CA3']): time = get_trial_time(epoch_key, ANIMALS) time = (pd.Series(np.ones_like(time, dtype=np.float), index=time) .resample('2ms').mean() .index) def _time_function(*args, **kwargs): return time logger.info('Loading position info...') position_info = ( get_interpolated_position_dataframe( epoch_key, ANIMALS, _time_function) .dropna(subset=['linear_position', 'speed'])) time = position_info.index tetrode_info = make_tetrode_dataframe(ANIMALS, epoch_key=epoch_key) is_brain_areas = ( tetrode_info.area.astype(str).str.upper().isin(brain_areas)) tetrode_keys = tetrode_info.loc[is_brain_areas].index lfps = get_LFPs(tetrode_keys, ANIMALS) lfps = lfps.resample('2ms').mean().fillna(method='pad').reindex(time) logger.info('Loading spikes...') try: neuron_info = make_neuron_dataframe(ANIMALS).xs( epoch_key, drop_level=False) neuron_info = neuron_info.loc[ (neuron_info.numspikes > 100) & neuron_info.area.isin(brain_areas) & (neuron_info.type == 'principal')] spikes = get_all_spike_indicators( neuron_info.index, ANIMALS, _time_function).reindex(time) except KeyError: spikes = None logger.info('Loading multiunit...') tetrode_info = tetrode_info.loc[is_brain_areas] multiunit = (get_all_multiunit_indicators( tetrode_info.index, ANIMALS, _time_function) .reindex({'time': time})) multiunit = multiunit.sel(features=MARKS) multiunit_spikes = (np.any(~np.isnan(multiunit.values), axis=1) ).astype(np.float) multiunit_firing_rate = pd.DataFrame( get_multiunit_population_firing_rate( multiunit_spikes, SAMPLING_FREQUENCY), index=time, columns=['firing_rate']) logger.info('Finding ripple times...') (ripple_times, ripple_filtered_lfps, ripple_lfps, ripple_consensus_trace_zscore) = get_ripple_times(epoch_key) ripple_times = ripple_times.assign( duration=lambda df: (df.end_time - df.start_time).dt.total_seconds()) return { 'position_info': position_info, 'ripple_times': ripple_times, 'spikes': spikes, 'multiunit': multiunit, 'lfps': lfps, 'tetrode_info': tetrode_info, 'ripple_filtered_lfps': ripple_filtered_lfps, 'ripple_lfps': ripple_lfps, 'ripple_consensus_trace_zscore': ripple_consensus_trace_zscore, 'multiunit_firing_rate': multiunit_firing_rate, 'sampling_frequency': SAMPLING_FREQUENCY, }
def decode_ripple_clusterless(epoch_key, animals, ripple_times, sampling_frequency=1500, n_place_bins=61, place_std_deviation=None, mark_std_deviation=20, mark_names=_MARKS, brain_areas=_BRAIN_AREAS): logger.info('Decoding ripples') tetrode_info = make_tetrode_dataframe(animals).xs(epoch_key, drop_level=False) brain_areas = [brain_areas] if isinstance(brain_areas, str) else brain_areas is_brain_areas = tetrode_info.area.isin(brain_areas) brain_areas_tetrodes = tetrode_info[ is_brain_areas & ~tetrode_info.descrip.str.endswith('Ref').fillna(False) & ~tetrode_info.descrip.str.startswith('Ref').fillna(False)] logger.debug(brain_areas_tetrodes.loc[:, ['area', 'depth', 'descrip']]) position_info = get_interpolated_position_dataframe( epoch_key, animals, max_distance_from_well=5) if mark_names is None: # Use all available mark dimensions mark_names = get_multiunit_indicator_dataframe( brain_areas_tetrodes.index[0], animals).columns.tolist() mark_names = [ mark_name for mark_name in mark_names if mark_name not in ['x_position', 'y_position'] ] is_training = (position_info.speed > 4) & position_info.is_correct marks = [(get_multiunit_indicator_dataframe(tetrode_key, animals).loc[:, mark_names]) for tetrode_key in brain_areas_tetrodes.index] marks = [ tetrode_marks for tetrode_marks in marks if (tetrode_marks.loc[is_training].dropna().shape[0]) != 0 ] train_position_info = position_info.loc[is_training] training_marks = np.stack([ tetrode_marks.loc[train_position_info.index, mark_names] for tetrode_marks in marks ], axis=0) decoder = ClusterlessDecoder( train_position_info.linear_distance.values, train_position_info.task.values, training_marks, replay_speedup_factor=16, ).fit() test_marks = _get_ripple_marks(marks, ripple_times, sampling_frequency) logger.info('Predicting replay types') results = [ decoder.predict(ripple_marks, time.total_seconds()) for ripple_marks, time in test_marks ] return summarize_replay_results(results, ripple_times, position_info, epoch_key)
make_neuron_dataframe, make_tetrode_dataframe) from src.parameters import ANIMALS from time_rescale import TimeRescaling ########################## Loading Data ####################################### epoch_info = make_epochs_dataframe(ANIMALS) tetrode_info = make_tetrode_dataframe(ANIMALS) epoch_key = ('HPa', 6, 2) tetrode_key = ('HPa', 6, 2, 5) neuron_info = make_neuron_dataframe(ANIMALS) neuron_key = ('HPa', 6, 2, 5, 2) spike = get_spike_indicator_dataframe(neuron_key, ANIMALS) linear_position = get_interpolated_position_dataframe( epoch_key, ANIMALS)['linear_position'] x_pos = get_interpolated_position_dataframe(epoch_key, ANIMALS)['x_position'] y_pos = get_interpolated_position_dataframe(epoch_key, ANIMALS)['y_position'] speed = get_interpolated_position_dataframe(epoch_key, ANIMALS)['speed'] head_direction = get_interpolated_position_dataframe(epoch_key, ANIMALS)['head_direction'] spike_position = spike.assign(linear_pos=linear_position, x_position=x_pos, y_position=y_pos, speed=speed, head_direction=head_direction) spike_pos = spike_position[spike['is_spike'] == 1] ################################## Mode 0 #####################################
date = 20161114 epoch_index = ('JZ1', 1, 2) tets = [21] areas = ['ca1'] full_tetrode_info = lfdp.make_tetrode_dataframe(animals) multiunit_data = [ lfdp.get_multiunit_indicator_dataframe(tetindex, animals).values for tetindex in full_tetrode_info.xs(epoch_index, drop_level=False).query( 'area.isin(@areas) & tetrode_number.isin(@tets)').index ] position_variables = ['linear_distance', 'trajectory_direction', 'speed'] position_info = lfdp.get_interpolated_position_dataframe(epoch_index, animals) train_position_info = position_info.query('speed > 4') # marks = train_position_info.join(multiunit_data[0]) # get_trajectory_direction() trajectory_direction, is_inbound = get_trajectory_direction( position_info.linear_distance) # b = [0,trajectory_direction] decoder = replay.ClusterlessDecoder(position=position_info.linear_distance, trajectory_direction=trajectory_direction, spike_marks=multiunit_data, replay_speedup_factor=1) decoder.fit()