tests for pipeline added

Author: kprokofi

configs/default_config.py

@@ -1,28 +1,28 @@
 data = dict(
     root="./data",
     resize=(224,224),
-    train_batch_size=64,
+    train_batch_size=128,
     val_batch_size=32,
-    max_epochs=200,
-    num_workers=4,
+    max_epochs=1,
+    num_workers=6,
     category_list='all',
     normalization=dict(mean=[0.5931, 0.4690, 0.4229],
                        std=[0.2471, 0.2214, 0.2157])
 )
 
-model = dict(name='mobilenetv3_large', pretrained=True, num_classes=1, load_weights='')
+model = dict(name='mobilenetv3_large', pretrained=False, num_classes=9, load_weights='')
 
 data_parallel = dict(use_parallel=True,
                      parallel_params=dict(device_ids=[0], output_device=0))
 
 optim = dict(name='adam', lr=0.001, momentum=0.9, wd=1e-4, betas=(0.9, 0.999), rho=0.9, alpha=0.99, nesterov=True)
 
-scheduler = dict(name='exp', gamma=0.1, exp_gamma=0.975, steps=[50])
+scheduler = dict(name='cosine', gamma=0.1, exp_gamma=0.975, steps=[50])
 
-loss=dict(names=['mse', 'add_loss'], coeffs=([1., .1],[]), smoothl1_beta=0.2, alwa=dict(use=False, lam_cls=1., lam_reg=1., C=100, compute_std=True))
+loss=dict(names=['smoothl1',  'cross_entropy'], coeffs=([1.],[1.]), smoothl1_beta=0.2, alwa=dict(use=False, lam_cls=1., lam_reg=1., C=100, compute_std=True))
 
-utils=dict(debug_mode = False, random_seeds=5, save_freq=10, print_freq=20, debug_steps=20)
+output_dir = './output/log'
 
-output_dir = './output/exp_0'
+utils=dict(debug_mode = False, random_seeds=5, save_freq=10, print_freq=20, debug_steps=100)
 
 regime = dict(type='training', vis_only=False)

tests/test_pipeline.py

@@ -0,0 +1,58 @@
+import torch
+
+from torchdet3d.evaluation import (compute_average_distance, compute_metrics_per_cls,
+                                    compute_2d_based_iou, compute_accuracy)
+
+from torchdet3d.losses import WingLoss, ADD_loss, DiagLoss
+from torchdet3d.builders import (build_loss, build_optimizer, build_scheduler, build_loader,
+                                    build_model, AVAILABLE_LOSS, AVAILABLE_OPTIMS, AVAILABLE_SCHEDS)
+from torchdet3d.utils import read_py_config
+
+
+class TestCasesPipeline:
+    gt_kps = torch.rand(128,9,2)
+    test_kps = torch.rand(128,9,2, requires_grad=True)
+    gt_cats = torch.randint(0,9,(128,))
+    test_cats = torch.rand(128,9)
+    config = read_py_config("./configs/default_config.py")
+
+    def test_metrics(self):
+        ADD, SADD = compute_average_distance(self.test_kps, self.gt_kps)
+        metrics = compute_metrics_per_cls(self.test_kps, self.gt_kps, self.test_cats, self.gt_cats)
+        IOU = compute_2d_based_iou(self.test_kps, self.gt_kps)
+        acc = compute_accuracy(self.test_cats, self.gt_cats)
+        assert 0 <= ADD <= 1 and 0 <= SADD <= 1 and 0 <= IOU <= 1 and 0 <= acc <= 1
+        assert len(metrics) == 9 and len(metrics[0]) == 4
+
+    def test_losses(self):
+        for loss in [WingLoss(), ADD_loss(), DiagLoss()]:
+            input_ = torch.sigmoid(torch.randn(512, 9, 2, requires_grad=True))
+            target = torch.sigmoid(torch.randn(512, 9, 2))
+            output = loss(input_, target)
+            assert not torch.any(torch.isnan(output))
+            output.backward()
+
+    def test_builders(self):
+        for loss_ in AVAILABLE_LOSS:
+            if loss_ != 'cross_entropy':
+                self.config['loss']['names']=[loss_, 'cross_entropy']
+                self.config.loss.coeffs=([1.],[1.])
+                regress_criterions, class_criterions = build_loss(self.config)
+                assert len(regress_criterions) == 1 and len(class_criterions) == 1
+        model = build_model(self.config)
+        assert model is not None
+        for optim_ in AVAILABLE_OPTIMS:
+            self.config['optim']['name'] = optim_
+            optimizer = build_optimizer(self.config, model)
+            assert optimizer is not None
+            for schd in AVAILABLE_SCHEDS:
+                self.config['scheduler']['name'] = schd
+                scheduler = build_scheduler(self.config, optimizer)
+                assert scheduler is not None
+
+    def test_random_inference(self):
+        model = build_model(self.config)
+        image = torch.rand(128,3,224,224)
+        kp, cat = model(image, self.gt_cats)
+        assert kp.shape == (128,9,2)
+        assert cat.shape == (128,9)

torchdet3d/builders/__init__.py

@@ -1,5 +1,5 @@
-from .loss_builder import build_loss
-from .optim_builder import build_optimizer
-from .scheduler_builder import build_scheduler
+from .loss_builder import build_loss, AVAILABLE_LOSS
+from .optim_builder import build_optimizer, AVAILABLE_OPTIMS
+from .scheduler_builder import build_scheduler, AVAILABLE_SCHEDS
 from .loader_builder import build_loader, build_augmentations
 from .model_builder import build_model

torchdet3d/builders/loss_builder.py

@@ -1,15 +1,15 @@
 import torch
 from torchdet3d.losses import DiagLoss, ADD_loss, WingLoss
 
-__AVAILABLE_LOSS = ['smoothl1', 'cross_entropy', 'diag_loss', 'mse', 'add_loss', 'wing']
+AVAILABLE_LOSS = ['smoothl1', 'cross_entropy', 'diag_loss', 'mse', 'add_loss', 'wing']
 
 
 def build_loss(cfg):
     "build losses in right order"
     regress_criterions = []
     class_criterions = []
     for loss_name in cfg.loss.names:
-        assert loss_name in __AVAILABLE_LOSS
+        assert loss_name in AVAILABLE_LOSS
         if loss_name == 'cross_entropy':
             class_criterions.append(torch.nn.CrossEntropyLoss())
         elif loss_name == 'smoothl1':

torchdet3d/builders/optim_builder.py

@@ -1,9 +1,9 @@
 import torch
 
-__AVAILABLE_OPTIMS = ['sgd', 'rmsprop', 'adam', 'adadelta']
+AVAILABLE_OPTIMS = ['sgd', 'rmsprop', 'adam', 'adadelta']
 
 def build_optimizer(cfg, net):
-    assert cfg.optim.name in __AVAILABLE_OPTIMS
+    assert cfg.optim.name in AVAILABLE_OPTIMS
     if cfg.optim.name == 'adadelta':
         optim = torch.optim.Adadelta(net.parameters(), lr=cfg.optim.lr, rho=cfg.optim.rho,
                                      weight_decay=cfg.optim.wd)

torchdet3d/builders/scheduler_builder.py

@@ -1,12 +1,12 @@
 import torch
 
-__AVAILABLE_SCHEDS = ['cosine', 'exp', 'stepLR', 'multistepLR']
+AVAILABLE_SCHEDS = ['cosine', 'exp', 'stepLR', 'multistepLR']
 
 def build_scheduler(cfg, optimizer):
     if cfg.scheduler.name is None:
         return None
 
-    assert cfg.scheduler.name in __AVAILABLE_SCHEDS
+    assert cfg.scheduler.name in AVAILABLE_SCHEDS
     if cfg.scheduler.name == 'cosine':
         sched = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer,
                                                            T_max=cfg.data.max_epochs,

torchdet3d/evaluation/evaluate.py

@@ -100,7 +100,7 @@ def val(self, epoch=None):
             IOU = compute_2d_based_iou(pred_kp, gt_kp)
             acc = compute_accuracy(pred_cats, gt_cats)
 
-            for cl, ADD_cls, SADD_cls, acc_cls in compute_metrics_per_cls(pred_kp, gt_kp, gt_cats, pred_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))

torchdet3d/evaluation/metrics.py

@@ -7,36 +7,34 @@
 
 from torchdet3d.utils import lift_2d
 
-
+@torch.no_grad()
 def compute_average_distance(pred_kp, gt_kp, num_keypoint=9, **kwargs):
     """Computes Average Distance (ADD) metric."""
-    detached_pred_kp = pred_kp.detach()
-    detached_gt_kp = gt_kp.detach()
     add_distance = 0.
     # compute
-    add_distance = torch.mean(torch.linalg.norm(detached_pred_kp - detached_gt_kp, dim=2))
+    add_distance = torch.mean(torch.linalg.norm(pred_kp - gt_kp, dim=2))
 
     # Computes the symmetric version of the average distance metric.
-    add_sym_distance = torch.zeros((detached_pred_kp.shape[0])).to(detached_pred_kp.device)
+    add_sym_distance = torch.zeros((pred_kp.shape[0])).to(pred_kp.device)
     for i in range(num_keypoint):
         # Find nearest vertex in gt_kp
-        distance = torch.linalg.norm(detached_pred_kp[:, i, :] - detached_gt_kp[:, i, :], dim=1)
+        distance = torch.linalg.norm(pred_kp[:, i, :] - gt_kp[:, i, :], dim=1)
         for j in range(num_keypoint):
-            d = torch.linalg.norm(detached_pred_kp[:, i, :] - detached_gt_kp[:, j, :], dim=1)
+            d = torch.linalg.norm(pred_kp[:, i, :] - gt_kp[:, j, :], dim=1)
             distance = torch.where(d < distance, d, distance)
         add_sym_distance += distance
 
     # average by num keypoints, then mean by batch
     add_sym_distance = torch.mean(add_sym_distance / num_keypoint)
     return add_distance.item(), add_sym_distance.item()
 
+@torch.no_grad()
 def compute_accuracy(pred_cats, gt_cats, **kwargs):
-    detached_pred_cats = pred_cats.detach()
-    detached_gt_cats = gt_cats.detach() if isinstance(gt_cats, torch.Tensor) else gt_cats
-    detached_pred_cats = torch.argmax(detached_pred_cats, dim=1)
-    return torch.mean((detached_pred_cats == detached_gt_cats).float()).item()
+    pred_cats = torch.argmax(pred_cats, dim=1)
+    return torch.mean((pred_cats == gt_cats).float()).item()
 
-def compute_metrics_per_cls(pred_kp, gt_kp, gt_cats, pred_cats, **kwargs):
+@torch.no_grad()
+def compute_metrics_per_cls(pred_kp, gt_kp, pred_cats, gt_cats, **kwargs):
     classes = torch.unique(gt_cats)
     computed_metrics = []
     for cl in classes:
@@ -50,6 +48,7 @@ def compute_metrics_per_cls(pred_kp, gt_kp, gt_cats, pred_cats, **kwargs):
 
     return computed_metrics
 
+@torch.no_grad()
 def compute_2d_based_iou(pred_kp: torch.Tensor, gt_kp: torch.Tensor):
     assert len(pred_kp.shape) == 3
     bs = pred_kp.shape[0]

torchdet3d/losses/regression_losses.py

@@ -113,15 +113,3 @@ def parse_losses(self, pred_kp, gt_kp,
                 print(f"classification coefficient changed : {self.lam_cls}")
 
         return self.lam_reg * sum(regress_loss) + self.lam_cls * sum(class_loss)
-
-def test():
-    import torch.nn.functional as F
-    for loss in [WingLoss()]:
-        input_ = F.sigmoid(torch.randn(3, 9, 2, requires_grad=True))
-        target = F.sigmoid(torch.randn(3, 9, 2))
-        output = loss(input_, target)
-        ic(output)
-        output.backward()
-
-if __name__ == '__main__':
-    test()