class_docstr: A fitter for GPs in multi-fidelity optimisation. 
class_docstr_tok: ["A","fitter","for","GPs","in","multi-fidelity","optimisation","."]
docstr: Sets parameters fro GPFitter. 
code: def _child_set_up(self):
      """Sets parameters fro GPFitter."""
      # pylint: disable=too-many-branches
      # Check args - so that we don't have to keep doing this all the time
      if self.options.fidel_kernel_type not in [
          "se",
          "matern",
          "poly",
          "expdecay",
      ]:
          raise ValueError(
              "Unknown fidel_kernel_type. Should be in {se, matern, poly, "
              + "expdecay."
          )
      if self.options.domain_kernel_type not in [
          "se",
          "matern",
          "poly",
      ]:
          raise ValueError(
              "Unknown domain_kernel_type. Should be either se or poly."
          )
      if self.options.noise_var_type not in ["tune", "label", "value"]:
          raise ValueError(
              "Unknown noise_var_type. Should be either tune, label or value."
          )
      if self.options.mean_func_type not in [
          "mean",
          "median",
          "const",
          "zero",
          "upper_bound",
          "tune",
      ]:
          raise ValueError(
              (
                  "Unknown mean_func_type. Should be one of ",
                  "mean/median/const/zero.",
              )
          )
      # Set some parameters we will be using often.
      self.ZZ_std_norm = np.linalg.norm(self.ZZ, "fro") + 5e-5
      self.XX_std_norm = np.linalg.norm(self.XX, "fro") + 5e-5
      self.ZX_std_norm = np.sqrt(
          self.ZZ_std_norm**2 + self.XX_std_norm**2
      )
  
      # Bounds for the hyper parameters
      # -------------------------------
      # Kernel scale
      self.scale_log_bounds = [
          np.log(0.1 * self.Y_var),
          np.log(10 * self.Y_var),
      ]
      self.cts_hp_bounds.append(self.scale_log_bounds)
      self.param_order.append(["scale", "cts"])
      # Fidelity kernel
      if self.options.fidel_kernel_type == "se":
          self._fidel_se_kernel_setup()
      elif self.options.fidel_kernel_type == "matern":
          self._fidel_matern_kernel_setup()
      elif self.options.fidel_kernel_type == "poly":
          self._fidel_poly_kernel_setup()
      elif self.options.fidel_kernel_type == "expdecay":
          self._fidel_expdecay_kernel_setup()
      elif self.options.fidel_kernel_type == "esp":
          self._fidel_esp_kernel_setup()
      # Domain kernel
      if self.options.domain_kernel_type == "se":
          self._domain_se_kernel_setup()
      elif self.options.domain_kernel_type == "matern":
          self._domain_matern_kernel_setup()
      elif self.options.domain_kernel_type == "poly":
          self._domain_poly_kernel_setup()
      elif self.options.domain_kernel_type == "esp":
          self._domain_esp_kernel_setup()
      # Additive grouping for domain kernel (this has to come after fidelity kernel set up).
      if self.options.domain_use_additive_gp:
          self.domain_add_group_size_idx_in_dscr_hp_vals = len(
              self.dscr_hp_vals
          )
          self.domain_add_max_group_size = min(
              self.options.domain_add_max_group_size, self.domain_dim
          )
          self.dscr_hp_vals.append(
              [x + 1 for x in range(self.domain_add_max_group_size)]
          )
          self.param_order.append(["additive_grp", "dscr"])
  
imports: from __future__ import division
  from argparse import Namespace
  import numpy
  from .None import gp_core, mf_gp
  from .None import kernel
  from ..utils.ancillary_utils import get_list_of_floats_as_str
  from ..utils.general_utils import get_sublist_from_indices, map_to_bounds
  from ..utils.option_handler import get_option_specs, load_options
  from ..utils.oper_utils import random_sample_from_discrete_domain
  from ..utils.reporters import get_reporter
label_desc: Use image node_id 2 for calling the EuclideanMFGPFitter obj's underlying member method code with example usage: obj._child_set_up() without return types