def test_get_seq_sqrt(self):
data = [self.data2[0]]
seqs = gpfa_util.get_seqs(data, bin_size=self.bin_size)
seqs_not_sqrt = gpfa_util.get_seqs(data, bin_size=self.bin_size,
use_sqrt=False)
self.assertEqual(seqs['T'], seqs_not_sqrt['T'])
self.assertEqual(seqs['y'].shape, seqs_not_sqrt['y'].shape)
def _format_training_data(self, spiketrains):
seqs = gpfa_util.get_seqs(spiketrains, self.bin_size)
# Remove inactive units based on training set
self.has_spikes_bool = np.hstack(seqs['y']).any(axis=1)
for seq in seqs:
seq['y'] = seq['y'][self.has_spikes_bool, :]
return seqs
def test_cut_trials_larger_length(self):
data = [self.data2[0]]
seqs = gpfa_util.get_seqs(data, bin_size=self.bin_size)
seg_length = seqs[0]['T'] + 1
with self.assertWarns(UserWarning):
gpfa_util.cut_trials(seqs, seg_length=seg_length)
def test_cut_trials_same_length(self):
data = [self.data2[0]]
seqs = gpfa_util.get_seqs(data, bin_size=self.bin_size)
seg_length = seqs[0]['T']
seqs_cut = gpfa_util.cut_trials(seqs, seg_length=seg_length)
assert_array_almost_equal(seqs[0]['y'], seqs_cut[0]['y'])
def test_cut_trials_zero_length(self):
seqs = gpfa_util.get_seqs(self.data2, bin_size=self.bin_size)
with self.assertRaises(ValueError):
gpfa_util.cut_trials(seqs, seg_length=0)
def transform(self, spiketrains, returned_data=['latent_variable_orth']):
"""
Obtain trajectories of neural activity in a low-dimensional latent
variable space by inferring the posterior mean of the obtained GPFA
model and applying an orthonormalization on the latent variable space.
Parameters
----------
spiketrains : list of list of neo.SpikeTrain
Spike train data to be transformed to latent variables.
The outer list corresponds to trials and the inner list corresponds
to the neurons recorded in that trial, such that
`spiketrains[l][n]` is the spike train of neuron `n` in trial `l`.
Note that the number and order of `neo.SpikeTrain` objects per
trial must be fixed such that `spiketrains[l][n]` and
`spiketrains[k][n]` refer to spike trains of the same neuron
for any choices of `l`, `k`, and `n`.
returned_data : list of str
The dimensionality reduction transform generates the following
resultant data:
'latent_variable_orth': orthonormalized posterior mean of latent
variable
'latent_variable': posterior mean of latent variable before
orthonormalization
'Vsm': posterior covariance between latent variables
'VsmGP': posterior covariance over time for each latent variable
'y': neural data used to estimate the GPFA model parameters
`returned_data` specifies the keys by which the data dict is
returned.
Default is ['latent_variable_orth'].
Returns
-------
np.ndarray or dict
When the length of `returned_data` is one, a single np.ndarray,
containing the requested data (the first entry in `returned_data`
keys list), is returned. Otherwise, a dict of multiple np.ndarrays
with the keys identical to the data names in `returned_data` is
returned.
N-th entry of each np.ndarray is a np.ndarray of the following
shape, specific to each data type, containing the corresponding
data for the n-th trial:
`latent_variable_orth`: (#latent_vars, #bins) np.ndarray
`latent_variable`: (#latent_vars, #bins) np.ndarray
`y`: (#units, #bins) np.ndarray
`Vsm`: (#latent_vars, #latent_vars, #bins) np.ndarray
`VsmGP`: (#bins, #bins, #latent_vars) np.ndarray
Note that the num. of bins (#bins) can vary across trials,
reflecting the trial durations in the given `spiketrains` data.
Raises
------
ValueError
If the number of neurons in `spiketrains` is different from that
in the training spiketrain data.
If `returned_data` contains keys different from the ones in
`self.valid_data_names`.
"""
if len(spiketrains[0]) != len(self.has_spikes_bool):
raise ValueError("'spiketrains' must contain the same number of "
"neurons as the training spiketrain data")
invalid_keys = set(returned_data).difference(self.valid_data_names)
if len(invalid_keys) > 0:
raise ValueError("'returned_data' can only have the following "
"entries: {}".format(self.valid_data_names))
seqs = gpfa_util.get_seqs(spiketrains, self.bin_size)
for seq in seqs:
seq['y'] = seq['y'][self.has_spikes_bool, :]
seqs, ll = gpfa_core.exact_inference_with_ll(seqs,
self.params_estimated,
get_ll=True)
self.transform_info['log_likelihood'] = ll
self.transform_info['num_bins'] = seqs['T']
Corth, seqs = gpfa_core.orthonormalize(self.params_estimated, seqs)
self.transform_info['Corth'] = Corth
if len(returned_data) == 1:
return seqs[returned_data[0]]
return {x: seqs[x] for x in returned_data}
