class_docstr: Hawkes process model for sum-exponential kernels with fixed and
  given decays.
  It is modeled with least square loss:
  
  .. math::
      \sum_{i=1}^{D} \left(
          \int_0^T \lambda_i(t)^2 dt
          - 2 \int_0^T \lambda_i(t) dN_i(t)
      \right)
  
  where :math:`\lambda_i` is the intensity:
  
  .. math::
      \forall i \in [1 \dots D], \quad
      \lambda_i(t) = \mu_i(t) + \sum_{j=1}^D
      \sum_{t_k^j < t} \phi_{ij}(t - t_k^j)
  
  where
  
  * :math:`D` is the number of nodes
  * :math:`\mu_i(t)` are the baseline intensities
  * :math:`\phi_{ij}` are the kernels
  * :math:`t_k^j` are the timestamps of all events of node :math:`j`
  
  and with a sum-exponential parametrisation of the kernels
  
  .. math::
      \phi_{ij}(t) = \sum_{u=1}^{U} \alpha^u_{ij} \beta^u
                     \exp (- \beta^u t) 1_{t > 0}
  
  In our implementation we denote:
  
  * Integer :math:`D` by the attribute `n_nodes`
  * Integer :math:`U` by the attribute `n_decays`
  * Vector :math:`\beta \in \mathbb{R}^{U}` by the
    parameter `decays`. This parameter is given to the model
  
  Parameters
  ----------
  decays : `numpy.ndarray`, shape=(n_decays, )
      An array giving the different decays of the exponentials kernels.
      
  n_baselines : `int`, default=1
      In this model baseline is supposed to be either constant or piecewise 
      constant. If `n_baseline > 1` then piecewise constant setting is 
      enabled. In this case :math:`\mu_i(t)` is piecewise constant on 
      intervals of size `period_length / n_baselines` and periodic.
      
  period_length : `float`, default=None
      In piecewise constant setting this denotes the period of the 
      piecewise constant baseline function.
  
  approx : `int`, default=0 (read-only)
      Level of approximation used for computing exponential functions
  
      * if 0: no approximation
      * if 1: a fast approximated exponential function is used
  
  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
  
  Attributes
  ----------
  n_nodes : `int` (read-only)
      Number of components, or dimension of the Hawkes model
  
  n_decays : `int` (read-only)
      Number of decays used in the sum-exponential kernel
      
  baseline_intervals : `np.ndarray`, shape=(n_baselines)
      Start time of each interval on which baseline is piecewise constant.
  
  data : `list` of `numpy.array` (read-only)
      The events given to the model through `fit` method.
      Note that data given through `incremental_fit` is not stored
code: def _epoch_size(self):
      # This gives the typical size of an epoch when using a
      # stochastic optimization algorithm
      return self.n_nodes
  
file_path: tick/tick/hawkes/model/model_hawkes_sumexpkern_leastsq.py
imports: import sys
  from warnings import warn
  import numpy
  from tick.base_model import LOSS_AND_GRAD
  from tick.hawkes.model.build.hawkes_model import ModelHawkesSumExpKernLeastSq
  from .base import ModelHawkes
label_desc: Use image node_id 3 for calling the ModelHawkesSumExpKernLeastSq obj's underlying member method code with example usage: obj._epoch_size() and returns: self