diff --git a/.gitignore b/.gitignore index c5444c8..4a4de90 100644 --- a/.gitignore +++ b/.gitignore @@ -145,4 +145,7 @@ dmypy.json .pytype/ # Cython debug symbols -cython_debug/ \ No newline at end of file +cython_debug/ + +# rendered videos +*.mp4 diff --git a/neuro_py/__init__.pyi b/neuro_py/__init__.pyi index 2937a9c..3074d22 100644 --- a/neuro_py/__init__.pyi +++ b/neuro_py/__init__.pyi @@ -10,6 +10,7 @@ __all__ = [ "spikes", "stats", "tuning", + "util", ] @@ -24,4 +25,5 @@ from . import ( spikes, stats, tuning, + util, ) \ No newline at end of file diff --git a/neuro_py/ensemble/__init__.pyi b/neuro_py/ensemble/__init__.pyi index dc108d7..53b107b 100644 --- a/neuro_py/ensemble/__init__.pyi +++ b/neuro_py/ensemble/__init__.pyi @@ -10,6 +10,8 @@ __all__ = [ "computeAssemblyActivity", "AssemblyReact", "ExplainedVariance", + "potential_landscape", + "potential_landscape_nd", "similarity_index", "similaritymat", "WeightedCorr", @@ -32,6 +34,10 @@ from .assembly import ( ) from .assembly_reactivation import AssemblyReact from .explained_variance import ExplainedVariance +from .dynamics import ( + potential_landscape, + potential_landscape_nd, +) from .similarity_index import similarity_index from .similaritymat import similaritymat from .replay import ( diff --git a/neuro_py/ensemble/dynamics.py b/neuro_py/ensemble/dynamics.py new file mode 100644 index 0000000..9896d76 --- /dev/null +++ b/neuro_py/ensemble/dynamics.py @@ -0,0 +1,280 @@ +from typing import Tuple, Union + +import numpy as np + +from scipy.stats import binned_statistic_dd + +from ..util.array import ( + find_terminal_masked_indices, + replace_border_zeros_with_nan, +) + + +def potential_landscape( + X_dyn: np.ndarray, + projbins: Union[int, np.ndarray], + domainbins: Union[int, np.ndarray, None] = None, +) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Compute numerical approximation of potential energy landscape across + 1D state and domain (e.g. time, position, etc.). + + Potential landscape is defined as the integral of the flow vectors. + + Parameters + ---------- + X_dyn : np.ndarray + State vectors of shape (trials, bins). + projbins : int or array-like + Number of bins for projection axis or bin edges + domainbins : int or array-like, optional + Number of bins for domain axis or bin edges, by default None + + Returns + ------- + np.ndarray + Potential energy landscape across state and domain + np.ndarray + Temporal gradient of potential energy landscape across state and domain + np.ndarray + Histogram of state vectors across state and domain + np.ndarray + Bin edges of state vectors + np.ndarray + Bin edges of domain + + References + ---------- + .. [1] Wang, S., Falcone, R., Richmond, B. et al. Attractor dynamics reflect + decision confidence in macaque prefrontal cortex. Nat Neurosci 26, + 1970–1980 (2023). + + Examples + -------- + >>> X_dyn = np.array([[0.1, 0.2, 0.4], [0.0, 0.3, 0.6]]) + >>> projbins = 3 + >>> domainbins = 3 + >>> potential_landscape(X_dyn, projbins, domainbins) + (array([[ 0. , 0. , nan], + [-0.1 , 0. , nan], + [ nan, 0. , -0.25]]), + array([[0.3 , nan, nan], + [0.1 , nan, nan], + [ nan, nan, 0.25]]), + array([[1., 0., 0.], + [1., 0., 0.], + [0., 0., 2.]]), + array([0. , 0.1, 0.2, 0.3]), + array([0. , 0.33333333, 0.66666667, 1. ])) + """ + # _t suffix is following notation of paper but applicable across any domain + nnrns = 1 + ntrials, nbins = X_dyn.shape + delta_t = np.diff(X_dyn, axis=1) # time derivatives: ntrials x nbins-1 x nnrns + + X_t_flat = np.reshape( + X_dyn[:, :-1], (-1, nnrns), order="F" + ).ravel() # skip last bin as no displacement exists for last time point + delta_t_flat = np.reshape( + delta_t, (-1, nnrns), order="F" + ).ravel() # column-major order + norm_tpts = np.repeat(np.arange(nbins - 1), ntrials) + + nbins_domain = ( + nbins - 1 if domainbins is None else domainbins + ) # downsample domain bins + + # 1D state space binning of time derivatives across domain + # assumes landscape may morph across domain + H, bin_edges, _ = binned_statistic_dd( # posbins x time + np.asarray((X_t_flat, norm_tpts)).T, + delta_t_flat, + statistic="count", + bins=(projbins, nbins_domain), + ) + latentedges, domainedges = bin_edges + + grad_pos_t_svm = binned_statistic_dd( + np.asarray((X_t_flat, norm_tpts)).T, + delta_t_flat, + statistic="sum", + bins=(projbins, nbins_domain), + ).statistic + # average derivative, a.k.a. flow/vector field for dynamics underlying + # population activity + grad_pos_t_svm = np.divide(grad_pos_t_svm, H, where=H != 0) + grad_pos_t_svm[H == 0] = np.nan # crucial to handle division by zero + # spatial integration via nnancumsum treats nan as zero for cumulative sum + potential_pos_t = -np.nancumsum(grad_pos_t_svm, axis=0) # projbins x domainbins + + idx_zero_X_t = np.searchsorted(latentedges, 0) + offset = potential_pos_t[idx_zero_X_t, :] # use potential at X_t = 0 as reference + potential_pos_t = potential_pos_t - offset # potential difference + + nonzero_mask = H != 0 + idx_first_nonzero, idx_last_nonzero = find_terminal_masked_indices( + nonzero_mask, axis=0 + ) # each have shape: time + # along axis 0 set all values from start to idx_first_nonzero to nan + for t in range(H.shape[1]): + potential_pos_t[: idx_first_nonzero[t], t] = np.nan + potential_pos_t[idx_last_nonzero[t] + 1 :, t] = np.nan + + return potential_pos_t, grad_pos_t_svm, H, latentedges, domainedges + + +def potential_landscape_nd( + X_dyn: np.ndarray, + projbins: Union[int, np.ndarray], + domainbins: Union[int, np.ndarray, None] = None, + nanborderempty: bool = True, +) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Compute numerical approximation of potential energy landscape across + n-dimensional state and domain (e.g. time, position, etc.). + + Potential landscape is defined as the integral of the flow vectors. + + Parameters + ---------- + X_dyn : np.ndarray + State vectors of shape (trials, bins, neurons) + projbins : int or array-like + Number of bins for projection axis or bin edges for each neuron + domainbins : int or array-like, optional + Number of bins for domain axis or bin edges, by default None + nanborderempty : bool, optional + Whether to set border values to nan if they are empty, by default True + + Returns + ------- + np.ndarray + Potential energy landscape across state averaged across domain for each + neuron. Shape: nnrns x projbins times nnrns + np.ndarray + Potential energy landscape across state and domain for each neuron. + Shape: projbins times nnrns x domainbins x nnrns + np.ndarray + Temporal gradient of potential energy landscape across state and domain + for each neuron. Shape: projbins times nnrns x domainbins x nnrns + np.ndarray + Histogram of state vectors across state and domain for each neuron. + Shape: projbins times nnrns x domainbins x nnrns + np.ndarray + Bin edges of state vectors for each neuron + np.ndarray + Bin edges of domain for each neuron + + References + ---------- + .. [1] Wang, S., Falcone, R., Richmond, B. et al. Attractor dynamics reflect + decision confidence in macaque prefrontal cortex. Nat Neurosci 26, + 1970–1980 (2023). + """ + # _t suffix is following notation of paper but applicable across any domain + ntrials, nbins, nnrns = X_dyn.shape + delta_t = np.diff( + X_dyn, axis=1 + ) # time derivatives: ntrials x ndomainbins-1 x nnrns + + X_t_flat = np.reshape( + X_dyn[:, :-1], (-1, nnrns), order="F" + ) # skip last bin as no displacement exists for last time point + delta_t_flat = np.reshape(delta_t, (-1, nnrns), order="F") # column-major order + norm_tpts = np.repeat(np.arange(nbins - 1), ntrials) + + nbins_domain = ( + nbins - 1 if domainbins is None else domainbins + ) # downsample domain bins + + potential_pos_t_nrns = [] + grad_pos_t_svm_nrns = [] + hist_nrns = [] + latentedges_nrns = [] + domainedges_nrns = [] + for nnrn in range(nnrns): + # 1D state space binning of time derivatives across domain + # assumes landscape may morph across domain + H, bin_edges, _ = binned_statistic_dd( # (nnrns times projbins) x time + np.asarray((*X_t_flat.T, norm_tpts)).T, + delta_t_flat[:, nnrn], + statistic="count", + bins=( + *[ + projbins if isinstance(projbins, int) else projbins[idx] + for idx in range(nnrns) + ], + nbins_domain, + ), + ) + latentedges = bin_edges[nnrn] + domainedges = bin_edges[-1] + + grad_pos_t_svm = binned_statistic_dd( + np.asarray((*X_t_flat.T, norm_tpts)).T, + delta_t_flat[:, nnrn], + statistic="sum", + bins=( + *[ + projbins if isinstance(projbins, int) else projbins[idx] + for idx in range(nnrns) + ], + nbins_domain, + ), + ).statistic + # average derivative, a.k.a. flow/vector field for dynamics underlying + # population activity + grad_pos_t_svm = np.divide(grad_pos_t_svm, H, where=H != 0) + grad_pos_t_svm[H == 0] = np.nan # crucial to handle division by zero + # spatial integration via nnancumsum treats nan as zero for cumulative sum + potential_pos_t = -np.nancumsum( + grad_pos_t_svm, axis=nnrn + ) # (nnrns times projbins) x domainbins + + if nanborderempty: + nonzero_mask = H != 0 + + for t in range(nbins_domain): + nrndimslices = [slice(None)] * nnrns + nrndimslices.append(t) + peripheral_zeros_nanmask = ~np.isnan( + replace_border_zeros_with_nan(nonzero_mask[tuple(nrndimslices)]) + ) + peripheral_zeros_nanmask = np.where( + peripheral_zeros_nanmask, peripheral_zeros_nanmask, np.nan + ) + potential_pos_t[tuple(nrndimslices)] *= peripheral_zeros_nanmask + + potential_pos_t_nrns.append(potential_pos_t) + grad_pos_t_svm_nrns.append(grad_pos_t_svm) + hist_nrns.append(H) + latentedges_nrns.append(latentedges) + domainedges_nrns.append(domainedges) + + potential_pos_t_nrns = np.stack( + potential_pos_t_nrns, axis=-1 + ) # projbins x domainbins x nnrns + grad_pos_t_svm_nrns = np.stack( + grad_pos_t_svm_nrns, axis=-1 + ) # projbins x domainbins x nnrns + hist = np.stack(hist_nrns, axis=-1) # projbins x domainbins x nnrns + latentedges_nrns = np.stack(latentedges_nrns, axis=-1) # projbins x nnrns + domainedges_nrns = np.stack(domainedges_nrns, axis=-1) # domainbins x nnrns + nrndimslices = [slice(None)] * (nnrns + 1) + nrndimslices.append(0) + potential_nrns_pos = [] + for nrn in range(nnrns): + nrndimslices[-1] = nrn + potential_nrns_pos.append( + np.nanmean( + potential_pos_t_nrns[tuple(nrndimslices)], axis=-1 + ) # average across domainbins + ) + potential_nrns_pos = np.asarray(potential_nrns_pos) # nnrns x nnrns times projbins + + return ( + potential_nrns_pos, + potential_pos_t_nrns, + grad_pos_t_svm_nrns, + hist, + latentedges_nrns, + domainedges_nrns, + ) diff --git a/neuro_py/util/__init__.py b/neuro_py/util/__init__.py new file mode 100644 index 0000000..9cce42d --- /dev/null +++ b/neuro_py/util/__init__.py @@ -0,0 +1,4 @@ +import lazy_loader as _lazy + +(__getattr__, __dir__, __all__) = _lazy.attach_stub(__name__, __file__) +del _lazy diff --git a/neuro_py/util/__init__.pyi b/neuro_py/util/__init__.pyi new file mode 100644 index 0000000..7141ae6 --- /dev/null +++ b/neuro_py/util/__init__.pyi @@ -0,0 +1,9 @@ +__all__ = ( + "find_terminal_masked_indices", + "replace_border_zeros_with_nan", +) + +from .array import ( + find_terminal_masked_indices, + replace_border_zeros_with_nan, +) diff --git a/neuro_py/util/array.py b/neuro_py/util/array.py new file mode 100644 index 0000000..5b81c67 --- /dev/null +++ b/neuro_py/util/array.py @@ -0,0 +1,104 @@ +from typing import Tuple + +import numpy as np + + +def find_terminal_masked_indices(mask: np.ndarray, axis: int) -> Tuple[np.ndarray, np.ndarray]: + """ + Find the first and last indices of non-masked values along an axis. + + Only tested upto 2D arrays. If `mask` is empty along `axis`, the first and + last indices are set to 0 and the last index along the axis, respectively. + + Parameters + ---------- + mask : np.ndarray + Mask of `arr`. + axis : int + Axis along which to find the first and last indices. + + Returns + ------- + np.ndarray + First index of non-masked values along `axis`. + np.ndarray + Last index of non-masked values along `axis`. + + Examples + -------- + 1D Example: + >>> mask = np.array([0, 0, 1, 1, 0]) + >>> find_terminal_masked_indices(mask, axis=0) + (2, 3) + + 2D Example (along rows): + >>> mask = np.array([[0, 0, 1], + ... [1, 1, 0], + ... [0, 0, 0]]) + >>> find_terminal_masked_indices(mask, axis=1) + (array([2, 0, 0]), array([2, 1, -1])) + + 2D Example (along columns): + >>> find_terminal_masked_indices(mask, axis=0) + (array([1, 1, 0]), array([1, 1, 0])) + """ + first_idx = np.argmax(mask, axis=axis) + reversed_mask = np.flip(mask, axis=axis) + last_idx = mask.shape[axis] - np.argmax(reversed_mask, axis=axis) - 1 + + return first_idx, last_idx + +def replace_border_zeros_with_nan(arr: np.ndarray) -> np.ndarray: + """Replace zero values at the borders of each dimension of a n-dimensional + array with NaN. + + Parameters + ---------- + arr : np.ndarray + Input array. + + Returns + ------- + np.ndarray + Array with zero values at the borders replaced with NaN. + + Examples + -------- + >>> arr = np.arange(27).reshape(3, 3, 3) + >>> arr[0, 2] = arr[2, 2] = arr[2, 0, 0] = arr[1, 1, 1] = 0 + >>> replace_border_zeros_with_nan(arr) + array([[[nan, 1., 2.], + [ 3., 4., 5.], + [nan, nan, nan]], + + [[ 9., 10., 11.], + [12., 0., 14.], + [15., 16., 17.]], + + [[nan, 19., 20.], + [21., 22., 23.], + [nan, nan, nan]]]) + """ + arr = np.array(arr, dtype=float) + dims = arr.shape + + for axis in range(len(dims)): + # Find indices where zero values start and stop + for idx in np.ndindex(*[dims[i] for i in range(len(dims)) if i != axis]): + slicer = list(idx) + slicer.insert(axis, slice(None)) # Insert the full slice along the current axis + + # Check for first sequence of zeros + subarray = arr[tuple(slicer)] + first_zero_indices = np.where(np.cumsum(subarray != 0) == 0)[0] + if len(first_zero_indices) > 0: + subarray[first_zero_indices] = np.nan + + # Check for last sequence of zeros + last_zero_indices = np.where(np.cumsum(subarray[::-1] != 0) == 0)[0] + if len(last_zero_indices) > 0: + subarray[-last_zero_indices-1] = np.nan + + arr[tuple(slicer)] = subarray # Replace modified subarray + + return arr diff --git a/tests/test_ensemble_dynamics.py b/tests/test_ensemble_dynamics.py new file mode 100644 index 0000000..6d56c28 --- /dev/null +++ b/tests/test_ensemble_dynamics.py @@ -0,0 +1,100 @@ +import unittest + +import numpy as np + +from neuro_py.ensemble.dynamics import ( + potential_landscape, + potential_landscape_nd, +) + + +class TestPotentialLandscape(unittest.TestCase): + def test_basic_case(self): + X_dyn = np.array([[0.1, 0.2, 0.4], [0.0, 0.3, 0.6]]) + projbins = 3 + domainbins = 3 + potential, gradient, hist, latentedges, domainedges = potential_landscape(X_dyn, projbins, domainbins) + + expected_potential = np.array([ + [ 0. , 0. , np.nan], + [-0.1 , 0., np.nan], + [np.nan, 0., -0.25] + ]) + expected_gradient = np.array([ + [0.3 , np.nan, np.nan], + [0.1 , np.nan, np.nan], + [np.nan, np.nan, 0.25] + ]) + expected_hist = np.array([ + [1., 0., 0.], + [1., 0., 0.], + [0., 0., 2.] + ]) + np.testing.assert_array_almost_equal(potential, expected_potential) + np.testing.assert_array_almost_equal(gradient, expected_gradient) + np.testing.assert_array_equal(hist, expected_hist) + + def test_no_domainbins(self): + X_dyn = np.array([[0.1, 0.2, 0.4], [0.0, 0.3, 0.6]]) + projbins = 3 + potential, gradient, hist, latentedges, domainedges = potential_landscape(X_dyn, projbins) + self.assertEqual(hist.shape[1], X_dyn.shape[1] - 1) + + def test_empty_input(self): + X_dyn = np.array([[]]) + projbins = 3 + with self.assertRaises(ValueError): + potential_landscape(X_dyn, projbins) + + def test_high_dimensional_input(self): + X_dyn = np.random.random((10, 50)) + projbins = 20 + domainbins = 15 + potential, gradient, hist, latentedges, domainedges = potential_landscape(X_dyn, projbins, domainbins) + self.assertEqual(hist.shape, (20, 15)) + + +class TestPotentialLandscapeND(unittest.TestCase): + def test_basic_case(self): + X_dyn = np.array([[0.1, 0.2, 0.4], [0.0, 0.3, 0.6]]) + projbins = 3 + domainbins = 3 + potential, gradient, hist, latentedges, domainedges = potential_landscape(X_dyn, projbins, domainbins) + + potential_nd, potential_pos_t_nd, gradient_nd, hist_nd, latentedges_nd, domainedges_nd = potential_landscape_nd(X_dyn.reshape(2, 3, 1), projbins, domainbins) + np.testing.assert_array_equal(potential.shape, potential_pos_t_nd[:, :, 0].shape) + np.testing.assert_array_almost_equal(gradient, gradient_nd[:, :, 0]) + np.testing.assert_array_equal(hist, hist_nd[:, :, 0]) + np.testing.assert_array_equal(latentedges, latentedges_nd[:, 0]) + np.testing.assert_array_equal(domainedges, domainedges_nd[:, 0]) + + def test_output_shapes(self): + nnrns = 3 + X_dyn = np.random.random((5, 10, nnrns)) + projbins = 5 + domainbins = 5 + potential, _, _, hist, latentedges, domainedges = potential_landscape_nd(X_dyn, projbins, domainbins) + + self.assertEqual(potential.shape, (nnrns, *[projbins for _ in range(nnrns)])) + self.assertEqual(hist.shape, (*[projbins for _ in range(nnrns)], domainbins, nnrns)) + self.assertEqual(len(latentedges), projbins+1) + self.assertEqual(len(domainedges), domainbins+1) + + def test_no_domainbins(self): + X_dyn = np.random.random((5, 10, 3)) + projbins = 5 + _, potential_pos_t, _, _, _, _ = potential_landscape_nd(X_dyn, projbins) + self.assertGreater(potential_pos_t.shape[-2], 0) + + def test_empty_input(self): + X_dyn = np.empty((0, 0, 0)) + projbins = 5 + with self.assertRaises(ValueError): + potential_landscape_nd(X_dyn, projbins) + + def test_nanborder_handling(self): + X_dyn = np.random.random((5, 10, 3)) + projbins = 5 + _, potential, _, _, _, _ = potential_landscape_nd(X_dyn, projbins, nanborderempty=True) + self.assertTrue(np.isnan(potential).any()) + diff --git a/tests/test_util_array.py b/tests/test_util_array.py new file mode 100644 index 0000000..ff5cb0b --- /dev/null +++ b/tests/test_util_array.py @@ -0,0 +1,122 @@ +import unittest + +import numpy as np + +from neuro_py.util.array import ( + find_terminal_masked_indices, + replace_border_zeros_with_nan, +) + + +class TestFindTerminalMaskedIndices(unittest.TestCase): + def test_1d_array(self): + mask = np.array([0, 0, 1, 1, 0]) + first_idx, last_idx = find_terminal_masked_indices(mask, axis=0) + self.assertEqual(first_idx, 2) + self.assertEqual(last_idx, 3) + + def test_2d_array_axis_0(self): + mask = np.array([[0, 0, 1], + [1, 1, 0], + [0, 0, 0]]) + first_idx, last_idx = find_terminal_masked_indices(mask, axis=0) + np.testing.assert_array_equal(first_idx, [1, 1, 0]) + np.testing.assert_array_equal(last_idx, [1, 1, 0]) + + def test_2d_array_axis_1(self): + mask = np.array([[0, 0, 1], + [1, 1, 0], + [0, 0, 0]]) + first_idx, last_idx = find_terminal_masked_indices(mask, axis=1) + np.testing.assert_array_equal(first_idx, [2, 0, 0]) + np.testing.assert_array_equal(last_idx, [2, 1, 2]) + + def test_empty_mask(self): + mask = np.array([[0, 0, 0], + [0, 0, 0]]) + first_idx, last_idx = find_terminal_masked_indices(mask, axis=0) + np.testing.assert_array_equal(first_idx, [0, 0, 0]) # argmax defaults to 0 for all-0 inputs + np.testing.assert_array_equal(last_idx, [1, 1, 1]) # Adjusted correctly for flipped argmax + + def test_full_mask(self): + mask = np.array([[1, 1, 1], + [1, 1, 1]]) + first_idx, last_idx = find_terminal_masked_indices(mask, axis=1) + np.testing.assert_array_equal(first_idx, [0, 0]) + np.testing.assert_array_equal(last_idx, [2, 2]) + + +class TestReplaceBorderZerosWithNaN(unittest.TestCase): + def test_1d_array(self): + arr = np.array([0, 1, 2, 0, 0]) + result = replace_border_zeros_with_nan(arr) + expected = np.array([np.nan, 1, 2, np.nan, np.nan]) + np.testing.assert_array_equal(result, expected) + + def test_2d_array(self): + arr = np.array([ + [0, 1, 2], + [3, 0, 5], + [0, 0, 0] + ]) + result = replace_border_zeros_with_nan(arr) + expected = np.array([ + [np.nan, 1, 2], + [3, np.nan, 5], + [np.nan, np.nan, np.nan] + ]) + np.testing.assert_array_equal(result, expected) + + def test_3d_array(self): + arr = np.arange(27).reshape(3, 3, 3) + arr[0, 2] = arr[2, 2] = arr[2, 0, 0] = arr[1, 1, 1] = 0 + result = replace_border_zeros_with_nan(arr) + expected = np.array([ + [[np.nan, 1., 2.], + [ 3., 4., 5.], + [np.nan, np.nan, np.nan]], + + [[ 9., 10., 11.], + [12., 0., 14.], + [15., 16., 17.]], + + [[np.nan, 19., 20.], + [21., 22., 23.], + [np.nan, np.nan, np.nan]] + ]) + np.testing.assert_array_equal(result, expected) + + def test_empty_array(self): + arr = np.array([]) + result = replace_border_zeros_with_nan(arr) + expected = np.array([]) + np.testing.assert_array_equal(result, expected) + + def test_all_zeros(self): + arr = np.zeros((3, 3)) + result = replace_border_zeros_with_nan(arr) + expected = np.full((3, 3), np.nan) + np.testing.assert_array_equal(result, expected) + + def test_no_zeros(self): + arr = np.array([ + [1, 2, 3], + [4, 5, 6], + [7, 8, 9] + ]) + result = replace_border_zeros_with_nan(arr) + np.testing.assert_array_equal(result, arr) # No change expected + + def test_single_element_array(self): + arr = np.array([0]) + result = replace_border_zeros_with_nan(arr) + expected = np.array([np.nan]) + np.testing.assert_array_equal(result, expected) + + def test_high_dimensional_array(self): + arr = np.zeros((2, 2, 2, 2)) + arr[0, 0, 0, 0] = 1 # Add non-zero in one corner + result = replace_border_zeros_with_nan(arr) + expected = np.full((2, 2, 2, 2), np.nan) + expected[0, 0, 0, 0] = 1 # Preserve the non-zero value + np.testing.assert_array_equal(result, expected) diff --git a/tutorials/attractor_landscape.ipynb b/tutorials/attractor_landscape.ipynb new file mode 100644 index 0000000..9e39291 --- /dev/null +++ b/tutorials/attractor_landscape.ipynb @@ -0,0 +1,74688 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ryanharvey1/neuro_py/blob/main/tutorials/attractor_landscape.ipynb)\n", + " \n", + "[![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://raw.githubusercontent.com/ryanharvey1/neuro_py/main/tutorials/attractor_landscape.ipynb)\n", + " \n", + "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/ryanharvey1/neuro_py/main?labpath=tutorials%2Fattractor_landscape.ipynb)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Attractor Estimation\n", + "\n", + "This tutorial demonstrates how to estimate potential energy landscapes for\n", + "simulated dynamical systems with attractors in one, two, three, and higher\n", + "dimensions. The goal is to understand the dynamics of systems governed by these\n", + "landscapes and validate estimations against the ground truth.\n", + "\n", + "---\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2\n", + "import warnings\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import ipywidgets as widgets\n", + "import napari\n", + "import neuro_py as npy\n", + "import scipy\n", + "import sklearn\n", + "import sklearn.decomposition\n", + "\n", + "from IPython.display import HTML\n", + "from matplotlib.animation import FuncAnimation\n", + "from napari_animation import Animation\n", + "\n", + "warnings.simplefilter(\"ignore\", category=RuntimeWarning)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 1: 1D Energy Landscape\n", + "\n", + "This section focuses on simulating and estimating a 1D energy landscape to\n", + "provide a foundational understanding of attractor dynamics in a simple setting.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Section 1.1: Simulate trials of 1D activity using Langevin dynamics with noise\n", + "\n", + "We simulate the dynamics of particles (or neural states) evolving under a 1D\n", + "potential landscape influenced by noise. The dynamics are modeled using Langevin\n", + "equations with parameters for attractor depths, positions, and noise.\n", + "\n", + "**Goals**:\n", + "\n", + "- To visualize particle dynamics under a simple potential landscape.\n", + "- To understand how initial states and noise affects convergence to attractors\n", + " and hence their estimation.\n", + "\n", + "**Key Insights**:\n", + "\n", + "- Particle trajectories converge to the minima of the potential wells,\n", + " confirming the attractor dynamics.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian(X, X0, sig, A):\n", + " G = A * np.exp(-((X - X0) ** 2) / (2 * sig**2))\n", + " dG = G * (X0 - X) / sig**2\n", + " return -G, -dG\n", + "\n", + "\n", + "def mix_gaussians(X, Xp, a):\n", + " u1, du1 = gaussian(X, Xp[0], 1, a[0])\n", + " u2, du2 = gaussian(X, Xp[1], 1, a[1])\n", + " u3, du3 = gaussian(X, Xp[2], 1, a[2])\n", + " u = u1 + u2 + u3\n", + " du = du1 + du2 + du3\n", + " return u, du\n", + "\n", + "\n", + "def simulate_trials(Xp, a, num_trials, iterations, dt, noise_fac):\n", + " \"\"\"Simulate trials using Langevin dynamics with noise\"\"\"\n", + " lan_fac = noise_fac * np.sqrt(dt)\n", + " X_dyn = np.empty((num_trials, iterations))\n", + " for i in range(num_trials):\n", + " # random initial condition\n", + " X_dyn[i, 0] = np.random.choice(Xp) + np.random.randn() * lan_fac\n", + " for ii in range(iterations - 1):\n", + " # energy and gradient at current position\n", + " E, dE = mix_gaussians(X_dyn[i, ii], Xp, a)\n", + " X_dyn[i, ii + 1] = X_dyn[i, ii] - dt * dE + lan_fac * np.random.randn()\n", + " return X_dyn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set parameters for the simulation generating the synthetic data influenced by\n", + "multiple bump attractors.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Xp = [-2.5, 0, 2.5] # positions of the minima of bump attractors\n", + "attractordepths = [0.25, 0.2, 0.25]\n", + "\n", + "ntrials = 100\n", + "iterations = 5000\n", + "domain_bins = proj_bins = 100\n", + "dt = 0.1 # time step\n", + "noise_fac = 0.15 # noise factor\n", + "\n", + "# generate data\n", + "X_dyn = simulate_trials(Xp, attractordepths, ntrials, iterations, dt, noise_fac)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Section 1.2: Analytically estimate the 1D potential energy landscape\n", + "\n", + "We analytically compute the 1D potential landscape and compare it to the\n", + "ground-truth potential used to generate the synthetic data.\n", + "\n", + "**Goal**:\n", + "\n", + "- To validate the simulation by comparing it to the analytical potential.\n", + "\n", + "**Plot Descriptions**:\n", + "\n", + "1. **Potential Landscape**: Displays the theoretical potential formed by the\n", + " Gaussian mixture components.\n", + "2. **Dynamics of Trials**: Shows the temporal evolution of particle positions\n", + " for selected trials.\n", + "3. **Potential Landscape Estimation**: Compares the analytical potential with\n", + " the estimated potential.\n", + "\n", + "**Key Insights**:\n", + "\n", + "- The estimated potential closely matches the analytical potential, confirming\n", + " the method's validity.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "potential_pos_t, grad_pos_t_svm, H, latentedges, domainedges = (\n", + " npy.ensemble.potential_landscape(X_dyn, proj_bins, domain_bins)\n", + ")\n", + "\n", + "# Visualize\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "X = np.arange(-10, 10, 0.0025)\n", + "\n", + "E, dE = mix_gaussians(X, Xp, attractordepths)\n", + "axes[0].plot(X, E, linewidth=2, label=\"Potential\")\n", + "axes[0].set_title(\"Potential Landscape\")\n", + "axes[0].set_xlabel(\"Position\")\n", + "axes[0].set_ylabel(\"Energy\")\n", + "\n", + "for i in range(len(Xp)):\n", + " axes[0].plot(\n", + " X, gaussian(X, Xp[i], 1, attractordepths[i])[0], label=f\"Component {i}\"\n", + " )\n", + "axes[0].legend()\n", + "\n", + "T = np.arange(0, iterations * dt, dt)\n", + "axes[1].plot(T, X_dyn[0], linewidth=2, label=\"Trial 1\")\n", + "axes[1].plot(T, X_dyn[-1], linewidth=2, label=f\"Trial {ntrials}\")\n", + "axes[1].set_title(\"Dynamics of trials\")\n", + "axes[1].set_xlabel(\"Time\")\n", + "axes[1].set_ylabel(\"Position (X)\")\n", + "axes[1].legend()\n", + "\n", + "axes[2].plot(X, E, linewidth=2, label=\"Potential\")\n", + "axes[2].plot(latentedges[:-1], np.nanmean(potential_pos_t, axis=1), label=\"Fit\")\n", + "axes[2].set_title(\"Potential Landscape Estimation\")\n", + "axes[2].set_xlabel(\"Position\")\n", + "axes[2].set_ylabel(\"Energy\")\n", + "axes[2].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 2: 2D Energy Landscape\n", + "\n", + "In this section, we extend the dynamics and estimation to two dimensions,\n", + "introducing more complexity.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Section 2.1: Simulate trials of 2D activity using Langevin dynamics with noise\n", + "\n", + "Simulate particle dynamics under a 2D potential landscape composed of Gaussian\n", + "attractors.\n", + "\n", + "**Goal**:\n", + "\n", + "- To explore how particle dynamics evolve in a 2D system with multiple\n", + " attractors\n", + "\n", + "**Key Insights**:\n", + "\n", + "- Particle trajectories converge to minima in 2D, clustering around attractor\n", + " states.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian_nd(X, X0, sig, A): # -> tuple:\n", + " \"\"\"n-dimensional Gaussian function\n", + "\n", + " Parameters\n", + " ----------\n", + " X : np.ndarray\n", + " n-dimensional grid space. Shape: (n_points, ndim).\n", + " X0 : np.ndarray\n", + " Centers of the Gaussian for each dimension (same shape as X).\n", + " sig : np.ndarray or float\n", + " Standard deviations for each dimension (either same shape as X or a single float).\n", + " A : float\n", + " Amplitude of the Gaussian.\n", + "\n", + " Returns\n", + " -------\n", + " G : np.ndarray\n", + " Value of the n-dimensional Gaussian function at X.\n", + " dG : np.ndarray\n", + " Derivative of the n-dimensional Gaussian function along each dimension.\n", + " \"\"\"\n", + " X = np.atleast_2d(X)\n", + " X0 = np.atleast_1d(X0)\n", + " sig = np.atleast_1d(sig)\n", + "\n", + " # Ensure X0 and sig are compatible with each dimension of the grid\n", + " # assert len(X) == len(X0), \"X0 should have the same number of dimensions as X\"\n", + " # assert len(X) == len(sig), \"sig should have the same number of dimensions as X\"\n", + "\n", + " # Compute the Gaussian function values across the grid\n", + " exponent = -np.sum((X - X0) ** 2 / (2 * sig**2), axis=-1)\n", + " G = A * np.exp(exponent)\n", + "\n", + " # Use np.gradient to compute the derivative along each axis\n", + " dG = (((X0 - X) / sig**2).T * G).T # shape: (n_points, ndim)\n", + "\n", + " return -G, -dG\n", + "\n", + "\n", + "def mix_functions(X, Xp, a, std=1, func=gaussian_nd):\n", + " \"\"\"Sum of Gaussians.\n", + "\n", + " Parameters\n", + " ----------\n", + " X : float\n", + " Position\n", + " Xp : list\n", + " Centers of the Gaussians\n", + " a : list\n", + " Amplitudes of the Gaussians\n", + " n : int\n", + " Number of Gaussians\n", + "\n", + " Returns\n", + " -------\n", + " U : float\n", + " Mixture of Gaussians\n", + " dU : float\n", + " Derivative of the mixture of Gaussians\n", + " \"\"\"\n", + " for i, xp in enumerate(Xp):\n", + " if i == 0:\n", + " U, dU = func(X, xp, std, a[i])\n", + " else:\n", + " u, du = func(X, xp, std, a[i])\n", + " U += u\n", + " dU += du\n", + " return U, dU\n", + "\n", + "\n", + "def simulate_trials(\n", + " Xp,\n", + " a,\n", + " ntrials,\n", + " iterations,\n", + " dt,\n", + " noise_fac,\n", + " std=1,\n", + " ngaussians=3,\n", + " xstarts=None,\n", + " func=gaussian_nd,\n", + "):\n", + " \"\"\"Simulate trials\n", + "\n", + " Parameters\n", + " ----------\n", + " Xp : list\n", + " Centers of the Gaussians\n", + " a : list\n", + " Amplitudes of the Gaussians\n", + " ntrials : int\n", + " Number of trials\n", + " iterations : int\n", + " Number of iterations\n", + " dt : float\n", + " Time step\n", + " noise_fac : float\n", + " Noise factor\n", + "\n", + " Returns\n", + " -------\n", + " X_dyn : array\n", + " Trajectories of the trials\n", + " \"\"\"\n", + " nnrns = len(np.atleast_1d(Xp[0]))\n", + " lan_fac = noise_fac * np.sqrt(dt) # Langevin factor\n", + " X_dyn = np.empty((ntrials, iterations, nnrns)) # Trajectories of the trials\n", + " for i in range(ntrials):\n", + " sel_ix = np.random.randint(len(Xp))\n", + " if xstarts is None or len(xstarts) <= i:\n", + " startstate = (\n", + " Xp[sel_ix] + np.random.randn(*X_dyn[i, 0].shape) * lan_fac\n", + " ) # random initial condition\n", + " else:\n", + " startstate = xstarts[i]\n", + " X_dyn[i, 0] = startstate\n", + " for ii in range(iterations - 1):\n", + " E, dE = mix_functions(X_dyn[i, ii], Xp, a, std=std, func=func)\n", + " X_dyn[i, ii + 1] = (\n", + " X_dyn[i, ii] - dt * dE + lan_fac * np.random.randn(*dE.shape)\n", + " )\n", + " return X_dyn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Xp_1D = [0] # Center of Gaussian\n", + "var_1D = 0.5 # Variance\n", + "X_1D = np.linspace(-5, 5, 100).reshape(-1, 1) # 1D input points\n", + "A_1D = 1.0 # Amplitude\n", + "\n", + "G_1D, dG_1D = gaussian_nd(X_1D, Xp_1D, var_1D, A_1D)\n", + "\n", + "Xp_2D = [0, 0]\n", + "var_2D = 1\n", + "X_2D = np.random.randn(5000, 2) # 2D input points\n", + "A_2D = 1.0 # Amplitude\n", + "\n", + "G_2D, dG_2D = gaussian_nd(X_2D, Xp_2D, var_2D, A_2D)\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 4, figsize=(20, 5))\n", + "\n", + "axes[0].plot(X_1D, G_1D, label=\"Gaussian\")\n", + "axes[0].plot(X_1D, dG_1D, label=\"Derivative\")\n", + "axes[0].set_title(\"1D Gaussian\")\n", + "axes[0].set_xlabel(\"Position\")\n", + "axes[0].set_ylabel(\"Potential\")\n", + "axes[0].legend()\n", + "\n", + "axes[1].scatter(X_2D[:, 0], X_2D[:, 1], c=G_2D, cmap=\"viridis\", s=5)\n", + "\n", + "axes[1].set_title(\"2D Gaussian\")\n", + "axes[1].set_xlabel(\"X\")\n", + "axes[1].set_ylabel(\"Y\")\n", + "\n", + "axes[2].scatter(X_2D[:, 0], X_2D[:, 1], c=dG_2D[:, 0], cmap=\"viridis\", s=5)\n", + "axes[2].set_title(\"2D Gaussian Derivative (X)\")\n", + "axes[2].set_xlabel(\"X\")\n", + "axes[2].set_ylabel(\"Y\")\n", + "\n", + "axes[3].scatter(X_2D[:, 0], X_2D[:, 1], c=dG_2D[:, 1], cmap=\"viridis\", s=5)\n", + "axes[3].set_title(\"2D Gaussian Derivative (Y)\")\n", + "axes[3].set_xlabel(\"X\")\n", + "axes[3].set_ylabel(\"Y\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set parameters for the simulation generating the synthetic data influenced by\n", + "multiple bump attractors.\n", + "\n", + "Note: We artificially create `xstarts` throughout different simulations to set\n", + "some of the initial states of the simulated trajectories to span the entire\n", + "space for better coverage, which is not necessary in real data and intelligent\n", + "initialization strategies can be used for simulations.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Xp = np.asarray([[-2, -2], [0, 0], [2, 2]])\n", + "attractordepths = [0.25, 0.2, 0.25]\n", + "\n", + "ntrials = 3000\n", + "iterations = 500\n", + "domain_bins = 20\n", + "proj_bins = 25\n", + "\n", + "dt = 0.1 # time step\n", + "noise_fac = 0.1 # noise factor\n", + "\n", + "# Generate starting points\n", + "posxstarts = np.linspace(-3.5, 3.5, 15)\n", + "xstarts = np.asarray(np.meshgrid(posxstarts, posxstarts)).T.reshape(-1, 2)\n", + "xstarts = np.repeat(xstarts, 5, axis=0)\n", + "np.random.shuffle(xstarts)\n", + "\n", + "# Simulate dynamics\n", + "X_dyn = simulate_trials(\n", + " Xp,\n", + " attractordepths,\n", + " ntrials,\n", + " iterations,\n", + " dt,\n", + " noise_fac,\n", + " ngaussians=len(Xp),\n", + " xstarts=xstarts,\n", + " std=1,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Section 2.2: Analytically estimate the potential energy landscape\n", + "\n", + "Compute and validate the 2D potential landscape using analytical and simulated\n", + "results.\n", + "\n", + "**Plot Descriptions**:\n", + "\n", + "1. **Potential Energy Landscape**: Visualizes the 2D attractor structure.\n", + "2. **Dynamics of Trials**: Shows particle trajectories across the 2D plane.\n", + "3. **Phase Plane**: Depicts vector fields indicating gradients toward attractor\n", + " basins.\n", + "4. **Time-Resolved Potential Estimation**: Highlights temporal changes in the\n", + " estimated landscape.\n", + "\n", + "**Key Insights**:\n", + "\n", + "- The agreement between the simulated dynamics and estimated landscapes\n", + " demonstrates robustness in two dimensions.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9b13ae8be6f64300a58fdfda7bb209f2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=0, description='t', max=19), Output()), _dom_classes=('widget-interact',…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "potential_pos, potential_pos_t_nrns, grad_pos_t_svm, H, latentedges, domainedges = (\n", + " npy.ensemble.potential_landscape_nd(\n", + " X_dyn,\n", + " [np.linspace(-3.5, 3.5, proj_bins), np.linspace(-3.5, 3.5, proj_bins)],\n", + " domain_bins,\n", + " )\n", + ")\n", + "\n", + "X = np.linspace(-3.5, 3.5, proj_bins)\n", + "y = np.linspace(-3.5, 3.5, proj_bins)\n", + "X, Y = np.meshgrid(X, y)\n", + "X = np.stack((X, Y), axis=-1)\n", + "X = X.reshape(-1, 2)\n", + "\n", + "E, dE = mix_functions(X, Xp, attractordepths, std=1, func=gaussian_nd)\n", + "\n", + "gaussians_nd = []\n", + "for i in range(len(Xp)):\n", + " gaussian = gaussian_nd(X, Xp[i], 1, attractordepths[i])[0].reshape(\n", + " proj_bins, proj_bins\n", + " )\n", + " gaussian = (gaussian - np.min(gaussian)) / (np.max(gaussian) - np.min(gaussian))\n", + " gaussians_nd.append(gaussian)\n", + "gaussians_nd = np.stack(gaussians_nd, axis=-1)\n", + "\n", + "\n", + "def simulate(t=0):\n", + " fig = plt.figure(figsize=(17, 10))\n", + " axes = []\n", + "\n", + " # make axes[0] 2D\n", + " axes.append(fig.add_subplot(2, 3, 1))\n", + " axes[-1].set_title(\"Potential Energy Landscape\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + "\n", + " axes[-1].imshow(gaussians_nd[::-1])\n", + " # add color label for each attractor outside the plot colored: red, green, blue\n", + " colors = [\"cyan\", \"magenta\", \"yellow\"]\n", + " for i, txt in enumerate([\"Bump 1\", \"Bump 2\", \"Bump 3\"]):\n", + " axes[-1].text(gaussians_nd.shape[0], 2 * i, txt, color=colors[i])\n", + "\n", + " # make axes[1] 3D\n", + " axes.append(fig.add_subplot(2, 3, 4, projection=\"3d\"))\n", + " X, Y = np.meshgrid(\n", + " np.linspace(-3.5, 3.5, proj_bins), np.linspace(-3.5, 3.5, proj_bins)\n", + " )\n", + " axes[-1].plot_surface(X, Y, E.reshape(proj_bins, proj_bins), cmap=\"turbo\")\n", + " # plot the xstarts over the surface\n", + " axes[-1].scatter(xstarts[:, 0], xstarts[:, 1], c=\"b\", marker=\".\", alpha=0.05)\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].set_zlabel(\"Energy\")\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 2))\n", + " for i in range(ntrials):\n", + " axes[-1].plot(*(X_dyn[i].T), color=\"black\", alpha=0.02)\n", + " axes[-1].plot(*(X_dyn[0].T), linewidth=1, label=\"Trial 1\", alpha=0.5)\n", + " # start with green and end with red\n", + " axes[-1].plot(*X_dyn[0, 0], \"go\", label=\"Start\")\n", + " axes[-1].plot(*X_dyn[0, -1], \"rx\", label=\"End\")\n", + " axes[-1].plot(*(X_dyn[-1].T), linewidth=1, label=f\"Trial {ntrials}\", alpha=0.5)\n", + " axes[-1].plot(*X_dyn[-1, 0], \"go\")\n", + " axes[-1].plot(*X_dyn[-1, -1], \"rx\")\n", + "\n", + " axes[-1].set_title(\"Dynamics of trials\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].legend()\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 3, projection=\"3d\"))\n", + " X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + " axes[-1].plot_surface(X, Y, np.nanmean(potential_pos, axis=0), cmap=\"turbo\")\n", + " axes[-1].set_title(\"Potential Estimation\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].set_zlabel(\"Energy\")\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 5))\n", + " # plot vector field\n", + " X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + " U = grad_pos_t_svm[:, :, t, 0]\n", + " V = grad_pos_t_svm[:, :, t, 1]\n", + " axes[-1].quiver(X, Y, U, V)\n", + " axes[-1].set_title(\"Phase plane\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 6, projection=\"3d\"))\n", + " axes[-1].plot_surface(\n", + " X, Y, np.nanmean(potential_pos_t_nrns[:, :, t], axis=-1), cmap=\"turbo\"\n", + " )\n", + " axes[-1].set_title(\"Time-resolved Potential Estimation\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].set_zlabel(\"Energy\")\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "_ = widgets.interact(simulate, t=(0, domain_bins - 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the time-resolved potential estimation to observe how the landscape\n", + "evolves over time.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t_steps = domain_bins # Number of time steps\n", + "\n", + "\n", + "def update_surface(t, ax, surf):\n", + " \"\"\"\n", + " Update the surface plot for time `t`.\n", + " \"\"\"\n", + " X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + " Z = -np.nanmean(\n", + " np.asarray(\n", + " [np.nancumsum(grad_pos_t_svm[:, :, t, nrn], axis=nrn) for nrn in range(2)]\n", + " ),\n", + " axis=0,\n", + " )\n", + "\n", + " surf[0].remove() # Remove old surface\n", + " surf[0] = ax.plot_surface(X, Y, Z, cmap=\"viridis\", edgecolor=\"none\")\n", + "\n", + "\n", + "def animate(t):\n", + " \"\"\"\n", + " Update the plot for frame t and rotate the view.\n", + " \"\"\"\n", + " update_surface(t, ax, surf)\n", + " ax.view_init(elev=30, azim=t * 360 / t_steps) # Rotate azimuth over time\n", + "\n", + "\n", + "# Create figure and 3D plot\n", + "fig = plt.figure(figsize=(6, 6))\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + "Z = np.nanmean(potential_pos_t_nrns[:, :, 0], axis=-1)\n", + "\n", + "surf = [ax.plot_surface(X, Y, Z, cmap=\"viridis\", edgecolor=\"none\")]\n", + "ax.set_xlabel(\"Position X\")\n", + "ax.set_ylabel(\"Position Y\")\n", + "ax.set_zlabel(\"Potential Energy\")\n", + "\n", + "# Animate\n", + "anim = FuncAnimation(fig, animate, frames=t_steps, interval=100, blit=False)\n", + "HTML(anim.to_jshtml())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Section 2.3: Simulate 2D trials for a ring attractor\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We simulate a 2D system with a ring attractor, a special case where attractors\n", + "form a ring structure, defined by:\n", + "\n", + "$$ \\psi(x, y) = \\frac{1}{\\pi \\sigma^4} (1 - \\frac{x^2 + y^2}{2 _ \\sigma^2}) {\\rm e}^{-\\frac{x^2 + y^2}{2 _ \\sigma^2}}$$\n", + "\n", + "where $\\sigma$ is the standard deviation of the repulsive potential.\n", + "\n", + "**Goal**:\n", + "\n", + "- To understand how ring attractors influence particle dynamics.\n", + "\n", + "**Key Insights**:\n", + "\n", + "- Particles converge to the ring attractor, forming a stable ring structure.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def mexican_hat_nd(X, X0, sig, A):\n", + " \"\"\"n-dimensional Mexican hat function\n", + "\n", + " Negative normalized second derivative of a Gaussian function.\n", + "\n", + " Parameters\n", + " ----------\n", + " X : np.ndarray\n", + " n-dimensional grid space. Shape: (n_points, ndim).\n", + " X0 : np.ndarray\n", + " Centers of the Mexican hat for each dimension (same shape as X).\n", + " sig : np.ndarray or float\n", + " Standard deviations for each dimension (either same shape as X or a single float).\n", + " A : float\n", + " Amplitude of the Mexican hat.\n", + "\n", + " Returns\n", + " -------\n", + " G : np.ndarray\n", + " Value of the n-dimensional Mexican hat function at X.\n", + " dG : np.ndarray\n", + " Derivative of the n-dimensional Mexican hat function along each dimension.\n", + " \"\"\"\n", + " X = np.atleast_2d(X)\n", + " X0 = np.atleast_1d(X0)\n", + " sig = np.atleast_1d(sig)\n", + "\n", + " # Compute the Mexican hat function values across the grid\n", + " exponent = np.sum((X - X0) ** 2 / (2 * sig**2), axis=-1)\n", + " M = A * (1 - exponent) * np.exp(-exponent) / sig**4\n", + "\n", + " dM = -(\n", + " ((X - X0) / (np.pi * sig**6)).T * np.exp(-exponent) * (2 - exponent)\n", + " ).T # shape: (n_points, ndim)\n", + "\n", + " return M, dM" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Xp_1D = [0] # Center of Gaussian\n", + "cov_1D = 0.5 # Variance\n", + "X_1D = np.linspace(-5, 5, proj_bins).reshape(-1, 1) # 1D input points\n", + "A_1D = 1.0 # Amplitude\n", + "\n", + "G_1D, dG_1D = mexican_hat_nd(X_1D, Xp_1D, cov_1D, A_1D)\n", + "\n", + "Xp_2D = [0, 0]\n", + "X_2D = 3 * np.random.randn(7500, 2) # 2D input points\n", + "A_2D = 1.0 # Amplitude\n", + "\n", + "G_2D, dG_2D = mexican_hat_nd(X_2D, Xp_2D, 1, A_2D)\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 4, figsize=(20, 5))\n", + "axes = axes.ravel()\n", + "\n", + "axes[0].plot(X_1D, G_1D, label=\"Mexican Hat\")\n", + "axes[0].plot(X_1D, dG_1D.ravel(), label=\"Derivative\")\n", + "axes[0].set_title(\"1D Mexican Hat\")\n", + "axes[0].set_xlabel(\"Position\")\n", + "axes[0].set_ylabel(\"Value\")\n", + "axes[0].legend()\n", + "\n", + "axes[1].remove()\n", + "axes[1] = fig.add_subplot(1, 4, 2, projection=\"3d\")\n", + "X, Y = np.meshgrid(X_1D, X_1D)\n", + "X_in = np.stack((X, Y), axis=-1)\n", + "X_in = X_in.reshape(-1, 2)\n", + "# test mexican hat once\n", + "axes[1].plot_surface(\n", + " X,\n", + " Y,\n", + " mexican_hat_nd(X_in, [0, 0], 1, 1)[0].reshape(proj_bins, proj_bins),\n", + " cmap=\"plasma\",\n", + ")\n", + "\n", + "axes[1].set_title(\"2D Mexican Hat\")\n", + "axes[1].set_xlabel(\"X\")\n", + "axes[1].set_ylabel(\"Y\")\n", + "\n", + "axes[2].remove()\n", + "axes[2] = fig.add_subplot(1, 4, 3, projection=\"3d\")\n", + "axes[2].plot_surface(\n", + " X,\n", + " Y,\n", + " mexican_hat_nd(X_in, [0, 0], 1, 1)[1][:, 0].reshape(proj_bins, proj_bins),\n", + " cmap=\"plasma\",\n", + ")\n", + "axes[2].set_title(\"2D Mexican Hat Derivative (X)\")\n", + "axes[2].set_xlabel(\"X\")\n", + "axes[2].set_ylabel(\"Y\")\n", + "\n", + "axes[3].remove()\n", + "axes[3] = fig.add_subplot(1, 4, 4, projection=\"3d\")\n", + "axes[3].plot_surface(\n", + " X,\n", + " Y,\n", + " mexican_hat_nd(X_in, [0, 0], 1, 1)[1][:, 1].reshape(proj_bins, proj_bins),\n", + " cmap=\"plasma\",\n", + ")\n", + "axes[3].set_title(\"2D Mexican Hat Derivative (Y)\")\n", + "axes[3].set_xlabel(\"X\")\n", + "axes[3].set_ylabel(\"Y\")\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Xp = np.asarray([[0, 0]])\n", + "attractordepths = [0.25]\n", + "\n", + "ntrials = 3000\n", + "iterations = 100\n", + "domain_bins = 20\n", + "proj_bins = 25\n", + "dt = 0.2 # time step\n", + "noise_fac = 0.1 # noise factor\n", + "\n", + "# Generate starting points\n", + "posxstarts = np.linspace(-3.5, 3.5, 15)\n", + "xstarts = np.asarray(np.meshgrid(posxstarts, posxstarts)).T.reshape(-1, 2)\n", + "xstarts = np.repeat(xstarts, 5, axis=0)\n", + "np.random.shuffle(xstarts)\n", + "\n", + "# Simulate dynamics\n", + "X_dyn = simulate_trials(\n", + " Xp,\n", + " attractordepths,\n", + " ntrials,\n", + " iterations,\n", + " dt,\n", + " noise_fac,\n", + " ngaussians=len(Xp),\n", + " xstarts=xstarts,\n", + " func=mexican_hat_nd,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Section 2.4: Analytically estimate the potential energy landscape\n", + "\n", + "Estimate the potential landscape for the ring attractor and compare it to the\n", + "ground-truth potential.\n", + "\n", + "**Plot Descriptions**:\n", + "\n", + "1. **Potential Energy Landscape**: Displays the ring attractor structure.\n", + "2. **Dynamics of Trials**: Shows particle trajectories in the 2D plane.\n", + "3. **Phase Plane**: Depicts vector fields indicating gradients toward the ring\n", + " attractor.\n", + "4. **Time-Resolved Potential Estimation**: Highlights temporal changes in the\n", + " estimated landscape.\n", + "\n", + "**Key Insights**:\n", + "\n", + "- The estimated potential closely matches the analytical potential, confirming\n", + " the method's validity.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0453f6d090064578b68b085795db3d04", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=0, description='t', max=19), Output()), _dom_classes=('widget-interact',…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "potential_pos, potential_pos_t_nrns, grad_pos_t_svm, H, latentedges, domainedges = (\n", + " npy.ensemble.potential_landscape_nd(\n", + " X_dyn,\n", + " [np.linspace(-3.5, 3.5, proj_bins), np.linspace(-3.5, 3.5, proj_bins)],\n", + " domain_bins,\n", + " )\n", + ")\n", + "\n", + "X = np.linspace(-3.5, 3.5, proj_bins)\n", + "y = np.linspace(-3.5, 3.5, proj_bins)\n", + "X, Y = np.meshgrid(X, y)\n", + "X = np.stack((X, Y), axis=-1)\n", + "X = X.reshape(-1, 2)\n", + "\n", + "E, dE = mix_functions(X, Xp, attractordepths, func=mexican_hat_nd)\n", + "\n", + "gaussians_nd = []\n", + "for i in range(len(Xp)):\n", + " gaussian = mexican_hat_nd(X, Xp[i], 1, attractordepths[i])[0].reshape(\n", + " proj_bins, proj_bins\n", + " )\n", + " gaussian = (gaussian - np.min(gaussian)) / (np.max(gaussian) - np.min(gaussian))\n", + " gaussians_nd.append(gaussian)\n", + "gaussians_nd = np.stack(gaussians_nd, axis=-1)\n", + "\n", + "\n", + "def simulate(t=0):\n", + " fig = plt.figure(figsize=(17, 10))\n", + " axes = []\n", + "\n", + " # make axes[0] 2D\n", + " axes.append(fig.add_subplot(2, 3, 1))\n", + " axes[-1].set_title(\"Potential Energy Landscape\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + "\n", + " axes[-1].imshow(gaussians_nd[::-1], cmap=\"turbo\")\n", + "\n", + " # make axes[1] 3D\n", + " axes.append(fig.add_subplot(2, 3, 4, projection=\"3d\"))\n", + " X, Y = np.meshgrid(\n", + " np.linspace(-3.5, 3.5, proj_bins), np.linspace(-3.5, 3.5, proj_bins)\n", + " )\n", + " axes[-1].plot_surface(X, Y, E.reshape(proj_bins, proj_bins), cmap=\"turbo\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].set_zlabel(\"Energy\")\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 2))\n", + " for i in range(ntrials):\n", + " axes[-1].plot(*(X_dyn[i].T), color=\"black\", alpha=0.02)\n", + " axes[-1].plot(*(X_dyn[0].T), linewidth=1, label=\"Trial 1\", alpha=0.5)\n", + " # start with green and end with red\n", + " axes[-1].plot(*X_dyn[0, 0], \"go\", label=\"Start\")\n", + " axes[-1].plot(*X_dyn[0, -1], \"rx\", label=\"End\")\n", + " axes[-1].plot(*(X_dyn[-1].T), linewidth=1, label=f\"Trial {ntrials}\", alpha=0.5)\n", + " axes[-1].plot(*X_dyn[-1, 0], \"go\")\n", + " axes[-1].plot(*X_dyn[-1, -1], \"rx\")\n", + "\n", + " axes[-1].set_title(\"Dynamics of trials\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].legend()\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 3, projection=\"3d\"))\n", + " X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + "\n", + " axes[-1].plot_surface(X, Y, np.nanmean(potential_pos, axis=0), cmap=\"turbo\")\n", + " axes[-1].set_title(\"Potential Estimation\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].set_zlabel(\"Energy\")\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 5))\n", + " # plot vector field\n", + " X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + " U = grad_pos_t_svm[:, :, t, 0]\n", + " V = grad_pos_t_svm[:, :, t, 1]\n", + " axes[-1].quiver(X, Y, U, V)\n", + " axes[-1].set_title(\"Phase plane\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + "\n", + " axes.append(fig.add_subplot(2, 3, 6, projection=\"3d\"))\n", + " X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + "\n", + " axes[-1].plot_surface(\n", + " X, Y, np.nanmean(potential_pos_t_nrns[:, :, t], axis=-1), cmap=\"turbo\"\n", + " )\n", + " axes[-1].set_title(\"Time-resolved Potential Estimation\")\n", + " axes[-1].set_xlabel(\"Position X\")\n", + " axes[-1].set_ylabel(\"Position Y\")\n", + " axes[-1].set_zlabel(\"Energy\")\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "_ = widgets.interact(simulate, t=(0, domain_bins - 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the time-resolved potential estimation for the ring attractor.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib.animation import FuncAnimation\n", + "\n", + "# Dummy data to simulate inputs\n", + "t_steps = domain_bins # Number of time steps\n", + "\n", + "\n", + "def animate(t):\n", + " \"\"\"\n", + " Update the plot for frame t and rotate the view.\n", + " \"\"\"\n", + " update_surface(t, ax, surf)\n", + " ax.view_init(elev=30, azim=t / 2 * 360 / t_steps) # Rotate azimuth over time\n", + "\n", + "\n", + "# Create figure and 3D plot\n", + "fig = plt.figure(figsize=(6, 6))\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "X, Y = np.meshgrid(latentedges[:-1, 0], latentedges[:-1, 0])\n", + "Z = np.nanmean(potential_pos_t_nrns[:, :, 0], axis=-1)\n", + "\n", + "surf = [ax.plot_surface(X, Y, Z, cmap=\"turbo\", edgecolor=\"none\")]\n", + "ax.set_xlabel(\"Position X\")\n", + "ax.set_ylabel(\"Position Y\")\n", + "ax.set_zlabel(\"Potential Energy\")\n", + "\n", + "# Animate\n", + "anim = FuncAnimation(fig, animate, frames=t_steps, interval=100, blit=False)\n", + "HTML(anim.to_jshtml())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 3: 3D Energy Landscape\n", + "\n", + "This section explores the dynamics and estimation of potential landscapes in\n", + "three dimensions.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Section 3.1: Simulate 3D trials using Langevin dynamics with noise\n", + "\n", + "Simulate 3D dynamics under Gaussian attractors to examine the additional\n", + "complexity introduced by higher dimensions.\n", + "\n", + "**Purpose**:\n", + "\n", + "- To study how particle trajectories behave in a 3D space with noise.\n", + "\n", + "**Plot Descriptions**:\n", + "\n", + "- **Dynamics of Trials**: Shows particle trajectories in the 3D space.\n", + "\n", + "**Key Insights**:\n", + "\n", + "- Trajectories exhibit complex convergence patterns due to added dimensionality.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Xp = np.asarray(\n", + " [\n", + " [-1.5, -1.5, -1.5],\n", + " [0, 0, 0],\n", + " [1.5, 1.5, 1.5],\n", + " ]\n", + ")\n", + "attractordepths = [1, 0.95, 1]\n", + "\n", + "ntrials = 5000\n", + "iterations = 500\n", + "domain_bins = 20\n", + "proj_bins = 20\n", + "dt = 0.1 # time step\n", + "noise_fac = 0.05 # noise factor\n", + "attractorfunc = gaussian_nd\n", + "\n", + "# Generate starting points\n", + "posxstarts = np.linspace(-3.5, 3.5, 30)\n", + "xstarts = np.asarray(np.meshgrid(posxstarts, posxstarts, posxstarts)).T.reshape(-1, 3)\n", + "xstarts = np.repeat(xstarts, 1, axis=0)\n", + "np.random.shuffle(xstarts)\n", + "\n", + "# Simulate dynamics\n", + "X_dyn = simulate_trials(\n", + " Xp,\n", + " attractordepths,\n", + " ntrials,\n", + " iterations,\n", + " dt,\n", + " noise_fac,\n", + " ngaussians=len(Xp),\n", + " xstarts=xstarts,\n", + " func=attractorfunc,\n", + " std=1,\n", + ") # shape: (ntrials, iterations, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert X_dyn to 2D with columns as (trial number, time step, x, y, z)\n", + "X_dyn_2D = np.concatenate(\n", + " [\n", + " np.repeat(np.arange(ntrials), iterations).reshape(-1, 1),\n", + " np.broadcast_to(np.arange(iterations), (ntrials, iterations))\n", + " .flatten()\n", + " .reshape(-1, 1),\n", + " X_dyn.reshape(-1, 3),\n", + " ],\n", + " axis=1,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rendering frames...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/168 [00:00" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "viewer = napari.Viewer(ndisplay=3)\n", + "viewer.add_tracks(X_dyn_2D, tail_width=1, name=\"Dynamics of trials\")\n", + "\n", + "animation = Animation(viewer)\n", + "viewer.update_console({\"animation\": animation})\n", + "\n", + "viewer.camera.angles = (0.0, 0.0, 90.0)\n", + "animation.capture_keyframe()\n", + "max_steps = int(viewer.dims.range[0][1])\n", + "# rotate the camera 360 degrees while advancing the time\n", + "for i in range(0, max_steps, 3):\n", + " angle_inc = i * 360 / max_steps\n", + " viewer.camera.angles = (\n", + " 0.0 + 0.075 * angle_inc,\n", + " 0.0 + angle_inc,\n", + " 90.0 + 0.1 * angle_inc,\n", + " )\n", + " viewer.dims.current_step = (i, *viewer.dims.current_step[1:])\n", + " animation.capture_keyframe(steps=1)\n", + "\n", + "animation.animate(\"anim3DTrajs.mp4\", canvas_only=True)\n", + "\n", + "HTML('