Preprocessing updates

Author: Daniel McDuff

code/load_faces.py

@@ -15,6 +15,7 @@
 import theano
 import theano.tensor as T
 from theano.tensor.shared_randomstreams import RandomStreams
+import pandas
 
 def logistic_transform(A, mu, sigma):
     A[numpy.where(A == 0)] = 0.1
@@ -24,49 +25,97 @@ def logistic_transform(A, mu, sigma):
     Z /= 255.
     return Z
 
-def import_data(label, data_dir):
+def import_data(label, data_dir, image_dim):
 
-    image_paths=[]
     inputs=[]
     target=[]
 
     for (dirpath,dirnames,filenames) in os.walk(data_dir):
         print "Loading "+dirpath
         paths = [os.path.join(dirpath, f) for f in filenames if ((f[-4:] == '.png') and ('normalized' in f))]
-        image_paths += paths
-    for f in image_paths:
-        test_target = int(os.path.basename(f).split("_")[2].split(".")[0])
-        if test_target>=0:
-            test_image = numpy.array(scipy.misc.imread(f))
-            if (len(test_image.flatten())!=2304):
-                continue
-            if test_target > 50:
-                    test_image2 = test_image.astype(float)
-                    temp = logistic_transform(test_image2.flatten(), 120, 0.1)
-                    if numpy.isnan(temp).any():
-                        continue
-                    else:
-                        inputs = numpy.append(inputs, temp, axis=0)
-                        target = numpy.append(target, [1], axis=0)
-            elif test_target == 0:
-                    test_image2 = test_image.astype(float)
-                    temp = logistic_transform(test_image2.flatten(), 120, 0.1)
-                    if numpy.isnan(temp).any():
-                        continue
-                    else:
-                        inputs = numpy.append(inputs, temp, axis=0)
-                        target = numpy.append(target, [0], axis=0)
-    inputs = inputs.reshape(-1,2304)
-    data_set = (inputs, target)
+        #image_paths += paths
+        if len(paths)==0:
+            continue
+
+        # Tab indent this to do each directory separately.  This is useful when adding labels.
+        # Load label file:
+        try:
+            print os.path.join(dirpath,'labels.csv')
+            label_df = pandas.read_csv(os.path.join(dirpath,'labels.csv'))
+        except:
+            print "No labels file in this folder."
+
+        # Loop through paths and store images and labels:
+        for f in paths:
+            print(f)
+            base=os.path.basename(f)
+            filename = base
+            #test_target = int(os.path.basename(f).split("_")[2].split(".")[0])
+            test_targets = label_df.loc[label_df['image_name']==filename]
+            test_target = test_targets.iloc[0]['Smile']
+
+
+            #temp = test_targets==0
+            #neutral = temp.any(1)
+            #print neutral.iloc[0]
+
+
+            #if neutral.iloc[0]:
+            if test_target>=-1:
+                test_image = numpy.array(scipy.misc.imread(f))
+                if (len(test_image.flatten())!=(image_dim*image_dim)):
+                    continue
+                #for i, row in enumerate(test_targets.iloc[0].values):
+                #    print i + str(test_targets.iloc[0][i])
+
+                if test_target > 50:
+                        test_image2 = test_image.astype(float)
+                        temp = logistic_transform(test_image2.flatten(), 120, 0.1)
+                        if numpy.isnan(temp).any():
+                            print "NaN found :("
+                            continue
+                        else:
+                            inputs = numpy.append(inputs, temp, axis=0)
+                            target = numpy.append(target, [1], axis=0)
+                elif test_target == 0:
+                        test_image2 = test_image.astype(float)
+                        temp = logistic_transform(test_image2.flatten(), 120, 0.1)
+                        if numpy.isnan(temp).any():
+                            print "NaN found :("
+                            continue
+                        else:
+                            inputs = numpy.append(inputs, temp, axis=0)
+                            target = numpy.append(target, [0], axis=0)
+                elif test_target == -1:
+                        test_image2 = test_image.astype(float)
+                        temp = logistic_transform(test_image2.flatten(), 120, 0.1)
+                        if numpy.isnan(temp).any():
+                            print "NaN found :("
+                            continue
+                        else:
+                            inputs = numpy.append(inputs, temp, axis=0)
+                            target = numpy.append(target, [-1], axis=0)
+
+    inputs = inputs.reshape(-1,(image_dim*image_dim))
+    perm = numpy.random.permutation(len(inputs[:,1]))
+    inputs = inputs[perm,:]
+    target = target[perm]
+
+    ## Create label mask:
+    data_mask = [target >= 0]
+
+    data_set = (inputs, target, data_mask)
     print label + " Data:"
-    print "Images: "+str(len(inputs[:,1]))
-    print "Features: "+str(len(inputs[1,:]))
-    print "Labels: "+str(len(target))
-    print "Positive Labels: "+str(sum(target))
+    print "Images:      "+str(len(inputs[:,1]))
+    print "Features:    "+str(len(inputs[1,:]))
+    print "Labels:      "+str(len(target))
+    print "  Positive Labels:       "+str(sum(target[data_mask]))
+    print "  Negative Labels:       "+str(len(target) - sum(target[data_mask]))
+    print "  Unlabeled Examples:    "+str(len(target) - numpy.sum(data_mask))
 
     return data_set
 
-def load_faces(dataset):
+def load_faces(dataset, image_dim):
     ''' Loads the dataset
     :type dataset: string
     :param dataset: the path to the dataset
@@ -80,19 +129,23 @@ def load_faces(dataset):
 
     pickle_dir = os.path.join(dataset,'imported_data_bin.p')
     if (os.path.isfile(pickle_dir)):
-        rval, train_set = pickle.load(open(pickle_dir,"rb"))
-        return rval, train_set
+        rval, test_set = pickle.load(open(pickle_dir,"rb"))
+        return rval, test_set
     else:
         print "No imported data found. Loading data from images now."
 
         data_dir_test = os.path.join(dataset,'train')
-        train_set = import_data('Training', data_dir_test)
+        train_set = import_data('Training', data_dir_test, image_dim)
+        pre_train_set = (train_set[0], train_set[1])
+        train_set = (train_set[0][train_set[2]], train_set[1][train_set[2]])
 
         data_dir_test = os.path.join(dataset,'valid')
-        valid_set = import_data('Validation', data_dir_test)
-    
+        valid_set = import_data('Validation', data_dir_test, image_dim)
+        valid_set = (valid_set[0][valid_set[2]], valid_set[1][valid_set[2]])
+
         data_dir_test = os.path.join(dataset,'test')
-        test_set = import_data('Testing', data_dir_test)
+        test_set = import_data('Testing', data_dir_test, image_dim)
+        test_set = (test_set[0][test_set[2]], test_set[1][test_set[2]])
 
         # Make each image a row of the matrix.
         # Make the targets a column vector.
@@ -125,13 +178,14 @@ def shared_dataset(data_xy, borrow=True):
         test_set_x, test_set_y = shared_dataset(test_set)
         valid_set_x, valid_set_y = shared_dataset(valid_set)
         train_set_x, train_set_y = shared_dataset(train_set)
+        pre_train_set_x, pre_train_set_y = shared_dataset(pre_train_set)
 
         rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
-                (test_set_x, test_set_y)]
+                (test_set_x, test_set_y), (pre_train_set_x, pre_train_set_y)]
 
         save_dir = os.path.join(dataset,'imported_data_bin.p')
         pickle.dump( [rval, train_set], open(save_dir,"wb"))
-        return rval, train_set
+        return rval, test_set
 
 if __name__ == '__main__':
     test_DBN()

code/rbm.py

@@ -156,7 +156,7 @@ def sample_h_given_v(self, v0_sample):
 
         rank_1 = ((h1_mean.argsort(axis=1)).argsort(axis=1).astype(theano.config.floatX) + 1.)/T.shape(h1_mean)[1].astype(theano.config.floatX)
 
-        h1_mean = (1.-0.5)*(rank_0**((1./0.03)-1.))+0.5*(rank_1**((1./0.03)-1.))
+        h1_mean = (1.-0.5)*(rank_0**((1./0.05)-1.))+0.5*(rank_1**((1./0.05)-1.))
 
         #pre_sigmoid_h1_bin = T.log(h1_mean) - T.log(1. - h1_mean)
         #pre_sigmoid_h1 = pre_sigmoid_h1_bin 
@@ -279,14 +279,14 @@ def get_cost_updates(self, lr=0.1, persistent=None, k=1):
         gparams = T.grad(cost, self.params, consider_constant=[chain_end])
 
         ## DAN ADDED:#########################
-        #pre_sigmoid_h1_bin = T.log(ph_mean) - T.log(1. - ph_mean)
+        pre_sigmoid_h1_bin = T.log(ph_mean) - T.log(1. - ph_mean)
         # get_gweights_up
-        #phi = 0.2
-        #gparams_lat_bias = theano.clone(gparams[0],replace={pre_sigmoid_ph:pre_sigmoid_h1_bin})
-        #gparams[0] = (1 - phi) * gparams[0] + phi * gparams_lat_bias
+        phi = 0.2
+        gparams_lat_bias = theano.clone(gparams[0],replace={pre_sigmoid_ph:pre_sigmoid_h1_bin})
+        gparams[0] = (1 - phi) * gparams[0] + phi * gparams_lat_bias
         ## DAN ADDED:
-        #hparams_lat_bias = theano.clone(gparams[1],replace={pre_sigmoid_ph:pre_sigmoid_h1_bin})
-        #gparams[1] = (1 - phi) * gparams[1] + phi * hparams_lat_bias
+        hparams_lat_bias = theano.clone(gparams[1],replace={pre_sigmoid_ph:pre_sigmoid_h1_bin})
+        gparams[1] = (1 - phi) * gparams[1] + phi * hparams_lat_bias
         #######################################
 
         # end-snippet-3 start-snippet-4
@@ -381,7 +381,7 @@ def get_reconstruction_cost(self, updates, pre_sigmoid_nv):
 
 
 def test_rbm(learning_rate=0.1, training_epochs=15,
-             dataset='mnist.pkl.gz', batch_size=10,
+             dataset='mnist.pkl.gz', batch_size=50,
              n_chains=20, n_samples=10, output_folder='rbm_plots',
              n_hidden=500):
     """

code/rbm_face.py

@@ -152,15 +152,12 @@ def sample_h_given_v(self, v0_sample):
         # the visibles
         pre_sigmoid_h1, h1_mean = self.propup(v0_sample)
 
-
-	##################################################################
-	## Sparsity: #####################################################
-	##################################################################
+        ##################################################################
+	    ## Sparsity: #####################################################
+	    ##################################################################
 	rank_0 = ((h1_mean.argsort(axis=0)).argsort(axis=0).astype(theano.config.floatX) + 1.)/T.shape(h1_mean)[0].astype(theano.config.floatX)
-
-	rank_1 = ((h1_mean.argsort(axis=1)).argsort(axis=1).astype(theano.config.floatX) + 1.)/T.shape(h1_mean)[1].astype(theano.config.floatX)
-
-	h1_mean = (1.-0.9)*(rank_0**((1./0.99)-1.))+0.9*(rank_1**((1./0.99)-1.))
+        rank_1 = ((h1_mean.argsort(axis=1)).argsort(axis=1).astype(theano.config.floatX) + 1.)/T.shape(h1_mean)[1].astype(theano.config.floatX)
+        h1_mean = (1.-0.9)*(rank_0**((1./0.99)-1.))+0.9*(rank_1**((1./0.99)-1.))
 
 
         # get a sample of the hiddens given their activation