[MRG] Added random_states (#35)

Author: bhargavvader

metric_learn/constraints.py

@@ -19,8 +19,8 @@ def __init__(self, partial_labels):
     self.known_label_idx, = np.where(partial_labels >= 0)
     self.known_labels = partial_labels[self.known_label_idx]
 
-  def adjacency_matrix(self, num_constraints):
-    a, b, c, d = self.positive_negative_pairs(num_constraints)
+  def adjacency_matrix(self, num_constraints, random_state=np.random):
+    a, b, c, d = self.positive_negative_pairs(num_constraints, random_state=random_state)
     row = np.concatenate((a, c))
     col = np.concatenate((b, d))
     data = np.ones_like(row, dtype=int)
@@ -29,48 +29,51 @@ def adjacency_matrix(self, num_constraints):
     # symmetrize
     return adj + adj.T
 
-  def positive_negative_pairs(self, num_constraints, same_length=False):
-    a, b = self._pairs(num_constraints, same_label=True)
-    c, d = self._pairs(num_constraints, same_label=False)
+  def positive_negative_pairs(self, num_constraints, same_length=False, random_state=np.random):
+    a, b = self._pairs(num_constraints, same_label=True, random_state=random_state)
+    c, d = self._pairs(num_constraints, same_label=False, random_state=random_state)
     if same_length and len(a) != len(c):
       n = min(len(a), len(c))
       return a[:n], b[:n], c[:n], d[:n]
     return a, b, c, d
 
-  def _pairs(self, num_constraints, same_label=True, max_iter=10):
+  def _pairs(self, num_constraints, same_label=True, max_iter=10, random_state=np.random):
     num_labels = len(self.known_labels)
     ab = set()
     it = 0
     while it < max_iter and len(ab) < num_constraints:
       nc = num_constraints - len(ab)
-      for aidx in np.random.randint(num_labels, size=nc):
+      for aidx in random_state.randint(num_labels, size=nc):
         if same_label:
           mask = self.known_labels[aidx] == self.known_labels
           mask[aidx] = False  # avoid identity pairs
         else:
           mask = self.known_labels[aidx] != self.known_labels
         b_choices, = np.where(mask)
         if len(b_choices) > 0:
-          ab.add((aidx, np.random.choice(b_choices)))
+          ab.add((aidx, random_state.choice(b_choices)))
       it += 1
     if len(ab) < num_constraints:
       warnings.warn("Only generated %d %s constraints (requested %d)" % (
           len(ab), 'positive' if same_label else 'negative', num_constraints))
     ab = np.array(list(ab)[:num_constraints], dtype=int)
     return self.known_label_idx[ab.T]
 
-  def chunks(self, num_chunks=100, chunk_size=2):
+  def chunks(self, num_chunks=100, chunk_size=2, random_state=np.random):
+    """
+    the random state object to be passed must be a numpy random seed
+    """
     chunks = -np.ones_like(self.known_label_idx, dtype=int)
     uniq, lookup = np.unique(self.known_labels, return_inverse=True)
     all_inds = [set(np.where(lookup==c)[0]) for c in xrange(len(uniq))]
     idx = 0
     while idx < num_chunks and all_inds:
-      c = random.randint(0, len(all_inds)-1)
+      c = random_state.randint(0, high=len(all_inds)-1)
       inds = all_inds[c]
       if len(inds) < chunk_size:
         del all_inds[c]
         continue
-      ii = random.sample(inds, chunk_size)
+      ii = random_state.choice(list(inds), chunk_size, replace=False)
       inds.difference_update(ii)
       chunks[ii] = idx
       idx += 1
@@ -80,10 +83,13 @@ def chunks(self, num_chunks=100, chunk_size=2):
     return chunks
 
   @staticmethod
-  def random_subset(all_labels, num_preserved=np.inf):
+  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 = np.random.randint(n, size=num_ignored)
+    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

@@ -166,7 +166,7 @@ def __init__(self, gamma=1., max_iters=1000, convergence_threshold=1e-3,
     self.params.update(num_labeled=num_labeled, num_constraints=num_constraints,
                        bounds=bounds, A0=A0)
 
-  def fit(self, X, labels):
+  def fit(self, X, labels, random_state=np.random):
     """Create constraints from labels and learn the ITML model.
     Needs num_constraints specified in constructor.
 
@@ -175,12 +175,13 @@ def fit(self, X, labels):
     X : (n x d) data matrix
         each row corresponds to a single instance
     labels : (n) data labels
+    random_state : a numpy random.seed object to fix the random_state if needed.
     """
     num_constraints = self.params['num_constraints']
     if num_constraints is None:
       num_classes = np.unique(labels)
       num_constraints = 20*(len(num_classes))**2
 
-    c = Constraints.random_subset(labels, self.params['num_labeled'])
+    c = Constraints.random_subset(labels, self.params['num_labeled'], random_state=random_state)
     return ITML.fit(self, X, c.positive_negative_pairs(num_constraints),
                     bounds=self.params['bounds'], A0=self.params['A0'])

metric_learn/lsml.py

@@ -155,7 +155,7 @@ def __init__(self, tol=1e-3, max_iter=1000, prior=None, num_labeled=np.inf,
     self.params.update(prior=prior, num_labeled=num_labeled,
                        num_constraints=num_constraints, weights=weights)
 
-  def fit(self, X, labels):
+  def fit(self, X, labels, random_state=np.random):
     """Create constraints from labels and learn the LSML model.
     Needs num_constraints specified in constructor.
 
@@ -164,13 +164,14 @@ def fit(self, X, labels):
     X : (n x d) data matrix
         each row corresponds to a single instance
     labels : (n) data labels
+    random_state : a numpy random.seed object to fix the random_state if needed.
     """
     num_constraints = self.params['num_constraints']
     if num_constraints is None:
       num_classes = np.unique(labels)
       num_constraints = 20*(len(num_classes))**2
 
-    c = Constraints.random_subset(labels, self.params['num_labeled'])
+    c = Constraints.random_subset(labels, self.params['num_labeled'], random_state=random_state)
     pairs = c.positive_negative_pairs(num_constraints, same_length=True)
     return LSML.fit(self, X, pairs, weights=self.params['weights'],
                     prior=self.params['prior'])

metric_learn/rca.py

@@ -112,7 +112,7 @@ def __init__(self, dim=None, num_chunks=100, chunk_size=2):
     RCA.__init__(self, dim=dim)
     self.params.update(num_chunks=num_chunks, chunk_size=chunk_size)
 
-  def fit(self, X, labels):
+  def fit(self, X, labels, random_state=np.random):
     """Create constraints from labels and learn the RCA model.
     Needs num_constraints specified in constructor.
 
@@ -121,7 +121,8 @@ def fit(self, X, labels):
     X : (n x d) data matrix
         each row corresponds to a single instance
     labels : (n) data labels
+    random_state : a random.seed object to fix the random_state if needed.
     """
     chunks = Constraints(labels).chunks(num_chunks=self.params['num_chunks'],
-                                        chunk_size=self.params['chunk_size'])
+                                        chunk_size=self.params['chunk_size'], random_state=random_state)
     return RCA.fit(self, X, chunks)

metric_learn/sdml.py

@@ -90,19 +90,20 @@ def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True,
     '''
     self.params.update(num_labeled=num_labeled, num_constraints=num_constraints)
 
-  def fit(self, X, labels):
+  def fit(self, X, labels, random_state=np.random):
     """Create constraints from labels and learn the SDML model.
 
     Parameters
     ----------
     X: data matrix, (n x d)
         each row corresponds to a single instance
     labels: data labels, (n,) array-like
+    random_state : a numpy random.seed object to fix the random_state if needed.
     """
     num_constraints = self.params['num_constraints']
     if num_constraints is None:
       num_classes = np.unique(labels)
       num_constraints = 20*(len(num_classes))**2
 
-    c = Constraints.random_subset(labels, self.params['num_labeled'])
+    c = Constraints.random_subset(labels, self.params['num_labeled'], random_state=random_state)
     return SDML.fit(self, X, c.adjacency_matrix(num_constraints))