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: Plot value of intensity for a given realization with the fitted
  parameters
  
  events : `list` of `np.ndarray`, default = None
      One Hawkes processes realization, a list of n_node for
      each component of the Hawkes. Namely `events[i]` contains a
      one-dimensional `numpy.array` of the events' timestamps of
      component i.
  
  n_points : `int`, default=10000
      Number of points used for intensity plot.
  
  plot_nodes : `list` of `int`, default=`None`
      List of nodes that will be plotted. If `None`, all nodes are
      considered
  
  t_min : `float`, default=`None`
      If not `None`, time at which plot will start
  
  t_max : `float`, default=`None`
      If not `None`, time at which plot will stop
  
  intensity_track_step : `float`, default=`None`
      Defines how often intensity will be computed. If this is too low,
      computations might be long. By default, a value will be
      extrapolated from (t_max - t_min) / n_points.
  
  max_jumps : `int`, default=`None`
      If not `None`, maximum of jumps per coordinate that will be plotted.
      This is useful when plotting big point processes to ensure a only
      readable part of them will be plotted
  
  show : `bool`, default=`True`
      if `True`, show the plot. Otherwise an explicit call to the show
      function is necessary. Useful when superposing several plots.
  
  ax : `list` of `matplotlib.axes`, default=None
      If not None, the figure will be plot on this axis and show will be
      set to False.
docstr_tok: ["Plot","value","of","intensity","for","a","given","realization","with","the","fitted","parameters","events",":","`","list","`","of","`","np.ndarray","`",",","default","=","None","One","Hawkes","processes","realization",",","a","list","of","n_node","for","each","component","of","the","Hawkes",".","Namely","`","events","[","i","]","`","contains","a","one-dimensional","`","numpy.array","`","of","the","events","'","timestamps","of","component","i.","n_points",":","`","int","`",",","default=10000","Number","of","points","used","for","intensity","plot",".","plot_nodes",":","`","list","`","of","`","int","`",",","default=","`","None","`","List","of","nodes","that","will","be","plotted",".","If","`","None","`",",","all","nodes","are","considered","t_min",":","`","float","`",",","default=","`","None","`","If","not","`","None","`",",","time","at","which","plot","will","start","t_max",":","`","float","`",",","default=","`","None","`","If","not","`","None","`",",","time","at","which","plot","will","stop","intensity_track_step",":","`","float","`",",","default=","`","None","`","Defines","how","often","intensity","will","be","computed",".","If","this","is","too","low",",","computations","might","be","long",".","By","default",",","a","value","will","be","extrapolated","from","(","t_max","-","t_min",")","\/","n_points",".","max_jumps",":","`","int","`",",","default=","`","None","`","If","not","`","None","`",",","maximum","of","jumps","per","coordinate","that","will","be","plotted",".","This","is","useful","when","plotting","big","point","processes","to","ensure","a","only","readable","part","of","them","will","be","plotted","show",":","`","bool","`",",","default=","`","True","`","if","`","True","`",",","show","the","plot",".","Otherwise","an","explicit","call","to","the","show","function","is","necessary",".","Useful","when","superposing","several","plots",".","ax",":","`","list","`","of","`","matplotlib.axes","`",",","default=None","If","not","None",",","the","figure","will","be","plot","on","this","axis","and","show","will","be","set","to","False","."]
code: def plot_estimated_intensity(
      self,
      events,
      n_points=10000,
      plot_nodes=None,
      t_min=None,
      t_max=None,
      intensity_track_step=None,
      max_jumps=None,
      show=True,
      ax=None,
  ):
      """Plot value of intensity for a given realization with the fitted
      parameters
  
      events : `list` of `np.ndarray`, default = None
          One Hawkes processes realization, a list of n_node for
          each component of the Hawkes. Namely `events[i]` contains a
          one-dimensional `numpy.array` of the events' timestamps of
          component i.
  
      n_points : `int`, default=10000
          Number of points used for intensity plot.
  
      plot_nodes : `list` of `int`, default=`None`
          List of nodes that will be plotted. If `None`, all nodes are
          considered
  
      t_min : `float`, default=`None`
          If not `None`, time at which plot will start
  
      t_max : `float`, default=`None`
          If not `None`, time at which plot will stop
  
      intensity_track_step : `float`, default=`None`
          Defines how often intensity will be computed. If this is too low,
          computations might be long. By default, a value will be
          extrapolated from (t_max - t_min) / n_points.
  
      max_jumps : `int`, default=`None`
          If not `None`, maximum of jumps per coordinate that will be plotted.
          This is useful when plotting big point processes to ensure a only
          readable part of them will be plotted
  
      show : `bool`, default=`True`
          if `True`, show the plot. Otherwise an explicit call to the show
          function is necessary. Useful when superposing several plots.
  
      ax : `list` of `matplotlib.axes`, default=None
          If not None, the figure will be plot on this axis and show will be
          set to False.
      """
  
      simu = self._corresponding_simu()
      end_time = max(map(max, events))
  
      if t_max is not None:
          end_time = max(end_time, t_max)
  
      if intensity_track_step is None:
          display_start_time = 0
          if t_min is not None:
              display_start_time = t_min
          display_end_time = end_time
  
          intensity_track_step = (
              display_end_time - display_start_time
          ) / n_points
  
      simu.track_intensity(intensity_track_step)
      simu.set_timestamps(events, end_time)
  
      plot_point_process(
          simu,
          plot_intensity=True,
          n_points=n_points,
          plot_nodes=plot_nodes,
          t_min=t_min,
          t_max=t_max,
          max_jumps=max_jumps,
          show=show,
          ax=ax,
      )
  
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 12 for calling the LearnerHawkesParametric obj's underlying member method code with example usage: obj.plot_estimated_intensity(events, n_points, plot_nodes, t_min, t_max, intensity_track_step, max_jumps, show, ax) without return types