Moved params to dictionary for all methods

Author: svecon

metric_learn/itml.py

@@ -30,9 +30,11 @@ def __init__(self, gamma=1., max_iters=1000, convergence_threshold=1e-3):
     max_iters : int, optional
     convergence_threshold : float, optional
     """
-    self.gamma = gamma
-    self.max_iters = max_iters
-    self.convergence_threshold = convergence_threshold
+    self.params = {
+      'gamma': gamma,
+      'max_iters': max_iters,
+      'convergence_threshold': convergence_threshold,
+    }
 
   def _process_inputs(self, X, constraints, bounds, A0):
     self.X = X
@@ -70,7 +72,7 @@ def fit(self, X, constraints, bounds=None, A0=None, verbose=False):
         initial regularization matrix, defaults to identity
     """
     a,b,c,d = self._process_inputs(X, constraints, bounds, A0)
-    gamma = self.gamma
+    gamma = self.params['gamma']
     num_pos = len(a)
     num_neg = len(c)
     _lambda = np.zeros(num_pos + num_neg)
@@ -80,7 +82,7 @@ def fit(self, X, constraints, bounds=None, A0=None, verbose=False):
     neg_bhat = np.zeros(num_neg) + self.bounds[1]
     A = self.A
 
-    for it in xrange(self.max_iters):
+    for it in xrange(self.params['max_iters']):
       # update positives
       vv = self.X[a] - self.X[b]
       for i,v in enumerate(vv):
@@ -106,7 +108,7 @@ def fit(self, X, constraints, bounds=None, A0=None, verbose=False):
         conv = np.inf
         break
       conv = np.abs(lambdaold - _lambda).sum() / normsum
-      if conv < self.convergence_threshold:
+      if conv < self.params['convergence_threshold']:
         break
       lambdaold = _lambda.copy()
       if verbose:

metric_learn/lsml.py

@@ -24,8 +24,10 @@ def __init__(self, tol=1e-3, max_iter=1000):
     tol : float, optional
     max_iter : int, optional
     """
-    self.tol = tol
-    self.max_iter = max_iter
+    self.params = {
+      'tol': tol,
+      'max_iter': max_iter,
+    }
 
   def _prepare_inputs(self, X, constraints, weights, prior):
     self.X = X
@@ -66,10 +68,10 @@ def fit(self, X, constraints, weights=None, prior=None, verbose=False):
     step_sizes = np.logspace(-10, 0, 10)
     if verbose:
       print('initial loss', s_best)
-    for it in xrange(1, self.max_iter+1):
+    for it in xrange(1, self.params['max_iter']+1):
       grad = self._gradient(self.M, prior_inv)
       grad_norm = scipy.linalg.norm(grad)
-      if grad_norm < self.tol:
+      if grad_norm < self.params['tol']:
         break
       if verbose:
         print('gradient norm', grad_norm)

metric_learn/rca.py

@@ -27,7 +27,9 @@ def __init__(self, dim=None):
     dim : int, optional
         embedding dimension (default: original dimension of data)
     """
-    self.dim = dim
+    self.params = {
+      'dim': dim,
+    }
 
   def transformer(self):
     return self._transformer
@@ -37,9 +39,9 @@ def _process_inputs(self, X, Y):
     self.X = X
     n, d = X.shape
 
-    if self.dim is None:
-      self.dim = d
-    elif not 0 < self.dim <= d:
+    if self.params['dim'] is None:
+      self.params['dim'] = d
+    elif not 0 < self.params['dim'] <= d:
       raise ValueError('Invalid embedding dimension, must be in [1,%d]' % d)
 
     Y = np.asanyarray(Y)
@@ -75,11 +77,11 @@ def fit(self, data, chunks):
     inner_cov = np.cov(chunk_data, rowvar=0, bias=1)
 
     # Fisher Linear Discriminant projection
-    if self.dim < d:
+    if self.params['dim'] < d:
       total_cov = np.cov(data[chunk_mask], rowvar=0)
       tmp = np.linalg.lstsq(total_cov, inner_cov)[0]
       vals, vecs = np.linalg.eig(tmp)
-      inds = np.argsort(vals)[:self.dim]
+      inds = np.argsort(vals)[:self.params['dim']]
       A = vecs[:,inds]
       inner_cov = A.T.dot(inner_cov).dot(A)
       self._transformer = _inv_sqrtm(inner_cov).dot(A.T)

metric_learn/sdml.py

@@ -23,14 +23,16 @@ def __init__(self, balance_param=0.5, sparsity_param=0.01, use_cov=True):
     balance_param: trade off between sparsity and M0 prior
     sparsity_param: trade off between optimizer and sparseness (see graph_lasso)
     '''
-    self.balance_param = balance_param
-    self.sparsity_param = sparsity_param
-    self.use_cov = use_cov
+    self.params = {
+      'balance_param': balance_param,
+      'sparsity_param': sparsity_param,
+      'use_cov': use_cov,
+    }
 
   def _prepare_inputs(self, X, W):
     self.X = X
     # set up prior M
-    if self.use_cov:
+    if self.params['use_cov']:
       self.M = np.cov(X.T)
     else:
       self.M = np.identity(X.shape[1])
@@ -46,11 +48,11 @@ def fit(self, X, W, verbose=False):
     W: connectivity graph, (n x n). +1 for positive pairs, -1 for negative.
     """
     self._prepare_inputs(X, W)
-    P = pinvh(self.M) + self.balance_param * self.loss_matrix
+    P = pinvh(self.M) + self.params['balance_param'] * self.loss_matrix
     emp_cov = pinvh(P)
     # hack: ensure positive semidefinite
     emp_cov = emp_cov.T.dot(emp_cov)
-    self.M, _ = graph_lasso(emp_cov, self.sparsity_param, verbose=verbose)
+    self.M, _ = graph_lasso(emp_cov, self.params['sparsity_param'], verbose=verbose)
     return self
 
   @classmethod