formatting 6/n: metrics (#5722)

* yapf metrics

* op

Author: Borda

.yapfignore

@@ -20,10 +20,6 @@ pytorch_lightning/core/*
 # TODO
 pytorch_lightning/loggers/*
 
-
-# TODO
-pytorch_lightning/metrics/*
-
 # TODO
 pytorch_lightning/plugins/legacy/*
 

pytorch_lightning/metrics/classification/auc.py

@@ -42,6 +42,7 @@ class AUC(Metric):
             Callback that performs the allgather operation on the metric state. When ``None``, DDP
             will be used to perform the allgather
     """
+
     def __init__(
         self,
         reorder: bool = False,

pytorch_lightning/metrics/classification/auroc.py

@@ -86,6 +86,7 @@ class AUROC(Metric):
         tensor(0.7778)
 
     """
+
     def __init__(
         self,
         num_classes: Optional[int] = None,
@@ -111,8 +112,9 @@ def __init__(
 
         allowed_average = (None, 'macro', 'weighted')
         if self.average not in allowed_average:
-            raise ValueError('Argument `average` expected to be one of the following:'
-                             f' {allowed_average} but got {average}')
+            raise ValueError(
+                f'Argument `average` expected to be one of the following: {allowed_average} but got {average}'
+            )
 
         if self.max_fpr is not None:
             if (not isinstance(max_fpr, float) and 0 < max_fpr <= 1):
@@ -146,8 +148,10 @@ def update(self, preds: torch.Tensor, target: torch.Tensor):
         self.target.append(target)
 
         if self.mode is not None and self.mode != mode:
-            raise ValueError('The mode of data (binary, multi-label, multi-class) should be constant, but changed'
-                             f' between batches from {self.mode} to {mode}')
+            raise ValueError(
+                'The mode of data (binary, multi-label, multi-class) should be constant, but changed'
+                f' between batches from {self.mode} to {mode}'
+            )
         self.mode = mode
 
     def compute(self) -> torch.Tensor:
@@ -163,5 +167,5 @@ def compute(self) -> torch.Tensor:
             self.num_classes,
             self.pos_label,
             self.average,
-            self.max_fpr
+            self.max_fpr,
         )

pytorch_lightning/metrics/classification/average_precision.py

@@ -68,6 +68,7 @@ class AveragePrecision(Metric):
         [tensor(1.), tensor(1.), tensor(0.2500), tensor(0.2500), tensor(nan)]
 
     """
+
     def __init__(
         self,
         num_classes: Optional[int] = None,
@@ -102,10 +103,7 @@ def update(self, preds: torch.Tensor, target: torch.Tensor):
             target: Ground truth values
         """
         preds, target, num_classes, pos_label = _average_precision_update(
-            preds,
-            target,
-            self.num_classes,
-            self.pos_label
+            preds, target, self.num_classes, self.pos_label
         )
         self.preds.append(preds)
         self.target.append(target)

pytorch_lightning/metrics/classification/confusion_matrix.py

@@ -70,6 +70,7 @@ class ConfusionMatrix(Metric):
                 [1., 1.]])
 
     """
+
     def __init__(
         self,
         num_classes: int,

pytorch_lightning/metrics/classification/f_beta.py

@@ -87,7 +87,9 @@ def __init__(
         process_group: Optional[Any] = None,
     ):
         super().__init__(
-            compute_on_step=compute_on_step, dist_sync_on_step=dist_sync_on_step, process_group=process_group,
+            compute_on_step=compute_on_step,
+            dist_sync_on_step=dist_sync_on_step,
+            process_group=process_group,
         )
 
         self.num_classes = num_classes
@@ -98,8 +100,10 @@ def __init__(
 
         allowed_average = ("micro", "macro", "weighted", None)
         if self.average not in allowed_average:
-            raise ValueError('Argument `average` expected to be one of the following:'
-                             f' {allowed_average} but got {self.average}')
+            raise ValueError(
+                'Argument `average` expected to be one of the following:'
+                f' {allowed_average} but got {self.average}'
+            )
 
         self.add_state("true_positives", default=torch.zeros(num_classes), dist_reduce_fx="sum")
         self.add_state("predicted_positives", default=torch.zeros(num_classes), dist_reduce_fx="sum")
@@ -125,8 +129,9 @@ def compute(self) -> torch.Tensor:
         """
         Computes fbeta over state.
         """
-        return _fbeta_compute(self.true_positives, self.predicted_positives,
-                              self.actual_positives, self.beta, self.average)
+        return _fbeta_compute(
+            self.true_positives, self.predicted_positives, self.actual_positives, self.beta, self.average
+        )
 
 
 class F1(FBeta):

pytorch_lightning/metrics/classification/iou.py

@@ -78,15 +78,15 @@ class IoU(ConfusionMatrix):
     """
 
     def __init__(
-            self,
-            num_classes: int,
-            ignore_index: Optional[int] = None,
-            absent_score: float = 0.0,
-            threshold: float = 0.5,
-            reduction: str = 'elementwise_mean',
-            compute_on_step: bool = True,
-            dist_sync_on_step: bool = False,
-            process_group: Optional[Any] = None,
+        self,
+        num_classes: int,
+        ignore_index: Optional[int] = None,
+        absent_score: float = 0.0,
+        threshold: float = 0.5,
+        reduction: str = 'elementwise_mean',
+        compute_on_step: bool = True,
+        dist_sync_on_step: bool = False,
+        process_group: Optional[Any] = None,
     ):
         super().__init__(
             num_classes=num_classes,

pytorch_lightning/metrics/classification/precision_recall_curve.py

@@ -82,6 +82,7 @@ class PrecisionRecallCurve(Metric):
         [tensor([0.7500]), tensor([0.7500]), tensor([0.0500, 0.7500]), tensor([0.0500, 0.7500]), tensor([0.0500])]
 
     """
+
     def __init__(
         self,
         num_classes: Optional[int] = None,
@@ -116,18 +117,17 @@ def update(self, preds: torch.Tensor, target: torch.Tensor):
             target: Ground truth values
         """
         preds, target, num_classes, pos_label = _precision_recall_curve_update(
-            preds,
-            target,
-            self.num_classes,
-            self.pos_label
+            preds, target, self.num_classes, self.pos_label
         )
         self.preds.append(preds)
         self.target.append(target)
         self.num_classes = num_classes
         self.pos_label = pos_label
 
-    def compute(self) -> Union[Tuple[torch.Tensor, torch.Tensor, torch.Tensor],
-                               Tuple[List[torch.Tensor], List[torch.Tensor], List[torch.Tensor]]]:
+    def compute(
+        self
+    ) -> Union[Tuple[torch.Tensor, torch.Tensor, torch.Tensor], Tuple[List[torch.Tensor], List[torch.Tensor],
+                                                                      List[torch.Tensor]]]:
         """
         Compute the precision-recall curve
 

pytorch_lightning/metrics/classification/roc.py

@@ -81,6 +81,7 @@ class ROC(Metric):
          tensor([1.7500, 0.7500, 0.0500])]
 
     """
+
     def __init__(
         self,
         num_classes: Optional[int] = None,
@@ -114,19 +115,16 @@ def update(self, preds: torch.Tensor, target: torch.Tensor):
             preds: Predictions from model
             target: Ground truth values
         """
-        preds, target, num_classes, pos_label = _roc_update(
-            preds,
-            target,
-            self.num_classes,
-            self.pos_label
-        )
+        preds, target, num_classes, pos_label = _roc_update(preds, target, self.num_classes, self.pos_label)
         self.preds.append(preds)
         self.target.append(target)
         self.num_classes = num_classes
         self.pos_label = pos_label
 
-    def compute(self) -> Union[Tuple[torch.Tensor, torch.Tensor, torch.Tensor],
-                               Tuple[List[torch.Tensor], List[torch.Tensor], List[torch.Tensor]]]:
+    def compute(
+        self
+    ) -> Union[Tuple[torch.Tensor, torch.Tensor, torch.Tensor], Tuple[List[torch.Tensor], List[torch.Tensor],
+                                                                      List[torch.Tensor]]]:
         """
         Compute the receiver operating characteristic
 

pytorch_lightning/metrics/classification/stat_scores.py

@@ -165,7 +165,7 @@ def __init__(
             if reduce == "micro":
                 zeros_shape = []
             elif reduce == "macro":
-                zeros_shape = (num_classes,)
+                zeros_shape = (num_classes, )
             default, reduce_fn = lambda: torch.zeros(zeros_shape, dtype=torch.long), "sum"
         else:
             default, reduce_fn = lambda: [], None