rename variables nb -> num (#567)

* rename nb -> num

* flake8

* batch_nb, epoch_nb, gpu_nb, split_nb

* add _num deprecations

README.md

@@ -96,15 +96,15 @@ To use lightning do 2 things:
         def forward(self, x):
             return torch.relu(self.l1(x.view(x.size(0), -1)))
 
-        def training_step(self, batch, batch_nb):
+        def training_step(self, batch, batch_idx):
             # REQUIRED
             x, y = batch
             y_hat = self.forward(x)
             loss = F.cross_entropy(y_hat, y)
             tensorboard_logs = {'train_loss': loss}
             return {'loss': loss, 'log': tensorboard_logs}
 
-        def validation_step(self, batch, batch_nb):
+        def validation_step(self, batch, batch_idx):
             # OPTIONAL
             x, y = batch
             y_hat = self.forward(x)
@@ -154,16 +154,16 @@ use something other than tensorboard).
 Here are more advanced examples
 ```python   
 # train on cpu using only 10% of the data (for demo purposes)
-trainer = Trainer(max_nb_epochs=1, train_percent_check=0.1)
+trainer = Trainer(max_num_epochs=1, train_percent_check=0.1)
 
 # train on 4 gpus (lightning chooses GPUs for you)
-# trainer = Trainer(max_nb_epochs=1, gpus=4, distributed_backend='ddp')  
+# trainer = Trainer(max_num_epochs=1, gpus=4, distributed_backend='ddp')  
 
 # train on 4 gpus (you choose GPUs)
-# trainer = Trainer(max_nb_epochs=1, gpus=[0, 1, 3, 7], distributed_backend='ddp')   
+# trainer = Trainer(max_num_epochs=1, gpus=[0, 1, 3, 7], distributed_backend='ddp')   
 
 # train on 32 gpus across 4 nodes (make sure to submit appropriate SLURM job)
-# trainer = Trainer(max_nb_epochs=1, gpus=8, nb_gpu_nodes=4, distributed_backend='ddp')
+# trainer = Trainer(max_num_epochs=1, gpus=8, num_gpu_nodes=4, distributed_backend='ddp')
 
 # train (1 epoch only here for demo)
 trainer.fit(model)
@@ -187,10 +187,10 @@ You define the blue parts using the LightningModule interface:
 
 ```python
 # what to do in the training loop
-def training_step(self, batch, batch_nb):
+def training_step(self, batch, batch_idx):
 
 # what to do in the validation loop
-def validation_step(self, batch, batch_nb):
+def validation_step(self, batch, batch_idx):
 
 # how to aggregate validation_step outputs
 def validation_end(self, outputs):
@@ -205,7 +205,7 @@ def test_dataloader():
 
 ```python
 # define what happens for training here
-def training_step(self, batch, batch_nb):
+def training_step(self, batch, batch_idx):
     x, y = batch
 
     # define your own forward and loss calculation
@@ -232,7 +232,7 @@ def training_step(self, batch, batch_nb):
 
 ```python
 # define what happens for validation here
-def validation_step(self, batch, batch_nb):    
+def validation_step(self, batch, batch_idx):    
     x, y = batch
 
     # or as basic as a CNN classification

docs/source/intro.md

@@ -16,7 +16,7 @@ class BERT(pl.LightningModule):
         elif model_name == 'my_cool_version':
             self.net = MyCoolVersion()
 
-    def training_step(self, batch, batch_nb):
+    def training_step(self, batch, batch_idx):
         if self.task == 'standard_bert':
             # do standard bert training with self.net...
             # return loss
@@ -35,7 +35,7 @@ class CoolerNotBERT(pl.LightningModule):
     def __init__(self):
         self.net = ...
 
-    def training_step(self, batch, batch_nb):
+    def training_step(self, batch, batch_idx):
         # do some other cool task
         # return loss   
 ```   

pl_examples/domain_templates/gan.py

@@ -90,12 +90,12 @@ def forward(self, z):
     def adversarial_loss(self, y_hat, y):
         return F.binary_cross_entropy(y_hat, y)
 
-    def training_step(self, batch, batch_nb, optimizer_i):
+    def training_step(self, batch, batch_idx, optimizer_idx):
         imgs, _ = batch
         self.last_imgs = imgs
 
         # train generator
-        if optimizer_i == 0:
+        if optimizer_idx == 0:
             # sample noise
             z = torch.randn(imgs.shape[0], self.hparams.latent_dim)
 
@@ -125,7 +125,7 @@ def training_step(self, batch, batch_nb, optimizer_i):
             return output
 
         # train discriminator
-        if optimizer_i == 1:
+        if optimizer_idx == 1:
             # Measure discriminator's ability to classify real from generated samples
 
             # how well can it label as real?

pl_examples/full_examples/imagenet/imagenet_example.py

@@ -234,7 +234,7 @@ def main(hparams):
     trainer = pl.Trainer(
         default_save_path=hparams.save_path,
         gpus=hparams.gpus,
-        max_nb_epochs=hparams.epochs,
+        max_num_epochs=hparams.epochs,
         distributed_backend=hparams.distributed_backend,
         use_amp=hparams.use_16bit
     )

pl_examples/multi_node_examples/multi_node_ddp2_demo.py

@@ -31,7 +31,7 @@ def main(hparams):
     # ------------------------
     trainer = Trainer(
         gpus=2,
-        nb_gpu_nodes=2,
+        num_nodes=2,
         distributed_backend='ddp2'
     )
 

pl_examples/multi_node_examples/multi_node_ddp_demo.py

@@ -31,7 +31,7 @@ def main(hparams):
     # ------------------------
     trainer = Trainer(
         gpus=2,
-        nb_gpu_nodes=2,
+        num_nodes=2,
         distributed_backend='ddp'
     )
 

pytorch_lightning/core/__init__.py

@@ -34,13 +34,13 @@ def __init__(self):
         def forward(self, x):
             return torch.relu(self.l1(x.view(x.size(0), -1)))
 
-        def training_step(self, batch, batch_nb):
+        def training_step(self, batch, batch_idx):
             # REQUIRED
             x, y = batch
             y_hat = self.forward(x)
             return {'loss': F.cross_entropy(y_hat, y)}
 
-        def validation_step(self, batch, batch_nb):
+        def validation_step(self, batch, batch_idx):
             # OPTIONAL
             x, y = batch
             y_hat = self.forward(x)
@@ -51,7 +51,7 @@ def validation_end(self, outputs):
             avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()
             return {'avg_val_loss': avg_loss}
 
-        def test_step(self, batch, batch_nb):
+        def test_step(self, batch, batch_idx):
             # OPTIONAL
             x, y = batch
             y_hat = self.forward(x)

pytorch_lightning/core/lightning.py

@@ -109,7 +109,7 @@ def training_step(self, *args, **kwargs):
         """return loss, dict with metrics for tqdm
 
         :param batch: The output of your dataloader. A tensor, tuple or list
-        :param int batch_nb: Integer displaying which batch this is
+        :param int batch_idx: Integer displaying which batch this is
         :return: dict with loss key and optional log, progress keys
          if implementing training_step, return whatever you need in that step:
             - loss -> tensor scalar [REQUIRED]
@@ -124,7 +124,7 @@ def training_step(self, *args, **kwargs):
 
         .. code-block:: python
 
-            def training_step(self, batch, batch_nb):
+            def training_step(self, batch, batch_idx):
                 x, y, z = batch
 
                 # implement your own
@@ -150,7 +150,7 @@ def training_step(self, batch, batch_nb):
         .. code-block:: python
 
             # Multiple optimizers (ie: GANs)
-            def training_step(self, batch, batch_nb, optimizer_idx):
+            def training_step(self, batch, batch_idx, optimizer_idx):
                 if optimizer_idx == 0:
                     # do training_step with encoder
                 if optimizer_idx == 1:
@@ -163,7 +163,7 @@ def training_step(self, batch, batch_nb, optimizer_idx):
         .. code-block:: python
 
             # Truncated back-propagation through time
-            def training_step(self, batch, batch_nb, hiddens):
+            def training_step(self, batch, batch_idx, hiddens):
                 # hiddens are the hiddens from the previous truncated backprop step
 
         You can also return a -1 instead of a dict to stop the current loop. This is useful
@@ -192,9 +192,9 @@ def training_end(self, *args, **kwargs):
         .. code-block:: python
 
             # WITHOUT training_end
-            # if used in DP or DDP2, this batch is 1/nb_gpus large
-            def training_step(self, batch, batch_nb):
-                # batch is 1/nb_gpus big
+            # if used in DP or DDP2, this batch is 1/num_gpus large
+            def training_step(self, batch, batch_idx):
+                # batch is 1/num_gpus big
                 x, y = batch
 
                 out = self.forward(x)
@@ -204,8 +204,8 @@ def training_step(self, batch, batch_nb):
 
             # --------------
             # with training_end to do softmax over the full batch
-            def training_step(self, batch, batch_nb):
-                # batch is 1/nb_gpus big
+            def training_step(self, batch, batch_idx):
+                # batch is 1/num_gpus big
                 x, y = batch
 
                 out = self.forward(x)
@@ -225,7 +225,7 @@ def training_end(self, outputs):
         .. code-block:: python
 
             # Multiple optimizers (ie: GANs)
-            def training_step(self, batch, batch_nb, optimizer_idx):
+            def training_step(self, batch, batch_idx, optimizer_idx):
                 if optimizer_idx == 0:
                     # do training_step with encoder
                 if optimizer_idx == 1:
@@ -237,7 +237,7 @@ def training_step(self, batch, batch_nb, optimizer_idx):
         .. code-block:: python
 
             # Truncated back-propagation through time
-            def training_step(self, batch, batch_nb, hiddens):
+            def training_step(self, batch, batch_idx, hiddens):
                 # hiddens are the hiddens from the previous truncated backprop step
 
         You can also return a -1 instead of a dict to stop the current loop. This is useful if you want to
@@ -249,17 +249,17 @@ def validation_step(self, *args, **kwargs):
         """return whatever outputs will need to be aggregated in validation_end
 
         :param batch: The output of your dataloader. A tensor, tuple or list
-        :param int batch_nb: Integer displaying which batch this is
+        :param int batch_idx: Integer displaying which batch this is
         :param int dataloader_idx: Integer displaying which dataloader this is (only if multiple val datasets used)
         :return dict: Dict or OrderedDict - passed to the validation_end step
 
         .. code-block:: python
 
             # if you have one val dataloader:
-            def validation_step(self, batch, batch_nb)
+            def validation_step(self, batch, batch_idx)
 
             # if you have multiple val dataloaders:
-            def validation_step(self, batch, batch_nb, dataloader_idxdx)
+            def validation_step(self, batch, batch_idx, dataloader_idxdx)
 
         If you don't need to validate you don't need to implement this method.
          In this step you'd normally generate examples or calculate anything of interest such as accuracy.
@@ -275,7 +275,7 @@ def validation_step(self, batch, batch_nb, dataloader_idxdx)
         .. code-block:: python
 
             # CASE 1: A single validation dataset
-            def validation_step(self, batch, batch_nb):
+            def validation_step(self, batch, batch_idx):
                 x, y = batch
 
                 # implement your own
@@ -307,7 +307,7 @@ def validation_step(self, batch, batch_nb):
         .. code-block:: python
 
             # CASE 2: multiple validation datasets
-            def validation_step(self, batch, batch_nb, dataset_idx):
+            def validation_step(self, batch, batch_idx, dataset_idx):
                 # dataset_idx tells you which dataset this is.
 
         The `dataset_idx` corresponds to the order of datasets returned in `val_dataloader`.
@@ -318,17 +318,17 @@ def test_step(self, *args, **kwargs):
         """return whatever outputs will need to be aggregated in test_end
 
         :param batch: The output of your dataloader. A tensor, tuple or list
-        :param int batch_nb: Integer displaying which batch this is
+        :param int batch_idx: Integer displaying which batch this is
         :param int dataloader_idx: Integer displaying which dataloader this is (only if multiple test datasets used)
         :return dict: Dict or OrderedDict with metrics to display in progress bar. All keys must be tensors.
 
         .. code-block:: python
 
             # if you have one test dataloader:
-            def test_step(self, batch, batch_nb)
+            def test_step(self, batch, batch_idx)
 
             # if you have multiple test dataloaders:
-            def test_step(self, batch, batch_nb, dataloader_idxdx)
+            def test_step(self, batch, batch_idx, dataloader_idxdx)
 
 
         **OPTIONAL**
@@ -348,7 +348,7 @@ def test_step(self, batch, batch_nb, dataloader_idxdx)
         .. code-block:: python
 
             # CASE 1: A single test dataset
-            def test_step(self, batch, batch_nb):
+            def test_step(self, batch, batch_idx):
                 x, y = batch
 
                 # implement your own
@@ -375,7 +375,7 @@ def test_step(self, batch, batch_nb):
         .. code-block:: python
 
             # CASE 2: multiple test datasets
-            def test_step(self, batch, batch_nb, dataset_idx):
+            def test_step(self, batch, batch_idx, dataset_idx):
                 # dataset_idx tells you which dataset this is.
 
 
@@ -694,13 +694,13 @@ def configure_optimizers(self):
         """
         raise NotImplementedError
 
-    def optimizer_step(self, epoch_nb, batch_nb, optimizer, optimizer_i, second_order_closure=None):
+    def optimizer_step(self, epoch_idx, batch_idx, optimizer, optimizer_idx, second_order_closure=None):
         """Do something instead of the standard optimizer behavior
 
-        :param int epoch_nb:
-        :param int batch_nb:
+        :param int epoch_idx:
+        :param int batch_idx:
         :param optimizer:
-        :param optimizer_i:
+        :param optimizer_idx:
         :param second_order_closure: closure for second order methods
         :return:
 
@@ -712,21 +712,21 @@ def optimizer_step(self, epoch_nb, batch_nb, optimizer, optimizer_i, second_orde
         .. code-block:: python
 
             # DEFAULT
-            def optimizer_step(self, current_epoch, batch_nb, optimizer, optimizer_i, second_order_closure=None):
+            def optimizer_step(self, current_epoch, batch_idx, optimizer, optimizer_idx, second_order_closure=None):
                 optimizer.step()
                 optimizer.zero_grad()
 
             # Alternating schedule for optimizer steps (ie: GANs)
-            def optimizer_step(self, current_epoch, batch_nb, optimizer, optimizer_i, second_order_closure=None):
+            def optimizer_step(self, current_epoch, batch_idx, optimizer, optimizer_idx, second_order_closure=None):
                 # update generator opt every 2 steps
-                if optimizer_i == 0:
-                    if batch_nb % 2 == 0 :
+                if optimizer_idx == 0:
+                    if batch_idx % 2 == 0 :
                         optimizer.step()
                         optimizer.zero_grad()
 
                 # update discriminator opt every 4 steps
-                if optimizer_i == 1:
-                    if batch_nb % 4 == 0 :
+                if optimizer_idx == 1:
+                    if batch_idx % 4 == 0 :
                         optimizer.step()
                         optimizer.zero_grad()
 
@@ -739,7 +739,7 @@ def optimizer_step(self, current_epoch, batch_nb, optimizer, optimizer_i, second
         .. code-block:: python
 
             # learning rate warm-up
-            def optimizer_step(self, current_epoch, batch_nb, optimizer, optimizer_i, second_order_closure=None):
+            def optimizer_step(self, current_epoch, batch_idx, optimizer, optimizer_idx, second_order_closure=None):
                 # warm up lr
                 if self.trainer.global_step < 500:
                     lr_scale = min(1., float(self.trainer.global_step + 1) / 500.)