formatting 1/n: pl_examples

.yapfignore

@@ -1,8 +1,5 @@
 .git/*
 
-# TODO
-pl_examples/*
-
 # TODO
 pytorch_lightning/*
 

pl_examples/__init__.py

@@ -9,7 +9,6 @@
 _TORCHVISION_AVAILABLE = _module_available("torchvision")
 _DALI_AVAILABLE = _module_available("nvidia.dali")
 
-
 LIGHTNING_LOGO = """
                     ####
                 ###########

pl_examples/basic_examples/autoencoder.py

@@ -43,12 +43,12 @@ def __init__(self):
         self.encoder = nn.Sequential(
             nn.Linear(28 * 28, 64),
             nn.ReLU(),
-            nn.Linear(64, 3)
+            nn.Linear(64, 3),
         )
         self.decoder = nn.Sequential(
             nn.Linear(3, 64),
             nn.ReLU(),
-            nn.Linear(64, 28 * 28)
+            nn.Linear(64, 28 * 28),
         )
 
     def forward(self, x):

pl_examples/basic_examples/backbone_image_classifier.py

@@ -36,6 +36,7 @@ class Backbone(torch.nn.Module):
       (l2): Linear(...)
     )
     """
+
     def __init__(self, hidden_dim=128):
         super().__init__()
         self.l1 = torch.nn.Linear(28 * 28, hidden_dim)
@@ -55,6 +56,7 @@ class LitClassifier(pl.LightningModule):
       (backbone): ...
     )
     """
+
     def __init__(self, backbone, learning_rate=1e-3):
         super().__init__()
         self.save_hyperparameters()

pl_examples/basic_examples/conv_sequential_example.py

@@ -39,16 +39,17 @@
     import pl_bolts
     from pl_bolts.transforms.dataset_normalizations import cifar10_normalization
 
-
 #####################
 #      Modules      #
 #####################
 
 
 class Flatten(nn.Module):
+
     def forward(self, x):
         return x.view(x.size(0), -1)
 
+
 ###############################
 #       LightningModule       #
 ###############################
@@ -61,6 +62,7 @@ class LitResnet(pl.LightningModule):
       (sequential_module): Sequential(...)
     )
     """
+
     def __init__(self, lr=0.05, batch_size=32, manual_optimization=False):
         super().__init__()
 
@@ -90,9 +92,7 @@ def __init__(self, lr=0.05, batch_size=32, manual_optimization=False):
             nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, padding=1),
             nn.ReLU(inplace=False),
             nn.MaxPool2d(kernel_size=2, stride=2),
-
             Flatten(),
-
             nn.Dropout(p=0.1),
             nn.Linear(4096, 1024),
             nn.ReLU(inplace=False),
@@ -159,7 +159,8 @@ def configure_optimizers(self):
                     optimizer,
                     0.1,
                     epochs=self.trainer.max_epochs,
-                    steps_per_epoch=math.ceil(45000 / self.hparams.batch_size)),
+                    steps_per_epoch=math.ceil(45000 / self.hparams.batch_size)
+                ),
                 'interval': 'step',
             }
         }
@@ -173,6 +174,7 @@ def automatic_optimization(self) -> bool:
 #     Instantiate Data Module   #
 #################################
 
+
 def instantiate_datamodule(args):
     train_transforms = torchvision.transforms.Compose([
         torchvision.transforms.RandomCrop(32, padding=4),

pl_examples/basic_examples/dali_image_classifier.py

@@ -95,22 +95,30 @@ class DALIClassificationLoader(DALIClassificationIterator):
     """
 
     def __init__(
-            self,
-            pipelines,
-            size=-1,
-            reader_name=None,
-            auto_reset=False,
-            fill_last_batch=True,
-            dynamic_shape=False,
-            last_batch_padded=False,
+        self,
+        pipelines,
+        size=-1,
+        reader_name=None,
+        auto_reset=False,
+        fill_last_batch=True,
+        dynamic_shape=False,
+        last_batch_padded=False,
     ):
         if NEW_DALI_API:
             last_batch_policy = LastBatchPolicy.FILL if fill_last_batch else LastBatchPolicy.DROP
-            super().__init__(pipelines, size, reader_name, auto_reset, dynamic_shape,
-                             last_batch_policy=last_batch_policy, last_batch_padded=last_batch_padded)
+            super().__init__(
+                pipelines,
+                size,
+                reader_name,
+                auto_reset,
+                dynamic_shape,
+                last_batch_policy=last_batch_policy,
+                last_batch_padded=last_batch_padded
+            )
         else:
-            super().__init__(pipelines, size, reader_name, auto_reset, fill_last_batch,
-                             dynamic_shape, last_batch_padded)
+            super().__init__(
+                pipelines, size, reader_name, auto_reset, fill_last_batch, dynamic_shape, last_batch_padded
+            )
         self._fill_last_batch = fill_last_batch
 
     def __len__(self):
@@ -120,6 +128,7 @@ def __len__(self):
 
 
 class LitClassifier(pl.LightningModule):
+
     def __init__(self, hidden_dim=128, learning_rate=1e-3):
         super().__init__()
         self.save_hyperparameters()

pl_examples/basic_examples/mnist_datamodule.py

@@ -58,8 +58,10 @@ def __init__(
         super().__init__(*args, **kwargs)
         if num_workers and platform.system() == "Windows":
             # see: https://stackoverflow.com/a/59680818
-            warn(f"You have requested num_workers={num_workers} on Windows,"
-                 " but currently recommended is 0, so we set it for you")
+            warn(
+                f"You have requested num_workers={num_workers} on Windows,"
+                " but currently recommended is 0, so we set it for you"
+            )
             num_workers = 0
 
         self.dims = (1, 28, 28)
@@ -132,9 +134,9 @@ def default_transforms(self):
         if not _TORCHVISION_AVAILABLE:
             return None
         if self.normalize:
-            mnist_transforms = transform_lib.Compose(
-                [transform_lib.ToTensor(), transform_lib.Normalize(mean=(0.5,), std=(0.5,))]
-            )
+            mnist_transforms = transform_lib.Compose([
+                transform_lib.ToTensor(), transform_lib.Normalize(mean=(0.5, ), std=(0.5, ))
+            ])
         else:
             mnist_transforms = transform_lib.ToTensor()
 

pl_examples/basic_examples/simple_image_classifier.py

@@ -31,6 +31,7 @@ class LitClassifier(pl.LightningModule):
       (l2): Linear(...)
     )
     """
+
     def __init__(self, hidden_dim=128, learning_rate=1e-3):
         super().__init__()
         self.save_hyperparameters()

pl_examples/bug_report_model.py

@@ -33,6 +33,7 @@ class RandomDataset(Dataset):
     >>> RandomDataset(size=10, length=20)  # doctest: +ELLIPSIS
     <...bug_report_model.RandomDataset object at ...>
     """
+
     def __init__(self, size, length):
         self.len = length
         self.data = torch.randn(length, size)
@@ -124,9 +125,11 @@ def configure_optimizers(self):
 #  parser = ArgumentParser()
 #  args = parser.parse_args(opt)
 
+
 def test_run():
 
     class TestModel(BoringModel):
+
         def on_train_epoch_start(self) -> None:
             print('override any method to prove your bug')
 

pl_examples/domain_templates/computer_vision_fine_tuning.py

@@ -1,4 +1,3 @@
-
 # Copyright The PyTorch Lightning team.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -60,14 +59,12 @@
 
 DATA_URL = "https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip"
 
-
 #  --- Finetunning Callback ---
 
+
 class MilestonesFinetuningCallback(BaseFinetuningCallback):
 
-    def __init__(self,
-                 milestones: tuple = (5, 10),
-                 train_bn: bool = True):
+    def __init__(self, milestones: tuple = (5, 10), train_bn: bool = True):
         self.milestones = milestones
         self.train_bn = train_bn
 
@@ -78,17 +75,13 @@ def finetunning_function(self, pl_module: pl.LightningModule, epoch: int, optimi
         if epoch == self.milestones[0]:
             # unfreeze 5 last layers
             self.unfreeze_and_add_param_group(
-                module=pl_module.feature_extractor[-5:],
-                optimizer=optimizer,
-                train_bn=self.train_bn
+                module=pl_module.feature_extractor[-5:], optimizer=optimizer, train_bn=self.train_bn
             )
 
         elif epoch == self.milestones[1]:
             # unfreeze remaing layers
             self.unfreeze_and_add_param_group(
-                module=pl_module.feature_extractor[:-5],
-                optimizer=optimizer,
-                train_bn=self.train_bn
+                module=pl_module.feature_extractor[:-5], optimizer=optimizer, train_bn=self.train_bn
             )
 
 
@@ -149,10 +142,12 @@ def __build_model(self):
         self.feature_extractor = nn.Sequential(*_layers)
 
         # 2. Classifier:
-        _fc_layers = [nn.Linear(2048, 256),
-                      nn.ReLU(),
-                      nn.Linear(256, 32),
-                      nn.Linear(32, 1)]
+        _fc_layers = [
+            nn.Linear(2048, 256),
+            nn.ReLU(),
+            nn.Linear(256, 32),
+            nn.Linear(32, 1),
+        ]
         self.fc = nn.Sequential(*_fc_layers)
 
         # 3. Loss:
@@ -218,25 +213,21 @@ def setup(self, stage: str):
 
         train_dataset = ImageFolder(
             root=data_path.joinpath("train"),
-            transform=transforms.Compose(
-                [
-                    transforms.Resize((224, 224)),
-                    transforms.RandomHorizontalFlip(),
-                    transforms.ToTensor(),
-                    normalize,
-                ]
-            ),
+            transform=transforms.Compose([
+                transforms.Resize((224, 224)),
+                transforms.RandomHorizontalFlip(),
+                transforms.ToTensor(),
+                normalize,
+            ]),
         )
 
         valid_dataset = ImageFolder(
             root=data_path.joinpath("validation"),
-            transform=transforms.Compose(
-                [
-                    transforms.Resize((224, 224)),
-                    transforms.ToTensor(),
-                    normalize,
-                ]
-            ),
+            transform=transforms.Compose([
+                transforms.Resize((224, 224)),
+                transforms.ToTensor(),
+                normalize,
+            ]),
         )
 
         self.train_dataset = train_dataset

pl_examples/domain_templates/generative_adversarial_net.py

@@ -43,6 +43,7 @@ class Generator(nn.Module):
       (model): Sequential(...)
     )
     """
+
     def __init__(self, latent_dim: int = 100, img_shape: tuple = (1, 28, 28)):
         super().__init__()
         self.img_shape = img_shape
@@ -60,7 +61,7 @@ def block(in_feat, out_feat, normalize=True):
             *block(256, 512),
             *block(512, 1024),
             nn.Linear(1024, int(np.prod(img_shape))),
-            nn.Tanh()
+            nn.Tanh(),
         )
 
     def forward(self, z):
@@ -76,6 +77,7 @@ class Discriminator(nn.Module):
       (model): Sequential(...)
     )
     """
+
     def __init__(self, img_shape):
         super().__init__()
 
@@ -106,13 +108,14 @@ class GAN(LightningModule):
       )
     )
     """
+
     def __init__(
-            self,
-            img_shape: tuple = (1, 28, 28),
-            lr: float = 0.0002,
-            b1: float = 0.5,
-            b2: float = 0.999,
-            latent_dim: int = 100,
+        self,
+        img_shape: tuple = (1, 28, 28),
+        lr: float = 0.0002,
+        b1: float = 0.5,
+        b2: float = 0.999,
+        latent_dim: int = 100,
     ):
         super().__init__()
 
@@ -130,12 +133,9 @@ def __init__(
     def add_argparse_args(parent_parser: ArgumentParser):
         parser = ArgumentParser(parents=[parent_parser], add_help=False)
         parser.add_argument("--lr", type=float, default=0.0002, help="adam: learning rate")
-        parser.add_argument("--b1", type=float, default=0.5,
-                            help="adam: decay of first order momentum of gradient")
-        parser.add_argument("--b2", type=float, default=0.999,
-                            help="adam: decay of second order momentum of gradient")
-        parser.add_argument("--latent_dim", type=int, default=100,
-                            help="dimensionality of the latent space")
+        parser.add_argument("--b1", type=float, default=0.5, help="adam: decay of first order momentum of gradient")
+        parser.add_argument("--b2", type=float, default=0.999, help="adam: decay of second order momentum of gradient")
+        parser.add_argument("--latent_dim", type=int, default=100, help="dimensionality of the latent space")
 
         return parser
 
@@ -180,8 +180,7 @@ def training_step(self, batch, batch_idx, optimizer_idx):
             fake = torch.zeros(imgs.size(0), 1)
             fake = fake.type_as(imgs)
 
-            fake_loss = self.adversarial_loss(
-                self.discriminator(self(z).detach()), fake)
+            fake_loss = self.adversarial_loss(self.discriminator(self(z).detach()), fake)
 
             # discriminator loss is the average of these
             d_loss = (real_loss + fake_loss) / 2
@@ -213,14 +212,14 @@ class MNISTDataModule(LightningDataModule):
     >>> MNISTDataModule()  # doctest: +ELLIPSIS
     <...generative_adversarial_net.MNISTDataModule object at ...>
     """
+
     def __init__(self, batch_size: int = 64, data_path: str = os.getcwd(), num_workers: int = 4):
         super().__init__()
         self.batch_size = batch_size
         self.data_path = data_path
         self.num_workers = num_workers
 
-        self.transform = transforms.Compose([transforms.ToTensor(),
-                                             transforms.Normalize([0.5], [0.5])])
+        self.transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])
         self.dims = (1, 28, 28)
 
     def prepare_data(self, stage=None):