Minor PEP8 tweaks, fixing return value

Author: perimosocordiae

metric_learn/base_metric.py

@@ -48,26 +48,28 @@ def transform(self, X=None):
 
   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.
-    
+        @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)
+    return self

metric_learn/itml.py

@@ -73,6 +73,7 @@ def fit(self, X, constraints, bounds=None, A0=None, verbose=False):
     """
     a,b,c,d = self._process_inputs(X, constraints, bounds, A0)
     gamma = self.params['gamma']
+    conv_thresh = self.params['convergence_threshold']
     num_pos = len(a)
     num_neg = len(c)
     _lambda = np.zeros(num_pos + num_neg)
@@ -108,7 +109,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.params['convergence_threshold']:
+      if conv < conv_thresh:
         break
       lambdaold = _lambda.copy()
       if verbose:

metric_learn/lfda.py

@@ -34,7 +34,7 @@ def __init__(self, dim=None, k=7, metric='weighted'):
     '''
     if metric not in ('weighted', 'orthonormalized', 'plain'):
       raise ValueError('Invalid metric: %r' % metric)
-    
+
     self.params = {
       'dim': dim,
       'metric': metric,
@@ -100,7 +100,8 @@ def fit(self, X, Y):
     if self.params['dim'] == d:
       vals, vecs = scipy.linalg.eigh(tSb, tSw)
     else:
-      vals, vecs = scipy.sparse.linalg.eigsh(tSb, k=self.params['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.params['dim']]
     vals = vals[order]

metric_learn/lmnn.py

@@ -47,9 +47,9 @@ def _process_inputs(self, X, labels):
     self.X = X
     self.L = np.eye(X.shape[1])
     required_k = np.bincount(self.label_inds).min()
-    k = self.params['k']
-    assert k <= required_k, ('not enough class labels for specified k' +
-                             ' (smallest class has %d)' % required_k)
+    assert self.params['k'] <= required_k, (
+        'not enough class labels for specified k'
+        ' (smallest class has %d)' % required_k)
 
   def fit(self, X, labels, verbose=False):
     k = self.params['k']

metric_learn/lsml.py

@@ -68,10 +68,11 @@ 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)
+    tol = self.params['tol']
     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.params['tol']:
+      if grad_norm < tol:
         break
       if verbose:
         print('gradient norm', grad_norm)

metric_learn/nca.py

@@ -34,6 +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]
+    learning_rate = self.params['learning_rate']
     for it in xrange(self.params['max_iter']):
       for i, label in enumerate(labels):
         mask = masks[i]
@@ -45,7 +46,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.params['learning_rate'] * A.dot(d)
+        A += learning_rate * A.dot(d)
 
     self.X = X
     self.A = A

metric_learn/sdml.py

@@ -22,6 +22,7 @@ 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)
+    use_cov: controls prior matrix, will use the identity if use_cov=False
     '''
     self.params = {
       'balance_param': balance_param,
@@ -52,7 +53,8 @@ def fit(self, X, W, verbose=False):
     emp_cov = pinvh(P)
     # hack: ensure positive semidefinite
     emp_cov = emp_cov.T.dot(emp_cov)
-    self.M, _ = graph_lasso(emp_cov, self.params['sparsity_param'], verbose=verbose)
+    self.M, _ = graph_lasso(emp_cov, self.params['sparsity_param'],
+                            verbose=verbose)
     return self
 
   @classmethod