lsst.scarlet.lite.parameters Namespace Reference

Classes
class	AdaproxParameter
class	FistaParameter
class	FixedParameter
class	Parameter
class	SingleItemArray

Functions
Callable	step_function_wrapper (float step)
Parameter	parameter (np.ndarray|Parameter x)
	_adam_phi_psi (it, g, m, v, vhat, b1, b2, eps, p)
	_nadam_phi_psi (it, g, m, v, vhat, b1, b2, eps, p)
	_amsgrad_phi_psi (it, g, m, v, vhat, b1, b2, eps, p)
	_padam_phi_psi (it, g, m, v, vhat, b1, b2, eps, p)
	_adamx_phi_psi (it, g, m, v, vhat, b1, b2, eps, p)
	_radam_phi_psi (it, g, m, v, vhat, b1, b2, eps, p)
	relative_step (np.ndarray x, float factor=0.1, float minimum=0, int|Sequence[int]|None axis=None)

Variables
int	DEFAULT_ADAPROX_FACTOR = 1e-2
dict	phi_psi

Function Documentation

_adam_phi_psi()

lsst.scarlet.lite.parameters._adam_phi_psi ( it, g, m, v, vhat, b1, b2, eps, p )

protected

Definition at line 240 of file parameters.py.

def _adam_phi_psi(it, g, m, v, vhat, b1, b2, eps, p):
    # moving averages
    m[:] = (1 - b1[it]) * g + b1[it] * m
    v[:] = (1 - b2) * (g**2) + b2 * v
 
    # bias correction
    t = it + 1
    phi = m / (1 - b1[it] ** t)
    psi = np.sqrt(v / (1 - b2**t)) + eps
    return phi, psi
 
 
# noinspection PyUnusedLocal

_adamx_phi_psi()

lsst.scarlet.lite.parameters._adamx_phi_psi ( it, g, m, v, vhat, b1, b2, eps, p )

protected

Definition at line 295 of file parameters.py.

def _adamx_phi_psi(it, g, m, v, vhat, b1, b2, eps, p):
    # moving averages
    m[:] = (1 - b1[it]) * g + b1[it] * m
    v[:] = (1 - b2) * (g**2) + b2 * v
 
    phi = m
    factor = (1 - b1[it]) ** 2 / (1 - b1[it - 1]) ** 2
    vhat[:] = np.maximum(factor * vhat, v)
    # sanitize zero-gradient elements
    if eps > 0:
        vhat = np.maximum(vhat, eps)
    psi = np.sqrt(vhat)
    return phi, psi
 
 
# noinspection PyUnusedLocal

_amsgrad_phi_psi()

lsst.scarlet.lite.parameters._amsgrad_phi_psi ( it, g, m, v, vhat, b1, b2, eps, p )

protected

Definition at line 266 of file parameters.py.

def _amsgrad_phi_psi(it, g, m, v, vhat, b1, b2, eps, p):
    # moving averages
    m[:] = (1 - b1[it]) * g + b1[it] * m
    v[:] = (1 - b2) * (g**2) + b2 * v
 
    phi = m
    vhat[:] = np.maximum(vhat, v)
    # sanitize zero-gradient elements
    if eps > 0:
        vhat = np.maximum(vhat, eps)
    psi = np.sqrt(vhat)
    return phi, psi
 
 

_nadam_phi_psi()

lsst.scarlet.lite.parameters._nadam_phi_psi ( it, g, m, v, vhat, b1, b2, eps, p )

protected

Definition at line 253 of file parameters.py.

def _nadam_phi_psi(it, g, m, v, vhat, b1, b2, eps, p):
    # moving averages
    m[:] = (1 - b1[it]) * g + b1[it] * m
    v[:] = (1 - b2) * (g**2) + b2 * v
 
    # bias correction
    t = it + 1
    phi = (b1[it] * m[:] + (1 - b1[it]) * g) / (1 - b1[it] ** t)
    psi = np.sqrt(v / (1 - b2**t)) + eps
    return phi, psi
 
 
# noinspection PyUnusedLocal

_padam_phi_psi()

lsst.scarlet.lite.parameters._padam_phi_psi ( it, g, m, v, vhat, b1, b2, eps, p )

protected

Definition at line 280 of file parameters.py.

def _padam_phi_psi(it, g, m, v, vhat, b1, b2, eps, p):
    # moving averages
    m[:] = (1 - b1[it]) * g + b1[it] * m
    v[:] = (1 - b2) * (g**2) + b2 * v
 
    phi = m
    vhat[:] = np.maximum(vhat, v)
    # sanitize zero-gradient elements
    if eps > 0:
        vhat = np.maximum(vhat, eps)
    psi = vhat**p
    return phi, psi
 
 
# noinspection PyUnusedLocal

_radam_phi_psi()

lsst.scarlet.lite.parameters._radam_phi_psi ( it, g, m, v, vhat, b1, b2, eps, p )

protected

Definition at line 311 of file parameters.py.

def _radam_phi_psi(it, g, m, v, vhat, b1, b2, eps, p):
    rho_inf = 2 / (1 - b2) - 1
 
    # moving averages
    m[:] = (1 - b1[it]) * g + b1[it] * m
    v[:] = (1 - b2) * (g**2) + b2 * v
 
    # bias correction
    t = it + 1
    phi = m / (1 - b1[it] ** t)
    rho = rho_inf - 2 * t * b2**t / (1 - b2**t)
 
    if rho > 4:
        psi = np.sqrt(v / (1 - b2**t))
        r = np.sqrt((rho - 4) * (rho - 2) * rho_inf / (rho_inf - 4) / (rho_inf - 2) / rho)
        psi /= r
    else:
        psi = np.ones(g.shape, g.dtype)
    # sanitize zero-gradient elements
    if eps > 0:
        psi = np.maximum(psi, np.sqrt(eps))
    return phi, psi
 
 
# Dictionary to link ADAM variation names to their functional algorithms.

parameter()

Parameter lsst.scarlet.lite.parameters.parameter

(

np.ndarray | Parameter

x

)

Convert a `np.ndarray` into a `Parameter`.

Parameters
----------
x:
    The array or parameter to convert into a `Parameter`.

Returns
-------
result:
    `x`, converted into a `Parameter` if necessary.

Definition at line 165 of file parameters.py.

def parameter(x: np.ndarray | Parameter) -> Parameter:
    """Convert a `np.ndarray` into a `Parameter`.
 
    Parameters
    ----------
    x:
        The array or parameter to convert into a `Parameter`.
 
    Returns
    -------
    result:
        `x`, converted into a `Parameter` if necessary.
    """
    if isinstance(x, Parameter):
        return x
    return Parameter(x, {}, 0)
 
 

relative_step()

lsst.scarlet.lite.parameters.relative_step	(	np.ndarray	x,
		float	factor = 0.1,
		float	minimum = 0,
		int | Sequence[int] | None	axis = None )

Step size set at `factor` times the mean of `X` in direction `axis`

Definition at line 464 of file parameters.py.

):
    """Step size set at `factor` times the mean of `X` in direction `axis`"""
    return np.maximum(minimum, factor * x.mean(axis=axis))

step_function_wrapper()

Callable lsst.scarlet.lite.parameters.step_function_wrapper

(

float

step

)

Wrapper to make a numerical step into a step function

Parameters
----------
step:
    The step to take for a given array.

Returns
-------
step_function:
    The step function that takes an array and returns the
    numerical step.

Definition at line 46 of file parameters.py.

def step_function_wrapper(step: float) -> Callable:
    """Wrapper to make a numerical step into a step function
 
    Parameters
    ----------
    step:
        The step to take for a given array.
 
    Returns
    -------
    step_function:
        The step function that takes an array and returns the
        numerical step.
    """
    return lambda x: step
 
 

Variable Documentation

DEFAULT_ADAPROX_FACTOR

int lsst.scarlet.lite.parameters.DEFAULT_ADAPROX_FACTOR = 1e-2

Definition at line 43 of file parameters.py.

phi_psi

dict lsst.scarlet.lite.parameters.phi_psi

Initial value:

=  {
    "adam": _adam_phi_psi,
    "nadam": _nadam_phi_psi,
    "amsgrad": _amsgrad_phi_psi,
    "padam": _padam_phi_psi,
    "adamx": _adamx_phi_psi,
    "radam": _radam_phi_psi,
}

Definition at line 336 of file parameters.py.