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()
