tick.prox.ProxL2¶

class tick.prox.ProxL2(strength: float, range: tuple = None, positive: bool = False)[source]¶

Proximal operator of the L2 penalization. Do not mix up with ProxL2sq, which is regular ridge (squared L2) penalization. ProxL2 induces sparsity on the full vector, whenever the norm of it is small enough. This is mostly used in the ProxGroupL1 for group-lasso penalization.

Parameters

strength : float

Level of penalization. Note that in this proximal operator, strength is automatically multiplied by the square-root of end - start, when a range is used, or n_coeffs, when no range is used (size of the passed vector). This allows to consider strengths that have the same order as with ProxL1 or other separable proximal operators.

range : tuple of two int, default=`None`

Range on which the prox is applied. If None then the prox is applied on the whole vector

positive : bool, default=`False`

If True, apply L2 penalization together with a projection onto the set of vectors with non-negative entries

Attributes

dtype : {'float64', 'float32'}

Type of the arrays used.

__init__(strength: float, range: tuple = None, positive: bool = False)[source]¶

Initialize self. See help(type(self)) for accurate signature.

call(coeffs, step=1.0, out=None)¶

Apply proximal operator on a vector. It computes:

\[argmin_x \big( f(x) + \frac{1}{2} \|x - v\|_2^2 \big)\]

Parameters

coeffs : numpy.ndarray, shape=(n_coeffs,)

Input vector on which is applied the proximal operator

step : float or np.array, default=1.

The amount of penalization is multiplied by this amount

• If float, the amount of penalization is multiplied by this amount

• If np.array, then each coordinate of coeffs (within the given range), receives an amount of penalization multiplied by t (available only for separable prox)

out : numpy.ndarray, shape=(n_params,), default=None

If not None, the output is stored in the given out. Otherwise, a new vector is created.

Returns

output : numpy.ndarray, shape=(n_coeffs,)

Same object as out

Notes

step must have the same size as coeffs whenever range is None, or a size matching the one given by the range otherwise

value(coeffs: numpy.ndarray)[source]¶

Returns the value of the penalization at coeffs

Parameters

coeffs : numpy.ndarray, shape=(n_coeffs,)

The value of the penalization is computed at this point

Returns

output : float

Value of the penalization at coeffs