Class LinearRegressionL2SmoothedL1TV

source code

     object --+        
              |        
  BaseEstimator --+    
                  |    
RegressionEstimator --+
                      |
                     LinearRegressionL2SmoothedL1TV

Linear regression with L2 and simultaneously smoothed L1 and TV
penalties:

    f(beta, X, y) = (1 / (2 * n)) * ||Xbeta - y||²_2
                    + (l2 / 2) * ||beta||²_2
                    + L1TV(beta),

where L1TV is l1 * L1(beta) + tv * TV(beta) smoothed together by Nesterov's
smoothing.

Parameters
----------
l2 : Non-negative float. The Lagrange multiplier, or regularisation
        constant, for the ridge (L2) penalty.

l1 : Non-negative float. The Lagrange multiplier, or regularisation
        constant, for the L1 penalty.

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

A : A list or tuple with 4 elements of (usually sparse) arrays. The linear
        operator for the smoothed L1+TV. The first element must be the
        linear operator for L1 and the following three for TV. May not be
        None.

algorithm : ExplicitAlgorithm. The algorithm that should be applied.
        Should be one of:
            1. ExcessiveGapMethod(...)

        Default is ExcessiveGapMethod(...).

algorithm_params : A dict. The dictionary algorithm_params contains
        parameters that should be set in the algorithm. Passing
        algorithm=ExcessiveGapMethod(**params) is equivalent to passing
        algorithm=ExcessiveGapMethod() and algorithm_params=params. Default
        is an empty dictionary.

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.

mean : Boolean. Whether to compute the squared loss or the mean squared
        loss. Default is True, the mean squared loss.

Examples
--------
>>> import numpy as np
>>> import parsimony.estimators as estimators
>>> import parsimony.algorithms.primaldual as primaldual
>>> import parsimony.functions.nesterov.l1tv as l1tv
>>> shape = (1, 4, 4)
>>> n = 10
>>> p = shape[0] * shape[1] * shape[2]
>>>
>>> np.random.seed(42)
>>> X = np.random.rand(n, p)
>>> y = np.random.rand(n, 1)
>>> l1 = 0.1  # L1 coefficient
>>> l2 = 0.9  # Ridge coefficient
>>> tv = 1.0  # TV coefficient
>>> A = l1tv.linear_operator_from_shape(shape, p, penalty_start=0)
>>> lr = estimators.LinearRegressionL2SmoothedL1TV(l2, l1, tv, A,
...                 algorithm=primaldual.ExcessiveGapMethod(),
...                 algorithm_params=dict(max_iter=1000),
...                 mean=False)
>>> res = lr.fit(X, y)
>>> error = lr.score(X, y)
>>> round(error, 14)
0.06837304969156