opt module reorg

Author: idc9

ya_glm/backends/andersoncd/glm_solver.py

@@ -13,10 +13,12 @@ def solve_glm(X, y,
               loss_func='lin_reg',
               loss_kws={},
               fit_intercept=True,
+              sample_weight=None,
 
               lasso_pen=None,
               lasso_weights=None,
 
+
               # groups=None,
               # L1to2=False,
               # nuc=False,
@@ -31,6 +33,9 @@ def solve_glm(X, y,
               p0=10, verbose=0, tol=1e-4, prune=0,
               return_n_iter=False):
 
+    if sample_weight is not None:
+        raise NotImplementedError("need to add")
+
     X = check_array(X, 'csc', dtype=[np.float64, np.float32],
                     order='F', copy=False, accept_large_sparse=False)
     y = check_array(y, 'csc', dtype=X.dtype.type, order='F', copy=False,

ya_glm/backends/cvxpy/glm_solver.py

@@ -14,6 +14,7 @@ def solve_glm(X, y,
               loss_func='lin_reg',
               loss_kws={},
               fit_intercept=True,
+              sample_weight=None,
               lasso_pen=None,
               lasso_weights=None,
               groups=None,
@@ -28,6 +29,9 @@ def solve_glm(X, y,
               solver=None,
               cp_kws={}):
 
+    if sample_weight is not None:
+        raise NotImplementedError("need to add")
+
     start_time = time()
     ######################
     # objective function #

ya_glm/backends/fista/WL1SolverGlm.py

@@ -32,6 +32,7 @@ def solve(self, L1_weights, opt_init=None, opt_init_upv=None):
                            loss_func=self.glm_loss,
 
                            loss_kws=self.loss_kws,
+                           sample_weight=self.sample_weight,
                            fit_intercept=self.fit_intercept,
                            lasso_pen=1,
                            lasso_weights=L1_weights,

ya_glm/backends/fista/glm_solver.py

@@ -1,25 +1,17 @@
 import numpy as np
-from copy import deepcopy
 from textwrap import dedent
 
-from ya_glm.info import is_multi_response
-from ya_glm.opt.linear_regression import LinRegLoss, LinRegMultiRespLoss
-from ya_glm.opt.huber_regression import HuberRegLoss, HuberRegMultiRespLoss
-from ya_glm.opt.multinomial import MultinomialLoss
-from ya_glm.opt.poisson_regression import PoissonRegLoss, \
-    PoissonRegMultiRespLoss
-from ya_glm.opt.quantile_regression import QuantileRegLoss
-
-from ya_glm.opt.logistic_regression import LogRegLoss
-from ya_glm.opt.penalty import LassoPenalty, RidgePenalty, \
+from ya_glm.opt.penalty.vec import LassoPenalty, RidgePenalty, \
     WithIntercept, TikhonovPenalty
-from ya_glm.opt.GroupLasso import GroupLasso
-from ya_glm.opt.mat_penalty import MultiTaskLasso, NuclearNorm, \
+from ya_glm.opt.penalty.GroupLasso import GroupLasso
+from ya_glm.opt.penalty.mat_penalty import MultiTaskLasso, NuclearNorm, \
     MatricizeEntrywisePen, \
     MatWithIntercept
 from ya_glm.opt.utils import decat_coef_inter_vec, decat_coef_inter_mat
 from ya_glm.opt.fista import solve_fista
-from ya_glm.opt.base import Func, Sum
+from ya_glm.opt.base import Sum
+from ya_glm.opt.glm_loss.get import get_glm_loss, safe_is_multi_response, \
+    _LOSS_FUNC_CLS2STR
 
 
 _solve_glm_params = dedent("""
@@ -38,6 +30,9 @@
 fit_intercept: bool
     Whether or not to fit an intercept.
 
+sample_weight: None or array-like,  shape (n_samples,)
+    Individual weights for each sample.
+
 lasso_pen: None, float
     (Optional) The L1 penalty parameter value.
 
@@ -72,9 +67,6 @@
 intercept_init: None, float
     (Optional) Initialization for the intercept.
 
-precomp_lip: None, float
-    (Optional) Precomputed Lipschitz constant.
-
 xtol: float, None
     The change in X stopping criterion. If provided, we terminate the algorithm if |x_new - x_current|_max < x_tol
 
@@ -109,6 +101,7 @@ def solve_glm(X, y,
               loss_func='lin_reg',
               loss_kws={},
               fit_intercept=True,
+              sample_weight=None,
 
               lasso_pen=None,
               lasso_weights=None,
@@ -121,7 +114,6 @@ def solve_glm(X, y,
 
               coef_init=None,
               intercept_init=None,
-              precomp_lip=None,
               xtol=1e-4,
               rtol=None,
               atol=None,
@@ -136,8 +128,9 @@ def solve_glm(X, y,
 
     # get loss function object
     loss_func = get_glm_loss(loss_func=loss_func, loss_kws=loss_kws,
-                             X=X, y=y, fit_intercept=fit_intercept,
-                             precomp_lip=precomp_lip)
+                             X=X, y=y,
+                             fit_intercept=fit_intercept,
+                             sample_weight=sample_weight)
 
     if _LOSS_FUNC_CLS2STR[type(loss_func)] == 'quantile':
         raise NotImplementedError("fista solver does not support quantile loss")
@@ -149,9 +142,14 @@ def solve_glm(X, y,
     #####################
     # set initial value #
     #####################
-    init_val = process_init(X=X, y=y, loss_func=loss_func,
-                            fit_intercept=fit_intercept,
-                            coef_init=coef_init, intercept_init=intercept_init)
+    if coef_init is None or intercept_init is None:
+        init_val = loss_func.default_init()
+    else:
+        init_val = loss_func.cat_intercept_coef(intercept_init, coef_init)
+
+    # init_val = process_init(X=X, y=y, loss_func=loss_func,
+    #                         fit_intercept=fit_intercept,
+    #                         coef_init=coef_init, intercept_init=intercept_init)
 
     #############################
     # pre process penalty input #
@@ -294,7 +292,7 @@ def solve_glm_path(X, y,
                    lasso_pen_seq=None, ridge_pen_seq=None,
                    loss_func='lin_reg', loss_kws={},
                    fit_intercept=True,
-                   precomp_lip=None,
+                   sample_weight=None,
                    # generator=True,
                    check_decr=True,
                    **kws):
@@ -335,8 +333,9 @@ def solve_glm_path(X, y,
 
     # this will precompute the lipschitz constant
     loss_func = get_glm_loss(loss_func=loss_func, loss_kws=loss_kws,
-                             X=X, y=y, fit_intercept=fit_intercept,
-                             precomp_lip=precomp_lip)
+                             X=X, y=y,
+                             fit_intercept=fit_intercept,
+                             sample_weight=sample_weight)
 
     # possibly get initializers
     if 'coef_init' in kws:
@@ -371,125 +370,58 @@ def solve_glm_path(X, y,
         yield fit_out, params
 
 
-_LOSS_FUNC_STR2CLS = {'lin_reg': LinRegLoss,
-                      'lin_reg_mr': LinRegMultiRespLoss,
-                      'huber_reg': HuberRegLoss,
-                      'huber_reg_mr': HuberRegMultiRespLoss,
-                      'log_reg': LogRegLoss,
-                      'multinomial': MultinomialLoss,
-                      'poisson': PoissonRegLoss,
-                      'poisson_mr': PoissonRegMultiRespLoss,
-                      'quantile': QuantileRegLoss
-                      }
-
-_LOSS_FUNC_CLS2STR = {v: k for (k, v) in _LOSS_FUNC_STR2CLS.items()}
-
-
-def get_glm_loss(X, y,
-                 loss_func='lin_reg', loss_kws={},
-                 fit_intercept=True, precomp_lip=None):
-    """
-    Returns an GLM loss function object.
-
-    Parameters
-    ----------
-    X: array-like, shape (n_samples, n_features)
-        The training covariate data.
-
-    y: array-like, shape (n_samples, )
-        The training response data.
-
-    fit_intercept: bool
-        Whether or not to fit an intercept.
-
-    loss_func: str
-        Which GLM loss function to use.
-        Must be one of ['linear_regression', 'logistic_regression'].
-        This may also be an instance of ya_glm.opt.base.Func.
-
-    precomp_lip: None, float
-        (Optional) Precomputed Lipchitz constant
-
-    Output
-    ------
-    glm_loss: ya_glm.opt.Func
-        The GLM loss function object.
-    """
-
-    if isinstance(loss_func, Func):
-        return loss_func
-
-    assert loss_func in _LOSS_FUNC_STR2CLS.keys()
-    obj_class = _LOSS_FUNC_STR2CLS[loss_func]
-
-    kws = {'X': X, 'y': y, 'fit_intercept': fit_intercept,
-           **loss_kws}
-
-    if precomp_lip is not None:
-        kws['lip'] = precomp_lip
-
-    return obj_class(**kws)
-
-
-def safe_is_multi_response(loss_func):
-    if isinstance(loss_func, Func):
-        return is_multi_response(_LOSS_FUNC_CLS2STR[type(loss_func)])
-    else:
-        return is_multi_response(loss_func)
-
-
-def process_init(X, y, loss_func, fit_intercept=True, coef_init=None,
-                 intercept_init=None):
-    """
-    Processes the initializer.
-
-    Parameters
-    ----------
-
-    Outout
-    ------
-    init_val: array-like
-        The initial value. Shape is (n_features, ), (n_features + 1, )
-        (n_features, n_responses) or (n_features, n_responses + 1)
-    """
-
-    if coef_init is None or (fit_intercept and intercept_init is None):
-
-        # determine the coefficient shape
-        if safe_is_multi_response(loss_func):
-            coef_shape = (X.shape[1], y.shape[1])
-        else:
-            coef_shape = X.shape[1]
-
-        # initialize coefficient
-        if coef_init is None:
-            coef_init = np.zeros(coef_shape)
-
-        # initialize intercept
-        if intercept_init is None:
-            if isinstance(coef_shape, tuple):
-                intercept_init = np.zeros(coef_shape[1])
-            else:
-                intercept_init = 0
-
-    # format
-    coef_init = np.array(coef_init)
-    if fit_intercept:
-        if coef_init.ndim > 1:
-            intercept_init = np.array(intercept_init)
-        else:
-            intercept_init = float(intercept_init)
-
-    # maybe concatenate
-    if fit_intercept:
-        if coef_init.ndim == 2:
-            init_val = np.vstack([intercept_init, coef_init])
-        else:
-            init_val = np.concatenate([[intercept_init], coef_init])
-    else:
-        init_val = deepcopy(coef_init)
-
-    return init_val
+# def process_init(X, y, loss_func, fit_intercept=True, coef_init=None,
+#                  intercept_init=None):
+#     """
+#     Processes the initializer.
+
+#     Parameters
+#     ----------
+
+#     Outout
+#     ------
+#     init_val: array-like
+#         The initial value. Shape is (n_features, ), (n_features + 1, )
+#         (n_features, n_responses) or (n_features, n_responses + 1)
+#     """
+
+#     if coef_init is None or (fit_intercept and intercept_init is None):
+
+#         # determine the coefficient shape
+#         if safe_is_multi_response(loss_func):
+#             coef_shape = (X.shape[1], y.shape[1])
+#         else:
+#             coef_shape = X.shape[1]
+
+#         # initialize coefficient
+#         if coef_init is None:
+#             coef_init = np.zeros(coef_shape)
+
+#         # initialize intercept
+#         if intercept_init is None:
+#             if isinstance(coef_shape, tuple):
+#                 intercept_init = np.zeros(coef_shape[1])
+#             else:
+#                 intercept_init = 0
+
+#     # format
+#     coef_init = np.array(coef_init)
+#     if fit_intercept:
+#         if coef_init.ndim > 1:
+#             intercept_init = np.array(intercept_init)
+#         else:
+#             intercept_init = float(intercept_init)
+
+#     # maybe concatenate
+#     if fit_intercept:
+#         if coef_init.ndim == 2:
+#             init_val = np.vstack([intercept_init, coef_init])
+#         else:
+#             init_val = np.concatenate([[intercept_init], coef_init])
+#     else:
+#         init_val = deepcopy(coef_init)
+
+#     return init_val
 
 
 def process_param_path(lasso_pen_seq=None, ridge_pen_seq=None, check_decr=True):
@@ -520,4 +452,3 @@ def process_param_path(lasso_pen_seq=None, ridge_pen_seq=None, check_decr=True):
         raise ValueError("One of lasso_pen_seq, ridge_pen_seq should be provided ")
 
     return param_path
-

ya_glm/backends/quantile_lp/cvxpy_quad_prog.py

@@ -6,7 +6,7 @@
     get_coef_inter, get_quad_mat
 
 
-def solve(X, y, fit_intercept=True, quantile=0.5, sample_weights=None,
+def solve(X, y, fit_intercept=True, quantile=0.5, sample_weight=None,
           lasso_pen=1, ridge_pen=None,
           lasso_weights=None, ridge_weights=None, tikhonov=None,
           coef_init=None, intercept_init=None,
@@ -29,7 +29,7 @@ def solve(X, y, fit_intercept=True, quantile=0.5, sample_weights=None,
         setup_problem(X=X, y=y,
                       fit_intercept=fit_intercept,
                       quantile=quantile,
-                      sample_weights=sample_weights,
+                      sample_weight=sample_weight,
                       lasso_pen=lasso_pen,
                       ridge_pen=ridge_pen,
                       lasso_weights=lasso_weights,
@@ -120,7 +120,7 @@ def solve_path(fit_intercept=True, cp_kws={}, zero_tol=1e-8,
         yield fit_out, params
 
 
-def setup_problem(X, y, fit_intercept=True, quantile=0.5, sample_weights=None,
+def setup_problem(X, y, fit_intercept=True, quantile=0.5, sample_weight=None,
                   lasso_pen=1, ridge_pen=None,
                   lasso_weights=None, ridge_weights=None, tikhonov=None,
                   coef_init=None, intercept_init=None):
@@ -142,7 +142,7 @@ def setup_problem(X, y, fit_intercept=True, quantile=0.5, sample_weights=None,
                           fit_intercept=fit_intercept,
                           quantile=quantile,
                           lasso_pen=lasso_pen,
-                          sample_weights=sample_weights,
+                          sample_weight=sample_weight,
                           lasso_weights=lasso_weights)
 
     lin_coef = cp.hstack(lin_coef)