class_docstr: Fits a GP by tuning the kernel hyper-params. 
docstr: Sets up child-specific parameters for the GP Fitter. 
docstr_tok: ["Sets","up","child-specific","parameters","for","the","GP","Fitter","."]
code: def _child_set_up(self):
      """Sets up child-specific parameters for the GP Fitter."""
      # pylint: disable=too-many-branches
      # Check args
      if not self.options.dist_type in ["lp", "emd", "lp-emd"]:
          raise ValueError(
              "Unknown dist_type. Should be one of 'lp', 'emd', 'lp-emd'."
          )
      if not self.options.kernel_type in [
          "lp",
          "emd",
          "lpemd_sum",
          "lpemd_prod",
          "default",
      ]:
          raise ValueError(
              "Unknown dist_type. Should be one of 'lp', 'emd', "
              + "'lpemd_sum', or 'lpemd_prod'."
          )
      if not self.options.noise_var_type in ["tune", "label", "value"]:
          raise ValueError(
              "Unknown noise_var_type. Should be either tune, label or value."
          )
      if not self.options.choose_mislabel_struct_coeffs in [
          "use_given",
          "tune_coeffs",
      ]:
          raise ValueError(
              "Unknown value for choose_mislabel_struct_coeffs. Should be one "
              + "of use_given or tune_coeffs."
          )
      # Set kernel type
      if self.options.kernel_type == "default":
          self.kernel_type = _DFLT_KERNEL_TYPE
      else:
          self.kernel_type = self.options.kernel_type
      # Check if dist_type and kernel_type are consistent
      if (
          self.options.dist_type in ["lp", "emd"]
          and self.kernel_type != self.options.dist_type
      ):
          raise ValueError(
              "If dist_type is %s, then kernel_type should be %s."
              % (self.options.dist_type, self.options.dist_type)
          )
      elif (
          self.options.dist_type == "lp-emd"
          and self.kernel_type not in ["lpemd_prod", "lpemd_sum"]
      ):
          raise ValueError(
              "If dist_type is lp-emd, then kernel_type should be lpemd_sum or "
              + "lpemd_prod."
          )
      if (
          self.options.choose_mislabel_struct_coeffs == "use_given"
          and (
              self.options.mislabel_coeffs == ""
              or self.options.struct_coeffs == ""
          )
      ):
          raise ValueError(
              (
                  "If choose_mislabel_struct_coeffs is use_given, then "
                  + "mislabel_coeffs and struct_coeffs cannot be empty. Given mislabel_coeffs=%s"
                  + " struct_coeffs=%s"
              )
              % (
                  self.options.mislabel_coeffs,
                  self.options.struct_coeffs,
              )
          )
      self._preprocess_struct_mislabel_coeffs()
      # Check if we need to pre-compute distances
      if (
          self.options.choose_mislabel_struct_coeffs == "use_given"
          and self.list_of_dists is None
      ):
          if self.tp_comp is None:
              self.tp_comp = (
                  otmann.get_otmann_distance_computer_from_args(
                      self.nn_type,
                      self.options.non_assignment_penalty,
                      self.mislabel_coeffs,
                      self.struct_coeffs,
                      self.options.dist_type,
                  )
              )
          self.list_of_dists = self.tp_comp(self.X, self.X)
      # Create bounds here. Order of hyper-parameters (this is critical): scale/alphas,
      # betas, mislabel_coeff, struct_coeff
      # 1. scale/alphas -----------------------------------------
      scale_log_bounds = [
          np.log(0.01 * self.Y_var),
          np.log(100 * self.Y_var),
      ]
      if self.kernel_type in ["lp", "emd", "lpemd_prod"]:
          self.cts_hp_bounds.append(scale_log_bounds)
      elif self.kernel_type == "lpemd_sum":
          self.cts_hp_bounds.extend([scale_log_bounds] * 2)
      # 2. betas ------------------------------------------------
      lp_beta_log_bounds = [
          [np.log(1e-9), np.log(1e-3)]
      ] * self.num_mislabel_struct_coeffs
      emd_beta_log_bounds = [
          [np.log(1e-1), np.log(1e2)]
      ] * self.num_mislabel_struct_coeffs
      if self.options.dist_type == "lp":
          all_beta_bounds = lp_beta_log_bounds
      elif self.options.dist_type == "emd":
          all_beta_bounds = emd_beta_log_bounds
      elif self.options.dist_type == "lp-emd":
          all_beta_bounds = [
              j
              for i in zip(lp_beta_log_bounds, emd_beta_log_bounds)
              for j in i
          ]
      self.cts_hp_bounds.extend(
          all_beta_bounds
      )  # extend with log_beta_bounds
      # 3 & 4. mislabel/struct_coeff ----------------------------
      if self.to_tune_mislabel_struct_coeffs:
          self.cts_hp_bounds.append(
              [0.001, 2.0]
          )  # mislabel coefficient (not in log space)
          self.cts_hp_bounds.append([0.001, 2.0])
  
imports: import numpy
  from .None import otmann
  from ..gp import gp_core
  from ..utils.ancillary_utils import get_list_of_floats_as_str
  from ..utils.reporters import get_reporter
  from ..utils.option_handler import get_option_specs, load_options
label_desc: Use image node_id 2 for calling the NNGPFitter obj's underlying member method code with example usage: obj._child_set_up() without return types