pylint fix

Author: kprokofi

.pylintrc

@@ -29,7 +29,7 @@ disable = arguments-differ,
 max-line-length = 120
 ignore-docstrings = yes
 ignored-modules = numpy,torch,cv2,openvino
-extension-pkg-whitelist = torch,cv2
+extension-pkg-whitelist = torch,cv2,scipy
 
 [SIMILARITIES]
 ignore-imports = yes

demo/demo.py

@@ -1,10 +1,4 @@
 import argparse
-import inspect
-import os.path as osp
-from threading import Thread
-import queue
-import os
-import sys
 
 import cv2 as cv
 import glog as log

scripts/optuna_optim.py

@@ -5,20 +5,15 @@
 import time
 
 import torch
-from torchvision import datasets
-from torchvision import transforms
 import optuna
 from optuna.trial import TrialState
 from functools import partial
-from icecream import ic
 
 from torchdet3d.builders import (build_loader, build_model, build_loss,
                                     build_optimizer, build_scheduler)
-from torchdet3d.evaluation import Evaluator, compute_average_distance, compute_accuracy
+from torchdet3d.evaluation import compute_average_distance, compute_accuracy
 from torchdet3d.losses import LossManager
-from torchdet3d.trainer import Trainer
 from torchdet3d.utils import AverageMeter, read_py_config, Logger, set_random_seed
-import numpy as np
 
 def put_on_device(items, device):
     for i, item in enumerate(items):

torchdet3d/dataloaders/objectron_main.py

@@ -33,7 +33,8 @@ def __init__(self, root_folder, mode='train', transform=None, debug_mode=False,
 
         # filter categories
         if category_list != 'all':
-            self.annotations = list(filter(lambda x: OBJECTRON_CLASSES[x['category_id'] - 1] in category_list, self.ann['annotations']))
+            self.annotations = list(filter(lambda x: OBJECTRON_CLASSES[x['category_id'] - 1] in
+                                                category_list, self.ann['annotations']))
             images_id = {ann_obj['image_id'] for ann_obj in self.annotations}
             # create dict since ordering now different
             self.images = {img_obj['id']: img_obj
@@ -52,7 +53,7 @@ def __getitem__(self, indx):
         img_id = self.annotations[indx]['image_id']
         cat_id = int(self.annotations[indx]['category_id']) - 1
         # in case when classes are not equal to 9 choose closest
-        category = min([i for i in range(self.num_classes)], key=lambda x:abs(x-cat_id))
+        category = min(range(self.num_classes), key=lambda x:abs(x-cat_id))
         # get raw key points for bb from annotations
         img_path = self.root_folder + '/' + (self.images[img_id]['file_name'])
         # read image
@@ -162,10 +163,14 @@ def dataset_test(root, mode='val', transform=None, batch_size=5):
     def cat_filter_test(root, mode='val', transform=None, category_list=['book']):
         ds = Objectron(root, mode=mode, transform=transform, category_list=category_list)
         dataloader = DataLoader(ds, batch_size=128, shuffle=True)
-        for  _, _, category in dataloader:
-            for cat in category:
-                assert OBJECTRON_CLASSES[cat] in category_list
-
+        ic(len(dataloader))
+        def in_func(cat):
+            assert OBJECTRON_CLASSES[cat] in category_list
+        for i, (_, _, category) in enumerate(dataloader):
+            ic(i)
+            if i == len(dataloader) // 10:
+                break
+            map(in_func, category)
 
     root = './data'
     normalization = A.augmentations.transforms.Normalize(**dict(mean=[0.5931, 0.4690, 0.4229],
@@ -183,7 +188,7 @@ def cat_filter_test(root, mode='val', transform=None, category_list=['book']):
         super_vision_test(root, mode='val', transform=transform, index=index)
     dataset_test(root, mode='val', transform=transform, batch_size=256)
     dataset_test(root, mode='train', transform=transform, batch_size=256)
-    # cat_filter_test(root, mode='val', transform=transform, category_list=['shoe', 'camera', 'bottle', 'bike'])
+    cat_filter_test(root, mode='val', transform=transform, category_list=['shoe', 'camera', 'bottle', 'bike'])
 
 if __name__ == '__main__':
     test()

torchdet3d/evaluation/evaluate.py

@@ -84,7 +84,7 @@ def val(self, epoch=None):
         IOU_meter = AverageMeter()
         ADD_cls_meter = [AverageMeter() for cl in range(self.num_classes)]
         SADD_cls_meter = [AverageMeter() for cl in range(self.num_classes)]
-        acc_cls_meter = [AverageMeter() for cl in range(self.num_classes)]
+        ACC_cls_meter = [AverageMeter() for cl in range(self.num_classes)]
         IOU__cls_meter = [AverageMeter() for cl in range(self.num_classes)]
 
         # switch to eval mode
@@ -98,23 +98,24 @@ def val(self, epoch=None):
             # measure metrics
             ADD, SADD = compute_average_distance(pred_kp, gt_kp)
             IOU = compute_2d_based_iou(pred_kp, gt_kp)
-            acc = compute_accuracy(pred_cats, gt_cats)
+            ACC = compute_accuracy(pred_cats, gt_cats)
 
-            for cl, ADD_cls, SADD_cls, acc_cls in compute_metrics_per_cls(pred_kp, gt_kp, pred_cats, gt_cats):
+            for cl, ADD_cls, SADD_cls, ACC_cls in compute_metrics_per_cls(pred_kp, gt_kp, pred_cats, gt_cats):
                 ADD_cls_meter[cl].update(ADD_cls, imgs.size(0))
                 SADD_cls_meter[cl].update(SADD_cls, imgs.size(0))
-                acc_cls_meter[cl].update(acc_cls, imgs.size(0))
+                ACC_cls_meter[cl].update(ACC_cls, imgs.size(0))
+                IOU__cls_meter[cl].update(IOU, imgs.size(0))
 
             # record loss
             ADD_meter.update(ADD, imgs.size(0))
             SADD_meter.update(SADD, imgs.size(0))
-            ACC_meter.update(acc, imgs.size(0))
+            ACC_meter.update(ACC, imgs.size(0))
             IOU_meter.update(IOU)
             if epoch is not None:
                 # update progress bar
                 loop.set_description(f'Val Epoch [{epoch}/{self.max_epoch}]')
                 loop.set_postfix(ADD=ADD, avr_ADD=ADD_meter.avg, SADD=SADD,
-                                    avr_SADD=SADD_meter.avg, acc=acc, acc_avg = ACC_meter.avg)
+                                    avr_SADD=SADD_meter.avg, acc=ACC, acc_avg = ACC_meter.avg)
 
             if self.debug and it == self.debug_steps:
                 break
@@ -125,16 +126,19 @@ def val(self, epoch=None):
             self.writer.add_scalar('Val/ADD', ADD_meter.avg, global_step=self.val_step)
             self.writer.add_scalar('Val/SADD', SADD_meter.avg, global_step=self.val_step)
             self.writer.add_scalar('Val/ACC', ACC_meter.avg, global_step=self.val_step)
+            self.writer.add_scalar('Val/IOU', IOU_meter.avg, global_step=self.val_step)
         for cls_ in range(self.num_classes):
             cl_str = OBJECTRON_CLASSES[cls_]
             if epoch is not None:
                 self.writer.add_scalar(f'Val/ADD_{cl_str}', ADD_cls_meter[cls_].avg, global_step=self.val_step)
                 self.writer.add_scalar(f'Val/SADD_{cl_str}', SADD_cls_meter[cls_].avg, global_step=self.val_step)
-                self.writer.add_scalar(f'Val/ACC_{cl_str}', acc_cls_meter[cls_].avg, global_step=self.val_step)
+                self.writer.add_scalar(f'Val/ACC_{cl_str}', ACC_cls_meter[cls_].avg, global_step=self.val_step)
+                self.writer.add_scalar(f'Val/IOU_{cl_str}', IOU__cls_meter[cls_].avg, global_step=self.val_step)
                 self.val_step += 1
             per_class_metr_message += (f"\n***{cl_str}***:\nADD: {ADD_cls_meter[cls_].avg}\n"
                                       f"SADD: {SADD_cls_meter[cls_].avg}\n"
-                                      f"accuracy: {acc_cls_meter[cls_].avg}\n")
+                                      f"IOU: {IOU__cls_meter[cls_].avg}\n"
+                                      f"accuracy: {ACC_cls_meter[cls_].avg}\n")
 
         ep_mess = f"epoch : {epoch}\n" if epoch is not None else ""
         print("\nComputed val metrics:\n"

torchdet3d/losses/regression_losses.py

@@ -101,7 +101,8 @@ def parse_losses(self, pred_kp, gt_kp,
             cls_std = torch.std(torch.stack(self.s_cls))
             reg_mean = torch.mean(torch.stack(self.s_reg))
             reg_std = torch.std(torch.stack(self.s_reg))
-            self.s_cls.clear(); self.s_reg.clear()
+            self.s_cls.clear()
+            self.s_reg.clear()
             if self.alwa_version == 'ver_1':
                 cls = cls_mean + cls_std
                 reg = reg_mean + reg_std

torchdet3d/trainer/train.py

@@ -3,7 +3,6 @@
 
 from tqdm import tqdm
 from dataclasses import dataclass
-import torch
 
 from torchdet3d.evaluation import compute_average_distance, compute_accuracy
 from torchdet3d.utils import AverageMeter, save_snap