TICK-367

Author: Stephane Gaiffas

setup.py

@@ -535,6 +535,7 @@ def add_dir_name(dir_name, filenames):
                   "prox_multi.cpp",
                   "prox_equality.cpp",
                   "prox_slope.cpp",
+                  "prox_oscar.cpp",
                   "prox_binarsity.cpp"],
     "h_files": ["prox.h",
                 "prox_separable.h",
@@ -549,6 +550,7 @@ def add_dir_name(dir_name, filenames):
                 "prox_multi.h",
                 "prox_equality.h",
                 "prox_slope.h",
+                "prox_oscar.h",
                 "prox_binarsity.h"],
     "swig_files": ["prox_module.i"],
     "module_dir": "./tick/optim/prox/",

tick/optim/prox/prox_oscar.py

@@ -1,48 +1,36 @@
 # License: BSD 3 clause
 
-# -*- coding: utf8 -*-
-
 from tick.optim.prox.base import Prox
 import numpy as np
 
-from tick.optim.prox.build.prox import ProxSortedL1 as _ProxSortedL1
-from tick.optim.prox.build.prox import WeightsType_bh, \
-    WeightsType_oscar
-
-
-# TODO: put also the OSCAR weights
-# TODO: we should be able to put any weights we want...
+from tick.optim.prox.build.prox import ProxOscar as _ProxOscar
 
 
-class ProxSortedL1(Prox):
-    """Proximal operator of sorted L1 penalization
+class ProxOscar(Prox):
+    """Proximal operator the oscar penalization.
+    This penalization is particularly relevant for feature selection, in
+    generalized linear models, when features correlation is not too high.
 
     Parameters
     ----------
     strength : `float`
         Level of penalization
 
-    fdr : `float`, default=0.6
-        Desired False Discovery Rate for detection of non-zeros in
-        the coefficients
-
-    weights_type : "bh" | "oscar", default="bh"
-
-        * If "bh", we use Benjamini-Hochberg weights, under a Gaussian
-          error assumption, and expect a FDR control
-        * If "oscar", there is no FDR control, and we get the OSCAR
-          penalization, see notes below for references
+    # TODO: clean this docstring
+    ratio : `float`, default=0
+        The Oscar mixing parameter, with 0 <= ratio <= 1.
+        For ratio = 0 this is ridge (L2) regularization
+        For ratio = 1 this is lasso (L1) regularization
+        For 0 < ratio < 1, the regularization is a linear combination
+        of L1 and L2.
 
     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
 
-    Attributes
-    ----------
-    weights : `np.array`, shape=(n_coeffs,)
-        The weights used in the penalization. They are automatically
-        setted, depending on the ``weights_type`` and ``fdr``
-        parameters.
+    positive : `bool`, default=`False`
+        If True, apply an extra projection onto the set of vectors with
+        non-negative entries
 
     Notes
     -----
@@ -58,59 +46,27 @@ class ProxSortedL1(Prox):
             "writable": True,
             "cpp_setter": "set_strength"
         },
-        "fdr": {
+        "ratio": {
             "writable": True,
-            "cpp_setter": "set_fdr"
-        },
-        "_weights_type": {
-            "writable": False,
-            "cpp_setter": "set_weights_type"
+            "cpp_setter": "set_ratio"
         },
         "positive": {
             "writable": True,
             "cpp_setter": "set_positive"
-        },
-        "weights": {
-            "writable": False,
         }
     }
 
-    def __init__(self, strength: float, fdr: float=0.6,
-                 weights_type: str="bh", range: tuple=None,
+    def __init__(self, strength: float, range: tuple=None,
                  positive: bool=False):
         Prox.__init__(self, range)
         self.strength = strength
-        self.fdr = fdr
-        self.weights_type = weights_type
         self.positive = positive
         self.weights = None
         if range is None:
-            self._prox = _ProxSortedL1(self.strength, self.fdr,
-                                       self._weights_type,
-                                       self.positive)
+            self._prox = _ProxOscar(self.strength, self.positive)
         else:
-            self._prox = _ProxSortedL1(self.strength, self.fdr,
-                                       self._weights_type,
-                                       self.range[0], self.range[1],
-                                       self.positive)
-
-    @property
-    def weights_type(self):
-        if self._weights_type == WeightsType_bh:
-            return "bh"
-        elif self._weights_type == WeightsType_oscar:
-            return "oscar"
-
-    @weights_type.setter
-    def weights_type(self, val):
-        if val == "bh":
-            self._set("_weights_type", WeightsType_bh)
-        elif val == "oscar":
-            self._set("_weights_type", WeightsType_oscar)
-            raise NotImplementedError("``oscar`` weights.")
-        else:
-            raise ValueError("``weights_type`` must be either 'bh' "
-                             "or 'oscar'")
+            self._prox = _ProxOscar(self.strength, self.range[0], self.range[1],
+                                    self.positive)
 
     def _call(self, coeffs: np.ndarray, t: float, out: np.ndarray):
         self._prox.call(coeffs, t, out)
@@ -130,8 +86,3 @@ def value(self, coeffs: np.ndarray) -> float:
             Value of the penalization at ``coeffs``
         """
         return self._prox.value(coeffs)
-
-    def _as_dict(self):
-        dd = Prox._as_dict(self)
-        del dd["weights"]
-        return dd

tick/optim/prox/prox_slope.py

@@ -25,12 +25,9 @@ class ProxSlope(Prox):
         Range on which the prox is applied. If `None` then the prox is
         applied on the whole vector
 
-    Attributes
-    ----------
-    weights : `np.array`, shape=(n_coeffs,)
-        The weights used in the penalization. They are automatically
-        setted, depending on the ``weights_type`` and ``fdr``
-        parameters.
+    positive : `bool`, default=`False`
+        If True, apply an extra projection onto the set of vectors with
+        non-negative entries
 
     Notes
     -----
@@ -53,9 +50,6 @@ class ProxSlope(Prox):
         "positive": {
             "writable": True,
             "cpp_setter": "set_positive"
-        },
-        "weights": {
-            "writable": False,
         }
     }
 
@@ -65,7 +59,6 @@ def __init__(self, strength: float, fdr: float=0.6, range: tuple=None,
         self.strength = strength
         self.fdr = fdr
         self.positive = positive
-        self.weights = None
         if range is None:
             self._prox = _ProxSlope(self.strength, self.fdr, self.positive)
         else:
@@ -91,8 +84,3 @@ def value(self, coeffs: np.ndarray) -> float:
             Value of the penalization at ``coeffs``
         """
         return self._prox.value(coeffs)
-
-    def _as_dict(self):
-        dd = Prox._as_dict(self)
-        del dd["weights"]
-        return dd

tick/optim/prox/src/CMakeLists.txt

@@ -8,6 +8,7 @@ add_library(tick_prox EXCLUDE_FROM_ALL
         prox_zero.cpp prox_zero.h
         prox_sorted_l1.cpp prox_sorted_l1.h
         prox_slope.cpp prox_slope.h
+        prox_oscar.cpp prox_oscar.h
         prox_tv.cpp prox_tv.h
         prox_l1w.cpp prox_l1w.h
         prox_elasticnet.cpp prox_elasticnet.h

tick/optim/prox/src/prox_oscar.cpp

@@ -0,0 +1,44 @@
+// License: BSD 3 clause
+
+#include "prox_oscar.h"
+
+ProxOscar::ProxOscar(double strength,
+                     double ratio,
+                     bool positive)
+  : ProxSortedL1(strength, WeightsType::bh, positive) {
+  this->ratio = ratio;
+}
+
+ProxOscar::ProxOscar(double strength,
+                     double ratio,
+                     ulong start,
+                     ulong end,
+                     bool positive)
+  : ProxSortedL1(strength, WeightsType::bh, start, end, positive) {
+  this->ratio = ratio;
+}
+
+const std::string ProxOscar::get_class_name() const {
+  return "ProxOscar";
+}
+
+void ProxOscar::compute_weights(void) {
+  if (!weights_ready) {
+    ulong size = end - start;
+    weights = ArrayDouble(size);
+    for (ulong i = 0; i < size; i++) {
+      // double tmp = false_discovery_rate / (2 * size);
+      // weights[i] = strength * standard_normal_inv_cdf(1 - tmp * (i + 1));
+      weights[i] = 0;
+    }
+    weights_ready = true;
+  }
+}
+
+double ProxOscar::get_ratio() const {
+  return ratio;
+}
+
+void ProxOscar::set_ratio(double ratio) {
+  this->ratio = ratio;
+}

tick/optim/prox/src/prox_oscar.h

@@ -0,0 +1,29 @@
+// License: BSD 3 clause
+
+#ifndef TICK_OPTIM_PROX_SRC_PROX_OSCAR_H_
+#define TICK_OPTIM_PROX_SRC_PROX_OSCAR_H_
+
+#include "prox_sorted_l1.h"
+
+class ProxOscar : public ProxSortedL1 {
+ protected:
+  void compute_weights(void) override;
+  double ratio;
+
+ public:
+  ProxOscar(double strength, double false_discovery_rate, bool positive);
+
+  ProxOscar(double strength,
+            double false_discovery_rate,
+            ulong start,
+            ulong end,
+            bool positive);
+
+  const std::string get_class_name() const override;
+
+  virtual double get_ratio() const;
+
+  virtual void set_ratio(double ratio);
+};
+
+#endif  // TICK_OPTIM_PROX_SRC_PROX_OSCAR_H_

tick/optim/prox/swig/prox_module.i

@@ -15,6 +15,7 @@
 %shared_ptr(ProxTV);
 %shared_ptr(ProxElasticNet);
 %shared_ptr(ProxSlope);
+%shared_ptr(ProxOscar);
 %shared_ptr(ProxMulti);
 %shared_ptr(ProxEquality);
 %shared_ptr(ProxBinarsity);
@@ -45,8 +46,10 @@
 
 %include prox_slope.i
 
+%include prox_oscar.i
+
 %include prox_multi.i
 
 %include prox_equality.i
 
-%include prox_binarsity.i
+%include prox_binarsity.i

tick/optim/prox/swig/prox_oscar.i

@@ -0,0 +1,16 @@
+// License: BSD 3 clause
+
+%{
+#include "prox_oscar.h"
+%}
+
+class ProxOscar : public Prox {
+ public:
+   ProxOscar(double strength, double ratio, bool positive);
+
+   ProxOscar(double strength, double ratio, unsigned long start, unsigned long end, bool positive);
+
+   virtual double get_ratio() const final;
+
+   virtual void set_ratio(double ratio) final;
+};