clean up

Author: bsridatta

.gitignore

@@ -0,0 +1,15 @@
+# dot files
+.vscode
+
+# cache
+__pycache__/
+.pytest_cache
+
+# packaging
+*.egg-info/
+
+# logs
+wandb/
+
+
+

README.md

@@ -1,8 +1,8 @@
 # Rotated-Object-Detection
-Tiny ResNet inspired FPN network (<2M params) for Rotated Object Detection using 5-parameter Modulated Rotation Loss
+Novel ResNet inspired Tiny-FPN network (<2M params) for Rotated Object Detection using 5-parameter Modulated Rotation Loss
 
 ### Crux
-* **Architecture**: FPN with classification and regression heads ~1.9M paramters  
+* **Architecture**: FPN with classification and regression heads ~1.9M parameters  
 * **Loss Function**: 5 Parameter Modulated Rotation Loss  
 * **Activation**: Mish  
 * **Model Summary** - *reports/FPN_torchsummary.txt* (reports/ also contain alterantive summary with named layers in table)
@@ -13,27 +13,27 @@ Tiny ResNet inspired FPN network (<2M params) for Rotated Object Detection using
 
 
 ### Method
-* The reported results are using a ResNet inspired building block modules and a FPN. 
+* The reported results are using a ResNet inspired building block modules and an FPN. 
 * Separate classification and regression subnets (single FC) are used. 
-* Feature map from the top of the pyramid which has the best semantic representation is used for classifcation. 
-* While the finer feature map at the bottom of the pyramid which has best global representation is used for regressing the rotated bounding box. Finer details can be found in the code as comments. Code: *src/models/detector_fpn.py* 
+* Feature map from the top of the pyramid that has the best semantic representation is used for classification. 
+* While the finer feature map at the bottom of the pyramid that has the best global representation is used for regressing the rotated bounding box. Finer details can be found in the code as comments. Code: *src/models/detector_fpn.py* 
 
 * The whole implementation is from scratch, in PyTorch. Only the method for calculating AP from PR curves is borrowed and referenced (*src/metrics.py/compute_ap*). 
 
 ### Approach
-1. (Confidential) Random data generator that creates images with high noise and rotated objects (shapes) in random scales and orientations
-2. Compare reusing generated samples for each epoch vs online generating and loading
+1. Random data generator that creates images with high noise and rotated objects (shapes) in random scales and orientations. (Private)
+2. Compare reusing generated samples for each epoch VS online generating and loading
 3. Implement modulated rotated loss and other metrics
 4. Experiment with loss functions and activations
-5. Tried to replace standard conv layers with ORN (Oriented Response Network) which use rotated filters to learn orientation (Could not integrate due to technical challenges)
+5. Tried to replace standard convolutional layers with ORN (Oriented Response Network) that use rotated filters to learn orientation (Could not integrate due to technical challenges)
 6. Improve basic model to use different heads for classification and regression
-7. Try variations by removing 512 dimensional filters as they take up the most parameters (~1M)
+7. Try variations by removing 512-dimensional filters as they take up the most parameters (~1M)
 8. Add feature pyramid and experiment with different building blocks and convolutional parameters (kernel size, stride in the first layer plays a big role)
-9.  Streamline parameters in the building blocks, prediciton heads to be lower than 2M
+9.  Streamline parameters in the building blocks and the prediction heads to be lower than 2M
 
 * **Please find the rest of the report, with details on experiments and analysis, in** *reports/experiments.pdf* 
 
 ### Opportunities to improve
-1. Use the rest of the pyramid layers for prediction (take more parameters) and have better logic to get best detection
+1. Use the rest of the pyramid layers for prediction (take more parameters) and have better logic to get the best detection
 2. Integrate ORN layers to FPN
 3. Using DenseNets with compact convolution layer configurations

bsridatta.egg-info/PKG-INFO

@@ -16,6 +16,7 @@ def train_dataloader(opt):
     print("samples - ", len(dataset))
     return loader
 
+
 def val_dataloader(opt):
     print("[INFO]: Validation dataloader called")
     dataset = Ships(n_samples=opt.val_len)
@@ -30,6 +31,7 @@ def val_dataloader(opt):
     print("samples - ", len(dataset))
     return loader
 
+
 def test_dataloader(opt):
     print("[INFO]: Test dataloader called")
     dataset = Ships(n_samples=opt.test_len)
@@ -42,4 +44,4 @@ def test_dataloader(opt):
                         sampler=sampler,
                         shuffle=shuffle)
     print("samples - ", len(dataset))
-    return loader 
+    return loader

bsridatta.egg-info/SOURCES.txt

@@ -4,37 +4,38 @@
 import numpy as np
 from tqdm import tqdm
 
+
 class Ships(Dataset):
     """ship datasets with has ship labels
     Keyword Arguments:
         n_samples {int} -- items in dataset, here, items per epoch (default: {1000})
         pre_load {bool} -- to make all items at once and query for each step (default: {False})
-    
+
     Returns:
         sample {Tenosr} -- p_ship, x, y, yaw, h, w
     """
+
     def __init__(self, n_samples=1000, pre_load=False):
         self.n_samples = n_samples
         self.pre_load = pre_load
         if pre_load:
             images, labels = make_batch(n_samples)
             # row, col -> n_channel,row,col
             inp = torch.tensor(images, dtype=torch.float32)
-            self.inps = inp[:,None, :, :]
+            self.inps = inp[:, None, :, :]
 
             # x,y,yaw,h,w -> p(ship),x,y,yaw,h,w
             target = torch.tensor(labels, dtype=torch.float32)
-            has_ship = (~torch.isnan(target[:,0])).float().reshape(-1,1)
+            has_ship = (~torch.isnan(target[:, 0])).float().reshape(-1, 1)
             self.targets = torch.cat((has_ship, target), dim=1)
 
-
     def __len__(self):
         return self.n_samples
 
     def __getitem__(self, idx):
         if self.pre_load:
             inp = self.inps[idx]
-            target = self.targets[idx] 
+            target = self.targets[idx]
         else:
             image, label = make_data()
 
@@ -52,6 +53,8 @@ def __getitem__(self, idx):
         return sample
 
 # Used for simple experiment
+
+
 def make_batch(batch_size):
     """Used only when pre_load = True
 

bsridatta.egg-info/dependency_links.txt

@@ -1,12 +1,13 @@
 import torch
 
+
 def compute_loss(pred, target):
     """Compute loss handling no ships
 
     Arguments:
         pred {Tensor Batch} -- p(ship), x, y, yaw, w, h
         target {Tensor Batch} -- p(ship), x, y, yaw, w, h
-   
+
     Returns:
         loss -- list of all - not averaged
     """
@@ -21,9 +22,9 @@ def compute_loss(pred, target):
 
     l_ship = torch.nn.functional.binary_cross_entropy_with_logits(
         pred[:, 0], target[:, 0], reduction='none')
-    
+
     loss = l_ship + l_bbox
-    
+
     return loss, l_ship, l_bbox
 
 

bsridatta.egg-info/top_level.txt

@@ -73,8 +73,8 @@ def _get_argparser():
     # device
     parser.add_argument('--cuda', default=True, type=lambda x: (str(x).lower() == 'true'),
                         help='enable cuda if available')
-    parser.add_argument('--pin_memory', default = False, type = lambda x: (str(x).lower() == 'true'),
-                        help = 'pin memory to device')
+    parser.add_argument('--pin_memory', default=False, type=lambda x: (str(x).lower() == 'true'),
+                        help='pin memory to device')
     parser.add_argument('--seed', default=400, type=int,
                         help='random seed')
     return parser

src/dataloader.py

@@ -14,7 +14,7 @@ def compute_metrics(pred, target, iou_threshold=0.7, pr_score=0.5):
     Keyword Arguments:
         iou_threshold {float} -- predicted bbox is correct if IOU > this value (default: {0.7})
         pr_score {float} -- object conf. threshold to sample precision and recall (default: {0.5})
-    
+
     Returns:
         precision, recall, F1 @ pr_score, AP@ iou_threshold and mean IOU
 
@@ -43,7 +43,7 @@ def compute_metrics(pred, target, iou_threshold=0.7, pr_score=0.5):
     mean_iou = torch.mean(ious)
 
     # Calcualted Precision, Recall, F1, AP
-    #### sort by conf
+    # sort by conf
     sorted_idx = torch.argsort(conf, dim=0, descending=True)
     tp, conf = tp[sorted_idx], conf[sorted_idx]
 
@@ -59,11 +59,11 @@ def compute_metrics(pred, target, iou_threshold=0.7, pr_score=0.5):
     rec = tpc / sum_tp_fn
 
     # One P, R at conf threshold
-    #### -1 as conf decreases along x
+    # -1 as conf decreases along x
     p = torch.tensor(np.interp(-pr_score, -conf.cpu(), prec[:, 0].cpu()))
     r = torch.tensor(np.interp(-pr_score, -conf.cpu(), rec[:, 0].cpu()))
 
-    ap = compute_ap(list(rec),list(prec))
+    ap = compute_ap(list(rec), list(prec))
 
     f1 = 2 * p * r / (p + r + eps)
 
@@ -72,10 +72,10 @@ def compute_metrics(pred, target, iou_threshold=0.7, pr_score=0.5):
 
 def compute_ap(recall, precision):
     """ Compute the average precision, given the recall and precision curves.
-   
+
     Code Source: 
         unmodified - https://github.com/rbgirshick/py-faster-rcnn.
-   
+
     Reference: 
         https://github.com/ultralytics/yolov3/blob/e0a5a6b411cca45f0d64aa932abffbf3c99b92b3/test.py
 
@@ -87,7 +87,8 @@ def compute_ap(recall, precision):
     """
 
     # Append sentinel values to beginning and end
-    mrec = np.concatenate(([0.], recall, [min(recall[-1] + 1E-3, 1.)])).astype('float')
+    mrec = np.concatenate(
+        ([0.], recall, [min(recall[-1] + 1E-3, 1.)])).astype('float')
     mpre = np.concatenate(([0.], precision, [0.]))
 
     # Compute the precision envelope

src/dataset.py

@@ -11,6 +11,7 @@ class Detector_ORN(nn.Module):
     Advatages - better IOU, fewer parameters, faster convergence, should be ideal for the task
     ORN paper - https://arxiv.org/pdf/1701.01833.pdf
     """
+
     def __init__(self):
         super(Detector_ORN, self).__init__()
         self.image_size = 200

src/loss.py

@@ -35,7 +35,7 @@ def _build_features(self, n_filter, activ):
         Arguments:
             n_filter {list} -- number of filter for each conv block
             activ {nn.Module} -- activation function to be used
-             
+
         Returns:
             feature extraction module 
         """

src/main.py

@@ -1,6 +1,7 @@
 import torch
 import torch.nn.functional as F
 
+
 @torch.jit.script
 def mish(input):
     '''
@@ -10,19 +11,20 @@ def mish(input):
     '''
     return input * torch.tanh(F.softplus(input))
 
+
 class Mish(torch.nn.Module):
     '''
     Source: https://github.com/digantamisra98/Mish/blob/master/Mish/Torch/mish.py
-    
+
     Applies the mish function element-wise:
     Shape:
         - Input: (N, *) where * means, any number of additional
           dimensions
         - Output: (N, *), same shape as the input
     '''
+
     def __init__(self):
         super().__init__()
 
     def forward(self, input):
         return mish(input)
-