More informative errors for wrong index dtype (#1345)

Summary:
## Motivation

This is fixing a very minor issue and I've probably already spent too much time on it. Unless anyone feels really strongly about this, I'd prefer to either have this quickly either accepted or rejected rather than spend a while iterating on revisions.

In the past it was possible to use indexers with dtypes that torch does not accept as indexers via `equality_constraints` and `inequality_constraints`. This was never really intended behavior and stopped being supported in #1341 (discussed in #1225 ) . This PR makes errors more informative if someone does try to use the wrong dtypes, since the existing error message did not make clear where the error came from.

I aslo refactored a test in test_initalizers.py.

### Have you read the [Contributing Guidelines on pull requests](https://github.com/pytorch/botorch/blob/main/CONTRIBUTING.md#pull-requests)?

Yes

Pull Request resolved: #1345

Test Plan:
Unit tests for errors raised

## Related PRs

#1341

Reviewed By: Balandat

Differential Revision: D38627695

Pulled By: esantorella

fbshipit-source-id: e9e4e917b79f81a36d74b79ff3b0f710667283cb

Author: esantorella

botorch/utils/sampling.py

@@ -888,12 +888,28 @@ def get_polytope_samples(
     """
     # create tensors representing linear inequality constraints
     # of the form Ax >= b.
+    # TODO: remove this error handling functionality in a few releases.
+    # Context: BoTorch inadvertently supported indices with unusual dtypes.
+    # This is now not supported.
+    index_dtype_error = (
+        "Normalizing {var_name} failed. Check that the first "
+        "element of {var_name} is the correct dtype following "
+        "the previous IndexError."
+    )
     if inequality_constraints:
         # normalize_linear_constraints is called to solve this issue:
         # https://github.com/pytorch/botorch/issues/1225
+        try:
+            # non-standard dtypes used to be supported for indices in constraints;
+            # this is no longer true
+            constraints = normalize_linear_constraints(bounds, inequality_constraints)
+        except IndexError as e:
+            msg = index_dtype_error.format(var_name="`inequality_constraints`")
+            raise ValueError(msg) from e
+
         A, b = sparse_to_dense_constraints(
             d=bounds.shape[-1],
-            constraints=normalize_linear_constraints(bounds, inequality_constraints),
+            constraints=constraints,
         )
         # Note the inequality constraints are of the form Ax >= b,
         # but PolytopeSampler expects inequality constraints of the
@@ -902,11 +918,18 @@ def get_polytope_samples(
     else:
         dense_inequality_constraints = None
     if equality_constraints:
+        try:
+            # non-standard dtypes used to be supported for indices in constraints;
+            # this is no longer true
+            constraints = normalize_linear_constraints(bounds, equality_constraints)
+        except IndexError as e:
+            msg = index_dtype_error.format(var_name="`equality_constraints`")
+            raise ValueError(msg) from e
+
         # normalize_linear_constraints is called to solve this issue:
         # https://github.com/pytorch/botorch/issues/1225
         dense_equality_constraints = sparse_to_dense_constraints(
-            d=bounds.shape[-1],
-            constraints=normalize_linear_constraints(bounds, equality_constraints),
+            d=bounds.shape[-1], constraints=constraints
         )
     else:
         dense_equality_constraints = None

test/utils/test_sampling.py

@@ -312,6 +312,22 @@ def test_normalize_linear_constraints(self):
             expected_rhs = 0.5
             self.assertAlmostEqual(new_constraints[0][-1], expected_rhs)
 
+    def test_normalize_linear_constraints_wrong_dtype(self):
+        for dtype in (torch.float, torch.double):
+            with self.subTest(dtype=dtype):
+                tkwargs = {"device": self.device, "dtype": dtype}
+                constraints = [
+                    (
+                        torch.ones(3, dtype=torch.float, device=self.device),
+                        torch.ones(3, **tkwargs),
+                        1.0,
+                    )
+                ]
+                bounds = torch.zeros(2, 4, **tkwargs)
+                msg = "tensors used as indices must be long, byte or bool tensors"
+                with self.assertRaises(IndexError, msg=msg):
+                    normalize_linear_constraints(bounds, constraints)
+
     def test_find_interior_point(self):
         # basic problem: 1 <= x_1 <= 2, 2 <= x_2 <= 3
         A = np.concatenate([np.eye(2), -np.eye(2)], axis=0)
@@ -333,6 +349,64 @@ def test_find_interior_point(self):
         x = find_interior_point(A=A, b=b)
         self.assertAlmostEqual(x.item(), 5.0, places=4)
 
+    def test_get_polytope_samples_wrong_inequality_constraints_dtype(self):
+        for dtype in (torch.float, torch.double):
+            with self.subTest(dtype=dtype):
+                tkwargs = {"device": self.device, "dtype": dtype}
+                bounds = torch.zeros(2, 4, **tkwargs)
+                inequality_constraints = [
+                    (
+                        torch.tensor([3], dtype=torch.float, device=self.device),
+                        torch.tensor([-4], **tkwargs),
+                        -3,
+                    )
+                ]
+
+                msg = (
+                    "Normalizing `inequality_constraints` failed. Check that the first "
+                    "element of `inequality_constraints` is the correct dtype following"
+                    " the previous IndexError."
+                )
+                msg_orig = "tensors used as indices must be long, byte or bool tensors"
+
+                with self.assertRaisesRegex(ValueError, msg), self.assertRaisesRegex(
+                    IndexError, msg_orig
+                ):
+                    get_polytope_samples(
+                        n=5,
+                        bounds=bounds,
+                        inequality_constraints=inequality_constraints,
+                    )
+
+    def test_get_polytope_samples_wrong_equality_constraints_dtype(self):
+        for dtype in (torch.float, torch.double):
+            with self.subTest(dtype=dtype):
+                tkwargs = {"device": self.device, "dtype": dtype}
+                bounds = torch.zeros(2, 4, **tkwargs)
+
+                equality_constraints = [
+                    (
+                        torch.tensor([0], dtype=torch.float, device=self.device),
+                        torch.tensor([1], **tkwargs),
+                        0.5,
+                    )
+                ]
+                msg = (
+                    "Normalizing `equality_constraints` failed. Check that the first "
+                    "element of `equality_constraints` is the correct dtype following "
+                    "the previous IndexError."
+                )
+                msg_orig = "tensors used as indices must be long, byte or bool tensors"
+
+                with self.assertRaisesRegex(ValueError, msg), self.assertRaisesRegex(
+                    IndexError, msg_orig
+                ):
+                    get_polytope_samples(
+                        n=5,
+                        bounds=bounds,
+                        equality_constraints=equality_constraints,
+                    )
+
     def test_get_polytope_samples(self):
         tkwargs = {"device": self.device}
         for dtype in (torch.float, torch.double):