Remove some usages of _filter_kwargs and code that triggers warnings from _filter_kwargs (#1895)

Summary:
## Motivation

Unused keyword arguments are a perennial bugbear. All else equal, it's better for a function to error upon receiving an unused keyword argument rather than ignoring it. `_filter_kwargs` gives a warning rather than an error if unused keyword arguments are passed. The warnings were cluttering unit test output and annoying me, so I removed usage of `_filter_kwargs` where it was straightforward to do so. I left a couple calls that would have been tricky to change. I also updated a tutorial to not use the deprected `fit_gpytorch_torch` function, which tends to generate a lot of `_filter_kwargs` warnings.

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

Yes

Pull Request resolved: #1895

Test Plan: Units

Reviewed By: SebastianAment

Differential Revision: D46831065

Pulled By: esantorella

fbshipit-source-id: db8843cbe7e7649afe57472a3c6fae60c6e33fdb

Author: esantorella

botorch/generation/gen.py

@@ -29,7 +29,7 @@
     NLC_TOL,
 )
 from botorch.optim.stopping import ExpMAStoppingCriterion
-from botorch.optim.utils import _filter_kwargs, columnwise_clamp, fix_features
+from botorch.optim.utils import columnwise_clamp, fix_features
 from botorch.optim.utils.timeout import minimize_with_timeout
 from scipy.optimize import OptimizeResult
 from torch import Tensor
@@ -367,9 +367,7 @@ def gen_candidates_torch(
 
     i = 0
     stop = False
-    stopping_criterion = ExpMAStoppingCriterion(
-        **_filter_kwargs(ExpMAStoppingCriterion, **options)
-    )
+    stopping_criterion = ExpMAStoppingCriterion(**options)
     while not stop:
         i += 1
         with torch.no_grad():

botorch/optim/optimize.py

@@ -282,11 +282,6 @@ def _optimize_acqf_batch(opt_inputs: OptimizeAcqfInputs) -> Tuple[Tensor, Tensor
         if not opt_inputs.nonlinear_inequality_constraints
         else 1,
     )
-    has_parameter_constraints = (
-        opt_inputs.inequality_constraints is not None
-        or opt_inputs.equality_constraints is not None
-        or opt_inputs.nonlinear_inequality_constraints is not None
-    )
 
     def _optimize_batch_candidates() -> Tuple[Tensor, Tensor, List[Warning]]:
         batch_candidates_list: List[Tensor] = []
@@ -308,16 +303,17 @@ def _optimize_batch_candidates() -> Tuple[Tensor, Tensor, List[Warning]]:
             "timeout_sec": timeout_sec,
         }
 
-        if has_parameter_constraints:
-            gen_kwargs.update(
-                {
-                    "inequality_constraints": opt_inputs.inequality_constraints,
-                    "equality_constraints": opt_inputs.equality_constraints,
-                    "nonlinear_inequality_constraints": (
-                        opt_inputs.nonlinear_inequality_constraints
-                    ),
-                }
-            )
+        # only add parameter constraints to gen_kwargs if they are specified
+        # to avoid unnecessary warnings in _filter_kwargs
+        if opt_inputs.inequality_constraints is not None:
+            gen_kwargs["inequality_constraints"] = opt_inputs.inequality_constraints
+        if opt_inputs.equality_constraints is not None:
+            gen_kwargs["equality_constraints"] = opt_inputs.equality_constraints
+        if opt_inputs.nonlinear_inequality_constraints is not None:
+            gen_kwargs[
+                "nonlinear_inequality_constraints"
+            ] = opt_inputs.nonlinear_inequality_constraints
+
         filtered_gen_kwargs = _filter_kwargs(opt_inputs.gen_candidates, **gen_kwargs)
 
         for i, batched_ics_ in enumerate(batched_ics):

botorch/optim/stopping.py

@@ -6,7 +6,6 @@
 
 from __future__ import annotations
 
-import typing  # noqa F401
 from abc import ABC, abstractmethod
 
 import torch

test/generation/test_gen.py

@@ -105,9 +105,7 @@ def test_gen_candidates(
                 self.assertTrue(-EPS <= candidates <= 1 + EPS)
 
     def test_gen_candidates_torch(self):
-        self.test_gen_candidates(
-            gen_candidates=gen_candidates_torch, options={"disp": False}
-        )
+        self.test_gen_candidates(gen_candidates=gen_candidates_torch)
 
     def test_gen_candidates_with_none_fixed_features(
         self,
@@ -144,7 +142,7 @@ def test_gen_candidates_with_none_fixed_features(
 
     def test_gen_candidates_torch_with_none_fixed_features(self):
         self.test_gen_candidates_with_none_fixed_features(
-            gen_candidates=gen_candidates_torch, options={"disp": False}
+            gen_candidates=gen_candidates_torch
         )
 
     def test_gen_candidates_with_fixed_features(
@@ -184,21 +182,20 @@ def test_gen_candidates_with_fixed_features(
     def test_gen_candidates_with_fixed_features_and_timeout(self):
         with self.assertLogs("botorch", level="INFO") as logs:
             self.test_gen_candidates_with_fixed_features(
-                options={"disp": False},
                 timeout_sec=1e-4,
+                options={"disp": False},
             )
         self.assertTrue(any("Optimization timed out" in o for o in logs.output))
 
     def test_gen_candidates_torch_with_fixed_features(self):
         self.test_gen_candidates_with_fixed_features(
-            gen_candidates=gen_candidates_torch, options={"disp": False}
+            gen_candidates=gen_candidates_torch
         )
 
     def test_gen_candidates_torch_with_fixed_features_and_timeout(self):
         with self.assertLogs("botorch", level="INFO") as logs:
             self.test_gen_candidates_with_fixed_features(
                 gen_candidates=gen_candidates_torch,
-                options={"disp": False},
                 timeout_sec=1e-4,
             )
         self.assertTrue(any("Optimization timed out" in o for o in logs.output))
@@ -335,23 +332,23 @@ def test_gen_candidates_scipy_nan_handling(self):
                     acquisition_function=mock.Mock(),
                 )
 
-    def test_gen_candidates_without_grad(self):
+    def test_gen_candidates_without_grad(self) -> None:
+        """Test with `with_grad=False` (not supported for gen_candidates_torch)."""
 
-        for gen_candidates in (gen_candidates_scipy, gen_candidates_torch):
-            self.test_gen_candidates(
-                gen_candidates=gen_candidates,
-                options={"disp": False, "with_grad": False},
-            )
+        self.test_gen_candidates(
+            gen_candidates=gen_candidates_scipy,
+            options={"disp": False, "with_grad": False},
+        )
 
-            self.test_gen_candidates_with_fixed_features(
-                gen_candidates=gen_candidates,
-                options={"disp": False, "with_grad": False},
-            )
+        self.test_gen_candidates_with_fixed_features(
+            gen_candidates=gen_candidates_scipy,
+            options={"disp": False, "with_grad": False},
+        )
 
-            self.test_gen_candidates_with_none_fixed_features(
-                gen_candidates=gen_candidates,
-                options={"disp": False, "with_grad": False},
-            )
+        self.test_gen_candidates_with_none_fixed_features(
+            gen_candidates=gen_candidates_scipy,
+            options={"disp": False, "with_grad": False},
+        )
 
 
 class TestRandomRestartOptimization(TestBaseCandidateGeneration):

test/optim/test_fit.py

@@ -393,7 +393,7 @@ def test_fit_gpytorch_torch(self):
                 self._test_fit_gpytorch_torch(mll.to(dtype=dtype))
 
     def _test_fit_gpytorch_torch(self, mll):
-        options = {"disp": False, "maxiter": 3}
+        options = {"maxiter": 3}
         ckpt = {
             k: TensorCheckpoint(v.detach().clone(), v.device, v.dtype)
             for k, v in mll.state_dict().items()

test/optim/test_optimize.py

@@ -292,9 +292,19 @@ def test_optimize_acqf_sequential(
                         4 * torch.ones(3, device=self.device, dtype=dtype),
                     ]
                 )
-                inequality_constraints = [
-                    (torch.tensor([2]), torch.tensor([4]), torch.tensor(5))
-                ]
+                if mock_gen_candidates is mock_gen_candidates_scipy:
+                    # x[2] * 4 >= 5
+                    inequality_constraints = [
+                        (torch.tensor([2]), torch.tensor([4]), torch.tensor(5))
+                    ]
+                    equality_constraints = [
+                        (torch.tensor([0, 1]), torch.ones(2), torch.tensor(4.0))
+                    ]
+                # gen_candidates_torch does not support constraints
+                else:
+                    inequality_constraints = None
+                    equality_constraints = None
+
                 mock_gen_candidates.reset_mock()
                 candidates, acq_value = optimize_acqf(
                     acq_function=mock_acq_function,
@@ -304,6 +314,7 @@ def test_optimize_acqf_sequential(
                     raw_samples=raw_samples,
                     options=options,
                     inequality_constraints=inequality_constraints,
+                    equality_constraints=equality_constraints,
                     post_processing_func=rounding_func if use_rounding else None,
                     sequential=True,
                     timeout_sec=timeout_sec,
@@ -1015,9 +1026,8 @@ def nlc(x):
                 if mock_gen_candidates == mock_gen_candidates_torch:
                     self.assertEqual(len(ws), 3)
                     message = (
-                        "Keyword arguments ['nonlinear_inequality_constraints',"
-                        " 'equality_constraints', 'inequality_constraints'] will"
-                        " be ignored because they are not allowed parameters for"
+                        "Keyword arguments ['nonlinear_inequality_constraints']"
+                        " will be ignored because they are not allowed parameters for"
                         " function gen_candidates. Allowed parameters are "
                         " ['initial_conditions', 'acquisition_function', "
                         "'lower_bounds', 'upper_bounds', 'optimizer', 'options',"