dnt 0.2.4__py3-none-any.whl → 0.3.1.7__py3-none-any.whl

dnt/track/dsort/deep_sort/deep/train.py

@@ -1,189 +0,0 @@
-import argparse
-import os
-import time
-
-import numpy as np
-import matplotlib.pyplot as plt
-import torch
-import torch.backends.cudnn as cudnn
-import torchvision
-
-from model import Net
-
-parser = argparse.ArgumentParser(description="Train on market1501")
-parser.add_argument("--data-dir",default='data',type=str)
-parser.add_argument("--no-cuda",action="store_true")
-parser.add_argument("--gpu-id",default=0,type=int)
-parser.add_argument("--lr",default=0.1, type=float)
-parser.add_argument("--interval",'-i',default=20,type=int)
-parser.add_argument('--resume', '-r',action='store_true')
-args = parser.parse_args()
-
-# device
-device = "cuda:{}".format(args.gpu_id) if torch.cuda.is_available() and not args.no_cuda else "cpu"
-if torch.cuda.is_available() and not args.no_cuda:
-    cudnn.benchmark = True
-
-# data loading
-root = args.data_dir
-train_dir = os.path.join(root,"train")
-test_dir = os.path.join(root,"test")
-transform_train = torchvision.transforms.Compose([
-    torchvision.transforms.RandomCrop((128,64),padding=4),
-    torchvision.transforms.RandomHorizontalFlip(),
-    torchvision.transforms.ToTensor(),
-    torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
-])
-transform_test = torchvision.transforms.Compose([
-    torchvision.transforms.Resize((128,64)),
-    torchvision.transforms.ToTensor(),
-    torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
-])
-trainloader = torch.utils.data.DataLoader(
-    torchvision.datasets.ImageFolder(train_dir, transform=transform_train),
-    batch_size=64,shuffle=True
-)
-testloader = torch.utils.data.DataLoader(
-    torchvision.datasets.ImageFolder(test_dir, transform=transform_test),
-    batch_size=64,shuffle=True
-)
-num_classes = max(len(trainloader.dataset.classes), len(testloader.dataset.classes))
-
-# net definition
-start_epoch = 0
-net = Net(num_classes=num_classes)
-if args.resume:
-    assert os.path.isfile("./checkpoint/ckpt.t7"), "Error: no checkpoint file found!"
-    print('Loading from checkpoint/ckpt.t7')
-    checkpoint = torch.load("./checkpoint/ckpt.t7")
-    # import ipdb; ipdb.set_trace()
-    net_dict = checkpoint['net_dict']
-    net.load_state_dict(net_dict)
-    best_acc = checkpoint['acc']
-    start_epoch = checkpoint['epoch']
-net.to(device)
-
-# loss and optimizer
-criterion = torch.nn.CrossEntropyLoss()
-optimizer = torch.optim.SGD(net.parameters(), args.lr, momentum=0.9, weight_decay=5e-4)
-best_acc = 0.
-
-# train function for each epoch
-def train(epoch):
-    print("\nEpoch : %d"%(epoch+1))
-    net.train()
-    training_loss = 0.
-    train_loss = 0.
-    correct = 0
-    total = 0
-    interval = args.interval
-    start = time.time()
-    for idx, (inputs, labels) in enumerate(trainloader):
-        # forward
-        inputs,labels = inputs.to(device),labels.to(device)
-        outputs = net(inputs)
-        loss = criterion(outputs, labels)
-
-        # backward
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-
-        # accumurating
-        training_loss += loss.item()
-        train_loss += loss.item()
-        correct += outputs.max(dim=1)[1].eq(labels).sum().item()
-        total += labels.size(0)
-
-        # print 
-        if (idx+1)%interval == 0:
-            end = time.time()
-            print("[progress:{:.1f}%]time:{:.2f}s Loss:{:.5f} Correct:{}/{} Acc:{:.3f}%".format(
-                100.*(idx+1)/len(trainloader), end-start, training_loss/interval, correct, total, 100.*correct/total
-            ))
-            training_loss = 0.
-            start = time.time()
-    
-    return train_loss/len(trainloader), 1.- correct/total
-
-def test(epoch):
-    global best_acc
-    net.eval()
-    test_loss = 0.
-    correct = 0
-    total = 0
-    start = time.time()
-    with torch.no_grad():
-        for idx, (inputs, labels) in enumerate(testloader):
-            inputs, labels = inputs.to(device), labels.to(device)
-            outputs = net(inputs)
-            loss = criterion(outputs, labels)
-
-            test_loss += loss.item()
-            correct += outputs.max(dim=1)[1].eq(labels).sum().item()
-            total += labels.size(0)
-        
-        print("Testing ...")
-        end = time.time()
-        print("[progress:{:.1f}%]time:{:.2f}s Loss:{:.5f} Correct:{}/{} Acc:{:.3f}%".format(
-                100.*(idx+1)/len(testloader), end-start, test_loss/len(testloader), correct, total, 100.*correct/total
-            ))
-
-    # saving checkpoint
-    acc = 100.*correct/total
-    if acc > best_acc:
-        best_acc = acc
-        print("Saving parameters to checkpoint/ckpt.t7")
-        checkpoint = {
-            'net_dict':net.state_dict(),
-            'acc':acc,
-            'epoch':epoch,
-        }
-        if not os.path.isdir('checkpoint'):
-            os.mkdir('checkpoint')
-        torch.save(checkpoint, './checkpoint/ckpt.t7')
-
-    return test_loss/len(testloader), 1.- correct/total
-
-# plot figure
-x_epoch = []
-record = {'train_loss':[], 'train_err':[], 'test_loss':[], 'test_err':[]}
-fig = plt.figure()
-ax0 = fig.add_subplot(121, title="loss")
-ax1 = fig.add_subplot(122, title="top1err")
-def draw_curve(epoch, train_loss, train_err, test_loss, test_err):
-    global record
-    record['train_loss'].append(train_loss)
-    record['train_err'].append(train_err)
-    record['test_loss'].append(test_loss)
-    record['test_err'].append(test_err)
-
-    x_epoch.append(epoch)
-    ax0.plot(x_epoch, record['train_loss'], 'bo-', label='train')
-    ax0.plot(x_epoch, record['test_loss'], 'ro-', label='val')
-    ax1.plot(x_epoch, record['train_err'], 'bo-', label='train')
-    ax1.plot(x_epoch, record['test_err'], 'ro-', label='val')
-    if epoch == 0:
-        ax0.legend()
-        ax1.legend()
-    fig.savefig("train.jpg")
-
-# lr decay
-def lr_decay():
-    global optimizer
-    for params in optimizer.param_groups:
-        params['lr'] *= 0.1
-        lr = params['lr']
-        print("Learning rate adjusted to {}".format(lr))
-
-def main():
-    for epoch in range(start_epoch, start_epoch+40):
-        train_loss, train_err = train(epoch)
-        test_loss, test_err = test(epoch)
-        draw_curve(epoch, train_loss, train_err, test_loss, test_err)
-        if (epoch+1)%20==0:
-            lr_decay()
-
-
-if __name__ == '__main__':
-    main()

dnt/track/dsort/utils/asserts.py

@@ -1,13 +0,0 @@
-from os import environ
-
-
-def assert_in(file, files_to_check):
-    if file not in files_to_check:
-        raise AssertionError("{} does not exist in the list".format(str(file)))
-    return True
-
-
-def assert_in_env(check_list: list):
-    for item in check_list:
-        assert_in(item, environ.keys())
-    return True

dnt/track/dsort/utils/draw.py

@@ -1,36 +0,0 @@
-import numpy as np
-import cv2
-
-palette = (2 ** 11 - 1, 2 ** 15 - 1, 2 ** 20 - 1)
-
-
-def compute_color_for_labels(label):
-    """
-    Simple function that adds fixed color depending on the class
-    """
-    color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]
-    return tuple(color)
-
-
-def draw_boxes(img, bbox, identities=None, offset=(0,0)):
-    for i,box in enumerate(bbox):
-        x1,y1,x2,y2 = [int(i) for i in box]
-        x1 += offset[0]
-        x2 += offset[0]
-        y1 += offset[1]
-        y2 += offset[1]
-        # box text and bar
-        id = int(identities[i]) if identities is not None else 0    
-        color = compute_color_for_labels(id)
-        label = '{}{:d}'.format("", id)
-        t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 2 , 2)[0]
-        cv2.rectangle(img,(x1, y1),(x2,y2),color,3)
-        cv2.rectangle(img,(x1, y1),(x1+t_size[0]+3,y1+t_size[1]+4), color,-1)
-        cv2.putText(img,label,(x1,y1+t_size[1]+4), cv2.FONT_HERSHEY_PLAIN, 2, [255,255,255], 2)
-    return img
-
-
-
-if __name__ == '__main__':
-    for i in range(82):
-        print(compute_color_for_labels(i))

dnt/track/dsort/utils/json_logger.py

@@ -1,383 +0,0 @@
-"""
-References:
-    https://medium.com/analytics-vidhya/creating-a-custom-logging-mechanism-for-real-time-object-detection-using-tdd-4ca2cfcd0a2f
-"""
-import json
-from os import makedirs
-from os.path import exists, join
-from datetime import datetime
-
-
-class JsonMeta(object):
-    HOURS = 3
-    MINUTES = 59
-    SECONDS = 59
-    PATH_TO_SAVE = 'LOGS'
-    DEFAULT_FILE_NAME = 'remaining'
-
-
-class BaseJsonLogger(object):
-    """
-    This is the base class that returns __dict__ of its own
-    it also returns the dicts of objects in the attributes that are list instances
-
-    """
-
-    def dic(self):
-        # returns dicts of objects
-        out = {}
-        for k, v in self.__dict__.items():
-            if hasattr(v, 'dic'):
-                out[k] = v.dic()
-            elif isinstance(v, list):
-                out[k] = self.list(v)
-            else:
-                out[k] = v
-        return out
-
-    @staticmethod
-    def list(values):
-        # applies the dic method on items in the list
-        return [v.dic() if hasattr(v, 'dic') else v for v in values]
-
-
-class Label(BaseJsonLogger):
-    """
-    For each bounding box there are various categories with confidences. Label class keeps track of that information.
-    """
-
-    def __init__(self, category: str, confidence: float):
-        self.category = category
-        self.confidence = confidence
-
-
-class Bbox(BaseJsonLogger):
-    """
-    This module stores the information for each frame and use them in JsonParser
-    Attributes:
-        labels (list): List of label module.
-        top (int):
-        left (int):
-        width (int):
-        height (int):
-
-    Args:
-        bbox_id (float):
-        top (int):
-        left (int):
-        width (int):
-        height (int):
-
-    References:
-        Check Label module for better understanding.
-
-
-    """
-
-    def __init__(self, bbox_id, top, left, width, height):
-        self.labels = []
-        self.bbox_id = bbox_id
-        self.top = top
-        self.left = left
-        self.width = width
-        self.height = height
-
-    def add_label(self, category, confidence):
-        # adds category and confidence only if top_k is not exceeded.
-        self.labels.append(Label(category, confidence))
-
-    def labels_full(self, value):
-        return len(self.labels) == value
-
-
-class Frame(BaseJsonLogger):
-    """
-    This module stores the information for each frame and use them in JsonParser
-    Attributes:
-        timestamp (float): The elapsed time of captured frame
-        frame_id (int): The frame number of the captured video
-        bboxes (list of Bbox objects): Stores the list of bbox objects.
-
-    References:
-        Check Bbox class for better information
-
-    Args:
-        timestamp (float):
-        frame_id (int):
-
-    """
-
-    def __init__(self, frame_id: int, timestamp: float = None):
-        self.frame_id = frame_id
-        self.timestamp = timestamp
-        self.bboxes = []
-
-    def add_bbox(self, bbox_id: int, top: int, left: int, width: int, height: int):
-        bboxes_ids = [bbox.bbox_id for bbox in self.bboxes]
-        if bbox_id not in bboxes_ids:
-            self.bboxes.append(Bbox(bbox_id, top, left, width, height))
-        else:
-            raise ValueError("Frame with id: {} already has a Bbox with id: {}".format(self.frame_id, bbox_id))
-
-    def add_label_to_bbox(self, bbox_id: int, category: str, confidence: float):
-        bboxes = {bbox.id: bbox for bbox in self.bboxes}
-        if bbox_id in bboxes.keys():
-            res = bboxes.get(bbox_id)
-            res.add_label(category, confidence)
-        else:
-            raise ValueError('the bbox with id: {} does not exists!'.format(bbox_id))
-
-
-class BboxToJsonLogger(BaseJsonLogger):
-    """
-    ُ This module is designed to automate the task of logging jsons. An example json is used
-    to show the contents of json file shortly
-    Example:
-          {
-          "video_details": {
-            "frame_width": 1920,
-            "frame_height": 1080,
-            "frame_rate": 20,
-            "video_name": "/home/gpu/codes/MSD/pedestrian_2/project/public/camera1.avi"
-          },
-          "frames": [
-            {
-              "frame_id": 329,
-              "timestamp": 3365.1254
-              "bboxes": [
-                {
-                  "labels": [
-                    {
-                      "category": "pedestrian",
-                      "confidence": 0.9
-                    }
-                  ],
-                  "bbox_id": 0,
-                  "top": 1257,
-                  "left": 138,
-                  "width": 68,
-                  "height": 109
-                }
-              ]
-            }],
-
-    Attributes:
-        frames (dict): It's a dictionary that maps each frame_id to json attributes.
-        video_details (dict): information about video file.
-        top_k_labels (int): shows the allowed number of labels
-        start_time (datetime object): we use it to automate the json output by time.
-
-    Args:
-        top_k_labels (int): shows the allowed number of labels
-
-    """
-
-    def __init__(self, top_k_labels: int = 1):
-        self.frames = {}
-        self.video_details = self.video_details = dict(frame_width=None, frame_height=None, frame_rate=None,
-                                                       video_name=None)
-        self.top_k_labels = top_k_labels
-        self.start_time = datetime.now()
-
-    def set_top_k(self, value):
-        self.top_k_labels = value
-
-    def frame_exists(self, frame_id: int) -> bool:
-        """
-        Args:
-            frame_id (int):
-
-        Returns:
-            bool: true if frame_id is recognized
-        """
-        return frame_id in self.frames.keys()
-
-    def add_frame(self, frame_id: int, timestamp: float = None) -> None:
-        """
-        Args:
-            frame_id (int):
-            timestamp (float): opencv captured frame time property
-
-        Raises:
-             ValueError: if frame_id would not exist in class frames attribute
-
-        Returns:
-            None
-
-        """
-        if not self.frame_exists(frame_id):
-            self.frames[frame_id] = Frame(frame_id, timestamp)
-        else:
-            raise ValueError("Frame id: {} already exists".format(frame_id))
-
-    def bbox_exists(self, frame_id: int, bbox_id: int) -> bool:
-        """
-        Args:
-            frame_id:
-            bbox_id:
-
-        Returns:
-            bool: if bbox exists in frame bboxes list
-        """
-        bboxes = []
-        if self.frame_exists(frame_id=frame_id):
-            bboxes = [bbox.bbox_id for bbox in self.frames[frame_id].bboxes]
-        return bbox_id in bboxes
-
-    def find_bbox(self, frame_id: int, bbox_id: int):
-        """
-
-        Args:
-            frame_id:
-            bbox_id:
-
-        Returns:
-            bbox_id (int):
-
-        Raises:
-            ValueError: if bbox_id does not exist in the bbox list of specific frame.
-        """
-        if not self.bbox_exists(frame_id, bbox_id):
-            raise ValueError("frame with id: {} does not contain bbox with id: {}".format(frame_id, bbox_id))
-        bboxes = {bbox.bbox_id: bbox for bbox in self.frames[frame_id].bboxes}
-        return bboxes.get(bbox_id)
-
-    def add_bbox_to_frame(self, frame_id: int, bbox_id: int, top: int, left: int, width: int, height: int) -> None:
-        """
-
-        Args:
-            frame_id (int):
-            bbox_id (int):
-            top (int):
-            left (int):
-            width (int):
-            height (int):
-
-        Returns:
-            None
-
-        Raises:
-            ValueError: if bbox_id already exist in frame information with frame_id
-            ValueError: if frame_id does not exist in frames attribute
-        """
-        if self.frame_exists(frame_id):
-            frame = self.frames[frame_id]
-            if not self.bbox_exists(frame_id, bbox_id):
-                frame.add_bbox(bbox_id, top, left, width, height)
-            else:
-                raise ValueError(
-                    "frame with frame_id: {} already contains the bbox with id: {} ".format(frame_id, bbox_id))
-        else:
-            raise ValueError("frame with frame_id: {} does not exist".format(frame_id))
-
-    def add_label_to_bbox(self, frame_id: int, bbox_id: int, category: str, confidence: float):
-        """
-        Args:
-            frame_id:
-            bbox_id:
-            category:
-            confidence: the confidence value returned from yolo detection
-
-        Returns:
-            None
-
-        Raises:
-            ValueError: if labels quota (top_k_labels) exceeds.
-        """
-        bbox = self.find_bbox(frame_id, bbox_id)
-        if not bbox.labels_full(self.top_k_labels):
-            bbox.add_label(category, confidence)
-        else:
-            raise ValueError("labels in frame_id: {}, bbox_id: {} is fulled".format(frame_id, bbox_id))
-
-    def add_video_details(self, frame_width: int = None, frame_height: int = None, frame_rate: int = None,
-                          video_name: str = None):
-        self.video_details['frame_width'] = frame_width
-        self.video_details['frame_height'] = frame_height
-        self.video_details['frame_rate'] = frame_rate
-        self.video_details['video_name'] = video_name
-
-    def output(self):
-        output = {'video_details': self.video_details}
-        result = list(self.frames.values())
-        output['frames'] = [item.dic() for item in result]
-        return output
-
-    def json_output(self, output_name):
-        """
-        Args:
-            output_name:
-
-        Returns:
-            None
-
-        Notes:
-            It creates the json output with `output_name` name.
-        """
-        if not output_name.endswith('.json'):
-            output_name += '.json'
-        with open(output_name, 'w') as file:
-            json.dump(self.output(), file)
-        file.close()
-
-    def set_start(self):
-        self.start_time = datetime.now()
-
-    def schedule_output_by_time(self, output_dir=JsonMeta.PATH_TO_SAVE, hours: int = 0, minutes: int = 0,
-                                seconds: int = 60) -> None:
-        """
-        Notes:
-            Creates folder and then periodically stores the jsons on that address.
-
-        Args:
-            output_dir (str): the directory where output files will be stored
-            hours (int):
-            minutes (int):
-            seconds (int):
-
-        Returns:
-            None
-
-        """
-        end = datetime.now()
-        interval = 0
-        interval += abs(min([hours, JsonMeta.HOURS]) * 3600)
-        interval += abs(min([minutes, JsonMeta.MINUTES]) * 60)
-        interval += abs(min([seconds, JsonMeta.SECONDS]))
-        diff = (end - self.start_time).seconds
-
-        if diff > interval:
-            output_name = self.start_time.strftime('%Y-%m-%d %H-%M-%S') + '.json'
-            if not exists(output_dir):
-                makedirs(output_dir)
-            output = join(output_dir, output_name)
-            self.json_output(output_name=output)
-            self.frames = {}
-            self.start_time = datetime.now()
-
-    def schedule_output_by_frames(self, frames_quota, frame_counter, output_dir=JsonMeta.PATH_TO_SAVE):
-        """
-        saves as the number of frames quota increases higher.
-        :param frames_quota:
-        :param frame_counter:
-        :param output_dir:
-        :return:
-        """
-        pass
-
-    def flush(self, output_dir):
-        """
-        Notes:
-            We use this function to output jsons whenever possible.
-            like the time that we exit the while loop of opencv.
-
-        Args:
-            output_dir:
-
-        Returns:
-            None
-
-        """
-        filename = self.start_time.strftime('%Y-%m-%d %H-%M-%S') + '-remaining.json'
-        output = join(output_dir, filename)
-        self.json_output(output_name=output)

dnt/track/dsort/utils/log.py

@@ -1,17 +0,0 @@
-import logging
-
-
-def get_logger(name='root'):
-    formatter = logging.Formatter(
-        # fmt='%(asctime)s [%(levelname)s]: %(filename)s(%(funcName)s:%(lineno)s) >> %(message)s')
-        fmt='%(asctime)s [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-
-    handler = logging.StreamHandler()
-    handler.setFormatter(formatter)
-
-    logger = logging.getLogger(name)
-    logger.setLevel(logging.INFO)
-    logger.addHandler(handler)
-    return logger
-
-

dnt/track/dsort/utils/parser.py

@@ -1,35 +0,0 @@
-import os
-import yaml
-from easydict import EasyDict as edict
-
-class YamlParser(edict):
-    """
-    This is yaml parser based on EasyDict.
-    """
-    def __init__(self, cfg_dict=None, config_file=None):
-        if cfg_dict is None:
-            cfg_dict = {}
-
-        if config_file is not None:
-            assert(os.path.isfile(config_file))
-            with open(config_file, 'r') as fo:
-                cfg_dict.update(yaml.safe_load(fo.read()))
-
-        super(YamlParser, self).__init__(cfg_dict)
-
-    
-    def merge_from_file(self, config_file):
-        with open(config_file, 'r') as fo:
-            self.update(yaml.safe_load(fo.read()))
-
-    
-    def merge_from_dict(self, config_dict):
-        self.update(config_dict)
-
-
-def get_config(config_file=None):
-    return YamlParser(config_file=config_file)
-
-
-if __name__ == "__main__":
-    pass