class

PolynomialLR

extends_LRScheduler

PolynomialLR(optimizer: Optimizer, total_iters: int = 5, power: float = 1.0, last_epoch: int = -1, verbose: bool = False, eta_min: float = 0.0)

source edit

Decay the learning rate using a polynomial function over a fixed number of steps.

The learning rate follows a polynomial decay from the base LR down to eta_min over total_iters epochs:

\eta_t = \begin{cases} (\eta_0 - \eta_{\min}) \left(1 - \dfrac{t}{T}\right)^{p} + \eta_{\min} & t < T \\ \eta_{\min} & t \ge T \end{cases}

where $T = \text{total\_iters}$ and $p = \text{power}$ .

Parameters

optimizerOptimizer

Wrapped optimizer.

total_itersint= 5

Number of epochs over which the decay runs (default: 5).

powerfloat= 1.0

Exponent of the polynomial. power=1 gives linear decay; power=2 gives quadratic decay (default: 1.0).

last_epochint= -1

The index of the last epoch (default: -1).

verbosebool= False

Print the updated LR after each step if True (default: False).

eta_minfloat= 0.0

Minimum learning rate reached at total_iters (default: 0.0).

Attributes

total_itersint

Decay period in epochs.

powerfloat

Polynomial exponent.

eta_minfloat

Lower bound on the learning rate.

Notes

power=1 (linear) is equivalent to LinearLR with start_factor=1 and end_factor=0. Higher powers produce a schedule that decays slowly at first and more steeply near the end.

Examples

>>> import lucid.nn as nn
>>> model = nn.Linear(4, 2)
>>> import lucid.optim as optim
>>> optimizer = optim.SGD(model.parameters(), lr=0.1)
>>> scheduler = optim.PolynomialLR(
...     optimizer, total_iters=100, power=2.0, eta_min=1e-5
... )
>>> for epoch in range(100):
...     optimizer.step()
...     scheduler.step()

Used by 1

lucid.optim

Constructors

dunder

init

→None

__init__(optimizer: Optimizer, total_iters: int = 5, power: float = 1.0, last_epoch: int = -1, verbose: bool = False, eta_min: float = 0.0)

source edit

Initialise the PolynomialLR. See the class docstring for parameter semantics.

Instance methods

get_lr

→list[float]

get_lr()

source edit

Compute the learning rate for each parameter group at the current step.

Returns

list[float]

One learning rate per param group, derived from the schedule formula documented in the class docstring.

>>> import lucid.nn as nn >>> model = nn.Linear(4, 2) >>> import lucid.optim as optim >>> optimizer = optim.SGD(model.parameters(), lr=0.1) >>> scheduler = optim.PolynomialLR( ... optimizer, total_iters=100, power=2.0, eta_min=1e-5 ... ) >>> for epoch in range(100): ... optimizer.step() ... scheduler.step()