update docs

Author: ananthsub

docs/source/advanced/sequences.rst

@@ -40,13 +40,21 @@ For example, it may save memory to use Truncated Backpropagation Through Time wh
 
 Lightning can handle TBTT automatically via this flag.
 
-.. testcode::
+.. testcode:: python
+
+    from pytorch_lightning import LightningModule
+
+    class MyModel(LightningModule):
 
-    # DEFAULT (single backwards pass per batch)
-    trainer = Trainer(truncated_bptt_steps=None)
+        def __init__(self):
+            super().__init__()
+            # Important: This property activates truncated backpropagation through time
+            # Setting this value to 2 splits the batch into sequences of size 2
+            self.truncated_bptt_steps = 2
 
-    # (split batch into sequences of size 2)
-    trainer = Trainer(truncated_bptt_steps=2)
+        def training_step(batch, batch_idx, hiddens):
+            # The training_step will be passed a `hiddens` argument for the split batch
+            ...
 
 .. note:: If you need to modify how the batch is split,
     override :meth:`pytorch_lightning.core.LightningModule.tbptt_split_batch`.

pytorch_lightning/accelerators/accelerator.py

@@ -196,7 +196,7 @@ def training_step(
                 - batch_idx (int): Integer displaying index of this batch
                 - optimizer_idx (int): When using multiple optimizers, this argument will also be present.
                 - hiddens(:class:`~torch.Tensor`): Passed in if
-                  :paramref:`~pytorch_lightning.trainer.trainer.Trainer.truncated_bptt_steps` > 0.
+                :paramref:`~pytorch_lightning.core.lightning.LightningModule.truncated_bptt_steps` > 0
 
         """
         args[0] = self.to_device(args[0])

pytorch_lightning/core/lightning.py

@@ -106,7 +106,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         self._current_hook_fx_name: Optional[str] = None
         self._current_dataloader_idx: Optional[int] = None
         self._automatic_optimization: bool = True
-        self._truncated_bptt_steps: Optional[int] = None
+        self._truncated_bptt_steps: int = 0
         self._param_requires_grad_state = dict()
 
     def optimizers(self, use_pl_optimizer: bool = True) -> Union[Optimizer, List[Optimizer], List[LightningOptimizer]]:
@@ -195,15 +195,15 @@ def automatic_optimization(self, automatic_optimization: bool) -> None:
         self._automatic_optimization = automatic_optimization
 
     @property
-    def truncated_bptt_steps(self) -> Optional[int]:
+    def truncated_bptt_steps(self) -> int:
         """
         truncated_bptt_steps: Truncated back prop breaks performs backprop every k steps of much a longer sequence.
         If this is > 0, the training step is passed ``hiddens``.
         """
         return self._truncated_bptt_steps
 
     @truncated_bptt_steps.setter
-    def truncated_bptt_steps(self, truncated_bptt_steps: Optional[int]) -> None:
+    def truncated_bptt_steps(self, truncated_bptt_steps: int) -> None:
         self._truncated_bptt_steps = truncated_bptt_steps
 
     @property
@@ -538,9 +538,8 @@ def training_step(self, *args, **kwargs) -> STEP_OUTPUT:
                 The output of your :class:`~torch.utils.data.DataLoader`. A tensor, tuple or list.
             batch_idx (int): Integer displaying index of this batch
             optimizer_idx (int): When using multiple optimizers, this argument will also be present.
-            hiddens(:class:`~torch.Tensor`): Passed in if either
+            hiddens(:class:`~torch.Tensor`): Passed in if
                 :paramref:`~pytorch_lightning.core.lightning.LightningModule.truncated_bptt_steps` > 0
-                :paramref:`~pytorch_lightning.trainer.trainer.Trainer.truncated_bptt_steps` > 0
 
 
         Return:
@@ -1462,7 +1461,6 @@ def tbptt_split_batch(self, batch, split_size):
             Called in the training loop after
             :meth:`~pytorch_lightning.callbacks.base.Callback.on_batch_start`
             if :paramref:`~pytorch_lightning.core.lightning.LightningModule.truncated_bptt_steps` > 0
-            or :paramref:`~pytorch_lightning.trainer.Trainer.truncated_bptt_steps` > 0
 
             Each returned batch split is passed separately to :meth:`training_step`.
 
@@ -1564,7 +1562,7 @@ def get_progress_bar_dict(self):
         if avg_training_loss is not None:
             tqdm_dict["loss"] = f"{avg_training_loss:.3g}"
 
-        module_tbptt_enabled = self.truncated_bptt_steps is not None and self.truncated_bptt_steps > 0
+        module_tbptt_enabled = self.truncated_bptt_steps > 0
         trainer_tbptt_enabled = self.trainer.truncated_bptt_steps is not None and self.trainer.truncated_bptt_steps > 0
         if module_tbptt_enabled or trainer_tbptt_enabled:
             tqdm_dict["split_idx"] = self.trainer.split_idx

pytorch_lightning/trainer/trainer.py

@@ -279,9 +279,8 @@ def __init__(
 
             track_grad_norm: -1 no tracking. Otherwise tracks that p-norm. May be set to 'inf' infinity-norm.
 
-            truncated_bptt_steps: Truncated back prop breaks performs backprop every k steps of much longer
-                sequence. This argument has been moved to LightningModule. It is deprecated here in v1.3 and
-                will be removed in v1.5.
+            truncated_bptt_steps: Deprecated in v1.3 to be removed in 1.5.
+                Please use :paramref:`~pytorch_lightning.core.lightning.LightningModule.truncated_bptt_steps` instead.
 
             val_check_interval: How often to check the validation set. Use float to check within a training epoch,
                 use int to check every n steps (batches).

pytorch_lightning/trainer/training_loop.py

@@ -885,16 +885,18 @@ def build_train_args(self, batch, batch_idx, opt_idx, hiddens):
     def _truncated_bptt_enabled(self) -> bool:
         """ Temporary tbptt utilities until this flag is fully migrated to the lightning module. """
         module = self.trainer.lightning_module
-        module_tbptt_enabled = module.truncated_bptt_steps is not None and module.truncated_bptt_steps > 0
+        module_tbptt_enabled = module.truncated_bptt_steps > 0
+        if module_tbptt_enabled:
+            return True
 
         trainer = self.trainer
         trainer_tbptt_enabled = trainer.truncated_bptt_steps is not None and trainer.truncated_bptt_steps > 0
-        return module_tbptt_enabled or trainer_tbptt_enabled
+        return trainer_tbptt_enabled
 
     def _truncated_bptt_steps(self) -> Optional[int]:
         lightning_module = self.trainer.lightning_module
         # Give precedence to the LightningModule as the Trainer flag will be removed in v1.5
-        if lightning_module.truncated_bptt_steps is not None and lightning_module.truncated_bptt_steps > 0:
+        if lightning_module.truncated_bptt_steps > 0:
             return lightning_module.truncated_bptt_steps
         return self.trainer.truncated_bptt_steps