code: def _compute_subset(
      class_type,
      data,
      bw,
      co,
      do,
      n_cvars,
      ix_ord,
      ix_unord,
      n_sub,
      class_vars,
      randomize,
      bound,
  ):
      """ "Compute bw on subset of data.
  
      Called from ``GenericKDE._compute_efficient_*``.
  
      Notes
      -----
      Needs to be outside the class in order for joblib to be able to pickle it.
      """
      if randomize:
          np.random.shuffle(data)
          sub_data = data[:n_sub, :]
      else:
          sub_data = data[bound[0] : bound[1], :]
  
      if class_type == "KDEMultivariate":
          from .kernel_density import KDEMultivariate
  
          var_type = class_vars[0]
          sub_model = KDEMultivariate(
              sub_data,
              var_type,
              bw=bw,
              defaults=EstimatorSettings(efficient=False),
          )
      elif class_type == "KDEMultivariateConditional":
          from .kernel_density import KDEMultivariateConditional
  
          k_dep, dep_type, indep_type = class_vars
          endog = sub_data[:, :k_dep]
          exog = sub_data[:, k_dep:]
          sub_model = KDEMultivariateConditional(
              endog,
              exog,
              dep_type,
              indep_type,
              bw=bw,
              defaults=EstimatorSettings(efficient=False),
          )
      elif class_type == "KernelReg":
          from .kernel_regression import KernelReg
  
          var_type, k_vars, reg_type = class_vars
          endog = _adjust_shape(sub_data[:, 0], 1)
          exog = _adjust_shape(sub_data[:, 1:], k_vars)
          sub_model = KernelReg(
              endog=endog,
              exog=exog,
              reg_type=reg_type,
              var_type=var_type,
              bw=bw,
              defaults=EstimatorSettings(efficient=False),
          )
      else:
          raise ValueError(
              "class_type not recognized, should be one of "
              "{KDEMultivariate, KDEMultivariateConditional, KernelReg}"
          )
  
      # Compute dispersion in next 4 lines
      if class_type == "KernelReg":
          sub_data = sub_data[:, 1:]
  
      dispersion = _compute_min_std_IQR(sub_data)
  
      fct = dispersion * n_sub ** (-1.0 / (n_cvars + co))
      fct[ix_unord] = n_sub ** (-2.0 / (n_cvars + do))
      fct[ix_ord] = n_sub ** (-2.0 / (n_cvars + do))
      sample_scale_sub = sub_model.bw / fct  # TODO: check if correct
      bw_sub = sub_model.bw
      return sample_scale_sub, bw_sub
  
imports: import copy
  import numpy
  from scipy import optimize
  from scipy.stats.mstats import mquantiles
  from .None import kernels
label_desc: Use image node_id 2 for calling a global function with example usage: _compute_subset(class_type, data, bw, co, do, n_cvars, ix_ord, ix_unord, n_sub, class_vars, randomize, bound) and returns: sample_scale_sub,  bw_sub