Merge pull request #515 from pynapple-org/dev

Bumping 0.10.1

Author: gviejo

README.md

@@ -19,6 +19,15 @@ pynapple is a light-weight python library for neurophysiological data analysis.
 
 ------------------------------------------------------------------------
 
+Learning pynapple
+-----------------
+
+Workshops are regularly organized by the [center for Computational Neuroscience ](https://www.simonsfoundation.org/flatiron/center-for-computational-neuroscience/) of the Flatiron institute 
+to teach pynapple & [NeMos](https://nemos.readthedocs.io/en/latest/) to new users. 
+
+**The next workshop will take place in New York City on February 2 - 5, 2026. Register [here](https://www.simonsfoundation.org/event/flatiron-ccn-neural-data-analysis-workshop/).**
+
+
 New release :fire:
 ------------------
 

doc/releases.md

@@ -1,5 +1,11 @@
 # Releases
 
+
+### 0.10.1 (2025-10-30)
+
+- Fixing smoothing for `nap.decode_bayes`.
+- Fixing `np.einsum`.
+
 ### 0.10.0 (2025-10-27)
 
 - Generalizing `nap.compute_tuning_curves`. It can take any time series object (Tsd, TsdFrame, TsGroup, TsdTensor) as input and 

doc/user_guide/07_decoding.md

@@ -32,8 +32,7 @@ Input to both decoding functions always includes:
  - `tuning_curves`, computed using [`compute_tuning_curves`](pynapple.process.tuning_curves.compute_tuning_curves).
  - `data`, neural activity as a `TsGroup` (spikes) or `TsdFrame` (smoothed counts or calcium activity or any other time series).
  - `epochs`, to restrict decoding to certain intervals.
- - `smoothing`, type of smoothing to apply to `data`, defaults to `None`, indicating no smoothing, but can be `gaussian` or `uniform`.
- - `smoothing_window`, smoothing window to use if `smoothing` is provided.
+ - `sliding_window_size`, uniform convolution window size (in number of bins) to smooth spike counts, only used if a `TsGroup` is passed (default is `None`, for no smoothing). This is equivalent to using a sliding window with overlapping bins.
  - `bin_size`, the size of the bins in which to count timestamps when data is a `TsGroup` object.
  - `time_units`, the units of `bin_size`, defaulting to seconds.
 
@@ -84,7 +83,7 @@ First, we compute the tuning curves:
 tuning_curves_1d = nap.compute_tuning_curves(
     tsgroup, 
     feature, 
-    bins=61, 
+    bins=60, 
     range=(0, 2 * np.pi), 
     feature_names=["Circular feature"]
 )
@@ -98,18 +97,17 @@ tuning_curves_1d.plot.line(x="Circular feature", add_legend=False)
 plt.show()
 ```
 
-We can then use `nap.decode_bayes` for Bayesian decoding.
-We will use the `smoothing` and `smoothing_window` arguments to additionally smooth the
-spike counts, this often helps with decoding:
+We can then use [`decode_bayes`](pynapple.process.decoding.decode_bayes) for Bayesian decoding.
+We will use the `sliding_window_size` argument to additionally smooth the
+spike counts with a uniform convolution window (i.e. use a sliding window), which often helps with decoding. 
 
 ```{code-cell} ipython3
 decoded, proba_feature = nap.decode_bayes(
     tuning_curves=tuning_curves_1d,
     data=tsgroup,
     epochs=epochs,
-    smoothing="gaussian",
-    smoothing_window=0.1,
-    bin_size=0.06,
+    sliding_window_size=4,
+    bin_size=0.02,
 )
 ```
 
@@ -198,16 +196,15 @@ tuning_curves_2d.plot(row="unit", col_wrap=6)
 plt.show()
 ```
 
-and then, `nap.decode_bayes` again performs bayesian decoding:
+and then, [`decode_bayes`](pynapple.process.decoding.decode_bayes) again performs bayesian decoding:
 
 ```{code-cell} ipython3
 decoded, proba_feature = nap.decode_bayes(
     tuning_curves=tuning_curves_2d,
     data=ts_group,
     epochs=epochs,
-    smoothing="gaussian",
-    smoothing_window=0.2,
-    bin_size=0.1,
+    sliding_window_size=2,
+    bin_size=0.05,
 )
 ```
 
@@ -306,13 +303,14 @@ tuning_curves_1d.plot.line(x="Circular feature", add_legend=False)
 plt.show()
 ```
 
-We can then use `nap.decode_template` for template matching:
+We can then use [`decode_template`](pynapple.process.decoding.decode_template) for template matching:
 
 ```{code-cell} ipython3
 decoded, dist = nap.decode_template(
     tuning_curves=tuning_curves_1d,
     data=tsgroup,
     epochs=epochs,
+    sliding_window_size=4,
     bin_size=0.05,
     metric="correlation"
 )
@@ -402,7 +400,7 @@ tuning_curves_2d.plot(row="unit", col_wrap=6)
 plt.show()
 ```
 
-and then, `nap.decode_template` again performs template matching:
+and then, [`decode_template`](pynapple.process.decoding.decode_template) again performs template matching:
 
 ```{code-cell} ipython3
 decoded, dist = nap.decode_template(

pynapple/core/metadata_class.py

@@ -3,6 +3,7 @@
 import itertools
 import warnings
 from collections import UserDict
+from functools import wraps
 from numbers import Number
 from typing import Union
 
@@ -28,6 +29,7 @@ def add_or_convert_metadata(func):
     Decorator for backwards compatibility of objects picked with older versions of pynapple.
     """
 
+    @wraps(func)
     def _decorator(self, *args, **kwargs):
         if (
             (len(args) == 1)

pynapple/core/utils.py

@@ -514,7 +514,7 @@ def modifies_time_axis(func, new_args, kwargs):
     try:
         sig = inspect.signature(func)
     except (TypeError, ValueError):
-        return True  # conservative
+        return False
 
     bound = sig.bind_partial(*new_args, **kwargs)
     bound.apply_defaults()
@@ -532,7 +532,7 @@ def modifies_time_axis(func, new_args, kwargs):
 
     ndim = getattr(arr, "ndim", None)
     if ndim is None:
-        return True  # conservative
+        return False
 
     ### 1) single-axis arguments ###
     axis = bound.arguments.get("axis", inspect._empty)

pynapple/process/decoding.py

@@ -45,14 +45,12 @@ def wrapper(*args, **kwargs):
                     units=kwargs["time_units"],
                 ),
             )[0]:
-                raise ValueError(
-                    "passed bin_size too different from actual data bin size."
-                )
+                warnings.warn("passed bin_size is different from actual data bin size.")
         elif isinstance(data, nap.TsGroup):
             data = data.count(
                 kwargs["bin_size"], kwargs["epochs"], time_units=kwargs["time_units"]
             )
-            was_continuous = True
+            was_continuous = False
         else:
             raise TypeError("Unknown format for data.")
 
@@ -72,28 +70,22 @@ def wrapper(*args, **kwargs):
             )
 
         # smooth
-        smoothing = kwargs["smoothing"]
-        smoothing_window = kwargs["smoothing_window"]
-        if smoothing is not None:
-            if smoothing not in ["gaussian", "uniform"]:
-                raise ValueError("smoothing should be one of 'gaussian' or 'uniform'.")
-            if not isinstance(smoothing_window, (int, float)):
-                raise ValueError("smoothing_window should be a number.")
-            if smoothing == "gaussian":
-                data = data.smooth(
-                    smoothing_window,
-                    time_units=kwargs["time_units"],
-                )
+        sliding_window_size = kwargs["sliding_window_size"]
+        if sliding_window_size is not None:
+            if not isinstance(sliding_window_size, int):
+                raise ValueError("sliding_window_size should be a integer.")
+            if sliding_window_size < 1:
+                raise ValueError("sliding_window_size should be >= 1.")
+            data = data.convolve(
+                np.ones(sliding_window_size),
+                ep=kwargs["epochs"],
+            )
+            if was_continuous:
+                data = data / sliding_window_size
             else:
-                smoothing_window_bins = max(
-                    1, int(smoothing_window / kwargs["bin_size"])
-                )
-                data = data.convolve(
-                    np.ones(smoothing_window_bins),
-                    ep=kwargs["epochs"],
-                )
-                if was_continuous:
-                    data = data / smoothing_window_bins
+                bin_size = sliding_window_size * kwargs["bin_size"]
+                kwargs["bin_size"] = bin_size
+
         kwargs["data"] = data
 
         # Call the original function with validated inputs
@@ -112,7 +104,7 @@ def _format_decoding_outputs(dist, tuning_curves, data, epochs, greater_is_bette
     all_nan = np.isnan(dist).all(axis=1)
     idx[all_nan] = -1
 
-    # Format probability distribution
+    # Format probability/distance distribution
     dist = dist.reshape(dist.shape[0], *tuning_curves.shape[1:])
     if dist.ndim > 2:
         dist = nap.TsdTensor(
@@ -167,8 +159,7 @@ def decode_bayes(
     data,
     epochs,
     bin_size,
-    smoothing=None,
-    smoothing_window=None,
+    sliding_window_size=None,
     time_units="s",
     uniform_prior=True,
 ):
@@ -224,10 +215,9 @@ def decode_bayes(
         The epochs on which decoding is computed
     bin_size : float
         Bin size. Default in seconds. Use ``time_units`` to change it.
-    smoothing : str, optional
-        Type of smoothing to apply to the binned spikes counts (``None`` [default], ``gaussian``, ``uniform``).
-    smoothing_window : float, optional
-        Size smoothing window. Default in seconds. Use ``time_units`` to change it.
+    sliding_window_size : int, optional
+        The size, in number of bins, for a uniform window to be convolved with the counts array for each neuron. Value should be >= 1.
+        If None (default), no smoothing is applied.
     time_units : str, optional
         Time unit of the bin size (``s`` [default], ``ms``, ``us``).
     uniform_prior : bool, optional
@@ -382,29 +372,35 @@ def decode_bayes(
     98.5        1.0  1.0
     dtype: float64, shape: (98, 2)
     """
-    occupancy = (
+    prior = (
         np.ones_like(tuning_curves[0]).flatten()
         if uniform_prior
         else tuning_curves.attrs["occupancy"].flatten()
     )
+    prior = prior.astype(np.float64)
+    prior /= prior.sum()
 
-    tc = tuning_curves.values.reshape(tuning_curves.sizes["unit"], -1).T
-    ct = data.values
+    rate_map = tuning_curves.values.reshape(tuning_curves.sizes["unit"], -1).T
+    observed_counts = data.values
     bin_size_s = nap.TsIndex.format_timestamps(
         np.array([bin_size], dtype=np.float64), time_units
     )[0]
+    observed_counts_expanded = np.tile(
+        observed_counts[:, np.newaxis, :], (1, rate_map.shape[0], 1)
+    )
 
-    p1 = np.exp(-bin_size_s * np.nansum(tc, 1))
-    p2 = occupancy / occupancy.sum()
-
-    ct2 = np.tile(ct[:, np.newaxis, :], (1, tc.shape[0], 1))
+    EPS = 1e-12
+    log_likelihood = np.nansum(
+        observed_counts_expanded * np.log(rate_map + EPS) - bin_size_s * rate_map,
+        axis=-1,
+    )
 
-    p3 = np.nanprod(tc**ct2, -1)
+    log_posterior = log_likelihood + np.log(prior)
+    posterior = np.exp(log_posterior - log_posterior.max(axis=1, keepdims=True))
+    posterior /= posterior.sum(axis=1, keepdims=True)
 
-    p = p1 * p2 * p3
-    p = p / p.sum(1)[:, np.newaxis]
     return _format_decoding_outputs(
-        p, tuning_curves, data, epochs, greater_is_better=True
+        posterior, tuning_curves, data, epochs, greater_is_better=True
     )
 
 
@@ -415,8 +411,7 @@ def decode_template(
     epochs,
     bin_size,
     metric="correlation",
-    smoothing=None,
-    smoothing_window=None,
+    sliding_window_size=None,
     time_units="s",
 ):
     """
@@ -476,10 +471,9 @@ def decode_template(
 
         If a callable, it must have the signature ``metric(u, v) -> float`` and
         return the distance between two 1D arrays.
-    smoothing : str, optional
-        Type of smoothing to apply to the binned spikes counts (``None`` [default], ``gaussian``, ``uniform``).
-    smoothing_window : float, optional
-        Size smoothing window. Default in seconds. Use ``time_units`` to change it.
+    sliding_window_size : int, optional
+        The size, in number of bins, for a uniform window to be convolved with the counts array for each neuron. Value should be >= 1.
+        If None (default), no smoothing is applied.
     time_units : str, optional
         Time unit of the bin size (``s`` [default], ``ms``, ``us``).