Merge pull request #18 from svecon/master

Added get_params, set_params and params moved to dictionary

Author: perimosocordiae

metric_learn/base_metric.py

@@ -45,3 +45,29 @@ def transform(self, X=None):
       X = self.X
     L = self.transformer()
     return X.dot(L.T)
+
+  def get_params(self, deep=False):
+    """Get parameters for this metric learner.
+    
+    Parameters
+    ----------
+    deep: boolean, optional
+        @WARNING doesn't do anything, only exists because scikit-learn has this on BaseEstimator.
+    
+    Returns
+    -------
+    params : mapping of string to any
+        Parameter names mapped to their values.
+    """
+    return self.params
+    
+  def set_params(self, **kwarg):
+    """Set the parameters of this metric learner.
+    
+    Overwrites any default parameters or parameters specified in constructor.
+    
+    Returns
+    -------
+    self
+    """
+    self.params.update(kwarg)

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/lfda.py

@@ -34,9 +34,12 @@ def __init__(self, dim=None, k=7, metric='weighted'):
     '''
     if metric not in ('weighted', 'orthonormalized', 'plain'):
       raise ValueError('Invalid metric: %r' % metric)
-    self.dim = dim
-    self.metric = metric
-    self.k = k
+    
+    self.params = {
+      'dim': dim,
+      'metric': metric,
+      'k': k,
+    }
 
   def transformer(self):
     return self._transformer
@@ -48,12 +51,12 @@ def _process_inputs(self, X, Y):
     unique_classes, Y = np.unique(Y, return_inverse=True)
     num_classes = len(unique_classes)
 
-    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)
 
-    if not 0 < self.k < d:
+    if not 0 < self.params['k'] < d:
       raise ValueError('Invalid k, must be in [0,%d]' % (d-1))
 
     return X, Y, num_classes, n, d
@@ -74,7 +77,7 @@ def fit(self, X, Y):
       # classwise affinity matrix
       dist = pairwise_distances(Xc, metric='l2', squared=True)
       # distances to k-th nearest neighbor
-      k = min(self.k, nc-1)
+      k = min(self.params['k'], nc-1)
       sigma = np.sqrt(np.partition(dist, k, axis=0)[:,k])
 
       local_scale = np.outer(sigma, sigma)
@@ -94,21 +97,22 @@ def fit(self, X, Y):
     tSw += tSw.T
     tSw /= 2
 
-    if self.dim == d:
+    if self.params['dim'] == d:
       vals, vecs = scipy.linalg.eigh(tSb, tSw)
     else:
-      vals, vecs = scipy.sparse.linalg.eigsh(tSb, k=self.dim, M=tSw, which='LA')
+      vals, vecs = scipy.sparse.linalg.eigsh(tSb, k=self.params['dim'], M=tSw, which='LA')
 
-    order = np.argsort(-vals)[:self.dim]
+    order = np.argsort(-vals)[:self.params['dim']]
     vals = vals[order]
     vecs = vecs[:,order]
 
-    if self.metric == 'weighted':
+    if self.params['metric'] == 'weighted':
        vecs *= np.sqrt(vals)
-    elif self.metric == 'orthonormalized':
+    elif self.params['metric'] == 'orthonormalized':
        vecs, _ = np.linalg.qr(vecs)
 
     self._transformer = vecs.T
+    return self
 
 
 def _sum_outer(x):

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/nca.py

@@ -11,8 +11,10 @@
 
 class NCA(BaseMetricLearner):
   def __init__(self, max_iter=100, learning_rate=0.01):
-    self.max_iter = max_iter
-    self.learning_rate = learning_rate
+    self.params = {
+      'max_iter': max_iter,
+      'learning_rate': learning_rate,
+    }
     self.A = None
 
   def transformer(self):
@@ -32,7 +34,7 @@ def fit(self, X, labels):
     dX = X[:,None] - X[None]  # shape (n, n, d)
     tmp = np.einsum('...i,...j->...ij', dX, dX)  # shape (n, n, d, d)
     masks = labels[:,None] == labels[None]
-    for it in xrange(self.max_iter):
+    for it in xrange(self.params['max_iter']):
       for i, label in enumerate(labels):
         mask = masks[i]
         Ax = A.dot(X.T).T  # shape (n, d)
@@ -43,7 +45,7 @@ def fit(self, X, labels):
 
         t = softmax[:, None, None] * tmp[i]  # shape (n, d, d)
         d = softmax[mask].sum() * t.sum(axis=0) - t[mask].sum(axis=0)
-        A += self.learning_rate * A.dot(d)
+        A += self.params['learning_rate'] * A.dot(d)
 
     self.X = X
     self.A = A

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