API: remove num_labeled parameter

Author: William de Vazelhes

metric_learn/constraints.py

@@ -88,15 +88,3 @@ def chunks(self, num_chunks=100, chunk_size=2, random_state=np.random):
       raise ValueError('Unable to make %d chunks of %d examples each' %
                        (num_chunks, chunk_size))
     return chunks
-
-  @staticmethod
-  def random_subset(all_labels, num_preserved=np.inf, random_state=np.random):
-    """
-    the random state object to be passed must be a numpy random seed
-    """
-    n = len(all_labels)
-    num_ignored = max(0, n - num_preserved)
-    idx = random_state.randint(n, size=num_ignored)
-    partial_labels = np.array(all_labels, copy=True)
-    partial_labels[idx] = -1
-    return Constraints(partial_labels)

metric_learn/itml.py

@@ -143,8 +143,7 @@ def metric(self):
 class ITML_Supervised(ITML):
   """Information Theoretic Metric Learning (ITML)"""
   def __init__(self, gamma=1., max_iter=1000, convergence_threshold=1e-3,
-               num_labeled=np.inf, num_constraints=None, bounds=None, A0=None,
-               verbose=False):
+               num_constraints=None, bounds=None, A0=None, verbose=False):
     """Initialize the learner.
 
     Parameters
@@ -153,8 +152,6 @@ def __init__(self, gamma=1., max_iter=1000, convergence_threshold=1e-3,
         value for slack variables
     max_iter : int, optional
     convergence_threshold : float, optional
-    num_labeled : int, optional
-        number of labels to preserve for training
     num_constraints: int, optional
         number of constraints to generate
     bounds : list (pos,neg) pairs, optional
@@ -167,7 +164,6 @@ def __init__(self, gamma=1., max_iter=1000, convergence_threshold=1e-3,
     ITML.__init__(self, gamma=gamma, max_iter=max_iter,
                   convergence_threshold=convergence_threshold,
                   A0=A0, verbose=verbose)
-    self.num_labeled = num_labeled
     self.num_constraints = num_constraints
     self.bounds = bounds
 
@@ -191,8 +187,7 @@ def fit(self, X, y, random_state=np.random):
       num_classes = len(np.unique(y))
       num_constraints = 20 * num_classes**2
 
-    c = Constraints.random_subset(y, self.num_labeled,
-                                  random_state=random_state)
+    c = Constraints(y)
     pos_neg = c.positive_negative_pairs(num_constraints,
                                         random_state=random_state)
     return ITML.fit(self, X, pos_neg, bounds=self.bounds)

metric_learn/lsml.py

@@ -132,7 +132,7 @@ def _gradient(self, metric):
 
 
 class LSML_Supervised(LSML):
-  def __init__(self, tol=1e-3, max_iter=1000, prior=None, num_labeled=np.inf,
+  def __init__(self, tol=1e-3, max_iter=1000, prior=None,
                num_constraints=None, weights=None, verbose=False):
     """Initialize the learner.
 
@@ -142,8 +142,6 @@ def __init__(self, tol=1e-3, max_iter=1000, prior=None, num_labeled=np.inf,
     max_iter : int, optional
     prior : (d x d) matrix, optional
         guess at a metric [default: covariance(X)]
-    num_labeled : int, optional
-        number of labels to preserve for training
     num_constraints: int, optional
         number of constraints to generate
     weights : (m,) array of floats, optional
@@ -153,7 +151,6 @@ def __init__(self, tol=1e-3, max_iter=1000, prior=None, num_labeled=np.inf,
     """
     LSML.__init__(self, tol=tol, max_iter=max_iter, prior=prior,
                   verbose=verbose)
-    self.num_labeled = num_labeled
     self.num_constraints = num_constraints
     self.weights = weights
 
@@ -177,8 +174,7 @@ def fit(self, X, y, random_state=np.random):
       num_classes = len(np.unique(y))
       num_constraints = 20 * num_classes**2
 
-    c = Constraints.random_subset(y, self.num_labeled,
-                                  random_state=random_state)
+    c = Constraints(y)
     pairs = c.positive_negative_pairs(num_constraints, same_length=True,
                                       random_state=random_state)
     return LSML.fit(self, X, pairs, weights=self.weights)

metric_learn/mmc.py

@@ -384,17 +384,15 @@ def transformer(self):
 class MMC_Supervised(MMC):
   """Mahalanobis Metric for Clustering (MMC)"""
   def __init__(self, max_iter=100, max_proj=10000, convergence_threshold=1e-6,
-               num_labeled=np.inf, num_constraints=None,
-               A0=None, diagonal=False, diagonal_c=1.0, verbose=False):
+               num_constraints=None, A0=None, diagonal=False,
+               diagonal_c=1.0, verbose=False):
     """Initialize the learner.
 
     Parameters
     ----------
     max_iter : int, optional
     max_proj : int, optional
     convergence_threshold : float, optional
-    num_labeled : int, optional
-        number of labels to preserve for training
     num_constraints: int, optional
         number of constraints to generate
     A0 : (d x d) matrix, optional
@@ -413,7 +411,6 @@ def __init__(self, max_iter=100, max_proj=10000, convergence_threshold=1e-6,
                  convergence_threshold=convergence_threshold,
                  A0=A0, diagonal=diagonal, diagonal_c=diagonal_c,
                  verbose=verbose)
-    self.num_labeled = num_labeled
     self.num_constraints = num_constraints
 
   def fit(self, X, y, random_state=np.random):
@@ -434,8 +431,7 @@ def fit(self, X, y, random_state=np.random):
       num_classes = len(np.unique(y))
       num_constraints = 20 * num_classes**2
 
-    c = Constraints.random_subset(y, self.num_labeled,
-                                  random_state=random_state)
+    c = Constraints(y)
     pos_neg = c.positive_negative_pairs(num_constraints,
                                         random_state=random_state)
     return MMC.fit(self, X, pos_neg)

metric_learn/sdml.py

@@ -82,7 +82,7 @@ def fit(self, X, W):
 
 class SDML_Supervised(SDML):
   def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,
-               num_labeled=np.inf, num_constraints=None, verbose=False):
+               num_constraints=None, verbose=False):
     """
     Parameters
     ----------
@@ -92,8 +92,6 @@ def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,
         trade off between optimizer and sparseness (see graph_lasso)
     use_cov : bool, optional
         controls prior matrix, will use the identity if use_cov=False
-    num_labeled : int, optional
-        number of labels to preserve for training
     num_constraints : int, optional
         number of constraints to generate
     verbose : bool, optional
@@ -102,7 +100,6 @@ def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,
     SDML.__init__(self, balance_param=balance_param,
                   sparsity_param=sparsity_param, use_cov=use_cov,
                   verbose=verbose)
-    self.num_labeled = num_labeled
     self.num_constraints = num_constraints
 
   def fit(self, X, y, random_state=np.random):
@@ -129,7 +126,6 @@ def fit(self, X, y, random_state=np.random):
       num_classes = len(np.unique(y))
       num_constraints = 20 * num_classes**2
 
-    c = Constraints.random_subset(y, self.num_labeled,
-                                  random_state=random_state)
+    c = Constraints(y)
     adj = c.adjacency_matrix(num_constraints, random_state=random_state)
     return SDML.fit(self, X, adj)

test/test_base_metric.py

@@ -30,26 +30,25 @@ def test_itml(self):
 """.strip('\n'))
     self.assertEqual(str(metric_learn.ITML_Supervised()), """
 ITML_Supervised(A0=None, bounds=None, convergence_threshold=0.001, gamma=1.0,
-        max_iter=1000, num_constraints=None, num_labeled=inf,
-        verbose=False)
+        max_iter=1000, num_constraints=None, verbose=False)
 """.strip('\n'))
 
   def test_lsml(self):
     self.assertEqual(
         str(metric_learn.LSML()),
         "LSML(max_iter=1000, prior=None, tol=0.001, verbose=False)")
     self.assertEqual(str(metric_learn.LSML_Supervised()), """
-LSML_Supervised(max_iter=1000, num_constraints=None, num_labeled=inf,
-        prior=None, tol=0.001, verbose=False, weights=None)
+LSML_Supervised(max_iter=1000, num_constraints=None, prior=None, tol=0.001,
+        verbose=False, weights=None)
 """.strip('\n'))
 
   def test_sdml(self):
     self.assertEqual(str(metric_learn.SDML()),
                      "SDML(balance_param=0.5, sparsity_param=0.01, "
                      "use_cov=True, verbose=False)")
     self.assertEqual(str(metric_learn.SDML_Supervised()), """
-SDML_Supervised(balance_param=0.5, num_constraints=None, num_labeled=inf,
-        sparsity_param=0.01, use_cov=True, verbose=False)
+SDML_Supervised(balance_param=0.5, num_constraints=None, sparsity_param=0.01,
+        use_cov=True, verbose=False)
 """.strip('\n'))
 
   def test_rca(self):
@@ -72,7 +71,7 @@ def test_mmc(self):
     self.assertEqual(str(metric_learn.MMC_Supervised()), """
 MMC_Supervised(A0=None, convergence_threshold=1e-06, diagonal=False,
         diagonal_c=1.0, max_iter=100, max_proj=10000, num_constraints=None,
-        num_labeled=inf, verbose=False)
+        verbose=False)
 """.strip('\n'))
 
 if __name__ == '__main__':