Trainer refactoring

delira/models/abstract_network.py

@@ -52,7 +52,7 @@ def __call__(self, *args, **kwargs):
 
     @staticmethod
     @abc.abstractmethod
-    def closure(model, data_dict: dict, optimizers: dict, criterions={},
+    def closure(model, data_dict: dict, optimizers: dict, losses={},
                 metrics={}, fold=0, **kwargs):
         """
         Function which handles prediction from batch, logging, loss calculation
@@ -65,8 +65,8 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
             dictionary containing the data
         optimizers : dict
             dictionary containing all optimizers to perform parameter update
-        criterions : dict
-            Functions or classes to calculate criterions
+        losses : dict
+            Functions or classes to calculate losses
         metrics : dict
             Functions or classes to calculate other metrics
         fold : int
@@ -79,7 +79,7 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
         dict
             Metric values (with same keys as input dict metrics)
         dict
-            Loss values (with same keys as input dict criterions)
+            Loss values (with same keys as input dict losses)
         list
             Arbitrary number of predictions
 

delira/models/classification/classification_network.py

@@ -63,7 +63,7 @@ def forward(self, input_batch: torch.Tensor):
 
         @staticmethod
         def closure(model: AbstractPyTorchNetwork, data_dict: dict,
-                    optimizers: dict, criterions={}, metrics={},
+                    optimizers: dict, losses={}, metrics={},
                     fold=0, **kwargs):
             """
             closure method to do a single backpropagation step
@@ -77,9 +77,9 @@ def closure(model: AbstractPyTorchNetwork, data_dict: dict,
                 dictionary containing the data
             optimizers : dict
                 dictionary of optimizers to optimize model's parameters
-            criterions : dict
-                dict holding the criterions to calculate errors
-                (gradients from different criterions will be accumulated)
+            losses : dict
+                dict holding the losses to calculate errors
+                (gradients from different losses will be accumulated)
             metrics : dict
                 dict holding the metrics to calculate
             fold : int
@@ -92,19 +92,19 @@ def closure(model: AbstractPyTorchNetwork, data_dict: dict,
             dict
                 Metric values (with same keys as input dict metrics)
             dict
-                Loss values (with same keys as input dict criterions)
+                Loss values (with same keys as input dict losses)
             list
                 Arbitrary number of predictions as torch.Tensor
 
             Raises
             ------
             AssertionError
-                if optimizers or criterions are empty or the optimizers are not
+                if optimizers or losses are empty or the optimizers are not
                 specified
 
             """
 
-            assert (optimizers and criterions) or not optimizers, \
+            assert (optimizers and losses) or not optimizers, \
                 "Criterion dict cannot be emtpy, if optimizers are passed"
 
             loss_vals = {}
@@ -125,7 +125,7 @@ def closure(model: AbstractPyTorchNetwork, data_dict: dict,
 
                 if data_dict:
 
-                    for key, crit_fn in criterions.items():
+                    for key, crit_fn in losses.items():
                         _loss_val = crit_fn(preds, *data_dict.values())
                         loss_vals[key] = _loss_val.detach()
                         total_loss += _loss_val

delira/models/gan/generative_adversarial_network.py

@@ -89,7 +89,7 @@ def forward(self, real_image_batch):
 
         @staticmethod
         def closure(model, data_dict: dict,
-                    optimizers: dict, criterions={}, metrics={},
+                    optimizers: dict, losses={}, metrics={},
                     fold=0, **kwargs):
             """
             closure method to do a single backpropagation step
@@ -102,9 +102,9 @@ def closure(model, data_dict: dict,
                 dictionary containing data
             optimizers : dict
                 dictionary of optimizers to optimize model's parameters
-            criterions : dict
-                dict holding the criterions to calculate errors
-                (gradients from different criterions will be accumulated)
+            losses : dict
+                dict holding the losses to calculate errors
+                (gradients from different losses will be accumulated)
             metrics : dict
                 dict holding the metrics to calculate
             fold : int
@@ -117,14 +117,14 @@ def closure(model, data_dict: dict,
             dict
                 Metric values (with same keys as input dict metrics)
             dict
-                Loss values (with same keys as input dict criterions)
+                Loss values (with same keys as input dict losses)
             list
                 Arbitrary number of predictions as torch.Tensor
 
             Raises
             ------
             AssertionError
-                if optimizers or criterions are empty or the optimizers are not
+                if optimizers or losses are empty or the optimizers are not
                 specified
 
             """
@@ -149,14 +149,14 @@ def closure(model, data_dict: dict,
                 fake_image_batch, discr_pred_fake, discr_pred_real = model(batch)
 
                 # train discr with prediction from real image
-                for key, crit_fn in criterions.items():
+                for key, crit_fn in losses.items():
                     _loss_val = crit_fn(discr_pred_real,
                                         torch.ones_like(discr_pred_real))
                     loss_vals[key + "_discr_real"] = _loss_val.detach()
                     total_loss_discr_real += _loss_val
 
                 # train discr with prediction from fake image
-                for key, crit_fn in criterions.items():
+                for key, crit_fn in losses.items():
                     _loss_val = crit_fn(discr_pred_fake,
                                         torch.zeros_like(discr_pred_fake))
                     loss_vals[key + "_discr_fake"] = _loss_val.detach()
@@ -175,7 +175,7 @@ def closure(model, data_dict: dict,
                     optimizers["discr"].step()
 
                 # calculate adversarial loss for generator update
-                for key, crit_fn in criterions.items():
+                for key, crit_fn in losses.items():
                     _loss_val = crit_fn(discr_pred_fake,
                                         torch.ones_like(discr_pred_fake))
                     loss_vals[key + "_adversarial"] = _loss_val.detach().cpu()

delira/models/segmentation/unet.py

@@ -172,7 +172,7 @@ def forward(self, x):
             return x
 
         @staticmethod
-        def closure(model, data_dict: dict, optimizers: dict, criterions={},
+        def closure(model, data_dict: dict, optimizers: dict, losses={},
                     metrics={}, fold=0, **kwargs):
             """
             closure method to do a single backpropagation step
@@ -186,9 +186,9 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
                 dictionary containing the data
             optimizers : dict
                 dictionary of optimizers to optimize model's parameters
-            criterions : dict
-                dict holding the criterions to calculate errors
-                (gradients from different criterions will be accumulated)
+            losses : dict
+                dict holding the losses to calculate errors
+                (gradients from different losses will be accumulated)
             metrics : dict
                 dict holding the metrics to calculate
             fold : int
@@ -201,20 +201,20 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
             dict
                 Metric values (with same keys as input dict metrics)
             dict
-                Loss values (with same keys as input dict criterions)
+                Loss values (with same keys as input dict losses)
             list
                 Arbitrary number of predictions as torch.Tensor
 
             Raises
             ------
             AssertionError
-                if optimizers or criterions are empty or the optimizers are not
+                if optimizers or losses are empty or the optimizers are not
                 specified
 
             """
 
-            assert (optimizers and criterions) or not optimizers, \
-                "Criterion dict cannot be emtpy, if optimizers are passed"
+            assert (optimizers and losses) or not optimizers, \
+                "Loss dict cannot be emtpy, if optimizers are passed"
 
             loss_vals = {}
             metric_vals = {}
@@ -234,7 +234,7 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
 
                 if data_dict:
 
-                    for key, crit_fn in criterions.items():
+                    for key, crit_fn in losses.items():
                         _loss_val = crit_fn(preds, *data_dict.values())
                         loss_vals[key] = _loss_val.detach()
                         total_loss += _loss_val
@@ -264,11 +264,6 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
                 loss_vals = eval_loss_vals
                 metric_vals = eval_metrics_vals
 
-            for key, val in {**metric_vals, **loss_vals}.items():
-                logging.info({"value": {"value": val.item(), "name": key,
-                                        "env_appendix": "_%02d" % fold
-                                        }})
-
             logging.info({'image_grid': {"images": inputs, "name": "input_images",
                                         "env_appendix": "_%02d" % fold}})
 
@@ -624,7 +619,7 @@ def forward(self, x):
             return x
 
         @staticmethod
-        def closure(model, data_dict: dict, optimizers: dict, criterions={},
+        def closure(model, data_dict: dict, optimizers: dict, losses={},
                     metrics={}, fold=0, **kwargs):
             """
             closure method to do a single backpropagation step
@@ -638,9 +633,9 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
                 dictionary containing the data
             optimizers : dict
                 dictionary of optimizers to optimize model's parameters
-            criterions : dict
-                dict holding the criterions to calculate errors
-                (gradients from different criterions will be accumulated)
+            losses : dict
+                dict holding the losses to calculate errors
+                (gradients from different losses will be accumulated)
             metrics : dict
                 dict holding the metrics to calculate
             fold : int
@@ -653,20 +648,20 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
             dict
                 Metric values (with same keys as input dict metrics)
             dict
-                Loss values (with same keys as input dict criterions)
+                Loss values (with same keys as input dict losses)
             list
                 Arbitrary number of predictions as torch.Tensor
 
             Raises
             ------
             AssertionError
-                if optimizers or criterions are empty or the optimizers are not
+                if optimizers or losses are empty or the optimizers are not
                 specified
 
             """
 
-            assert (optimizers and criterions) or not optimizers, \
-                "Criterion dict cannot be emtpy, if optimizers are passed"
+            assert (optimizers and losses) or not optimizers, \
+                "Loss dict cannot be emtpy, if optimizers are passed"
 
             loss_vals = {}
             metric_vals = {}
@@ -686,7 +681,7 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
 
                 if data_dict:
 
-                    for key, crit_fn in criterions.items():
+                    for key, crit_fn in losses.items():
                         _loss_val = crit_fn(preds, *data_dict.values())
                         loss_vals[key] = _loss_val.detach()
                         total_loss += _loss_val
@@ -716,11 +711,6 @@ def closure(model, data_dict: dict, optimizers: dict, criterions={},
                 loss_vals = eval_loss_vals
                 metric_vals = eval_metrics_vals
 
-            for key, val in {**metric_vals, **loss_vals}.items():
-                logging.info({"value": {"value": val.item(), "name": key,
-                                        "env_appendix": "_%02d" % fold
-                                        }})
-
             slicing_dim = inputs.size(2) // 2  # visualize slice in mid of volume
 
             logging.info({'image_grid': {"inputs": inputs[:, :, slicing_dim, ...],

delira/training/__init__.py

@@ -7,7 +7,6 @@
 if "TORCH" in get_backends():
     from .experiment import PyTorchExperiment
     from .pytorch_trainer import PyTorchNetworkTrainer
-    from .metrics import AccuracyMetricPyTorch, AurocMetricPyTorch
 
 if "TF" in get_backends():
     from .experiment import TfExperiment