class_docstr: This class is used for performing non parametric estimation of
  multi-dimensional Hawkes processes based on expectation maximization
  algorithm and the hypothesis that kernels are linear
  combinations of some basis kernels.
  
  Hawkes processes are point processes defined by the intensity:
  
  .. math::
      \forall i \in [1 \dots D], \quad
      \lambda_i = \mu_i + \sum_{j=1}^D \int \phi_{ij} dN_j
  
  where
  
  * :math:`D` is the number of nodes
  * :math:`\mu_i` are the baseline intensities
  * :math:`\phi_{ij}` are the kernels
  
  The basis kernel hypothesis translates to:
  
  .. math::
      \phi_{ij}(t) = \sum_{u}^U a_{ij}^u g^u(t)
  
  where
  
  * :math:`U` is the number of basis kernels.
  * :math:`g^u` is a basis kernel
  * :math:`a_{ij}^u` is the amplitude of basis kernel :math:`u` in kernel
    :math:`\phi_{ij}`
  
  Finally we also suppose that basis kernels :math:`g^u` are piecewise
  constant on a given support and number of intervals.
  
  Parameters
  ----------
  kernel_support : `float`
      The support size common to all the kernels.
  
  n_basis : `int`, default=`None`
      Number of non parametric basis kernels to be used.
      If `None` or 0, it will be set to `n_nodes`
  
  kernel_size : `int`, default=10
      Number of discretizations of the kernel
  
  C : `float`, default=1e-1
      The penalization parameter. It penalizes both the amplitudes
      squared values and the basis kernels smoothness through the
      integral of their squared derivative.
  
  tol : `float`, default=1e-5
      The tolerance of the solver (iterations stop when the stopping
      criterion is below it). If not reached 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=10
      Record history information when ``n_iter`` (iteration number) is
      a multiple of ``record_every``
  
  n_threads : `int`, default=1
      Number of threads used for parallel computation.
  
      * if `int <= 0`: the number of physical cores available on the CPU
      * otherwise the desired number of threads
  
  Other Parameters
  ----------------
  ode_max_iter : `int`, default=100
      Maximum number of loop for inner ODE (ordinary differential equation)
      algorithm.
  
  ode_tol : `float`, default=1e-5
      Tolerance of loop for inner inner ODE (ordinary differential equation)
      algorithm.
  
  Attributes
  ----------
  n_nodes : `int`
      Number of nodes of the estimated Hawkes process
  
  n_realizations : `int`
      Number of given realizations`
  
  baseline : `np.array` shape=(n_nodes)
      The estimated baseline
  
  amplitudes : `np.array` shape=(n_nodes, n_nodes, n_basis)
      Amplitudes of all basis kernels for all kernels.
  
  basis_kernels : `np.array` shape=(n_basis, kernel_size)
      Estimated basis kernels
  
  kernel_dt : `float`
      Kernel discretization step. It is equal to
      `kernel_support` / `kernel_size`
  
  kernel_discretization : `np.ndarray`, shape=(kernel_size + 1, )
      Kernel discretizations points, denotes the interval on which basis
      kernels are piecewise constant.
  
  References
  ----------
  Zhou, K., Zha, H. and Song, L., 2013, June. Learning Triggering Kernels for
  Multi-dimensional Hawkes Processes. In `ICML (3) (pp. 1301-1309)`_.
  
  Some rewriting notes for implementing the algorithm can be found in the
  doc/tex directory.
  
  .. _ICML (3) (pp. 1301-1309): http://jmlr.org/proceedings/papers/v28/zhou13.html
docstr: Fit the model according to the given training data.
  
  Parameters
  ----------
  events : `list` of `list` of `np.ndarray`
      List of Hawkes processes realizations.
      Each realization of the Hawkes process is a list of n_node for
      each component of the Hawkes. Namely `events[i][j]` contains a
      one-dimensional `numpy.array` of the events' timestamps of
      component j of realization i.
      If only one realization is given, it will be wrapped into a list
  
  end_times : `np.ndarray` or `float`, default = None
      List of end time of all hawkes processes that will be given to the
      model. If None, it will be set to each realization's latest time.
      If only one realization is provided, then a float can be given.
  
  baseline_start : `None` or `np.ndarray`, shape=(n_nodes)
      Used to force start values for baseline attribute
      If `None` starts with uniform 1 values
  
  amplitudes_start : `None` or `np.ndarray`, shape=(n_nodes,n_nodes,D)
      Used to force start values for amplitude parameter
      If `None` starts with random values uniformly sampled between
      0.5 and 0.9
  
  basis_kernels_start : `None` or `np.darray`, shape=(D,kernel_size)
      Used to force start values for the basis kernels
      If `None` starts with random values uniformly sampled between
      0 and 0.1
docstr_tok: ["Fit","the","model","according","to","the","given","training","data",".","Parameters","--","--","--","--","--","events",":","`","list","`","of","`","list","`","of","`","np.ndarray","`","List","of","Hawkes","processes","realizations",".","Each","realization","of","the","Hawkes","process","is","a","list","of","n_node","for","each","component","of","the","Hawkes",".","Namely","`","events","[","i","]","[","j","]","`","contains","a","one-dimensional","`","numpy.array","`","of","the","events","'","timestamps","of","component","j","of","realization","i",".","If","only","one","realization","is","given",",","it","will","be","wrapped","into","a","list","end_times",":","`","np.ndarray","`","or","`","float","`",",","default","=","None","List","of","end","time","of","all","hawkes","processes","that","will","be","given","to","the","model",".","If","None",",","it","will","be","set","to","each","realization","'s","latest","time",".","If","only","one","realization","is","provided",",","then","a","float","can","be","given",".","baseline_start",":","`","None","`","or","`","np.ndarray","`",",","shape=","(","n_nodes",")","Used","to","force","start","values","for","baseline","attribute","If","`","None","`","starts","with","uniform","1","values","amplitudes_start",":","`","None","`","or","`","np.ndarray","`",",","shape=","(","n_nodes",",","n_nodes",",","D",")","Used","to","force","start","values","for","amplitude","parameter","If","`","None","`","starts","with","random","values","uniformly","sampled","between","0.5","and","0.9","basis_kernels_start",":","`","None","`","or","`","np.darray","`",",","shape=","(","D",",","kernel_size",")","Used","to","force","start","values","for","the","basis","kernels","If","`","None","`","starts","with","random","values","uniformly","sampled","between","0","and","0.1"]
code: def fit(
      self,
      events,
      end_times=None,
      baseline_start=None,
      amplitudes_start=None,
      basis_kernels_start=None,
  ):
      """Fit the model according to the given training data.
  
      Parameters
      ----------
      events : `list` of `list` of `np.ndarray`
          List of Hawkes processes realizations.
          Each realization of the Hawkes process is a list of n_node for
          each component of the Hawkes. Namely `events[i][j]` contains a
          one-dimensional `numpy.array` of the events' timestamps of
          component j of realization i.
          If only one realization is given, it will be wrapped into a list
  
      end_times : `np.ndarray` or `float`, default = None
          List of end time of all hawkes processes that will be given to the
          model. If None, it will be set to each realization's latest time.
          If only one realization is provided, then a float can be given.
  
      baseline_start : `None` or `np.ndarray`, shape=(n_nodes)
          Used to force start values for baseline attribute
          If `None` starts with uniform 1 values
  
      amplitudes_start : `None` or `np.ndarray`, shape=(n_nodes,n_nodes,D)
          Used to force start values for amplitude parameter
          If `None` starts with random values uniformly sampled between
          0.5 and 0.9
  
      basis_kernels_start : `None` or `np.darray`, shape=(D,kernel_size)
          Used to force start values for the basis kernels
          If `None` starts with random values uniformly sampled between
          0 and 0.1
      """
      LearnerHawkesNoParam.fit(self, events, end_times=end_times)
      self.solve(
          baseline_start=baseline_start,
          amplitudes_start=amplitudes_start,
          basis_kernels_start=basis_kernels_start,
      )
      return self
  
imports: import numpy
  from tick.hawkes.inference.base import LearnerHawkesNoParam
  from tick.hawkes.inference.build.hawkes_inference import HawkesBasisKernels
  from tick.solver.base.utils import relative_distance
label_desc: Use image node_id 2 for calling the HawkesBasisKernels obj's underlying member method code with example usage: obj.fit(events, end_times, baseline_start, amplitudes_start, basis_kernels_start) and returns: self