Updated Learning Rule

Author: FinHerbig

and_net.py

@@ -10,17 +10,12 @@ def __init__(self, neurons, connections):
         self.neurons = []  # A list of lif_neuron objects
         self.connections = []  # A list of lif_connection objects
 
+    run_time = 1000
+
     # Function calculates current from an array of spikes from a neuron's output activity
     def spikes_to_current(self, a_spikes, conversion_factor):
 
-        spike_count = 0
-        for i in range(len(a_spikes)):
-            if a_spikes[i] == 1:
-                spike_count += 1
-
-        spikes_per_second = spike_count / len(a_spikes)
-
-        return spikes_per_second * conversion_factor * 100000
+        return sum(a_spikes) / len(a_spikes) * conversion_factor * 50000
 
     # Configure the network to solve problem 3
     def create_simple_net(self):
@@ -47,17 +42,17 @@ def spikes_to_binary(self, output_neuron, threshold=4):
             if output_neuron.output[i] == 1:
                 spike_count += 1
 
-        spike_frequency = spike_count / len(output_neuron.output)
+        spike_frequency = spike_count
 
         if (spike_frequency > threshold):
             return 1
 
         return 0
 
-    # Converts a single bit into 1000 ms array of spikes
+    # Converts a single bit into an array of spikes
     # A value of 0 makes 5Hz spikes
     # A value of 1 makes 15Hz spikes
-    def binary_to_spikes(self, val, nsteps=1000):
+    def binary_to_spikes(self, val, nsteps=run_time):
 
         a_spikes = [0] * nsteps
         nspikes = 5
@@ -66,33 +61,36 @@ def binary_to_spikes(self, val, nsteps=1000):
             nspikes = 15
 
         interval = int(nsteps / nspikes)
-        for i in range(1000):
+        for i in range(nsteps):
             if (i % interval == 0):
                 a_spikes[i] = 1
 
         return a_spikes
 
     # Runs the neural net
     # Maybe include option to run without training neuron
-    def run_net(self, input):
+    def run_net(self, input, time = run_time):
         # Initializes a current for the three input neurons
         xIn = self.spikes_to_current(self.binary_to_spikes(input[0]), self.connections[0].weight)
         yIn = self.spikes_to_current(self.binary_to_spikes(input[1]), self.connections[1].weight)
         # Change and to xor/or
-        teachIn = self.spikes_to_current(self.binary_to_spikes(input[1] and input[0]), self.connections[2].weight)
-        self.neurons[0].sim(xIn, 1000)
-        self.neurons[1].sim(yIn, 1000)
-        self.neurons[2].sim(teachIn, 1000)
+        #teachIn = self.spikes_to_current(self.binary_to_spikes(input[1] and input[0]), self.connections[2].weight)
+        self.neurons[0].sim(xIn, time)
+        self.neurons[1].sim(yIn, time)
+        #self.neurons[2].sim(teachIn, time)
         # Calculates the input current for the output by using an or function on all 3 spike outputs 
         outIn = []
-        for i in range(1000):
-            outIn.append(self.neurons[0].output[i] or self.neurons[1].output[i] or self.neurons[2].output[i])
-        self.neurons[3].sim(self.spikes_to_current(outIn, 1), 1000)
+        for i in range(time):
+            if(self.neurons[0].output[i] == 1 or self.neurons[1].output[i] == 1):
+                outIn.append(1)
+            else:
+                outIn.append(0)
+        #Conversion factor scales # of spikes from output
+        self.neurons[3].sim(self.spikes_to_current(outIn, .5), time)
         output = 0
-        for i in range(1000):
+        for i in range(time):
             output = output + self.neurons[3].output[i]
         if output > 5:
             return 1
         else:
-            return 0
-
+            return 0

training.py

@@ -1,19 +1,19 @@
 from and_net import and_net
-import matplotlib.pyplot as plt
+#import matplotlib.pyplot as plt
 
 net = and_net([], [])
 net.create_simple_net()
 # X at [0], Y at [1], Teacher at [2]
-net.connections[0].weight = 1
-net.connections[1].weight = 1
+net.connections[0].weight = .6
+net.connections[1].weight = .4
 net.connections[2].weight = 1
 # data[0] holds X, data[1] holds Y, output calculated by data[0][i] && data[1][i]
 data = []
 i = 0
 j = 0
 k = 0
 
-
+"""
 def raster_plot(net):
     plt.figure()
     plt.title('Raster plot for network activity')
@@ -46,7 +46,7 @@ def raster_plot(net):
             plt.axvline(k)
 
     plt.show()
-
+"""
 
 #lines = open(input("Enter Filepath: "), "r").readlines()
 lines = open("data.txt", "r").readlines()
@@ -63,21 +63,32 @@ def raster_plot(net):
 # Trains the network
 for r in range(runs):
     net.run_net(data[r])
-    #TODO Find better formula
-    for i in range(1000):
-        for j in range(2):
-            if net.neurons[j].output[i] == net.neurons[3].output[i] == 1:
-                #increase
-                net.connections[j].weight += .1
-            elif net.neurons[j].output[i] == 1 and net.neurons[3].output[i] == 0:
-                #decrease
-                if(net.connections[j].weight != 0):
-                    net.connections[j].weight -= .1
+    time = len(net.neurons[0].output)
+    w_max = 1
+    for i in range(int(time/100)-1):
+        #Finds rate for each neuron in a time step of 100
+        v_x = sum(net.neurons[0].output[100*i:100*(i+1)])
+        v_y = sum(net.neurons[1].output[100*i:100*(i+1)])
+        v_o = sum(net.neurons[3].output[100*i:100*(i+1)])
+        #Sets a_corr value
+        a_corr_x = w_max - net.connections[0].weight
+        a_corr_y = w_max - net.connections[1].weight
+        #If the rate is below 5, set value to 0
+        if v_x <= 5:
+            v_x = 0
+        if v_y <= 5:
+            v_y = 0
+        if v_y <= 5:
+            v_y = 0
+        #Hebb with postsynaptic LTP/LTD threshold
+        #TODO change .01 to something else?
+        net.connections[0].weight += a_corr_x * v_x * (v_o - .01)
+        net.connections[1].weight += a_corr_y * v_y * (v_o - .01)
     print((data[r][0] and data[r][1]), "||", net.spikes_to_binary(net.neurons[3]), "\n")
     x_spikes = sum(net.neurons[0].output)
     y_spikes = sum(net.neurons[1].output)
     o_spikes = sum(net.neurons[3].output)
     print("X =", net.connections[0].weight, x_spikes, "\nY =", net.connections[1].weight, y_spikes, "\n", o_spikes)
     for i in range(3):
         net.neurons[i].clear
-raster_plot(net)
+#raster_plot(net)