class_docstr: Learner for a Robust Generalized Linear Model (GML).
  This is a GLM with sample intercepts (one for each sample).
  Slope penalization is used on the individual intercepts.
  Not intended for end-users, but for development only.
  It should be sklearn-learn compliant.
  
  Parameters
  ----------
  C_sample_intercepts : `float`
      Level of penalization of the ProxSlope penalization used for detection
      of outliers. Ideally, this should be equal to n_samples / noise_level,
      where noise_level is an estimated noise level
  
  C : `float`, default=1e3
      Level of penalization of the model weights
  
  fdr : `float`, default=0.05
      Target false discovery rate for the detection of outliers, namely for
      the detection of non-zero entries in ``sample_intercepts``
  
  penalty : {'none', 'l1', 'l2', 'elasticnet', 'slope'}, default='l2'
      The penalization to use. Default 'l2', namely ridge penalization.
  
  fit_intercept : `bool`, default=True
      If `True`, include an intercept in the model, namely a global intercept
  
  refit : 'bool', default=False
      Not implemented yet
  
  solver : 'gd', 'agd'
      The name of the solver to use. For now, only gradient descent and
      accelerated gradient descent are available
  
  warm_start : `bool`, default=False
      If true, learning will start from the last reached solution
  
  step : `float`, default=None
      Initial step size used for learning.
  
  tol : `float`, default=1e-7
      The tolerance of the solver (iterations stop when the stopping
      criterion is below it).
  
  max_iter : `int`, default=100
      Maximum number of iterations of the solver
  
  verbose : `bool`, default=True
      If `True`, we verbose things, otherwise the solver does not
      print anything (but records information in history anyway)
  
  print_every : `int`, default=10
      Print history information when ``n_iter`` (iteration number) is
      a multiple of ``print_every``
  
  record_every : `int`, default=10
      Record history information when ``n_iter`` (iteration number) is
      a multiple of ``record_every``
      
  Other Parameters
  ----------------
  elastic_net_ratio : `float`, default=0.95
      Ratio of elastic net mixing parameter with 0 <= ratio <= 1.
      For ratio = 0 this is ridge (L2 squared) regularization
      For ratio = 1 this is lasso (L1) regularization
      For 0 < ratio < 1, the regularization is a linear combination
      of L1 and L2.
      Used in 'elasticnet' penalty only.
  
  slope_fdr : `float`, default=0.05
      Target false discovery rate for the detection of detection of non-zero
      entries in the model weights.
      Used in the 'slope' penalty only.
  
  Attributes
  ----------
  weights : `numpy.array`, shape=(n_features,)
      The learned weights of the model (not including the intercept)
  
  sample_intercepts : `numpy.array`, shape=(n_samples,)
      Sample intercepts. This should be a sparse vector, since a non-zero
      entry means that the sample is an outlier.
  
  intercept : `float` or `None`
      The intercept, if ``fit_intercept=True``, otherwise `None`
  
  coeffs : `numpy.array`, shape=(n_features + n_samples + 1,)
      The full array of coefficients of the model. Namely, this is simply
      the concatenation of ``weights``, ``sample_intercepts``
      and ``intercept``
code: def __init__(
      self,
      C_sample_intercepts,
      C=1e3,
      fdr=0.05,
      penalty="l2",
      fit_intercept=True,
      refit=False,
      solver="agd",
      warm_start=False,
      step=None,
      tol=1e-5,
      max_iter=100,
      verbose=True,
      print_every=10,
      record_every=10,
      elastic_net_ratio=0.95,
      slope_fdr=0.05,
  ):
      extra_model_kwargs = {"fit_intercept": fit_intercept}
  
      LearnerGLM.__init__(
          self,
          fit_intercept=fit_intercept,
          penalty=penalty,
          C=C,
          solver=solver,
          step=step,
          tol=tol,
          max_iter=max_iter,
          verbose=verbose,
          warm_start=warm_start,
          print_every=print_every,
          record_every=record_every,
          elastic_net_ratio=elastic_net_ratio,
          random_state=None,
          blocks_start=None,
          blocks_length=None,
      )
  
      self._prox_intercepts_obj = ProxSlope(1e-2)
      self.C_sample_intercepts = C_sample_intercepts
      self.fdr = fdr
      self.refit = refit
  
      if "slope_fdr" in self._actual_kwargs or penalty == "slope":
          self.slope_fdr = slope_fdr
  
      self.sample_intercepts = None
      self.coeffs = None
  
imports: from warnings import warn
  import numpy
  from tick.base import Base
  from tick.base.learner import LearnerGLM
  from tick.prox import ProxZero, ProxL1, ProxL2Sq, ProxElasticNet, ProxSlope, ProxMulti
label_desc: Use image node_id 1 to create a new LearnerRobustGLM object from inherited base classes: LearnerGLM with example: obj = LearnerRobustGLM(C_sample_intercepts, C, fdr, penalty, fit_intercept, refit, solver, warm_start, step, tol, max_iter, verbose, print_every, record_every, elastic_net_ratio, slope_fdr)