class_docstr: Base Hawkes process learner for given kernels, with many choices of
  penalization and solvers.
  
  Hawkes processes are point processes defined by the intensity:
  
  .. math::
      \forall i \in [1 \dots D], \quad
      \lambda_i(t) = \mu_i + \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` are the baseline intensities
  * :math:`\phi_{ij}` are the kernels
  * :math:`t_k^j` are the timestamps of all events of node :math:`j`
  
  In our implementation we denote:
  
  * Integer :math:`D` by the attribute `n_nodes`
  * Vector :math:`\mu \in \mathbb{R}^{n\_nodes}` by the attribute
    `baseline`
  
  Parameters
  ----------
  C : `float`, default=1e3
      Level of penalization
  
  penalty : 'l1', 'l2', 'elasticnet', default='l2'
      The penalization to use. Default is ridge penalization.
  
  solver : 'gd', 'agd', 'bfgs', 'svrg', default='agd'
      The name of the solver to use
  
  step : `float`, default=None
      Initial step size used for learning. Used in 'gd', 'agd', 'sgd'
      and 'svrg' solvers
  
  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``
  
  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, or None (default)
      The seed that will be used by stochastic solvers. If `None`, a random
      seed will be used (based on timestamp and other physical metrics).
      Used in 'sgd', and 'svrg' solvers
  
  Attributes
  ----------
  n_nodes : `int`
      Number of nodes / components in the Hawkes model
  
  baseline : `np.array`, shape=(n_nodes,)
      Inferred baseline of each component's intensity
  
  coeffs : `np.array`, shape=(n_nodes * n_nodes + n_nodes, )
      Raw coefficients of the model.
  
  events : `list` of `np.ndarray`
      Events given to learner during fitting
docstr: Computes kernel support. This makes our learner compliant with
  `tick.plot.plot_hawkes_kernels` API
  
  Returns
  -------
  output : `np.ndarray`, shape=(n_nodes, n_nodes)
      2d array in which each entry i, j corresponds to the support of
      kernel i, j
docstr_tok: ["Computes","kernel","support",".","This","makes","our","learner","compliant","with","`","tick.plot.plot_hawkes_kernels","`","API","Returns","--","--","--","-","output",":","`","np.ndarray","`",",","shape=","(","n_nodes",",","n_nodes",")","2d","array","in","which","each","entry","i",",","j","corresponds","to","the","support","of","kernel","i",",","j"]
code: def get_kernel_supports(self):
      """Computes kernel support. This makes our learner compliant with
      `tick.plot.plot_hawkes_kernels` API
  
      Returns
      -------
      output : `np.ndarray`, shape=(n_nodes, n_nodes)
          2d array in which each entry i, j corresponds to the support of
          kernel i, j
      """
      corresponding_simu = self._corresponding_simu()
      get_support = np.vectorize(
          lambda kernel: kernel.get_plot_support()
      )
      return get_support(corresponding_simu.kernels)
  
imports: from warnings import warn
  import numpy
  from tick.base import actual_kwargs
  from tick.base.learner import LearnerOptim
  from tick.base_model import ModelLipschitz
  from tick.hawkes import SimuHawkes
  from tick.plot import plot_point_process, qq_plots
  from tick.prox import ProxElasticNet, ProxL1, ProxL2Sq, ProxPositive
label_desc: Use image node_id 7 for calling the LearnerHawkesParametric obj's underlying member method code with example usage: obj.get_kernel_supports() and returns: get_support