Block modelling in dynamic networks with non-homogeneous Poisson processes and exact ICL

Abstract

We develop a model in which interactions between nodes of a dynamic network are counted by non-homogeneous Poisson processes. In a block modelling perspective, nodes belong to hidden clusters (whose number is unknown) and the intensity functions of the counting processes only depend on the clusters of nodes. In order to make inference tractable, we move to discrete time by partitioning the entire time horizon in which interactions are observed in fixed-length time sub-intervals. First, we derive an exact integrated classification likelihood criterion and maximize it relying on a greedy search approach. This allows to estimate the memberships to clusters and the number of clusters simultaneously. Then, a maximum likelihood estimator is developed to estimate nonparametrically the integrated intensities. We discuss the over-fitting problems of the model and propose a regularized version solving these issues. Experiments on real and simulated data are carried out in order to assess the proposed methodology.

Appendix: Computational complexity

In this section, we provide details about the computational complexity of the main model presented in this paper, namely the model A. Assuming that the gamma function can be computed in constant time (see Press et al. 2007), we focus on the three statistics appearing in Eq. (9), namely

• 1. $S_{kgu}:=\sum _{z_i=k} \sum _{z_j=g}Y_{ij}^{I_u}$,

• 2. $P_{kgu}:=\prod _{z_i=k} \prod _{z_j=g}Y_{ij}^{I_u}!$,

• 3. $R_{kg}:=|{\mathcal {A}}_k||{\mathcal {A}}_g|$.

The whole computation task consists in evaluating the increase in ICL induced by nodes exchanges and merges. Those computations involves the three quantities listed above. The tensor $\{S_{kgu}\}_{k,g \le K, u\le U}$ is stored in a three-dimensional array, never resized, occupying a $O(K_{\max }^2U)$ memory space. Hence, at any time during the algorithm its elements can be accessed and modified in constant time. The tensor $\{P_{kgu}\}_{k,g \le K, u\le U}$ is handled similarly and clusters sizes (we recall that $|{\mathcal {A}}_k|$ corresponds to the size of cluster ${\mathcal {A}}_k$) are also stored in arrays. In order to evaluate the ICL changes, induced by an operation, we need to maintain aggregated interaction counts for each node: for a node i we have, e.g.

$$\begin{aligned} S_{igu}:=\sum _{z_j=g}Y_{ij}^{I_u}, \end{aligned}$$

the number of interactions from node i to cluster ${\mathcal {A}}_g$ inside the time interval $I_u$. Similarly

$$\begin{aligned} S_{igu}':=\sum _{z_j=g}Y_{ji}^{I_u} \end{aligned}$$

denotes the number of interactions from cluster ${\mathcal {A}}_g$ to node i inside the time interval $I_u$. Other related quantities are considered. These structures occupy a memory space of $O(N^2 U)$.

1.1 Exchanges

In order to evaluate the ICL increase induced by the switch of a node (say i) from cluster ${\mathcal {A}}_{k'}$ to cluster ${\mathcal {A}}_{l}$, we perform the following operations:

• $S_{k'gu}$ (respectively, $S_{gk'u}$) is reduced by $S_{igu}$ ($S_{igu}'$) and $S_{lgu}$ ($S_{glu}$) is increased by the same amount;

• $P_{k'gu}$ (respectively, $P_{g'ku}$) is reduced by $P_{igu}$ ($P_{igu}'$) and $P_{lgu}$ ($P_{glu}$) is increased by the same amount;

• ${\mathcal {A}}_{k'}$ (${\mathcal {A}}_l$) is reduced (increased) by one.

Although these operations are in constant time, they are involved in a sum with (KU) elements (this can be seen in Eq. (22)), so that the total cost of the test is O(KU). Since node i can be switched to $K-1$ remaining clusters and the graph has N nodes, the cost of a full exchange routine is $O(NK^2U)$.

Remark 6

When a node is actually switched from its cluster to another one, all data structures are updated, but the update cost is dominated by the cost of the testing phase described above.

Notice that we have evaluated the total cost of one full exchange routine, i.e. in the case where all nodes are considered once. Reductions in the number of clusters (very likely to be induced by exchanges in case $K_{\max }$ is high) are not taken into account.

1.2 Merges

The entire merge routine, consisting in a test phase and an actual merge, has a computational cost that is dominated by the cost of exchanges. Consider a cluster ${\mathcal {A}}_{k'}$. We first look for the cluster (say ${\mathcal {A}}_l$), leading to the best merge (highest increase in the ICL) with ${\mathcal {A}}_{k'}$. This operation has a cost of $O(K^2U)$: for each ${\mathcal {A}}_l$ the evaluation of the increase in ICL has a cost of O(KU) (see Eq. (23)) and l can take $K-1$ possible values. Since we look for the best merge for all $k' \in \{1,\ldots , K \}$, the computational cost for a merge of two nodes clusters is $O(K^3U)$, where we recall that $D\le N$.

1.3 Total cost

The worst case complexity for one iteration of the algorithm, with each node considered once, is $O(NK^2U)$. However, it is difficult to evaluate the actual complexity of the whole algorithm for two reasons. Firstly, we have no way to estimate the number of exchanges needed in the exchange phase. Secondly, nodes exchanges are very likely to reduce the number of clusters, especially at the beginning of the algorithm, when $K_{\max }$ is relatively high. Thus, the individual cost of an exchange reduces very quickly, leading to a vast overestimation of its cost using the proposed bounds. A detailed evaluation of the behaviour of the proposed algorithm, although outside the scope of the this paper, would be necessary to assess its use on large data sets.