condense init parameters

examples/plot_multivariate_fadin.py

@@ -35,7 +35,8 @@
 discretization = torch.linspace(0, kernel_length, L)
 
 ###############################################################################
-# Here, we set the parameters of a Hawkes process with a Exponential(1) distributions.
+# Here, we set the parameters of a Hawkes process with a Exponential(1)
+# distribution.
 
 baseline = np.array([.1, .5])
 alpha = np.array([[0.6, 0.3], [0.25, 0.7]])
@@ -50,13 +51,14 @@
 ###############################################################################
 # Here, we apply FaDIn.
 
-solver = FaDIn(n_dim=n_dim,
-               kernel="truncated_exponential",
-               kernel_length=kernel_length,
-               delta=dt, optim="RMSprop",
-               params_optim={'lr': 1e-3},
-               max_iter=10000, criterion='l2'
-               )
+solver = FaDIn(
+    n_dim=n_dim,
+    kernel="truncated_exponential",
+    kernel_length=kernel_length,
+    delta=dt, optim="RMSprop",
+    params_optim={'lr': 1e-3},
+    max_iter=10000
+)
 solver.fit(events, T)
 
 # We average on the 10 last values of the optimization.

examples/plot_univariate_fadin.py

@@ -56,7 +56,7 @@
                kernel_length=kernel_length,
                delta=dt, optim="RMSprop",
                params_optim={'lr': 1e-3},
-               max_iter=2000, criterion='l2'
+               max_iter=2000
                )
 solver.fit(events, T)
 

experiments/benchmark/run_benchmark_exp.py

@@ -25,8 +25,13 @@ def simulate_data(baseline, alpha, decay, T, dt, seed=0):
     L = int(1 / dt)
     discretization = torch.linspace(0, 1, L)
     n_dim = decay.shape[0]
-    EXP = DiscreteKernelFiniteSupport(dt, n_dim=n_dim, kernel='truncated_exponential',
-                                      lower=0, upper=1)
+    EXP = DiscreteKernelFiniteSupport(
+        dt,
+        n_dim=n_dim,
+        kernel='truncated_exponential',
+        lower=0,
+        upper=1
+    )
 
     kernel_values = EXP.kernel_eval([torch.Tensor(decay)],
                                     discretization)
@@ -62,14 +67,16 @@ def simulate_data(baseline, alpha, decay, T, dt, seed=0):
 def run_fadin(events, decay_init, baseline_init, alpha_init, T, dt, seed=0):
     start = time.time()
     max_iter = 2000
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(decay_init)]
+    }
     solver = FaDIn(2,
                    "truncated_exponential",
-                   [torch.tensor(decay_init)],
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
+                   init=init,
                    delta=dt, optim="RMSprop",
                    step_size=1e-3, max_iter=max_iter,
-                   optimize_kernel=True, precomputations=True,
                    ztzG_approx=True, device='cpu', log=False
                    )
 
@@ -258,14 +265,17 @@ def run_experiment(baseline, alpha, decay, T, dt, seed=0):
     alpha_hat = results['param_alpha']
     decay_hat = results['param_kernel'][0]
 
-    RC = DiscreteKernelFiniteSupport(dt, n_dim=2, kernel='truncated_exponential',
+    RC = DiscreteKernelFiniteSupport(dt, n_dim=2,
+                                     kernel='truncated_exponential',
                                      lower=0, upper=1)
     intens_fadin = RC.intensity_eval(torch.tensor(baseline_hat),
                                      torch.tensor(alpha_hat),
                                      [torch.Tensor(decay_hat)],
                                      events_grid, torch.linspace(0, 1, L))
 
-    res['err_fadin'] = np.absolute(intens.numpy() - intens_fadin.numpy()).mean()
+    res['err_fadin'] = np.absolute(
+        intens.numpy() - intens_fadin.numpy()
+        ).mean()
     res['time_fadin'] = results['time']
 
     results = run_gibbs(S, size_grid, dt, seed=seed)

experiments/benchmark/run_benchmark_rc.py

@@ -63,15 +63,16 @@ def simulate_data(baseline, alpha, mu, sigma, T, dt, seed=0):
 def run_fadin(events, u_init, sigma_init, baseline_init, alpha_init, T, dt, seed=0):
     start = time.time()
     max_iter = 2000
+    init = {
+        'kernel': [torch.tensor(u_init), torch.tensor(sigma_init)],
+        'baseline': torch.tensor(baseline_init),
+        'alpha': torch.tensor(alpha_init)
+    }
     solver = FaDIn(2,
                    "raised_cosine",
-                   [torch.tensor(u_init),
-                    torch.tensor(sigma_init)],
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
+                   init=init,
                    delta=dt, optim="RMSprop",
                    step_size=1e-3, max_iter=max_iter,
-                   optimize_kernel=True, precomputations=True,
                    ztzG_approx=True, device='cpu', log=False
                    )
 

experiments/benchmark/run_benchmark_tg.py

@@ -62,15 +62,16 @@ def simulate_data(baseline, alpha, m, sigma, T, dt, seed=0):
 def run_fadin(events, m_init, sigma_init, baseline_init, alpha_init, T, dt, seed=0):
     start = time.time()
     max_iter = 2000
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(m_init), torch.tensor(sigma_init)]
+    }
     solver = FaDIn(2,
                    "truncated_gaussian",
-                   [torch.tensor(m_init),
-                    torch.tensor(sigma_init)],
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
+                   init=init,
                    delta=dt, optim="RMSprop",
                    step_size=1e-3, max_iter=max_iter,
-                   optimize_kernel=True, precomputations=True,
                    ztzG_approx=True, device='cpu', log=False
                    )
 

experiments/benchmark/run_comparison_ll.py

@@ -9,7 +9,7 @@
 from tick.hawkes import SimuHawkes, HawkesKernelTimeFunc
 
 from fadin.kernels import DiscreteKernelFiniteSupport
-from fadin.solver import FaDIn
+from fadin.solver import FaDIn, FaDIn_loglikelihood
 
 # %% simulate data
 # Simulated data
@@ -56,23 +56,40 @@ def simulate_data(baseline, alpha, kernel_params,
 
 
 def run_solver(criterion, events, kernel_params_init,
-               baseline_init, alpha_init, T, dt, seed=0, kernel='raised_cosine'):
-    k_params_init = [torch.tensor(a) for a in kernel_params_init]
+               baseline_init, alpha_init, T, dt, seed=0,
+               kernel='raised_cosine'):
     max_iter = 2000
-    solver = FaDIn(1,
-                   kernel,
-                   k_params_init,
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
-                   delta=dt,
-                   optim="RMSprop",
-                   step_size=1e-3,
-                   max_iter=max_iter,
-                   log=False,
-                   random_state=seed,
-                   device="cpu",
-                   optimize_kernel=True,
-                   criterion=criterion)
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(a) for a in kernel_params_init]
+    }
+    if criterion == 'l2':
+        solver = FaDIn(
+            1,
+            kernel,
+            init=init,
+            delta=dt,
+            optim="RMSprop",
+            step_size=1e-3,
+            max_iter=max_iter,
+            log=False,
+            random_state=seed,
+            device="cpu"
+        )
+    elif criterion == 'll':
+        solver = FaDIn_loglikelihood(
+            1,
+            kernel,
+            init=init,
+            delta=dt,
+            optim="RMSprop",
+            step_size=1e-3,
+            max_iter=max_iter,
+            log=False,
+            random_state=seed,
+            device="cpu"
+        )
     results = solver.fit(events, T)
     if kernel == 'truncated_exponential':
         results_ = dict(param_baseline=results['param_baseline'][-10:].mean().item(),

experiments/benchmark/run_nonparam_exp.py

@@ -61,19 +61,22 @@ def simulate_data(baseline, alpha, decay, T, dt, seed=0):
 #  @mem.cache
 def run_solver(events, decay_init, baseline_init, alpha_init, T, dt, seed=0):
     max_iter = 800
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(decay_init)]
+    }
     solver = FaDIn(1,
                    "truncated_exponential",
-                   [torch.tensor(decay_init)],
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
+                   init=init,
                    delta=dt,
                    optim="RMSprop",
                    step_size=1e-3,
                    max_iter=max_iter,
                    log=False,
                    random_state=seed,
                    device="cpu",
-                   optimize_kernel=True)
+                   )
     results = solver.fit(events, T)
     return results
 

experiments/benchmark/run_nonparam_rc.py

@@ -64,20 +64,22 @@ def simulate_data(baseline, alpha, mu, sigma, T, dt, seed=0):
 #  @mem.cache
 def run_solver(events, u_init, sigma_init, baseline_init, alpha_init, T, dt, seed=0):
     max_iter = 800
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(u_init), torch.tensor(sigma_init)]
+    }
     solver = FaDIn(1,
                    "raised_cosine",
-                   [torch.tensor(u_init),
-                    torch.tensor(sigma_init)],
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
+                   init=init,
                    delta=dt,
                    optim="RMSprop",
                    step_size=1e-3,
                    max_iter=max_iter,
                    log=False,
                    random_state=seed,
                    device="cpu",
-                   optimize_kernel=True)
+                   )
     results = solver.fit(events, T)
     return results
 

experiments/benchmark/run_nonparam_tg.py

@@ -63,20 +63,22 @@ def simulate_data(baseline, alpha, m, sigma, T, dt, seed=0):
 #  @mem.cache
 def run_solver(events, m_init, sigma_init, baseline_init, alpha_init, T, dt, seed=0):
     max_iter = 800
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(m_init), torch.tensor(sigma_init)]
+    }
     solver = FaDIn(1,
                    "truncated_gaussian",
-                   [torch.tensor(m_init),
-                    torch.tensor(sigma_init)],
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
+                   init=init,
                    delta=dt,
                    optim="RMSprop",
                    step_size=1e-3,
                    max_iter=max_iter,
                    log=False,
                    random_state=seed,
                    device="cpu",
-                   optimize_kernel=True)
+                   )
     results = solver.fit(events, T)
     return results
 

experiments/example_multivariate.py

@@ -61,12 +61,12 @@ def run_solver(events, dt, T,
                ztzG_approx, seed=0):
     start = time.time()
     max_iter = 2000
-    solver = FaDIn(2,
-                   "raised_cosine",
-                   delta=dt, optim="RMSprop", max_iter=max_iter,
-                   optimize_kernel=True, precomputations=True,
-                   ztzG_approx=ztzG_approx, device='cpu', log=False, tol=10e-6
-                   )
+    solver = FaDIn(
+        2,
+        "raised_cosine",
+        delta=dt, optim="RMSprop", max_iter=max_iter,
+        ztzG_approx=ztzG_approx, device='cpu', log=False, tol=10e-6
+)
 
     print(time.time() - start)
     solver.fit(events, T)

experiments/example_univariate.py

@@ -53,15 +53,17 @@ def run_solver(events, u_init, sigma_init, baseline_init,
                alpha_init, kernel_length, dt, T, seed=0):
     start = time.time()
     max_iter = 10000
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(u_init), torch.tensor(sigma_init)]
+    }
     solver = FaDIn(1,
                    "kumaraswamy",
-                   [torch.tensor(u_init),
-                    torch.tensor(sigma_init)],
-                   torch.tensor(baseline_init),
-                   torch.tensor(alpha_init),
+                   init=init,
                    kernel_length=kernel_length,
                    delta=dt, optim="RMSprop",
-                   max_iter=max_iter, criterion='l2'
+                   max_iter=max_iter, criterion='l2',
                    )
 
     print(time.time() - start)

experiments/inference_error/run_comp_autodiff.py

@@ -10,7 +10,7 @@
 from tick.hawkes import SimuHawkes, HawkesKernelTimeFunc
 
 from fadin.kernels import DiscreteKernelFiniteSupport
-from fadin.solver import FaDIn
+from fadin.solver import FaDIn, FaDIn_no_precomputations
 
 ################################
 # Meta parameters
@@ -58,30 +58,36 @@ def simulate_data(baseline, alpha, mu, sigma, T, dt, seed=0):
 
 @mem.cache
 def run_solver(events, u_init, sigma_init, baseline_init, alpha_init, T, dt, seed=0):
-
     max_iter = 800
-    solver_autodiff = FaDIn(1,
-                            "raised_cosine",
-                            [torch.tensor(u_init),
-                             torch.tensor(sigma_init)],
-                            torch.tensor(baseline_init),
-                            torch.tensor(alpha_init),
-                            delta=dt, optim="RMSprop",
-                            step_size=1e-3, max_iter=max_iter,
-                            precomputations=False, random_state=0)
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(u_init), torch.tensor(sigma_init)]
+    }
+    solver_autodiff = FaDIn_no_precomputations(
+        1,
+        "raised_cosine",
+        init=init,
+        delta=dt, optim="RMSprop",
+        step_size=1e-3, max_iter=max_iter,
+        random_state=0
+    )
     start_autodiff = time.time()
     solver_autodiff.fit(events, T)
     time_autodiff = time.time() - start_autodiff
-
-    solver_FaDIn = FaDIn(1,
-                         "raised_cosine",
-                         [torch.tensor(u_init),
-                          torch.tensor(sigma_init)],
-                         torch.tensor(baseline_init),
-                         torch.tensor(alpha_init),
-                         delta=dt, optim="RMSprop",
-                         step_size=1e-3, max_iter=max_iter,
-                         precomputations=True, random_state=0)
+    init = {
+        'alpha': torch.tensor(alpha_init),
+        'baseline': torch.tensor(baseline_init),
+        'kernel': [torch.tensor(u_init), torch.tensor(sigma_init)]
+    }
+    solver_FaDIn = FaDIn(
+        1,
+        "raised_cosine",
+        init=init,
+        delta=dt, optim="RMSprop",
+        step_size=1e-3, max_iter=max_iter,
+        random_state=0
+    )
     start_FaDIn = time.time()
     solver_FaDIn.fit(events, T)
     time_FaDIn = time.time() - start_FaDIn