Remove the need for skggm

Author: William de Vazelhes

metric_learn/_util.py

@@ -15,14 +15,6 @@ def vector_norm(X):
     return np.linalg.norm(X, axis=1)
 
 
-def has_installed_skggm():
-  try:
-    import inverse_covariance
-    return True
-  except ImportError:
-    return False
-
-
 def check_input(input_data, y=None, preprocessor=None,
                 type_of_inputs='classic', tuple_size=None, accept_sparse=False,
                 dtype='numeric', order=None,

metric_learn/sdml.py

@@ -13,13 +13,12 @@
 import numpy as np
 from sklearn.base import TransformerMixin
 from scipy.linalg import pinvh
+from sklearn.covariance import graphical_lasso
 from sklearn.exceptions import ConvergenceWarning
 
 from .base_metric import MahalanobisMixin, _PairsClassifierMixin
 from .constraints import Constraints, wrap_pairs
-from ._util import transformer_from_metric, has_installed_skggm
-if has_installed_skggm():
-  from inverse_covariance import quic
+from ._util import transformer_from_metric
 
 
 class _BaseSDML(MahalanobisMixin):
@@ -47,11 +46,6 @@ def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,
         The preprocessor to call to get tuples from indices. If array-like,
         tuples will be gotten like this: X[indices].
     """
-    if not has_installed_skggm():
-      raise NotImplementedError("SDML cannot be instantiated without "
-                                "installing skggm. Please install skggm and "
-                                "try again (make sure you meet skggm's "
-                                "requirements).")
     self.balance_param = balance_param
     self.sparsity_param = sparsity_param
     self.use_cov = use_cov
@@ -83,11 +77,10 @@ def _fit(self, pairs, y):
                     "To prevent that, try to decrease the balance parameter "
                     "`balance_param` and/or to set use_covariance=False.",
                     ConvergenceWarning)
-    sigma0 = (V * (w - min(0, np.min(w)) + 1e-10)).dot(V.T)
-    theta0 = pinvh(sigma0)
-    M, _, _, _, _, _ = quic(emp_cov, lam=self.sparsity_param,
-                            msg=self.verbose,
-                            Theta0=theta0, Sigma0=sigma0)
+    cov_init = (V * (w - min(0, np.min(w)) + 1e-10)).dot(V.T)
+    _, M = graphical_lasso(emp_cov, alpha=self.sparsity_param,
+                           verbose=self.verbose,
+                           cov_init=cov_init)
     self.transformer_ = transformer_from_metric(np.atleast_2d(M))
     return self
 

test/metric_learn_test.py

@@ -15,7 +15,6 @@
                           LSML_Supervised, ITML_Supervised, SDML_Supervised,
                           RCA_Supervised, MMC_Supervised, SDML)
 # Import this specially for testing.
-from metric_learn._util import has_installed_skggm
 from metric_learn.constraints import wrap_pairs
 from metric_learn.lmnn import python_LMNN
 
@@ -150,43 +149,25 @@ def test_no_twice_same_objective(capsys):
 
 class TestSDML(MetricTestCase):
 
-  def test_raises_error_msg_not_installed_skggm(self):
-    """Tests that the right error message is raised if someone tries to
-    instantiate SDML but has not installed skggm"""
-    # TODO: to be removed when scikit-learn v0.21 is released
-    if not has_installed_skggm():
-      msg = ("SDML cannot be instantiated without "
-             "installing skggm. Please install skggm and "
-             "try again (make sure you meet skggm's "
-             "requirements).")
-      with pytest.raises(NotImplementedError) as expected_err:
-        SDML()
-      assert str(expected_err.value) == msg
-    else:  # otherwise we should be able to instantiate SDML and it should
-      # raise no warning
-      with pytest.warns(None) as record:
-        SDML()
-      assert len(record) == 0
-
-  if has_installed_skggm():
-
     def test_iris(self):
       # Note: this is a flaky test, which fails for certain seeds.
       # TODO: un-flake it!
       rs = np.random.RandomState(5555)
 
-      sdml = SDML_Supervised(num_constraints=1500)
+      sdml = SDML_Supervised(num_constraints=1500, use_cov=False,
+                             balance_param=5e-5)
       sdml.fit(self.iris_points, self.iris_labels, random_state=rs)
       csep = class_separation(sdml.transform(self.iris_points),
                               self.iris_labels)
-      self.assertLess(csep, 0.20)
+      self.assertLess(csep, 0.22)
 
     def test_deprecation_num_labeled(self):
       # test that a deprecation message is thrown if num_labeled is set at
       # initialization
       # TODO: remove in v.0.6
       X, y = make_classification()
-      sdml_supervised = SDML_Supervised(num_labeled=np.inf)
+      sdml_supervised = SDML_Supervised(num_labeled=np.inf, use_cov=False,
+                                        balance_param=5e-5)
       msg = ('"num_labeled" parameter is not used.'
              ' It has been deprecated in version 0.5.0 and will be'
              'removed in 0.6.0')

test/test_base_metric.py

@@ -5,7 +5,6 @@
 from sklearn import clone
 from sklearn.utils.testing import set_random_state
 
-from metric_learn._util import has_installed_skggm
 from test.test_utils import ids_metric_learners, metric_learners
 
 
@@ -54,33 +53,17 @@ def test_lsml(self):
         weights=None)
 """.strip('\n'))
 
-  if has_installed_skggm():
-    def test_sdml(self):
-      self.assertEqual(str(metric_learn.SDML()),
-                       "SDML(balance_param=0.5, preprocessor=None, "
-                       "sparsity_param=0.01, use_cov=True,\n   "
-                       "verbose=False)")
-      self.assertEqual(str(metric_learn.SDML_Supervised()), """
+  def test_sdml(self):
+    self.assertEqual(str(metric_learn.SDML()),
+                     "SDML(balance_param=0.5, preprocessor=None, "
+                     "sparsity_param=0.01, use_cov=True,\n   "
+                     "verbose=False)")
+    self.assertEqual(str(metric_learn.SDML_Supervised()), """
 SDML_Supervised(balance_param=0.5, num_constraints=None,
         num_labeled='deprecated', preprocessor=None, sparsity_param=0.01,
         use_cov=True, verbose=False)
 """.strip('\n'))
 
-  else:
-    # if we haven't install skggm, we will just check that instantiating SDML
-    # or SDML_Supervised will return an error
-    def test_sdml(self):
-      expected_msg = ("SDML cannot be instantiated without "
-                      "installing skggm. Please install skggm and "
-                      "try again (make sure you meet skggm's "
-                      "requirements).")
-      with pytest.raises(NotImplementedError) as raised_error:
-        metric_learn.SDML()
-      assert str(raised_error.value) == expected_msg
-      with pytest.raises(NotImplementedError) as raised_error:
-        metric_learn.SDML_Supervised()
-      assert str(raised_error.value) == expected_msg
-
   def test_rca(self):
     self.assertEqual(str(metric_learn.RCA()),
                      "RCA(num_dims=None, pca_comps=None, preprocessor=None)")

test/test_fit_transform.py

@@ -6,9 +6,8 @@
 
 from metric_learn import (
     LMNN, NCA, LFDA, Covariance, MLKR,
-    LSML_Supervised, ITML_Supervised, SDML_Supervised, RCA_Supervised, MMC_Supervised)
-
-from metric_learn._util import has_installed_skggm
+    LSML_Supervised, ITML_Supervised, SDML_Supervised, RCA_Supervised,
+    MMC_Supervised)
 
 
 class TestFitTransform(unittest.TestCase):
@@ -63,18 +62,19 @@ def test_lmnn(self):
 
     assert_array_almost_equal(res_1, res_2)
 
-  if has_installed_skggm():
-    def test_sdml_supervised(self):
-      seed = np.random.RandomState(1234)
-      sdml = SDML_Supervised(num_constraints=1500)
-      sdml.fit(self.X, self.y, random_state=seed)
-      res_1 = sdml.transform(self.X)
+  def test_sdml_supervised(self):
+    seed = np.random.RandomState(1234)
+    sdml = SDML_Supervised(num_constraints=1500, balance_param=1e-5,
+                           use_cov=False)
+    sdml.fit(self.X, self.y, random_state=seed)
+    res_1 = sdml.transform(self.X)
 
-      seed = np.random.RandomState(1234)
-      sdml = SDML_Supervised(num_constraints=1500)
-      res_2 = sdml.fit_transform(self.X, self.y, random_state=seed)
+    seed = np.random.RandomState(1234)
+    sdml = SDML_Supervised(num_constraints=1500, balance_param=1e-5,
+                           use_cov=False)
+    res_2 = sdml.fit_transform(self.X, self.y, random_state=seed)
 
-      assert_array_almost_equal(res_1, res_2)
+    assert_array_almost_equal(res_1, res_2)
 
   def test_nca(self):
     n = self.X.shape[0]

test/test_mahalanobis_mixin.py

@@ -274,8 +274,6 @@ def test_transformer_is_2D(estimator, build_dataset):
   """Tests that the transformer of metric learners is 2D"""
   input_data, labels, _, X = build_dataset()
   model = clone(estimator)
-  if model.__class__.__name__.startswith('SDML'):
-    model.set_params(use_cov=False, balance_param=1e-3)
   set_random_state(model)
   # test that it works for X.shape[1] features
   model.fit(input_data, labels)

test/test_sklearn_compat.py

@@ -17,7 +17,6 @@
                                      train_test_split, KFold)
 from sklearn.utils.testing import _get_args
 
-from metric_learn._util import has_installed_skggm
 from test.test_utils import (metric_learners, ids_metric_learners,
                              mock_preprocessor)
 
@@ -75,10 +74,7 @@ def test_mmc(self):
     check_estimator(dMMC)
 
   def test_sdml(self):
-    if has_installed_skggm():
-      check_estimator(dSDML)
-    else:
-      pass
+    check_estimator(dSDML)
 
   # This fails because the default num_chunks isn't data-dependent.
   # def test_rca(self):

test/test_transformer_metric_conversion.py

@@ -6,7 +6,6 @@
 from metric_learn import (
     LMNN, NCA, LFDA, Covariance, MLKR,
     LSML_Supervised, ITML_Supervised, SDML_Supervised, RCA_Supervised)
-from metric_learn._util import has_installed_skggm
 
 
 class TestTransformerMetricConversion(unittest.TestCase):
@@ -43,13 +42,12 @@ def test_lmnn(self):
     L = lmnn.transformer_
     assert_array_almost_equal(L.T.dot(L), lmnn.get_mahalanobis_matrix())
 
-  if has_installed_skggm():
-    def test_sdml_supervised(self):
-      seed = np.random.RandomState(1234)
-      sdml = SDML_Supervised(num_constraints=1500)
-      sdml.fit(self.X, self.y, random_state=seed)
-      L = sdml.transformer_
-      assert_array_almost_equal(L.T.dot(L), sdml.get_mahalanobis_matrix())
+  def test_sdml_supervised(self):
+    seed = np.random.RandomState(1234)
+    sdml = SDML_Supervised(num_constraints=1500)
+    sdml.fit(self.X, self.y, random_state=seed)
+    L = sdml.transformer_
+    assert_array_almost_equal(L.T.dot(L), sdml.get_mahalanobis_matrix())
 
   def test_nca(self):
     n = self.X.shape[0]

test/test_utils.py

@@ -9,8 +9,7 @@
 from sklearn.base import clone
 from metric_learn._util import (check_input, make_context, preprocess_tuples,
                                 make_name, preprocess_points,
-                                check_collapsed_pairs, validate_vector,
-                                has_installed_skggm)
+                                check_collapsed_pairs, validate_vector)
 from metric_learn import (ITML, LSML, MMC, RCA, SDML, Covariance, LFDA,
                           LMNN, MLKR, NCA, ITML_Supervised, LSML_Supervised,
                           MMC_Supervised, RCA_Supervised, SDML_Supervised,
@@ -105,9 +104,7 @@ def build_quadruplets(with_preprocessor=False):
 
 pairs_learners = [(ITML(), build_pairs),
                   (MMC(max_iter=2), build_pairs),  # max_iter=2 for faster
-                  ]
-if has_installed_skggm():
-  pairs_learners.append(((SDML(), build_pairs)))
+                  (SDML(use_cov=False, balance_param=1e-5), build_pairs)]
 ids_pairs_learners = list(map(lambda x: x.__class__.__name__,
                               [learner for (learner, _) in
                                pairs_learners]))
@@ -121,9 +118,8 @@ def build_quadruplets(with_preprocessor=False):
                (LSML_Supervised(), build_classification),
                (MMC_Supervised(max_iter=5), build_classification),
                (RCA_Supervised(num_chunks=10), build_classification),
-               ]
-if has_installed_skggm():
-  classifiers.append(((SDML_Supervised(), build_classification)))
+               (SDML_Supervised(use_cov=False, balance_param=1e-5),
+                build_classification)]
 ids_classifiers = list(map(lambda x: x.__class__.__name__,
                            [learner for (learner, _) in
                             classifiers]))