docstr: Tests single type MTGP via Modular BoTorch instantiation
  with both single & multi objective optimization.
code: def test_ST_MTGP(self, use_saas: bool = False) -> None:
      """Tests single type MTGP via Modular BoTorch instantiation
      with both single & multi objective optimization."""
      for exp, status_quo_features in [
          get_branin_experiment_with_status_quo_trials(
              num_sobol_trials=2
          ),
          get_branin_experiment_with_status_quo_trials(
              num_sobol_trials=2, multi_objective=True
          ),
      ]:
          # testing custom and default kernel for a surrogate
          surrogates = (
              [None]
              if use_saas
              else [
                  Surrogate(
                      botorch_model_class=MultiTaskGP,
                      mll_class=ExactMarginalLogLikelihood,
                      covar_module_class=ScaleMaternKernel,
                      covar_module_options={
                          "ard_num_dims": DEFAULT,
                          "lengthscale_prior": GammaPrior(6.0, 3.0),
                          "outputscale_prior": GammaPrior(2.0, 0.15),
                          "batch_shape": DEFAULT,
                      },
                      allow_batched_models=False,
                      model_options={},
                  ),
                  None,
              ]
          )
  
          lengthscale_priors = [
              GammaPrior(6.0, 3.0),
              GammaPrior(3.0, 6.0),
          ]
  
          for surrogate, lengthscale_prior in zip(
              surrogates, lengthscale_priors
          ):
              constructor = (
                  Models.SAAS_MTGP if use_saas else Models.ST_MTGP
              )
              mtgp = constructor(
                  experiment=exp,
                  data=exp.fetch_data(),
                  status_quo_features=status_quo_features,
                  surrogate=surrogate,
              )
              self.assertIsInstance(mtgp, TorchModelBridge)
              self.assertIsInstance(mtgp.model, BoTorchModel)
              self.assertEqual(
                  mtgp.model.acquisition_class, Acquisition
              )
  
              self.assertIsInstance(
                  mtgp.model.surrogate.model, ModelListGP
              )
              models = mtgp.model.surrogate.model.models
  
              for i in range(len(models)):
                  self.assertIsInstance(
                      models[i],
                      SaasFullyBayesianMultiTaskGP
                      if use_saas
                      else MultiTaskGP,
                  )
                  if use_saas is False:
                      self.assertIsInstance(
                          models[i].covar_module, ScaleKernel
                      )
                      base_kernel = models[i].covar_module.base_kernel
                      self.assertIsInstance(base_kernel, MaternKernel)
                      self.assertEqual(
                          base_kernel.lengthscale_prior.concentration,
                          lengthscale_prior.concentration,
                      )
                      self.assertEqual(
                          base_kernel.lengthscale_prior.rate,
                          lengthscale_prior.rate,
                      )
  
              gr = mtgp.gen(
                  n=1,
                  fixed_features=ObservationFeatures({}, trial_index=1),
              )
              self.assertEqual(len(gr.arms), 1)
  
imports: from collections import OrderedDict
  import numpy
  import pandas
  import torch
  from ax.core.data import Data
  from ax.core.observation import ObservationFeatures
  from ax.modelbridge.discrete import DiscreteModelBridge
  from ax.modelbridge.random import RandomModelBridge
  from ax.modelbridge.registry import Cont_X_trans, get_model_from_generator_run, MODEL_KEY_TO_MODEL_SETUP, Models, Y_trans
  from ax.modelbridge.torch import TorchModelBridge
  from ax.models.base import Model
  from ax.models.discrete.eb_thompson import EmpiricalBayesThompsonSampler
  from ax.models.discrete.thompson import ThompsonSampler
  from ax.models.random.alebo_initializer import ALEBOInitializer
  from ax.models.torch.alebo import ALEBO
  from ax.models.torch.botorch_modular.acquisition import Acquisition
  from ax.models.torch.botorch_modular.kernels import ScaleMaternKernel
  from ax.models.torch.botorch_modular.model import BoTorchModel, SurrogateSpec
  from ax.models.torch.botorch_modular.surrogate import Surrogate
  from ax.models.torch.botorch_moo import MultiObjectiveBotorchModel
  from ax.utils.common.constants import Keys
  from ax.utils.common.kwargs import get_function_argument_names
  from ax.utils.common.testutils import TestCase
  from ax.utils.testing.core_stubs import get_branin_data, get_branin_experiment, get_branin_experiment_with_status_quo_trials, get_branin_optimization_config, get_factorial_experiment
  from ax.utils.testing.mock import fast_botorch_optimize
  from botorch.acquisition.monte_carlo import qExpectedImprovement
  from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP
  from botorch.models.fully_bayesian_multitask import SaasFullyBayesianMultiTaskGP
  from botorch.models.gp_regression import SingleTaskGP
  from botorch.models.model_list_gp_regression import ModelListGP
  from botorch.models.multitask import MultiTaskGP
  from botorch.utils.types import DEFAULT
  from gpytorch.kernels.matern_kernel import MaternKernel
  from gpytorch.kernels.scale_kernel import ScaleKernel
  from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood
  from gpytorch.priors.torch_priors import GammaPrior
label_desc: Use image node_id 16 for calling the ModelRegistryTest obj's underlying member method code with example usage: obj.test_ST_MTGP(use_saas) without return types