code: def test_init(self) -> None:
      acquisition1 = self.get_acquisition_function(
          options={"target_point": self.target_point},
      )
      # Check that determinstic metric is added to surrogate
      surrogate = acquisition1.surrogates["sebo"]
      model_list = not_none(surrogate._model)
      self.assertIsInstance(model_list, ModelList)
      self.assertIsInstance(model_list.models[0], SingleTaskGP)
      self.assertIsInstance(
          model_list.models[1], GenericDeterministicModel
      )
      self.assertEqual(acquisition1.det_metric_indx, -1)
  
      # Check right penalty term is instantiated
      self.assertEqual(acquisition1.penalty_name, "L0_norm")
      self.assertIsInstance(model_list.models[1]._f, L0Approximation)
  
      # Check transformed objective threshold
      self.assertTrue(
          torch.equal(
              acquisition1.acqf.ref_point[-1],
              -1 * self.objective_thresholds_sebo[-1],
          )
      )
      self.assertTrue(
          torch.equal(
              not_none(acquisition1.objective_thresholds),
              self.objective_thresholds_sebo,
          )
      )
      self.assertEqual(
          acquisition1.sparsity_threshold, self.X.shape[-1]
      )
  
      # Check using non-default penalty
      acquisition2 = self.get_acquisition_function(
          options={
              "penalty": "L1_norm",
              "target_point": self.target_point,
          },
      )
      self.assertEqual(acquisition2.penalty_name, "L1_norm")
      surrogate = acquisition2.surrogates["sebo"]
      model_list = not_none(surrogate._model)
      self.assertIsInstance(model_list.models[1]._f, functools.partial)
      self.assertIs(model_list.models[1]._f.func, L1_norm_func)
  
      # assert error raise when constructing non L0/L1 penalty terms
      with self.assertRaisesRegex(
          NotImplementedError, "L2_norm is not currently implemented."
      ):
          self.get_acquisition_function(
              fixed_features=self.fixed_features,
              options={
                  "penalty": "L2_norm",
                  "target_point": self.target_point,
              },
          )
  
      # assert error raise if multiple surrogates are given
      with self.assertRaisesRegex(
          ValueError,
          "SEBO does not support support multiple surrogates.",
      ):
          SEBOAcquisition(
              botorch_acqf_class=qNoisyExpectedHypervolumeImprovement,
              surrogates={
                  Keys.ONLY_SURROGATE: self.surrogates,
                  "sebo2": self.surrogates,
              },
              search_space_digest=self.search_space_digest,
              torch_opt_config=self.torch_opt_config,
              options=self.options,
          )
  
      # assert error raise if target point is not given
      with self.assertRaisesRegex(
          ValueError, "please provide target point."
      ):
          self.get_acquisition_function(options={"penalty": "L1_norm"})
  
imports: from __future__ import annotations
  import dataclasses
  import functools
  from typing import Any, Dict, Optional, Union
  from unittest import mock
  from unittest.mock import Mock
  import torch
  from ax.core.search_space import SearchSpaceDigest
  from ax.models.torch.botorch_modular.acquisition import Acquisition
  from ax.models.torch.botorch_modular.sebo import L1_norm_func, SEBOAcquisition
  from ax.models.torch.botorch_modular.surrogate import Surrogate
  from ax.models.torch_base import TorchOptConfig
  from ax.utils.common.constants import Keys
  from ax.utils.common.testutils import TestCase
  from ax.utils.common.typeutils import not_none
  from ax.utils.testing.mock import fast_botorch_optimize
  from botorch.acquisition import PosteriorMean
  from botorch.acquisition.monte_carlo import qNoisyExpectedImprovement
  from botorch.acquisition.multi_objective.monte_carlo import qNoisyExpectedHypervolumeImprovement
  from botorch.acquisition.penalized import L0Approximation
  from botorch.models.deterministic import GenericDeterministicModel
  from botorch.models.gp_regression import SingleTaskGP
  from botorch.models.model import ModelList
  from botorch.optim import Homotopy, HomotopyParameter, LinearHomotopySchedule
  from botorch.utils.datasets import SupervisedDataset
  from torch.nn import Parameter
label_desc: Use image node_id 3 for calling the TestSebo obj's underlying member method code with example usage: obj.test_init() without return types