def fit_occupancy(position, place_bin_centers, model, model_kwargs,
is_track_interior):
'''
Parameters
----------
position : ndarray, shape (n_time, n_position_dims)
place_bin_centers : ndarray, shape (n_bins, n_position_dims)
model : model class
model_kwargs : dict
is_track_interior : ndarray, shape (n_bins,)
Returns
-------
occupancy : ndarray, shape (n_bins,)
occupancy_model : model class instance
'''
not_nan_position = np.all(~np.isnan(atleast_2d(position)), axis=1)
occupancy_model = model(**model_kwargs).fit(
atleast_2d(position[not_nan_position]))
occupancy = np.zeros((place_bin_centers.shape[0], ))
occupancy[is_track_interior] = np.exp(
occupancy_model.score_samples(
atleast_2d(place_bin_centers[is_track_interior])))
return occupancy, occupancy_model
def fit_marginal_model(multiunit, position, place_bin_centers, model,
model_kwargs, is_track_interior):
'''
Parameters
----------
multiunit : ndarray, shape (n_time, n_features)
position : ndarray, shape (n_time, n_position_dims)
place_bin_centers : ndarray, shape (n_bins, n_position_dims)
model : class
model_kwargs : dict
is_track_interior : ndarray, shape (n_bins,)
Returns
-------
marginal_density : ndarray, shape (n_bins,)
'''
is_spike = np.any(~np.isnan(multiunit), axis=1)
marginal_density = np.zeros((place_bin_centers.shape[0], ))
if is_spike.sum() > 0:
not_nan_position = np.all(~np.isnan(atleast_2d(position)), axis=1)
marginal_model = (model(**model_kwargs).fit(
atleast_2d(position)[is_spike & not_nan_position]))
marginal_density[is_track_interior] = np.exp(
marginal_model.score_samples(
atleast_2d(place_bin_centers[is_track_interior])))
return marginal_density
def simulate_place_field_firing_rate(means,
position,
max_rate=15,
variance=10,
is_condition=None):
'''Simulates the firing rate of a neuron with a place field at `means`.
Parameters
----------
means : ndarray, shape (n_position_dims,)
position : ndarray, shape (n_time, n_position_dims)
max_rate : float, optional
variance : float, optional
is_condition : None or ndarray, (n_time,)
Returns
-------
firing_rate : ndarray, shape (n_time,)
'''
if is_condition is None:
is_condition = np.ones(position.shape[0], dtype=bool)
position = atleast_2d(position)
firing_rate = multivariate_normal(means, variance).pdf(position)
firing_rate /= firing_rate.max()
firing_rate *= max_rate
firing_rate[~is_condition] = 0.0
return firing_rate
def empirical_movement(place_bin_centers, is_track_interior, position, edges,
is_training, replay_speed, position_extent,
movement_var, place_bin_center_ind_to_node,
distance_between_nodes):
'''Estimate the probablity of the next position based on the movement
data, given the movment is sped up by the
`replay_speed`
Place cell firing during a hippocampal replay event is a "sped-up"
version of place cell firing when the animal is actually moving.
Here we use the animal's actual movements to constrain which place
cell is likely to fire next.
Parameters
----------
position : ndarray, shape (n_time, n_position_dims)
edges : sequence
A sequence of arrays describing the bin edges along each dimension.
is_training : None or bool ndarray, shape (n_time,), optional
replay_speed : int, optional
How much the movement is sped-up during a replay event
position_extent : sequence, optional
A sequence of `n_position_dims`, each an optional (lower, upper)
tuple giving the outer bin edges for position.
An entry of None in the sequence results in the minimum and maximum
values being used for the corresponding dimension.
The default, None, is equivalent to passing a tuple of
`n_position_dims` None values.
Returns
-------
transition_matrix : ndarray, shape (n_position_bins, n_position_bins)
'''
if is_training is None:
is_training = np.ones((position.shape[0]), dtype=np.bool)
position = atleast_2d(position)[is_training]
movement_bins, _ = np.histogramdd(np.concatenate(
(position[1:], position[:-1]), axis=1),
bins=edges * 2,
range=position_extent)
original_shape = movement_bins.shape
n_position_dims = position.shape[1]
shape_2d = np.product(original_shape[:n_position_dims])
movement_bins = _normalize_row_probability(
movement_bins.reshape((shape_2d, shape_2d), order='F'))
movement_bins = np.linalg.matrix_power(movement_bins, replay_speed)
return movement_bins
def train_joint_model(multiunit, position, model, model_kwargs):
'''Fits a density model to the joint pdf of position and mark.
Parameters
----------
multiunit : ndarray, shape (n_time, n_features)
position : ndarray, shape (n_time, n_position_dims)
model : model class
model_kwargs : dict
Returns
-------
fitted_joint_model : model class instance
'''
multiunit, position = atleast_2d(multiunit), atleast_2d(position)
is_spike = (np.any(~np.isnan(multiunit), axis=1)
& np.all(~np.isnan(position), axis=1))
not_nan_marks = np.any(~np.isnan(multiunit), axis=0)
return (model(**model_kwargs).fit(
np.concatenate(
(multiunit[is_spike][:, not_nan_marks], position[is_spike]),
axis=1)))
def estimate_movement_var(position, sampling_frequency):
'''Estimates the movement variance based on position.
Parameters
----------
position : ndarray, shape (n_time, n_position_dim)
Returns
-------
movement_std : ndarray, shape (n_position_dim,)
'''
position = atleast_2d(position)
is_nan = np.any(np.isnan(position), axis=1)
position = position[~is_nan]
movement_var = np.cov(np.diff(position, axis=0), rowvar=False)
return movement_var * sampling_frequency
def fit(self,
position,
spikes,
is_training=None,
is_track_interior=None,
encoding_group_labels=None,
encoding_group_to_state=None,
track_graph=None,
edge_order=None,
edge_spacing=15):
'''
Parameters
----------
position : ndarray, shape (n_time, n_position_dims)
spikes : ndarray, shape (n_time, n_neurons)
is_training : None or bool ndarray, shape (n_time), optional
Time bins to be used for encoding.
is_track_interior : None or bool ndaarray, shape (n_x_bins, n_y_bins)
encoding_group_labels : None or ndarray, shape (n_time,)
encoding_group_to_state : None or ndarray, shape (n_states,)
track_graph : networkx.Graph
edge_order : array_like
edge_spacing : None, float or array_like
Returns
-------
self
'''
position = atleast_2d(np.asarray(position))
spikes = np.asarray(spikes)
self.fit_place_grid(position, track_graph,
edge_order, edge_spacing,
self.infer_track_interior, is_track_interior)
self.fit_initial_conditions(position)
self.fit_continuous_state_transition(
position, is_training,
continuous_transition_types=self.continuous_transition_types)
self.fit_discrete_state_transition()
self.fit_place_fields(position, spikes, is_training,
encoding_group_labels,
encoding_group_to_state)
return self
def fit(self,
position,
multiunits,
is_training=None,
is_track_interior=None,
encoding_group_labels=None,
encoding_group_to_state=None,
track_graph=None,
edge_order=None,
edge_spacing=15):
'''
Parameters
----------
position : array_like, shape (n_time, n_position_dims)
multiunits : array_like, shape (n_time, n_marks, n_electrodes)
is_training : None or array_like, shape (n_time,)
is_track_interior : None or ndarray, shape (n_x_bins, n_y_bins)
encoding_group_labels : None or ndarray, shape (n_time,)
encoding_group_to_state : None or ndarray, shape (n_states,)
track_graph : networkx.Graph
edge_order : array_like
edge_spacing : None, float or array_like
Returns
-------
self
'''
position = atleast_2d(np.asarray(position))
multiunits = np.asarray(multiunits)
self.fit_place_grid(position, track_graph,
edge_order, edge_spacing,
self.infer_track_interior, is_track_interior)
self.fit_initial_conditions(position)
self.fit_continuous_state_transition(
position, is_training,
continuous_transition_types=self.continuous_transition_types)
self.fit_discrete_state_transition()
self.fit_multiunits(position, multiunits, is_training,
encoding_group_labels, encoding_group_to_state)
return self
def fit_multiunit_likelihood_integer_no_dask(position,
multiunits,
place_bin_centers,
mark_std,
position_std,
is_track_interior=None,
**kwargs):
'''
Parameters
----------
position : ndarray, shape (n_time, n_position_dims)
multiunits : ndarray, shape (n_time, n_marks, n_electrodes)
place_bin_centers : ndarray, shape ( n_bins, n_position_dims)
model : sklearn model
model_kwargs : dict
occupancy_model : sklearn model
occupancy_kwargs : dict
is_track_interior : None or ndarray, shape (n_bins,)
Returns
-------
joint_pdf_models : list of sklearn models, shape (n_electrodes,)
ground_process_intensities : list of ndarray, shape (n_electrodes,)
occupancy : ndarray, (n_bins, n_position_dims)
mean_rates : ndarray, (n_electrodes,)
'''
if is_track_interior is None:
is_track_interior = np.ones((place_bin_centers.shape[0], ),
dtype=np.bool)
position = atleast_2d(position)
place_bin_centers = atleast_2d(place_bin_centers)
not_nan_position = np.all(~np.isnan(position), axis=1)
occupancy = np.zeros((place_bin_centers.shape[0], ))
occupancy[is_track_interior] = estimate_position_density(
place_bin_centers[is_track_interior], position[not_nan_position],
position_std)
mean_rates = []
ground_process_intensities = []
encoding_marks = []
encoding_positions = []
for multiunit in np.moveaxis(multiunits, -1, 0):
# ground process intensity
is_spike = np.any(~np.isnan(multiunit), axis=1)
mean_rates.append(is_spike.mean())
marginal_density = np.zeros((place_bin_centers.shape[0], ))
if is_spike.sum() > 0:
marginal_density[is_track_interior] = estimate_position_density(
place_bin_centers[is_track_interior],
position[is_spike & not_nan_position], position_std)
ground_process_intensities.append(
estimate_intensity(marginal_density, occupancy, mean_rates[-1]) +
np.spacing(1))
encoding_marks.append(multiunit[is_spike
& not_nan_position].astype(int))
encoding_positions.append(position[is_spike & not_nan_position])
summed_ground_process_intensity = np.sum(np.stack(
ground_process_intensities, axis=0),
axis=0,
keepdims=True)
return {
'encoding_marks': encoding_marks,
'encoding_positions': encoding_positions,
'summed_ground_process_intensity': summed_ground_process_intensity,
'occupancy': occupancy,
'mean_rates': mean_rates,
'mark_std': mark_std,
'position_std': position_std,
**kwargs,
}