r"""Runs the full optimization routine. Args: model: Model to fit. train_dataloaders: An iterable or collection of i

Log a scalar to all loggers that were added to Fabric. Args: name: The name of the metric to log. value: The metric v

The current device this process runs on. Use this to create tensors directly on the device if needed.

Calls the registered strategy with the required parameters and returns the strategy object. Args: name (str): the name that ident

r"""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.

r"""Function that sets the seed for pseudo-random number generators in: torch, numpy, and Python's random module. In addition, sets the following

Launch and initialize all the processes needed for distributed execution. Args: function: Optional function to launch when using

Load a checkpoint from a file and restore the state of objects (modules, optimizers, etc.). How and which processes load gets determined by t

Save arguments to ``hparams`` attribute. Args: args: single object of `dict`, `NameSpace` or `OmegaConf` or strin

r"""Save checkpoint contents to a file. How and which processes save gets determined by the `strategy`. For example, the `ddp` strategy

r"""Set up a model and its optimizers for accelerated training. Args: module: A :class:`torch.nn.Module` to set up. *

r"""Run inference on your data. This will call the model forward function to compute predictions. Useful to perform distributed and batched pr

r"""Primary way of loading a model from a checkpoint. When Lightning saves a checkpoint it stores the arguments passed to ``__init__`` in the

r"""Perform one evaluation epoch over the validation set. Args: model: The model to validate. dataloaders: An iterab

r"""Runs routine to create a checkpoint. This method needs to be called on all processes in case the selected strategy is handling distribute

Called by the Trainer to connect the strategy with the model.

See :meth:`torch.nn.Module.cpu`.

r"""Send a tensor from one process to all others. This method needs to be called on all processes. Failing to do so will cause your program t

Call this directly from your :meth:`training_step` when doing optimizations manually. By using this, Lightning can ensure that all the proper

The LightningModule, but possibly wrapped into DataParallel or DistributedDataParallel. To access the pure LightningModule, use :meth

See :meth:`torch.nn.Module.float`.

r"""Set up one or multiple dataloaders for accelerated training. If you need different settings for each dataloader, call this method individu

Registers a strategy mapped to a name and with required metadata. Args: name : the name that identifies a strategy, e.g. "deepspe

r"""Replaces ``loss.backward()`` in your training loop. Handles precision automatically for you. Args: tensor: The tensor (loss)

Iteratively try to find the largest batch size for a given model that does not give an out of memory (OOM) error. Args: m

Instantiate the model and its parameters under this context manager to reduce peak memory usage. The parameters get created on the device and

Yields a context manager to encapsulate the scope of a profiled action. Example:: with self.profile('load training data'):

Wait for all processes to enter this call. Use this to synchronize all parallel processes, but only if necessary, otherwise the overhead of s

Enables the user to do a range test of good initial learning rates, to reduce the amount of guesswork in picking a good starting learning rate

Summarize the LightningModule specified by `lightning_module`. Args: lightning_module: `LightningModule` to summarize. max_depth

See :meth:`torch.nn.Module.to`.

Gather tensors or collections of tensors from multiple processes. This method needs to be called on all processes and the tensors need to hav

Log multiple scalars at once to all loggers that were added to Fabric. Args: metrics: A dictionary where the key is the name of t

r"""Helper function to seed everything without explicitly importing Lightning. See :func:`~lightning.fabric.utilities.seed.seed_everything` f

Loads the state of this loop and all its children.

Update throughput metrics. Args: time: Total elapsed time in seconds. It should monotonically increase by the iteration time with

This context manager is used to add support for re-instantiation of custom (subclasses) of `base_cls`. It patches the ``__init__``, ``__setattr__

MPS is only available on a machine with the ARM-based Apple Silicon processors.

Applies Lightning version migrations to a checkpoint dictionary. Args: checkpoint: A dictionary with the loaded state from the checkpoint

This will propose a suggestion for an initial learning rate based on the point with the steepest negative gradient. Args:

By default compiles the whole model to a ``torch.jit.ScriptModule``. If you want to use tracing, please provided the argument ``method='trace'

Transfers a collection of data to the given device. Any object that defines a method ``to(device)`` will be moved and all other objects in the col

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

Removes the registered strategy by name.

Set the version of a Lightning checkpoint.

r"""Set up one or more optimizers for accelerated training. Some strategies do not allow setting up model and optimizer independently. For th

A heuristic check to determine whether the path points to a directory with checkpoint shards.

Clip the gradients of the model to a given max value or max norm. Args: module: The module whose parameters should be clipped.

Logs a profile report after the conclusion of run.