Coupled Point Process-based Sequence Modeling for Privacy-preserving Network Alignment

1 Introduction

As a fundamental task for network modeling and analysis, network alignment plays a central role in many realworld applications, such as financial fraud detection [Zhang et al., 2019; Pourhabibi et al., 2020] and crime network tracing [Wang et al., 2019a; Sun et al., 2022] across different platforms, and is significant for social good. Given two or more networks, we often model network alignment as a graph matching problem and infer the correspondence between the networks based on their topologies (e.g., the adjacency matrices indicating edges [Bayati et al., 2009; Mohammadi et al., 2017] and the similarity matrices derived from node features [Heimann et al., 2018; Xu et al., 2019]). Following this modeling strategy, many network alignment methods have been proposed. However, these methods ignore that the network topology is unreliable and even unavailable in many real-world scenarios, which limits their applications.

Take financial crime network identification and tracing as an example. Criminals often have multiple accounts across different financial platforms with fake identities. Detecting and tracing crime networks across different platforms needs to access the network topologies of multiple platforms and align the networks based on their topological similarities. However, for the service providers of the platforms, sharing their network topologies with others raises the risk of customer information leakage because the network topology often contains the private information of normal accounts (e.g., their identities, profiles, and social connections) besides the criminals' accounts. As a result, coordinating with multiple platforms to obtain their network topologies is often technically and politically infeasible for a third party. Such a scenario leads to a significant and challenging privacypreserving network alignment problem, which requires us to align networks without accessing their topologies.

The privacy-preserving network alignment problem is highly correlated with the 16th United Nations Sustainable Development Goal (UN-SDG), i.e., promoting peaceful and inclusive societies for sustainable development, providing access to justice for all, and building effective, accountable, and inclusive institutions at all levels. On the one hand, network alignment is one of the necessary techniques for combating global cybercrimes, especially for detecting and tracing financial fraud and money laundering across platforms. On the other hand, privacy preservation is an objective restriction for any institution accessing multi-network data, which helps to protect civil rights. While this problem commonly appears in various practical applications, to our surprise, it is seldom considered by existing network alignment works.

In this study, we develop a novel coupled point process (CPP) model associated with a robust learning algorithm, which provides a potential solution to privacy-preserving network alignment. As illustrated in Figure 1, our method aligns two networks based on the event sequences of their nodes in the continuous-time domain rather than the network topologies. This setting is based on two facts: i) The sequential behaviors of nodes are often driven by their social relations (i.e., the network topology) and thus contain important information for our alignment task (i.e., the nodes having correspondence should have similar sequential behaviors). ii) Compared to the network topology, the sequential behaviors of nodes are relatively easy to access and with much less private information. 1 Our CPP model consists of two modules: i) a coupled node embedding layer capturing the node embeddings specified for different networks, and ii) a shared neural point process module predicting the dynamics of the event sequences jointly. Instead of embedding the nodes independently, the coupled embedding layer explicitly models one network's node embeddings and parameterizes the other network's node embeddings by multiplying the explicit node embeddings with a learnable alignment matrix. The alignment matrix is doubly-stochastic, which indicates the correspondence between the two networks' nodes in a probabilistic manner. The CPP model can be efficiently learned by the maximum likelihood estimation with an inverse optimal transport (IOT) regularizer [Li et al., 2019].

To our knowledge, our work makes the first attempt to achieve privacy-preserving network alignment based on a coupled point process-based modeling strategy. For our CPP model, its coupled node embedding layer provides a new technical route to jointly model the node embeddings of different networks. In the learning phase, the IOT-based regularizer works better than other candidate regularizers, which leads to robust alignment results. Experiments show that our method is compatible with various point process backbones [Zuo et al., 2020; Zhang et al., 2020a] and thus is robust to the model misspecification issue. It outperforms other sequence-based alignment methods [Luo et al., 2019] and is comparable to the traditional methods that rely on network topology, which achieves a trade-off between alignment accuracy and privacy preservation.

1 For example, for a criminal with a financial account, accessing the transaction history of the account is easier than inferring the identity and the social network of the criminal [Zhu and Xie, 2022].

2 RelatedWork

2.1 Network Alignment

Traditional network alignment methods can be categorized into two classes. One is extracting manually-designed node features and aligning them via heuristic algorithms, e.g., the genetic algorithms used in [Sun et al., 2015; Vijayan et al., 2015], the greedy search in [Neyshabur et al., 2013; Huang et al., 2016], and the spectral methods in [Patro and Kingsford, 2012; Nassar et al., 2018]. The other formulates the task as a quadratic assignment problem (QAP) and solves it approximately under different relaxation strategies and with various structural information. The commonly-used relaxation strategies include the convex relaxation [Hashemifar et al., 2016] and the doubly-stochastic relaxation based on the optimal transport theory [Xu et al., 2019]. For the structural information, besides considering the pairwise relations [Liu et al., 2016], the TAME in [Mohammadi et al., 2017] further considers high-order relations among nodes when aligning networks. These methods are based on the consistency assumption, i.e., the two nodes of different networks are likely to be aligned if their neighborhoods have similar topologies.

Recently, some learning-based network alignment methods have been proposed, which align networks based on learned node embeddings. Typical node embedding strategies include the matrix factorization used in REGAL [Heimann et al., 2018], the random walk-based method in BRIGHT [Yan et al., 2021], and the graph convolution network in NeXtAlign [Zhang et al., 2021]. These methods apply learnable modules to embed nodes and align the networks based on the similarity matrix constructed by the node embeddings. More recently, beyond learning node embeddings, some attempts have been made to make the whole network alignment task learnable in an end-to-end manner, e.g., the graph matching network (GMN) in [Zanfir and Sminchisescu, 2018], the PIA/PCA-GM in [Wang et al., 2019b], and the DGMC in [Fey et al., 2020]. These methods learn a differentiable alignment matrix for network alignment via the Sinkhorn matching module [Adams and Zemel, 2011].

2.2 Point Process-Based NetworkModeling

Given the event sequences generated based on network topology, we often apply temporal point processes (TPPs) [Daley and Vere-Jones, 2007] to capture their dynamics. One of the most well-known TPPs is the Hawkes process [Hawkes, 1971], which can infer network topology directly by exploring the Granger causal graph of nodes from the event sequences [Zhou et al., 2013; Xu et al., 2016a]. Recently, some variants of Hawkes process have been proposed, e.g., RMTPP [Du et al., 2016], CT-LSTM [Mei and Eisner, 2017], self-attentive Hawkes process (SAHP) [Zhang et al., 2020a], and Transformer Hawkes process (THP) [Zuo et al., 2020]. These models enhance the representation power of Hawkes process via neural networks, e.g., recurrent neural networks and attention layers [Vaswani et al., 2017]. The work in [Zhang et al., 2020c] shows that these neural point processes can learn the Granger causal graph of nodes (i.e., the network topology) as the traditional Hawkes process does. We often learn the TPP models based on the maximum likelihood estimation (MLE) [Daley and Vere-Jones, 2007]. The work in [Guo et al., 2018; Mei et al., 2020] applies contrastive learning strategies to speed up the learning process.

The above TPP models have been applied to many practical applications, e.g., financial data analysis [Bacry et al., 2015] and crime network detection [Mohler et al., 2011; Zhu and Xie, 2022]. However, given the event sequences generated from two or more networks, their joint modeling is seldom considered by existing work. Recently, the fused Gromov-Wasserstein alignment (FGWA) method is proposed for Hawkes processes [Luo et al., 2019], which aligns networks based on the event sequences of nodes. This method is hard to expand to large-scale networks and sensitive to hyperparameter settings. Moreover, it assumes that the event sequences are generated by random processes predefined on the networks, resulting in a high model misspecification risk.

3 ProposedModel

3.1 Preliminaries and Problem Statement

Suppose that we have two networks, which are represented as two graphs, i.e., {Gk(Vk,Ak)}2k=1 . For the k-th network, Vk = {vk i }Ik i=1 is the node set, and Ak ∈ RIk×Ik is the adjacency matrix, whose non-zero elements indicates the edges. As aforementioned, we consider the scenario where neither the topological structures of the graphs (the Ak's) nor the correspondence among them is known. What we observed are the event sequences of their nodes in the continuous-time domain, denoted as Sk = {(tkm, vkm) ∈ [0, T ] × Vk}Mk m=1 for k = 1, 2. Here, Sk represents the event sequence generated by the k-th network, and (tkm, vkm) represents the m-th event of the node vkm ∈ Vk at the timestamp tkm ∈ [0, T], where T indicates the length of the time window.

We assume that the event sequence of the k-th network is generated by an unknown temporal point process (TPP), i.e.,

where Nk(t;Ak) = {N k v (t;Ak)}v∈Vk is the counting process corresponding to the temporal point process, whose parameters are determined by the adjacency matrix Ak. N k v (t;Ak) counts the number of the node v's events till time t, and we characterize the expected instantaneous happening rates of the events via an intensity function, i.e.,

where v indicates the node index belonging to a node set Vk, and Hk t = {(tkm, vkm) ∈ Sk|tkm < t} represents the historical events till time t.

Suppose that the two networks have correspondence with each other, i.e.,

where the alignment matrix P ∈ {0, 1}N2×N1 indicates the correspondence between the two networks' nodes, and E ∈ RN2×N1 represents the unknown random noise. Given {Sk}2k=1 , we would like to infer P robustly.

This privacy-preserving network alignment problem is more challenging than the traditional one because it introduces more uncertainty. In particular, neither the adjacency matrices nor the alignment matrix is known, so we have to solve the network inference and alignment jointly. A na¨ıve way is solving the following learning task:

where L(Sk;Ak) is the negative log-likelihood (NLL) of the sequence Sk, which is defined as

and R(A1,A2,P) is a regularizer for the network topology and the alignment matrix, whose significance is controlled by τ > 0. We can design the regularizer in various manners. For example, it can be ∥A2 - PA1P T ∥2F based on the model assumption in (3). In [Luo et al., 2019], it is defined as a Gromov-Wasserstein (GW) alignment loss [Xu et al., 2019], i.e., R(A1,A2,P) = maxP∈Ω⟨A2PA1,P⟩, where Ω is a doubly-stochastic constraint on P and ⟨·, ·⟩ indicates the inner product of matrices.

Unfortunately, this na¨ıve method suffers from the following three problems. Firstly, learning the TPP models and the alignment matrix jointly has much higher complexity and often leads to unsatisfactory sub-optimal solutions. Secondly, the scalability of this learning method is poor because the complexity of the model parameters is quadratic to the number of nodes. Finally, the formulation of the TPP model in (1) is often unknown in practice, so the learning problem often suffers from the model misspecification issue. Based on the analysis above, we need to design a TPP model that has better scalability and is robust to the model misspecification problem. Additionally, we need to introduce prior knowledge and design a more informative regularizer to avoid catastrophic over-fitting. These requirements motivate us to design the coupled point process model and its learning algorithm.

3.2 Coupled Point Process Model

Given the event sequences of two networks, our CPP models their dynamics jointly based on the same conditional intensity function instead of modeling them independently. Specifically, given a timestamp t and the historical events Ht (from either S1 or S2), we have

where Vk = [vk i ] ∈ RD×Ik represents the node embeddings of the k-th network. g is a neural TPP that takes the timestamp and the history as input. Its parameters include: i) the node embeddings {Vk}2k=1 that are specified for each network, and ii) the parameter θ shared by the two networks.

The CPP in (6) is a generalized framework covering many representative temporal point process models. In particular, we can implement g based on different backbones and obtain various point processes accordingly.

Classic Point Processes. Our CPP can cover classic TPPs, e.g., Hawkes processes [Zhou et al., 2013] and mutuallycorrecting processes [Xu et al., 2016b], via parameterizing the adjacency matrices based on the node embeddings. For the Hawkes process, denoted as HP(µ, Φ), its intensity function λv(t) = µv + ∑tn<t ϕvvn (t - tn) consists of a base intensity µ = [µv] and a set of impact functions Φ = [ϕvv′ (t)]. Each impact function is often modeled based on the adjacency matrix and a decay function, i.e., ϕvv′(t) = avv′κ(t), where avv′ is the element of A. Our CPP parameterizes A as a bi-linear model V T WV and µ as a linear model V T w, and accordingly, θ = {W ∈ RD×D , w ∈ RD }.

Neural Hawkes Processes. When g is a multi-head selfattention module, our CPP corresponds to the Transformer Hawkes process (THP) [Zuo et al., 2020] or the selfattentive Hawkes process (SAHP) [Zhang et al., 2020a]. When g is a recurrent neural network module defined in the continuous-time domain, our CPP corresponds to the continuous-time LSTM (CT-LSTM) [Mei and Eisner, 2017] or the RMTPP [Du et al., 2016]. These TPPs take learnable node embeddings as input.

Our CPP models the event sequences of two networks jointly, whose number of parameters is fewer than that of modeling the sequences independently. Additionally, instead of inferring the adjacency matrices, our CPP captures the topological information of the networks by the node embeddings. As a result, our model has better scalability and a lower risk of over-fitting because the number of model parameters is linear rather than quadratic to the network size.

Based on the node embeddings, we reformulate the network alignment problem as inferring an alignment matrix to indicate the similar node embeddings across the two networks, i.e., V2 = V1P T . The key point of our CPP model is the following coupled node embedding layer, which takes the alignment matrix as a part of the model parameters.

3.3 Coupled Node Embedding Layer

As illustrated in Figure 2, our coupled node embedding layer models the node embeddings of one network explicitly and parameterizes the node embeddings of the other network as

where Pγ is an approximation of the alignment matrix P, which is parameterized by γ. To make the layer differentiable, we relax the binary restriction of the alignment matrix, modeling Pγ by the following Sinkhorn matching module [Adams and Zemel, 2011]:

where Sinkhorn(Cγ, ϵ) denotes the matching module based on the Sinkhorn scaling algorithm [Sinkhorn and Knopp, 1967; Cuturi, 2013], which solves the entropic optimal transport (EOT) problem in (8) via Algorithm 1. Here, Cγ ∈ RI2×I1 is the grounding cost matrix of the EOT problem, which is with parameter γ. In this study, we consider two implementations of Cγ: i) treating it as a non-parametric model

Algorithm 1 Sinkhorn matching module

• 1: Input: The cost matrix Cγ.
• 2: Hyperparameters: The number of iterations K, the weight of the entropic regularizer ϵ.
• 3: Initialize K = exp(- Cγ ϵ ), a = 1I1 , and b = 1I2
• 4: for k = 1, ...,K do
• 5: b ← 1 I2Ka , then a← 1 I1KT b .
• 6: end for
• 7: Output: T ∗ ← diag(b)Kdiag(a).

and learning the matrix directly; ii) further parameterizing it by a neural network (e.g., a parametric model like an MLP) and learning the neural network instead.

The optimal solution of the EOT problem, denoted as T ∗ is a doubly-stochastic matrix, i.e., T ∗ ∈ Π( 1 I2 1I2 , 1 I1 1I1 ) = {T ∈ RI2×I1 + |T1I1 = 1 I2 1I2 , T T 1I2 = 1 I1 1I1 }. Therefore, Pγ = I2T ∗ is a transition matrix, which provides a probabilistic approximation of the alignment matrix P. In particular, the element of Pγ, denoted as p(v|v′ ; γ), represents the conditional probability of v ∈ V2 given v′ ∈ V1. Note that the proposed coupled node embedding layer can be easily extended to multi-network scenarios - when new networks come, we merely need to add more Sinkhorn matching modules to derive their node embeddings.

4 Learning Algorithm

We learn the CPP model via a regularized maximum likelihood framework. In this framework, the likelihood of the event sequences is maximized, and the alignment matrix is regularized by an intensity-based priori matrix in an inverse optimal transport (IOT) format.

4.1 Intensity-Based Prior of Alignment Matrix

As aforementioned, the event sequences generated by the networks often contain useful information for network alignment. Given the event sequences, the significance of a node can be measured by the average intensity of its events, i.e.,

The average intensity records the density of observed events in the time window [0, T], which reflects the activity of the node v. We assume that the nodes with similar average intensity should be aligned with a higher probability. Based on this assumption, we can construct an intensity-based prior

Algorithm 2 Learning the proposed CPP model

• 1: Input: Event sequences {Sk}2k=1 .
• 2: Hyperparameters: The number of iterations M, the weight of the IOT regularizer τ.
• 3: Compute the average intensity for each node in V1 ∪ V2 and construct C.
• 4: Compute the priori alignment matrix P0 via Algorithm 1 and fix it as a constant.
• 5: for m= 1, ...,M do
• 6: Compute the loss function in (10) and udpate the parameters by Adam [Kingma and Ba, 2014].
• 7: end for
• 8: Output: Learned alignment matrix Pγ ∗ .

for the alignment matrix. In particular, we first calculate the average intensity for each node and construct a cost matrix C = [cvv′ ] ∈ RI2×I1 , where cvv′ = |¯λv(T) - ¯λv′(T)| for v ∈ V2 and v′ ∈ V1. Then, we reuse the Sinkhorn matching module in Algorithm 1, computing a priori alignment matrix, denoted as P0 = I2Sinkhorn(C, ϵ).

It should be noted that the assumption behind the prior is reasonable, which matches the principle of network alignment. In practice, given two networks, we often first align the key nodes that have high degrees and then deal with other nodes [Xu et al., 2019; Malod-Dognin and Prˇzulj, 2015] because these key nodes have sufficient and distinguishable topological information. In our privacy-preserving scenario, although the network topology is unavailable, we can still detect the key nodes based on the average intensity in (9) - the key nodes, e.g., the leaders in a network, often have active behaviors (i.e., high average intensity) and thus have significant impacts on other nodes. Moreover, the average intensity is an unbiased estimation of E[λ(T)], i.e., ¯λv(T) → E[λ(T)] with the increase of time and event number. In other words, the average intensity of the key nodes is more reliable than that of other nodes because of the sufficiency of events. Accordingly, the priori alignment matrix may provide useful evidence for the alignment of the key nodes.

4.2 RegularizedMaximumLikelihood Estimation

Given the event sequences of two networks and the priori alignment matrix, we learn our CPP model via solving the following optimization problem:

where S1 ∪ S2 is the collection of the event sequences of the two networks. They are modeled jointly by our CPP model, and L is the negative log-likelihood defined in (5). KL(Pγ∥P0) penalizes the KL-divergence between the approximated alignment matrix and its prior. From the viewpoint of optimal transport, 1 I2 Pγ is a transport matrix derived based on a learnable cost matrix Cγ, while 1 I2 P0 is a known transport matrix. Accordingly, the KL-divergence leads to the inverse optimal transport problem [Li et al., 2019], i.e., optimizing the cost matrix given a predefined transport matrix.

We solve (10) by stochastic gradient descent (SGD), as shown in Algorithm 2. Note that, when implementing our CPP via neural point processes, the integral in the negative log-likelihood is approximated by the Monte Carlo integration, as the work in [Mei and Eisner, 2017; Zhang et al., 2020a; Zuo et al., 2020] did.

5 Experiments

5.1 Experimental Setup

To demonstrate the feasibility and usefulness of our CPP model in privacy-preserving network alignment tasks, we conduct experiments on both synthetic and real-world datasets. The pairwise networks we considered include:

SynData contains three synthetic network pairs. In each pair, the source network G1 is an Erd¨os-R´enyi graph [Gilbert, 1959] with self-loops, and the target network G2 is an isomorphism of G1. Accordingly, the ground truth alignment matrix P corresponds to a permutation matrix. For the networks, we set the number of nodes I ∈ {10, 50, 100}.

Arenas is a network recording email communications among 1,133 users [Leskovec and Sosiˇc, 2016]. Taking this network as G1, we follow the network alignment literature [Koutra et al., 2013; Zhang and Tong, 2016; Heimann et al., 2018] and construct G2 by removing the edges of G1 with probability 0.05 (and without disconnecting any nodes).

Cora records a citation network among 2,708 publications [Yang et al., 2016]. Given the network, we i) insert 10% additional edges randomly to get G1, and ii) remove 15% of its original edges to get G2.

Phone-Email contains two communication networks corresponding to phone calls and emails, respectively [Zhang et al., 2020b]. G1 contains 41,191 phone calls (i.e., edges) among 1,000 users (i.e., nodes), and similarly, G2 contains 4,627 email communications among 1,003 users. There are 1,000 users appearing in both networks, and the ground-truth alignment matrix is provided.

It is easy to find that these datasets have different noise levels. The networks in the synthetic data are isomorphic and thus do not have any noise. The Arenas is a little noisy, in which G1 and G2 may have about 5% inconsistent edges. The Cora has medium noise, and the percentage of inconsistent edges increases to about 25%. The Phone-Email dataset is the most challenging one - the edges of the two networks are significantly unbalanced.

We generate a few event sequences for each dataset for the source G1 and target network G2, respectively, and infer the alignment matrix based on the event sequences. In particular, given a network G(V,A), we assume that its event sequences are generated by a Hawkes process [Zhou et al., 2013] driven by the adjacency matrix A, i.e., HP(µ,Φ), where µ := 1 ∥A1∥∞ A1 and Φ := 0.8 ∥A∥2 Aexp(t). Given the Hawkes process model, we simulate each event sequence independently in the time window [0, 50] by Ogata's thinning algorithm [Ogata, 1981]. Table 1 shows the basic statistics of the datasets and the number of event sequences per network.

In our experiments, we compare our CPP-based alignment method with the following three competitors:

GWL [Xu et al., 2019] and REGAL [Heimann et al., 2018] are two state-of-the-art network alignment methods. GWL achieves an optimal transport-based graph matching algorithm that aligns networks and learns node embeddings jointly. REGAL learns the structure similarity between the networks by cross-network matrix factorization.

FGWA [Luo et al., 2019] is a sequence-driven network alignment method. It jointly learns two Hawkes processes in a regularized maximum likelihood estimation framework. By penalizing the GW-based alignment loss [Titouan et al., 2019] between the model parameters of the two Hawkes processes, this method learns an optimal transport matrix to infer the correspondence between the two networks.

Remark. On the one hand, GWL and REGAL work as "oracles" because of using topological information directly. On the other hand, FGWA applies the na¨ıve strategy in (4) by setting the regularizer as the GW-based alignment loss, which works as the baseline of our method. We hope our CPP-based method can outperform the baseline and approach the oracles' performance. We evaluate the performance of the methods by the commonly-used top-K node correctness (denoted as NC@K) [Heimann et al., 2018; Luo et al., 2019; Xu et al., 2019], which records the percentage of the nodes in G2 whose correspondence nodes in G1 are in the top-K lists inferred by an alignment method. In each experiment, we run all the methods in five trials, with different random seeds, and record the mean and standard deviation of NC@K.

We implement the methods in PyTorch and conduct experiments on NVIDIA GeForce RTX 3090. When implementing our method, we use SAHP [Zhang et al., 2020a] and THP [Zuo et al., 2020] as the backbone of our CPP model, respectively. Each backbone has four 4-head attention layers. The dimension of node embedding is 64, and the hidden dimension of the position-wise feed-forward network is 128. The coupled node embedding layer applies a parametric cost matrix by default. The weight of the IOT regularizer is set to be 100. For different datasets, we adjust the learning rate from 10-5 to 10-3 and the ϵ in the Sinkhorn matching module from 10-4 to 10-1 . For fairness, the hyperparameters of GWL, REGAL, and FGWA are optimized by grid search.

5.2 Comparison Experiments

We first demonstrate the feasibility of our method on synthetic data. The alignment results of different methods on the synthetic data are shown in Table 2. Both REGAL and GWL outperform all the sequence-based alignment methods (including FGWA and ours). The gap is caused by i) the randomness introduced by stochastic event sequences; ii) the misspecification caused by the model assumption. However, as representative traditional alignment methods, REGAL and GWL are based on the network topology and thus cannot achieve privacy preservation. On the contrary, FGWA does not require the network topology directly, but it is only applicable for the Hawkes processes defined on networks and suffers from a high risk of model misspecification. As a result, the performance of FGWA is unsatisfactory compared to the oracles. Our CPP-based method outperforms FGWA consistently because the CPP model is more flexible and has better capacity. Additionally, our method is robust to the selection of backbone model - both CPP-SAHP and CPP-THP achieve encouraging alignment results. Besides the numerical results in Table 2, we further compare our approximated alignment matrices with the ground truth in Figure 3. In summary, our CPP-based method works better than FGWA, reducing the gap to the oracles significantly. These results mean that in the privacy-preserving network alignment problem, our method achieves a trade-off between alignment accuracy and privacy preservation.

We further verify our above claim in real-world experiments. Table 3 records the alignment results of various methods on real-world datasets. In these experiments, all the methods suffer from performance degradation because the real-world networks are not isomorphic and often have noise, which makes the alignment tasks challenging. In the cases with light or medium noise (e.g., Arenas and Cora), the oracles still outperform the sequence-based alignment methods. However, in the case of heavy noise (e.g., Phone-Email), our CPP methods achieve the best performance. A potential reason for this interesting phenomenon is that the network topology becomes unreliable in highly noisy cases. Accordingly, the uncertainty caused by the event sequences is not dominant, which does not influence the results much.

5.3 Analytic Experiments

Take our CPP-THP as an example, we further analyze the rationality of our alignment method in the following analytic experiments. In Table 4, we show the alignment results of our CPP-THP method achieved under different settings, including the modeling strategy of the cost matrix and the utilization of the IOT regularizer. We can find that our method achieves comparable alignment results under different cost models, which further verifies its robustness to modeling strategy. On the contrary, the IOT regularizer impacts our method a lot. Table 4 shows that applying the IOT regularizer (i.e., τ ̸= 0) leads to significant improvements in the alignment results, which demonstrates the necessity of the regularizer and according to the rationality of our learning algorithm. Additionally, our method is robust to the weight of the IOT regularizer. As shown in Table 4, our alignment results are stable when τ changes in a wide range. In Table 5, we show the impacts of the number of sequences on our alignment results of SynData (I = 100) and Arenas, respectively. Increasing the number of training sequences helps to improve the alignment results consistently. The more data we have, the better alignment results we can obtain.

6 Conclusion and FutureWork

We have proposed a CPP model and its learning algorithm, which aligns networks based on their event sequences rather than their topologies. The proposed method shows the feasibility of privacy-preserving network alignment, which achieves a trade-off between alignment accuracy and privacy preservation. In the future, we plan to further improve the scalability of the proposed method for large-scale applications. Additionally, we would like to make collaborations with network service providers and financial institutes and test our method in real-world scenarios.

Acknowledgments

Dr. Dixin Luo was supported by the National Natural Science Foundation of China (62102031) and the Young Scholar Program (XSQD-202107001) from Beijing Institute of Technology. Dr. Hongteng Xu was supported by the National Natural Science Foundation of China (62106271, 92270110), CAAIHuawei MindSpore Open Fund, the Fundamental Research Funds for the Central Universities, and the Research Funds of Renmin University of China. He thanks the support from the Beijing Key Laboratory of Big Data Management and Analysis Methods, the Intelligent Social Governance Platform, Major Innovation & Planning Interdisciplinary Platform for the "Double-First Class" Initiative.

Contribution Statement

The first two authors of this work have equal contributions. Hongteng Xu is the correspondence author.