A refactor to prepare for a merge with the stocker lab

Author: aribenjamin

.idea/Illusions.iml

@@ -27,27 +27,32 @@ def forward(self, x):
 class AngleDecoder(torch.nn.Module):
     """This class takes the inputs of the pretrained VGG function and gives out the angle
     """
-    def __init__(self, layer, noise = 0, nonlinear = False):
-        super(OrientationDecoder, self).__init__()
+    def __init__(self, layer, noise = 0, nonlinear = False,n_filts=6):
+        super(AngleDecoder, self).__init__()
         self.layer = layer
         self.noise = noise
+        self.n_filts = n_filts
         maxpool_indices = [ 4, 9, 16, 23, 30]
         assert layer in maxpool_indices
 
         # load the pretrained network
         self.vgg_chopped = VGG_chopped(layer)
 
-        n_feats = {4: 64 * 112 * 112,
+        # n_feats = {4: 64 * 112 * 112,
+        #            9: 128 * 56 * 56,
+        #           16: 256 * 28 * 28,
+        #           23: 512 * 14 * 14,
+        #           30: 512 * 7 * 7}
+
+        n_feats = {4: 64 * (n_filts*2)**2,
                    9: 128 * 56 * 56,
                   16: 256 * 28 * 28,
                   23: 512 * 14 * 14,
                   30: 512 * 7 * 7}
 
         if nonlinear:
             self.decoder = torch.nn.Sequential(
-                torch.nn.Linear(n_feats[layer], 50),
-                torch.nn.Dropout(.5),
-                torch.nn.Linear(50, 1)
+                torch.nn.Linear(n_feats[layer], 500),
             )
         else:
             self.decoder = torch.nn.Sequential(
@@ -60,11 +65,16 @@ def __init__(self, layer, noise = 0, nonlinear = False):
 
     def forward(self, x):
         x = self.vgg_chopped(x)
+        # take just the center bit. (HARDCODED LAYER=4)
+        x = x[:,:,(56-self.n_filts):(56+self.n_filts),(56-self.n_filts):(56+self.n_filts)]
         # flatten
-        x = x.view(-1,self.n_feat)
+        x = x.contiguous().view(-1,self.n_feat)
+
+
+
         # add noise
-        x += self.noise * torch.randn(*x.size())
+        x += self.noise * torch.randn_like(x)
         # get angle
-        x = self.deconv(x)
+        x = self.decoder(x)
 
         return x

.idea/workspace.xml

@@ -0,0 +1,34 @@
+import pandas as pd
+import torch
+
+def loader_generator(h5_path, batch_size, as_tensor=True, n_samples = 10000):
+    """Given an h5 path to a file that holds the arrays, returns a generator
+    that can get certain data at a time."""
+
+    stop = n_samples
+    curr_index = 0
+    start = 0
+    while 1:
+
+        dataframe = pd.read_hdf(h5_path, start=curr_index,
+                                stop=min([curr_index + batch_size, stop]))
+        curr_index += batch_size
+
+        if (dataframe.shape[0]==0) or (curr_index >= stop):
+            curr_index = start
+            continue
+
+        if as_tensor:
+            if dataframe.shape[1]>1:
+                out = torch.Tensor(dataframe.values).view(batch_size, -1, 224, 224)
+            else:
+                out = torch.Tensor(dataframe.values)
+        else:
+            if dataframe.shape[1] > 1:
+                out = dataframe.values.reshape((batch_size, -1, 224, 224))
+            else:
+                out = dataframe.values
+        yield out
+
+def data_iterator(h5_path, batch_size, as_tensor=True):
+    return iter(loader_generator(h5_path, batch_size, as_tensor))

from_lines/__init__.py …l_orientation_of_cross_lines/__init__.pyfrom_lines/__init__.py renamed to Local_orientation_of_cross_lines/__init__.py from_lines/__init__.py renamed to Local_orientation_of_cross_lines/__init__.py

@@ -8,20 +8,41 @@
 
 import argparse
 import os
+from tqdm import tqdm as tqdm
 
-
-def gen_many_lines_on_white(noise=True, mask=None):
+def gen_many_lines_on_white(noise=True, mask=None,N=1000, test = False):
     """ Two intersecting lines of random central angle and relative angle and position.
 
+    if test = True, then we sample from angles with final digits in the range 0-1
+    else the rest.
+
+
     """
+
+
+
+
     all_inputs = list()
     angles = list()
-    n_samples = 10000
-    for n in range(n_samples):
-        # usually near the center
-        centerloc = np.random.randint(80, 224 - 80, 2)
-        fixed_angle = np.random.uniform(0, np.pi)
-        relative_angle = np.random.uniform(0, np.pi / 2)
+    n_samples = N
+
+
+    if test:
+        def gen_angle():
+            tens = np.random.randint(0,18)*10
+            rest = np.random.uniform(0,1)
+            return (tens+rest)/180*np.pi-np.pi
+    else:
+        def gen_angle():
+            tens = np.random.randint(0,18)*10
+            rest = np.random.uniform(1,10)
+            return (tens+rest)/180*np.pi-np.pi
+
+    for n in tqdm(range(n_samples)):
+        #at center
+        centerloc = (112,112)#np.random.randint(80, 224 - 80, 2)
+        fixed_angle = np.pi/2
+        relative_angle = gen_angle()
 
         mask = np.zeros((224, 224)).astype(np.bool) if mask is None else mask
 
@@ -47,11 +68,14 @@ def gen_many_lines_on_white(noise=True, mask=None):
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
 
-    parser.add_argument("--noise", help="The variance of gaussian noise added to the raw images",
+    parser.add_argument("--noise", help="Whether to add gaussian noise added to the raw images",
+                        action = 'store_true')
+    parser.add_argument("--n_images", help="How many to build",
+                        type=int, default = 10000)
+    parser.add_argument("--test", help="Test set or train set?",
                         action = 'store_true')
-
     parser.add_argument("--image_directory", type = str,
-                        default='/home/abenjamin/DNN_illusions/fast_data/features/straight_lines/',
+                        default='/home/abenjamin/DNN_illusions/fast_data/features/rel_angle/',
                         help="""Path to the folder in which we store the `lines.h5` and `lines_targets.h5` files.
                              If lines_targets.h5 does not exist, we just plot the input and model output.""")
 
@@ -63,8 +87,7 @@ def gen_many_lines_on_white(noise=True, mask=None):
             if (i - 112) ** 2 + (j - 112) ** 2 >= 100 ** 2:
                 unit_circle[i, j] = True
 
-
-    all_inputs, all_targets = gen_many_lines_on_white(args.noise, unit_circle)
+    all_inputs, all_targets = gen_many_lines_on_white(args.noise, unit_circle, N=args.n_images, test = args.test)
 
     all_inputs = pd.DataFrame(np.stack(all_inputs))
     all_inputs.to_hdf(args.image_directory+'lines.h5', key="l", mode='w')

from_lines/angle_decoder/__init__.py …of_cross_lines/angle_decoder/__init__.pyfrom_lines/angle_decoder/__init__.py renamed to Local_orientation_of_cross_lines/angle_decoder/__init__.py from_lines/angle_decoder/__init__.py renamed to Local_orientation_of_cross_lines/angle_decoder/__init__.py

@@ -0,0 +1,160 @@
+import torch
+from torch.autograd import Variable
+
+import argparse
+import os
+from data_loader_utils import data_iterator
+from angle_decoder_linear import AngleDecoder
+
+#visualize
+from matplotlib.colors import ListedColormap
+import matplotlib as mpl
+import matplotlib
+from colorspacious import cspace_convert
+import numpy as np
+from matplotlib import pyplot as plt
+
+def gen_test_lines(mask=None):
+    """ Two intersecting lines of certain central angle and relative angle and position.
+
+    """
+    all_inputs = list()
+    angles = list()
+    n_samples = 180
+    for n in range(n_samples):
+        centerloc = (112,112)
+        fixed_angle = 0
+        relative_angle = n*np.pi/360 # up to 90 deg
+
+        mask = np.zeros((224, 224)).astype(np.bool) if mask is None else mask
+
+        numpy_im = generate_intersecting_rgb(centerloc, fixed_angle, relative_angle,
+                                negative_mask=mask,
+                                             linewidth=1)
+
+
+
+        all_inputs.append(numpy_to_torch(numpy_im).view(-1))
+        angles.append(relative_angle)
+
+    return all_inputs, angles
+
+def pass_test_images(model, samples, gpu = True, batch_size = 10):
+    """This script loads a model, as specified by the path, tests some images, and displays the decoded images.
+
+    Inputs:
+        samples: a list of images
+
+    Returns a list of tuples of (input_image (3x224x224), orientation_image (2x224x224),
+                        target_orientation_image (2x224x224))
+    """
+
+    samples = torch.stack(samples)
+
+    if gpu:
+        feats = samples.cuda()
+    data = Variable(samples)
+
+    output = model(data).detach()
+    if gpu:
+        output = output.cpu()
+    del data
+
+    return output.numpy()
+
+def load_model(args):
+    """Loads the VGG+decoder network trained and saved at path."""
+    model = AngleDecoder(args.layer, 0, args.nonlinear)
+
+    model.load_state_dict(torch.load(args.model_path))
+    model.eval()
+    return model
+
+
+def save_and_visualize(outputs, targets):
+    """Here we take decoded relative angles [range(180)] and plot them, along with what the angles actually were
+
+    """
+
+
+
+    #
+    #
+    # for i,(input,output,target) in enumerate(images):
+    #
+    #     check_sizes(input, output)
+    #
+    #     plt.figure(figsize=(15, 5))
+    #     plt.subplot(131)
+    #     plt.imshow(np.moveaxis(input,0,2))
+    #     ax = plt.gca()
+    #     ax.set_axis_off()
+    #     ax.set_title("Input")
+    #
+    #     plt.subplot(132)
+    #     ax2 = show_orientation_image(output)
+    #     ax2.set_title("Decoded orientation")
+    #
+    #     try:#if target is not None:
+    #         plt.subplot(133)
+    #         ax3 = show_orientation_image(target)
+    #         ax3.set_title("Target orientation")
+    #     except:
+    #         print("Recomputing orientation image with kernel size {}".format(kernel_size))
+    #         filts = get_quadratures(kernel_size)
+    #
+    #         # note that we invert to get the map
+    #         target = get_orientation_map(1-np.mean(check_on_float_scale(input),axis=0), filts)
+    #         plt.subplot(133)
+    #         ax3 = show_orientation_image(target)
+    #         ax3.set_title("Target orientation")
+    #
+    #
+    #     plt.tight_layout()
+    #     if save:
+    #         plt.savefig("Decoded_test_image_{}.png".format(i))
+    #         #save just decoded png
+    #         print(type(output), output.shape)
+    #         output_img = convert_to_orientation_image(output)
+    #         target_img = convert_to_orientation_image(target)
+    #         # matplotlib.image.imsave('only_original_img_{}'.format(i), input)
+    #         matplotlib.image.imsave('only_decoded_img_{}.png'.format(i), output_img)
+    #         matplotlib.image.imsave('only_target_img_{}.png'.format(i), target_img)
+    #     plt.show()
+    #
+    #
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("model_path", help="relative path to the saved model",
+                        type=str, default='/home/abenjamin/DNN_illusions/data/models/Angle_decoder_4.pt')
+    parser.add_argument("layer", help="which layer of VGG the model was trained to decode from",
+                        type=int)
+
+    parser.add_argument('--no-cuda', action='store_true',
+                    help='Disable CUDA')
+    parser.add_argument("--card", help="which card to use",
+                        type=int, default =0 )
+    parser.add_argument('--nonlinear', action='store_true',
+                        help='Use the decoder with nonlinear 2 layer network')
+    args = parser.parse_args()
+    args.gpu = not args.no_cuda
+
+    os.environ["CUDA_VISIBLE_DEVICES"]=str(args.card)
+
+    # note that right now the model is on the cpu
+    model = load_model(args)
+    if args.gpu:
+        model = model.cuda()
+
+    # get data
+    unit_circle = np.zeros((224, 224)).astype(np.bool)
+    for i in range(224):
+        for j in range(224):
+            if (i - 112) ** 2 + (j - 112) ** 2 >= 100 ** 2:
+                unit_circle[i, j] = True
+    samples, targets = gen_test_lines(unit_circle)
+
+    outputs = pass_test_images(model, samples,args.gpu)
+
+    save_and_visualize(outputs, targets)