Merge branch 'master' into lowering_precision

Author: n-shevko

.github/workflows/python-app.yml

@@ -16,13 +16,20 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up Python 3.9
+    - name: Set up Python 3.13
       uses: actions/setup-python@v4
       with:
-        python-version: 3.9
+<<<<<<< HEAD
+        python-version: 3.10
     - name: Install Poetry
       env:
-        POETRY_VERSION: 1.5.1
+        POETRY_VERSION: 2.0.0
+=======
+        python-version: 3.13
+    - name: Install Poetry
+      env:
+        POETRY_VERSION: 2.1.2
+>>>>>>> origin
       run: |
         curl -sSL https://install.python-poetry.org | python - -y &&\
             poetry config virtualenvs.create false

.github/workflows/pythonpackage.yml

@@ -9,7 +9,11 @@ jobs:
     strategy:
       max-parallel: 4
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
+<<<<<<< HEAD
+        python-version: ["3.10", "3.11", "3.12"]
+=======
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+>>>>>>> origin
 
     steps:
     - uses: actions/checkout@v3
@@ -19,7 +23,11 @@ jobs:
         python-version: ${{ matrix.python-version }}
     - name: Install Poetry
       env:
-        POETRY_VERSION: 1.5.1
+<<<<<<< HEAD
+        POETRY_VERSION: 2.0.0
+=======
+        POETRY_VERSION: 2.1.2
+>>>>>>> origin
       run: |
         curl -sSL https://install.python-poetry.org | python - -y &&\
             poetry config virtualenvs.create false

README.md

@@ -9,9 +9,9 @@ This package is used as part of ongoing research on applying SNNs, machine learn
 
 Check out the [BindsNET examples](https://github.com/BindsNET/bindsnet/tree/master/examples) for a collection of experiments, functions for the analysis of results, plots of experiment outcomes, and more. Documentation for the package can be found [here](https://bindsnet-docs.readthedocs.io).
 
-![Build Status](https://github.com/BindsNET/bindsnet/actions/workflows/python-app.yml/badge.svg?branch=master)
+[![CodeQL](https://github.com/BindsNET/bindsnet/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/BindsNET/bindsnet/actions/workflows/github-code-scanning/codeql)
 [![Documentation Status](https://readthedocs.org/projects/bindsnet-docs/badge/?version=latest)](https://bindsnet-docs.readthedocs.io/?badge=latest)
-[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/bindsnet_/community)
+[![Neuromorphic Computing](https://img.shields.io/badge/Collaboration_Network-Open_Neuromorphic-blue)](https://open-neuromorphic.org/neuromorphic-computing/)
 
 ## Requirements
 

bindsnet/evaluation/evaluation.py

@@ -44,8 +44,11 @@ def assign_labels(
             indices = torch.nonzero(labels == i).view(-1)
 
             # Compute average firing rates for this label.
+            selected_spikes = torch.index_select(
+                spikes, dim=0, index=torch.tensor(indices)
+            )
             rates[:, i] = alpha * rates[:, i] + (
-                torch.sum(spikes[indices], 0) / n_labeled
+                torch.sum(selected_spikes, 0) / n_labeled
             )
 
     # Compute proportions of spike activity per class.
@@ -111,6 +114,8 @@ def all_activity(
 
     # Sum over time dimension (spike ordering doesn't matter).
     spikes = spikes.sum(1)
+    if spikes.is_sparse:
+        spikes = spikes.to_dense()
 
     rates = torch.zeros((n_samples, n_labels), device=spikes.device)
     for i in range(n_labels):
@@ -152,6 +157,8 @@ def proportion_weighting(
 
     # Sum over time dimension (spike ordering doesn't matter).
     spikes = spikes.sum(1)
+    if spikes.is_sparse:
+        spikes = spikes.to_dense()
 
     rates = torch.zeros((n_samples, n_labels), device=spikes.device)
     for i in range(n_labels):

bindsnet/learning/MCC_learning.py

@@ -102,7 +102,12 @@ def update(self, **kwargs) -> None:
         if ((self.min is not None) or (self.max is not None)) and not isinstance(
             self, NoOp
         ):
-            self.feature_value.clamp_(self.min, self.max)
+            if self.feature_value.is_sparse:
+                self.feature_value = (
+                    self.feature_value.to_dense().clamp_(self.min, self.max).to_sparse()
+                )
+            else:
+                self.feature_value.clamp_(self.min, self.max)
 
     @abstractmethod
     def reset_state_variables(self) -> None:
@@ -247,10 +252,15 @@ def _connection_update(self, **kwargs) -> None:
                         torch.mean(self.average_buffer_pre, dim=0) * self.connection.dt
                     )
             else:
-                self.feature_value -= (
-                    self.reduction(torch.bmm(source_s, target_x), dim=0)
-                    * self.connection.dt
-                )
+                if self.feature_value.is_sparse:
+                    self.feature_value -= (
+                        torch.bmm(source_s, target_x) * self.connection.dt
+                    ).to_sparse()
+                else:
+                    self.feature_value -= (
+                        self.reduction(torch.bmm(source_s, target_x), dim=0)
+                        * self.connection.dt
+                    )
             del source_s, target_x
 
         # Post-synaptic update.
@@ -278,10 +288,15 @@ def _connection_update(self, **kwargs) -> None:
                         torch.mean(self.average_buffer_post, dim=0) * self.connection.dt
                     )
             else:
-                self.feature_value += (
-                    self.reduction(torch.bmm(source_x, target_s), dim=0)
-                    * self.connection.dt
-                )
+                if self.feature_value.is_sparse:
+                    self.feature_value += (
+                        torch.bmm(source_x, target_s) * self.connection.dt
+                    ).to_sparse()
+                else:
+                    self.feature_value += (
+                        self.reduction(torch.bmm(source_x, target_s), dim=0)
+                        * self.connection.dt
+                    )
             del source_x, target_s
 
         super().update()
@@ -508,16 +523,16 @@ def _connection_update(self, **kwargs) -> None:
                 self.average_buffer_index + 1
             ) % self.average_update
 
-            if self.continues_update:
-                self.feature_value += self.nu[0] * torch.mean(
-                    self.average_buffer, dim=0
-                )
-            elif self.average_buffer_index == 0:
-                self.feature_value += self.nu[0] * torch.mean(
-                    self.average_buffer, dim=0
-                )
+            if self.continues_update or self.average_buffer_index == 0:
+                update = self.nu[0] * torch.mean(self.average_buffer, dim=0)
+                if self.feature_value.is_sparse:
+                    update = update.to_sparse()
+                self.feature_value += update
         else:
-            self.feature_value += self.nu[0] * self.reduction(update, dim=0)
+            update = self.nu[0] * self.reduction(update, dim=0)
+            if self.feature_value.is_sparse:
+                update = update.to_sparse()
+            self.feature_value += update
 
         # Update P^+ and P^- values.
         self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus)
@@ -686,14 +701,16 @@ def _connection_update(self, **kwargs) -> None:
                 self.average_buffer_index + 1
             ) % self.average_update
 
-            if self.continues_update:
-                self.feature_value += torch.mean(self.average_buffer, dim=0)
-            elif self.average_buffer_index == 0:
-                self.feature_value += torch.mean(self.average_buffer, dim=0)
+            if self.continues_update or self.average_buffer_index == 0:
+                update = torch.mean(self.average_buffer, dim=0)
+                if self.feature_value.is_sparse:
+                    update = update.to_sparse()
+                self.feature_value += update
         else:
-            self.feature_value += (
-                self.nu[0] * self.connection.dt * reward * self.eligibility_trace
-            )
+            update = self.nu[0] * self.connection.dt * reward * self.eligibility_trace
+            if self.feature_value.is_sparse:
+                update = update.to_sparse()
+            self.feature_value += update
 
         # Update P^+ and P^- values.
         self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus)  # Decay

bindsnet/learning/learning.py

@@ -98,7 +98,10 @@ def update(self) -> None:
             (self.connection.wmin != -np.inf).any()
             or (self.connection.wmax != np.inf).any()
         ) and not isinstance(self, NoOp):
-            self.connection.w.clamp_(self.connection.wmin, self.connection.wmax)
+            if self.connection.w.is_sparse:
+                raise Exception("SparseConnection isn't supported for wmin\\wmax")
+            else:
+                self.connection.w.clamp_(self.connection.wmin, self.connection.wmax)
 
 
 class NoOp(LearningRule):
@@ -396,7 +399,10 @@ def _connection_update(self, **kwargs) -> None:
         if self.nu[0].any():
             source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float()
             target_x = self.target.x.view(batch_size, -1).unsqueeze(1) * self.nu[0]
-            self.connection.w -= self.reduction(torch.bmm(source_s, target_x), dim=0)
+            update = self.reduction(torch.bmm(source_s, target_x), dim=0)
+            if self.connection.w.is_sparse:
+                update = update.to_sparse()
+            self.connection.w -= update
             del source_s, target_x
 
         # Post-synaptic update.
@@ -405,7 +411,10 @@ def _connection_update(self, **kwargs) -> None:
                 self.target.s.view(batch_size, -1).unsqueeze(1).float() * self.nu[1]
             )
             source_x = self.source.x.view(batch_size, -1).unsqueeze(2)
-            self.connection.w += self.reduction(torch.bmm(source_x, target_s), dim=0)
+            update = self.reduction(torch.bmm(source_x, target_s), dim=0)
+            if self.connection.w.is_sparse:
+                update = update.to_sparse()
+            self.connection.w += update
             del source_x, target_s
 
         super().update()
@@ -1113,10 +1122,14 @@ def _connection_update(self, **kwargs) -> None:
 
         # Pre-synaptic update.
         update = self.reduction(torch.bmm(source_s, target_x), dim=0)
+        if self.connection.w.is_sparse:
+            update = update.to_sparse()
         self.connection.w += self.nu[0] * update
 
         # Post-synaptic update.
         update = self.reduction(torch.bmm(source_x, target_s), dim=0)
+        if self.connection.w.is_sparse:
+            update = update.to_sparse()
         self.connection.w += self.nu[1] * update
 
         super().update()
@@ -1542,8 +1555,10 @@ def _connection_update(self, **kwargs) -> None:
             a_minus = torch.tensor(a_minus, device=self.connection.w.device)
 
         # Compute weight update based on the eligibility value of the past timestep.
-        update = reward * self.eligibility
-        self.connection.w += self.nu[0] * self.reduction(update, dim=0)
+        update = self.reduction(reward * self.eligibility, dim=0)
+        if self.connection.w.is_sparse:
+            update = update.to_sparse()
+        self.connection.w += self.nu[0] * update
 
         # Update P^+ and P^- values.
         self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus)
@@ -2214,10 +2229,11 @@ def _connection_update(self, **kwargs) -> None:
         self.eligibility_trace *= torch.exp(-self.connection.dt / self.tc_e_trace)
         self.eligibility_trace += self.eligibility / self.tc_e_trace
 
+        update = self.nu[0] * self.connection.dt * reward * self.eligibility_trace
+        if self.connection.w.is_sparse:
+            update = update.to_sparse()
         # Compute weight update.
-        self.connection.w += (
-            self.nu[0] * self.connection.dt * reward * self.eligibility_trace
-        )
+        self.connection.w += update
 
         # Update P^+ and P^- values.
         self.p_plus *= torch.exp(-self.connection.dt / self.tc_plus)
@@ -2936,6 +2952,9 @@ def _connection_update(self, **kwargs) -> None:
         ) * source_x[:, None]
 
         # Compute weight update.
-        self.connection.w += self.nu[0] * reward * self.eligibility_trace
+        update = self.nu[0] * reward * self.eligibility_trace
+        if self.connection.w.is_sparse:
+            update = update.to_sparse()
+        self.connection.w += update
 
         super().update()

bindsnet/models/models.py

@@ -4,6 +4,7 @@
 import torch
 from scipy.spatial.distance import euclidean
 from torch.nn.modules.utils import _pair
+from torch import device
 
 from bindsnet.learning import PostPre
 from bindsnet.learning.MCC_learning import PostPre as MMCPostPre
@@ -101,6 +102,8 @@ def __init__(
         self,
         n_inpt: int,
         device: str = "cpu",
+        batch_size: int = None,
+        sparse: bool = False,
         n_neurons: int = 100,
         exc: float = 22.5,
         inh: float = 17.5,
@@ -193,25 +196,31 @@ def __init__(
                     reduction=reduction,
                     nu=nu,
                     learning_rule=MMCPostPre,
+                    sparse=sparse,
+                    batch_size=batch_size,
                 )
             ],
         )
         w = self.exc * torch.diag(torch.ones(self.n_neurons))
+        if sparse:
+            w = w.unsqueeze(0).expand(batch_size, -1, -1)
         exc_inh_conn = MulticompartmentConnection(
             source=exc_layer,
             target=inh_layer,
             device=device,
-            pipeline=[Weight("weight", w, value_dtype=w_dtype, range=[0, self.exc])],
+            pipeline=[Weight("weight", w, value_dtype=w_dtype, range=[0, self.exc], sparse=sparse)],
         )
         w = -self.inh * (
             torch.ones(self.n_neurons, self.n_neurons)
             - torch.diag(torch.ones(self.n_neurons))
         )
+        if sparse:
+            w = w.unsqueeze(0).expand(batch_size, -1, -1)
         inh_exc_conn = MulticompartmentConnection(
             source=inh_layer,
             target=exc_layer,
             device=device,
-            pipeline=[Weight("weight", w, value_dtype=w_dtype, range=[-self.inh, 0])],
+            pipeline=[Weight("weight", w, value_dtype=w_dtype, range=[-self.inh, 0], sparse=sparse)],
         )
 
         # Add to network

bindsnet/network/monitors.py

@@ -45,6 +45,7 @@ def __init__(
         time: Optional[int] = None,
         batch_size: int = 1,
         device: str = "cpu",
+        sparse: Optional[bool] = False,
     ):
         # language=rst
         """
@@ -62,6 +63,7 @@ def __init__(
         self.time = time
         self.batch_size = batch_size
         self.device = device
+        self.sparse = sparse
 
         # if time is not specified the monitor variable accumulate the logs
         if self.time is None:
@@ -98,11 +100,12 @@ def record(self) -> None:
         for v in self.state_vars:
             data = getattr(self.obj, v).unsqueeze(0)
             # self.recording[v].append(data.detach().clone().to(self.device))
-            self.recording[v].append(
-                torch.empty_like(data, device=self.device, requires_grad=False).copy_(
-                    data, non_blocking=True
-                )
-            )
+            record = torch.empty_like(
+                data, device=self.device, requires_grad=False
+            ).copy_(data, non_blocking=True)
+            if self.sparse:
+                record = record.to_sparse()
+            self.recording[v].append(record)
             # remove the oldest element (first in the list)
             if self.time is not None:
                 self.recording[v].pop(0)

bindsnet/network/network.py

@@ -19,7 +19,9 @@ def load(file_name: str, map_location: str = "cpu", learning: bool = None) -> "N
     :param learning: Whether to load with learning enabled. Default loads value from
         disk.
     """
-    network = torch.load(open(file_name, "rb"), map_location=map_location)
+    network = torch.load(
+        open(file_name, "rb"), map_location=map_location, weights_only=False
+    )
     if learning is not None and "learning" in vars(network):
         network.learning = learning
 
@@ -191,6 +193,7 @@ def save(self, file_name: str) -> None:
             # Save the network to disk.
             network.save(str(Path.home()) + '/network.pt')
         """
+        torch.serialization.add_safe_globals([self])
         torch.save(self, open(file_name, "wb"))
 
     def clone(self) -> "Network":