Added k.inner system

analysis_functions.py

@@ -37,7 +37,7 @@ def calculate_angle_from_history(manager):
         denominator = [np.linalg.norm(state) * np.linalg.norm(pattern) for pattern in patterns]
         # Get the angles and store them
         dis = [a / b for (a, b) in zip(nominator, denominator)]
-        distances[index, :manager.nn.minicolumns] = dis
+        distances[index, :len(patterns)] = dis
 
     return distances
 

network.py

@@ -7,7 +7,7 @@ class BCPNN:
     def __init__(self, hypercolumns, minicolumns, beta=None, w=None, o=None, s=None, a=None, z_pre=None,
                  z_post=None, p_pre=None, p_post=None, p_co=None, G=1.0, tau_m=0.050, g_w=1, g_beta=1,
                  tau_z_pre=0.240, tau_z_post=0.240, tau_p=10.0, tau_a=2.70, g_a=97.0, g_I=10.0,
-                 k=0.0, sigma=1.0, epsilon=1e-10, prng=np.random):
+                 k=0.0, sigma=1.0, epsilon=1e-20, prng=np.random):
         # Initial values are taken from the paper on memory by Marklund and Lansner.
 
         # Random number generator
@@ -187,16 +187,18 @@ def __init__(self, hypercolumns, minicolumns, beta=None, w=None, G=1.0, tau_m=0.
         self.tau_z_post_ampa = tau_z_post_ampa
         self.tau_p = tau_p
         self.tau_a = tau_a
-        self.k = k
         self.g_a = g_a
         self.g_w = g_w
         self.g_w_ampa = g_w_ampa
         self.g_beta = g_beta
         self.g_I = g_I
 
+        self.k = k
+        self.k_inner = False
+
         # If state variables and parameters are not initialized
 
-        self.o = np.ones(self.hypercolumns * self.minicolumns) * (1.0 / self.minicolumns)
+        self.o = np.zeros(self.hypercolumns * self.minicolumns) * (1.0 / self.minicolumns)
         self.s = np.log(np.ones(self.hypercolumns * self.minicolumns) * (1.0 / self.minicolumns))
         self.beta = np.log(np.ones_like(self.o) * (1.0 / self.minicolumns))
 
@@ -309,15 +311,26 @@ def update_continuous(self, dt=1.0, sigma=None):
         self.z_post_ampa += (dt / self.tau_z_post_ampa) * (self.o - self.z_post_ampa)
         self.z_co_ampa = np.outer(self.z_post_ampa, self.z_pre_ampa)
 
-        # Updated the probability of the NMDA connection
-        self.p_pre += (dt / self.tau_p) * (self.z_pre - self.p_pre)
-        self.p_post += (dt / self.tau_p) * (self.z_post - self.p_post)
-        self.p_co += (dt / self.tau_p) * (self.z_co - self.p_co)
+        if self.k_inner:
+            # Updated the probability of the NMDA connection
+            self.p_pre += (dt / self.tau_p) * (self.z_pre - self.p_pre) * self.k
+            self.p_post += (dt / self.tau_p) * (self.z_post - self.p_post) * self.k
+            self.p_co += (dt / self.tau_p) * (self.z_co - self.p_co) * self.k
 
-        # Updated the probability of AMPA connection
-        self.p_pre_ampa += (dt / self.tau_p) * (self.z_pre_ampa - self.p_pre_ampa)
-        self.p_post_ampa += (dt / self.tau_p) * (self.z_post_ampa - self.p_post_ampa)
-        self.p_co_ampa += (dt / self.tau_p) * (self.z_co_ampa - self.p_co_ampa)
+            # Updated the probability of AMPA connection
+            self.p_pre_ampa += (dt / self.tau_p) * (self.z_pre_ampa - self.p_pre_ampa) * self.k
+            self.p_post_ampa += (dt / self.tau_p) * (self.z_post_ampa - self.p_post_ampa) * self.k
+            self.p_co_ampa += (dt / self.tau_p) * (self.z_co_ampa - self.p_co_ampa) * self.k
+        else:
+            # Updated the probability of the NMDA connection
+            self.p_pre += (dt / self.tau_p) * (self.z_pre - self.p_pre)
+            self.p_post += (dt / self.tau_p) * (self.z_post - self.p_post)
+            self.p_co += (dt / self.tau_p) * (self.z_co - self.p_co)
+
+            # Updated the probability of AMPA connection
+            self.p_pre_ampa += (dt / self.tau_p) * (self.z_pre_ampa - self.p_pre_ampa)
+            self.p_post_ampa += (dt / self.tau_p) * (self.z_post_ampa - self.p_post_ampa)
+            self.p_co_ampa += (dt / self.tau_p) * (self.z_co_ampa - self.p_co_ampa)
 
         if self.k > self.epsilon:
             self.beta = get_beta(self.p_post, self.epsilon)

play.py

@@ -16,20 +16,20 @@
 
 # Patterns parameters
 hypercolumns = 4
-minicolumns = 30
-n_patterns = 30  # Number of patterns
+minicolumns = 20
+n_patterns = 10  # Number of patterns
 
 # Manager properties
 dt = 0.001
-T_recalling = 10.0
+T_recalling = 5.0
 values_to_save = ['o']
 values_to_save = ['o', 'z_pre', 'z_post', 'p_pre', 'p_post', 'p_co', 'z_co', 'w']
 
 # Protocol
 training_time = 0.1
-inter_sequence_interval = 3.0
+inter_sequence_interval = 1.0
 inter_pulse_interval = 0.0
-epochs = 3
+epochs = 5
 
 # Build patterns
 patterns_dic = build_ortogonal_patterns(hypercolumns, minicolumns)
@@ -39,6 +39,8 @@
 # Build the network
 nn = BCPNNFast(hypercolumns, minicolumns)
 nn.tau_a = 0.270
+nn.g_a = 200
+nn.k_inner = False
 
 # Build the manager
 manager = NetworkManager(nn=nn, dt=dt, values_to_save=values_to_save)
@@ -52,13 +54,25 @@
 epoch_history = manager.run_network_protocol(protocol=protocol, verbose=True, values_to_save_epoch=['w'])
 w = epoch_history['w']
 
-if False:
-    traces_to_plot = [1, 0, 2]
+if True:
+    traces_to_plot = [10, 0, 11]
     plot_state_variables_vs_time(manager, traces_to_plot, ampa=False)
-    traces_to_plot = [0, 9, 1]
+    traces_to_plot = [0, 11, 1]
     plot_state_variables_vs_time(manager, traces_to_plot, ampa=False)
     plot_weight_matrix(nn, one_hypercolum=True)
     plt.show()
 
+if False:
+    # Recall
+    manager.run_network_recall(T_recalling, I_cue=patterns[1], T_cue=0.100)
+    plot_winning_pattern(manager, ax=None, separators=False, remove=0.010)
+    plot_network_activity_angle(manager)
+    plot_weight_matrix(nn, one_hypercolum=True)
+    plt.show()
 
+    from analysis_functions import calculate_angle_from_history, calculate_winning_pattern_from_distances
+    from analysis_functions import calculate_patterns_timings
+    distances = calculate_angle_from_history(manager)
+    winning = calculate_winning_pattern_from_distances(distances)
+    timings = calculate_patterns_timings(winning, dt, remove=0.01)