DEP remove positive parameter for lars solver (scikit-learn#13863)

Author: XavierSATTLER

sklearn/decomposition/dict_learning.py

@@ -21,6 +21,14 @@
 from ..linear_model import Lasso, orthogonal_mp_gram, LassoLars, Lars
 
 
+def _check_positive_coding(method, positive):
+ if positive and method in ["omp", "lars"]:
+ raise ValueError(
+ "Positive constraint not supported for '{}' "
+ "coding method.".format(method)
+ )
+
+
 def _sparse_encode(X, dictionary, gram, cov=None, algorithm='lasso_lars',
  regularization=None, copy_cov=True,
  init=None, max_iter=1000, check_input=True, verbose=0,
@@ -107,6 +115,8 @@ def _sparse_encode(X, dictionary, gram, cov=None, algorithm='lasso_lars',
  copy_cov = False
  cov = np.dot(dictionary, X.T)
 
+ _check_positive_coding(algorithm, positive)
+
  if algorithm == 'lasso_lars':
  alpha = float(regularization) / n_features # account for scaling
  try:
@@ -147,7 +157,7 @@ def _sparse_encode(X, dictionary, gram, cov=None, algorithm='lasso_lars',
  # corrects the verbosity level.
  lars = Lars(fit_intercept=False, verbose=verbose, normalize=False,
  precompute=gram, n_nonzero_coefs=int(regularization),
- fit_path=False, positive=positive)
+ fit_path=False)
  lars.fit(dictionary.T, X.T, Xy=cov)
  new_code = lars.coef_
  finally:
@@ -160,11 +170,6 @@ def _sparse_encode(X, dictionary, gram, cov=None, algorithm='lasso_lars',
  np.clip(new_code, 0, None, out=new_code)
 
  elif algorithm == 'omp':
- # TODO: Should verbose argument be passed to this?
- if positive:
- raise ValueError(
- "Positive constraint not supported for \"omp\" coding method."
- )
  new_code = orthogonal_mp_gram(
  Gram=gram, Xy=cov, n_nonzero_coefs=int(regularization),
  tol=None, norms_squared=row_norms(X, squared=True),
@@ -519,6 +524,9 @@ def dict_learning(X, n_components, alpha, max_iter=100, tol=1e-8,
  if method not in ('lars', 'cd'):
  raise ValueError('Coding method %r not supported as a fit algorithm.'
  % method)
+
+ _check_positive_coding(method, positive_code)
+
  method = 'lasso_' + method
 
  t0 = time.time()
@@ -729,6 +737,9 @@ def dict_learning_online(X, n_components=2, alpha=1, n_iter=100,
 
  if method not in ('lars', 'cd'):
  raise ValueError('Coding method not supported as a fit algorithm.')
+
+ _check_positive_coding(method, positive_code)
+
  method = 'lasso_' + method
 
  t0 = time.time()

sklearn/decomposition/tests/test_dict_learning.py

@@ -18,6 +18,7 @@
 from sklearn.decomposition import DictionaryLearning
 from sklearn.decomposition import MiniBatchDictionaryLearning
 from sklearn.decomposition import SparseCoder
+from sklearn.decomposition import dict_learning
 from sklearn.decomposition import dict_learning_online
 from sklearn.decomposition import sparse_encode
 
@@ -56,29 +57,30 @@ def test_dict_learning_overcomplete():
  assert dico.components_.shape == (n_components, n_features)
 
 
-# positive lars deprecated 0.22
-@pytest.mark.filterwarnings('ignore::DeprecationWarning')
+def test_dict_learning_lars_positive_parameter():
+ n_components = 5
+ alpha = 1
+ err_msg = "Positive constraint not supported for 'lars' coding method."
+ with pytest.raises(ValueError, match=err_msg):
+ dict_learning(X, n_components, alpha, positive_code=True)
+
+
 @pytest.mark.parametrize("transform_algorithm", [
  "lasso_lars",
  "lasso_cd",
- "lars",
  "threshold",
 ])
-@pytest.mark.parametrize("positive_code", [
- False,
- True,
-])
-@pytest.mark.parametrize("positive_dict", [
- False,
- True,
-])
+@pytest.mark.parametrize("positive_code", [False, True])
+@pytest.mark.parametrize("positive_dict", [False, True])
 def test_dict_learning_positivity(transform_algorithm,
  positive_code,
  positive_dict):
  n_components = 5
  dico = DictionaryLearning(
  n_components, transform_algorithm=transform_algorithm, random_state=0,
- positive_code=positive_code, positive_dict=positive_dict).fit(X)
+ positive_code=positive_code, positive_dict=positive_dict,
+ fit_algorithm="cd").fit(X)
+
  code = dico.transform(X)
  if positive_dict:
  assert (dico.components_ >= 0).all()
@@ -90,6 +92,31 @@ def test_dict_learning_positivity(transform_algorithm,
  assert (code < 0).any()
 
 
+@pytest.mark.parametrize("positive_dict", [False, True])
+def test_dict_learning_lars_dict_positivity(positive_dict):
+ n_components = 5
+ dico = DictionaryLearning(
+ n_components, transform_algorithm="lars", random_state=0,
+ positive_dict=positive_dict, fit_algorithm="cd").fit(X)
+
+ if positive_dict:
+ assert (dico.components_ >= 0).all()
+ else:
+ assert (dico.components_ < 0).any()
+
+
+def test_dict_learning_lars_code_positivity():
+ n_components = 5
+ dico = DictionaryLearning(
+ n_components, transform_algorithm="lars", random_state=0,
+ positive_code=True, fit_algorithm="cd").fit(X)
+
+ err_msg = "Positive constraint not supported for '{}' coding method."
+ err_msg = err_msg.format("lars")
+ with pytest.raises(ValueError, match=err_msg):
+ dico.transform(X)
+
+
 def test_dict_learning_reconstruction():
  n_components = 12
  dico = DictionaryLearning(n_components, transform_algorithm='omp',
@@ -170,31 +197,29 @@ def test_dict_learning_online_shapes():
  assert_equal(np.dot(code, dictionary).shape, X.shape)
 
 
-# positive lars deprecated 0.22
-@pytest.mark.filterwarnings('ignore::DeprecationWarning')
+def test_dict_learning_online_lars_positive_parameter():
+ alpha = 1
+ err_msg = "Positive constraint not supported for 'lars' coding method."
+ with pytest.raises(ValueError, match=err_msg):
+ dict_learning_online(X, alpha, positive_code=True)
+
+
 @pytest.mark.parametrize("transform_algorithm", [
  "lasso_lars",
  "lasso_cd",
- "lars",
  "threshold",
 ])
-@pytest.mark.parametrize("positive_code", [
- False,
- True,
-])
-@pytest.mark.parametrize("positive_dict", [
- False,
- True,
-])
-def test_dict_learning_online_positivity(transform_algorithm,
- positive_code,
- positive_dict):
- rng = np.random.RandomState(0)
+@pytest.mark.parametrize("positive_code", [False, True])
+@pytest.mark.parametrize("positive_dict", [False, True])
+def test_minibatch_dictionary_learning_positivity(transform_algorithm,
+ positive_code,
+ positive_dict):
  n_components = 8
-
  dico = MiniBatchDictionaryLearning(
  n_components, transform_algorithm=transform_algorithm, random_state=0,
- positive_code=positive_code, positive_dict=positive_dict).fit(X)
+ positive_code=positive_code, positive_dict=positive_dict,
+ fit_algorithm='cd').fit(X)
+
  code = dico.transform(X)
  if positive_dict:
  assert (dico.components_ >= 0).all()
@@ -205,7 +230,30 @@ def test_dict_learning_online_positivity(transform_algorithm,
  else:
  assert (code < 0).any()
 
+
+@pytest.mark.parametrize("positive_dict", [False, True])
+def test_minibatch_dictionary_learning_lars(positive_dict):
+ n_components = 8
+
+ dico = MiniBatchDictionaryLearning(
+ n_components, transform_algorithm="lars", random_state=0,
+ positive_dict=positive_dict, fit_algorithm='cd').fit(X)
+
+ if positive_dict:
+ assert (dico.components_ >= 0).all()
+ else:
+ assert (dico.components_ < 0).any()
+
+
+@pytest.mark.parametrize("positive_code", [False, True])
+@pytest.mark.parametrize("positive_dict", [False, True])
+def test_dict_learning_online_positivity(positive_code,
+ positive_dict):
+ rng = np.random.RandomState(0)
+ n_components = 8
+
  code, dictionary = dict_learning_online(X, n_components=n_components,
+ method="cd",
  alpha=1, random_state=rng,
  positive_dict=positive_dict,
  positive_code=positive_code)
@@ -307,29 +355,34 @@ def test_sparse_encode_shapes():
  assert_equal(code.shape, (n_samples, n_components))
 
 
-# positive lars deprecated 0.22
-@pytest.mark.filterwarnings('ignore::DeprecationWarning')
-@pytest.mark.parametrize("positive", [
- False,
- True,
+@pytest.mark.parametrize("algo", [
+ 'lasso_lars',
+ 'lasso_cd',
+ 'threshold'
 ])
-def test_sparse_encode_positivity(positive):
+@pytest.mark.parametrize("positive", [False, True])
+def test_sparse_encode_positivity(algo, positive):
  n_components = 12
  rng = np.random.RandomState(0)
  V = rng.randn(n_components, n_features) # random init
  V /= np.sum(V ** 2, axis=1)[:, np.newaxis]
- for algo in ('lasso_lars', 'lasso_cd', 'lars', 'threshold'):
- code = sparse_encode(X, V, algorithm=algo, positive=positive)
- if positive:
- assert (code >= 0).all()
- else:
- assert (code < 0).any()
+ code = sparse_encode(X, V, algorithm=algo, positive=positive)
+ if positive:
+ assert (code >= 0).all()
+ else:
+ assert (code < 0).any()
 
- try:
- sparse_encode(X, V, algorithm='omp', positive=positive)
- except ValueError:
- if not positive:
- raise
+
+@pytest.mark.parametrize("algo", ['lars', 'omp'])
+def test_sparse_encode_unavailable_positivity(algo):
+ n_components = 12
+ rng = np.random.RandomState(0)
+ V = rng.randn(n_components, n_features) # random init
+ V /= np.sum(V ** 2, axis=1)[:, np.newaxis]
+ err_msg = "Positive constraint not supported for '{}' coding method."
+ err_msg = err_msg.format(algo)
+ with pytest.raises(ValueError, match=err_msg):
+ sparse_encode(X, V, algorithm=algo, positive=True)
 
 
 def test_sparse_encode_input():

sklearn/linear_model/least_angle.py

@@ -397,10 +397,11 @@ def _lars_path_solver(X, y, Xy=None, Gram=None, n_samples=None, max_iter=500,
 
  """
  if method == 'lar' and positive:
- warnings.warn('positive option is broken for Least'
- ' Angle Regression (LAR). Use method="lasso".'
- ' This option will be removed in version 0.22.',
- DeprecationWarning)
+ raise ValueError(
+ "Positive constraint not supported for 'lar' "
+ "coding method."
+ )
+
  n_samples = n_samples if n_samples is not None else y.size
 
  if Xy is None:
@@ -804,14 +805,6 @@ class Lars(LinearModel, RegressorMixin, MultiOutputMixin):
  setting ``fit_path`` to ``False`` will lead to a speedup, especially
  with a small alpha.
 
- positive : boolean (default=False)
- Restrict coefficients to be >= 0. Be aware that you might want to
- remove fit_intercept which is set True by default.
-
- .. deprecated:: 0.20
-
- The option is broken and deprecated. It will be removed in v0.22.
-
  Attributes
  ----------
  alphas_ : array, shape (n_alphas + 1,) | list of n_targets such arrays
@@ -844,7 +837,7 @@ class Lars(LinearModel, RegressorMixin, MultiOutputMixin):
  >>> reg.fit([[-1, 1], [0, 0], [1, 1]], [-1.1111, 0, -1.1111])
  ... # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
  Lars(copy_X=True, eps=..., fit_intercept=True, fit_path=True,
- n_nonzero_coefs=1, normalize=True, positive=False, precompute='auto',
+ n_nonzero_coefs=1, normalize=True, precompute='auto',
  verbose=False)
  >>> print(reg.coef_) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
  [ 0. -1.11...]
@@ -856,17 +849,16 @@ class Lars(LinearModel, RegressorMixin, MultiOutputMixin):
 
  """
  method = 'lar'
+ positive = False
 
  def __init__(self, fit_intercept=True, verbose=False, normalize=True,
  precompute='auto', n_nonzero_coefs=500,
- eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,
- positive=False):
+ eps=np.finfo(np.float).eps, copy_X=True, fit_path=True):
  self.fit_intercept = fit_intercept
  self.verbose = verbose
  self.normalize = normalize
  self.precompute = precompute
  self.n_nonzero_coefs = n_nonzero_coefs
- self.positive = positive
  self.eps = eps
  self.copy_X = copy_X
  self.fit_path = fit_path
@@ -1303,13 +1295,6 @@ class LarsCV(Lars):
  copy_X : boolean, optional, default True
  If ``True``, X will be copied; else, it may be overwritten.
 
- positive : boolean (default=False)
- Restrict coefficients to be >= 0. Be aware that you might want to
- remove fit_intercept which is set True by default.
-
- .. deprecated:: 0.20
- The option is broken and deprecated. It will be removed in v0.22.
-
  Attributes
  ----------
  coef_ : array, shape (n_features,)
@@ -1360,7 +1345,7 @@ class LarsCV(Lars):
  def __init__(self, fit_intercept=True, verbose=False, max_iter=500,
  normalize=True, precompute='auto', cv='warn',
  max_n_alphas=1000, n_jobs=None, eps=np.finfo(np.float).eps,
- copy_X=True, positive=False):
+ copy_X=True):
  self.max_iter = max_iter
  self.cv = cv
  self.max_n_alphas = max_n_alphas
@@ -1369,8 +1354,7 @@ def __init__(self, fit_intercept=True, verbose=False, max_iter=500,
  verbose=verbose, normalize=normalize,
  precompute=precompute,
  n_nonzero_coefs=500,
- eps=eps, copy_X=copy_X, fit_path=True,
- positive=positive)
+ eps=eps, copy_X=copy_X, fit_path=True)
 
  def fit(self, X, y):
  """Fit the model using X, y as training data.
@@ -1683,7 +1667,6 @@ class LassoLarsIC(LassoLars):
  As a consequence using LassoLarsIC only makes sense for problems where
  a sparse solution is expected and/or reached.
 
-
  Attributes
  ----------
  coef_ : array, shape (n_features,)

sklearn/linear_model/tests/test_least_angle.py

@@ -514,13 +514,11 @@ def test_lars_path_positive_constraint():
  # and all positive when positive=True
  # for method 'lar' (default) and lasso
 
- # Once deprecation of LAR + positive option is done use these:
- # assert_raises(ValueError, linear_model.lars_path, diabetes['data'],
- # diabetes['target'], method='lar', positive=True)
- with pytest.warns(DeprecationWarning, match='broken'):
+ err_msg = "Positive constraint not supported for 'lar' coding method."
+ with pytest.raises(ValueError, match=err_msg):
  linear_model.lars_path(diabetes['data'], diabetes['target'],
- return_path=True, method='lar',
- positive=True)
+ method='lar', positive=True)
+
  method = 'lasso'
  _, _, coefs = \
  linear_model.lars_path(X, y, return_path=True, method=method,