def estimate_spiking_likelihood(spikes, conditional_intensity,
is_track_interior=None):
'''
Parameters
----------
spikes : ndarray, shape (n_time, n_neurons)
conditional_intensity : ndarray, shape (n_bins, n_neurons)
is_track_interior : None or ndarray, optional, shape (n_x_position_bins,
n_y_position_bins)
Returns
-------
likelihood : ndarray, shape (n_time, n_bins)
'''
if is_track_interior is not None:
is_track_interior = is_track_interior.ravel(order='F')
else:
n_bins = conditional_intensity.shape[0]
is_track_interior = np.ones((n_bins,), dtype=np.bool)
log_likelihood = combined_likelihood(spikes, conditional_intensity)
mask = np.ones_like(is_track_interior, dtype=np.float)
mask[~is_track_interior] = np.nan
return scaled_likelihood(log_likelihood * mask)
def predict(self, multiunits, time=None, is_compute_acausal=True):
'''
Parameters
----------
multiunits : array_like, shape (n_time, n_marks, n_electrodes)
time : None or ndarray, shape (n_time,)
is_compute_acausal : bool, optional
Use future information to compute the posterior.
Returns
-------
results : xarray.Dataset
'''
multiunits = np.asarray(multiunits)
is_track_interior = self.is_track_interior_.ravel(order='F')
n_time = multiunits.shape[0]
n_position_bins = is_track_interior.shape[0]
st_interior_ind = np.ix_(is_track_interior, is_track_interior)
results = {}
results['likelihood'] = scaled_likelihood(
_ClUSTERLESS_ALGORITHMS[self.clusterless_algorithm][1](
multiunits=multiunits,
place_bin_centers=self.place_bin_centers_,
is_track_interior=is_track_interior,
**self.encoding_model_))
results['causal_posterior'] = np.full((n_time, n_position_bins),
np.nan)
results['causal_posterior'][:, is_track_interior] = _causal_decode(
self.initial_conditions_[is_track_interior],
self.state_transition_[st_interior_ind],
results['likelihood'][:, is_track_interior])
if is_compute_acausal:
results['acausal_posterior'] = np.full(
(n_time, n_position_bins, 1), np.nan)
results['acausal_posterior'][:, is_track_interior] = (
_acausal_decode(
results['causal_posterior'][:, is_track_interior,
np.newaxis],
self.state_transition_[st_interior_ind]))
if time is None:
time = np.arange(n_time)
return self.convert_results_to_xarray(results, time)
def estimate_multiunit_likelihood(multiunits,
place_bin_centers,
joint_pdf_models,
ground_process_intensities,
occupancy,
mean_rates,
is_track_interior=None):
'''
Parameters
----------
multiunits : ndarray, shape (n_time, n_marks, n_electrodes)
place_bin_centers : ndarray, (n_bins, n_position_dims)
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,)
Returns
-------
log_likelihood : (n_time, n_bins)
'''
if is_track_interior is None:
is_track_interior = np.ones((place_bin_centers.shape[0], ),
dtype=np.bool)
n_bin = place_bin_centers.shape[0]
n_time = multiunits.shape[0]
log_likelihood = np.zeros((n_time, n_bin))
zipped = zip(np.moveaxis(multiunits, -1, 0), joint_pdf_models, mean_rates,
ground_process_intensities)
for multiunit, joint_model, mean_rate, ground_process_intensity in zipped:
joint_mark_intensity = estimate_joint_mark_intensity(
multiunit, place_bin_centers, occupancy, joint_model, mean_rate,
is_track_interior)
log_likelihood += poisson_mark_log_likelihood(
joint_mark_intensity, np.atleast_2d(ground_process_intensity))
mask = np.ones_like(is_track_interior, dtype=np.float)
mask[~is_track_interior] = np.nan
return scaled_likelihood(log_likelihood * mask)
def predict(self, spikes, time=None, is_compute_acausal=True):
'''
Parameters
----------
spikes : ndarray, shape (n_time, n_neurons)
time : ndarray or None, shape (n_time,), optional
is_compute_acausal : bool, optional
Returns
-------
results : xarray.Dataset
'''
spikes = np.asarray(spikes)
is_track_interior = self.is_track_interior_.ravel(order='F')
n_time = spikes.shape[0]
n_position_bins = is_track_interior.shape[0]
st_interior_ind = np.ix_(is_track_interior, is_track_interior)
results = {}
results['likelihood'] = scaled_likelihood(
estimate_spiking_likelihood(spikes,
np.asarray(self.place_fields_)))
results['causal_posterior'] = np.full((n_time, n_position_bins),
np.nan)
results['causal_posterior'][:, is_track_interior] = _causal_decode(
self.initial_conditions_[is_track_interior],
self.state_transition_[st_interior_ind],
results['likelihood'][:, is_track_interior])
if is_compute_acausal:
results['acausal_posterior'] = np.full(
(n_time, n_position_bins, 1), np.nan)
results['acausal_posterior'][:, is_track_interior] = (
_acausal_decode(
results['causal_posterior'][:, is_track_interior,
np.newaxis],
self.state_transition_[st_interior_ind]))
if time is None:
time = np.arange(n_time)
return self.convert_results_to_xarray(results, time)
def predict(self, multiunits, time=None, is_compute_acausal=True,
state_names=None):
'''
Parameters
----------
multiunits : array_like, shape (n_time, n_marks, n_electrodes)
time : None or ndarray, shape (n_time,)
is_compute_acausal : bool, optional
Use future information to compute the posterior.
state_names : None or array_like, shape (n_states,)
Returns
-------
results : xarray.Dataset
'''
multiunits = np.asarray(multiunits)
is_track_interior = self.is_track_interior_.ravel(order='F')
n_time = multiunits.shape[0]
n_position_bins = is_track_interior.shape[0]
n_states = self.discrete_state_transition_.shape[0]
is_states = np.ones((n_states,), dtype=bool)
st_interior_ind = np.ix_(
is_states, is_states, is_track_interior, is_track_interior)
results = {}
likelihood = {}
for encoding_group, encoding_params in self.encoding_model_.items():
likelihood[encoding_group] = _ClUSTERLESS_ALGORITHMS[
self.clusterless_algorithm][1](
multiunits=multiunits,
place_bin_centers=self.place_bin_centers_,
is_track_interior=is_track_interior,
**encoding_params
)
results['likelihood'] = np.stack(
[likelihood[encoding_group]
for encoding_group in self.encoding_group_to_state_],
axis=1)
results['likelihood'] = scaled_likelihood(
results['likelihood'], axis=(1, 2))[..., np.newaxis]
results['causal_posterior'] = np.full(
(n_time, n_states, n_position_bins, 1), np.nan)
results['causal_posterior'][:, :, is_track_interior] = _causal_classify(
self.initial_conditions_[:, is_track_interior],
self.continuous_state_transition_[st_interior_ind],
self.discrete_state_transition_,
results['likelihood'][:, :, is_track_interior])
if is_compute_acausal:
results['acausal_posterior'] = np.full(
(n_time, n_states, n_position_bins, 1), np.nan)
results['acausal_posterior'][:, :, is_track_interior] = _acausal_classify(
results['causal_posterior'][:, :, is_track_interior],
self.continuous_state_transition_[st_interior_ind],
self.discrete_state_transition_)
if time is None:
time = np.arange(n_time)
return self.convert_results_to_xarray(results, time, state_names)
def predict(self, spikes, time=None, is_compute_acausal=True,
state_names=None):
'''
Parameters
----------
spikes : ndarray, shape (n_time, n_neurons)
time : ndarray or None, shape (n_time,), optional
is_compute_acausal : bool, optional
state_names : None or array_like, shape (n_states,)
Returns
-------
results : xarray.Dataset
'''
spikes = np.asarray(spikes)
is_track_interior = self.is_track_interior_.ravel(order='F')
n_time = spikes.shape[0]
n_position_bins = is_track_interior.shape[0]
n_states = self.discrete_state_transition_.shape[0]
is_states = np.ones((n_states,), dtype=bool)
st_interior_ind = np.ix_(
is_states, is_states, is_track_interior, is_track_interior)
results = {}
likelihood = {}
for encoding_group in np.asarray(self.place_fields_.encoding_group):
likelihood[encoding_group] = estimate_spiking_likelihood(
spikes,
np.asarray(self.place_fields_.sel(
encoding_group=encoding_group)),
is_track_interior)
results['likelihood'] = np.stack(
[likelihood[encoding_group]
for encoding_group in self.encoding_group_to_state_],
axis=1)
results['likelihood'] = scaled_likelihood(
results['likelihood'], axis=(1, 2))[..., np.newaxis]
results['causal_posterior'] = np.full(
(n_time, n_states, n_position_bins, 1), np.nan)
results['causal_posterior'][:, :, is_track_interior] = _causal_classify(
self.initial_conditions_[:, is_track_interior],
self.continuous_state_transition_[st_interior_ind],
self.discrete_state_transition_,
results['likelihood'][:, :, is_track_interior])
if is_compute_acausal:
results['acausal_posterior'] = np.full(
(n_time, n_states, n_position_bins, 1), np.nan)
results['acausal_posterior'][:, :, is_track_interior] = _acausal_classify(
results['causal_posterior'][:, :, is_track_interior],
self.continuous_state_transition_[st_interior_ind],
self.discrete_state_transition_)
n_time = spikes.shape[0]
if time is None:
time = np.arange(n_time)
return self.convert_results_to_xarray(results, time, state_names)