moving over from github

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pth.tar filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+**/__pycache__/
+**/.ipynb_checkpoints/
+**/data/
+**/datasets/
+**/development/

LICENSE

@@ -0,0 +1,2 @@
+Demo software - Experiments on person tracking with quantized networks by HyperbeeAI
+Copyrights © 2023 Hyperbee.AI Inc. All rights reserved. main@shallow.ai

README.md

@@ -1,3 +1,9 @@
----
-license: other
----
+# Experiments on person tracking with quantized networks by HyperbeeAI
+
+Copyrights © 2023 Hyperbee.AI Inc. All rights reserved. main@shallow.ai
+
+This repository contains our experiments for quantized neural networks for the person tracking task, evaluated over the WIDER pedestrian surveillance dataset.
+
+See efficientdet_comparison/ for the comparison of our trained models with efficientdet
+
+![demo](./experiments/demo.gif)

dataloader.py

@@ -0,0 +1,513 @@
+###########################################################################
+# Computer vision - Embedded person tracking demo software by HyperbeeAI. #
+# Copyrights © 2023 Hyperbee.AI Inc. All rights reserved. main@shallow.ai #
+###########################################################################
+import os, sys, random, torch, torchvision
+from torchvision import transforms
+from torchvision.datasets.vision import VisionDataset
+import torchvision.ops as ops
+import torch.utils.data
+import numpy as np
+import pandas as pd
+import copy
+from PIL import Image
+import os.path
+import time, json
+from typing import Any, Callable, Optional, Tuple, List
+from typing import Callable
+
+
+class input_fxpt_normalize:
+    def __init__(self, act_8b_mode):
+        self.act_8b_mode = act_8b_mode
+
+    def __call__(self, img):
+        if(self.act_8b_mode):
+            return img.sub(0.5).mul(256.).round().clamp(min=-128, max=127)
+        return img.sub(0.5).mul(256.).round().clamp(min=-128, max=127).div(128.)
+
+
+### Emre Can: Our COCO Dataloder for training classes at specific ratio in every batch.
+def class_lookup(cls):
+    c = list(cls.__bases__)
+    for base in c:
+        c.extend(class_lookup(base))
+    return c
+
+# ref: https://pytorch.org/vision/main/_modules/torchvision/datasets/coco.html
+class CocoDetection(VisionDataset):
+    """`MS Coco Detection <https://cocodataset.org/#detection-2016>`_ Dataset.
+    Args:
+        root (string): Root directory where images are downloaded to.
+        
+        annFile (string): Path to json annotation file.
+        
+        scaleImgforCrop (int, optional): Img and target BBs are scaled with 
+        constant aspect ratio st:
+            if image width, image height > scaleImgforCrop image is shrinked 
+            until width or height becomes equal to scaleImgforCrop
+    
+            if image width, image height < scaleImgforCrop image is expanded 
+            until width or height becomes equal to scaleImgforCrop
+            
+            else no scaling
+        fit_full_img: If it is set to true, image is scaled t fully fit in the window specified by "scaleImgforCrop x scaleImgforCrop"  
+        transform (callable, optional): A function/transform that  takes in an 
+        PIL image and returns a transformed version. E.g, ``transforms.ToTensor``
+        
+        target_transform (callable, optional): A function/transform that takes in 
+        the target and transforms it.
+        transforms (callable, optional): A function/transform that takes input 
+        sample and its target as entry and returns a transformed version.
+    """
+
+    def __init__(
+        self,
+        root: str,
+        annFile: str,
+        scaleImgforCrop: int= None,
+        fit_full_img = False,
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+        transforms: Optional[Callable] = None
+    ):
+        super().__init__(root, transforms, transform, target_transform)
+        from pycocotools.coco import COCO
+        
+        self.coco = COCO(annFile)
+        self.ids = list(sorted(self.coco.imgs.keys()))
+        self.annFilePath = os.path.join('.',annFile)
+        self.catPersonId = self.coco.getCatIds(catNms=['person'])[0]
+        self.scaleImgforCrop = scaleImgforCrop
+        self.fit_full_img = fit_full_img
+        
+
+    def _load_image(self, id: int) -> Image.Image:
+        path = self.coco.loadImgs(id)[0]["file_name"]
+        return Image.open(os.path.join(self.root, path)).convert("RGB")
+
+    def _load_target(self, id) -> List[Any]:
+        return self.coco.loadAnns(self.coco.getAnnIds(id, iscrowd=False))
+
+    def __getitem__(self, index: int) -> Tuple[Any, Any, Any]:
+
+        id = self.ids[index]
+        imgID = id
+
+        try:
+            image = self._load_image(id)
+        except:
+            print(f'********Unable to load image with id: {imgID}********')
+            print('Please check if image is corrupted, and remove it from annotations if necessary.')
+            
+            
+        target = copy.deepcopy(self._load_target(id)) # deepcopy target list beforecentercrop manip, to be abe to work with same
+                                                      # dateset without reloading it 
+        
+        image_width = image.size[0]
+        image_height = image.size[1]
+        
+        
+        # If necesary rescale the image and BBs near the size of planned center crop as much as possible
+        scale = self._calcPrescale(image_width=image_width, image_height=image_height)
+        image = self._prescaleImage(image, scale)
+        
+        for i, t in enumerate(target):
+            BB = t['bbox'].copy()
+            scaledBB = self._prescaleBB(BB,scale)
+            target[i]['bbox'] = scaledBB
+            
+        
+        
+        # Image width height after prescaling
+        image_width = image.size[0]
+        image_height = image.size[1]
+        
+        # Check if center crop applied
+        centerCropped = False
+        if self.transforms is not None:
+            image, target = self.transforms(image, target)
+            
+            # If center crop applied, transform BBs as well
+            for t in self.transforms.transform.transforms:
+                if (type(t) == torchvision.transforms.transforms.CenterCrop):
+                    centerCropped = True
+        
+        
+
+        x_scale = image.size(2) / image_width
+        y_scale = image.size(1) / image_height
+
+        bbox_arr = []
+        
+        for idx,ann in enumerate(target):
+            if ann['category_id'] == self.catPersonId:
+                crop_size = image.shape[1]
+                
+                if centerCropped:
+                    bbox = ann['bbox'].copy()
+                    croppedBB = self.cropBBox(bbox, crop_size,image_height,image_width)    
+                else:
+                    croppedBB = torch.tensor(ann['bbox']) 
+                
+                if not (croppedBB == None):
+                    bbox_arr.append(croppedBB)                
+                             
+        if len(bbox_arr) != 0:
+            bbox_arr = torch.stack(bbox_arr)
+            wh = bbox_arr[:, 2:] 
+            xy = bbox_arr[:, :2]
+            
+            id_tensor = torch.tensor([id]).unsqueeze(0).expand(bbox_arr.size(0), -1)
+
+            bbox_arr = torch.cat([id_tensor, xy, wh], dim=-1)
+        else:
+            bbox_arr = torch.tensor(bbox_arr)
+               
+        return image, bbox_arr , imgID 
+
+    def __len__(self) -> int:
+        return len(self.ids)
+    
+    def get_labels(self):
+        labels = []
+        for id in self.ids:
+            anns = self._load_target(id)
+            person_flag = False
+            for ann in anns:     
+                person_flag = ann['category_id'] == self.catPersonId
+                if person_flag == True:
+                    break
+            if person_flag == True:
+                labels.append(1)
+            else:
+                labels.append(0)
+        return torch.tensor(labels)
+    
+    def get_cat_person_id(self):
+        return self.catPersonId
+    
+    def get_coco_api(self):
+        return self.coco
+    
+    
+    # Functions defined for prescaling images/targets before center crop operation
+    def _calcPrescale(self, image_width, image_height):
+        # Calculate scale factor to shrink/expand image to coincide width or height to croppig area
+        scale = 1.0
+        if self.scaleImgforCrop != None:
+            if self.fit_full_img:
+                max_size = max(image_width, image_height)
+                scale = max_size/self.scaleImgforCrop
+            else:
+                # image fully encapsulates cropping area or vice versa
+                if ((image_width-self.scaleImgforCrop)*(image_height-self.scaleImgforCrop) > 0): 
+                    # if width of original image is closer to crop area
+                    if abs(1-image_width/self.scaleImgforCrop) < abs(1-image_height/self.scaleImgforCrop):
+                        scale = image_width/self.scaleImgforCrop
+                    else:
+                        scale = image_height/self.scaleImgforCrop
+        return scale
+    
+    # Scales the image with defined scale
+    def _prescaleImage(self, image, scale):
+        image_width = int(image.size[0]/scale)
+        image_height = int(image.size[1]/scale)
+
+        t = transforms.Resize([image_height,image_width])
+        image = t(image)
+        return image
+    
+    # Scales the targets with defined scale
+    def _prescaleBB(self, BB, scale):
+        scaledbb = [round(p/scale,1) for p in BB]
+        return scaledbb
+        
+    
+    def cropBBox(self,bbox,crop_size, image_height, image_width):
+
+        bbox_aligned = []
+        x, y, w, h = bbox[0], bbox[1], bbox[2], bbox[3]
+
+        # Casses for cropping       
+        if image_height < crop_size:
+            offset = (crop_size - image_height) // 2
+            y = y + offset
+            if (y+h) > crop_size:
+                offset = (y+h)-crop_size
+                h = h - offset
+        if image_width < crop_size:
+            offset = (crop_size - image_width) // 2
+            x = x + offset
+            if (x+w) > crop_size:
+                offset = (x+w)-crop_size
+                w = w - offset
+        if image_width > crop_size:
+            offset = (image_width - crop_size) // 2
+            if offset > x:
+                # Deal with BB coincide with left cropping boundary
+                w = w -(offset-x)
+                x = 0
+            else:
+                x = x - offset
+                
+                # Deal with BB coincide with right cropping boundary
+                if (x+w) > crop_size:
+                    offset = (x+w)-crop_size
+                    w = w - offset
+                    
+        if image_height > crop_size:
+
+            offset = (image_height - crop_size) // 2
+            if offset > y:
+                # Deal with BB coincide with top cropping boundary
+                h = h -(offset-y)
+                y = 0
+            else:
+                y = y - offset
+                # Deal with BB coincide with bottom cropping boundary
+                if (y+h) > crop_size:
+                    offset = (y+h)-crop_size
+                    h = h - offset
+        
+        bbox_aligned.append(x)
+        bbox_aligned.append(y)
+        bbox_aligned.append(w)
+        bbox_aligned.append(h)
+
+        if ((w <= 0) or (h <= 0)):
+            return None
+        else:
+            x_scale, y_scale = 1.0,1.0
+            return torch.mul(torch.tensor(bbox_aligned), torch.tensor([x_scale, y_scale, x_scale, y_scale]))
+    
+    def __round_floats(self,o):
+        '''
+        Used to round floats before writing to json file
+        '''
+        if isinstance(o, float):
+            return round(o, 2)
+        if isinstance(o, dict):
+            return {k: self.__round_floats(v) for k, v in o.items()}
+        if isinstance(o, (list, tuple)):
+            return [self.__round_floats(x) for x in o]
+        return o
+    
+    def _check_if_annot_ignored(self, annot_bbox, ignore_bboxes):
+        '''gets an annotation and ignore bboxes list in [xmin, ymin, w, h] form and calculates the percentage
+           of the overlapping area. If overlapping area exceeds 50% for any ignore part, returns True, otherwise returns False
+        '''
+        annot_bbox = annot_bbox.copy()
+        annot_area = max(annot_bbox[2] * annot_bbox[3], 0)
+        annot_bbox[2] = annot_bbox[0] + annot_bbox[2]
+        annot_bbox[3] = annot_bbox[1] + annot_bbox[3]
+        
+        for ignore_bbox in ignore_bboxes:
+            
+            ignore_bbox  = ignore_bbox.copy()
+
+            ignore_bbox[2] = ignore_bbox[0] + ignore_bbox[2]
+            ignore_bbox[3] = ignore_bbox[1] + ignore_bbox[3]
+
+            x_min_intersect = max(annot_bbox[0], ignore_bbox[0])
+            y_min_intersect = max(annot_bbox[1], ignore_bbox[1])
+            x_max_intersect = min(annot_bbox[2], ignore_bbox[2])
+            y_max_intersect = min(annot_bbox[3], ignore_bbox[3])
+            w = max(x_max_intersect - x_min_intersect, 0)
+            h = max(y_max_intersect - y_min_intersect, 0)
+            
+            if annot_area <= 0:
+                return True
+            
+            if w * h / annot_area > 0.5:
+                return True
+            
+        return False
+        
+    
+    def createResizedAnnotJson(self,targetFileName,cropsize=512, mask_ignore_parts=False, ignore_parts_file=None):
+        '''
+        Resizes person annotations after center crop operation and saves as json file to the
+        directory of original annotations with the name "targetFileName"
+        
+        If 'mask_ignore_parts' flag set to true and corresponding wider dataset ignore_parts_file supplied, 
+        annotations having 50% or more overlap with an ignore part are deleted.
+        
+        '''
+        
+        # Get ignore part bb's in to a dictionary, wit image names as keys
+        if mask_ignore_parts:
+            ignore_part_dict = {}
+            with open(ignore_parts_file) as f:
+                for t, ignore_raw in enumerate(f):
+                    ignore_raw = ignore_raw.split()
+                    imgName = ignore_raw[:1][0]
+
+                    BBs_str = ignore_raw[1:]
+                    bb_raw = [int(bb) for bb in BBs_str]
+
+                    BBs = []
+                    bb = []
+                    for i, p in enumerate(bb_raw):
+                        bb.append(p)
+                        if ((i+1)%4 == 0):
+
+                            BBs.append(bb)
+                            bb = []
+
+                    ignore_part_dict[imgName] = BBs
+            
+        
+        t1 = time.time()
+        # Get original json annot file path, and create pah for resized json annot file
+        path, annotfilename = os.path.split(self.annFilePath)
+        resizedAnnotPath = os.path.join(path,targetFileName)
+        
+        print('')
+        print(f'Creating Json file for resized annotations: {resizedAnnotPath}')
+        
+
+        # Load original annotation json file as dictionary and assign it to resized annot dict
+        with open(self.annFilePath) as json_file:
+            resizedanotDict = json.load(json_file)
+
+        # Original annotations array
+        origannList = resizedanotDict['annotations']
+        
+        # Check if center crop applied
+        centerCropped = False
+        if self.transforms is not None:
+            # If center crop applied, transform BBs as well
+            for t in self.transforms.transform.transforms:
+                if (type(t) == torchvision.transforms.transforms.CenterCrop):
+                    centerCropped = True
+                    
+        
+        resizedannList = []
+        for resizedannot in origannList:
+
+            currentcatID = resizedannot['category_id']
+            currentBB = resizedannot['bbox']
+            currentImgID = resizedannot['image_id']
+            
+            # if annotations overlaps with an ignore part, do not add it to new annot file
+            if mask_ignore_parts:
+                image_name = self.coco.loadImgs(currentImgID)[0]['file_name']
+                if image_name in ignore_part_dict:
+                    ignoreBBs = ignore_part_dict[image_name]
+                    is_ignored = False
+                    is_ignored = self._check_if_annot_ignored(resizedannot['bbox'].copy(), ignoreBBs)
+
+                    if is_ignored:
+                        continue
+            
+            # Get crop size and original image sizes
+            image_width = self.coco.loadImgs(currentImgID)[0]['width']
+            image_height = self.coco.loadImgs(currentImgID)[0]['height']
+
+            
+            # If presclae applied to image, calculate new image width and height
+            scale = self._calcPrescale(image_width=image_width, image_height=image_height)
+            image_width = image_width / scale
+            image_height = image_height / scale
+
+            if currentcatID == self.catPersonId:
+                # if BB is person
+                bbox = resizedannot['bbox'].copy()
+                
+                # If prescale appied to image, resize annotations BBs
+                bbox = self._prescaleBB(bbox, scale)
+                
+                # If center crop  applied, crop/recalculate BBs as well
+                if centerCropped:
+                    croppedBB = self.cropBBox(bbox, cropsize,image_height,image_width)    
+                else:
+                    croppedBB = torch.tensor(bbox) 
+                
+                if (croppedBB != None):
+                    # If BB is person and valid after crop, add it to resized annotations list
+                    croppedBB = croppedBB.tolist()
+                    resizedannot['bbox'] = self.__round_floats(croppedBB)
+                    resizedannot['area'] = self.__round_floats(croppedBB[2]*croppedBB[3])
+                    resizedannList.append(resizedannot)
+            else:
+                # If BB is non-person add it to resized annotations list as it is
+                resizedannList.append(resizedannot)
+                
+        # If prescale or center-crop applied
+        # Change width and height information of "images" field in annotations file
+        origImgList = resizedanotDict['images']
+        
+        for i, imagInfo in enumerate(origImgList):
+            curInfo = origImgList[i]
+            image_width = curInfo['width']
+            image_height = curInfo['height']
+            
+            if centerCropped:
+                curInfo['width'] = cropsize
+                curInfo['height'] = cropsize
+            else:
+                scale = self._calcPrescale(image_width=image_width, image_height=image_height)
+                curInfo['width'] = int(image_width / scale)
+                curInfo['height'] = int(image_height / scale)
+
+            origImgList[i] = curInfo.copy()
+                
+        resizedanotDict['images'] = origImgList
+        resizedanotDict['annotations'] = resizedannList
+        print('Saving resized annotations to json file...')
+
+        # Save resized annotations in json file
+        resizedanotDict = json.dumps(resizedanotDict)
+        with open(resizedAnnotPath, 'w') as outfile:
+            outfile.write(resizedanotDict)
+
+        print(f'{resizedAnnotPath} saved.')
+        t2 = time.time()
+        print(f'Elapsed time: {t2-t1} seconds')
+            
+# ref: https://github.com/ufoym/imbalanced-dataset-sampler
+class ImbalancedDatasetSampler(torch.utils.data.sampler.Sampler):
+    """Samples elements randomly from a given list of indices for imbalanced dataset
+    Arguments:
+        indices: a list of indices
+        num_samples: number of samples to draw
+        constantSeed: Make it true if you want same random at each run
+        callback_get_label: a callback-like function which takes two arguments - dataset and index
+    """
+
+    def __init__(self, dataset,constantSeed: bool = False, indices: list = None, num_samples: int = None, 
+                 callback_get_label: Callable = None, ratio: int = 4):
+        # if indices is not provided, all elements in the dataset will be considered
+        self.constantSeed = constantSeed
+        self.indices = list(range(len(dataset))) if indices is None else indices
+
+        # define custom callback
+        self.callback_get_label = callback_get_label
+
+        # if num_samples is not provided, draw `len(indices)` samples in each iteration
+        self.num_samples = len(self.indices) if num_samples is None else num_samples
+
+        # distribution of classes in the dataset
+        df = pd.DataFrame()
+        df["label"] = self._get_labels(dataset)
+        df.index = self.indices
+        df = df.sort_index()
+
+        label_to_count = df["label"].value_counts()
+        label_to_count[1] = int(label_to_count[1] / ratio)
+
+        weights = 1.0 / label_to_count[df["label"]]
+
+        self.weights = torch.DoubleTensor(weights.to_list())
+
+    def _get_labels(self, dataset):
+        return dataset.get_labels()
+
+    def __iter__(self):
+        if self.constantSeed:
+            torch.random.manual_seed(1234)
+        return (self.indices[i] for i in torch.multinomial(self.weights, self.num_samples, replacement=True))
+
+    def __len__(self):
+        return self.num_samples

efficientdet_comparison/coco_eval.py

@@ -0,0 +1,301 @@
+###########################################################################
+# Computer vision - Embedded person tracking demo software by HyperbeeAI. #
+# Copyrights © 2023 Hyperbee.AI Inc. All rights reserved. main@shallow.ai #
+###########################################################################
+# Author: Zylo117
+
+"""
+COCO-Style Evaluations
+
+put images here datasets/your_project_name/val_set_name/*.jpg
+put annotations here datasets/your_project_name/annotations/instances_{val_set_name}.json
+put weights here /path/to/your/weights/*.pth
+change compound_coef
+
+"""
+
+import json
+import os
+import numpy as np
+
+import argparse
+import torch
+from tqdm import tqdm
+from pycocotools.coco import COCO
+from pycocotools.cocoeval import COCOeval
+from torch.utils.data import DataLoader
+import torchvision
+import torchvision.transforms as transforms
+import time
+
+from models import mnv2_SSDlite
+from library.ssd import conv_model_fptunc2fpt, conv_model_fpt2qat, conv_model_qat2hw, collate_fn, PredsPostProcess, round_floats
+from dataloader import CocoDetection, input_fxpt_normalize
+
+#from library.ssd import generateAnchorsInOrigImage, collate_fn, point_form, prepareHeadDataforLoss_fast, plot_image_mnv2_2xSSDlite, sampleRandomPicsFromCOCO, saveOutputs ,PredsPostProcess, calculatemAP, batchNormAdaptation, round_floats
+
+ap = argparse.ArgumentParser()
+ap.add_argument('-m', '--mode', type=str, default='qat', help='Mode of the model, allowed modes: fpt_unc, fpt, qat')
+ap.add_argument('--nms_threshold', type=float, default=0.5, help='non max supression threshold')
+ap.add_argument('--conf_threshold', type=float, default=0.5, help='confidence treshold, predictions below this level will be discarded')
+ap.add_argument('-dp', '--data_path', type=str, default=None, help='/path/to/images')
+ap.add_argument('-ap', '--json_path', type=str, default=None, help='/path/to/annotations.json')
+ap.add_argument('-wp', '--weights_path', type=str, default=None, help='/path/to/weights')
+
+args = ap.parse_args()
+
+mode = args.mode
+nms_threshold = args.nms_threshold
+conf_threshold = args.conf_threshold
+data_path = args.data_path
+json_path = args.json_path
+weights_path = args.weights_path
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+def evaluate_coco(model, DATA_PATH, JSON_PATH , nmsIoUTreshold = 0.5, PredMinConfTreshold = 0.5, HW_mode = False):
+    
+    if HW_mode:
+        act_8b_mode = True
+    else:
+        act_8b_mode = False
+
+    transform = transforms.Compose([transforms.ToTensor(), input_fxpt_normalize(act_8b_mode=act_8b_mode)])
+    targetFileName = 'resized.json'
+    dataset = CocoDetection(root=DATA_PATH, annFile=JSON_PATH, transform=transform, scaleImgforCrop= None)
+
+    dataset.createResizedAnnotJson(targetFileName=targetFileName)
+    resizedFilePath = os.path.join(os.path.split(JSON_PATH)[0],targetFileName)
+    cocoGt=COCO(resizedFilePath)
+    os.remove(resizedFilePath)
+
+    seq_sampler = torch.utils.data.SequentialSampler(dataset)
+    data_loader = DataLoader(dataset,
+                              sampler=seq_sampler,
+                              batch_size=1,
+                              collate_fn=collate_fn,
+                              drop_last=False)
+    print(f"Dataset Length: {len(dataset)}, Number of Batches: {len(data_loader)}")
+    
+    ANCHORS_HEAD1 = [(11.76, 28.97),
+                     (20.98, 52.03),
+                     (29.91, 77.24),
+                     (38.97, 106.59)]
+
+    ANCHORS_HEAD2 = [(52.25, 144.77),
+                    (65.86, 193.05),
+                    (96.37, 254.09),
+                    (100.91, 109.82),
+                    (140, 350)]
+    
+    predsPostProcess = PredsPostProcess(512, ANCHORS_HEAD1, ANCHORS_HEAD2)
+
+    
+    dataDictList =[]
+    imgIDS = []
+    for i, data in enumerate(tqdm(data_loader)):
+        imageBatch, targetBatch , idxBatch = data
+
+        imageStack = torch.stack(imageBatch).detach().to(device)
+        imageStack.requires_grad_(True)
+        predBatch = model(imageStack)
+        
+        if HW_mode:
+            BBs1 = predBatch[0].detach() / 128.0
+            CFs1 = predBatch[1].detach() / 128.0
+            BBs2 = predBatch[2].detach() / 128.0
+            CFs2 = predBatch[3].detach() / 128.0
+        else:
+            BBs1 = predBatch[0].detach()
+            CFs1 = predBatch[1].detach()
+            BBs2 = predBatch[2].detach()
+            CFs2 = predBatch[3].detach()
+
+        for imgNum in range(imageStack.shape[0]):
+            img = imageStack[imgNum,:,:,:]
+            target = targetBatch[imgNum]
+            image_id = int(idxBatch[imgNum])
+            imgIDS.append(image_id)
+
+            pred = (BBs1[imgNum,:,:,:].unsqueeze(0), CFs1[imgNum,:,:,:].unsqueeze(0), 
+                    BBs2[imgNum,:,:,:].unsqueeze(0), CFs2[imgNum,:,:,:].unsqueeze(0))
+
+            boxes, confidences = predsPostProcess.getPredsInOriginal(pred)
+
+            nms_picks   = torchvision.ops.nms(boxes, confidences, nmsIoUTreshold) 
+            boxes_to_draw = boxes[nms_picks]
+            confs_to_draw = confidences[nms_picks]
+            confMask = (confs_to_draw > PredMinConfTreshold)
+
+            # Inputs to mAP algorithm
+            if (confMask.any()):
+
+                # pred boxes -> [xmin,ymin,xmax,ymax], tensor shape[numpred,4]
+                bbox = boxes_to_draw[confMask]
+                scores = confs_to_draw[confMask]
+                # Convert BB to coco annot format -> [xmin,ymin,width, height]
+                bbox[:,2] = bbox[:,2] - bbox[:,0]
+                bbox[:,3] = bbox[:,3] - bbox[:,1]
+                
+
+                bbox = bbox.tolist() # pred boxes -> [xmin,ymin,xmax,ymax], shape[numpred,4]
+                score = scores.tolist()
+                category_id = np.ones_like(score,dtype=int).tolist()
+
+                for j in range(len(bbox)):
+                    box = {"image_id":image_id, "category_id":category_id[j], "bbox":bbox[j],"score":score[j]}
+                    dataDictList.append(round_floats(box))
+
+    if (len(dataDictList)):        
+        # Evavluate and Accumulate mAP for remained baches, if any
+        cocoDT = json.dumps(dataDictList)
+
+        # Write detections to .json file
+        with open('cocoDT.json', 'w') as outfile:
+            outfile.write(cocoDT) 
+
+        # Load detections
+        cocoDt=cocoGt.loadRes('cocoDT.json')
+        os.remove("cocoDT.json")
+
+        # running evaluation
+        annType = 'bbox'
+        cocoEval = COCOeval(cocoGt,cocoDt,annType)
+        cocoEval.params.catIds = 1
+        cocoEval.params.imgIds  = imgIDS
+        cocoEval.evaluate()
+        cocoEval.accumulate()
+        
+        print('')
+        cocoEval.summarize()
+    else:
+        raise Exception('the model does not provide any valid output, check model architecture and the data input')
+
+
+if __name__ == '__main__':
+    model = mnv2_SSDlite()
+    
+    layer_bits_dictionary = {}
+    layer_bits_dictionary['conv1' ] = 8;
+    layer_bits_dictionary['epw_conv2' ] = 8;
+    layer_bits_dictionary['dw_conv2' ]  = 8;
+    layer_bits_dictionary['ppw_conv2' ] = 8;
+
+    layer_bits_dictionary['epw_conv3' ] = 8;
+    layer_bits_dictionary['dw_conv3' ]  = 8;
+    layer_bits_dictionary['ppw_conv3' ] = 8;
+
+    layer_bits_dictionary['epw_conv4' ] = 8;
+    layer_bits_dictionary['dw_conv4' ]  = 8;
+    layer_bits_dictionary['ppw_conv4' ] = 8;
+
+    layer_bits_dictionary['epw_conv5']  = 8;
+    layer_bits_dictionary['dw_conv5']   = 8;
+    layer_bits_dictionary['ppw_conv5']  = 8;
+
+    layer_bits_dictionary['epw_conv6']  = 8;
+    layer_bits_dictionary['dw_conv6']   = 8;
+    layer_bits_dictionary['ppw_conv6']  = 8;
+
+    layer_bits_dictionary['epw_conv7']  = 8;
+    layer_bits_dictionary['dw_conv7']   = 8;
+    layer_bits_dictionary['ppw_conv7']  = 8;
+
+    layer_bits_dictionary['epw_conv8']  = 8;
+    layer_bits_dictionary['dw_conv8']   = 8;
+    layer_bits_dictionary['ppw_conv8']  = 8;
+
+    layer_bits_dictionary['epw_conv9']  = 8;
+    layer_bits_dictionary['dw_conv9']   = 8;
+    layer_bits_dictionary['ppw_conv9']  = 8;
+
+    layer_bits_dictionary['epw_conv10'] = 8;
+    layer_bits_dictionary['dw_conv10']  = 8;
+    layer_bits_dictionary['ppw_conv10'] = 8;
+
+    layer_bits_dictionary['epw_conv11'] = 8;
+    layer_bits_dictionary['dw_conv11']  = 8;
+    layer_bits_dictionary['ppw_conv11'] = 8;
+
+    layer_bits_dictionary['epw_conv12'] = 8;
+    layer_bits_dictionary['dw_conv12']  = 8;
+    layer_bits_dictionary['ppw_conv12'] = 8;
+
+    layer_bits_dictionary['epw_conv13'] = 8;
+    layer_bits_dictionary['dw_conv13']  = 8;
+    layer_bits_dictionary['ppw_conv13'] = 8;
+
+    layer_bits_dictionary['epw_conv14'] = 8;
+    layer_bits_dictionary['dw_conv14']  = 8;
+    layer_bits_dictionary['ppw_conv14'] = 8;
+
+    layer_bits_dictionary['epw_conv15'] = 8;
+    layer_bits_dictionary['dw_conv15']  = 8;
+    layer_bits_dictionary['ppw_conv15'] = 8;
+
+    layer_bits_dictionary['epw_conv16'] = 8;
+    layer_bits_dictionary['dw_conv16']  = 8;
+    layer_bits_dictionary['ppw_conv16'] = 8;
+
+    layer_bits_dictionary['epw_conv17'] = 8;
+    layer_bits_dictionary['dw_conv17']  = 8;
+    layer_bits_dictionary['ppw_conv17'] = 8;
+
+    layer_bits_dictionary['epw_conv18'] = 8;
+    layer_bits_dictionary['dw_conv18']  = 8;
+    layer_bits_dictionary['ppw_conv18'] = 8;
+
+    layer_bits_dictionary['head1_dw_classification'] = 8;
+    layer_bits_dictionary['head1_pw_classification'] = 8;
+    layer_bits_dictionary['head1_dw_regression'] = 8;
+    layer_bits_dictionary['head1_pw_regression'] = 8;
+
+    layer_bits_dictionary['head2_dw_classification'] = 8;
+    layer_bits_dictionary['head2_pw_classification'] = 8;
+    layer_bits_dictionary['head2_dw_regression'] = 8;
+    layer_bits_dictionary['head2_pw_regression'] = 8;
+
+    # Convert model to appropriate mode before loading weights
+    HW_mode = False
+    if mode == 'fpt_unc':
+        model.to(device)
+        
+    elif mode == 'fpt':
+        model = conv_model_fptunc2fpt(model)
+        model.to(device)
+        
+    elif mode == 'qat':
+        model = conv_model_fptunc2fpt(model)
+        model.to(device)
+        model = conv_model_fpt2qat(model, layer_bits_dictionary)
+        model.to(device)
+        
+    elif mode == 'hw':
+        HW_mode = True
+        model = conv_model_fptunc2fpt(model)
+        model.to(device)
+        model = conv_model_fpt2qat(model, layer_bits_dictionary)
+        model.to(device)
+        model = conv_model_qat2hw(model)
+        model.to(device)
+
+    else:
+        raise Exception('Invalid model mode is selected, select from: fpt_unc, fpt, qat, hw')
+
+
+    weights = torch.load(weights_path, map_location=torch.device('cpu'))
+    model.load_state_dict(weights['state_dict'], strict=True)
+
+    model.requires_grad_(False)
+    model.eval()
+    
+    if mode == 'qat' or mode == 'hw':
+        print(''*5)
+        print('*'*120)
+        print('qat or hardware mode is selected, please make sure you configured layer_bits_dictionary in "coco_eval.py" accordingly!!!')
+        print('*'*120)
+        print('')
+        time.sleep(5)
+
+    evaluate_coco(model, DATA_PATH=data_path, JSON_PATH=json_path , nmsIoUTreshold=nms_threshold, 
+                  PredMinConfTreshold=conf_threshold, HW_mode = HW_mode)

efficientdet_comparison/hardware_experiment_best.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4712fd8026f221b6a40f464438821858389a7a9d021da6c4f2ddb881d7a695e
+size 7481103

efficientdet_comparison/readme.md

@@ -0,0 +1,186 @@
+# Performance Benchmark of Quantized Detection Model
+
+This directory is built for comparison of our "quantized / quantization aware trained" detection algorithm to one of the SOTA compact detection algorithms, EfficientDet-d0, which has comparable complexity and structure with our quantized model.
+
+Our person tracking algorithm uses MobileNet-v2 as backbone mechanism and combines it with 2 SSD heads using total of 9 anchor boxes. Overall model consists of 60 convolution layers. 
+
+We quantized the layers of this model and applied "quantization aware training" methods to recover its accuracy drop due to quantization of layers and output clamping. We have re-scaled and center cropped the images in [Wider Person Dataset](https://competitions.codalab.org/competitions/20132#learn_the_details), also we resized its annotations and converted in to COCO annotation format to use them in our training/evaluation tasks. Then we applied smart training approaches which consider the effects of quantization and output clamping of the layers during optimization, which we call "quantization aware training".
+
+Our main motivation of quantizing networks and applying quantization aware training methods is to reduce the overall network size, inference time and training effort while keeping accuracy drop in an acceptable level. We aim to develop quantized compact detection algorithms executable on low power and low cost accelerator chips.
+
+## Dependencies
+* [PyTorch](https://github.com/pytorch/pytorch)
+* [Torchvision](https://github.com/pytorch/vision)
+* [Pycocotools](https://github.com/cocodataset/cocoapi/tree/master/PythonAPI/pycocotools)
+* [webcolors](https://pypi.org/project/webcolors/)
+* [PyYAML](https://github.com/yaml/pyyaml)
+
+## Evaluating EfficientDet with Wider Person Validation Dataset
+In this section, steps to reproduce the evaluation of EfficientDet model from [Yet-Another-EfficientDet-Pytorch Repository](https://github.com/zylo117/Yet-Another-EfficientDet-Pytorch.git) with d0 coefficients is explained. For evaluation, aforementioned Wider Person Validation Dataset in COCO format is used. 
+
+### 1. Clone EfficientDet to Your Local
+Open a terminal and go to directory in your local where you want to clone , then type:
+```bash
+git clone --depth 1 https://github.com/zylo117/Yet-Another-EfficientDet-Pytorch
+```
+
+### 2. Prepare EfficientDet-d0 Coefficients
+* Go to main directory
+    ```bash
+    cd Yet-Another-EfficientDet-Pytorch/
+    ```
+* Create weights folder
+    ```bash
+    mkdir weights
+    ```
+* Download EfficientDet d0 coefficients 
+    ```bash
+    wget https://github.com/zylo117/Yet-Another-EfficientDet-Pytorch/releases/download/1.0/efficientdet-d0.pth -O weights/efficientdet-d0.pth
+    ```
+
+### 3. Prepare Wider Person Dataset
+* Download original Wider Person Dataset
+    * Sign up [Codalab](https://competitions.codalab.org/) and  participate to [WIDER Face & Person Challenge 2019](https://competitions.codalab.org/competitions/20132)
+    * Under "Participate" tab click "Train & Validation Data in Google Drive" and download
+        * val_data.tar.gz
+        * Annotations/val_bbox.txt
+    * Extract val_data.tar.gz as val_data and move val_data folder under ./data/original_wider/val_data
+    * Move "val_bbox.txt" under ./data/original_wider/
+
+* Move our "wider2coco.py" script in "efficientdet_comparison" folder to main folder of your local "Yet-Another-EfficientDet-Pytorch" repository. Following code will produce resized images and annotations.
+    ```bash
+    python wider2coco.py -ip ./data/original_wider/val_data -af ./data/original_wider/val_bbox.txt 
+    ```
+* Script will automatically convert Wider Dataset in to COCO format and create following repository structure:
+
+        ./Yet-Another-EfficientDet-Pytorch/datasets/wider/val
+             image001.jpg
+             image002.jpg
+             ...
+        ./Yet-Another-EfficientDet-Pytorch/datasets/wider/annotations
+            instances_val.json
+    
+   
+
+### 4. Manually Set Project's Specific Parameters
+
+* Create a yml file "wider.yml" under "projects"
+    ```bash
+    touch projects/wider.yml
+    ```
+
+ * Copy following content in to "wider.yml" file
+ 
+       project_name: wider
+       train_set: train
+       val_set: val
+       num_gpus: 1  # 0 means using cpu, 1-N means using gpus 
+        
+       # Wider validation dataset mean and std in RGB order
+       mean: [0.416, 0.413, 0.406]
+       std: [0.308, 0.306, 0.310]
+        
+       # this is coco anchors, change it if necessary
+       anchors_scales: '[2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)]'
+       anchors_ratios: '[(1.0, 1.0), (1.4, 0.7), (0.7, 1.4)]'
+        
+       # objects from all labels from your dataset with the order from your annotations.
+       # its index must match your dataset's category_id.
+       # category_id is one_indexed,
+       # for example, index of 'car' here is 2, while category_id of is 3
+       obj_list: ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant', '', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', '', 'backpack', 'umbrella', '', '', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 'bottle', '', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', '', 'dining table', '', '', 'toilet', '', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', '', 'book', 'clock', 'vase', 'scissors','teddy bear', 'hair drier', 'toothbrush']
+
+### 5. Evaluate EfficientDet model performance
+* Setup "person only evaluation"
+    * Open "coco_eval.py" under <parent directory>/Yet-Another-EfficientDet-Pytorch
+    * Paste following code after line 132, "coco_eval.params.imgIds = image_ids", to evaluate mAP results only for person category
+        ```python
+        coco_eval.params.catIds = 1
+        ```
+
+* For evaluation on cuda enabled platform 
+    ```bash
+    python coco_eval.py -p wider -c 0 -w ./weights/efficientdet-d0.pth
+    ```
+
+* For evaluation on cuda disabled platform 
+    ```bash
+    python coco_eval.py -p wider -c 0 -w ./weights/efficientdet-d0.pth --cuda False
+    ```
+
+
+## Evaluating Our Quantized MobilenetSSDLite model with Wider Person Validation Dataset
+
+### 1. Clone Quantized Mobilenet Model to Your Local
+Open a terminal and go to directory in your local where you want to clone our [Quantization Aware Training - Person Tracking](https://github.com/sai-tr/persontracking_qat.git) repository, then type:
+```bash
+git clone --depth 1 https://github.com/sai-tr/persontracking_qat.git
+```
+
+### 2. Prepare Wider Person Dataset
+* Download original Wider Person Dataset
+    * Sign up [Codalab](https://competitions.codalab.org/) and  participate to [WIDER Face & Person Challenge 2019](https://competitions.codalab.org/competitions/20132)
+    * Under "Participate" tab click "Train & Validation Data in Google Drive" and download
+        * val_data.tar.gz
+        * Annotations/val_bbox.txt
+    * Extract val_data.tar.gz as val_data and move val_data folder under ./data/original_wider/val_data
+    * Move "val_bbox.txt" under ./data/original_wider/
+
+* Move our "wider2coco.py" script in "efficientdet_comparison" folder to main folder of your local "persontracking_qat" repository. Following code will produce resized images and annotations.
+    ```bash
+    python wider2coco.py -ip ./data/original_wider/val_data -af ./data/original_wider/val_bbox.txt 
+    ```
+* Script will automatically convert Wider Dataset in to COCO format and create following repository structure:
+
+        ./persontracking_qat/datasets/wider/val
+             image001.jpg
+             image002.jpg
+             ...
+        ./persontracking_qat/datasets/wider/annotations
+            instances_val.json
+
+### 3. Evaluate Quantized Mobilenet Model Performance
+Note that model mode should match with the loaded model parameter dictionary. Selectable model modes are: 
+* Full Precision Unconstrained(fpt_unc): All layers are in full precision and no output clamping
+* Full Precision Constrained(fpt): All layers are in full precision and layer output are clamped to +-1 
+* Quantized(qat): All layers are quantized layer outputs are clamped to +-1
+
+
+* Move our "coco_eval.py" script in "efficientdet_comparison" folder to "persontracking_qat" folder and use following command for evaluation:
+    ```bash
+    python coco_eval.py -m qat -dp ./datasets/wider/val -ap ./datasets/wider/annotations/all_val_prep.json -wp ./efficientdet_comparison/training_experiment_best.pth.tar
+    ```
+    Note that: Code evaluates quantized model with weights "training_experiment_best.pth.tar", using images and annotations in paths  "./datasets/wider/val" "./datasets/wider/annotations/instances_val.json" respectively.
+
+## mAP Comparisons
+### EfficientDet-d0
+    ### Wider Validation Dataset mAP scores ###
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.292
+    Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.543
+    Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.275
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.109
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.409
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.532
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.106
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.369
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.435
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.270
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.546
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.678
+    
+
+### Quantized Mobilenet
+    ### Wider Validation Dataset mAP scores ###
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.281
+    Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.457
+    Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.310
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.075
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.406
+    Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.582
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.107
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.324
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.331
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.110
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.481
+    Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.637
+    

efficientdet_comparison/training_experiment_best.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79dbbd0f1849c213da61f71985dce57a88b7cd03881cd093a44b3daab61902f4
+size 7480143

efficientdet_comparison/wider2coco.py

@@ -0,0 +1,577 @@
+###########################################################################
+# Computer vision - Embedded person tracking demo software by HyperbeeAI. #
+# Copyrights © 2023 Hyperbee.AI Inc. All rights reserved. main@shallow.ai #
+###########################################################################
+import os
+import datetime, time
+import json
+from PIL import Image
+from tqdm import tqdm
+
+import torch, torchvision 
+from torchvision import transforms
+from torchvision.datasets.vision import VisionDataset
+
+from typing import Any, Callable, Optional, Tuple, List
+import argparse
+
+##############################################################################
+####################### Functions to Prepare Images ##########################
+##############################################################################
+# Functions defined for prescaling images/targets before center crop operation
+def calcPrescale(image_width, image_height, scaleImgforCrop = 512):
+    # Calculate scale factor to shrink/expand image to coincide width or height to croppig area
+    scale = 1.0
+    # image fully encapsulates cropping area or vice versa
+    if ((image_width-scaleImgforCrop)*(image_height-scaleImgforCrop) > 0): 
+        # if width of original image is closer to crop area
+        if abs(1-image_width/scaleImgforCrop) < abs(1-image_height/scaleImgforCrop):
+            scale = image_width/scaleImgforCrop
+        else:
+            scale = image_height/scaleImgforCrop
+    return scale
+
+
+# Scales the image with defined scale
+def prescaleImage(image, scale):
+    
+    image_width = int(image.size[0]/scale)
+    image_height = int(image.size[1]/scale)
+
+
+    image_res = image.resize((image_width, image_height))
+    return image_res
+
+
+def preProcessImages(org_images_path):
+    corruptedImgs = []
+    ccrop_size = 512
+    folder_dir,folder_name = os.path.split(org_images_path)
+    cur_dir = os.getcwd()
+    
+    processed_images_path = os.path.join(cur_dir,'datasets','wider','val')
+    
+    if not os.path.isdir(processed_images_path):
+        os.makedirs(processed_images_path)
+    imageNames = os.listdir(org_images_path)
+    
+    for i, image in enumerate(tqdm(imageNames)):
+        try:
+            if(image.split('.')[1] == 'jpg'):
+                imgDir = os.path.join(org_images_path,image)
+                img = Image.open(imgDir)
+
+                # prescaling 
+                image_width = img.size[0]
+                image_height = img.size[1]
+                scale = calcPrescale(image_width, image_height,scaleImgforCrop=ccrop_size)
+                img_resized = prescaleImage(img, scale)
+
+                # Center Crop
+                width, height = img_resized.size   # Get dimensions
+
+                left = (width - ccrop_size)/2
+                top = (height - ccrop_size)/2
+                right = (width + ccrop_size)/2
+                bottom = (height + ccrop_size)/2
+
+                # Crop the center of the image
+                img_ccropped = img_resized.crop((left, top, right, bottom))
+                img_ccropped.save(os.path.join(processed_images_path, image))
+        except:
+            print('Cannot Load: ' + image + ', check if it is corrupted.')
+            corruptedImgs.append(image)
+
+    print('')
+    print('Conversion Finished')
+    print('')
+    if len(corruptedImgs):
+        print('Something wrong with the following images and they are not processed:')
+        print(corruptedImgs)
+        print('Please delete these images from associated annotations')
+    return
+
+
+##############################################################################
+##################### Functions to Prepare Annotations #######################
+##############################################################################
+class CocoDetection(VisionDataset):
+    """`MS Coco Detection <https://cocodataset.org/#detection-2016>`_ Dataset.
+    Args:
+        root (string): Root directory where images are downloaded to.
+        
+        annFile (string): Path to json annotation file.
+        
+        scaleImgforCrop (int, optional): Img and target BBs are scaled with 
+        constant aspect ratio st:
+            if image width, image height > scaleImgforCrop image is shrinked 
+            until width or height becomes equal to scaleImgforCrop
+    
+            if image width, image height < scaleImgforCrop image is expanded 
+            until width or height becomes equal to scaleImgforCrop
+            
+            else no scaling
+        transform (callable, optional): A function/transform that  takes in an 
+        PIL image and returns a transformed version. E.g, ``transforms.ToTensor``
+        
+        target_transform (callable, optional): A function/transform that takes in 
+        the target and transforms it.
+        transforms (callable, optional): A function/transform that takes input 
+        sample and its target as entry and returns a transformed version.
+    """
+
+    def __init__(
+        self,
+        root: str,
+        annFile: str,
+        scaleImgforCrop: int= None, 
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+        transforms: Optional[Callable] = None
+    ):
+        super().__init__(root, transforms, transform, target_transform)
+        from pycocotools.coco import COCO
+        
+        self.coco = COCO(annFile)
+        self.ids = list(sorted(self.coco.imgs.keys()))
+        self.annFilePath = os.path.join('.',annFile)
+        self.catPersonId = self.coco.getCatIds(catNms=['person'])[0]
+        self.scaleImgforCrop = scaleImgforCrop
+        
+    def _load_image(self, id: int) -> Image.Image:
+        path = self.coco.loadImgs(id)[0]["file_name"]
+        return Image.open(os.path.join(self.root, path)).convert("RGB")
+
+    def _load_target(self, id) -> List[Any]:
+        return self.coco.loadAnns(self.coco.getAnnIds(id, iscrowd=False))
+
+    def __getitem__(self, index: int) -> Tuple[Any, Any, Any]:
+
+        id = self.ids[index]
+        imgID = id
+
+        try:
+            image = self._load_image(id)
+        except:
+            print(f'********Unable to load image with id: {imgID}********')
+            print('Please check if image is corrupted, and remove it from annotations if necessary.')
+            
+            
+        target = copy.deepcopy(self._load_target(id)) # deepcopy target list beforecentercrop manip, to be abe to work with same
+                                                      # dateset without reloading it 
+        
+        image_width = image.size[0]
+        image_height = image.size[1]
+        
+        
+        # If necesary rescale the image and BBs near the size of planned center crop as much as possible
+        scale = self._calcPrescale(image_width=image_width, image_height=image_height)
+        image = self._prescaleImage(image, scale)
+        
+        for i, t in enumerate(target):
+            BB = t['bbox'].copy()
+            scaledBB = self._prescaleBB(BB,scale)
+            target[i]['bbox'] = scaledBB
+            
+        
+        
+        # Image width height after prescaling
+        image_width = image.size[0]
+        image_height = image.size[1]
+        
+        # Check if center crop applied
+        centerCropped = False
+        if self.transforms is not None:
+            image, target = self.transforms(image, target)
+            
+            # If center crop applied, transform BBs as well
+            for t in self.transforms.transform.transforms:
+                if (type(t) == torchvision.transforms.transforms.CenterCrop):
+                    centerCropped = True
+        
+        
+
+        x_scale = image.size(2) / image_width
+        y_scale = image.size(1) / image_height
+
+        bbox_arr = []
+        
+        for idx,ann in enumerate(target):
+            if ann['category_id'] == self.catPersonId:
+                crop_size = image.shape[1]
+                
+                if centerCropped:
+                    bbox = ann['bbox'].copy()
+                    croppedBB = self.cropBBox(bbox, crop_size,image_height,image_width)    
+                else:
+                    croppedBB = torch.tensor(ann['bbox']) 
+                
+                if not (croppedBB == None):
+                    bbox_arr.append(croppedBB)                
+                             
+        if len(bbox_arr) != 0:
+            bbox_arr = torch.stack(bbox_arr)
+            wh = bbox_arr[:, 2:] 
+            xy = bbox_arr[:, :2]
+            
+            id_tensor = torch.tensor([id]).unsqueeze(0).expand(bbox_arr.size(0), -1)
+
+            bbox_arr = torch.cat([id_tensor, xy, wh], dim=-1)
+        else:
+            bbox_arr = torch.tensor(bbox_arr)
+            
+            
+        return image, bbox_arr , imgID 
+
+    def __len__(self) -> int:
+        return len(self.ids)
+    
+    def get_labels(self):
+        labels = []
+        for id in self.ids:
+            anns = self._load_target(id)
+            person_flag = False
+            for ann in anns:     
+                person_flag = ann['category_id'] == self.catPersonId
+                if person_flag == True:
+                    break
+            if person_flag == True:
+                labels.append(1)
+            else:
+                labels.append(0)
+        return torch.tensor(labels)
+    
+    def get_cat_person_id(self):
+        return self.catPersonId
+    
+    def get_coco_api(self):
+        return self.coco
+    
+    
+    # Functions defined for prescaling images/targets before center crop operation
+    def _calcPrescale(self, image_width, image_height):
+        # Calculate scale factor to shrink/expand image to coincide width or height to croppig area
+        scale = 1.0
+        if self.scaleImgforCrop != None:
+            # image fully encapsulates cropping area or vice versa
+            if ((image_width-self.scaleImgforCrop)*(image_height-self.scaleImgforCrop) > 0): 
+                # if width of original image is closer to crop area
+                if abs(1-image_width/self.scaleImgforCrop) < abs(1-image_height/self.scaleImgforCrop):
+                    scale = image_width/self.scaleImgforCrop
+                else:
+                    scale = image_height/self.scaleImgforCrop
+        return scale
+    
+    # Scales the image with defined scale
+    def _prescaleImage(self, image, scale):
+        image_width = int(image.size[0]/scale)
+        image_height = int(image.size[1]/scale)
+
+        t = transforms.Resize([image_height,image_width])
+        image = t(image)
+        return image
+    
+    # Scales the targets with defined scale
+    def _prescaleBB(self, BB, scale):
+        scaledbb = [round(p/scale,1) for p in BB]
+        return scaledbb
+        
+    
+    def cropBBox(self,bbox,crop_size, image_height, image_width):
+
+        bbox_aligned = []
+        x, y, w, h = bbox[0], bbox[1], bbox[2], bbox[3]
+
+        # Casses for cropping       
+        if image_height < crop_size:
+            offset = (crop_size - image_height) // 2
+            y = y + offset
+            if (y+h) > crop_size:
+                offset = (y+h)-crop_size
+                h = h - offset
+        if image_width < crop_size:
+            offset = (crop_size - image_width) // 2
+            x = x + offset
+            if (x+w) > crop_size:
+                offset = (x+w)-crop_size
+                w = w - offset
+        if image_width > crop_size:
+            offset = (image_width - crop_size) // 2
+            if offset > x:
+                # Deal with BB coincide with left cropping boundary
+                w = w -(offset-x)
+                x = 0
+            else:
+                x = x - offset
+                
+                # Deal with BB coincide with right cropping boundary
+                if (x+w) > crop_size:
+                    offset = (x+w)-crop_size
+                    w = w - offset
+                    
+        if image_height > crop_size:
+
+            offset = (image_height - crop_size) // 2
+            if offset > y:
+                # Deal with BB coincide with top cropping boundary
+                h = h -(offset-y)
+                y = 0
+            else:
+                y = y - offset
+                # Deal with BB coincide with bottom cropping boundary
+                if (y+h) > crop_size:
+                    offset = (y+h)-crop_size
+                    h = h - offset
+        
+        bbox_aligned.append(x)
+        bbox_aligned.append(y)
+        bbox_aligned.append(w)
+        bbox_aligned.append(h)
+
+        if ((w <= 0) or (h <= 0)):
+            return None
+        else:
+            x_scale, y_scale = 1.0,1.0
+            return torch.mul(torch.tensor(bbox_aligned), torch.tensor([x_scale, y_scale, x_scale, y_scale]))
+    
+    def __round_floats(self,o):
+        '''
+        Used to round floats before writing to json file
+        '''
+        if isinstance(o, float):
+            return round(o, 2)
+        if isinstance(o, dict):
+            return {k: self.__round_floats(v) for k, v in o.items()}
+        if isinstance(o, (list, tuple)):
+            return [self.__round_floats(x) for x in o]
+        return o
+    
+    def createResizedAnnotJson(self,targetFileName,cropsize = 512):
+        '''
+        Resizes person annotations after center crop operation and saves as json file to the
+        directory of original annotations with the name "targetFileName"
+        '''
+        t1 = time.time()
+        # Get original json annot file path, and create pah for resized json annot file
+        path, annotfilename = os.path.split(self.annFilePath)
+        resizedAnnotPath = os.path.join(path,targetFileName)
+        
+        print('')
+        print(f'Creating Json file for resized annotations: {resizedAnnotPath}')
+        
+
+        # Load original annotation json file as dictionary and assign it to resized annot dict
+        with open(self.annFilePath) as json_file:
+            resizedanotDict = json.load(json_file)
+
+        # Original annotations array
+        origannList = resizedanotDict['annotations']
+        
+        # Check if center crop applied
+        centerCropped = False
+        if self.transforms is not None:
+            # If center crop applied, transform BBs as well
+            for t in self.transforms.transform.transforms:
+                if (type(t) == torchvision.transforms.transforms.CenterCrop):
+                    centerCropped = True
+        
+        resizedannList = []
+        for resizedannot in origannList:
+
+            currentcatID = resizedannot['category_id']
+            currentBB = resizedannot['bbox']
+            currentImgID = resizedannot['image_id']
+            
+            
+            # Get crop size and original image sizes
+            image_width = self.coco.loadImgs(currentImgID)[0]['width']
+            image_height = self.coco.loadImgs(currentImgID)[0]['height']
+            
+            # If presclae applied to image, calculate new image width and height
+            scale = self._calcPrescale(image_width=image_width, image_height=image_height)
+            image_width = image_width / scale
+            image_height = image_height / scale
+
+            if currentcatID == self.catPersonId:
+                # if BB is person
+                bbox = resizedannot['bbox'].copy()
+                
+                # If prescale appied to image, resize annotations BBs
+                bbox = self._prescaleBB(bbox, scale)
+                
+                # If center crop  applied, crop/recalculate BBs as well
+                if centerCropped:
+                    croppedBB = self.cropBBox(bbox, cropsize,image_height,image_width)    
+                else:
+                    croppedBB = torch.tensor(bbox) 
+                
+                if (croppedBB != None):
+                    # If BB is person and valid after crop, add it to resized annotations list
+                    croppedBB = croppedBB.tolist()
+                    resizedannot['bbox'] = self.__round_floats(croppedBB)
+                    resizedannot['area'] = self.__round_floats(croppedBB[2]*croppedBB[3])
+                    resizedannList.append(resizedannot)
+            else:
+                # If BB is non-person add it to resized annotations list as it is
+                resizedannList.append(resizedannot)   
+
+        resizedanotDict['annotations'] = resizedannList
+        print('Saving resized annotations to json file...')
+
+        # Save resized annotations in json file
+        resizedanotDict = json.dumps(resizedanotDict)
+        with open(resizedAnnotPath, 'w') as outfile:
+            outfile.write(resizedanotDict)
+
+        print(f'{resizedAnnotPath} saved.')
+        t2 = time.time()
+        print(f'Elapsed time: {t2-t1} seconds')
+        
+# Taken from : https://github.com/hasanirtiza/Pedestron/blob/master/tools/convert_datasets/pycococreatortools.py
+def create_image_info(image_id, file_name, image_size,
+                      date_captured=datetime.datetime.utcnow().isoformat(' '),
+                      license_id=1, coco_url="", flickr_url=""):
+
+    image_info = {
+            "id": image_id,
+            "file_name": file_name,
+            "width": image_size[0],
+            "height": image_size[1],
+            "date_captured": date_captured,
+            "license": license_id,
+            "coco_url": coco_url,
+            "flickr_url": flickr_url
+    }
+
+    return image_info
+
+# Taken from : https://github.com/hasanirtiza/Pedestron/blob/master/tools/convert_datasets/pycococreatortools.py
+def create_annotation_info(annotation_id, image_id, category_info, bounding_box):
+    is_crowd = category_info['is_crowd']
+
+    annotation_info = {
+        "id": annotation_id,
+        "image_id": image_id,
+        "category_id": category_info["id"],
+        "iscrowd": is_crowd,
+        "bbox": bounding_box
+    }
+
+    return annotation_info
+
+def convWidertoCOCO(annotFile, orgImageDir):
+    '''
+    Converts wider dataset annotations to COCO format. 
+    Args: 
+        annotFile: Original annotation file
+        orgImageDir: Original Images directory
+    '''
+
+    totalImgnum = 0
+    imgID = 0
+    annID = 0
+
+    imgList = []
+    annList = []
+
+    category_info= {}
+    category_info['is_crowd'] = False
+    category_info['id'] = 1
+
+    data ={}
+
+    data['info'] = {'description': 'Example Dataset', 'url': '', 'version': '0.1.0', 'year': 2022, 'contributor': 'ljp', 'date_created': '2019-07-18 06:56:33.567522'}
+    data['categories'] = [{'id': 1, 'name': 'person', 'supercategory': 'person'}]
+    data['licences'] = [{'id': 1, 'name': 'Attribution-NonCommercial-ShareAlike License', 'url': 'http://creativecommons.org/licenses/by-nc-sa/2.0/'}]
+
+    with open(annotFile) as f:
+        for _, annot_raw in enumerate(tqdm(f)):
+            imgID += 1
+
+            annot_raw = annot_raw.split()
+            imgName = annot_raw[:1][0]
+
+            totalImgnum +=1 
+            imageFullPath = os.path.join(orgImageDir,imgName)
+            try:
+                curImg = Image.open(imageFullPath)
+                image_size = curImg.size
+
+                BBs_str = annot_raw[1:]
+                bb_raw = [int(bb) for bb in BBs_str]
+
+                imgInf = create_image_info(image_id = imgID, file_name = imgName, image_size =image_size,
+                      date_captured=datetime.datetime.utcnow().isoformat(' '),
+                      license_id=1, coco_url="", flickr_url="")
+                imgList.append(imgInf)
+
+                bb = []
+                for i, p in enumerate(bb_raw):
+
+                    bb.append(p)
+                    if ((i+1)%4 == 0):
+                        annID += 1
+                        ann = create_annotation_info(annID, imgID, category_info = category_info, bounding_box = bb)
+                        annList.append(ann)
+                        bb = []
+
+            except:
+                print(f'Cannot create annot for {imgName}, image does not exist in given directory.')
+
+    data['annotations'] = annList
+    data['images'] = imgList
+    
+    
+    cur_dir = os.getcwd()
+    processed_annot_path = os.path.join(cur_dir,'datasets','wider','annotations')
+    
+    if not os.path.isdir(processed_annot_path):
+        os.makedirs(processed_annot_path)
+    
+    orgCOCOAnnotFile = os.path.join( processed_annot_path ,'orig_annot.json')
+
+    with open(orgCOCOAnnotFile, 'w') as fp:
+        json.dump(data, fp)
+    
+    
+    print('Annotations saved as: ' + orgCOCOAnnotFile)
+    print(f'Created {annID} COCO annotations for total {totalImgnum} images')
+    print('')
+    return orgCOCOAnnotFile
+
+
+def main():
+    parser = argparse.ArgumentParser(description='This script converts original Wider Person'
+                                                     'Validation Dataset images to 512 x 512'
+                                                     'Then resisez the annotations accordingly, saves new images and annotations under datasets folder')
+    parser.add_argument('-ip', '--wider_images_path', type=str, required = True,
+                        help='path of the folder containing original images')
+    parser.add_argument('-af', '--wider_annotfile', type=str, required = True,
+                        help='full path of original annotations file e.g. ./some/path/some_annot.json')
+
+
+    args = parser.parse_args()
+    wider_images_path = args.wider_images_path
+    wider_annotfile = args.wider_annotfile
+
+    # Prepare images
+    print('')
+    print('Prescaling and Center-cropping original images to 512 x 512')
+    preProcessImages(wider_images_path)
+    print('\n'*2)
+
+    # Convert original wider annotations in to COCO format
+    print('Converting original annotations to COCO format')
+    orgCOCOAnnotFile = convWidertoCOCO(wider_annotfile, wider_images_path)
+    print('\n'*2)
+
+    # Prescale/Center-crop annotations and save
+    print('Prescaling/Center-cropping original annotations in COCO format')
+    transform = transforms.Compose([transforms.CenterCrop(512), transforms.ToTensor()])
+    dataset = CocoDetection(root=wider_images_path, annFile=orgCOCOAnnotFile, transform=transform,scaleImgforCrop= 512)
+    targetFileName = 'instances_val.json'
+    dataset.createResizedAnnotJson(targetFileName=targetFileName)
+    os.remove(orgCOCOAnnotFile)
+
+if __name__ == '__main__':
+    main()

experiments/shallow800_mnv2ssdlite_8b_retrain_wider_optimizedAnchors_annealedlr_0_95/fpt_experiment.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13b1b6622d7a390468d66c9629e562cf1f3dba0bf2d582aee64f5fc8c44eb20f
+size 7807691

experiments/shallow800_mnv2ssdlite_8b_retrain_wider_optimizedAnchors_annealedlr_0_95/hardware_experiment.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4712fd8026f221b6a40f464438821858389a7a9d021da6c4f2ddb881d7a695e
+size 7481103

experiments/shallow800_mnv2ssdlite_8b_retrain_wider_optimizedAnchors_annealedlr_0_95/training_experiment.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79dbbd0f1849c213da61f71985dce57a88b7cd03881cd093a44b3daab61902f4
+size 7480143

experiments/shallow830_mnv2ssdlite_2b8b_wider_somelayers_excluded_annealedlr_0_95/fpt_experiment.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b6629e998ec6a9a6482aeaa386370e25b26b3fae0206d7073401581dbae708a9
+size 5433449

experiments/shallow830_mnv2ssdlite_2b8b_wider_somelayers_excluded_annealedlr_0_95/hardware_experiment.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5eb91a81fcd0442b75e893822ffa7602eddbe9a7002b8c8062522d87986720e5
+size 5203607

experiments/shallow830_mnv2ssdlite_2b8b_wider_somelayers_excluded_annealedlr_0_95/modified_model.py

@@ -0,0 +1,147 @@
+###########################################################################
+# Computer vision - Embedded person tracking demo software by HyperbeeAI. #
+# Copyrights © 2023 Hyperbee.AI Inc. All rights reserved. main@shallow.ai #
+###########################################################################
+import torch.nn as nn
+import qat_core.layers as layers
+
+class mnv2_SSDlite(nn.Module):
+    def __init__(self, in_channels=3, n_classes=1):
+        super(mnv2_SSDlite, self).__init__()
+
+        self.conv1 = layers.conv(C_in_channels=in_channels, D_out_channels=32, K_kernel_dimension=3, stride=2, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv2 = layers.conv(C_in_channels=32,    D_out_channels=32,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv2  = layers.conv(C_in_channels=32,    D_out_channels=32,   K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=32, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv2 = layers.conv(C_in_channels=32,    D_out_channels=16,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv3 = layers.conv(C_in_channels=16,    D_out_channels=96,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv3  = layers.conv(C_in_channels=96,    D_out_channels=96,   K_kernel_dimension=3, stride=2, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=96, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv3 = layers.conv(C_in_channels=96,    D_out_channels=24,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+        self.epw_conv4 = layers.conv(C_in_channels=24,    D_out_channels=144,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv4  = layers.conv(C_in_channels=144,   D_out_channels=144,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=144, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv4 = layers.conv(C_in_channels=144,   D_out_channels=24,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv5 = layers.conv(C_in_channels=24,    D_out_channels=144,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv5  = layers.conv(C_in_channels=144,   D_out_channels=144,  K_kernel_dimension=3, stride=2, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=144, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv5 = layers.conv(C_in_channels=144,   D_out_channels=32,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv7 = layers.conv(C_in_channels=32,    D_out_channels=192,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv7  = layers.conv(C_in_channels=192,   D_out_channels=192,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=192, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv7 = layers.conv(C_in_channels=192,   D_out_channels=32,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv8  = layers.conv(C_in_channels=32,   D_out_channels=192,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv8   = layers.conv(C_in_channels=192,  D_out_channels=192,  K_kernel_dimension=3, stride=2, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=192, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv8  = layers.conv(C_in_channels=192,  D_out_channels=64,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv11 = layers.conv(C_in_channels=64,   D_out_channels=384,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv11  = layers.conv(C_in_channels=384,  D_out_channels=384,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=384, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv11 = layers.conv(C_in_channels=384,  D_out_channels=64,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+        
+        self.epw_conv12  = layers.conv(C_in_channels=64,  D_out_channels=384,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv12   = layers.conv(C_in_channels=384, D_out_channels=384,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=384, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv12  = layers.conv(C_in_channels=384, D_out_channels=96,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv14  = layers.conv(C_in_channels=96,  D_out_channels=576,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv14   = layers.conv(C_in_channels=576, D_out_channels=576,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=576, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv14  = layers.conv(C_in_channels=576, D_out_channels=96,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained') #ilk çıkış: torch.Size([2, 96, /16, /16])
+
+        self.epw_conv15  = layers.conv(C_in_channels=96,  D_out_channels=576,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv15   = layers.conv(C_in_channels=576, D_out_channels=576,  K_kernel_dimension=3, stride=2, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=576, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv15  = layers.conv(C_in_channels=576, D_out_channels=160,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv17  = layers.conv(C_in_channels=160, D_out_channels=960,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv17   = layers.conv(C_in_channels=960, D_out_channels=960,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=960, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv17  = layers.conv(C_in_channels=960, D_out_channels=160,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained')
+
+        self.epw_conv18  = layers.conv(C_in_channels=160, D_out_channels=960,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', quantization_mode = 'fpt_unconstrained')
+        self.dw_conv18   = layers.conv(C_in_channels=960, D_out_channels=960,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, bias=False, activation='relu', num_groups=960, quantization_mode = 'fpt_unconstrained')
+        self.ppw_conv18  = layers.conv(C_in_channels=960, D_out_channels=320,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), batchnorm=True, batchnorm_affine=True, bias=False, quantization_mode = 'fpt_unconstrained') #ikinci çıkış: torch.Size([2, 320, /32, /32])
+
+        self.head1_dw_classification = layers.conv(C_in_channels=96,  D_out_channels=96,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, activation='relu', num_groups=96, quantization_mode = 'fpt_unconstrained')
+        self.head1_pw_classification = layers.conv(C_in_channels=96,  D_out_channels=8,   K_kernel_dimension=1, stride=1, padding=(0,0,0,0), output_width_30b = True, quantization_mode = 'fpt_unconstrained')
+        self.head1_dw_regression     = layers.conv(C_in_channels=96,  D_out_channels=96,  K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, activation='relu', num_groups=96, quantization_mode = 'fpt_unconstrained')
+        self.head1_pw_regression     = layers.conv(C_in_channels=96,  D_out_channels=16,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), output_width_30b = True, quantization_mode = 'fpt_unconstrained')
+
+        self.head2_dw_classification = layers.conv(C_in_channels=320, D_out_channels=320, K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, activation='relu', num_groups=320, quantization_mode = 'fpt_unconstrained')
+        self.head2_pw_classification = layers.conv(C_in_channels=320, D_out_channels=10,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), output_width_30b = True, quantization_mode = 'fpt_unconstrained')
+        self.head2_dw_regression     = layers.conv(C_in_channels=320, D_out_channels=320, K_kernel_dimension=3, stride=1, padding=(1,1,1,1), batchnorm=True, batchnorm_affine=True, activation='relu', num_groups=320, quantization_mode = 'fpt_unconstrained')
+        self.head2_pw_regression     = layers.conv(C_in_channels=320, D_out_channels=20,  K_kernel_dimension=1, stride=1, padding=(0,0,0,0), output_width_30b = True, quantization_mode = 'fpt_unconstrained')
+        
+        self.add_residual            = layers.add_residual(quantization_mode = 'fpt_unconstrained')
+
+
+    def forward(self, x):
+        x = self.conv1(x)
+
+        x = self.epw_conv2(x)
+        x = self.dw_conv2(x)
+        x = self.ppw_conv2(x)
+
+        x = self.epw_conv3(x)
+        x = self.dw_conv3(x)
+        x = self.ppw_conv3(x)
+        res4 = x
+        x = self.epw_conv4(x)
+        x = self.dw_conv4(x)
+        x = self.ppw_conv4(x)
+        x = self.add_residual(x,res4)
+
+        x = self.epw_conv5(x)
+        x = self.dw_conv5(x)
+        x = self.ppw_conv5(x)
+
+        res7 = x
+        x = self.epw_conv7(x)
+        x = self.dw_conv7(x)
+        x = self.ppw_conv7(x)
+        x = self.add_residual(x,res7)
+
+        x = self.epw_conv8(x)
+        x = self.dw_conv8(x)
+        x = self.ppw_conv8(x)
+
+        res11 = x
+        x = self.epw_conv11(x)
+        x = self.dw_conv11(x)
+        x = self.ppw_conv11(x)
+        x = self.add_residual(x,res11)
+
+        x = self.epw_conv12(x)
+        x = self.dw_conv12(x)
+        x = self.ppw_conv12(x)
+
+        res14 = x
+        x = self.epw_conv14(x)
+        x = self.dw_conv14(x)
+        x = self.ppw_conv14(x)
+        x = self.add_residual(x,res14)
+        output1 = x
+
+        x = self.epw_conv15(x)
+        x = self.dw_conv15(x)
+        x = self.ppw_conv15(x)
+
+        res17 = x
+        x = self.epw_conv17(x)
+        x = self.dw_conv17(x)
+        x = self.ppw_conv17(x)
+        x = self.add_residual(x,res17)
+
+        x = self.epw_conv18(x)
+        x = self.dw_conv18(x)
+        x = self.ppw_conv18(x)
+        output2 = x
+
+        output1_class = self.head1_dw_classification(output1)
+        output1_class = self.head1_pw_classification(output1_class)
+        output1_reg   = self.head1_dw_regression(output1)
+        output1_reg   = self.head1_pw_regression(output1_reg)
+
+        output2_class = self.head2_dw_classification(output2)
+        output2_class = self.head2_pw_classification(output2_class)
+        output2_reg   = self.head2_dw_regression(output2)
+        output2_reg   = self.head2_pw_regression(output2_reg)
+
+        #print(f"Output1 Regression: {output1_reg.shape}, Output1 Classification: {output1_class.shape}\nOutput2 Regression: {output2_reg.shape}, Output2 Classification: {output2_class.shape}")
+        return (output1_reg, output1_class, output2_reg, output2_class)

experiments/shallow830_mnv2ssdlite_2b8b_wider_somelayers_excluded_annealedlr_0_95/training_experiment.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24f990cf40e986094eb4695dfd3b310ff358ffffaa50ff755a8ab71b5f3e9fde
+size 5202903