Print basic information of proposed database :param database: the database with the format mentioned above

Plot decay function and its integration and save the figure as a png file Args: t_stop (float): the end of timestamp

Save trained model :param full_path: the path of directory :param mode: 'parameter' for saving only parameters of the mode

Load event sequences from a csv file :param file_name: the path and name of the target csv file :param domain_names: a dictionary cont

Simulate one or more event sequences from given model. :param history: historical observations history = {'event_featu

Build a dictionary containing all events' basic information (i.e., index and features) for a specific event sequence :param database: the p

Learn parameters of a generalized Hawkes process given observed sequences :param dataloader: a pytorch batch-based data loader

Calculate the integrations of decay kernel in the interval [t_start, t_stop] :param t_stop: a 2D Tensor containing stop timestamps

Load pre-trained model :param full_path: the path of directory :param mode: 'parameter' for saving only parameters of the

Plot and save the stem figure of exogenous intensity :param sample_dict: :param output_name: :return:

Print basic information of the kernel model.

Calculate decay kernel's value at time 'dt' :param dt: a 2D Tensor containing the time intervals between current event and historic

Convert a batch sampled from dataloader to a dictionary :param samples: a batch of data sampled from the "dataloader" defined by EventSampl

Initialize decay functions gate, g(t) = 1/a, if t in [delay, delay + a], = 0 otherwise. :param parame

Calculate the granger causality among event types a_{cc'm} :param sample_dict is a dictionary contains a batch of sample

Compute the avaraged loss per event of a generalized Hawkes process given observed sequences and current model :param data

Initialize endogenous impact: phi_{kk'}(t) = sum_{m} a_{kk'm} kernel_m(t), for m = 1, ..., M, A_m = [a_{kk'm}] in R^{C*C+1}, C is t

load events' features from a csv file :param file_name: the path and the name of the csv file :param event_domain: the name of the key

load sequences' features from a csv file :param file_name: the path and the name of the csv file :param seq_domain: the name of the ke

Initialize exogenous intensity function: mu(t) = mu, mu in R^{C+1}, C is the number of event type :param num_type: for a point proc

Initialize generalized Hawkes process :param num_type: int, the number of event types. :param mu_dict: the dictionary of e

Stitch each sequence in database2 to the end of one sequence of database1 :param database1: the observed event sequences :param databa

Superpose each sequence in database2 to one sequence of database1 :param database1: the observed event sequences :param database2: ano

Compute the avaraged loss per event of a generalized Hawkes process given observed sequences and current model :param dataloader: a

Count the number of events in predefined time bins, and convert event sequences to aggregate time series :param database: the observed

Calculate expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :param

Calculate the expected number of events in dts sum_i int_{0}^{dt_i} phi_cc_i(s)ds for dt_i in "dts" and c in {1, ..., num_type}

Find the root "data" directory within this repository. Returns: str: absolute path of the "data" directory within this repository

Find the root path of this repository. Returns: str: absolute path of the root of this repository

Calculate intensity mu_{c_i} for c_i in "events"; :param sample_dict is a dictionary contains a batch of samples sample_

Calculate intensity of event phi_{c_i,c_j}(t_i - t_j) for c_i in "events"; :param sample_dict is a dictionary contains a

Create a directory (and its parents) if it does not exist. Args: path (str): directory path to create, including any missing parents

Navigate to a parent directory relative to a given file path. Args: path (str): path to navigate from (file or directory; note that

Print basic information of the model.

Simulate one or more event sequences from given model. :param history: historical observations history = {'event_featu

Initialize decay functions exponential g(t) = w * exp(-w(t-delay)) if t>=delay, = 0 if t<delay :param par

Initialize a mixture model of generalized Hawkes processes :param num_type: int, the number of event types :param num_clus

Initialize exogenous intensity function: mu(t) = mu, mu in R^{C+1}, C is the number of event type :param num_type: for a point proc

Initialize exogenous intensity function: mu(t) = mu, mu in R^{C+1}, C is the number of event type :param num_type: for a point proc

Initialize generalized Hawkes process :param num_type: int, the number of event types. :param loss_type: str, the type of

Initialize generalized Hawkes process :param num_type: int, the number of event types. :param mu_dict: the dictionary of e

Initialize exogenous intensity function: mu(t) = mu, mu in R^{C+1}, C is the number of event type :param num_type: for a point proc

Initialize endogenous impact: phi_{kk'}(t) = sum_{m} a_{kk'm} kernel_m(t), for m = 1, ..., M, A_m = [a_{kk'm}] in R^{C*C+1}, C is t

Initialize endogenous impact: phi_{kk'}(t) = sum_{m} a_{kk'm} kernel_m(t), for m = 1, ..., M, A_m = [a_{kk'm}] in R^{C*C+1}, C is t

Initialize endogenous impact: phi_{kk'}(t) = sum_m (w_{cm}^T * f_{c'}) * kernel_m(t), for m = 1, ..., M, W_m = [w_{cm}] in R^{(C+1)

Initialize endogenous impact: phi_{cc'}(t) = sum_m (f_{c}^T * W_m * f_{c'}) * kernel_m(t) for m = 1, ..., M, W_m = [w_{cm}] in R^{(

Initialize decay functions rayleigh, g(t) = wt * exp(-wt^2/2) if t>0 :param parameters: the parameter

Initialize decay functions rayleigh, g(t) = w * exp(-wt^2/2) if t>0 :param parameters: the parameters

Initialize decay functions powerlaw, g(t) = (w-1)*delay^(w-1)*t^(-w) if t>=delay, = (w-1)/delay if t<delay

Initialize decay functions multigauss. g(t) = sum_i 1/sqrt(2pi*sigma_i^2) * exp(-(t-mu_i)^2/(2*sigma_i^2))

:param database: the observed event sequences database = {'event_features': None or (C, De) float array of event's static featu

:param database: the observed event sequences database = {'event_features': None or (C, De) float array of event's static featu

Calculate the expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :p

Calculate the expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :p

Calculate the expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :p

Calculate the expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :p

Calculate the expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :p

Calculate the expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :p

Calculate the expected number of events in dts int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type} :p

Find a custom data directory within this repository, and optionally create it if it does not exist. For example, to resolve the absolute pat

Learn parameters of a generalized Hawkes process given observed sequences :param dataloader: a pytorch batch-based data loader

Learn parameters of a generalized Hawkes process given observed sequences :param dataloader: a pytorch batch-based data loader

compute negative log-likelihood of the given batch :param lambda_t: (batchsize, 1) float tensor representing intensity functions

compute negative log-likelihood of the given batch :param lambda_t: (batchsize, 1) float tensor representing intensity functions

compute least-square loss between integrated intensity and counting matrix :param lambda_t: (batch_size, 1) :param Lambda_

Calculate GW discrepancy :param As: learnable cost matrix of source :param At: learnable cost matrix of target :p

Calculate GW discrepancy :param mu_s: learnable base intensity of source :param mu_t: learnable base intensity of target

Calculate 1) mu_{c_i} for c_i in "events"; 2) int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ..., num_type}

Calculate 1) phi_{c_i,c_j}(t_i - t_j) for c_i in "events"; 2) int_{0}^{dt_i} mu_c(s)ds for dt_i in "dts" and c in {1, ...,

Learning optimal transport from source to target domain Args: cost_s: (Ns, Ns) matrix representing the relationships among sourc

Calculate the granger causality among event types a_{cc'm} :param sample_dict is a dictionary contains a batch of sample

Calculate the granger causality among event types a_{cc'm} :param sample_dict is a dictionary contains a batch of sample

Calculate the granger causality among event types a_{cc'm} :param sample_dict is a dictionary contains a batch of sample

Calculate the granger causality among event types a_{cc'm} :param sample_dict is a dictionary contains a batch of sample

Calculate the integrations of decay kernel in the interval [t_start, t_stop] :param t_stop: a 2D Tensor containing stop timestamps

Calculate the integrations of decay kernel in the interval [t_start, t_stop] :param t_stop: a 2D Tensor containing stop timestamps

Calculate the integrations of decay kernel in the interval [t_start, t_stop] :param t_stop: a 2D Tensor containing stop timestamps

Calculate the integrations of decay kernel in the interval [t_start, t_stop] :param t_stop: a 2D Tensor containing stop timestamps

Calculate the integrations of decay kernel in the interval [t_start, t_stop] :param t_stop: a 2D Tensor containing stop timestamps