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