Few changes in variable naming

Author: tedyhabtegebrial

AutoEncoder.py

@@ -26,7 +26,6 @@ def __init__(self, inp_dim, hid_dim):
         self.b = -3 * np.ones((hid_dim, 1))
         # learning rate for synaptic plasticity of read-out layer (RO)
         self.lrateRO = 0.01
-        # 0.0001 * (2 / (3 * lnum))  #numerical regularization constant
         self.regRO = 0.0002
         self.decayP = 0  # decay factor for positive weights [0..1]
         self.decayN = 1  # decay factor for negative weights [0..1]
@@ -99,6 +98,7 @@ def train(self, X):
 
     def update(self):
         self.g = np.dot(self.W.transpose(), self.inp)
+
         # Apply activation function
         self.h = float(1) / (1 + np.exp(-self.a * self.g - self.b))
 

Node.py

@@ -14,50 +14,47 @@ def __init__(self, layer_number, node_pos, cifar_stat={'patch_mean': [], 'patch_
         self.layer_number = layer_number
         self.node_position = node_pos
         self.belief = []
-        # cifarStat = load_cifar(4)#  to be used for Normalization and Whitening
-        #  Purposes
         self.patch_mean = cifar_stat['patch_mean']
         self.patch_std = cifar_stat['patch_std']
         self.v = cifar_stat['whiten_mat']
+        self.learning_algorithm = []
+        self.input = []
+        self.algorithm_choice = []
 
     def init_node_learning_params(self, algorithm_choice, alg_params):
         self.algorithm_choice = algorithm_choice
         if algorithm_choice == 'Clustering':
             cents_per_layer = alg_params['num_cents_per_layer']
-            #  input_width = input_widths[layer_num]
+
             if self.layer_number == 0:
                 input_width = 48
             else:
                 input_width = cents_per_layer[self.layer_number - 1] * 4
             self.learning_algorithm = Clustering(alg_params['mr'], alg_params['vr'], alg_params['sr'], input_width,
                                                 alg_params['num_cents_per_layer'][self.layer_number], self.node_position)
-            # mr, vr, sr, di, ce, node_id
         else:
             self.belief = np.ones((alg_params[self.layer_number][1], 1))
             self.algorithm_choice = algorithm_choice
             self.learning_algorithm = NNSAE(
                 alg_params[self.layer_number][0], alg_params[self.layer_number][1])
 
-    def load_input(self, In):
+    def load_input(self, in_):
         if self.layer_number == 0:
-            In = In - self.patch_mean
-            In = In / self.patch_std
-            In = In.dot(self.v)
-        self.input = In
+            in_ = in_ - self.patch_mean
+            in_ = in_ / self.patch_std
+            in_ = in_.dot(self.v)
+        self.input = in_
 
     def do_node_learning(self, mode):
         if self.algorithm_choice == 'Clustering':
             self.learning_algorithm.update_node(self.input, mode)
             self.belief = self.learning_algorithm.belief
         else:
             self.learning_algorithm.train(self.input)
-            W = np.transpose((self.learning_algorithm.W + 0.00005)/np.sum((self.learning_algorithm.W + 0.00005),0))
-            input_ = self.input/np.sum(self.input,0)
-            # input_ = np.transpose(self.input)/np.sum(np.transpose(self.input),0)
-            # print np.shape(W)
-            # print np.shape(input_)
-            # activations = np.dot(W, input_) + 0.00005
-            dist = W - input_
+            eps = np.exp(-10)
+            weight = np.transpose((self.learning_algorithm.W + eps)/np.sum((self.learning_algorithm.W + eps), 0))
+            input_ = self.input/np.sum(self.input, 0)
+            dist = weight - input_
             sq_dist = np.square(dist)
             norm_dist = np.sum(sq_dist, axis=1)
             chk = (norm_dist == 0)
@@ -66,42 +63,5 @@ def do_node_learning(self, mode):
                 self.belief[chk] = 1.0
             else:
                 norm_dist = 1 / norm_dist
-                belief = (norm_dist / sum(norm_dist)) # .reshape(np.shape(self.belief)[0], np.shape(self.belief)[1])
-            #belief = activations / (np.sum(activations))
-            self.belief = belief
-            # belief = np.maximum(activations, 0)
-            # self.belief = belief
-            # for K in range(activations.shape[0]):
-            #     belief[K] = max(0.0, float((activations[K] - 0.025)))
-            # self.belief = np.asarray(belief)/np.sum(belief)
-
-            """
-
-    def calcuatebelief(self, input_):
-        self.load_inputTonodes(input_, [4,4])
-        for I in range(len(self.nodes)):
-            for J in range(len(self.nodes[0])):
-                W = np.transpose(self.NNSAE.W)
-                Image = return_node_input(input_, [I*4, J*4], [4,4], 'Adjacent', 'Color')
-                activations = np.dot(W, np.transpose(Image))
-                activations = activations/sum(sum(activations))
-                self.nodes[I][J].Activation = activations
-                m = np.mean(np.mean(activations,1))
-                for K in range(activations.shape[0]):
-                        self.nodes[I][J].belief[K,0] = max(0, (activations[K,0] - 0.025))
-                print self.nodes[0][0].belief"""
-            """
-                def produce_belief(self, sqdiff):
-        """
-        # Update belief state.
-        """
-        normdist = np.sum(sqdiff / self.var, axis=1)
-        chk = (normdist == 0)
-        if any(chk):
-            self.belief = np.zeros((1, self.CENTS))
-            self.belief[chk] = 1.0
-        else:
-            normdist = 1 / normdist
-            self.belief = (normdist / sum(normdist)).reshape(1, self.CENTS)
-
-            """
+                belief = (norm_dist / sum(norm_dist))
+            self.belief = belief/sum(belief)    # Make sure that beliefs are normalized

testDestin.py

@@ -1,8 +1,8 @@
 __author__ = 'teddy'
+import cPickle as pickle
 from Network import *
 from loadData import *
-from time import time
-import cPickle as pickle
+
 
 """
 Here I don't move the image, I rather let a typical node move around the image
@@ -52,16 +52,13 @@
 DESTIN.setmode(network_mode)
 DESTIN.set_lowest_layer(0)
 # Load Data
-[data, labels] = loadCifar(10)  # loads cifar_data_batch_1
+[data, labels] = loadCifar(10)
 del labels
 # data = np.random.rand(5,32*32*3)
 # Initialize Network; there is is also a layer-wise initialization option
 DESTIN.init_network()
-t = time()
 for I in range(data.shape[0]):  # For Every image in the data set
     if I % 200 == 0:
-        print time() - t
-        t = time()
         print("Training Iteration Number %d" % I)
     for L in range(DESTIN.number_of_layers):
         if L == 0:
@@ -82,13 +79,12 @@
 print("Testing Started")
 network_mode = False
 DESTIN.setmode(network_mode)
+
 # On the training set
 [data, labels] = loadCifar(10)
 del labels
 for I in range(data.shape[0]):  # For Every image in the data set
     if I % 1000 == 0:
-        print time() - t
-        t = time()
         print("Testing Iteration Number %d" % I)
     for L in range(DESTIN.number_of_layers):
         if L == 0:
@@ -107,10 +103,10 @@
         file_id.close()
         # Get rid-off accumulated training beliefs
         DESTIN.clean_belief_exporter()
-# On the test set
+
 [data, labels] = loadCifar(6)
-# data = np.random.rand(5,32*32*3)
 del labels
+# On the test set
 for I in range(data.shape[0]):  # For Every image in the data set
     if I % 1000 == 0:
         print("Testing Iteration Number %d" % (I+50000))
@@ -130,4 +126,4 @@
         pickle.dump(np.array(DESTIN.network_belief['belief']), file_id)
         file_id.close()
         # Get rid-off accumulated training beliefs
-        DESTIN.clean_belief_exporter()
+        DESTIN.clean_belief_exporter()