class_docstr: Nonparametric censored regression.
  
  Calculates the conditional mean ``E[y|X]`` where ``y = g(X) + e``,
  where y is left-censored.  Left censored variable Y is defined as
  ``Y = min {Y', L}`` where ``L`` is the value at which ``Y`` is censored
  and ``Y'`` is the true value of the variable.
  
  Parameters
  ----------
  endog : list with one element which is array_like
      This is the dependent variable.
  exog : list
      The training data for the independent variable(s)
      Each element in the list is a separate variable
  dep_type : str
      The type of the dependent variable(s)
      c: Continuous
      u: Unordered (Discrete)
      o: Ordered (Discrete)
  reg_type : str
      Type of regression estimator
      lc: Local Constant Estimator
      ll: Local Linear Estimator
  bw : array_like
      Either a user-specified bandwidth or
      the method for bandwidth selection.
      cv_ls: cross-validation least squares
      aic: AIC Hurvich Estimator
  ckertype : str, optional
      The kernel used for the continuous variables.
  okertype : str, optional
      The kernel used for the ordered discrete variables.
  ukertype : str, optional
      The kernel used for the unordered discrete variables.
  censor_val : float
      Value at which the dependent variable is censored
  defaults : EstimatorSettings instance, optional
      The default values for the efficient bandwidth estimation
  
  Attributes
  ----------
  bw : array_like
      The bandwidth parameters
code: def __init__(
      self,
      endog,
      exog,
      var_type,
      reg_type,
      bw="cv_ls",
      ckertype="gaussian",
      ukertype="aitchison_aitken_reg",
      okertype="wangryzin_reg",
      censor_val=0,
      defaults=None,
  ):
      self.var_type = var_type
      self.data_type = var_type
      self.reg_type = reg_type
      self.ckertype = ckertype
      self.okertype = okertype
      self.ukertype = ukertype
      if not (
          self.ckertype in kernel_func
          and self.ukertype in kernel_func
          and self.okertype in kernel_func
      ):
          raise ValueError(
              "user specified kernel must be a supported "
              "kernel from statsmodels.nonparametric.kernels."
          )
  
      self.k_vars = len(self.var_type)
      self.endog = _adjust_shape(endog, 1)
      self.exog = _adjust_shape(exog, self.k_vars)
      self.data = np.column_stack((self.endog, self.exog))
      self.nobs = np.shape(self.exog)[0]
      self.est = dict(
          lc=self._est_loc_constant, ll=self._est_loc_linear
      )
      defaults = EstimatorSettings() if defaults is None else defaults
      self._set_defaults(defaults)
      self.censor_val = censor_val
      if self.censor_val is not None:
          self.censored(censor_val)
      else:
          self.W_in = np.ones((self.nobs, 1))
  
      if not self.efficient:
          self.bw = self._compute_reg_bw(bw)
      else:
          self.bw = self._compute_efficient(bw)
  
imports: import copy
  import numpy
  from scipy import optimize
  from scipy.stats.mstats import mquantiles
  from ._kernel_base import GenericKDE, EstimatorSettings, gpke, LeaveOneOut, _get_type_pos, _adjust_shape, _compute_min_std_IQR, kernel_func
label_desc: Use image node_id 1 to create a new KernelCensoredReg object from inherited base classes: KernelReg with example: obj = KernelCensoredReg(endog, exog, var_type, reg_type, bw, ckertype, ukertype, okertype, censor_val, defaults)