class_docstr: Simulation of a Poisson regression model, with
  identity or exponential link.
  
  Parameters
  ----------
  weights : `numpy.ndarray`, shape=(n_features,)
      The array of weights of the model
  
  intercept : `float`, default=`None`
      The intercept. If None, then no intercept is used
  
  features : `numpy.ndarray`, shape=(n_samples, n_features), default=`None`
      The features matrix to use. If None, it is simulated
  
  n_samples : `int`, default=200
      Number of samples
  
  link : `str`, default="exponential"
      Type of link function
  
      * if ``"identity"`` : the intensity is the inner product of the
        model's weights 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 weights with the features
  
  features_type : `str`, default="cov_toeplitz"
      The type of features matrix to simulate
  
      * If ``"cov_toeplitz"`` : a Gaussian distribution with
        Toeplitz correlation matrix
  
      * If ``"cov_uniform"`` : a Gaussian distribution with
        correlation matrix given by .5 * (U + U.T), where U is
        uniform on [0, 1] and diagonal filled with ones.
  
  cov_corr : `float`, default=.5
      Correlation to use in the Toeplitz correlation matrix
  
  features_scaling : `str`, default="none"
      The way the features matrix is scaled after simulation
  
      * If ``"standard"`` : the columns are centered and
        normalized
  
      * If ``"min-max"`` : remove the minimum and divide by
        max-min
  
      * If ``"norm"`` : the columns are normalized but not centered
  
      * If ``"none"`` : nothing is done to the features
  
  seed : `int`, default=None
      The seed of the random number generator. If `None` it is not
      seeded
  
  verbose : `bool`, default=True
      If `True`, print things
  
  dtype : `{'float64', 'float32'}`, default='float64'
      Type of the generated arrays.
      Used in the case features is None
  
  Attributes
  ----------
  features : `numpy.ndarray`, shape=(n_samples, n_features)
      The simulated (or given) features matrix
  
  labels : `numpy.ndarray`, shape=(n_samples,)
      The simulated labels
  
  time_start : `str`
      Start date of the simulation
  
  time_elapsed : `int`
      Duration of the simulation, in seconds
  
  time_end : `str`
      End date of the simulation
code: def _simulate(self):
      # Note: the features matrix already exists, and is created by
      # the super class
      features = self.features
      n_samples, n_features = features.shape
      link = self.link
      u = features.dot(self.weights)
      # Add the intercept if necessary
      if self.intercept is not None:
          u += self.intercept
      # Compute the intensities
      if link == "identity":
          if np.any(u <= 0):
              raise ValueError(
                  (
                      "features and weights leads to ,",
                      "non-negative intensities for ",
                      "Poisson.",
                  )
              )
          intensity = u
      else:
          intensity = np.exp(u)
      # Simulate the Poisson variables. We want it in float64 for
      #   later computations, hence the next line.
      labels = np.empty(n_samples, dtype=self.dtype)
      labels[:] = poisson(intensity)
      self._set("labels", labels)
      return features, labels
  
file_path: tick/tick/linear_model/simu_poisreg.py
imports: import numpy
  from numpy.random.mtrand import poisson
  from os import linesep
  from warnings import warn
  from tick.base.simulation import SimuWithFeatures
label_desc: Use image node_id 5 for calling the SimuPoisReg obj's underlying member method code with example usage: obj._simulate() and returns: features,  labels