class_docstr: Poisson regression model with identity or exponential link for data with
  a count label. This class gives first order and second order information for
  this model (gradient, loss and hessian norm)  and can be passed
  to any solver through the solver's ``set_model`` method.
  Can lead to overflows with some solvers (see the note below).
  
  Given training data :math:`(x_i, y_i) \in \mathbb R^d \times \mathbb N`
  for :math:`i=1, \ldots, n`, this model considers a goodness-of-fit
  
  .. math::
      f(w, b) = \frac 1n \sum_{i=1}^n \ell(y_i, b + x_i^\top w),
  
  where :math:`w \in \mathbb R^d` is a vector containing the model-weights,
  :math:`b \in \mathbb R` is the intercept (used only whenever
  ``fit_intercept=True``) and
  :math:`\ell : \mathbb R^2 \rightarrow \mathbb R` is the loss given by
  
  .. math::
      \ell(y, y') = e^{y'} - y y'
  
  whenever ``link='exponential'`` and
  
  .. math::
      \ell(y, y') = y' - y \log(y')
  
  whenever ``link='identity'``,  for :math:`y \in \mathbb N` and
  :math:`y' \in \mathbb R`. Data is passed
  to this model through the ``fit(X, y)`` method where X is the features
  matrix (dense or sparse) and y is the vector of labels.
  
  Parameters
  ----------
  fit_intercept : `bool`
      If `True`, the model uses an intercept
  
  link : `str`, default="exponential"
      Type of link function
  
      * if ``"identity"``: the intensity is the inner product of the
        model's coeffs with the features. In this case, one
        must ensure that the intensity is non-negative
  
      * if ``"exponential"``: the intensity is the exponential of the
        inner product of the model's coeffs with the features.
  
      Note that link cannot be changed after creation of
      `ModelPoisReg`
  
  Attributes
  ----------
  features : {`numpy.ndarray`, `scipy.sparse.csr_matrix`}, shape=(n_samples, n_features)
      The features matrix, either dense or sparse
  
  labels : `numpy.ndarray`, shape=(n_samples,) (read-only)
      The labels vector
  
  n_samples : `int` (read-only)
      Number of samples
  
  n_features : `int` (read-only)
      Number of features
  
  n_coeffs : `int` (read-only)
      Total number of coefficients of the model
  
  n_threads : `int`, default=1 (read-only)
      Number of threads used for parallel computation.
  
      * if ``int <= 0``: the number of threads available on
        the CPU
      * otherwise the desired number of threads
  
  dtype : `{'float64', 'float32'}`, default='float64'
      Type of the data arrays used.
  
  Notes
  -----
  The gradient and loss for the exponential link case cannot be
  overflow proof. In this case, only a solver working in the dual
  (such as `SDCA`) should be used.
  
  In summary, use grad and call at your own risk when
  ``link="exponential"``
docstr: Computes the dual loss at the given dual coefficients
  
  Parameters
  ----------
  dual_coeffs : `np.ndarray`
      Dual coefficients
  
  Returns
  -------
  dual_loss : `float`
      The value of the dual loss
docstr_tok: ["Computes","the","dual","loss","at","the","given","dual","coefficients","Parameters","--","--","--","--","--","dual_coeffs",":","`","np.ndarray","`","Dual","coefficients","Returns","--","--","--","-","dual_loss",":","`","float","`","The","value","of","the","dual","loss"]
code: def dual_loss(self, dual_coeffs):
      """Computes the dual loss at the given dual coefficients
  
      Parameters
      ----------
      dual_coeffs : `np.ndarray`
          Dual coefficients
  
      Returns
      -------
      dual_loss : `float`
          The value of the dual loss
      """
      if self.link != "identity":
          raise (NotImplementedError())
      non_zero_labels = self.labels != 0
      dual_loss = self.labels[non_zero_labels] * (
          1 + np.log(dual_coeffs / self.labels[non_zero_labels])
      )
      dual_loss += np.mean(gammaln(self.labels[non_zero_labels] + 1))
      return np.mean(dual_loss) * self._sdca_rand_max / self.n_samples
  
imports: import numpy
  from scipy.special import gammaln
  from tick.base_model import ModelGeneralizedLinear, ModelFirstOrder, ModelSecondOrder, ModelSelfConcordant
  from .build.linear_model import ModelPoisRegDouble
  from .build.linear_model import ModelPoisRegFloat
  from .build.linear_model import LinkType_identity
  from .build.linear_model import LinkType_exponential
label_desc: Use image node_id 11 for calling the ModelPoisReg obj's underlying member method code with example usage: obj.dual_loss(dual_coeffs) and returns: unknown