Real-Time Influence Maximization on Dynamic Social Streams

TL;DR

This paper introduces a real-time influence maximization method for dynamic social streams, using a novel checkpoint framework to efficiently identify influential users in evolving social networks.

Contribution

It proposes the SIM query model and the IC/SIC frameworks, enabling efficient, approximate influence maximization on social streams with dynamic network updates.

Findings

The SIC framework reduces checkpoint storage to O(log N/β).

Experimental results show improved efficiency over existing methods.

The approach maintains high influence spread accuracy in dynamic settings.

Abstract

Influence maximization (IM), which selects a set of $k$ users (called seeds) to maximize the influence spread over a social network, is a fundamental problem in a wide range of applications such as viral marketing and network monitoring. Existing IM solutions fail to consider the highly dynamic nature of social influence, which results in either poor seed qualities or long processing time when the network evolves. To address this problem, we define a novel IM query named Stream Influence Maximization (SIM) on social streams. Technically, SIM adopts the sliding window model and maintains a set of $k$ seeds with the largest influence value over the most recent social actions. Next, we propose the Influential Checkpoints (IC) framework to facilitate continuous SIM query processing. The IC framework creates a checkpoint for each window slide and ensures an $\varepsilon$-approximate solution. To improve its efficiency, we further devise a Sparse Influential Checkpoints (SIC) framework which selectively keeps $O(\frac{\log{N}}{\beta})$ checkpoints for a sliding window of size $N$ and maintains an $\frac{\varepsilon(1-\beta)}{2}$-approximate solution. Experimental results on both real-world and synthetic datasets confirm the effectiveness and efficiency of our proposed frameworks against the state-of-the-art IM approaches.

Tables

Table 1. Table 1: Frequently used notations

Symbol	Definition and Description
$U$	the set of all users in a social network
$a_t={⟨u,a_{t^{\prime }}⟩}_t$	a user $u$ performs an action at time $t$ triggered by an action $a_{t^{\prime }}$()
$N$	the size of the sliding window
$L$	the number of actions for each window slide, $L=1$ by default
$W_t,W_t\left[i\right]$	the sliding window at time $t$, and the $i$-th action in the window
$I_t\left(u\right),I_t\left(S\right)$	the influence set of a user $u$ or a set of users $S$ wrt. $W_t$
$I_t\left[i\right]\left(u\right),I_t\left[i\right]\left(S\right)$	the influence set of $u$ or $S$ for contiguous actions $\{W_t\left[i\right],\dots ,W_t\left[N\right]\}$
$f$	a monotone submodular influence function
$k$	the cardinality constraint of SIM
${\Lambda }_t\left[i\right]$	an influential checkpoint maintaining an $\epsilon$-approximate solution of SIM for $\{W_t\left[i\right],\dots ,W_t\left[N\right]\}$
$S_t^{opt},{\mathrm{𝖮𝖯𝖳}}_t$	the optimal seed set of SIM wrt. $W_t$, and its influence value ${\mathrm{𝖮𝖯𝖳}}_t=f\left(I_t\left(S_t^{opt}\right)\right)$
$S_t^{opt}\left[i\right],{\mathrm{𝖮𝖯𝖳}}_t\left[i\right]$	the optimal seed set of SIM for $\{W_t\left[i\right],$ $\dots ,$ $W_t\left[N\right]\}$, and its influence value

Table 2. Table 2: Candidate checkpoint oracles

Oracle	Quality	Update	Function
SieveStreaming [3]	$1/2-\beta$	$O\left(\frac{\log k}{\beta }\right)$	General
ThresholdStream [18]	$1/2-\beta$	$O\left(\frac{\log k}{\beta }\right)$	General
Blog Watch [30]	$1/4$	$O\left(k\right)$	Cardinality
M$k$C [2]	$1/4$	$O\left(k\log k\right)$	Cardinality

Table 3. Table 3: Statistics on datasets

Dataset	Users	Actions	Resp. dist.	Avg. depth
Reddit	2,628,904	48,104,875	404714.9	4.58
Twitter	2,881,154	9,724,908	294609.4	1.87
SYN-O	1M–5M	10,000,000	500,000	2.5
SYN-N	1M–5M	10,000,000	5,000	2.59

Table 4. Table 4: Parameters in experiments

Parameter	Values
$k$	5, 25, 50, 75, 100
$\beta$	0.1, 0.2, 0.3, 0.4, 0.5
$N$	100K, 250K, 500K, 750K, 1,000K
$L$	1K, 2.5K, 5K, 7.5K, 10K
$\left|U\right|$	1M, 2M, 3M, 4M, 5M

Equations

$$S_t^{opt}={\mathrm{argmax}}_{S\in U\wedge |S|\le k}f(I_t(S))$$

$$f^{\prime }(CX\cup \{X_t\})-f^{\prime }(CX)\ge \frac{\mathsf{OP}{\mathsf{T}}^{\prime }/2-f^{\prime }(CX)}{k-|CX|}$$

$$f(I_t[i](C{X}_i\cup \{u\}))-f(I_t[i](C{X}_i))\ge \frac{{\mathsf{OPT}}_t[i]/2-f(I_t[i](C{X}_i))}{k-|C{X}_i|}$$

$${\mathsf{OPT}}_{t_3}^{t_1}=f(S_{t_1,t_3}^{opt})$$

$$\le {\mathsf{OPT}}_{t_2}^{t_1}+{\mathsf{OPT}}_{t_3}^{t_2}$$

$${\Lambda }_{t_4}^{t_2}$$

$$\ge \frac{1-\beta }{2}({\Lambda }_{t_3}^{t_1}+{\Lambda }_{t_4}^{t_2})\ge \frac{\epsilon (1-\beta )}{2}({\mathsf{OPT}}_{t_3}^{t_1}+{\mathsf{OPT}}_{t_4}^{t_2})$$

$$\ge \frac{\epsilon (1-\beta )}{2}{\mathsf{OPT}}_{t_4}^{t_1}$$

Full text

1 Introduction

Social media advertising has become an indispensable tool for many companies to promote their business online. Such trends have generated over 17 billion dollars advertising revenue for Facebook in 2015 alone111https://www.bamsec.com/companies/1326801/facebook-inc. Influence Maximization (IM) is a key algorithmic problem behind social media viral marketing [12, 17]. Through the word-of-mouth propagation among friends, IM aims to select a set of $k$ users such that the source information (e.g., advertisement) is maximally spread in the network, and it has been extensively researched [1, 6, 9, 10, 15, 16, 23, 21, 25, 24, 17, 28, 29, 36, 35, 37, 39] in the last decade. Besides viral marketing, IM is also the cornerstone in many other important applications such as network monitoring [20] and recommendation [33].

Most existing IM solutions rely on influence probabilities between users to acquire the seeds. The influence probabilities are usually derived from social actions in online social networks [14, 19, 31], e.g., “retweets” on Twitter. In reality, social influences are highly dynamic and the propagation tendencies between users can be altered drastically by breaking news and trending topics. Consequently, the seeds selected by IM methods [6, 17, 28, 36, 35] that assume static social influences can quickly become outdated. Recently, there are some research efforts on IM under dynamic social influences. However, existing solutions for dynamic IM either do not offer theoretical guarantees for the qualities of the seeds selected (e.g., [1, 39]) or provide guarantees at the expense of high processing overhead for updates (e.g., [10, 29]). In fact, the state-of-the-art dynamic IM solution [29] is only able to process several hundred updates per second, which is far lower than the update rates of real-world social networks. For example, over 7.4K tweets are generated on Twitter in one second222http://www.internetlivestats.com/one-second/.

To resolve the aforementioned drawbacks and make dynamic IM both effective and efficient, we propose a novel Stream Influence Maximization (SIM) query to support real-time influential users tracking. SIM utilizes the widely available social actions (e.g., “retweets” on Twitter, “replies” on Reddit and “comments” on Facebook) to estimate the social influence and maintain the seed set continuously. To capture the short-term memory effect of social influences [32], where past influences quickly fade as new influences emerge, SIM adopts the sliding window model [11] which always considers the most recent $N$ actions and strives to find $k$ users who collectively have the largest influence value in the current window. In addition, SIM supports general monotone submodular functions to compute the influence values as such functions are often used to represent the “diminishing returns” property of social influences in different types of IM problems [4, 9, 15, 17, 23, 21, 37].

Due to the NP-hardness of SIM, we focus on processing it approximately with theoretical bounds. Leveraging the monotonicity and submodularity of influence functions, a naïve greedy algorithm [27] can provide a $(1-1/e)$ approximate solution for SIM. However, the greedy algorithm requires $O(k\cdot|U|)$ ($|U|$ is the number of users in the network) influence function evaluations for each update. Empirically, it takes around 10 seconds to select $100$ seeds from a network with $500,000$ users, which hardly matches the rates of real-world social streams. Another closely related technique to SIM is Streaming Submodular Optimization (SSO) [3, 18]. Existing SSO approaches [3, 18] can provide solutions with theoretical guarantees for maximizing submodular functions with cardinality constraints over append-only streams. However, to the best of our knowledge, none of the proposed SSO algorithms can support the sliding window model.

In this paper, we propose a novel Influential Checkpoints (IC) framework to support efficient continuous SIM processing with theoretical guarantees. IC not only tracks the solution for the current window but also maintains partial solutions called Checkpoints for future windows that overlap with the current window. Therefore, for every subsequent window shift, the up-to-date solution can be retrieved efficiently. We further design a generic Set-Stream Mapping (SSM) interface which can adapt a wide range of existing SSO algorithms to SIM so that the solution retrieved for each sliding window has at least the same approximation ratio as those algorithms. However, maintaining all $O(N)$ checkpoints incurs significant update overhead ($N$ is the number of actions in a window). To support efficient IC maintenance, we propose a Sparse Influential Checkpoints (SIC) framework to selectively maintain a subset of checkpoints by leveraging the monotonicity and subadditivity of the influence values returned by different checkpoints. Consequently, SIC only keeps $O(\frac{\log N}{\beta})$ checkpoints and maintains an $\frac{\varepsilon(1-\beta)}{2}$-approximate solution.

We hereby summarize our contributions as follows.

• •

We address the limitations of existing IM solutions in supporting fast evolving social networks and propose a novel SIM query over sliding windows. (Section 3)

• •

We develop a novel Influential Checkpoints (IC) framework for SIM query processing. It is integrated with a generic Set-Stream Mapping (SSM) interface to incorporate existing $\varepsilon$-approximate SSO algorithms while retaining their approximation ratios. (Section 4)

• •

We further propose the SIC framework to selectively maintain $O(\frac{\log{N}}{\beta})$ checkpoints for a sliding window of size $N$. Leveraging the subadditivity and submodularity of the influence values returned by different checkpoints, an $\frac{\varepsilon(1-\beta)}{2}$-approximation ratio is always guaranteed. (Section 5)

• •

We experimentally evaluate the effectiveness and efficiency of our proposed frameworks. First, the qualities of the seeds selected by IC and SIC are competitive with the state-of-the-art IM algorithms on both static and dynamic graphs. Second, SIC achieves speedups of up to 2 orders of magnitude over the static approaches. Third, SIC achieves up to 8 times speedups over IC with less than $5\%$ quality losses. (Section 6)

2 Related work

We summarize the most relevant literature from three areas: influence maximization, streaming submodular optimization and function estimation on sliding windows.

2.1 Influence Maximization (IM)

IM aims to extract a given number of users that maximize the influence spread over a network. Previous efforts on IM can be generally categorized into static methods and dynamic methods based on their abilities to handle changes in social influences. Here, we summarize them separately.

IM in Static Networks: There has been a vast amount of literature on influence maximization (IM) in static networks over the last decade (see [6, 9, 23, 21, 25, 17, 28, 36, 35, 37]). The state-of-the-art static IM method on the classic influence models (i.e., independent cascade (IC) and linear threshold (LT)) is IMM [35]. It runs in nearly linear time wrt. the graph size with a $(1-1/e-\varepsilon)$ approximation guarantee. Nevertheless, these static IM methods including IMM cannot efficiently support highly evolving networks since a complete rerun is required for every update on influence graphs.

There are also many static methods considering different types of IM problems by extending classic influence models. For example, topic-aware IM [4, 9] considers the influence diffusion under topic models; location-aware IM [21, 37] focuses on maximizing the influence spread in certain spatial areas; and conformity-aware IM [23] considers users’ conformity tendencies in the influence estimation.

IM in Dynamic Networks: Recently, there are emerging studies about IM in dynamic networks. However, most of these methods cannot provide a theoretical guarantee of their seed quality and may return arbitrarily bad solutions [1, 39]. Chen et al. [10] proposed an Upper Bound Interchange (UBI) method with a $1/2$-approximation ratio. Nevertheless, UBI is sensitive to the number of users selected. When the size of the seed set increases, both its performance and solution quality degrade dramatically. This prevents UBI from being practically useful. Very recently, a new dynamic IM method with a theoretical bound is presented in [29]. It dynamically maintains a RIS-based [6] index against changes on graphs and achieves a $(1-1/e-\varepsilon)$ approximation guarantee. However, due to the high maintenance cost, it can only process several hundred of influence graph updates per second. This is far from the requirement of real-world social streams. Therefore, existing dynamic IM methods cannot provide high-quality solutions efficiently.

2.2 Streaming Submodular Optimization

Another closely related field to SIM is the Streaming Submodular Optimization (SSO) [30, 2, 3, 18, 38]. SSO adopts the append-only streaming model where elements arrive one by one and the objective is to dynamically maintain a set of at most $k$ elements to maximize a submodular function wrt. all the observed elements at any time. Saha et al. [30] and Ausiello et al. [2] developed two swapping-based approaches for a special case of SSO (i.e., the online Maximum $k$-Coverage problem) with the same $1/4$ approximation ratio. Then, Yu and Yuan [38] proposed a greedy-based algorithm for the online Maximum $k$-Coverage problem with an approximation ratio around 0.3 based on computer-aided simulation. The state-of-the-art SSO solutions are SieveStreaming [3] and ThresholdStream [18]. They maintain a sequence of candidate solutions by estimating the optimal value and each solution uses its own threshold to decide whether a new element is included. At any time, the candidate solution with the largest function among all maintained solutions is returned as the result. Both of them can achieve a $(1/2-\beta)$ approximation ratio for any $\beta>0$.

Unfortunately, SSO algorithms cannot be directly applied to the sliding window model because they do not handle the continuous expiry of elements. Nevertheless, we will show in Section 4.2 that existing SSO algorithms can serve as checkpoint oracles in the IC and SIC frameworks.

2.3 Function Estimation on Sliding Windows

Several works [11, 7] studied how to continuously estimate a function in the sliding window model. They leverage special properties of target functions to achieve sublinear performance and reasonable quality. Let $g$ be the target function, and $A$,$B$,$C$ be three sequences on streams such that $B$ is a tail subsequence of $A$ and $C$ is contiguous to $B$. The exponential histogram [11] is proposed to approximate weakly additive functions, i.e., $g(A)+g(C)\leq g(A\cup C)\leq c(g(A)+g(C))$ for some small constant $c$. The smooth histogram [7] requires that the target functions are $(\alpha,\beta)$-smooth. Specifically, we say $g$ is $(\alpha,\beta)$-smooth if $\frac{g(B)}{g(A)}\geq 1-\beta$, then $\frac{g(B\cup C)}{g(A\cup C)}\geq 1-\alpha$ for some $0<\beta\leq\alpha<1$. Following the analysis in [7], smooth histograms are applicable only when $g$ can be computed with an approximation ratio of at least $0.8$ in the append-only streaming setting. In this paper, we use monotone submodular influence functions [17] widely adopted in the social influence analysis. However, monotone submodular functions are not weakly additive and existing SSO algorithms [3, 18] can only achieves an approximation of at most $1/2$. This imply that these techniques cannot be directly applied to our scenario.

3 Problem Statement

We consider a social stream over a social network with a user set $U$. The social stream comprises unbounded time-sequenced social actions which are generated by user activities in the social network. Let $a_{t}=\langle u,a_{t^{\prime}}\rangle_{t}$ $(t^{\prime}<t)$ be an action at time $t$ representing the following social activity: user $u$ performs $a_{t}$ at time $t$ responding to an earlier action $a_{t^{\prime}}$. Typical actions include “retweet” on Twitter, “reply” on Reddit, “comment” on Facebook, to name just a few. If an action $a_{t}$ does not respond to any previous action, e.g., a user $u$ posted an original tweet, we call it a root action and denote it by $a_{t}=\langle u,nil\rangle_{t}$.

Like many data streams, social streams are time-sensitive: recent actions are more valuable than those in the past. We adopt the well-recognized sequence-based sliding window [11] model to capture such essence. Let $N$ be the window size, a sequence-based sliding window $W_{t}$ maintains the latest $N$ actions till $a_{t}$ in the stream, i.e., $W_{t}=\{a_{t-N+1},\ldots,a_{t}\}$. For simplicity, we use $W_{t}[i]$ to represent the $i$-th ($i\geq 1$) action within $W_{t}$. Then, we use $A_{t}\subseteq U$ to denote the set of active users who perform at least one action in $W_{t}$, i.e., $A_{t}=\{W_{t}[i].u|i=1,\ldots,N\}$.

Since social actions directly reflect the information diffusion in the social network [14, 15, 34, 19], we define the influence between users according to their performed actions. We say user $u$ influences user $v$ in $W_{t}$, denoted by $(u\leadsto v)_{t}$, if there exists an action $a$ performed by user $v$ s.t. $a\in W_{t}$ and $a$ is directly or indirectly triggered by an action $a^{\prime}$ of $u$. It is notable that such an $a^{\prime}$ is not necessarily in $W_{t}$.

We formally define the influence set of a user as follows:

Definition 1**.**

The influence set of a user $u\in U$ at time $t$, denoted as $I_{t}(u)\subseteq A_{t}$, is the set of users who are influenced by $u$ wrt. the sliding window at time $t$ (i.e., $W_{t}$). Equivalently, $I_{t}(u)=\{v|(u\leadsto v)_{t}\}$.

Intuitively, the influence set of $u$ denotes the set of users who recently performed actions under the impact of $u$. The concept of the influence set can be naturally extended to a set of users. In particular, let $S=\{u_{1},\ldots,u_{k}\}$ be a set of $k$ users, the influence set of $S$ wrt. $W_{t}$ is a union of the influence sets of all its members, i.e., $I_{t}(S)=\cup_{u\in S}I_{t}(u)$. Then the influence value of $S$ is measured by $f(I_{t}(S)):2^{|U|}\rightarrow\mathbb{R}_{\geq 0}$. We consider $f(I_{t}(\cdot))$ as a nonnegative monotone333A set function $g$ is monotone if for all $A\subseteq B$, $g(A)\leq g(B)$. submodular444A set function $g$ is submodular if for all $A\subseteq B$, and any element $x\not\in B$, $g(A\cup\{x\})-g(A)\geq g(B\cup\{x\})-g(B)$. function [27] which is widely adopted by many IM problems for its natural representation of the “diminishing returns” property on the social influence [17].

For ease of presentation, we only consider the cardinality function, i.e., $f(I_{t}(\cdot))=|I_{t}(\cdot)|$, as the influence function in the main text of this paper. It should be noted that any other monotone submodular influence functions can also be used in our frameworks. In Appendix A, we will discuss how to extend our frameworks to different types of IM problems by filtering the streams or using different influence functions.

Example 1 illustrates our definition of influence over the sliding windows on a social action stream.

Example 1**.**

Figure 1(a) gives an example of a social action stream. Given the window size $N=8$, two windows, $W_{8}$ and $W_{10}$, are highlighted in blue and red boxes respectively. In Figure 1(b), $I_{8}(u_{1})=\{u_{1},u_{2},u_{3}\}$ as $a_{1}$,$a_{6}$ are performed by $u_{1}$ and $a_{2}$,$a_{4}$ performed by $u_{2}$,$u_{3}$ respectively are triggered by $a_{1}$ in $W_{8}$. When the window slides from $W_{8}$ to $W_{10}$, $a_{1}$,$a_{2}$ expire while $a_{9}$,$a_{10}$ arrive. Then, $I_{10}(u_{1})=\{u_{1},u_{3}\}$ as Figure 1(c). Due to the expiry of $a_{2}$, $u_{2}$ is deleted from $I_{10}(u_{1})$. However, since $a_{4}$ has not expired yet, $u_{1}$ still influences $u_{3}$ in $W_{10}$ regardless of the expiry of $a_{1}$.

As new actions arrive at high speed while old ones expire at the same rate, users with the largest influence values keep evolving. To track the influential users over social streams in real-time, we propose a Stream Influence Maximization (SIM) query which is formally defined as follows:

Definition 2**.**

Let $W_{t}$ be the sliding window at time $t$, Stream Influence Maximization (SIM) is a continuous query on a social stream that returns a set of at most $k$ users $S^{opt}_{t}$ who collectively achieve the largest influence value wrt. $W_{t}$:

[TABLE]

We continue with the running example in Figure 1 to show how SIM keeps track of the most influential users over the sliding windows.

Example 2**.**

Given $k=2$, SIM returns $S^{opt}_{8}=\{u_{1},u_{3}\}$ as the most influential users at time $8$ since $I_{8}(S^{opt}_{8})=I_{8}(u_{1})\cup I_{8}(u_{3})$ contains all users in $A_{8}$. We have $f(I_{8}(S^{opt}_{8}))=5$ using the cardinality function. However, as $a_{1}$,$a_{2}$ expire while $a_{9}$,$a_{10}$ arrive at time $10$, $f(I_{10}(S^{opt}_{8}))=4$ as $u_{2}$ is deleted from $I_{10}(S^{opt}_{8})$. Thus, SIM returns $S^{opt}_{10}=\{u_{2},u_{3}\}$ in $W_{10}$ because $I_{10}(S^{opt}_{10})$ contains all users in $A_{10}$. We have $f(I_{10}(S^{opt}_{10}))=6$ accordingly.

Note that the solutions proposed in this paper also support the case where the sliding window shifts for more than one action. For simplicity, we focus on presenting solutions for handling sliding windows with single action shift at a time and leave the discussion on handling multiple action shifts at a time to Section 5.3.

Then, we prove the NP-hardness of SIM by showing that a well-known NP-hard problem, i.e.,the Maximum $k$-Coverage problem [2, 13, 30], is polynomial-time reducible to SIM.

Theorem 1**.**

SIM is NP-hard.

Proof.

We prove the theorem by reducing a well-known NP-hard problem, i.e., Maximum $k$-Coverage [13], to SIM. A Maximum $k$-Coverage instance consists of an integer $k$ and a collection of $m$ non-empty sets $\mathcal{S}=\{s_{1},s_{2},\ldots,s_{m}\}$. It aims to find a subset $\mathcal{S^{\prime}}\subseteq\mathcal{S}$ such that $|\mathcal{S^{\prime}}|\leq k$ and $|\cup_{s_{i}\in\mathcal{S^{\prime}}}s_{i}|$ is maximized. Any Maximum $k$-Coverage instance is reduced to a SIM instance as follows: Let $t$ be the timestamp and $G=\cup_{s_{i}\in\mathcal{S}}s_{i}$ be the ground set. For any set $s_{i}\in\mathcal{S}$, we create an action $a_{t^{\prime}}=\langle u_{i},nil\rangle_{t^{\prime}}$ where $u_{i}\notin G$. For each element $e\in s_{i}$, we create an action $a_{t}=\langle e,a_{t^{\prime}}\rangle_{t}$($t^{\prime}<t$). Next, we stream all actions created to SIM in the ascending order of $t$. Since the total number of actions created is $O(m\cdot|G|)$, the reduction is performed in polynomial time. Let the window size $N$ equal to the total number of actions created. Let $S^{opt}_{N}=\{u_{i},\cdots,u_{j}\}$ be the optimal solution of SIM wrt. $W_{N}$ using the cardinality function. $\{s_{i},\cdots,s_{j}\}$ will be optimal for the corresponding Maximum $k$-Coverage instance as well. Thus, the reduction naturally follows. ∎

Before moving on to the technical parts of this paper, we summarize the frequently used notations in Table 1.

4 Influential Checkpoints

Since SIM is NP-hard, it is infeasible to maintain the optimal seed set for each sliding window in polynomial time. Therefore, our goal is to maintain an approximate solution achieving a bounded ratio to the optimal one efficiently. A naïve scheme is to run the greedy algorithm [27] for each window slide. The greedy algorithm starts with an empty user set $S_{0}=\emptyset$, and at each iteration $i$ ($1\leq i\leq k$), it incrementally adds a user $u$ to the partial user set $S_{i-1}$ maximizing $f(I(S_{i-1}\cup\{u\}))-f(I(S_{i-1}))$ wrt. $W_{t}$. Although the greedy algorithm obtains a $(1-1/e)$-approximation ratio which is the best achievable for submodular maximization with cardinality constraints [27], it takes $O(k\cdot|U|)$ influence function evaluations for each update. Such an inefficient update scheme makes the greedy algorithm unable to handle a large window size with new actions arriving at high speed.

A key challenge for efficiently supporting SIM over sliding windows is to handle the expiry of old actions and the arrival of new actions simultaneously. Such a compound update pattern brings about fluctuations on users’ influence sets which potentially degrade the quality of previously maintained seeds. In the remaining of this section, we present a novel Influential Checkpoints (IC) framework, which consists of a sequence of checkpoint oracles to efficiently handle the expiry and the arrival of actions simultaneously. We first give an overview of the IC framework in Section 4.1. Then, we describe how to construct a checkpoint oracle in Section 4.2. Finally, we take SieveStreaming [3] as an example to illustrate the Set-Stream Mapping interface in Section 4.3.

4.1 The Influential Checkpoints Framework

The high level idea of the IC framework is to avoid handling the expiry of old actions when the window slides. Towards this goal, the framework maintains a partial result (i.e., an influential checkpoint) incrementally for each window slide. When an old action expires, the outdated result is simply deleted. In this way, the sliding window model is transformed to a simpler append-only model for each checkpoint, where many existing approaches [3, 18] can provide theoretically bounded approximate solutions.

Technically, let an influential checkpoint $\Lambda_{t}[i]$ $(1\leq i\leq N)$ denote a checkpoint oracle555 We overload the notation $\Lambda_{t}[i]$ to denote the influence value returned by the oracle when it is clear in the context. which provides an $\varepsilon$-approximate solution for SIM over contiguous actions $\{W_{t}[i],\ldots,W_{t}[N]\}$. By maintaining $N$ checkpoints (i.e., $\Lambda_{t}[1],\ldots,\Lambda_{t}[N]$), a simple procedure to handle a window slide from $W_{t-1}$ to $W_{t}$ is presented in Algorithm 1. Whenever a new action $a_{t}$ arrives, the oldest checkpoint in $W_{t-1}$ (i.e., $\Lambda_{t-1}[1]$) expires and a new checkpoint $\Lambda_{t}[N]$ is added to $W_{t}$ (Line 2). After adding the remaining checkpoints in $W_{t-1}$ to $W_{t}$ (Lines 3-5), each checkpoint in $W_{t}$ processes $a_{t}$ as an appending action to update its partial solution (Lines 6-8). To answer the SIM query for $W_{t}$, we simply return the solution of $\Lambda_{t}[1]$.

Example 3**.**

Figure 2 illustrates the maintenance of checkpoints in the IC framework following Example 1. Let $N=8$ and $k=2$. The number of checkpoints always equals to the window size (i.e., $8$). When action $a_{10}$ arrives, $a_{2}$ will expire. Consequently, the checkpoint $\Lambda_{10}[8]$ is created and $\Lambda_{9}[1]$ is deleted. When the SIM query is issued at time $10$, the result from $\Lambda_{10}[1]$ (i.e.,$\{u_{2},u_{3}\}$) is returned.

It is not hard to see that once each checkpoint oracle maintains an $\varepsilon$-approximate solution for its append-only action stream, IC always returns the solution with the same approximation ratio.

4.2 Checkpoint Oracle

The approximation ratio of IC relies on the checkpoint oracle providing an $\varepsilon$-approximate solution over an append-only action stream. Although submodular maximization in an append-only stream has attracted many research interests [2, 3, 30, 18, 38], they focused on a different set-stream model where elements in the stream are sets instead of actions. In general, an algorithm $\mathcal{A}$ on an append-only set-stream contains two components: $f^{\prime}(\cdot)$ is a monotone submodular objective function and $CX_{t}$ is a candidate solution containing no more than $k$ sets from $t$ observed sets (i.e., $X_{1},\ldots,X_{t}$). Given a stream of sets $\{X_{1},X_{2},\ldots,X_{m}\}$, the objective of $\mathcal{A}$ is to maximize $f^{\prime}(CX_{t})$ at any time $t$ ($1\leq t\leq m$). Although this problem resembles our problem, the set-stream model cannot directly fit in our scenario due to the following mismatch: it strives to keep $k$ sets from a stream of sets but all observed sets are immutable. However, SIM aims to maintain $k$ users from a sequence of actions and each arrival action may induce updates in existing users’ influence sets.

To bridge the gap between the two stream models and leverage existing algorithms based on the set-stream model, we propose a generic Set-Stream Mapping (SSM) interface. The interface makes two adaptations for a set-stream algorithm to serve as the checkpoint oracle. First, the candidate solution $CX$ is adapted to store $k$ users. Second, the objective function $f^{\prime}$ is adapted to the influence function $f(I_{t}[i](\cdot))$, where $I_{t}[i]$ denotes the influence set of user(s) over contiguous actions $\{W_{t}[i],\ldots,W_{t}[N]\}$. Subsequently, SSM maps an action stream to a set-stream and feeds the set-stream to $\Lambda_{t}[i]$. Whenever a new action $a_{t}$ arrives, the following steps are taken for each $\Lambda_{t}[i]$:

(1) Identify users $u_{1},u_{2},\ldots,u_{d}$ whose $I_{t}[i](\cdot)$ is updated.

(2) Feed $\Lambda_{t}[i]$ with a stream $S^{\prime}_{t}=\{I_{t}[i](u_{1}),\ldots,$ $I_{t}[i](u_{d})\}$.

(3) Update the solution of $\Lambda_{t}[i]$ for each $I_{t}[i](u)\in S^{\prime}_{t}$.

There are several choices of oracles that are developed for the set-stream model with differences on the solution quality, update performance, and function generality. Typical oracles are listed in Table 2. An important conclusion is that our SSM procedure does not affect the quality guarantee of the mapped algorithms. Formally:

Theorem 2**.**

Let $\mathcal{A}$ be an $\varepsilon$-approximate SSO algorithm in the set-stream model and $\overline{\mathcal{A}}$ be the mapped algorithm of $\mathcal{A}$ using SSM. Then, $\overline{\mathcal{A}}$ is also $\varepsilon$-approximate for SIM.

Proof.

To show $\overline{\mathcal{A}}$ is also $\varepsilon$-approximate, we consider an append-only set-stream generated by SSM over the action stream. At any time $t$, let $\mathsf{OPT}_{t}$ be the optimal influence value of SIM wrt. $W_{t}$, and $\mathsf{OPT}^{*}_{t}$ be the optimal influence value achieved by any set of at most $k$ sets from the mapped set-stream. We treat all influence sets in the mapped stream as independent sets regardless of whether they belong to the same user. We run $\overline{\mathcal{A}}$ on the mapped set-stream till time $t$ and produce a result with at most $k$ sets: $CX_{t}=\{I_{t_{a}}(u_{t_{a}}),\ldots,I_{t_{b}}(u_{t_{b}})\}$. Note that the influential sets in $CX_{t}$ may be outdated and refer to the same user. Nevertheless, we can still use $CX_{t}$ to approximate $\mathsf{OPT}_{t}$ without affecting the approximation ratio. To obtain the seed set from $CX_{t}$, we select a set of distinct users $U_{t}$ from $CX_{t}$. Since the influence function $f$ is monotone and the up-to-date influence set of any user always grows larger in the append-only stream, we have $f(I_{t}(U_{t}))\geq f(\cup_{X\in CX_{t}}X)$. Moreover, $CX_{t}$ is an $\varepsilon$-approximate solution over the append-only stream, i.e., $f(\cup_{X\in CX_{t}}X)\geq\varepsilon\mathsf{OPT}^{*}_{t}$. As the up-to-date influence sets always appear in the append-only set-stream, we have $\mathsf{OPT}^{*}_{t}\geq\mathsf{OPT}_{t}$, and thus $f(I_{t}(U_{t}))\geq\varepsilon\mathsf{OPT}_{t}$. Therefore, $U_{t}$ is an $\varepsilon$-approximate solution for SIM wrt. $W_{t}$. ∎

According to the SSM steps, an action $a_{t}$ is mapped to at most $d$ influence sets, where $d$ is the number of ancestors of $a_{t}$ in its propagation. In practice, $d$ is usually small, e.g., $d$ is less than $5$ on average as shown in our experiments (see Table 3). Since the number of checkpoints in the IC framework is $N$, the total number of checkpoint evaluations is $O(dN)$. If the update complexity of the checkpoint oracle for each set is $O(g)$, the total time complexity of the IC framework for each action is $O(dgN)$.

In the remaining of this section, we conduct a case study on using SieveStreaming [3] as the checkpoint oracle. The adoption of other oracles can be similarly inferred.

4.3 A Case Study on SieveStreaming

The SieveStreaming Algorithm: SieveStreaming [3] works as follows: Given a monotone submodular function $f^{\prime}$ and the optimal value $\mathsf{OPT^{\prime}}$ of $f^{\prime}$ over the entire stream under a cardinality constraint, SieveStreaming maintains a candidate solution $CX$ that includes an incoming set $X_{t}$ if $CX$ has less than $k$ sets and the following holds:

[TABLE]

However, since $\mathsf{OPT^{\prime}}$ is unknown in advance, SieveStreaming maintains a sequence of possible values for $\mathsf{OPT^{\prime}}$, i.e., $\Omega=\{(1+\beta)^{j}|j\in\mathbb{Z},m\leq(1+\beta)^{j}\leq 2\cdot k\cdot m\}$ where $m=\max_{X}f(\{X\})$ that has been observed. Accordingly, SieveStreaming keeps $|\Omega|=O(\frac{\log{k}}{\beta})$ instances to ensure at least one of them achieves a $(1/2-\beta)$ approximation ratio (see [3] for more details).

Set-Stream Mapping for SieveStreaming: Following SSM, we create $\Lambda_{t}[i]$ as follows: Let $CX_{i}$ be the user set maintained by $\Lambda_{t}[i]$. For each user $u$ with her updated influence set $I_{t}[i](u)$, $\Lambda_{t}[i]$ selects $u$ to $CX_{i}$ if $|CX_{i}|<k$ and:

[TABLE]

where $\mathsf{OPT}_{t}[i]$ is the optimal influence value achievable on all actions from $W_{t}[i]$ to $W_{t}[N]$. Similar to SieveStreaming, each $\Lambda_{t}[i]$ keeps a set of possible values for $\mathsf{OPT}_{t}[i]$, i.e., $\Omega_{t}[i]=\{(1+\beta)^{j}|j\in\mathbb{Z},m\leq(1+\beta)^{j}\leq 2\cdot k\cdot m\}$ where $m$ denotes the maximum influence value of a single influence set over the actions $\{W_{t}[i],\ldots,W_{t}[N]\}$, i.e., $m=\max_{u\in U}f(I_{t}[i](u))$, and maintains $|\Omega_{t}[i]|=O(\frac{\log{k}}{\beta})$ corresponding instances. To answer the SIM query, we always maintain the candidate user set achieving the largest influence value within the checkpoint. Figure 3 is an example for using SieveStreaming as the checkpoint oracle.

Example 4**.**

Figure 3 illustrates the contents of $\Lambda_{8}[1]$ in Example 3. $\Lambda_{8}[1]$ consists of the meta information and a sequence of SieveStreaming instances. In the meta information, the Checkpoint ID indicates the relative position of this checkpoint in the current window. The Seed Users and the Influence Value are maintained for query processing and checkpoint maintenance (as shown in Figure 3). The Max Cardinality is the maximum cardinality of a single user’s influence set, i.e., $|I_{8}(u_{3})|=4$ for $\Lambda_{8}[1]$. Suppose $\beta=0.3$, $5$ candidates with $j=6,\ldots,10$ are maintained for $\Lambda_{8}[1]$ ($4<1.3^{6}<\ldots<1.3^{10}<16$). Each instance is maintained independently over the mapped set-stream and the instance with the largest influence value is used as the candidate solution (i.e., Instance with $j=6$ as highlighted in Figure 3).

Combining the results of Table 2 with Theorem 2, we can see that at least one user set maintained by $\Lambda_{t}[1]$ guarantees a $(1/2-\beta)$-approximate solution for SIM wrt. $W_{t}$ when SieveStreaming is used as the checkpoint oracle. In addition, the time complexity of IC for each update is $O(\frac{dN\log k}{\beta})$, since the update complexity of SieveStreaming is $O(\frac{\log k}{\beta})$.

5 Sparse Influential Checkpoints

In the IC framework, $N$ checkpoints should be maintained to guarantee an $\varepsilon$-approximation ratio. This implies that $O(dN)$ checkpoint oracle updates need to be performed for each arrival action. However, real world applications often require millions of actions in one window. Therefore, it incurs prohibitive cost to maintain all checkpoints in practice.

To reduce the number of checkpoints maintained and thus improve the update efficiency, we design a Sparse Influential Checkpoints (SIC) framework to selectively maintain a subset of checkpoints without losing too much solution accuracy as the window slides. Specifically, the number of checkpoints maintained by SIC is logarithmic with the window size $N$ while its approximation ratio remains $\frac{\varepsilon(1-\beta)}{2}$ for any $\beta>0$ if the checkpoint oracle is $\varepsilon$-approximate.

In this section, we first present the SIC framework and demonstrate its checkpoint maintenance in Section 5.1. In Section 5.2, we analyze the theoretical soundness and the complexity of SIC. Finally, we discuss how to generalize IC and SIC to handle multiple window shifts in Section 5.3.

5.1 The SIC Framework

The idea of SIC is to leverage a subset of checkpoints to approximate the rest. On the one hand, to reduce the update cost, the number of checkpoints maintained should be as small as possible; on the other hand, the approximation ratio should remain tight. To achieve both goals, we propose a strategy to safely remove some checkpoints in the current window while ensuring the remaining checkpoints are able to approximate any windows with a bounded ratio.

We consider a sequence of checkpoints $\{\Lambda_{t}[x_{0}],\Lambda_{t}[x_{1}],$ $\ldots,$ $\Lambda_{t}[x_{s}]\}$ maintained by SIC at time $t$. Intuitively, given any three consecutive checkpoints $\Lambda_{t}[x_{i-1}]$, $\Lambda_{t}[x_{i}]$, $\Lambda_{t}[x_{i+1}]$ kept by SIC and a parameter $\beta\in(0,1)$, as long as $(1-\beta)\Lambda_{t}[x_{i-1}]$ is less than $\Lambda_{t}[x_{i}]$ and $\Lambda_{t}[x_{i+1}]$, we can safely delete $\Lambda_{t}[x_{i}]$ as $\Lambda_{t}[x_{i+1}]$ is at least $(1-\beta)$-approximate to $\Lambda_{t}[x_{i}]$. Given a checkpoint oracle with an $\varepsilon$-approximation for SIM, it is not hard to identify that using $\Lambda_{t}[x_{i+1}]$ for $\mathsf{OPT}_{t}[x_{i}]$ offers an $\varepsilon(1-\beta)$ approximate solution. Although such a maintenance strategy is simple, we need to ensure that the approximation ratio does not degrade seriously over time, i.e., the ratio should be at least $\frac{\varepsilon(1-\beta)}{2}$ at any time $t^{\prime}>t$. We leave this rather complex analysis to Section 5.2 and focus on describing the maintenance procedure in the remaining of this subsection for ease of presentation.

Algorithm 2 presents how to efficiently maintain the checkpoints over sliding windows in the SIC framework. Similar to the maintenance of IC, upon receiving a new action $a_{t}$, we create a new checkpoint for $a_{t}$ (Line 2), add all checkpoints in $W_{t-1}$ to $W_{t}$, and use $a_{t}$ to update all checkpoints in $W_{t}$ (Lines 3-8). Then the efficient deletion of checkpoints are presented in Lines 9-20. For each checkpoint $\Lambda_{t}[x_{i}]$, we find the first $x_{j}$ ($j\geq i$) such that $\Lambda_{t}[x_{j}]\geq(1-\beta)\Lambda_{t}[x_{i}]$ and $\Lambda_{t}[x_{j+1}]<(1-\beta)\Lambda_{t}[x_{i}]$. Then, all checkpoints between $x_{i}$ and $x_{j}$ are deleted and will be approximated by $\Lambda_{t}[x_{j}]$ in the subsequent window slides. Finally, if the second checkpoint (i.e., $\Lambda_{t}[x_{1}]$) has expired, the earliest checkpoint (i.e., $\Lambda_{t}[x_{0}]$) will be deleted (Lines 21-23). It is notable that an additional checkpoint ($\Lambda_{t}[x_{0}]$) is stored in SIC to keep track of the solution over a window with size larger than $N$. Since $\Lambda_{t}[x_{0}]$ approximates the upper bound of the optimal solution for the current window and Algorithm 2 always maintains a bounded ratio between two neighboring checkpoints, a bounded approximation ratio is guaranteed by using $\Lambda_{t}[x_{1}]$ as the solution for the current window. Figure 4 and Example 5 provide the running example of the SIC maintenance.

Example 5**.**

Figure 4 illustrates the maintenance of checkpoints in the SIC framework following Example 1. Let $N=8$, $k=2$ and $\beta=0.3$. There are initially $6$ checkpoints in SIC at time $8$. According to Algorithm 2, $\Lambda_{8}[5]$ is deleted from SIC since $\Lambda_{8}[6]=3>(1-0.3)\times 3=(1-\beta)\Lambda_{8}[4]$. At time $8$, $\Lambda_{8}[1]$ will be used to answer the SIM query. As the window shifts at time $9$ with the arrival of $a_{9}$, $a_{1}$ and $\Lambda_{8}[1]$ (which later becomes $\Lambda_{9}[0]$) expire. But $\Lambda_{9}[0]$ is stored because $\Lambda_{9}[3]$ has not expired yet. Then all checkpoints will be updated according to $a_{9}$. After the update procedure, we find $\Lambda_{9}[3]$ can be deleted since $\Lambda_{9}[5]>(1-\beta)\Lambda_{9}[0]$. Finally, all checkpoints are updated according to $a_{10}$ at time $10$ and no checkpoints are deleted. $\Lambda_{10}[4]$ will be used to answer the SIM query at time $10$.

In the following, we will demonstrate the theoretical soundness of SIC and also analyze the complexity of SIC.

5.2 Theoretical Analysis

To establish our theoretical claims for SIC, we first analyze the property of the optimal checkpoint oracle which always returns the optimal solution for SIM over an append-only action stream. There are two important properties of the optimal checkpoint oracle.

Definition 3** (Monotonicity & Subadditivity).**

Let $t_{a}\leq t_{b}$ be two timestamps and $W^{t_{a}}_{t_{b}}$ represents a window containing a set of contiguous actions: $a_{t_{a}},...,a_{t_{b}}$ with the corresponding checkpoint denoted as $\Lambda^{t_{a}}_{t_{b}}$. Given any $t_{1},t_{2},t_{3}$ s.t. $t_{1}\leq t_{2}\leq t_{3}$, the checkpoint is monotone if $\Lambda^{t_{1}}_{t_{3}}\geq\Lambda^{t_{1}}_{t_{2}}$. Moreover, the checkpoint is subadditive if $\Lambda^{t_{1}}_{t_{3}}\leq\Lambda^{t_{1}}_{t_{2}}+\Lambda^{t_{2}}_{t_{3}}$.

Lemma 1**.**

Let $t_{a}\leq t_{b}$ be two timestamps and $\mathsf{OPT}^{t_{a}}_{t_{b}}$ denote the optimal oracle (as well as the optimal value) for $W^{t_{a}}_{t_{b}}$. The optimal oracle is both monotone and subadditive.

Proof.

Let $I^{t_{a}}_{t_{b}}(S)$ be the influence set of $S$ and $S^{opt}_{t_{a},t_{b}}$ be the optimal solution of SIM for contiguous actions $\{W_{t_{a}},$ $\ldots,$ $W_{t_{b}}\}$. Because $S^{opt}_{t_{1},t_{2}}$ must be a candidate solution for $W^{t_{1}}_{t_{3}}$, it is obvious to see $\mathsf{OPT}^{t_{1}}_{t_{3}}\geq\mathsf{OPT}^{t_{1}}_{t_{2}}$. Then, we prove $\mathsf{OPT}^{t_{1}}_{t_{3}}\leq\mathsf{OPT}^{t_{1}}_{t_{2}}+\mathsf{OPT}^{t_{2}}_{t_{3}}$. For any $S\subseteq U$, we have $I^{t_{1}}_{t_{3}}(S)=I^{t_{1}}_{t_{2}}(S)\cup I^{t_{2}}_{t_{3}}(S)$. Then, we have:

[TABLE]

where the first inequality holds for the property of influence sets, and the second inequality is satisfied because $S^{opt}_{t_{1},t_{3}}$ is also a candidate solution for both $W^{t_{1}}_{t_{2}}$ and $W^{t_{2}}_{t_{3}}$. ∎

We note that although the optimal checkpoint oracle is both monotone and subadditive, it is intractable unless $P=NP$. In practice, we utilize the approximate checkpoint oracles as listed in Table 2. The approximate oracles are monotone. This is essential due to their greedy nature: updating the maintained result only when this update increases the function value. Given the monotonicity of the approximate checkpoint oracles, the monotonicity and subadditivity of the optimal oracle, we are ready to prove that the checkpoint maintenance strategy used in SIC is theoretically bounded.

Lemma 2**.**

Given any $t_{1},t_{2},t_{3},t_{4}$ s.t. $t_{1}\leq t_{2}\leq t_{3}\leq t_{4}$, $\forall\beta\in(0,1)$, if $(1-\beta)\Lambda^{t_{1}}_{t_{3}}\leq\Lambda^{t_{2}}_{t_{3}}$, then $\frac{\varepsilon(1-\beta)}{2}\mathsf{OPT}^{t_{1}}_{t_{4}}\leq\Lambda^{t_{2}}_{t_{4}}$.

Proof.

The following inequalities hold:

[TABLE]

where the first inequality holds from the monotonicity of the approximate checkpoint oracles; the second inequality is due to the condition that $\Lambda_{t_{3}}^{t_{2}}\geq(1-\beta)\Lambda^{t_{1}}_{t_{3}}$; the third inequality is obvious since $\beta\in(0,1)$; the fourth inequality holds because of the approximation ratio of checkpoint oracles and the final inequality holds as the optimal checkpoint oracle is both monotone and subadditive. ∎

According to Lemma 2, if $(1-\beta)\Lambda^{t_{1}}_{t_{3}}\leq\Lambda^{t_{2}}_{t_{3}}$, using the checkpoint oracle started at $t_{2}$ to approximate any checkpoints between $t_{1}$ and $t_{2}$ always achieves an $\frac{\varepsilon(1-\beta)}{2}$ approximation for any number of appending actions. Next, we present Lemma 3 to demonstrate the property of the checkpoints maintained by Algorithm 2.

Lemma 3**.**

The SIC on window $W_{t}$ contains $s$ checkpoints $\Lambda_{t}[x_{0}],\Lambda_{t}[x_{1}],\ldots,\Lambda_{t}[x_{s}]$ $(x_{0}<x_{1}<\ldots<x_{s})$ maintained by Algorithm 2. Given a constant $\beta\in(0,1)$, any neighboring checkpoints $\Lambda_{t}[x_{i}]$, $\Lambda_{t}[x_{i+1}]$ and $\Lambda_{t}[x_{i+2}]$ satisfy one of the following conditions:

if $\Lambda_{t}[x_{i+1}]\geq(1-\beta)\Lambda_{t}[x_{i}]$, then $\Lambda_{t}[x_{i+2}]<(1-\beta)\Lambda_{t}[x_{i}]$. 2. 2.

if $x_{i+1}\neq x_{i}+1\wedge\Lambda_{t}[x_{i+1}]<(1-\beta)\Lambda_{t}[x_{i}]$, then $\frac{\varepsilon(1-\beta)}{2}\\ \mathsf{OPT}_{t}[x_{i}]\leq\Lambda_{t}[x_{i+1}]$. 3. 3.

$x_{i+1}=x_{i}+1\wedge\Lambda_{t}[x_{i+1}]<(1-\beta)\Lambda_{t}[x_{i}]$.

Proof.

We prove the lemma by induction. As the base case, initially there are only 2 actions in the window and either condition 1 or 3 holds.

Next, assume Lemma 3 holds at time $t$ and we show that it still holds after the update procedure in Algorithm 2 at time $t+1$. Let $\Lambda_{t}[x_{i}]$ be a checkpoint instantiated before $t+1$ and is not deleted during the update procedure at $t+1$, then $\Lambda_{t}[x_{i+1}]$ is the subsequent checkpoint of $\Lambda_{t+1}[x_{i}]$ at time $t$, Next, we discuss all possible cases when performing the update procedure of Algorithm 2 at time $t+1$:

Case 1: $x_{i+1}\neq x_{i}+1$ and $\Lambda_{t}[x_{i+1}]$ is deleted at $t+1$. In this case, we have $\Lambda_{t+1}[x_{i+1}]\geq(1-\beta)\Lambda_{t+1}[x_{i}]$ and $\Lambda_{t+1}[x_{i+2}]<(1-\beta)\Lambda_{t+1}[x_{i}]$ according to Lines 9-20 of Algorithm 2. In this case, condition 1 holds at $t+1$.

Case 2: $x_{i+1}\neq x_{i}+1$ and $\Lambda_{t+1}[x_{i+1}]$ is not deleted at $t+1$. In this case, $\Lambda_{t+1}[x_{i+1}]$ must become the subsequent checkpoint of $\Lambda_{t+1}[x_{i}]$ at some time $t^{\prime}\leq t$. Then, at $t^{\prime}$, we have $\Lambda_{t^{\prime}}[x_{i+1}]\geq(1-\beta)\Lambda_{t^{\prime}}[x_{i}]$. According to Lemma 2, $\Lambda_{t+1}[x_{i+1}]\geq\frac{\varepsilon(1-\beta)}{2}\mathsf{OPT}_{t+1}[x_{i}]$ holds. Because $\Lambda_{t+1}[x_{i+1}]$ is not deleted at $t+1$, we have either condition 1 (when $\Lambda_{t+1}[x_{i+1}]\geq(1-\beta)\Lambda_{t+1}[x_{i}]$) or condition 2 holds (when $\Lambda_{t+1}[x_{i+1}]<(1-\beta)\Lambda_{t+1}[x_{i}]$) at $t+1$.

Case 3: $x_{i+1}=x_{i}+1$. If $\Lambda_{t+1}[x_{i+1}]\geq(1-\beta)\Lambda_{t+1}[x_{i}]$, then condition 1 holds since $\Lambda_{t+1}[x_{i+1}]$ is not deleted at $t+1$; otherwise, condition 3 holds.

Therefore, at least one condition in Lemma 3 holds in all possible cases at $t+1$ and we conclude the proof. ∎

Leveraging Lemma 3, we are able to analyze SIC theoretically. First, from conditions 1 and 2, we can infer that if there are checkpoints deleted between $x_{i}$ and $x_{i+1}$, the ratios between $\Lambda_{t}[x_{i+1}]$ and the optimal solution of deleted checkpoints are guaranteed to be at least $\frac{\varepsilon(1-\beta)}{2}$. Next, by collectively examining conditions 1–3, we can see that there is at least one checkpoint in $\Lambda_{t}[x_{i+1}]$ and $\Lambda_{t}[x_{i+2}]$ returning an influence value of smaller than $(1-\beta)\Lambda_{t}[x_{i}]$, and thus the number of checkpoints maintained is $O(\frac{\log N}{\beta})$. Based on these intuitions, we then formally state the approximation guarantee and the complexity of SIC in Theorems 3–5:

Theorem 3**.**

SIC maintains a $\frac{\varepsilon(1-\beta)}{2}$-approximate solution for SIM in $\Lambda_{t}[x_{1}]$ when a $\varepsilon$-approximate checkpoint oracle is used.

Proof.

We use $\mathsf{OPT}_{t}$ to denote the optimal solution of SIM w.r.t. $W_{t}$ and we prove that $\frac{\varepsilon(1-\beta)}{2}$ is a lower bound for the ratio between $\Lambda_{t}[x_{1}]$ and $\mathsf{OPT}_{t}$.

Let $\Lambda_{t}[x_{0}]$ be the expired checkpoint just before $\Lambda_{t}[x_{1}]$. Since $\Lambda_{t}[x_{0}]$ and $\Lambda_{t}[x_{1}]$ are neighboring checkpoints in SIC, one of the conditions in Lemma 3 holds at time $t$.

If condition 3 in Lemma 3 holds, we have $\mathsf{OPT}_{t}\leq\varepsilon\Lambda_{t}[x_{1}]$ since $\Lambda_{t}[x_{1}]$ directly maintains an approximate solution on $W_{t}$. Otherwise, we have: $\mathsf{OPT}_{t}\leq\mathsf{OPT}_{t}[x_{0}]\leq\frac{2}{\varepsilon(1-\beta)}\Lambda_{t}[x_{1}]$ since $\Lambda_{t}[x_{0}]$ has expired. Thus, SIC maintains an at least $\frac{\varepsilon(1-\beta)}{2}$-approximate solution in $\Lambda_{t}[x_{1}]$. ∎

Theorem 4**.**

SIC obtains a $(1/4-\beta)$-approximate solution for SIM when SieveStreaming is used as the checkpoint oracle.

Proof.

Since the SieveStreaming algorithm guarantees a $(1/2-\beta)$ approximation ratio to the optimal solution, SIC with SieveStreaming as the checkpoint oracle preserves a $\frac{1}{2}(\frac{1}{2}-\beta)(1-\beta)$ approximation guarantee according to Theorem 3. As $\frac{1}{2}(\frac{1}{2}-\beta)(1-\beta)=\frac{1}{4}-\frac{3}{4}\beta+\beta^{2}>\frac{1}{4}-\beta$, we get at least a $(1/4-\beta)$-approximate solution for SIM. ∎

Theorem 5**.**

The number of checkpoints maintained by SIC wrt. a sliding window of size $N$ is $O(\frac{\log N}{\beta})$.

Proof.

Lemma 3 guarantees either $\Lambda_{t}[x_{i+1}]$ or $\Lambda_{t}[x_{i+2}]$ is less than $(1-\beta)\Lambda_{t}[x_{i}]$. Since we have $\Lambda_{t}[x_{1}]/\Lambda_{t}[N]$ is bounded by $O(N)$, the number of checkpoints is at most $\frac{2\cdot\log{N}}{\log(1-\beta)^{-1}}$ for $\beta\in(0,1)$. Therefore, the number of checkpoints maintained by SIC is $O(\frac{\log N}{\beta})$. ∎

As the time complexity for a checkpoint to update each action is $O(dg)$ if each checkpoint takes $O(g)$ to evaluate one influence set and the number of checkpoints maintained by SIC is $O(\frac{\log N}{\beta})$, the time complexity of SIC to update each action is $O(\frac{dg\log N}{\beta})$. When SieveStreaming is used as the checkpoint oracle, we have $g=O(\frac{\log k}{\beta})$ and thus the time complexity of SIC for each update is $O(\frac{d\log N\log k}{\beta^{2}})$.

5.3 Handling Multiple Window Shifts

Although we have discussed how to handle SIM queries for windows which shift for one action at a time, many applications do not require to retrieve the result at such an intense rate. Hereby, we discuss how to handle multiple window shifts, i.e., each window shift receives $L$ new actions while the earliest $L$ actions become expired at the same time.

To handle multiple window shifts for IC, we create only one new checkpoint and delete the earliest checkpoint when the window slides from time $t$ to $t+L$. Subsequently, all actions from $a_{t+1}$ to $a_{t+L}$ are collected to update all checkpoints in the window. Thus, the number of checkpoints created for multiple window shifts will be $\left\lceil\frac{N}{L}\right\rceil$. On top of the IC maintenance strategy, we still use the same SIC algorithm over the checkpoints created by IC to support multiple window shifts.

Lastly, the aforementioned maintenance strategies still preserve the theoretical results as there is no fundamental differences between handling single window shift and multiple window shifts using our proposed frameworks.

6 Experimental Results

In this section, we evaluate the efficiency and effectiveness of our proposed frameworks on several real-world and synthetic datasets. First, we compare IC and SIC for influence values and processing efficiency with varying $\beta$. Then, we compare the solution qualities and throughputs of all approaches with different seed set size. Finally, we evaluate the scalability of all compared approaches.

6.1 Experimental Setup

Datasets: We collect two real-world datasets and synthesize two datasets for extensive studies.

• •

Reddit: Reddit is an online forum where user actions include post and comment. We collect all Reddit comment actions in May 2015 from kaggle666https://www.kaggle.com/reddit/reddit-comments-may-2015 and query the Reddit API for the post actions in the same period. The dataset contains $48,104,875$ actions from $2,628,904$ users.

• •

Twitter: Twitter is an online social network where actions include tweet, retweet, quote and reply. We crawl these actions for one week via Twitter stream API777https://dev.twitter.com/streaming/overview on trending topics such as US presidential election, 2016 NBA finals and Euro 2016. The dataset contains $9,724,908$ actions from $2,881,154$ users.

• •

Synthetic Datasets: We synthesize two action streams with different response patterns to test the robustness of the proposed solutions. There are two types of actions in concern: post and follow. We use the R-MAT model [8] to synthesize 5 different power law graphs with the number of users ranging from $1$-$5$ million ($2$ million by default). For each synthetic graph, we generate $10$ million actions by randomly selecting a user to perform either a post or a follow action. If an action $a_{t}$ is follow, it will respond to a previous action $a_{t^{\prime}}$ with a response distance $\Delta=t-t^{\prime}$. To demonstrate different response patterns, two datasets are generated based on the distances conforming to exponential distributions with different parameters: (1)SYN-O: $\Delta\sim\mathtt{exp}(\lambda=2.0\times 10^{-6})$, which indicates “old posts get more followers”; (2)SYN-N: $\Delta\sim\mathtt{exp}(\lambda=2.0\times 10^{-4})$, which represents “recent posts get more followers”.

The statistics of these datasets are summarized in Table 3.

Approaches: All approaches compared in the experiments are listed as follows:

• •

IMM [35]: To support our argument on the effectiveness, we use the state-of-the-art IM algorithm on static graphs as a baseline. At each time $t$, we construct an influence graph $G_{t}$ by treating users as vertices and the influence relationships between users wrt. $W_{t}$ as directed edges. The edge probabilities between users are assigned by the weighted cascade (WC) [17] model. To extract the influential users at time $t$, we set the parameters of IMM to be $\varepsilon=0.5$, $l=1$ [35] and run the algorithm on the generated influence graph $G_{t}$.

• •

UBI [10]: We use the state-of-the-art method for IM on dynamic graphs as another baseline. The generation of influence graphs is the same as IMM. Then, a sequence of influence graphs $\{G_{1},G_{2},\ldots\}$ are fed to UBI in a chronological order to track the influential users. We keep the same interchange threshold as used in [10], i.e., $\gamma=0.01$.

• •

Greedy [27]: We also implement the classic greedy algorithm in [27] since it achieves the best theoretical approximation (i.e., $1-1/e$) of SIM queries. A detailed description of this algorithm is presented in Section 4. Since the Greedy algorithm does not store any intermediate result, it always recomputes the solution when being queried.

• •

IC: The IC framework proposed in Section 4. We use SieveStreaming [3] as the checkpoint oracle.

• •

SIC: The SIC framework proposed in Section 5. We use the same checkpoint oracle as IC.

Quality Metric: We note that IMM and UBI work under the WC model whereas Greedy, IC and SIC are proposed to answer SIM queries in Section 3. To verify the effectiveness of our proposed solutions, we retrieve the seed users returned by all approaches for each window slide. When a set of seed users is returned by each approach at time $t$, we evaluate the influence spread of the users under the WC model with 10,000 rounds of Monte-Carlo simulation on the corresponding influence graph $G_{t}$. Finally, we use the average influence spread of all windows for each approach as the quality metric.

Performance Metric: We use throughput as our performance metric. Specifically, whenever the window slides for $L$ actions, we measure the elapsed CPU time of each approach and the throughput is $L$ divided by the elapsed time. We do not measure the query processing time because all approaches maintain the seed users explicitly and the time to retrieve them is negligible.

Parameters: The parameters examined in our experiments: (1) $\beta$ is the parameter in IC and SIC to achieve a trade-off between quality and efficiency. (2) $k$ is the size of the seed set. (3) $N$ is the window size. (4) $L$ is the number of actions for each window slide. (5) $|U|$ is the total number of users for synthetic datasets. We vary $N$, $L$ and $|U|$ to test the scalability of the compared approaches. The summary of parameters is listed in Table 4. The default values of all parameters are in bold.

Experiment Settings: All experiments are conducted on a desktop machine running Ubuntu 14.04 with a quad core 3.4 GHz Intel i7-2600 processor and 16 GB memory. All the approaches except IMM are implemented in Java $8$. The IMM implementation available888https://sourceforge.net/projects/im-imm/ is written in C++.

6.2 Testing $\beta$ for IC and SIC

We first vary $\beta$ to test its effect on IC and SIC in terms of the average influence value of SIM queries using the cardinality function, the number of maintained checkpoints and the throughput. Note that we compare the seed qualities of IC and SIC with the baselines in Section 6.3 and only focus on their effectiveness of answering SIM queries here.

Influence Value: The influence values of IC and SIC with varying $\beta$ are presented in Figure 5a–5d. The influence values of IC are slightly better than SIC in most experiments. This is because SIC trades quality for efficiency by maintaining fewer checkpoints. In spite of that, SIC is able to obtain competitive values with at most $5\%$ off from IC. In addition, we can see that both SIC and IC achieve better influence values for a smaller $\beta$ and the influence values of SIC degrade faster than IC for a larger $\beta$ due to the deletion of checkpoints. We note that in the SYN-N dataset, the influence values of SIC degrade more severely than other datasets for a larger $\beta$. This is because the average reply distance is very short, which leads to the frequent changes of the influential users. Nevertheless, SIC still returns solutions within the theoretical bound stated in Section 5.2.

Number of checkpoints: We examine the average number of checkpoints maintained by IC and SIC for all sliding windows. The results are presented in Figure 6a–6d. IC maintains a constant number of checkpoints wrt. $\beta$. This is because the number of checkpoints maintained by IC in each sliding window exactly equals to $\lceil\frac{N}{L}\rceil$. On the contrary, the number of checkpoints in SIC is $O(\frac{\log N}{\beta})$ according to Theorem 5 in Section 5.2, and is thus negatively correlated with $\beta$. The trend for the number of checkpoints emphasizes the superiority of SIC in both space and time efficiencies.

Throughput: The throughputs of IC and SIC are presented in Figure 7a–7d. Both IC and SIC achieve better performance for a larger $\beta$. There are two reasons behind such an observation. First, both approaches employ SieveStreaming as the checkpoint oracle where fewer candidate instances are kept within each checkpoint for a larger $\beta$, which makes the update time shorter for each checkpoint. Second, SIC maintains fewer checkpoints as $\beta$ becomes larger, which naturally leads to shorter processing time. Thus, for a larger $\beta$, SIC shows even more superiority over IC in all experiments because fewer checkpoints are maintained by SIC.

6.3 Comparing Approaches with Varying $k$

We compare different approaches by using the quality and the performance metric defined in Section 6.1 for varying $k$.

Quality: The results of solution qualities for different approaches are presented in Figure 8a–8d. Compared with IMM, Greedy, IC and SIC achieve less than $10\%$ quality losses. The results have verified the effectiveness of SIM as the seeds for SIM queries achieve nearly equivalent influence spreads as the seeds retrieved by IMM under the WC model. Moreover, SIC shows competitive qualities though it maintains fewer checkpoints than IC. In contrast, the qualities of UBI are close to IMM when $k$ is small (i.e., $k\leq 25$). But its qualities degrade dramatically when $k$ increases. This is because UBI relies on interchanging users to maintain the influential users against the updates of the influence graph. It interchanges a user into the maintained influential user set only when a substantial gain is achieved for the estimated influence spread (i.e., $1\%$ of the total influence spread prior to the interchange). Thus, for a larger $k$, it becomes harder for a user to be interchanged since the total influence spread of the maintained user set is larger. This results in the delays of interchanges and causes larger errors.

Throughput: The performances with varying $k$ are presented in Figure 9a–9d. The throughputs of all approaches are inversely proportional to $k$. IC and SIC both employ SieveStreaming as the checkpoint oracle, each checkpoint maintains a number of candidate instances and each instance contains up to $k$ candidate users. When $k$ gets larger, it is more expensive to evaluate the influence function for each checkpoint. This explains why the performances of IC and SIC drop while $k$ becomes larger. Compared with IC and all baseline methods, SIC shows significant advantages in efficiency for all experiments. Moreover, SIC dominates Greedy and IMM by achieving a speedup of up to 2 orders of magnitude across all datasets. The throughput of UBI is also far behind SIC and IC on all datasets except Twitter, where it achieves an equivalent throughput compared to IC. Nonetheless, UBI is still more than 3 times slower than SIC.

6.4 Scalability

In this section, we evaluate the scalability of compared methods through measuring the throughputs when varying the window size $N$, the length of each window slide $L$ and the total number of users $|U|$.

Varying $N$: The performances for varying $N$ are presented in Figure 10a–10d. Although the throughputs of all approaches decrease with increasing $N$, SIC shows better scalability as it only maintains $O(\log{N})$ checkpoints when $\beta$ is fixed. We observe a smaller performance gap between IC and SIC in all datasets when $N$ is small (i.e., $N=100,000$). This is because the number of checkpoints maintained by IC is very close to SIC (fewer than $8$) and the benefits of sparse checkpoints become less significant. Nonetheless, when $N$ increases, SIC regains its superiority. Moreover, SIC achieves speedups of up to 40x, 100x and 70x compared to Greedy, IMM and UBI respectively.

Varying $L$: We show the performances for varying $L$ in Figure 11a–11d. As $L$ increases, the throughputs of IC and SIC increase. This is because larger $L$ results in a smaller number of checkpoints for both methods. IC exhibits a linear performance improvement wrt. larger $L$ since it maintains $\lceil\frac{N}{L}\rceil$ checkpoints. As SIC deletes some checkpoints created by IC, it continues to be superior to IC in terms of performance, which demonstrates its scalability in handling multiple window slides. Like the results for varying $N$, SIC dominates Greedy, IMM and UBI in terms of the throughput.

Varying $|U|$: Finally, we show the performances for varying $|U|$ on two synthetic datasets in Figure 12a–12b. We observe that the throughputs of SIC, IC and UBI increase as $|U|$ becomes larger. Fixing the window size $N$, the influence graphs become more sparse for a larger $|U|$. All these three approaches show better performance on more sparse graphs. However, Greedy and IMM need more processing time to run as $|U|$ increases since these complexities are directly related to $|U|$. Finally, SIC still shows superior performances in all experiments with various $|U|$ settings.

7 Conclusion

In this paper, we proposed a novel Stream Influence Maximization (SIM) query to retrieve $k$ influential users who collectively maximize the influence value over a social action stream. Then, we presented a novel framework Influential Checkpoints (IC) and its improved version Sparse Influential Checkpoints (SIC) to efficiently support the continuous SIM queries over high-speed social streams. Theoretically, SIC maintained $O(\frac{\log N}{\beta})$ checkpoints to obtain an $\frac{\epsilon(1-\beta)}{2}$-approximate solution for SIM queries. Empirically, our experiments showed that SIC achieves up to $2$ orders of magnitude speedups over the state-of-the-art static and dynamic IM approaches with less than $10\%$ losses in seed quality. In particular, SIC demonstrated a peak processing rate of more than $150$K actions per second, which is adequate for real-world social streams. In the future, we plan to extend our proposed frameworks to support a broader class of IM problems, e.g., competitive IM [5, 22, 26].

Acknowledgment

We thank Mr. Ohsaka Naoto for providing his implementation of algorithms in [29].

Appendix A Discussion

In this section, we discuss how to extend our proposed frameworks to different types of IM problems in a streaming setting. Here, we take topic-aware IM [4, 9], location-aware IM [21, 37], and conformity-aware IM [23] as examples.

Topic-Aware IM: First, we consider processing topic-aware SIM queries in a dynamic social stream. Given a set of topics $T$, we assume that a topic oracle can provide a subset of topics $T_{t}\subseteq T$ for each arrival action $a_{t}$, where $T_{t}$ contains all topics that are related to $a_{t}$. Then, we consider each SIM query $q$ only concerns a subset of topics $T_{q}\subseteq T$. To maintain the influential users for $q$, we can invoke IC or SIC but only process a sub-stream of actions $\{a_{t}|T_{t}\cap T_{q}\neq\emptyset\}$.

Location-Aware IM: Then, we consider the location-aware SIM queries in a dynamic social stream. For a location-aware SIM query $q$ with a spatial region $R$, we aim to find users who have the largest influences in $R$. It can be processed in a similar way with topic-aware SIM queries. We assume each action $a_{t}$ is associated with a position $p_{t}$, which means that $a_{t}$ happens at $p_{t}$. To maintain the influential users for $q$, we can also invoke IC or SIC but only process a sub-stream of actions $\{a_{t}|p_{t}\in R\}$.

Conformity-Aware IM: In conformity-aware IM, the influence and conformity scores of all users are calculated offline. To incorporate these scores into SIM, we can design the influence function as follows: given any user set $S$, the influence function is set to $\sum_{u^{\prime}\in I(S)}w_{S}(u^{\prime})$ where $I(S)$ is the set of users influenced by $S$ in our model and $w_{S}(u^{\prime})$ is the conformity-aware influence score from $S$ to a user $u^{\prime}$. Specifically, $w_{S}(u^{\prime})$ is evaluated as $w_{S}(u^{\prime})=1-\prod_{u\in S\wedge u^{\prime}\in I(\{u\})}(1-\Phi(u)\Omega(u^{\prime}))$ with $\Phi(\cdot)$ and $\Omega(\cdot)$ denoting the influence and conformity scores calculated by the conformity-aware model offline. As conformity-aware scores naturally evolve slowly, it is reasonable to treat them as constants for a long time and recompute them periodically. As the adapted influence function retains the monotone and submodular properties, our proposed frameworks remain effective and efficient when considering conformity-aware IM.

From the above examples, we see different types of IM problems with monotone submodular objective functions can be adapted to our frameworks. However, it is still an open problem to use our frameworks to support IM problems having non-monotone or non-submodular objective functions (e.g. opinion-aware IM) or considering the dependency of different queries (e.g., competitive IM).