LightningIRTrainer

Bases: Trainer

Customize every aspect of training via flags.

Parameters:

accelerator – Supports passing different accelerator types (“cpu”, “gpu”, “tpu”, “hpu”, “mps”, “auto”) as well as custom accelerator instances.
strategy – Supports different training strategies with aliases as well custom strategies. Default: "auto".
devices – The devices to use. Can be set to a positive number (int or str), a sequence of device indices (list or str), the value -1 to indicate all available devices should be used, or "auto" for automatic selection based on the chosen accelerator. Default: "auto".
num_nodes – Number of GPU nodes for distributed training. Default: 1.
precision – Double precision (64, ‘64’ or ‘64-true’), full precision (32, ‘32’ or ‘32-true’), 16bit mixed precision (16, ‘16’, ‘16-mixed’) or bfloat16 mixed precision (‘bf16’, ‘bf16-mixed’). Can be used on CPU, GPU, TPUs, or HPUs. Default: '32-true'.
logger – Logger (or iterable collection of loggers) for experiment tracking. A True value uses the default TensorBoardLogger if it is installed, otherwise CSVLogger. False will disable logging. If multiple loggers are provided, local files (checkpoints, profiler traces, etc.) are saved in the log_dir of the first logger. Default: True.
callbacks – Add a callback or list of callbacks. Default: None.
fast_dev_run – Runs n if set to n (int) else 1 if set to True batch(es) of train, val and test to find any bugs (ie: a sort of unit test). Default: False.
max_epochs – Stop training once this number of epochs is reached. Disabled by default (None). If both max_epochs and max_steps are not specified, defaults to max_epochs = 1000. To enable infinite training, set max_epochs = -1.
min_epochs – Force training for at least these many epochs. Disabled by default (None).
max_steps – Stop training after this number of steps. Disabled by default (-1). If max_steps = -1 and max_epochs = None, will default to max_epochs = 1000. To enable infinite training, set max_epochs to -1.
min_steps – Force training for at least these number of steps. Disabled by default (None).
max_time – Stop training after this amount of time has passed. Disabled by default (None). The time duration can be specified in the format DD:HH:MM:SS (days, hours, minutes seconds), as a datetime.timedelta, or a dictionary with keys that will be passed to datetime.timedelta.
limit_train_batches – How much of training dataset to check (float = fraction, int = num_batches). Default: 1.0.
limit_val_batches – How much of validation dataset to check (float = fraction, int = num_batches). Default: 1.0.
limit_test_batches – How much of test dataset to check (float = fraction, int = num_batches). Default: 1.0.
limit_predict_batches – How much of prediction dataset to check (float = fraction, int = num_batches). Default: 1.0.
overfit_batches – Overfit a fraction of training/validation data (float) or a set number of batches (int). Default: 0.0.
val_check_interval – How often to check the validation set. Pass a float in the range [0.0, 1.0] to check after a fraction of the training epoch. Pass an int to check after a fixed number of training batches. An int value can only be higher than the number of training batches when check_val_every_n_epoch=None, which validates after every N training batches across epochs or during iteration-based training. Default: 1.0.
check_val_every_n_epoch – Perform a validation loop after every N training epochs. If None, validation will be done solely based on the number of training batches, requiring val_check_interval to be an integer value. Default: 1.
num_sanity_val_steps – Sanity check runs n validation batches before starting the training routine. Set it to -1 to run all batches in all validation dataloaders. Default: 2.
log_every_n_steps – How often to log within steps. Default: 50.
enable_checkpointing – If True, enable checkpointing. It will configure a default ModelCheckpoint callback if there is no user-defined ModelCheckpoint in :paramref:`~lightning.pytorch.trainer.trainer.Trainer.callbacks`. Default: True.
enable_progress_bar – Whether to enable to progress bar by default. Default: True.
enable_model_summary – Whether to enable model summarization by default. Default: True.
accumulate_grad_batches – Accumulates gradients over k batches before stepping the optimizer. Default: 1.
gradient_clip_val – The value at which to clip gradients. Passing gradient_clip_val=None disables gradient clipping. If using Automatic Mixed Precision (AMP), the gradients will be unscaled before. Default: None.
gradient_clip_algorithm – The gradient clipping algorithm to use. Pass gradient_clip_algorithm="value" to clip by value, and gradient_clip_algorithm="norm" to clip by norm. By default it will be set to "norm".
deterministic – If True, sets whether PyTorch operations must use deterministic algorithms. Set to "warn" to use deterministic algorithms whenever possible, throwing warnings on operations that don’t support deterministic mode. If not set, defaults to False. Default: None.
benchmark – The value (True or False) to set torch.backends.cudnn.benchmark to. The value for torch.backends.cudnn.benchmark set in the current session will be used (False if not manually set). If :paramref:`~lightning.pytorch.trainer.trainer.Trainer.deterministic` is set to True, this will default to False. Override to manually set a different value. Default: None.
inference_mode – Whether to use torch.inference_mode() or torch.no_grad() during evaluation (validate/test/predict).
use_distributed_sampler – Whether to wrap the DataLoader’s sampler with torch.utils.data.DistributedSampler. If not specified this is toggled automatically for strategies that require it. By default, it will add shuffle=True for the train sampler and shuffle=False for validation/test/predict samplers. If you want to disable this logic, you can pass False and add your own distributed sampler in the dataloader hooks. If True and a distributed sampler was already added, Lightning will not replace the existing one. For iterable-style datasets, we don’t do this automatically.
profiler – To profile individual steps during training and assist in identifying bottlenecks. Default: None.
detect_anomaly – Enable anomaly detection for the autograd engine. Default: False.
barebones – Whether to run in “barebones mode”, where all features that may impact raw speed are disabled. This is meant for analyzing the Trainer overhead and is discouraged during regular training runs. The following features are deactivated: :paramref:`~lightning.pytorch.trainer.trainer.Trainer.enable_checkpointing`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.logger`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.enable_progress_bar`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.log_every_n_steps`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.enable_model_summary`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.num_sanity_val_steps`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.fast_dev_run`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.detect_anomaly`, :paramref:`~lightning.pytorch.trainer.trainer.Trainer.profiler`, log(), log_dict().
plugins – Plugins allow modification of core behavior like ddp and amp, and enable custom lightning plugins. Default: None.
sync_batchnorm – Synchronize batch norm layers between process groups/whole world. Default: False.
reload_dataloaders_every_n_epochs – Set to a positive integer to reload dataloaders every n epochs. Default: 0.
default_root_dir – Default path for logs and weights when no logger/ckpt_callback passed. Default: os.getcwd(). Can be remote file paths such as s3://mybucket/path or ‘hdfs://path/’

Raises:

TypeError – If gradient_clip_val is not an int or float.
MisconfigurationException – If gradient_clip_algorithm is invalid.

Methods

`__init__`(*[, accelerator, strategy, ...])	Customize every aspect of training via flags.
`fit`(model[, train_dataloaders, ...])	Runs the full optimization routine.
`index`([model, dataloaders, ckpt_path, ...])	Index a collection of documents.
`init_module`([empty_init])	Tensors that you instantiate under this context manager will be created on the device right away and have the right data type depending on the precision setting in the Trainer.
`predict`([model, dataloaders, datamodule, ...])	Run inference on your data.
`print`(args, *kwargs)	Print something only on the first process.
`re_rank`([model, dataloaders, ckpt_path, ...])	Re-rank a set of retrieved documents.
`save_checkpoint`(filepath[, weights_only, ...])	Runs routine to create a checkpoint.
`search`([model, dataloaders, ckpt_path, ...])	Search for relevant documents.
`test`([model, dataloaders, ckpt_path, ...])	Perform one evaluation epoch over the test set.
`validate`([model, dataloaders, ckpt_path, ...])	Perform one evaluation epoch over the validation set.

Attributes

`accelerator`
`callback_metrics`	The metrics available to callbacks.
`checkpoint_callback`	The first `ModelCheckpoint` callback in the Trainer.callbacks list, or `None` if it doesn't exist.
`checkpoint_callbacks`	A list of all instances of `ModelCheckpoint` found in the Trainer.callbacks list.
`ckpt_path`	Set to the path/URL of a checkpoint loaded via `fit()`, `validate()`, `test()`, or `predict()`.
`current_epoch`	The current epoch, updated after the epoch end hooks are run.
`default_root_dir`	The default location to save artifacts of loggers, checkpoints etc.
`device_ids`	List of device indexes per node.
`distributed_sampler_kwargs`
`early_stopping_callback`	The first `EarlyStopping` callback in the Trainer.callbacks list, or `None` if it doesn't exist.
`early_stopping_callbacks`	A list of all instances of `EarlyStopping` found in the Trainer.callbacks list.
`enable_validation`	Check if we should run validation during training.
`estimated_stepping_batches`	The estimated number of batches that will `optimizer.step()` during training.
`evaluating`
`global_rank`
`global_step`	The number of optimizer steps taken (does not reset each epoch).
`interrupted`
`is_global_zero`	Whether this process is the global zero in multi-node training.
`is_last_batch`	Whether trainer is executing the last batch.
`lightning_module`
`local_rank`
`log_dir`	The directory for the current experiment.
`logged_metrics`	The metrics sent to the loggers.
`logger`	The first `Logger` being used.
`loggers`	The list of `Logger` used.
`lr_scheduler_configs`
`max_epochs`
`max_steps`
`min_epochs`
`min_steps`
`model`	The LightningModule, but possibly wrapped into DataParallel or DistributedDataParallel.
`node_rank`
`num_devices`	Number of devices the trainer uses per node.
`num_nodes`
`num_predict_batches`	The number of prediction batches that will be used during `trainer.predict()`.
`num_sanity_val_batches`	The number of validation batches that will be used during the sanity-checking part of `trainer.fit()`.
`num_test_batches`	The number of test batches that will be used during `trainer.test()`.
`num_training_batches`	The number of training batches that will be used during `trainer.fit()`.
`num_val_batches`	The number of validation batches that will be used during `trainer.fit()` or `trainer.validate()`.
`optimizers`
`precision`
`precision_plugin`
`predict_dataloaders`	The prediction dataloader(s) used during `trainer.predict()`.
`predicting`
`progress_bar_callback`	An instance of `ProgressBar` found in the Trainer.callbacks list, or `None` if one doesn't exist.
`progress_bar_metrics`	The metrics sent to the progress bar.
`received_sigterm`	Whether a `signal.SIGTERM` signal was received.
`sanity_checking`	Whether sanity checking is running.
`scaler`
`strategy`
`test_dataloaders`	The test dataloader(s) used during `trainer.test()`.
`testing`
`train_dataloader`	The training dataloader(s) used during `trainer.fit()`.
`training`
`val_dataloaders`	The validation dataloader(s) used during `trainer.fit()` or `trainer.validate()`.
`validating`
`world_size`

property callback_metrics: dict[str, Tensor]

The metrics available to callbacks.

def training_step(self, batch, batch_idx):
    self.log("a_val", 2.0)


callback_metrics = trainer.callback_metrics
assert callback_metrics["a_val"] == 2.0

property checkpoint_callback: Checkpoint | None: The first ModelCheckpoint callback in the Trainer.callbacks list, or None if it doesn’t exist.

property checkpoint_callbacks: list[Checkpoint]: A list of all instances of ModelCheckpoint found in the Trainer.callbacks list.

property ckpt_path: str | Path | None

Set to the path/URL of a checkpoint loaded via fit(), validate(), test(), or predict().

None otherwise.

property current_epoch: int: The current epoch, updated after the epoch end hooks are run.

property default_root_dir: str

The default location to save artifacts of loggers, checkpoints etc.

It is used as a fallback if logger or checkpoint callback do not define specific save paths.

property device_ids: list[int]: List of device indexes per node.

property early_stopping_callback: EarlyStopping | None: The first EarlyStopping callback in the Trainer.callbacks list, or None if it doesn’t exist.

property early_stopping_callbacks: list[EarlyStopping]: A list of all instances of EarlyStopping found in the Trainer.callbacks list.

property enable_validation: bool: Check if we should run validation during training.

property estimated_stepping_batches: int | float

The estimated number of batches that will optimizer.step() during training.

This accounts for gradient accumulation and the current trainer configuration. This might be used when setting up your training dataloader, if it hasn’t been set up already.

def configure_optimizers(self):
    optimizer = ...
    stepping_batches = self.trainer.estimated_stepping_batches
    scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=1e-3, total_steps=stepping_batches)
    return [optimizer], [scheduler]

Raises:: MisconfigurationException – If estimated stepping batches cannot be computed due to different accumulate_grad_batches at different epochs.

Runs the full optimization routine.

Parameters:

model – Model to fit.
train_dataloaders – An iterable or collection of iterables specifying training samples. Alternatively, a LightningDataModule that defines the train_dataloader hook.
val_dataloaders – An iterable or collection of iterables specifying validation samples.
datamodule – A LightningDataModule that defines the train_dataloader hook.
ckpt_path – Path/URL of the checkpoint from which training is resumed. Could also be one of two special keywords "last" and "hpc". If there is no checkpoint file at the path, an exception is raised.

Raises:

TypeError – If model is not LightningModule for torch version less than 2.0.0 and if model is not LightningModule or torch._dynamo.OptimizedModule for torch versions greater than or equal to 2.0.0 .

For more information about multiple dataloaders, see this section.

property global_step: int

The number of optimizer steps taken (does not reset each epoch).

This includes multiple optimizers (if enabled).

index(model: LightningModule | None = None, dataloaders: Any | LightningDataModule | None = None, ckpt_path: str | Path | None = None, verbose: bool = True, datamodule: LightningDataModule | None = None) → List[Mapping[str, float]][source]: Index a collection of documents.

init_module(empty_init: bool | None = None) → Generator

Tensors that you instantiate under this context manager will be created on the device right away and have the right data type depending on the precision setting in the Trainer.

The parameters and tensors get created on the device and with the right data type right away without wasting memory being allocated unnecessarily.

Parameters:: empty_init – Whether to initialize the model with empty weights (uninitialized memory). If None, the strategy will decide. Some strategies may not support all options. Set this to True if you are loading a checkpoint into a large model.

property is_global_zero: bool

Whether this process is the global zero in multi-node training.

def training_step(self, batch, batch_idx):
    if self.trainer.is_global_zero:
        print("in node 0, accelerator 0")

property is_last_batch: bool: Whether trainer is executing the last batch.

property log_dir: str | None

The directory for the current experiment. Use this to save images to, etc…

Note

You must call this on all processes. Failing to do so will cause your program to stall forever.

def training_step(self, batch, batch_idx):
    img = ...
    save_img(img, self.trainer.log_dir)

property logged_metrics: dict[str, Tensor]

The metrics sent to the loggers.

This includes metrics logged via log() with the :paramref:`~lightning.pytorch.core.LightningModule.log.logger` argument set.

property logger: Logger | None: The first Logger being used.

property loggers: list[Logger]

The list of Logger used.

for logger in trainer.loggers:
    logger.log_metrics({"foo": 1.0})

property model: Module | None

The LightningModule, but possibly wrapped into DataParallel or DistributedDataParallel.

To access the pure LightningModule, use lightning_module() instead.

property num_devices: int: Number of devices the trainer uses per node.

property num_predict_batches: list[int | float]: The number of prediction batches that will be used during trainer.predict().

property num_sanity_val_batches: list[int | float]: The number of validation batches that will be used during the sanity-checking part of trainer.fit().

property num_test_batches: list[int | float]: The number of test batches that will be used during trainer.test().

property num_training_batches: int | float: The number of training batches that will be used during trainer.fit().

property num_val_batches: list[int | float]: The number of validation batches that will be used during trainer.fit() or trainer.validate().

Run inference on your data. This will call the model forward function to compute predictions. Useful to perform distributed and batched predictions. Logging is disabled in the predict hooks.

Parameters:

model – The model to predict with.
dataloaders – An iterable or collection of iterables specifying predict samples. Alternatively, a LightningDataModule that defines the predict_dataloader hook.
datamodule – A LightningDataModule that defines the predict_dataloader hook.
return_predictions – Whether to return predictions. True by default except when an accelerator that spawns processes is used (not supported).
ckpt_path – Either "best", "last", "hpc" or path to the checkpoint you wish to predict. If None and the model instance was passed, use the current weights. Otherwise, the best model checkpoint from the previous trainer.fit call will be loaded if a checkpoint callback is configured.

For more information about multiple dataloaders, see this section.

Returns:

Returns a list of dictionaries, one for each provided dataloader containing their respective predictions.

Raises:

TypeError – If no model is passed and there was no LightningModule passed in the previous run. If model passed is not LightningModule or torch._dynamo.OptimizedModule.
MisconfigurationException – If both dataloaders and datamodule are passed. Pass only one of these.
RuntimeError – If a compiled model is passed and the strategy is not supported.

See Lightning inference section for more.

property predict_dataloaders: Any | None: The prediction dataloader(s) used during trainer.predict().

print(*args: Any, **kwargs: Any) → None

Print something only on the first process. If running on multiple machines, it will print from the first process in each machine.

Arguments passed to this method are forwarded to the Python built-in print() function.

property progress_bar_callback: ProgressBar | None: An instance of ProgressBar found in the Trainer.callbacks list, or None if one doesn’t exist.

property progress_bar_metrics: dict[str, float]

The metrics sent to the progress bar.

This includes metrics logged via log() with the :paramref:`~lightning.pytorch.core.LightningModule.log.prog_bar` argument set.

re_rank(model: LightningModule | None = None, dataloaders: Any | LightningDataModule | None = None, ckpt_path: str | Path | None = None, verbose: bool = True, datamodule: LightningDataModule | None = None) → List[Mapping[str, float]][source]: Re-rank a set of retrieved documents.

property received_sigterm: bool

Whether a signal.SIGTERM signal was received.

For example, this can be checked to exit gracefully.

property sanity_checking: bool

Whether sanity checking is running.

Useful to disable some hooks, logging or callbacks during the sanity checking.

save_checkpoint(filepath: str | Path, weights_only: bool = False, storage_options: Any | None = None) → None

Runs routine to create a checkpoint.

This method needs to be called on all processes in case the selected strategy is handling distributed checkpointing.

Parameters:

filepath – Path where checkpoint is saved.
weights_only – If True, will only save the model weights.
storage_options – parameter for how to save to storage, passed to CheckpointIO plugin

Raises:

AttributeError – If the model is not attached to the Trainer before calling this method.

search(model: LightningModule | None = None, dataloaders: Any | LightningDataModule | None = None, ckpt_path: str | Path | None = None, verbose: bool = True, datamodule: LightningDataModule | None = None) → List[Mapping[str, float]][source]: Search for relevant documents.

Perform one evaluation epoch over the test set. It’s separated from fit to make sure you never run on your test set until you want to.

Parameters:

model – The model to test.
dataloaders – An iterable or collection of iterables specifying test samples. Alternatively, a LightningDataModule that defines the test_dataloader hook.
ckpt_path – Either "best", "last", "hpc" or path to the checkpoint you wish to test. If None and the model instance was passed, use the current weights. Otherwise, the best model checkpoint from the previous trainer.fit call will be loaded if a checkpoint callback is configured.
verbose – If True, prints the test results.
datamodule – A LightningDataModule that defines the test_dataloader hook.

For more information about multiple dataloaders, see this section.

Returns:

List of dictionaries with metrics logged during the test phase, e.g., in model- or callback hooks like test_step() etc. The length of the list corresponds to the number of test dataloaders used.

Raises:

TypeError – If no model is passed and there was no LightningModule passed in the previous run. If model passed is not LightningModule or torch._dynamo.OptimizedModule.
MisconfigurationException – If both dataloaders and datamodule are passed. Pass only one of these.
RuntimeError – If a compiled model is passed and the strategy is not supported.

property test_dataloaders: Any | None: The test dataloader(s) used during trainer.test().

property train_dataloader: Any | None: The training dataloader(s) used during trainer.fit().

property val_dataloaders: Any | None: The validation dataloader(s) used during trainer.fit() or trainer.validate().

Perform one evaluation epoch over the validation set.

Parameters:

model – The model to validate.
dataloaders – An iterable or collection of iterables specifying validation samples. Alternatively, a LightningDataModule that defines the val_dataloader hook.
ckpt_path – Either "best", "last", "hpc" or path to the checkpoint you wish to validate. If None and the model instance was passed, use the current weights. Otherwise, the best model checkpoint from the previous trainer.fit call will be loaded if a checkpoint callback is configured.
verbose – If True, prints the validation results.
datamodule – A LightningDataModule that defines the val_dataloader hook.

For more information about multiple dataloaders, see this section.

Returns:

List of dictionaries with metrics logged during the validation phase, e.g., in model- or callback hooks like validation_step() etc. The length of the list corresponds to the number of validation dataloaders used.

Raises:

TypeError – If no model is passed and there was no LightningModule passed in the previous run. If model passed is not LightningModule or torch._dynamo.OptimizedModule.
MisconfigurationException – If both dataloaders and datamodule are passed. Pass only one of these.
RuntimeError – If a compiled model is passed and the strategy is not supported.