change based model

Author: humanpose1

torch_points3d/metrics/__init__.py

@@ -0,0 +1,81 @@
+import torch
+from typing import Dict, Optional, Tuple, Any, Union
+
+
+def compute_average_intersection_union(confusion_matrix: torch.Tensor, missing_as_one: bool = False) -> torch.Tensor:
+    """
+    compute intersection over union on average from confusion matrix
+    Parameters
+    Parameters
+    ----------
+    confusion_matrix: torch.Tensor
+      square matrix
+    missing_as_one: bool, default: False
+    """
+
+    values, existing_classes_mask = compute_intersection_union_per_class(confusion_matrix, return_existing_mask=True)
+    if torch.sum(existing_classes_mask) == 0:
+        return torch.sum(existing_classes_mask)
+    if missing_as_one:
+        values[~existing_classes_mask] = 1
+        existing_classes_mask[:] = True
+    return torch.sum(values[existing_classes_mask]) / torch.sum(existing_classes_mask)
+
+
+def compute_mean_class_accuracy(confusion_matrix: torch.Tensor) -> torch.Tensor:
+    """
+    compute intersection over union on average from confusion matrix
+
+    Parameters
+    ----------
+    confusion_matrix: torch.Tensor
+      square matrix
+    """
+    total_gts = confusion_matrix.sum(1)
+    labels_presents = torch.where(total_gts > 0)[0]
+    if len(labels_presents) == 0:
+        return total_gts[0]
+    ones = torch.ones_like(total_gts)
+    max_ones_total_gts = torch.cat([total_gts[None, :], ones[None, :]], 0).max(0)[0]
+    re = (torch.diagonal(confusion_matrix)[labels_presents].float() / max_ones_total_gts[labels_presents]).sum()
+    return re / float(len(labels_presents))
+
+
+def compute_overall_accuracy(confusion_matrix: torch.Tensor) -> Union[int, torch.Tensor]:
+    """
+    compute overall accuracy from confusion matrix
+
+    Parameters
+    ----------
+    confusion_matrix: torch.Tensor
+      square matrix
+    """
+    all_values = confusion_matrix.sum()
+    if all_values == 0:
+        return 0
+    matrix_diagonal = torch.trace(confusion_matrix)
+    return matrix_diagonal.float() / all_values
+
+
+def compute_intersection_union_per_class(
+    confusion_matrix: torch.Tensor, return_existing_mask: bool = False, eps: float = 1e-8
+) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+    """
+    compute intersection over union per class from confusion matrix
+
+    Parameters
+    ----------
+    confusion_matrix: torch.Tensor
+      square matrix
+    """
+
+    TP_plus_FN = confusion_matrix.sum(0)
+    TP_plus_FP = confusion_matrix.sum(1)
+    TP = torch.diagonal(confusion_matrix)
+    union = TP_plus_FN + TP_plus_FP - TP
+    iou = eps + TP / (union + eps)
+    existing_class_mask = union > 1e-3
+    if return_existing_mask:
+        return iou, existing_class_mask
+    else:
+        return iou, None

torch_points3d/metrics/segmentation/__init__.py

@@ -4,85 +4,7 @@
 from torchmetrics import Metric
 
 from torch_points3d.metrics.base_tracker import BaseTracker
-
-
-def compute_average_intersection_union(confusion_matrix: torch.Tensor, missing_as_one: bool = False) -> torch.Tensor:
-    """
-    compute intersection over union on average from confusion matrix
-    Parameters
-    Parameters
-    ----------
-    confusion_matrix: torch.Tensor
-      square matrix
-    missing_as_one: bool, default: False
-    """
-
-    values, existing_classes_mask = compute_intersection_union_per_class(confusion_matrix, return_existing_mask=True)
-    if torch.sum(existing_classes_mask) == 0:
-        return torch.sum(existing_classes_mask)
-    if missing_as_one:
-        values[~existing_classes_mask] = 1
-        existing_classes_mask[:] = True
-    return torch.sum(values[existing_classes_mask]) / torch.sum(existing_classes_mask)
-
-
-def compute_mean_class_accuracy(confusion_matrix: torch.Tensor) -> torch.Tensor:
-    """
-    compute intersection over union on average from confusion matrix
-
-    Parameters
-    ----------
-    confusion_matrix: torch.Tensor
-      square matrix
-    """
-    total_gts = confusion_matrix.sum(1)
-    labels_presents = torch.where(total_gts > 0)[0]
-    if len(labels_presents) == 0:
-        return total_gts[0]
-    ones = torch.ones_like(total_gts)
-    max_ones_total_gts = torch.cat([total_gts[None, :], ones[None, :]], 0).max(0)[0]
-    re = (torch.diagonal(confusion_matrix)[labels_presents].float() / max_ones_total_gts[labels_presents]).sum()
-    return re / float(len(labels_presents))
-
-
-def compute_overall_accuracy(confusion_matrix: torch.Tensor) -> Union[int, torch.Tensor]:
-    """
-    compute overall accuracy from confusion matrix
-
-    Parameters
-    ----------
-    confusion_matrix: torch.Tensor
-      square matrix
-    """
-    all_values = confusion_matrix.sum()
-    if all_values == 0:
-        return 0
-    matrix_diagonal = torch.trace(confusion_matrix)
-    return matrix_diagonal.float() / all_values
-
-
-def compute_intersection_union_per_class(
-    confusion_matrix: torch.Tensor, return_existing_mask: bool = False, eps: float = 1e-8
-) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
-    """
-    compute intersection over union per class from confusion matrix
-
-    Parameters
-    ----------
-    confusion_matrix: torch.Tensor
-      square matrix
-    """
-
-    TP_plus_FN = confusion_matrix.sum(0)
-    TP_plus_FP = confusion_matrix.sum(1)
-    TP = torch.diagonal(confusion_matrix)
-    union = TP_plus_FN + TP_plus_FP - TP
-    iou = eps + TP / (union + eps)
-    existing_class_mask = union > 1e-3
-    if return_existing_mask:
-        return iou, existing_class_mask
-    else:
-        return iou, None
+import torch_points3d.metrics.segmentation.metrics as mt
 
 
 class SegmentationTracker(BaseTracker):
@@ -104,10 +26,10 @@ def __init__(
         self.eps = eps
 
     def compute_metrics_from_cm(self, matrix: torch.Tensor) -> Dict[str, Any]:
-        acc = compute_overall_accuracy(matrix)
-        macc = compute_mean_class_accuracy(matrix)
-        miou = compute_average_intersection_union(matrix)
-        iou_per_class, _ = compute_intersection_union_per_class(matrix, eps=self.eps)
+        acc = mt.compute_overall_accuracy(matrix)
+        macc = mt.compute_mean_class_accuracy(matrix)
+        miou = mt.compute_average_intersection_union(matrix)
+        iou_per_class, _ = mt.compute_intersection_union_per_class(matrix, eps=self.eps)
         iou_per_class_dict = {f"{self.stage}_iou_class_{i}": (100 * v) for i, v in enumerate(iou_per_class)}
         res = {
             "{}_acc".format(self.stage): 100 * acc,

torch_points3d/metrics/segmentation/metrics.py

@@ -23,14 +23,9 @@ def forward(self) -> Optional[torch.Tensor]:
     def compute_loss(self):
         raise (NotImplementedError("get_losses needs to be defined!"))
 
-    def get_losses(self, stage: Optional[str] = None) -> Optional[Dict["str", torch.Tensor]]:
-        if stage is None:
-            return self._losses
-        else:
-            losses = {}
-            for name, l in self._losses.items():
-                losses[f"{stage}_{name}"] = l.item()
-            return losses
+    def get_losses(self) -> Optional[Dict["str", torch.Tensor]]:        
+        return self._losses
+
 
     def get_outputs(self) -> Dict[str, Optional[torch.Tensor]]:
         """

torch_points3d/metrics/segmentation/segmentation_tracker.py

@@ -32,18 +32,18 @@ def forward(self) -> Optional[torch.Tensor]:
         features = self.backbone(self.input).x
         logits = self.head(features)
         self._output = F.log_softmax(logits, dim=-1)
-        self.compute_losses()
-        if "loss" in self._losses.keys():
-            return self._losses["loss"]
-        else:
-            return None
+        loss = self.compute_losses()
+        return loss
 
     def compute_losses(self):
         """
         compute every loss. store the total loss in an attribute _loss
         """
         if self.labels is not None and self.criterion is not None:
             self._losses["loss"] = self.criterion(self._output, self.labels)
+            return self._losses["loss"]
+        else:
+            return None
 
     def get_outputs(self) -> Dict[str, torch.Tensor]:
         """