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 predict(
self,
position,
multiunits,
time=None,
is_compute_acausal=True,
set_no_spike_to_equally_likely=False,
use_gpu=False,
store_likelihood=False
):
position = atleast_2d(np.asarray(position))
multiunits = np.asarray(multiunits)
logger.info('Estimating likelihood...')
likelihood = self.encoding_model_(
multiunits=multiunits,
position=position,
set_no_spike_to_equally_likely=set_no_spike_to_equally_likely)
if store_likelihood:
self.likelihood_ = likelihood
return self._get_results(
position,
likelihood,
time=time,
is_compute_acausal=is_compute_acausal,
use_gpu=use_gpu,
)
def fit(self, position, multiunits, is_training=None, refit=False):
position = atleast_2d(np.asarray(position))
multiunits = np.asarray(multiunits)
if is_training is None:
is_training = np.ones((position.shape[0],), dtype=bool)
else:
is_training = np.asarray(is_training)
if not refit:
self.fit_place_grid(
position=position,
track_graph=self.track_graph,
edge_order=self.edge_order,
edge_spacing=self.edge_spacing,
infer_track_interior=self.infer_track_interior,
)
self.fit_discrete_state_transition(
discrete_transition_diagonal=self.discrete_transition_diagonal,
is_training=is_training
)
self.fit_continuous_state_transition(
position=position,
is_training=is_training,
)
self.fit_multiunits(
position,
multiunits,
is_training
)
return self
def fit_continuous_state_transition(
self,
position=None,
is_training=None,
):
logger.info('Fitting continuous state transition...')
if self.continuous_state_transition_type == 'empirical':
if is_training is None:
n_time = position.shape[0]
is_training = np.ones((n_time,), dtype=bool)
if position is not None:
position = atleast_2d(np.asarray(position))
self.continuous_state_transition_ = empirical_movement(
position,
self.edges_,
is_training,
replay_speed=20)
elif ((self.continuous_state_transition_type == 'random_walk') &
(self.track_graph is not None)):
place_bin_center_ind_to_node = np.asarray(
self.place_bin_centers_nodes_df_.node_id)
self.continuous_state_transition_ = random_walk_on_track_graph(
self.place_bin_centers_,
0.0,
self.random_walk_variance,
place_bin_center_ind_to_node,
self.distance_between_nodes_
)
elif self.continuous_state_transition_type == 'random_walk':
self.continuous_state_transition_ = random_walk(
self.place_bin_centers_,
self.random_walk_variance,
self.is_track_interior_.ravel(order='F'),
1)
def fit_multiunits(
self,
position,
multiunits,
is_training=None,
):
'''
Parameters
----------
position : array_like, shape (n_time, n_position_dims)
multiunits : array_like, shape (n_time, n_features, n_electrodes)
is_training : None or array_like, shape (n_time,)
'''
logger.info('Fitting multiunits...')
position = atleast_2d(np.asarray(position))
multiunits = np.asarray(multiunits)
if is_training is None:
is_training = np.ones((position.shape[0],), dtype=bool)
else:
is_training = np.asarray(is_training)
if self.clusterless_algorithm == 'multiunit_likelihood':
self.encoding_model_ = fit_multiunit_likelihood(
position=position,
multiunits=multiunits,
is_training=is_training,
place_bin_centers=self.place_bin_centers_,
is_track_interior=self.is_track_interior_.ravel(order='F'),
**self.clusterless_algorithm_params,
)
elif self.clusterless_algorithm == 'multiunit_likelihood_integer':
self.encoding_model_ = fit_multiunit_likelihood_integer(
position=position,
multiunits=multiunits,
is_training=is_training,
place_bin_centers=self.place_bin_centers_,
is_track_interior=self.is_track_interior_.ravel(order='F'),
**self.clusterless_algorithm_params
)
elif self.clusterless_algorithm == 'multiunit_likelihood_integer_gpu':
self.encoding_model_ = fit_multiunit_likelihood_gpu(
position=position,
multiunits=multiunits,
is_training=is_training,
place_bin_centers=self.place_bin_centers_,
is_track_interior=self.is_track_interior_.ravel(order='F'),
**self.clusterless_algorithm_params
)
else:
raise NotImplementedError
def fit_place_fields(self, position, spikes, is_training=None):
logger.info('Fitting place fields...')
position = atleast_2d(np.asarray(position))
spikes = np.asarray(spikes)
if is_training is None:
is_training = np.ones((spikes.shape[0],), dtype=bool)
else:
is_training = np.asarray(is_training)
self.encoding_model_ = fit_spiking_likelihood(
position,
spikes,
is_training,
self.place_bin_centers_,
self.place_bin_edges_,
self.is_track_interior_.ravel(order='F'),
self.spike_model_penalty,
self.spike_model_knot_spacing)
def fit_place_grid(
self,
position=None,
track_graph=None,
edge_order=None,
edge_spacing=None,
infer_track_interior=True
):
position = atleast_2d(np.asarray(position))
self.track_graph = track_graph
if self.track_graph is None:
(self.edges_,
self.place_bin_edges_,
self.place_bin_centers_,
self.centers_shape_
) = get_grid(position, self.place_bin_size, self.position_range,
self.infer_track_interior)
self.infer_track_interior = infer_track_interior
if self.is_track_interior is None and self.infer_track_interior:
self.is_track_interior_ = get_track_interior(
position, self.edges_)
elif (self.is_track_interior is None and
not self.infer_track_interior):
self.is_track_interior_ = np.ones(
self.centers_shape_, dtype=np.bool)
else:
(
self.place_bin_centers_,
self.place_bin_edges_,
self.is_track_interior_,
self.distance_between_nodes_,
self.centers_shape_,
self.edges_,
self.track_graph_with_bin_centers_edges_,
self.original_nodes_df_,
self.place_bin_edges_nodes_df_,
self.place_bin_centers_nodes_df_,
self.nodes_df_
) = get_track_grid(self.track_graph, edge_order,
edge_spacing, self.place_bin_size)
return self
def plot_spikes(position, spikes, is_training=None, sampling_frequency=1,
col_wrap=5, bins='auto'):
if is_training is None:
is_training = np.ones((spikes.shape[0], ), dtype=bool)
else:
is_training = np.asarray(is_training.copy()).squeeze()
position = np.asarray(position.copy()).squeeze()[is_training]
position = atleast_2d(np.asarray(position))
spikes = np.asarray(spikes.copy())[is_training]
position_occupancy, bin_edges = np.histogram(position, bins=bins)
bin_size = np.diff(bin_edges)[0]
time_ind, neuron_ind = np.nonzero(spikes)
n_neurons = spikes.shape[1]
n_rows = np.ceil(n_neurons / col_wrap).astype(np.int)
fig, axes = plt.subplots(n_rows, col_wrap, sharex=True,
figsize=(col_wrap * 2, n_rows * 2))
for ind, ax in enumerate(axes.flat):
if ind < n_neurons:
hist, _ = np.histogram(position[time_ind[neuron_ind == ind]],
bins=bin_edges)
rate = sampling_frequency * hist / position_occupancy
ax.bar(bin_edges[:-1], rate, width=bin_size)
ax.set_title(f'Neuron #{ind + 1}')
ax.set_ylabel('Spikes / s')
ax.set_xlabel('Position')
else:
ax.axis('off')
plt.tight_layout()
return axes
def fit_multiunit_likelihood_gpu(position,
multiunits,
is_training,
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=bool)
is_zero = np.isclose(is_training.astype(float), 0.0)
# Exclude from dataset if is training is exactly zero
is_training = is_training[~is_zero]
position = atleast_2d(position)[~is_zero]
multiunits = multiunits[~is_zero]
place_bin_centers = atleast_2d(place_bin_centers)
interior_place_bin_centers = cp.asarray(
place_bin_centers[is_track_interior.ravel(order='F')],
dtype=cp.float32)
gpu_is_track_interior = cp.asarray(is_track_interior.ravel(order='F'))
not_nan_position = np.all(~np.isnan(position), axis=1)
occupancy = cp.zeros((place_bin_centers.shape[0], ), dtype=cp.float32)
occupancy[gpu_is_track_interior] = estimate_position_density(
interior_place_bin_centers,
cp.asarray(position[not_nan_position], dtype=cp.float32),
position_std,
sample_weights=cp.asarray(is_training, dtype=cp.float32),
)
mean_rates = []
summed_ground_process_intensity = cp.zeros(
(place_bin_centers.shape[0], ), dtype=cp.float32)
encoding_marks = []
encoding_positions = []
encoding_weights = []
for multiunit in np.moveaxis(multiunits, -1, 0):
# ground process intensity
is_spike = np.any(~np.isnan(multiunit), axis=1)
mean_rates.append(np.average(is_spike, weights=is_training))
marginal_density = cp.zeros((place_bin_centers.shape[0], ),
dtype=cp.float32)
if is_spike.sum() > 0:
marginal_density[
gpu_is_track_interior] = estimate_position_density(
interior_place_bin_centers,
cp.asarray(position[is_spike & not_nan_position],
dtype=cp.float32),
position_std,
sample_weights=cp.asarray(
is_training[is_spike & not_nan_position],
dtype=cp.float32),
)
summed_ground_process_intensity += (estimate_intensity(
marginal_density, occupancy, mean_rates[-1]))
is_mark_features = np.any(~np.isnan(multiunit), axis=0)
encoding_marks.append(
cp.asarray(multiunit[np.ix_(is_spike & not_nan_position,
is_mark_features)],
dtype=cp.int16))
encoding_positions.append(
cp.asarray(position[is_spike & not_nan_position],
dtype=cp.float32))
encoding_weights.append(
cp.asarray(is_training[is_spike & not_nan_position],
dtype=cp.float32))
summed_ground_process_intensity = cp.asnumpy(
summed_ground_process_intensity) + np.spacing(1)
return partial(
multiunit_likelihood,
place_bin_centers=place_bin_centers,
encoding_marks=encoding_marks,
encoding_marks_position=encoding_positions,
encoding_weights=encoding_weights,
encoding_position=position,
summed_ground_process_intensity=summed_ground_process_intensity,
occupancy=occupancy,
mean_rates=mean_rates,
mark_std=mark_std,
position_std=position_std,
is_track_interior=is_track_interior,
is_training=cp.asarray(is_training, dtype=cp.float32),
**kwargs,
)
