class_docstr: Poisson regression learner, with exponential link function.
  It supports several solvers and several penalizations.
  Note that for this model, there is no way to tune
  automatically the `step` of the solver. Thus, the default for `step`
  might work, or not, so that several values should be tried out.
  
  Parameters
  ----------
  step : `float`, default=1e-3
      Step-size to be used for the solver. For Poisson regression there is no
      way to tune it automatically. The default tuning might work, or not...
  
  C : `float`, default=1e3
      Level of penalization
  
  penalty : {'l1', 'l2', 'elasticnet', 'tv'}, default='l2'
      The penalization to use. Default is ridge penalization
  
  solver : {'gd', 'agd', 'bfgs', 'svrg', 'sgd'}, default='svrg'
      The name of the solver to use
  
  fit_intercept : `bool`, default=True
      If `True`, include an intercept in the model
  
  warm_start : `bool`, default=False
      If true, learning will start from the last reached solution
  
  tol : `float`, default=1e-6
      The tolerance of the solver (iterations stop when the stopping
      criterion is below it). By default the solver does ``max_iter``
      iterations
  
  max_iter : `int`, default=100
      Maximum number of iterations of the solver
  
  verbose : `bool`, default=False
      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=1
      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
  
  random_state : `int` seed, RandomState instance, or None (default)
      The seed that will be used by stochastic solvers. Used in 'sgd',
      'svrg', and 'sdca' solvers
  
  blocks_start : `numpy.array`, shape=(n_features,), default=None
      The indices of the first column of each binarized feature blocks. It
      corresponds to the ``feature_indices`` property of the
      ``FeaturesBinarizer`` preprocessing.
      Used in 'binarsity' penalty
  
  blocks_length : `numpy.array`, shape=(n_features,), default=None
      The length of each binarized feature blocks. It corresponds to the
      ``n_values`` property of the ``FeaturesBinarizer`` preprocessing.
      Used in 'binarsity' penalty
  
  Attributes
  ----------
  weights : `numpy.array`, shape=(n_features,)
      The learned weights of the model (not including the intercept)
  
  intercept : `float` or None
      The intercept, if ``fit_intercept=True``, otherwise `None`
docstr: Decision function for given samples. This is simply given by
  the predicted means of each sample.
  Predicted mean in this model for a features vector x is simply given by
  exp(x.dot(weights) + intercept)
  
  Parameters
  ----------
  X : `np.ndarray` or `scipy.sparse.csr_matrix`, shape=(n_samples, n_features)
      Features matrix
  
  Returns
  -------
  output : `np.array`, shape=(n_samples,)
      Value of the decision function of each sample points
code: def decision_function(self, X):
      """Decision function for given samples. This is simply given by
      the predicted means of each sample.
      Predicted mean in this model for a features vector x is simply given by
      exp(x.dot(weights) + intercept)
  
      Parameters
      ----------
      X : `np.ndarray` or `scipy.sparse.csr_matrix`, shape=(n_samples, n_features)
          Features matrix
  
      Returns
      -------
      output : `np.array`, shape=(n_samples,)
          Value of the decision function of each sample points
      """
      if not self._fitted:
          raise ValueError("You must call ``fit`` before")
      else:
          X = self._safe_array(X, dtype=X.dtype)
          z = X.dot(self.weights)
          if self.intercept:
              z += self.intercept
          return np.exp(z)
  
file_path: tick/tick/linear_model/poisson_regression.py
imports: import numpy
  from tick.base import actual_kwargs
  from tick.base.learner import LearnerGLM
  from .model_poisreg import ModelPoisReg
label_desc: Use image node_id 5 for calling the PoissonRegression obj's underlying member method code with example usage: obj.decision_function(X) and returns: np