int input checks and tests

Author: grudloff

metric_learn/scml.py

@@ -43,6 +43,20 @@ def _fit(self, triplets, basis=None, n_basis=None):
     dual averaging method.
     """
 
+    if not isinstance(self.max_iter, int):
+      raise ValueError("max_iter should be an integer, instead it is of type"
+                       " %s" % type(self.max_iter))
+    if not isinstance(self.output_iter, int):
+      raise ValueError("output_iter should be an integer, instead it is of "
+                       "type %s" % type(self.output_iter))
+    if not isinstance(self.batch_size, int):
+      raise ValueError("batch_size should be an integer, instead it is of type"
+                       " %s" % type(self.batch_size))
+
+    if(self.output_iter > self.max_iter):
+      raise ValueError("The value of output_iter must be equal or smaller than"
+                       " max_iter.")
+
     # Currently prepare_inputs makes triplets contain points and not indices
     triplets = self._prepare_inputs(triplets, type_of_inputs='tuples')
 
@@ -76,6 +90,23 @@ def _fit(self, triplets, basis=None, n_basis=None):
     rand_int = rng.randint(low=0, high=n_triplets,
                            size=(self.max_iter, self.batch_size))
     for iter in range(self.max_iter):
+
+      idx = rand_int[iter]
+
+      slack_val = 1 + np.matmul(dist_diff[idx, :], w.T)
+      slack_mask = np.squeeze(slack_val > 0, axis=1)
+
+      grad_w = np.sum(dist_diff[idx[slack_mask], :],
+                      axis=0, keepdims=True)/self.batch_size
+      avg_grad_w = (iter * avg_grad_w + grad_w) / (iter+1)
+
+      ada_grad_w = np.sqrt(np.square(ada_grad_w) + np.square(grad_w))
+
+      scale_f = -(iter+1) / self.gamma / (delta + ada_grad_w)
+
+      # proximal operator with negative trimming equivalent
+      w = scale_f * np.minimum(avg_grad_w + self.beta, 0)
+
       if (iter + 1) % self.output_iter == 0:
         # regularization part of obj function
         obj1 = np.sum(w)*self.beta
@@ -100,22 +131,6 @@ def _fit(self, triplets, basis=None, n_basis=None):
           best_obj = obj
           best_w = w
 
-      idx = rand_int[iter]
-
-      slack_val = 1 + np.matmul(dist_diff[idx, :], w.T)
-      slack_mask = np.squeeze(slack_val > 0, axis=1)
-
-      grad_w = np.sum(dist_diff[idx[slack_mask], :],
-                      axis=0, keepdims=True)/self.batch_size
-      avg_grad_w = (iter * avg_grad_w + grad_w) / (iter+1)
-
-      ada_grad_w = np.sqrt(np.square(ada_grad_w) + np.square(grad_w))
-
-      scale_f = -(iter+1) / self.gamma / (delta + ada_grad_w)
-
-      # proximal operator with negative trimming equivalent
-      w = scale_f * np.minimum(avg_grad_w + self.beta, 0)
-
     if self.verbose:
       print("max iteration reached.")
 
@@ -506,6 +521,13 @@ def fit(self, X, y):
 
     basis, n_basis = self._initialize_basis_supervised(X, y)
 
+    if not isinstance(self.k_genuine, int):
+      raise ValueError("k_genuine should be an integer, instead it is of type"
+                       " %s" % type(self.k_genuine))
+    if not isinstance(self.k_impostor, int):
+      raise ValueError("k_impostor should be an integer, instead it is of "
+                       "type %s" % type(self.k_impostor))
+
     constraints = Constraints(y)
     triplets = constraints.generate_knntriplets(X, self.k_genuine,
                                                 self.k_impostor)

test/metric_learn_test.py

@@ -203,10 +203,11 @@ def test_array_basis(self, estimator, data):
   def test_verbose(self, estimator, data, capsys):
     # assert there is proper output when verbose = True
     model = estimator(preprocessor=np.array([[0, 0], [1, 1], [2, 2], [3, 3]]),
-                      max_iter=1, output_iter=1, batch_size=1, verbose=True)
+                      max_iter=1, output_iter=1, batch_size=1, basis='triplet_diffs',
+                      random_state=42, verbose=True)
     model.fit(*data)
     out, _ = capsys.readouterr()
-    expected_out = ('[%s] iter 1\t obj 1.000000\t num_imp 8\n'
+    expected_out = ('[%s] iter 1\t obj 0.569946\t num_imp 2\n'
                     'max iteration reached.\n' % estimator.__name__)
     assert out == expected_out
 
@@ -276,6 +277,52 @@ def test_lda(self, n_samples, n_features, n_classes):
     assert n_basis == expected_n_basis
     assert basis.shape == expected_shape
 
+  @pytest.mark.parametrize('name', ['max_iter', 'output_iter', 'batch_size',
+                                    'n_basis'])
+  def test_int_inputs(self, name):
+    value = 1.0
+    d = {name: value}
+    scml = SCML(**d)
+    triplets = np.array([[[0, 1], [2, 1], [0, 0]],
+                         [[2, 1], [0, 1], [2, 0]],
+                         [[0, 0], [2, 0], [0, 1]],
+                         [[2, 0], [0, 0], [2, 1]]])
+
+    msg = name
+    msg += (" should be an integer, instead it is of type"
+            " %s" % type(value))
+    with pytest.raises(ValueError) as raised_error:
+      scml.fit(triplets)
+    assert msg == raised_error.value.args[0]
+
+  @pytest.mark.parametrize('name', ['max_iter', 'output_iter', 'batch_size',
+                                    'k_genuine', 'k_impostor', 'n_basis'])
+  def test_int_inputs_supervised(self, name):
+    value = 1.0
+    d = {name: value}
+    scml = SCML_Supervised(**d)
+    X = np.array([[0, 0], [1, 1], [3, 3], [4, 4]])
+    y = np.array([1, 1, 0, 0])
+    msg = name
+    msg += (" should be an integer, instead it is of type"
+            " %s" % type(value))
+    with pytest.raises(ValueError) as raised_error:
+      scml.fit(X, y)
+    assert msg == raised_error.value.args[0]
+
+  def test_large_output_iter(self):
+    scml = SCML(max_iter=1, output_iter=2)
+    triplets = np.array([[[0, 1], [2, 1], [0, 0]],
+                         [[2, 1], [0, 1], [2, 0]],
+                         [[0, 0], [2, 0], [0, 1]],
+                         [[2, 0], [0, 0], [2, 1]]])
+    msg = ("The value of output_iter must be equal or smaller than"
+           " max_iter.")
+
+    with pytest.raises(ValueError) as raised_error:
+      scml.fit(triplets)
+    assert msg == raised_error.value.args[0]
+
 
 class TestLSML(MetricTestCase):
   def test_iris(self):