IZNN neurons no longer have a simulation time step member; this value is now passed to the Neuron.advance method and the IzNetwork.advance method.

Added common IZNN neuron parameter sets to the iznn module for convenience.
 Comment & docstring edits.

Author: CodeReclaimers

examples/xor/xor2_parallel.py

@@ -6,9 +6,8 @@
 inter-process communication.
 
 If your evaluation function is what's taking up most of your processing time
-(and you should probably check by using a profiler while running
-single-process), you should see a significant performance improvement by
-evaluating in parallel.
+(and you should check by using a profiler while running single-process),
+you should see a significant performance improvement by evaluating in parallel.
 
 This example is only intended to show how to do a parallel experiment
 in neat-python.  You can of course roll your own parallelism mechanism

examples/xor/xor2_spiking.py

@@ -10,10 +10,12 @@
 xor_inputs = ((0, 0), (0, 1), (1, 0), (1, 1))
 xor_outputs = (0, 1, 1, 0)
 
+# Use fast spiking neurons.
+neuron_params = iznn.FAST_SPIKING_PARAMS
 # Maximum amount of simulated time (in milliseconds) to wait for the network to produce an output.
 max_time = 50.0
-# Parameters for "fast spiking" Izhikevich neurons, simulation time step 0.25 millisecond.
-iz_params = [0.1, 0.2, -65.0, 2.0, 0.25]
+# Use a simulation time step of 0.25 millisecond.
+dt = 0.25
 
 
 def compute_output(t0, t1):
@@ -31,9 +33,8 @@ def compute_output(t0, t1):
 
 
 def simulate(genome):
-    # Create a network of Izhikevich neurons based on the given genome.
-    net = iznn.create_phenotype(genome, *iz_params)
-    dt = iz_params[-1]
+    # Create a network of "fast spiking" Izhikevich neurons.
+    net = iznn.create_phenotype(genome, **neuron_params)
     sum_square_error = 0.0
     simulated = []
     for inputData, outputData in zip(xor_inputs, xor_outputs):
@@ -51,7 +52,7 @@ def simulate(genome):
         num_steps = int(max_time / dt)
         for j in range(num_steps):
             t = dt * j
-            output = net.advance()
+            output = net.advance(dt)
 
             # Capture the time and neuron membrane potential for later use if desired.
             for i, n in net.neurons.items():
@@ -103,8 +104,9 @@ def run():
     winner = pop.statistics.best_genome()
     print('\nBest genome:\n{!s}'.format(winner))
     print('\nBest network output:')
-    net = iznn.create_phenotype(winner, *iz_params)
-    dt = iz_params[-1]
+
+    # Create a network of "fast spiking" Izhikevich neurons, simulation time step 0.25 millisecond.
+    net = iznn.create_phenotype(winner, **neuron_params)
     for inputData, outputData in zip(xor_inputs, xor_outputs):
         neuron_data = {}
         for i, n in net.neurons.items():
@@ -115,12 +117,10 @@ def run():
         net.set_inputs(inputData)
         t0 = None
         t1 = None
-        v0 = None
-        v1 = None
         num_steps = int(max_time / dt)
         for j in range(num_steps):
             t = dt * j
-            output = net.advance()
+            output = net.advance(dt)
 
             # Capture the time and neuron membrane potential for later use if desired.
             for i, n in net.neurons.items():

neat/iznn/__init__.py

@@ -9,9 +9,17 @@
 http://www.izhikevich.org/publications/spikes.pdf
 """
 
+REGULAR_SPIKING_PARAMS        = {'a': 0.02, 'b': 0.20, 'c': -65.0, 'd': 8.00}
+INTRINSICALLY_BURSTING_PARAMS = {'a': 0.02, 'b': 0.20, 'c': -55.0, 'd': 4.00}
+CHATTERING_PARAMS             = {'a': 0.02, 'b': 0.20, 'c': -50.0, 'd': 2.00}
+FAST_SPIKING_PARAMS           = {'a': 0.10, 'b': 0.20, 'c': -65.0, 'd': 2.00}
+THALAMO_CORTICAL_PARAMS       = {'a': 0.02, 'b': 0.25, 'c': -65.0, 'd': 0.05}
+RESONATOR_PARAMS              = {'a': 0.10, 'b': 0.25, 'c': -65.0, 'd': 2.00}
+LOW_THRESHOLD_SPIKING_PARAMS  = {'a': 0.02, 'b': 0.25, 'c': -65.0, 'd': 2.00}
+
 
 class Neuron(object):
-    def __init__(self, bias, a, b, c, d, time_step_msec=1.0):
+    def __init__(self, bias, a, b, c, d):
         """
         a, b, c, d are the parameters of this model.
         a: the time scale of the recovery variable.
@@ -20,20 +28,19 @@ def __init__(self, bias, a, b, c, d, time_step_msec=1.0):
         d: after-spike reset of the recovery variable.
 
         The following parameters produce some known spiking behaviors:
-            Regular spiking: a = 0.02, b = 0.2, c = -65.0, d = 8.0
-            Intrinsically bursting: a = 0.02, b = 0.2, c = -55.0, d = 4.0
-            Chattering: a = 0.02, b = 0.2, c = -50.0, d = 2.0
-            Fast spiking: a = 0.1, b = 0.2, c = -65.0, d = 2.0
-            Thalamo-cortical: a = 0.02, b = 0.25, c = -65.0, d = 0.05
-            Resonator: a = 0.1, b = 0.25, c = -65.0, d = 2.0
-            Low-threshold spiking: a = 0.02, b = 0.25, c = -65, d = 2.0
+            Regular spiking:        a = 0.02, b = 0.2,  c = -65.0, d = 8.0
+            Intrinsically bursting: a = 0.02, b = 0.2,  c = -55.0, d = 4.0
+            Chattering:             a = 0.02, b = 0.2,  c = -50.0, d = 2.0
+            Fast spiking:           a = 0.1,  b = 0.2,  c = -65.0, d = 2.0
+            Thalamo-cortical:       a = 0.02, b = 0.25, c = -65.0, d = 0.05
+            Resonator:              a = 0.1,  b = 0.25, c = -65.0, d = 2.0
+            Low-threshold spiking:  a = 0.02, b = 0.25, c = -65.0, d = 2.0
         """
         self.a = a
         self.b = b
         self.c = c
         self.d = d
         self.bias = bias
-        self.dt_msec = time_step_msec
 
         # Membrane potential (millivolts).
         self.v = self.c
@@ -44,9 +51,9 @@ def __init__(self, bias, a, b, c, d, time_step_msec=1.0):
         self.output = 0.0
         self.current = self.bias
 
-    def advance(self):
+    def advance(self, dt_msec):
         """
-        Advances simulation time by 1 ms.
+        Advances simulation time by the given time step in milliseconds.
 
         v' = 0.04 * v^2 + 5v + 140 - u + I
         u' = a * (b * v - u)
@@ -59,9 +66,9 @@ def advance(self):
         # TODO: The need to catch overflows indicates that the current method is
         # not stable for all possible network configurations and states.
         try:
-            self.v += 0.5 * self.dt_msec * (0.04 * self.v ** 2 + 5 * self.v + 140 - self.u + self.current)
-            self.v += 0.5 * self.dt_msec * (0.04 * self.v ** 2 + 5 * self.v + 140 - self.u + self.current)
-            self.u += self.dt_msec * self.a * (self.b * self.v - self.u)
+            self.v += 0.5 * dt_msec * (0.04 * self.v ** 2 + 5 * self.v + 140 - self.u + self.current)
+            self.v += 0.5 * dt_msec * (0.04 * self.v ** 2 + 5 * self.v + 140 - self.u + self.current)
+            self.u += dt_msec * self.a * (self.b * self.v - self.u)
         except OverflowError:
             # Reset without producing a spike.
             self.v = self.c
@@ -97,18 +104,19 @@ def __init__(self, neurons, inputs, outputs, connections):
         self.currents = [0.0] * (1 + max_node)
 
     def set_inputs(self, inputs):
+        """Assign input voltages and reset currents to zero."""
         assert len(inputs) == len(self.inputs)
         for i, v in zip(self.inputs, inputs):
             self.currents[i] = 0.0
             self.neurons[i].current = 0.0
             self.neurons[i].output = v
 
     def reset(self):
-        # Reset all neurons.
+        """Reset all neurons to their default state."""
         for i, n in self.neurons.items():
             n.reset()
 
-    def advance(self):
+    def advance(self, dt_msec):
         # Initialize all non-input neuron currents to the bias value.
         for i, n in self.neurons.items():
             if i not in self.inputs:
@@ -121,12 +129,12 @@ def advance(self):
         for i, n in self.neurons.items():
             if i not in self.inputs:
                 n.current = self.currents[i]
-                n.advance()
+                n.advance(dt_msec)
 
         return [self.neurons[i].output for i in self.outputs]
 
 
-def create_phenotype(genome, a, b, c, d, time_step_msec=1.0):
+def create_phenotype(genome, a, b, c, d):
     """ Receives a genome and returns its phenotype (a neural network) """
 
     neurons = {}
@@ -135,7 +143,7 @@ def create_phenotype(genome, a, b, c, d, time_step_msec=1.0):
     for ng in genome.node_genes.values():
         # TODO: It seems like we should have a separate node gene implementation
         # that optionally encodes more (all?) of the Izhikevich model parameters.
-        neurons[ng.ID] = Neuron(ng.bias, a, b, c, d, time_step_msec)
+        neurons[ng.ID] = Neuron(ng.bias, a, b, c, d)
         if ng.type == 'INPUT':
             inputs.append(ng.ID)
         elif ng.type == 'OUTPUT':

tests/test_iznn.py

@@ -5,25 +5,26 @@
 
 
 def test_basic():
-    n = iznn.Neuron(10, 0.02, 0.2, -65.0, 8.0)
+    n = iznn.Neuron(10, **iznn.REGULAR_SPIKING_PARAMS)
     spike_train = []
     for i in range(1000):
         spike_train.append(n.v)
-        n.advance()
+        n.advance(0.25)
 
 
 def test_network():
-    neurons = {0: iznn.Neuron(0, 0.02, 0.2, -65.0, 8.0),
-               1: iznn.Neuron(0, 0.02, 0.2, -65.0, 8.0),
-               2: iznn.Neuron(0, 0.02, 0.2, -65.0, 8.0)}
+    neurons = {0: iznn.Neuron(0, **iznn.INTRINSICALLY_BURSTING_PARAMS),
+               1: iznn.Neuron(0, **iznn.CHATTERING_PARAMS),
+               2: iznn.Neuron(0, **iznn.FAST_SPIKING_PARAMS),
+               3: iznn.Neuron(0, **iznn.LOW_THRESHOLD_SPIKING_PARAMS)}
     inputs = [0, 1]
     outputs = [2]
     connections = [(0, 2, 0.123), (1, 2, 0.234)]
 
     net = iznn.IzNetwork(neurons, inputs, outputs, connections)
     net.set_inputs([1.0, 0.0])
-    net.advance()
-    net.advance()
+    net.advance(0.25)
+    net.advance(0.25)
 
 
 def test_iznn_evolve():
@@ -35,8 +36,6 @@ def test_iznn_evolve():
 
     # Maximum amount of simulated time (in milliseconds) to wait for the network to produce an output.
     max_time = 50.0
-    # Parameters for "fast spiking" Izhikevich neurons, simulation time step 0.25 millisecond.
-    iz_params = [0.1, 0.2, -65.0, 2.0, 0.25]
 
     def compute_output(t0, t1):
         '''Compute the network's output based on the "time to first spike" of the two output neurons.'''
@@ -53,8 +52,8 @@ def compute_output(t0, t1):
 
     def simulate(genome):
         # Create a network of Izhikevich neurons based on the given genome.
-        net = iznn.create_phenotype(genome, *iz_params)
-        dt = iz_params[-1]
+        net = iznn.create_phenotype(genome, **iznn.THALAMO_CORTICAL_PARAMS)
+        dt = 0.25
         sum_square_error = 0.0
         simulated = []
         for inputData, outputData in zip(xor_inputs, xor_outputs):
@@ -72,7 +71,7 @@ def simulate(genome):
             num_steps = int(max_time / dt)
             for j in range(num_steps):
                 t = dt * j
-                output = net.advance()
+                output = net.advance(dt)
 
                 # Capture the time and neuron membrane potential for later use if desired.
                 for i, n in net.neurons.items():
@@ -125,7 +124,7 @@ def eval_fitness(genomes):
 
     # Verify network output against training data.
     print('\nBest network output:')
-    net = iznn.create_phenotype(winner, *iz_params)
+    net = iznn.create_phenotype(winner, **iznn.RESONATOR_PARAMS)
     sum_square_error, simulated = simulate(winner)
 
     repr(winner)