Remove indent that existed only to make review of previous diff easier (#1523)

Summary:
Pull Request resolved: #1523

Remove indent that existed only to make review of previous diff easier

Reviewed By: Balandat

Differential Revision: D41509531

fbshipit-source-id: 918b73576a5d6b1729c9ea044e86745f48eb4850

Author: esantorella

test/models/test_model_list_gp_regression.py

@@ -75,120 +75,114 @@ class TestModelListGP(BotorchTestCase):
     def _base_test_ModelListGP(
         self, fixed_noise: bool, dtype, use_octf: bool
     ) -> ModelListGP:
-        # this is to make review easier -- will be removed in the next
-        # commit in the stack and never landed
-        unneccessary_condition_for_indentation_remove_me = True
-        if unneccessary_condition_for_indentation_remove_me:
-            tkwargs = {"device": self.device, "dtype": dtype}
-            model = _get_model(fixed_noise=fixed_noise, use_octf=use_octf, **tkwargs)
-            self.assertIsInstance(model, ModelListGP)
-            self.assertIsInstance(model.likelihood, LikelihoodList)
-            for m in model.models:
-                self.assertIsInstance(m.mean_module, ConstantMean)
-                self.assertIsInstance(m.covar_module, ScaleKernel)
-                matern_kernel = m.covar_module.base_kernel
-                self.assertIsInstance(matern_kernel, MaternKernel)
-                self.assertIsInstance(matern_kernel.lengthscale_prior, GammaPrior)
-                if use_octf:
-                    self.assertIsInstance(m.outcome_transform, Standardize)
-
-            # test constructing likelihood wrapper
-            mll = SumMarginalLogLikelihood(model.likelihood, model)
-            for mll_ in mll.mlls:
-                self.assertIsInstance(mll_, ExactMarginalLogLikelihood)
-
-            # test model fitting (sequential)
-            with warnings.catch_warnings():
-                warnings.filterwarnings("ignore", category=OptimizationWarning)
-                mll = fit_gpytorch_mll(
-                    mll, optimizer_kwargs={"options": {"maxiter": 1}}, max_attempts=1
-                )
-            with warnings.catch_warnings():
-                warnings.filterwarnings("ignore", category=OptimizationWarning)
-                # test model fitting (joint)
-                mll = fit_gpytorch_mll(
-                    mll,
-                    optimizer_kwargs={"options": {"maxiter": 1}},
-                    max_attempts=1,
-                    sequential=False,
-                )
-
-            # test subset outputs
-            subset_model = model.subset_output([1])
-            self.assertIsInstance(subset_model, ModelListGP)
-            self.assertEqual(len(subset_model.models), 1)
-            sd_subset = subset_model.models[0].state_dict()
-            sd = model.models[1].state_dict()
-            self.assertTrue(set(sd_subset.keys()) == set(sd.keys()))
-            self.assertTrue(all(torch.equal(v, sd[k]) for k, v in sd_subset.items()))
-
-            # test posterior
-            test_x = torch.tensor([[0.25], [0.75]], **tkwargs)
-            posterior = model.posterior(test_x)
-            self.assertIsInstance(posterior, GPyTorchPosterior)
-            self.assertIsInstance(posterior.distribution, MultitaskMultivariateNormal)
+        tkwargs = {"device": self.device, "dtype": dtype}
+        model = _get_model(fixed_noise=fixed_noise, use_octf=use_octf, **tkwargs)
+        self.assertIsInstance(model, ModelListGP)
+        self.assertIsInstance(model.likelihood, LikelihoodList)
+        for m in model.models:
+            self.assertIsInstance(m.mean_module, ConstantMean)
+            self.assertIsInstance(m.covar_module, ScaleKernel)
+            matern_kernel = m.covar_module.base_kernel
+            self.assertIsInstance(matern_kernel, MaternKernel)
+            self.assertIsInstance(matern_kernel.lengthscale_prior, GammaPrior)
             if use_octf:
-                # ensure un-transformation is applied
-                submodel = model.models[0]
-                p0 = submodel.posterior(test_x)
-                tmp_tf = submodel.outcome_transform
-                del submodel.outcome_transform
-                p0_tf = submodel.posterior(test_x)
-                submodel.outcome_transform = tmp_tf
-                expected_var = tmp_tf.untransform_posterior(p0_tf).variance
-                self.assertTrue(torch.allclose(p0.variance, expected_var))
-
-            # test output_indices
-            posterior = model.posterior(
-                test_x, output_indices=[0], observation_noise=True
+                self.assertIsInstance(m.outcome_transform, Standardize)
+
+        # test constructing likelihood wrapper
+        mll = SumMarginalLogLikelihood(model.likelihood, model)
+        for mll_ in mll.mlls:
+            self.assertIsInstance(mll_, ExactMarginalLogLikelihood)
+
+        # test model fitting (sequential)
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=OptimizationWarning)
+            mll = fit_gpytorch_mll(
+                mll, optimizer_kwargs={"options": {"maxiter": 1}}, max_attempts=1
+            )
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=OptimizationWarning)
+            # test model fitting (joint)
+            mll = fit_gpytorch_mll(
+                mll,
+                optimizer_kwargs={"options": {"maxiter": 1}},
+                max_attempts=1,
+                sequential=False,
             )
-            self.assertIsInstance(posterior, GPyTorchPosterior)
-            self.assertIsInstance(posterior.distribution, MultivariateNormal)
 
-            # test condition_on_observations
-            f_x = [torch.rand(2, 1, **tkwargs) for _ in range(2)]
-            f_y = torch.rand(2, 2, **tkwargs)
-            if fixed_noise:
-                noise = 0.1 + 0.1 * torch.rand_like(f_y)
-                cond_kwargs = {"noise": noise}
-            else:
-                cond_kwargs = {}
-            cm = model.condition_on_observations(f_x, f_y, **cond_kwargs)
-            self.assertIsInstance(cm, ModelListGP)
-
-            # test condition_on_observations batched
-            f_x = [torch.rand(3, 2, 1, **tkwargs) for _ in range(2)]
-            f_y = torch.rand(3, 2, 2, **tkwargs)
-            cm = model.condition_on_observations(f_x, f_y, **cond_kwargs)
-            self.assertIsInstance(cm, ModelListGP)
-
-            # test condition_on_observations batched (fast fantasies)
-            f_x = [torch.rand(2, 1, **tkwargs) for _ in range(2)]
-            f_y = torch.rand(3, 2, 2, **tkwargs)
-            cm = model.condition_on_observations(f_x, f_y, **cond_kwargs)
-            self.assertIsInstance(cm, ModelListGP)
+        # test subset outputs
+        subset_model = model.subset_output([1])
+        self.assertIsInstance(subset_model, ModelListGP)
+        self.assertEqual(len(subset_model.models), 1)
+        sd_subset = subset_model.models[0].state_dict()
+        sd = model.models[1].state_dict()
+        self.assertTrue(set(sd_subset.keys()) == set(sd.keys()))
+        self.assertTrue(all(torch.equal(v, sd[k]) for k, v in sd_subset.items()))
 
-            # test condition_on_observations (incorrect input shape error)
-            with self.assertRaises(BotorchTensorDimensionError):
-                model.condition_on_observations(
-                    f_x, torch.rand(3, 2, 3, **tkwargs), **cond_kwargs
-                )
+        # test posterior
+        test_x = torch.tensor([[0.25], [0.75]], **tkwargs)
+        posterior = model.posterior(test_x)
+        self.assertIsInstance(posterior, GPyTorchPosterior)
+        self.assertIsInstance(posterior.distribution, MultitaskMultivariateNormal)
+        if use_octf:
+            # ensure un-transformation is applied
+            submodel = model.models[0]
+            p0 = submodel.posterior(test_x)
+            tmp_tf = submodel.outcome_transform
+            del submodel.outcome_transform
+            p0_tf = submodel.posterior(test_x)
+            submodel.outcome_transform = tmp_tf
+            expected_var = tmp_tf.untransform_posterior(p0_tf).variance
+            self.assertTrue(torch.allclose(p0.variance, expected_var))
+
+        # test output_indices
+        posterior = model.posterior(test_x, output_indices=[0], observation_noise=True)
+        self.assertIsInstance(posterior, GPyTorchPosterior)
+        self.assertIsInstance(posterior.distribution, MultivariateNormal)
 
-            # test X having wrong size
-            with self.assertRaises(AssertionError):
-                model.condition_on_observations(f_x[:1], f_y)
+        # test condition_on_observations
+        f_x = [torch.rand(2, 1, **tkwargs) for _ in range(2)]
+        f_y = torch.rand(2, 2, **tkwargs)
+        if fixed_noise:
+            noise = 0.1 + 0.1 * torch.rand_like(f_y)
+            cond_kwargs = {"noise": noise}
+        else:
+            cond_kwargs = {}
+        cm = model.condition_on_observations(f_x, f_y, **cond_kwargs)
+        self.assertIsInstance(cm, ModelListGP)
+
+        # test condition_on_observations batched
+        f_x = [torch.rand(3, 2, 1, **tkwargs) for _ in range(2)]
+        f_y = torch.rand(3, 2, 2, **tkwargs)
+        cm = model.condition_on_observations(f_x, f_y, **cond_kwargs)
+        self.assertIsInstance(cm, ModelListGP)
+
+        # test condition_on_observations batched (fast fantasies)
+        f_x = [torch.rand(2, 1, **tkwargs) for _ in range(2)]
+        f_y = torch.rand(3, 2, 2, **tkwargs)
+        cm = model.condition_on_observations(f_x, f_y, **cond_kwargs)
+        self.assertIsInstance(cm, ModelListGP)
+
+        # test condition_on_observations (incorrect input shape error)
+        with self.assertRaises(BotorchTensorDimensionError):
+            model.condition_on_observations(
+                f_x, torch.rand(3, 2, 3, **tkwargs), **cond_kwargs
+            )
 
-            # test posterior transform
-            X = torch.rand(3, 1, **tkwargs)
-            weights = torch.tensor([1, 2], **tkwargs)
-            post_tf = ScalarizedPosteriorTransform(weights=weights)
-            posterior_tf = model.posterior(X, posterior_transform=post_tf)
-            self.assertTrue(
-                torch.allclose(
-                    posterior_tf.mean,
-                    model.posterior(X).mean @ weights.unsqueeze(-1),
-                )
+        # test X having wrong size
+        with self.assertRaises(AssertionError):
+            model.condition_on_observations(f_x[:1], f_y)
+
+        # test posterior transform
+        X = torch.rand(3, 1, **tkwargs)
+        weights = torch.tensor([1, 2], **tkwargs)
+        post_tf = ScalarizedPosteriorTransform(weights=weights)
+        posterior_tf = model.posterior(X, posterior_transform=post_tf)
+        self.assertTrue(
+            torch.allclose(
+                posterior_tf.mean,
+                model.posterior(X).mean @ weights.unsqueeze(-1),
             )
+        )
 
         return model