hooks¶
Classes
Hooks to be used with Checkpointing. |
|
Hooks to be used for data related stuff. |
|
Hooks to be used in LightningModule. |
Various hooks to be used in the Lightning code.
-
class
pytorch_lightning.core.hooks.
CheckpointHooks
[source]¶ Bases:
object
Hooks to be used with Checkpointing.
-
on_load_checkpoint
(checkpoint)[source]¶ Called by Lightning to restore your model. If you saved something with
on_save_checkpoint()
this is your chance to restore this.Example:
def on_load_checkpoint(self, checkpoint): # 99% of the time you don't need to implement this method self.something_cool_i_want_to_save = checkpoint['something_cool_i_want_to_save']
Note
Lightning auto-restores global step, epoch, and train state including amp scaling. There is no need for you to restore anything regarding training.
- Return type
-
on_save_checkpoint
(checkpoint)[source]¶ Called by Lightning when saving a checkpoint to give you a chance to store anything else you might want to save.
Example:
def on_save_checkpoint(self, checkpoint): # 99% of use cases you don't need to implement this method checkpoint['something_cool_i_want_to_save'] = my_cool_pickable_object
Note
Lightning saves all aspects of training (epoch, global step, etc…) including amp scaling. There is no need for you to store anything about training.
- Return type
-
-
class
pytorch_lightning.core.hooks.
DataHooks
[source]¶ Bases:
object
Hooks to be used for data related stuff.
-
on_after_batch_transfer
(batch, dataloader_idx)[source]¶ Override to alter or apply batch augmentations to your batch after it is transferred to the device.
Warning
dataloader_idx
always returns 0, and will be updated to support the trueidx
in the future.Note
This hook only runs on single GPU training and DDP (no data-parallel). Data-Parallel support will come in near future.
- Parameters
- Returns
A batch of data
Example:
def on_after_batch_transfer(self, batch, dataloader_idx): batch['x'] = gpu_transforms(batch['x']) return batch
- Raises
MisconfigurationException – If using data-parallel,
Trainer(accelerator='dp')
.
-
on_before_batch_transfer
(batch, dataloader_idx)[source]¶ Override to alter or apply batch augmentations to your batch before it is transferred to the device.
Warning
dataloader_idx
always returns 0, and will be updated to support the true index in the future.Note
This hook only runs on single GPU training and DDP (no data-parallel). Data-Parallel support will come in near future.
- Parameters
- Returns
A batch of data
Example:
def on_before_batch_transfer(self, batch, dataloader_idx): batch['x'] = transforms(batch['x']) return batch
- Raises
MisconfigurationException – If using data-parallel,
Trainer(accelerator='dp')
.
-
predict_dataloader
()[source]¶ Implement one or multiple PyTorch DataLoaders for prediction.
It’s recommended that all data downloads and preparation happen in
prepare_data()
.Note
Lightning adds the correct sampler for distributed and arbitrary hardware There is no need to set it yourself.
- Return type
- Returns
Single or multiple PyTorch DataLoaders.
Note
In the case where you return multiple prediction dataloaders, the
predict()
will have an argumentdataloader_idx
which matches the order here.
-
prepare_data
()[source]¶ Use this to download and prepare data.
Warning
DO NOT set state to the model (use setup instead) since this is NOT called on every GPU in DDP/TPU
Example:
def prepare_data(self): # good download_data() tokenize() etc() # bad self.split = data_split self.some_state = some_other_state()
In DDP prepare_data can be called in two ways (using Trainer(prepare_data_per_node)):
Once per node. This is the default and is only called on LOCAL_RANK=0.
Once in total. Only called on GLOBAL_RANK=0.
Example:
# DEFAULT # called once per node on LOCAL_RANK=0 of that node Trainer(prepare_data_per_node=True) # call on GLOBAL_RANK=0 (great for shared file systems) Trainer(prepare_data_per_node=False)
This is called before requesting the dataloaders:
model.prepare_data() if ddp/tpu: init() model.setup(stage) model.train_dataloader() model.val_dataloader() model.test_dataloader()
- Return type
-
test_dataloader
()[source]¶ Implement one or multiple PyTorch DataLoaders for testing.
The dataloader you return will not be called every epoch unless you set
reload_dataloaders_every_epoch
toTrue
.For data processing use the following pattern:
download in
prepare_data()
process and split in
setup()
However, the above are only necessary for distributed processing.
Warning
do not assign state in prepare_data
fit()
…
setup()
Note
Lightning adds the correct sampler for distributed and arbitrary hardware. There is no need to set it yourself.
- Return type
- Returns
Single or multiple PyTorch DataLoaders.
Example:
def test_dataloader(self): transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (1.0,))]) dataset = MNIST(root='/path/to/mnist/', train=False, transform=transform, download=True) loader = torch.utils.data.DataLoader( dataset=dataset, batch_size=self.batch_size, shuffle=False ) return loader # can also return multiple dataloaders def test_dataloader(self): return [loader_a, loader_b, ..., loader_n]
Note
If you don’t need a test dataset and a
test_step()
, you don’t need to implement this method.Note
In the case where you return multiple test dataloaders, the
test_step()
will have an argumentdataloader_idx
which matches the order here.
-
train_dataloader
()[source]¶ Implement one or more PyTorch DataLoaders for training.
- Return type
- Returns
Either a single PyTorch
DataLoader
or a collection of these (list, dict, nested lists and dicts). In the case of multiple dataloaders, please see this page
The dataloader you return will not be called every epoch unless you set
reload_dataloaders_every_epoch
toTrue
.For data processing use the following pattern:
download in
prepare_data()
process and split in
setup()
However, the above are only necessary for distributed processing.
Warning
do not assign state in prepare_data
fit()
…
setup()
Note
Lightning adds the correct sampler for distributed and arbitrary hardware. There is no need to set it yourself.
Example:
# single dataloader def train_dataloader(self): transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (1.0,))]) dataset = MNIST(root='/path/to/mnist/', train=True, transform=transform, download=True) loader = torch.utils.data.DataLoader( dataset=dataset, batch_size=self.batch_size, shuffle=True ) return loader # multiple dataloaders, return as list def train_dataloader(self): mnist = MNIST(...) cifar = CIFAR(...) mnist_loader = torch.utils.data.DataLoader( dataset=mnist, batch_size=self.batch_size, shuffle=True ) cifar_loader = torch.utils.data.DataLoader( dataset=cifar, batch_size=self.batch_size, shuffle=True ) # each batch will be a list of tensors: [batch_mnist, batch_cifar] return [mnist_loader, cifar_loader] # multiple dataloader, return as dict def train_dataloader(self): mnist = MNIST(...) cifar = CIFAR(...) mnist_loader = torch.utils.data.DataLoader( dataset=mnist, batch_size=self.batch_size, shuffle=True ) cifar_loader = torch.utils.data.DataLoader( dataset=cifar, batch_size=self.batch_size, shuffle=True ) # each batch will be a dict of tensors: {'mnist': batch_mnist, 'cifar': batch_cifar} return {'mnist': mnist_loader, 'cifar': cifar_loader}
-
transfer_batch_to_device
(batch, device=None)[source]¶ Override this hook if your
DataLoader
returns tensors wrapped in a custom data structure.The data types listed below (and any arbitrary nesting of them) are supported out of the box:
torch.Tensor
or anything that implements .to(…)torchtext.data.batch.Batch
For anything else, you need to define how the data is moved to the target device (CPU, GPU, TPU, …).
Note
This hook should only transfer the data and not modify it, nor should it move the data to any other device than the one passed in as argument (unless you know what you are doing).
Note
This hook only runs on single GPU training and DDP (no data-parallel). Data-Parallel support will come in near future.
- Parameters
- Return type
- Returns
A reference to the data on the new device.
Example:
def transfer_batch_to_device(self, batch, device): if isinstance(batch, CustomBatch): # move all tensors in your custom data structure to the device batch.samples = batch.samples.to(device) batch.targets = batch.targets.to(device) else: batch = super().transfer_batch_to_device(data, device) return batch
- Raises
MisconfigurationException – If using data-parallel,
Trainer(accelerator='dp')
.
See also
move_data_to_device()
apply_to_collection()
-
val_dataloader
()[source]¶ Implement one or multiple PyTorch DataLoaders for validation.
The dataloader you return will not be called every epoch unless you set
reload_dataloaders_every_epoch
toTrue
.It’s recommended that all data downloads and preparation happen in
prepare_data()
.Note
Lightning adds the correct sampler for distributed and arbitrary hardware There is no need to set it yourself.
- Return type
- Returns
Single or multiple PyTorch DataLoaders.
Examples:
def val_dataloader(self): transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (1.0,))]) dataset = MNIST(root='/path/to/mnist/', train=False, transform=transform, download=True) loader = torch.utils.data.DataLoader( dataset=dataset, batch_size=self.batch_size, shuffle=False ) return loader # can also return multiple dataloaders def val_dataloader(self): return [loader_a, loader_b, ..., loader_n]
Note
If you don’t need a validation dataset and a
validation_step()
, you don’t need to implement this method.Note
In the case where you return multiple validation dataloaders, the
validation_step()
will have an argumentdataloader_idx
which matches the order here.
-
-
class
pytorch_lightning.core.hooks.
ModelHooks
[source]¶ Bases:
object
Hooks to be used in LightningModule.
-
on_after_backward
()[source]¶ Called in the training loop after loss.backward() and before optimizers do anything. This is the ideal place to inspect or log gradient information.
Example:
def on_after_backward(self): # example to inspect gradient information in tensorboard if self.trainer.global_step % 25 == 0: # don't make the tf file huge for k, v in self.named_parameters(): self.logger.experiment.add_histogram( tag=k, values=v.grad, global_step=self.trainer.global_step )
- Return type
-
on_before_zero_grad
(optimizer)[source]¶ Called after optimizer.step() and before optimizer.zero_grad().
Called in the training loop after taking an optimizer step and before zeroing grads. Good place to inspect weight information with weights updated.
This is where it is called:
for optimizer in optimizers: optimizer.step() model.on_before_zero_grad(optimizer) # < ---- called here optimizer.zero_grad()
-
on_fit_end
()[source]¶ Called at the very end of fit. If on DDP it is called on every process
- Return type
-
on_fit_start
()[source]¶ Called at the very beginning of fit. If on DDP it is called on every process
- Return type
-
on_post_move_to_device
()[source]¶ Called in the
parameter_validation
decorator afterto()
is called. This is a good place to tie weights between modules after moving them to a device. Can be used when training models with weight sharing properties on TPU.Addresses the handling of shared weights on TPU: https://github.com/pytorch/xla/blob/master/TROUBLESHOOTING.md#xla-tensor-quirks
Example:
def on_post_move_to_device(self): self.decoder.weight = self.encoder.weight
- Return type
-
on_pretrain_routine_end
()[source]¶ Called at the end of the pretrain routine (between fit and train start).
fit
pretrain_routine start
pretrain_routine end
training_start
- Return type
-
on_pretrain_routine_start
()[source]¶ Called at the beginning of the pretrain routine (between fit and train start).
fit
pretrain_routine start
pretrain_routine end
training_start
- Return type
-
on_test_batch_end
(outputs, batch, batch_idx, dataloader_idx)[source]¶ Called in the test loop after the batch.
-
on_test_batch_start
(batch, batch_idx, dataloader_idx)[source]¶ Called in the test loop before anything happens for that batch.
-
on_test_epoch_start
()[source]¶ Called in the test loop at the very beginning of the epoch.
- Return type
-
on_train_batch_end
(outputs, batch, batch_idx, dataloader_idx)[source]¶ Called in the training loop after the batch.
-
on_train_batch_start
(batch, batch_idx, dataloader_idx)[source]¶ Called in the training loop before anything happens for that batch.
If you return -1 here, you will skip training for the rest of the current epoch.
-
on_train_end
()[source]¶ Called at the end of training before logger experiment is closed.
- Return type
-
on_train_epoch_end
(outputs)[source]¶ Called in the training loop at the very end of the epoch.
- Return type
-
on_train_epoch_start
()[source]¶ Called in the training loop at the very beginning of the epoch.
- Return type
-
on_validation_batch_end
(outputs, batch, batch_idx, dataloader_idx)[source]¶ Called in the validation loop after the batch.
-
on_validation_batch_start
(batch, batch_idx, dataloader_idx)[source]¶ Called in the validation loop before anything happens for that batch.
-
on_validation_epoch_end
()[source]¶ Called in the validation loop at the very end of the epoch.
- Return type
-
on_validation_epoch_start
()[source]¶ Called in the validation loop at the very beginning of the epoch.
- Return type
-
setup
(stage)[source]¶ Called at the beginning of fit and test. This is a good hook when you need to build models dynamically or adjust something about them. This hook is called on every process when using DDP.
Example:
class LitModel(...): def __init__(self): self.l1 = None def prepare_data(self): download_data() tokenize() # don't do this self.something = else def setup(stage): data = Load_data(...) self.l1 = nn.Linear(28, data.num_classes)
- Return type
-