Merge pull request #4 from Hananel-Hazan/dan

Adding documentation strings; adding integrate-and-fire (IF) neurons; minor tweaks.

Author: Hananel-Hazan

CONTRIBUTING.md

@@ -3,7 +3,7 @@
 To clone this project locally, issue
 
 ```
-git clone https://github.com/djsaunde/spiketorch.git  # 
+git clone https://github.com/djsaunde/spiketorch.git  # clones spiketorch repository
 ```
 
 in the directory of your choice. This will place the repository's code in a directory titled `spiketorch`.

bindsnet/analysis/__init__.py

@@ -72,9 +72,6 @@ def run(self, inpts, time):
 		for key in self.layers:
 			spikes[key] = torch.zeros(self.layers[key].n, timesteps)
 
-		for monitor in self.monitors:
-			self.monitors[monitor].reset()
-
 		# Get input to all layers.
 		inpts.update(self.get_inputs())
 
@@ -117,4 +114,26 @@ def reset(self):
 			self.layers[layer].reset()
 
 		for connection in self.connections:
-			self.connections[connection].reset()
+			self.connections[connection].reset()
+
+		for monitor in self.monitors:
+			self.monitors[monitor].reset()
+
+class Monitor:
+	'''
+	Records state variables of interest.
+	'''
+	def __init__(self, obj, state_vars):
+		self.obj = obj
+		self.state_vars = state_vars
+		self.recording = {var : torch.Tensor() for var in self.state_vars}
+
+	def get(self, var):
+		return self.recording[var]
+
+	def record(self):
+		for var in self.state_vars:
+			self.recording[var] = torch.cat([self.recording[var], self.obj.__dict__[var]])
+
+	def reset(self):
+		self.recording = {var : torch.Tensor() for var in self.state_vars}

bindsnet/datasets/__init__.py

@@ -29,6 +29,14 @@ class Input(Nodes):
 	Layer of nodes with user-specified spiking behavior.
 	'''
 	def __init__(self, n, traces=False, trace_tc=5e-2):
+		'''
+		Instantiates a layer of input neurons.
+		
+		Inputs:
+			n (int): The number of neurons in the layer.
+			traces (bool): Whether to record decaying spike traces.
+			trace_tc (float): Time constant of spike trace decay.
+		'''
 		super().__init__()
 
 		self.n = n  # No. of neurons.
@@ -43,6 +51,11 @@ def step(self, inpts, dt):
 		'''
 		On each simulation step, set the spikes of the
 		population equal to the inputs.
+
+		Inputs:
+			inpts (torch.FloatTensor or torch.cuda.FloatTensor): Matrix
+				of inputs to the layer, with size equal to self.n.
+			dt (float): Simulation time step.
 		'''
 		# Set spike occurrences to input values.
 		self.s = inpts
@@ -53,6 +66,9 @@ def step(self, inpts, dt):
 			self.x[self.s] = 1
 
 	def reset(self):
+		'''
+		Resets relevant state variables.
+		'''
 		self.s = torch.zeros_like(torch.Tensor(n))  # Spike occurences.
 
 		if self.traces:
@@ -61,7 +77,7 @@ def reset(self):
 
 class McCullochPitts(Nodes):
 	'''
-	McCulloch-Pitts neuron.
+	Layer of McCulloch-Pitts neurons.
 	'''
 	def __init__(self, n, traces=False, threshold=1.0, trace_tc=5e-2):
 		'''
@@ -88,8 +104,8 @@ def step(self, inpts, dt):
 		Runs a single simulation step.
 
 		Inputs:
-			inpts (torch.FloatTensor or torch.cuda.FloatTensor): Vector of
-				inputs to the layer, with size equal to self.n.
+			inpts (torch.FloatTensor or torch.cuda.FloatTensor): Vector
+				of inputs to the layer, with size equal to self.n.
 			dt (float): Simulation time step.
 		'''
 		self.s = inpts >= self.threshold  # Check for spiking neurons.
@@ -100,19 +116,108 @@ def step(self, inpts, dt):
 			self.x[self.s] = 1
 
 	def reset(self):
+		'''
+		Resets relevant state variables.
+		'''
 		self.s = torch.zeros_like(torch.Tensor(n))  # Spike occurences.
 
 		if self.traces:
 			self.x = torch.zeros_like(torch.Tensor(n))  # Firing traces.
 
 
+class IFNodes(Nodes):
+	'''
+	Layer of integrate-and-fire (IF) neurons.
+	'''
+	def __init__(self, n, traces=False, threshold=-52.0, reset=-65.0,
+										refractory=5, trace_tc=5e-2):
+		'''
+		Instantiates a layer of IF neurons.
+		
+		Inputs:
+			n (int): The number of neurons in the layer.
+			traces (bool): Whether to record decaying spike traces.
+			threshold (float): Value at which to record a spike.
+			reset (float): Value to which neurons are set to following a spike.
+			refractory (int): The number of timesteps following
+				a spike during which a neuron cannot spike again.
+			trace_tc (float): Time constant of spike trace decay.
+		'''
+		
+		super().__init__()
+
+		self.n = n  # No. of neurons.
+		self.traces = traces  # Whether to record synpatic traces.
+		self.reset = reset  # Post-spike reset voltage.
+		self.threshold = threshold  # Spike threshold voltage.
+		self.refractory = refractory  # Post-spike refractory period.
+
+		self.v = self.reset * torch.ones(n)  # Neuron voltages.
+		self.s = torch.zeros(n)  # Spike occurences.
+
+		if traces:
+			self.x = torch.zeros(n)  # Firing traces.
+			self.trace_tc = trace_tc  # Rate of decay of spike trace time constant.
+
+		self.refrac_count = torch.zeros(n)  # Refractory period counters.
+
+	def step(self, inpts, dt):
+		'''
+		Runs a single simulation step.
+
+		Inputs:
+			inpts (torch.FloatTensor or torch.cuda.FloatTensor): Vector
+				of inputs to the layer, with size equal to self.n.
+			dt (float): Simulation time step.
+		'''
+		# Decrement refractory counters.
+		self.refrac_count[self.refrac_count != 0] -= dt
+
+		# Check for spiking neurons.
+		self.s = (self.v >= self.threshold) * (self.refrac_count == 0)
+		self.refrac_count[self.s] = self.refractory
+		self.v[self.s] = self.reset
+
+		# Integrate input and decay voltages.
+		self.v += inpts
+
+		if self.traces:
+			# Decay and set spike traces.
+			self.x -= dt * self.trace_tc * self.x
+			self.x[self.s] = 1.0
+
+	def reset(self):
+		'''
+		Resets relevant state variables.
+		'''
+		self.s = torch.zeros_like(torch.Tensor(n))  # Spike occurences.
+		self.v = self.reset * torch.ones(n)  # Neuron voltages.
+		self.refrac_count = torch.zeros(n)  # Refractory period counters.
+
+		if self.traces:
+			self.x = torch.zeros_like(torch.Tensor(n))  # Firing traces.
+
+
 class LIFNodes(Nodes):
 	'''
-	Group of leaky integrate-and-fire neurons.
+	Layer of leaky integrate-and-fire (LIF) neurons.
 	'''
-	def __init__(self, n, traces=False, rest=-65.0, reset=-65.0, threshold=-52.0, 
+	def __init__(self, n, traces=False, threshold=-52.0, rest=-65.0, reset=-65.0,
 								refractory=5, voltage_decay=1e-2, trace_tc=5e-2):
+		'''
+		Instantiates a layer of LIF neurons.
 		
+		Inputs:
+			n (int): The number of neurons in the layer.
+			traces (bool): Whether to record decaying spike traces.
+			threshold (float): Value at which to record a spike.
+			rest (float): Value to which neuron voltages decay.
+			reset (float): Value to which neurons are set to following a spike.
+			refractory (int): The number of timesteps following
+				a spike during which a neuron cannot spike again.
+			voltage_decay (float): Time constant of neuron voltage decay.
+			trace_tc (float): Time constant of spike trace decay.
+		'''
 		super().__init__()
 
 		self.n = n  # No. of neurons.
@@ -133,9 +238,14 @@ def __init__(self, n, traces=False, rest=-65.0, reset=-65.0, threshold=-52.0,
 		self.refrac_count = torch.zeros(n)  # Refractory period counters.
 
 	def step(self, inpts, dt):
-		# Decay voltages.
-		self.v -= dt * self.voltage_decay * (self.v - self.rest)
+		'''
+		Runs a single simulation step.
 
+		Inputs:
+			inpts (torch.FloatTensor or torch.cuda.FloatTensor): Vector
+				of inputs to the layer, with size equal to self.n.
+			dt (float): Simulation time step.
+		'''
 		if self.traces:
 			# Decay spike traces.
 			self.x -= dt * self.trace_tc * self.x
@@ -152,10 +262,14 @@ def step(self, inpts, dt):
 		self.v += inpts
 
 		if self.traces:
-			# Setting synaptic traces.
+			# Decay and set spike traces.
+			self.x -= dt * self.trace_tc * self.x
 			self.x[self.s] = 1.0
 
 	def reset(self):
+		'''
+		Resets relevant state variables.
+		'''
 		self.s = torch.zeros_like(torch.Tensor(n))  # Spike occurences.
 		self.v = self.rest * torch.ones(n)  # Neuron voltages.
 		self.refrac_count = torch.zeros(n)  # Refractory period counters.