Class L2

source code

               object --+        
                        |        
      properties.Function --+    
                            |    
    properties.AtomicFunction --+
                                |
                   object --+   |
                            |   |
           properties.Penalty --+
                                |
                   object --+   |
                            |   |
        properties.Constraint --+
                                |
                   object --+   |
                            |   |
  properties.ProximalOperator --+
                                |
                   object --+   |
                            |   |
properties.ProjectionOperator --+
                                |
                               L2

The proximal operator of the L2 function with a penalty formulation

    f(eta) = l * (0.5 * ||eta||_2 - c),

where ||eta||_2 is the L2 loss function. The constrained version has
the form

    0.5 * ||eta||_2 <= c.

Parameters
----------
l : Non-negative float. The Lagrange multiplier, or regularisation
        constant, of the function.

c : Float. The limit of the constraint. The function is feasible if
        0.5 * ||eta||_2 <= c. The default value is c=0, i.e. the
        default is a regularised formulation.

penalty_start : Non-negative integer. The number of columns, variables
        etc., to be exempt from penalisation. Equivalently, the first index
        to be penalised. Default is 0, all columns are included.

The corresponding projection operator.

From the interface "ProjectionOperator".

Examples
--------
>>> import numpy as np
>>> from parsimony.functions.penalties import L2
>>> np.random.seed(42)
>>> l2 = L2(c=0.3183098861837907)
>>> y1 = l2.proj(np.random.rand(100, 1) * 2.0 - 1.0)
>>> round(np.linalg.norm(y1), 15)
0.318309886183791
>>> y2 = np.random.rand(100, 1) * 2.0 - 1.0
>>> l2.feasible(y2)
False
>>> l2.feasible(l2.proj(y2))
True

Feasibility of the constraint.

From the interface "Constraint".

Parameters
----------
beta : Numpy array. The variable to check for feasibility.

Examples
--------
>>> import numpy as np
>>> from parsimony.functions.penalties import L2
>>> np.random.seed(42)
>>> l2 = L2(c=0.3183098861837907)
>>> y1 = 0.01 * (np.random.rand(50, 1) * 2.0 - 1.0)
>>> l2.feasible(y1)
True
>>> y2 = 10.0 * (np.random.rand(50, 1) * 2.0 - 1.0)
>>> l2.feasible(y2)
False
>>> y3 = l2.proj(50.0 * np.random.rand(100, 1) * 2.0 - 1.0)
>>> l2.feasible(y3)
True