Linter Fixes

Author: pranavsinghps1

vissl/data/ssl_transforms/img_pil_color_distortion.py

@@ -21,7 +21,7 @@ class ImgPilColorDistortion(ClassyTransform):
     randomly convert the image to grayscale.
     """
 
-    def __init__(self, strength , brightness=0.8 , contrast=0.8 , saturation=0.8, 
+    def __init__(self, strength , brightness=0.8 , contrast=0.8 , saturation=0.8,
                     hue=0.2,color_jitter_probability=0.8,grayscale_probability=0.2):
         """
         Args:
@@ -35,11 +35,11 @@ def __init__(self, strength , brightness=0.8 , contrast=0.8 , saturation=0.8,
                               jitter saturation. Default value is 0.8.
             hue (float): A floating point number used to quantify
                               jitter hue. Default value is 0.2.
-            color_jitter_probability (float): A floating point number used to 
-                            quantify to apply randomly a list of transformations 
+            color_jitter_probability (float): A floating point number used to
+                            quantify to apply randomly a list of transformations
                             with a given probability. Default value is 0.8.
-            grayscale_probability (float): A floating point number used to 
-                            quantify to apply randomly convert image to grayscale with 
+            grayscale_probability (float): A floating point number used to
+                            quantify to apply randomly convert image to grayscale with
                             the assigned probability. Default value is 0.2.
             This function follows the Pytorch documentation: https://pytorch.org/vision/stable/transforms.html
         """

vissl/hooks/byol_hooks.py

@@ -4,11 +4,9 @@
 
 import torch
 from classy_vision import tasks
-from classy_vision.generic.distributed_util import is_distributed_training_run
 from classy_vision.hooks.classy_hook import ClassyHook
 from vissl.models import build_model
 from vissl.utils.env import get_machine_local_and_dist_rank
-from vissl.utils.misc import concat_all_gather
 
 class BYOLHook(ClassyHook):
     """
@@ -94,7 +92,7 @@ def _update_momentum_coefficient(self, task: tasks.ClassyTask) -> None:
         if self.total_iters is None:
 
             self.total_iters = task.max_iteration
-            logging.info(f"{self.total_iters} total iters") 
+            logging.info(f"{self.total_iters} total iters")
         training_iteration = task.iteration
         self.momentum = self.target_ema(training_iteration, self.base_momentum, self.total_iters)
 
@@ -118,8 +116,8 @@ def _update_target_network(self, task: tasks.ClassyTask) -> None:
     @torch.no_grad()
     def on_forward(self, task: tasks.ClassyTask) -> None:
         """
-        Creates a target network needed for Contrastive learning 
-        on which BYOL is based. It then updates the target network's 
+        Creates a target network needed for Contrastive learning
+        on which BYOL is based. It then updates the target network's
         parameters based on the online network's parameters.
         This function also computer and saves target embeddings,
         which need be can be used for further downstream tasks.

vissl/losses/byol_loss.py

@@ -6,17 +6,14 @@
 import torch
 import torch.nn.functional as F
 from classy_vision.losses import ClassyLoss, register_loss
-from torch import nn
-from vissl.utils.misc import concat_all_gather
-
 
 _BYOLLossConfig = namedtuple(
     "_BYOLLossConfig", ["embedding_dim", "momentum"]
 )
 
 def regression_loss(x, y):
     """
-    This function is used for computing loss between the prediction 
+    This function is used for computing loss between the prediction
     from the Online network and projection from the target network.
     We can either use L2 normalized Root mean squared or
     Cosine similarity. This implementation uses Cosine similarity.
@@ -39,7 +36,7 @@ def defaults() -> "BYOLLossConfig":
 @register_loss("byol_loss")
 class BYOLLoss(ClassyLoss):
     """
-    This is the loss proposed in BYOL 
+    This is the loss proposed in BYOL
     - Bootstrap your own latent: (https://arxiv.org/abs/2006.07733)
     This class wraps functions which computes
     - loss