Merge branch 'master' into hananel

Author: Hananel-Hazan

.travis.yml

@@ -1,8 +1,9 @@
 language: python
-dist: xenial
+dist: bionic
 python:
  - 3.6
  - 3.7
+ - 3.8
 install:
  - pip install . --progress-bar off
 script:

bindsnet/encoding/encoders.py

@@ -86,16 +86,18 @@ def __init__(self, time: int, dt: float = 1.0, **kwargs):
 
 
 class PoissonEncoder(Encoder):
-    def __init__(self, time: int, dt: float = 1.0, **kwargs):
+    def __init__(self, time: int, dt: float = 1.0, approx: bool = False, **kwargs):
         # language=rst
         """
         Creates a callable PoissonEncoder which encodes as defined in
         ``bindsnet.encoding.poisson`
 
         :param time: Length of Poisson spike train per input variable.
         :param dt: Simulation time step.
+        :param approx: Bool: use alternate faster, less accurate computation.
+
         """
-        super().__init__(time, dt=dt, **kwargs)
+        super().__init__(time, dt=dt, approx=approx, **kwargs)
 
         self.enc = encodings.poisson
 

bindsnet/encoding/encodings.py

@@ -98,7 +98,12 @@ def bernoulli(
 
 
 def poisson(
-    datum: torch.Tensor, time: int, dt: float = 1.0, device="cpu", **kwargs
+    datum: torch.Tensor,
+    time: int,
+    dt: float = 1.0,
+    device="cpu",
+    approx=False,
+    **kwargs
 ) -> torch.Tensor:
     # language=rst
     """
@@ -110,6 +115,8 @@ def poisson(
     :param datum: Tensor of shape ``[n_1, ..., n_k]``.
     :param time: Length of Poisson spike train per input variable.
     :param dt: Simulation time step.
+    :param device: target destination of poisson spikes.
+    :param approx: Bool: use alternate faster, less accurate computation.
     :return: Tensor of shape ``[time, n_1, ..., n_k]`` of Poisson-distributed spikes.
     """
     assert (datum >= 0).all(), "Inputs must be non-negative"
@@ -119,28 +126,36 @@ def poisson(
     datum = datum.flatten()
     time = int(time / dt)
 
-    # Compute firing rates in seconds as function of data intensity,
-    # accounting for simulation time step.
-    rate = torch.zeros(size, device=device)
-    rate[datum != 0] = 1 / datum[datum != 0] * (1000 / dt)
-
-    # Create Poisson distribution and sample inter-spike intervals
-    # (incrementing by 1 to avoid zero intervals).
-    dist = torch.distributions.Poisson(rate=rate)
-    intervals = dist.sample(sample_shape=torch.Size([time + 1]))
-    intervals[:, datum != 0] += (intervals[:, datum != 0] == 0).float()
-
-    # Calculate spike times by cumulatively summing over time dimension.
-    times = torch.cumsum(intervals, dim=0).long()
-    times[times >= time + 1] = 0
-
-    # Create tensor of spikes.
-    spikes = torch.zeros([time + 1, size], device=device, dtype=torch.bool)
-    spikes[times, torch.arange(size)] = 1
-    spikes = spikes[1:]
-
-    return spikes.view(time, *shape)
+    if approx:
+        # random normal power awful approximation
+        x = torch.randn((time, size), device=device).abs()
+        x = torch.pow(x, (datum * 0.11 + 5) / 50)
+        y = torch.tensor(x < 0.6, dtype=torch.bool, device=device)
 
+        return y.view(time, *shape).byte()
+    else:
+        # Compute firing rates in seconds as function of data intensity,
+        # accounting for simulation time step.
+        rate = torch.zeros(size, device=device)
+        rate[datum != 0] = 1 / datum[datum != 0] * (1000 / dt)
+
+        # Create Poisson distribution and sample inter-spike intervals
+        # (incrementing by 1 to avoid zero intervals).
+        dist = torch.distributions.Poisson(rate=rate)
+        intervals = dist.sample(sample_shape=torch.Size([time + 1]))
+        intervals[:, datum != 0] += (intervals[:, datum != 0] == 0).float()
+
+        # Calculate spike times by cumulatively summing over time dimension.
+        times = torch.cumsum(intervals, dim=0).long()
+        times[times >= time + 1] = 0
+
+        # Create tensor of spikes.
+        spikes = torch.zeros(time + 1, size, device=device).byte()
+        spikes[times, torch.arange(size)] = 1
+        spikes = spikes[1:]
+
+        return spikes.view(time, *shape)
+      
 
 def rank_order(
     datum: torch.Tensor, time: int, dt: float = 1.0, **kwargs

bindsnet/learning/learning.py

@@ -52,7 +52,9 @@ def __init__(
         elif isinstance(nu, float) or isinstance(nu, int):
             nu = [nu, nu]
 
-        self.nu = nu
+        self.nu = torch.zeros(2, dtype=torch.float)
+        self.nu[0] = nu[0]
+        self.nu[1] = nu[1]
 
         # Parameter update reduction across minibatch dimension.
         if reduction is None:
@@ -64,7 +66,7 @@ def __init__(
             self.reduction = reduction
 
         # Weight decay.
-        self.weight_decay = weight_decay
+        self.weight_decay = 1.0 - weight_decay if weight_decay else 1.0
 
     def update(self) -> None:
         # language=rst
@@ -73,7 +75,7 @@ def update(self) -> None:
         """
         # Implement weight decay.
         if self.weight_decay:
-            self.connection.w -= self.weight_decay * self.connection.w
+            self.connection.w *= self.weight_decay
 
         # Bound weights.
         if (
@@ -177,20 +179,21 @@ def _connection_update(self, **kwargs) -> None:
         """
         batch_size = self.source.batch_size
 
-        source_s = self.source.s.view(batch_size, -1).unsqueeze(2).float()
-        source_x = self.source.x.view(batch_size, -1).unsqueeze(2)
-        target_s = self.target.s.view(batch_size, -1).unsqueeze(1).float()
-        target_x = self.target.x.view(batch_size, -1).unsqueeze(1)
-
         # Pre-synaptic update.
         if self.nu[0]:
-            update = self.reduction(torch.bmm(source_s, target_x), dim=0)
-            self.connection.w -= self.nu[0] * update
+            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)
+            del source_s, target_x
 
         # Post-synaptic update.
         if self.nu[1]:
-            update = self.reduction(torch.bmm(source_x, target_s), dim=0)
-            self.connection.w += self.nu[1] * update
+            target_s = (
+                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)
+            del source_x, target_s
 
         super().update()
 

bindsnet/network/network.py

@@ -4,7 +4,7 @@
 import torch
 
 from .monitors import AbstractMonitor
-from .nodes import Nodes
+from .nodes import Nodes, CSRMNodes
 from .topology import AbstractConnection
 from ..learning.reward import AbstractReward
 
@@ -226,12 +226,23 @@ def _get_inputs(self, layers: Iterable = None) -> Dict[str, torch.Tensor]:
                 target = self.connections[c].target
 
                 if not c[1] in inputs:
-                    inputs[c[1]] = torch.zeros(
-                        self.batch_size, *target.shape, device=target.s.device
-                    )
+                    if isinstance(target, CSRMNodes):
+                        inputs[c[1]] = torch.zeros(
+                            self.batch_size,
+                            target.res_window_size,
+                            *target.shape,
+                            device=target.s.device
+                        )
+                    else:
+                        inputs[c[1]] = torch.zeros(
+                            self.batch_size, *target.shape, device=target.s.device
+                        )
 
                 # Add to input: source's spikes multiplied by connection weights.
-                inputs[c[1]] += self.connections[c].compute(source.s)
+                if isinstance(target, CSRMNodes):
+                    inputs[c[1]] += self.connections[c].compute_window(source.s)
+                else:
+                    inputs[c[1]] += self.connections[c].compute(source.s)
 
         return inputs