class_docstr: A class that implements parametric inference for Hawkes processes
  with an exponential parametrisation of the kernels and a mix of Lasso
  and nuclear regularization
  
  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`
  
  and with an exponential parametrisation of the kernels
  
  .. math::
      \phi_{ij}(t) = \alpha^{ij} \beta \exp (- \beta t) 1_{t > 0}
  
  In our implementation we denote:
  
  * Integer :math:`D` by the attribute `n_nodes`
  * Vector :math:`\mu \in \mathbb{R}^{D}` by the attribute
    `baseline`
  * Matrix :math:`A = (\alpha^{ij})_{ij} \in \mathbb{R}^{D \times D}`
    by the attribute `adjacency`
  * Number :math:`\beta \in \mathbb{R}` by the parameter `decay`. This
    parameter is given to the model
  
  Parameters
  ----------
  decay : `float`
      The decay used in the exponential kernel
  
  C : `float`, default=1e3
      Level of penalization
  
  lasso_nuclear_ratio : `float`, default=0.5
      Ratio of Lasso-Nuclear regularization mixing parameter with
      0 <= ratio <= 1.
  
      * For ratio = 0 this is nuclear regularization
      * For ratio = 1 this is lasso (L1) regularization
      * For 0 < ratio < 1, the regularization is a linear combination
        of Lasso and nuclear.
  
  max_iter : `int`, default=50
      Maximum number of iterations of the solving algorithm
  
  tol : `float`, default=1e-5
      The tolerance of the solving algorithm (iterations stop when the
      stopping criterion is below it). If not reached it does ``max_iter``
      iterations
  
  verbose : `bool`, default=False
      If `True`, we verbose things
  
  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
  
  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``
  
  Other Parameters
  ----------------
  rho : `float`, default=0.1
      Positive parameter of the augmented Lagrangian. Called penalty
      parameter, the higher it is, the more strict will be the
      penalization.
  
  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
  
  em_max_iter : `int`, default=30
      Maximum number of loop for inner em algorithm.
  
  em_tol : `float`, default=None
      Tolerance of loop for inner em algorithm. If relative difference of
      baseline and adjacency goes bellow this tolerance, em inner loop
      will stop.
      If None, it will be set given a heuristic which look at last
      relative difference obtained in the main loop.
  
  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
  
  adjacency : `np.ndarray`, shape=(n_nodes, n_nodes)
      Inferred adjacency matrix
  
  References
  ----------
  Zhou, K., Zha, H., & Song, L. (2013, May).
  Learning Social Infectivity in Sparse Low-rank Networks Using
  Multi-dimensional Hawkes Processes. In `AISTATS (Vol. 31, pp. 641-649)
  <http://www.jmlr.org/proceedings/papers/v31/zhou13a.pdf>`_.
class_docstr_tok: ["A","class","that","implements","parametric","inference","for","Hawkes","processes","with","an","exponential","parametrisation","of","the","kernels","and","a","mix","of","Lasso","and","nuclear","regularization","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","`","and","with","an","exponential","parametrisation","of","the","kernels","..","math",":",":","\\phi_","{","ij","}","(","t",")","=","\\alpha^","{","ij","}","\\beta","\\exp","(","-","\\beta","t",")","1_","{","t",">","0","}","In","our","implementation","we","denote",":","*","Integer",":","math",":","`","D","`","by","the","attribute","`","n_nodes","`","*","Vector",":","math",":","`","\\mu","\\in","\\mathbb","{","R","}","^","{","D","}","`","by","the","attribute","`","baseline","`","*","Matrix",":","math",":","`","A","=","(","\\alpha^","{","ij","}",")","_","{","ij","}","\\in","\\mathbb","{","R","}","^","{","D","\\times","D","}","`","by","the","attribute","`","adjacency","`","*","Number",":","math",":","`","\\beta","\\in","\\mathbb","{","R","}","`","by","the","parameter","`","decay","`",".","This","parameter","is","given","to","the","model","Parameters","--","--","--","--","--","decay",":","`","float","`","The","decay","used","in","the","exponential","kernel","C",":","`","float","`",",","default=1e3","Level","of","penalization","lasso_nuclear_ratio",":","`","float","`",",","default=0.5","Ratio","of","Lasso-Nuclear","regularization","mixing","parameter","with","0","<","=","ratio","<","=","1",".","*","For","ratio","=","0","this","is","nuclear","regularization","*","For","ratio","=","1","this","is","lasso","(","L1",")","regularization","*","For","0","<","ratio","<","1",",","the","regularization","is","a","linear","combination","of","Lasso","and","nuclear",".","max_iter",":","`","int","`",",","default=50","Maximum","number","of","iterations","of","the","solving","algorithm","tol",":","`","float","`",",","default=1e-5","The","tolerance","of","the","solving","algorithm","(","iterations","stop","when","the","stopping","criterion","is","below","it",")",".","If","not","reached","it","does","``","max_iter","``","iterations","verbose",":","`","bool","`",",","default=False","If","`","True","`",",","we","verbose","things","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","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","``","Other","Parameters","--","--","--","--","--","--","--","--","rho",":","`","float","`",",","default=0.1","Positive","parameter","of","the","augmented","Lagrangian",".","Called","penalty","parameter",",","the","higher","it","is",",","the","more","strict","will","be","the","penalization",".","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","em_max_iter",":","`","int","`",",","default=30","Maximum","number","of","loop","for","inner","em","algorithm",".","em_tol",":","`","float","`",",","default=None","Tolerance","of","loop","for","inner","em","algorithm",".","If","relative","difference","of","baseline","and","adjacency","goes","bellow","this","tolerance",",","em","inner","loop","will","stop",".","If","None",",","it","will","be","set","given","a","heuristic","which","look","at","last","relative","difference","obtained","in","the","main","loop",".","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","adjacency",":","`","np.ndarray","`",",","shape=","(","n_nodes",",","n_nodes",")","Inferred","adjacency","matrix","References","--","--","--","--","--","Zhou",",","K.",",","Zha",",","H.",",","&","Song",",","L.","(","2013",",","May",")",".","Learning","Social","Infectivity","in","Sparse","Low-rank","Networks","Using","Multi-dimensional","Hawkes","Processes",".","In","`","AISTATS","(","Vol",".","31",",","pp",".","641-649",")","<","http",":","\/\/www.jmlr.org\/proceedings\/papers\/v31\/zhou13a.pdf",">","`","_","."]
docstr: Perform one iteration of the algorithm
  
  Parameters
  ----------
  baseline_start : `None` or `np.ndarray`, shape=(n_nodes)
      Set initial value of baseline parameter
      If `None` starts with uniform 1 values
  
  adjacency_start : `None` or `np.ndarray', shape=(n_nodes, n_nodes)
      Set initial value of adjacency parameter
      If `None` starts with random values uniformly sampled between 0.5
      and 0.9
docstr_tok: ["Perform","one","iteration","of","the","algorithm","Parameters","--","--","--","--","--","baseline_start",":","`","None","`","or","`","np.ndarray","`",",","shape=","(","n_nodes",")","Set","initial","value","of","baseline","parameter","If","`","None","`","starts","with","uniform","1","values","adjacency_start",":","`","None","`","or","`","np.ndarray","'",",","shape=","(","n_nodes",",","n_nodes",")","Set","initial","value","of","adjacency","parameter","If","`","None","`","starts","with","random","values","uniformly","sampled","between","0.5","and","0.9"]
code: def _solve(self, baseline_start=None, adjacency_start=None):
      """Perform one iteration of the algorithm
  
      Parameters
      ----------
      baseline_start : `None` or `np.ndarray`, shape=(n_nodes)
          Set initial value of baseline parameter
          If `None` starts with uniform 1 values
  
      adjacency_start : `None` or `np.ndarray', shape=(n_nodes, n_nodes)
          Set initial value of adjacency parameter
          If `None` starts with random values uniformly sampled between 0.5
          and 0.9
      """
  
      if baseline_start is None:
          baseline_start = np.ones(self.n_nodes)
  
      self._set("baseline", baseline_start.copy())
  
      if adjacency_start is None:
          adjacency_start = np.random.uniform(
              0.5, 0.9, (self.n_nodes, self.n_nodes)
          )
      self._set("adjacency", adjacency_start.copy())
  
      z1 = np.zeros_like(self.adjacency)
      z2 = np.zeros_like(self.adjacency)
      u1 = np.zeros_like(self.adjacency)
      u2 = np.zeros_like(self.adjacency)
  
      if self.rho <= 0:
          raise ValueError(
              "The parameter rho equals {}, while it should "
              "be strictly positive.".format(self.rho)
          )
  
      max_relative_distance = 1e-1
      for i in range(self.max_iter):
          if self._should_record_iter(i):
              prev_objective = self.objective(self.coeffs)
              prev_baseline = self.baseline.copy()
              prev_adjacency = self.adjacency.copy()
  
          for _ in range(self.em_max_iter):
              inner_prev_baseline = self.baseline.copy()
              inner_prev_adjacency = self.adjacency.copy()
              self._learner.solve(
                  self.baseline, self.adjacency, z1, z2, u1, u2
              )
              inner_rel_baseline = relative_distance(
                  self.baseline, inner_prev_baseline
              )
              inner_rel_adjacency = relative_distance(
                  self.adjacency, inner_prev_adjacency
              )
  
              if self.em_tol is None:
                  inner_tol = max_relative_distance * 1e-2
              else:
                  inner_tol = self.em_tol
  
              if (
                  max(inner_rel_baseline, inner_rel_adjacency)
                  < inner_tol
              ):
                  break
  
          z1 = self._prox_nuclear.call(
              np.ravel(self.adjacency + u1), step=1.0 / self.rho
          ).reshape(self.n_nodes, self.n_nodes)
          z2 = self._prox_l1.call(
              np.ravel(self.adjacency + u2), step=1.0 / self.rho
          ).reshape(self.n_nodes, self.n_nodes)
  
          u1 += self.adjacency - z1
          u2 += self.adjacency - z2
  
          if self._should_record_iter(i):
              objective = self.objective(self.coeffs)
  
              rel_obj = abs(objective - prev_objective) / abs(
                  prev_objective
              )
              rel_baseline = relative_distance(
                  self.baseline, prev_baseline
              )
              rel_adjacency = relative_distance(
                  self.adjacency, prev_adjacency
              )
  
              max_relative_distance = max(rel_baseline, rel_adjacency)
              # We perform at least 5 iterations as at start we sometimes
              # reach a low tolerance if inner_tol is too low
              converged = max_relative_distance <= self.tol and i > 5
              force_print = (i + 1 == self.max_iter) or converged
  
              self._handle_history(
                  i + 1,
                  obj=objective,
                  rel_obj=rel_obj,
                  rel_baseline=rel_baseline,
                  rel_adjacency=rel_adjacency,
                  force=force_print,
              )
  
              if converged:
                  break
  
imports: import numpy
  from tick.hawkes import ModelHawkesExpKernLogLik, SimuHawkesExpKernels
  from tick.hawkes.inference.base import LearnerHawkesNoParam
  from tick.hawkes.inference.build.hawkes_inference import HawkesADM4
  from tick.prox import ProxNuclear
  from tick.prox.prox_l1 import ProxL1
  from tick.solver.base.utils import relative_distance
label_desc: Use image node_id 4 for calling the HawkesADM4 obj's underlying member method code with example usage: obj._solve(baseline_start, adjacency_start) without return types