FLEET: Butterfly Estimation from a Bipartite Graph Stream

TL;DR

This paper introduces FLEET, a suite of algorithms for space-efficient, accurate estimation of butterfly counts in bipartite graph streams, including sliding window scenarios, with provable guarantees and experimental validation.

Contribution

It provides the first space lower bounds and algorithms with error guarantees for butterfly estimation in bipartite graph streams, addressing a gap in subgraph counting research.

Findings

FLEET algorithms achieve good accuracy with low space usage.

Provable error bounds are established for the estimations.

Experimental results demonstrate effective tradeoffs between space and accuracy.

Abstract

We consider space-efficient single-pass estimation of the number of butterflies, a fundamental bipartite graph motif, from a massive bipartite graph stream where each edge represents a connection between entities in two different partitions. We present a space lower bound for any streaming algorithm that can estimate the number of butterflies accurately, as well as FLEET, a suite of algorithms for accurately estimating the number of butterflies in the graph stream. Estimates returned by the algorithms come with provable guarantees on the approximation error, and experiments show good tradeoffs between the space used and the accuracy of approximation. We also present space-efficient algorithms for estimating the number of butterflies within a sliding window of the most recent elements in the stream. While there is a significant body of work on counting subgraphs such as triangles in a unipartite graph stream, our work seems to be one of the few to tackle the case of bipartite graph streams.

Tables

Table 1. Table 1. Properties of the bipartite graphs. | E | 𝐸 |E| is the number of edges, ξ 𝜉 \xi the total number of butterflies, and the butterfly density is the ratio ξ / | E | 4 𝜉 superscript 𝐸 4 \xi/{|E|}^{4} .

Graphs	—E—	—V— (Left)	—V— (Right)	$\xi$	Butterfly density
Movie-lens	\num10000054	\num69878	\num10677	1.1T	$1.1\times {10}^{-16}$
Edit-frwiki	\num22090703	\num288275	\num3992426	601.2B	$2.5\times {10}^{-18}$
Yahoo-song	\num256804235	\num1000990	\num624961	101.4T	$2.3\times {10}^{-20}$
Edit-enwiki	\num122075170	\num3819691	\num21416395	2T	$9.1\times {10}^{-21}$
Bag-pubmed	\num483450157	\num8200000	\num141043	40.8T	$7.4\times {10}^{-22}$

Table 2. Table 2. MAPE (Mean Absolute Percent Error) of different algorithms for γ = 0.8 𝛾 0.8 \gamma=0.8 and M = \num ​ 150 𝑀 \num 150 M=\num{150} K

Graphs	Fleet1	Fleet2	Fleet3	GPS (Ahmed et al., 2017)	BC (Bera and Chakrabarti, 2017)
Movie-lens	1.03	0.72	0.69	89.32	103.23
Edit-frwiki	4.37	1.7	1.68	63.92	102.36
Yahoo-song	13.97	5.62	0.78	43.1	104.48
Edit-enwiki	19.43	9.94	2.95	46.65	85.38
Bag-pubmed	103.74	91.59	5.65	14.22	113.77

Equations

$$f(S_1,S_2,\dots ,S_n,i,j)=\{\begin{array}{ll}1& \text{mbox}ifj\in S_i\\ 0& \text{mbox}otherwise\end{array}$$

$$\mathrm{Pr}\left[B\right]=$$

$$\le$$

Full text

butterfly counting, rectangle counting, data stream

1. Introduction

Enumeration and counting of graph substructures has emerged as a basic tool in understanding complex networks, and has found wide applications in social networks, spam/fraud detection, and link recommendation, and more. Due to the scale of today’s datasets, enumeration and counting needs to be performed on very large graphs, with the order of billions of vertices and trillions or larger number of graph substructures. Such large graphs are naturally modeled as graph streams – the edges of such a graph are not available all at once, but are instead observed as a sequence of updates.

In this work, we focus on bipartite graph streams. A bipartite graph consists of two disjoint node sets $L$ and $R$. Each edge in the graph connects a node in $L$ with a node in $R$. Bipartite graphs are widely used in modeling relationships in the real world. For instance, they can be used to model relationships between authors and papers they have published, where the set of authors form one node partition, papers form the other node partition, and an author has an edge to each paper that she published (Deng et al., 2009). In web search, bipartite graphs have been used in modeling relations between queries and URLs in query logs (Li et al., 2008) and in matching users to advertisements in computational advertising (Mehta, 2013; Aggarwal et al., 2014). In computational biology, bipartite graphs are used to model enzyme-reaction links in metabolic pathways and gene-disease associations (Pavlopoulos et al., 2018). Other examples include user-product relations, word-document affiliations, and actor-movie networks. Bipartite graphs can be used to represent hypergraphs that capture many-to-many relations among entities, through having the hyperedges in one partition, and the entities in another partition. Bipartite graph streams are natural in the above examples, where new entities may arise in either partition, and new edges are observed as time progresses. The challenge in bipartite graph stream processing is to maintain properties in a time- and space-efficient way as more edges are observed.

While there is a rich literature on subgraph motif counting from unipartite network streams, these methods do not take into account the special structure present in bipartite networks. For instance, the number of triangles (cliques of size 3), a widely studied metric for unipartite graph streams (Ahmed et al., 2017; Becchetti et al., 2010; Chen and Lui, 2017; Han and Sethu, 2017; Jha et al., 2015; Jowhari and Ghodsi, 2005; Bulteau et al., 2016; Lim and Kang, 2015; Pavan et al., 2013; Tangwongsan et al., 2013; Shin et al., 2018; Stefani et al., 2017; Z. Bar-Yossef and Sivakumar, 2002; Kolountzakis et al., 2012; Alon et al., 1997; Turk and Turkoglu, 2019), is not a useful metric for bipartite networks, since a bipartite network is triangle-free. Instead, the most basic motif which models cohesion in a bipartite network is the $2\times 2$ biclique, known as a butterfly (Aksoy et al., 2017; Sarıyüce and Pinar, 2018; Sanei-Mehri et al., 2018) or a rectangle (Wang et al., 2014). The number of butterflies has been used in defining the clustering coefficient in a bipartite graph (Robins and Alexander, 2004; Lind et al., 2005) and can be considered as playing the same role in bipartite networks as the triangle did in unipartite networks – a building block for community structure. Though there are some prior works on counting butterflies in a static bipartite graph (Sanei-Mehri et al., 2018; Wang et al., 2014), these have not considered bipartite graph streams.

1.1. Contributions

We present FLEET, butterFLy Estimation from a bipartitE graph sTream – a suite of space-efficient one-pass streaming algorithms for estimating the number of butterflies in a bipartite graph stream. Our algorithms use fixed-size memory that is much smaller than the size of the stream, and continuously maintain an estimate of the number of butterflies as edges arrive in the stream. Our algorithms are simple to implement, backed up by theoretical guarantees, and have good practical performance.

– Space Lower Bound. We first show a lower bound, proving that any streaming algorithm (whether deterministic or randomized) that can approximately maintain an estimate of the number of butterflies with a bounded relative error in a graph on $n$ vertices must use a memory of size $\Omega(n^{2})$ on certain input streams. Note that using $\Omega(n^{2})$ memory, it is possible to store the entire graph stream. This shows that in general, it is not possible for a streaming algorithm to maintain an estimate of the number of butterflies using memory sub-linear in the size of the graph. However, the lower bound applies for cases when the number of butterflies in the graph is very small; in particular, the proof depends on distinguishing between two cases, one where there are no butterflies, and another where there is a single butterfly. Real-world bipartite graph streams typically have a large number of butterflies (e.g., Figure 3), and hence, one cannot rule out algorithms that are more space-efficient and return an accurate estimate of the number of butterflies, thus motivating our further work on small-memory algorithms.

– Infinite Window Streaming. We next present small-memory algorithms for estimating the number of butterflies within an infinite window consisting of all edges seen so far in the stream. The memory used by our algorithms is no more than a given parameter $M$. We first present an algorithm Fleet1 that is based on adaptive random sampling from the edge stream so that as more edges are seen, the sampling probability decreases so as to fit within available memory. We prove that the estimator returned by Fleet1 is unbiased, and derive concentration bounds showing that the estimator is close to the actual value with a high probability, if the memory used is large enough. We present two enhancements to Fleet1, leading to algorithms Fleet2 and Fleet3 which provide better memory-accuracy tradeoffs in practice.

– Sliding Window Streaming. In stream data mining, the scope of aggregation often needs to be restricted to include edges that have arrived within a recent window. To handle such cases, we present extensions of Fleet to the sliding window model (Babcock et al., 2002; Gibbons and Tirthapura, 2002; Braverman et al., 2009). We consider two types of sliding windows. (1) For a sequence-based window, defined as the set of $W$ most recent edges in the stream for a window size parameter $W$, we present an algorithm FleetSSW (2) For a time-based window, defined as stream elements whose timestamps are greater than $(c-w)$, where $c$ is the current time and $w$ is the window size, we present an algorithm FleetTSW. Both algorithms use a bounded memory that does not increase with the number of edges in the window. Our algorithm for a time-based window is flexible to receive the window size as a parameter during the query, and does not need to know the window size in advance.

– Experimental Evaluation. We experimentally evaluate Fleet on real-world graph streams. Results show that our algorithms are effectively able to handle large graph streams. For instance, on the Bag-pubmed graph with approximately 500M edges and 40T butterflies, our algorithms are able to achieve estimates with an error of less than 1% using a memory of 600K edges. Our methods present different tradeoffs between memory, estimation accuracy, and runtime, that make them applicable in real-world applications with different requirements, and significantly outperform prior works on subgraph counting from graph streams (Ahmed et al., 2017; Bera and Chakrabarti, 2017; Manjunath et al., 2011).

1.2. Related Works

Network motifs. Network motifs are small subgraphs that are defined on a few nodes and edges. Unlike graph communities or dense subgraphs, whose sizes do not have to be bounded, network motifs are typically subgraphs with less than six nodes. A similar concept is graphlets (Pržulj, 2007). Network motif detection and counting is now an indispensable tool in network analysis (Milo et al., 2002; Liu et al., 2019). The distribution of motif counts in a network, as well as the number of motifs that a node takes part in, help characterize the roles of networks and nodes (Milenković and Pržulj, 2008), an idea that has been used in numerous applications in networking, web and social network analysis, and computational biology (Schiöberg et al., 2015; Becchetti et al., 2010; Faisal and Milenković, 2014; Wang et al., 2014; Singh et al., 2014).

Butterfly Counting. There have been relatively few works on counting motifs in a bipartite graph. Wang et al. (Wang et al., 2014) presented exact algorithms for butterfly counting in static graphs that outperform generic matrix multiplication based methods (Alon et al., 1997). Sanei-Mehri et al. (Sanei-Mehri et al., 2018) and Zhu et al. (Zhu et al., 2018) present exact and randomized algorithms for butterfly counting on static bipartite graphs. (Wang et al., 2019; Shi and Shun, 2019) presents parallel algorithms for butterfly counting on static graphs. All these works have considered static graphs and not graph streams, like we do here.

Motif Counting in Graphs. There are a number of algorithms known for triangle counting for unipartite streaming graphs, including (Ahmed et al., 2017; Becchetti et al., 2010; Z. Bar-Yossef and Sivakumar, 2002; Chen and Lui, 2017; Han and Sethu, 2017; Jha et al., 2015; Jowhari and Ghodsi, 2005; Bulteau et al., 2016; Lim and Kang, 2015; Pavan et al., 2013; Shin et al., 2018; Wang et al., 2017). Recent works on counting 4-vertex (Ahmed et al., 2015) and 5-vertex subgraphs (Pinar et al., 2017) have focused on exact counting and are not designed for streaming graphs.

Since a butterfly is a 4-cycle, prior works on counting 4-cycles in any graph stream (Bordino et al., 2008; Buriol et al., 2007; Manjunath et al., 2011; Kane et al., 2012; Bera and Chakrabarti, 2017) can be also applied to a bipartite graph stream, and we compare with such prior work. Note that these algorithms do not use the additional structure in a bipartite graph (absence of edges between vertices in the same partition), and are thus naturally disadvantageous for bipartite streams. Bordino et al. (Bordino et al., 2008) present three-pass algorithms for counting 4-cycles, while we focus on single-pass streaming algorithms. Buriol et al. (Buriol et al., 2007) consider 3,3-biclique counting from a stream. They assume the incidence stream model, where edges in the graph stream are presented in a specific order such that all edges incident to a given vertex arrive together, whereas we assume the more general model where edges can arrive in an arbitrary order. Bera and Chakrabarti (Bera and Chakrabarti, 2017) present algorithms for counting 4-cycles in a graph using two passes through the stream. The work of Ahmed et al. (Ahmed et al., 2017) can be specialized to count butterflies in a stream, and we present an experimental comparison with (Ahmed et al., 2017; Bera and Chakrabarti, 2017) in Section 6. Other works include Manjunath et al. (Manjunath et al., 2011) and Kane et al. (Kane et al., 2012) for subgraph counting based on graph sketches.

Lower Bounds for Subgraph Counting. There are multiple prior works on memory (space) lower bounds for triangle and subgraph counting in general graphs (Bera and Chakrabarti, 2017; Z. Bar-Yossef and Sivakumar, 2002; Cormode and Jowhari, 2017; Braverman et al., 2013), but not for subgraph counting in bipartite graphs. Since a bipartite graph is more restrictive than a general graph (certain edges are disallowed), lower bounds for unipartite graphs do not directly apply to bipartite graphs. To the best of our knowledge, our work presents the first lower bounds for subgraph counting in bipartite graph streams.

2. Preliminaries

We consider simple unweighted and undirected bipartite graphs, without multiple edges between the same pair of vertices. Let $G=(V,E)$ be a bipartite graph with vertices $V$ and edges $E$. The vertex set $V$ of $G$ is partitioned into two disjoint sets $L$ and $R$. The edge set $E\subseteq L\times R$, so each edge $e$ connects one vertex in set $L$ and the other in set $R$. A butterfly is subgraph on four vertices $\{a,b,x,y\}\subset V$, where $a,b\in L$ and $x,y\in R$ such that edges $(a,x),(a,y),(b,x)$ and $(b,y)$ exist in the edge set $E$ (see Figure 1).

A graph stream is a sequence of edges $\mathcal{S}=e_{1},e_{2},\ldots$ where $e_{i}$ is the $i$-th edge in the stream. For $t>0$, let $\mathcal{S}^{t}$ denote the first $t$ edges of the stream and let $G^{t}=(V^{t},E^{t})$ denote the graph formed by the first $t$ edges, i.e., $G^{t}=\{e_{1},e_{2},\ldots,e_{t}\}$. Let \raisebox{0.0pt}{\mathbin{\text{\scalebox{1.18}[0.7]{\rotatebox[origin={c}]{90.0}{{\small$\bowtie$}}}}}}^{t}(G) denote the set of all butterflies in the graph $G^{t}$ and let \xi^{t}(G)=|\raisebox{0.0pt}{\mathbin{\text{\scalebox{1.18}[0.7]{\rotatebox[origin={c}]{90.0}{{\small$\bowtie$}}}}}}^{t}(G)| denote the number of butterflies in $G^{t}$. When $G$ is clear from the context, we use notations \raisebox{0.0pt}{\mathbin{\text{\scalebox{1.18}[0.7]{\rotatebox[origin={c}]{90.0}{{\small$\bowtie$}}}}}}^{t},\xi^{t}, and when both $G$ and $t$ are clear from the context, we use \raisebox{0.0pt}{\mathbin{\text{\scalebox{1.18}[0.7]{\rotatebox[origin={c}]{90.0}{{\small$\bowtie$}}}}}},\xi. Figure 2 shows the setup for processing a stream of edges from a bipartite network. We consider the following settings.

Infinite Window: For any $t>0$ and a stream $\mathcal{S}$, the goal is to continuously maintain (an estimate of) $\xi^{t}$, the number of butterflies in the graph $G^{t}$, as $t$ changes.

Sliding Window: For a window size parameter $W$, a sequence-based sliding window is defined as the set of $W$ most recent edges. For $t\geq W$, when edge $e_{t}$ is observed, the sliding window consists of edges $e_{t-W+1},e_{t-W+2},\ldots e_{t}$. For $t<W$, the window consists of the entire stream so far. The goal is to continuously maintain an estimate of the number of butterflies in the graph defined by the sliding window. We also consider time-based sliding window, a generalization of sequence-based window, defined as the set of edges whose timestamps are the most recent. In a time-based window, the window size does not correspond to a specific number of edges, but instead to a range of timestamps.

Our randomized algorithms solely rely on randomness internal to the algorithm, and do not assume that the input is drawn from a specific probability distribution. The input graph stream, including the set of edges and their order of arrivals, could be generated by an adversary. In our space complexity analysis, we assume that a single edge from the graph and an edge timestamp can be stored in a constant number of words. Let $[n]$ denote the set $\{1,2,3,\ldots,n\}$.

3. Space Lower Bound

We show that it is impossible for any streaming algorithm to approximate the number of butterflies to within a small relative error using $o(n^{2})$ space. This shows that one cannot expect an algorithm that always returns an accurate estimate using fixed space. In fact, the lower bound shows that essentially, the entire graph needs to be stored (which is possible in $\Theta(n^{2})$ bits), if one desires an algorithm that always returns an accurate estimate of the number of butterflies in a bipartite graph stream. Note that our lower bound applies to randomized as well as deterministic algorithms, and for algorithms that return either exact or approximate answers. Note that this lower bound is based on the space complexity of distinguishing between an edge stream that has zero butterflies and one that has at least butterfly.

Theorem 3.1**.**

For any streaming algorithm $\mathcal{L}$ that estimates $\xi(G)$ for a streaming bipartite graph $G$ on $n$ vertices, there exist input graph streams on which the algorithm uses memory $\Omega(n^{2})$ bits.

The proof uses a reduction from a one-round communication complexity problem, where there are two parties Alice and Bob. Alice gets input $a\in A$ and Bob gets input $b\in B$. It is required to compute a function $g(a,b)$ using only one-way communication from Alice to Bob, while communicating as few bits as possible. $g$ may be computed approximately, and there may be a failure probability that the approximation error is not achieved. Let the one-round communication complexity of function $g:A\times B\rightarrow Z$ with failure probability $\delta$ be denoted by $R_{\delta}^{1}(g)$.

Consider function $f$ that takes as input $n$ sets $S_{1},S_{2},\ldots,S_{n}$ and two integers $i$ and $j$ where each $S_{k},1\leq k\leq n$ is a subset of $[n]$ of size $n/10$ and $i,j\in[n]$. The function is defined as:

[TABLE]

Inputs $S_{1},S_{2},\ldots,S_{n}$ are given to Alice and inputs $i$ and $j$ are given to Bob. Communication is allowed only from Alice to Bob, and Bob has to return the approximate value of the function. We use the following result from (Z. Bar-Yossef and Sivakumar, 2002).

Lemma 1** **(Bar-Yossef et al. (Z. Bar-Yossef

and Sivakumar, 2002)).

The one round communication complexity of any algorithm for $f$ is lower bounded as follows: for any $0<\delta<1/100$, $R_{\delta}^{1}(f)\geq n^{2}/40$.

• Proof of Theorem 3.1.

Suppose there exists a streaming algorithm $\mathcal{L}$ for estimating the number of butterflies with relative error of $1/2$ with error probability no more than $\delta$, which uses space of $s$ bits. We reduce the one-round distributed computation of $f$ to streaming butterfly counting as follows.

Given her input $S_{1},S_{2},\ldots,S_{n}$, Alice constructs a part of graph $G$ on $4n$ vertices with vertex set $P\cup Q\cup R\cup T$, where $P=\{p_{1},p_{2},\ldots,p_{n}\}$, $Q=\{q_{1},q_{2},\ldots,q_{n}\}$ and similarly $R$ and $T$. She inserts the following edges into the streaming algorithm in any order. First for each $k=1\ldots n$, edges $(p_{k},q_{k})$ and $(q_{k},r_{k})$ are inserted. Next, for each set $S_{k},k=1\ldots n$, and for each $\ell\in S_{k}$, an edge is inserted between $t_{k}$ and $r_{\ell}$. After Alice is done inserting all these edges into $\mathcal{L}$, she transmits the contents of the memory of $\mathcal{L}$ (the entire current state) to Bob, incurring a communication cost of no more than $s$ bits.

Upon receiving the state of $\mathcal{L}$ from Alice, Bob continues running $\mathcal{L}$ by inserting edge $(t_{i},p_{j})$ into the graph $G$. He then queries $\mathcal{L}$ for an approximate count of the number of butterflies in $G$. If the answer is non-zero, then he declares that $f(S_{1},S_{2},\ldots,S_{n},i,j)=1$, and if the answer is zero, then he declares the function to be [math]. Note that if $j\in S_{i}$, then there is an edge $(t_{i},r_{j})$ inserted by Alice. If we further consider edges $(t_{i},p_{j})$ inserted by Bob, and edges $(p_{j},q_{j})$ and $(q_{j},r_{j})$ inserted by Alice, we get a single butterfly in $G$. If $j\not\in S_{i}$ then, it can be verified that there are no butterflies in $G$. Since $\mathcal{L}$ provides a relative error guarantee, it must return a non-zero estimate if the actual number of butterflies is non-zero and an estimate of zero if the actual number of butterflies is zero.

We further note that $G$ is a bipartite graph whose vertex set consists of two partitions, $P\cup R$ and $Q\cup T$. It can be verified that there are no edges connecting vertices within a single partition.

Thus, we have reduced the one-round distributed computation of $f$ using $s$ bits of communication to streaming butterfly counting using memory of $s$ bits. Using Lemma 1, we see that $s\geq n^{2}/40$, thus completing the lower bound proof. ∎

4. Infinite Window Streaming

We present streaming algorithms for estimating the number of butterflies over an infinite window, i.e., all edges seen so far. Our randomized algorithms maintain an unbiased estimate of the number of butterflies using a bounded memory of $M$, and provide a trade-off between memory used and the accuracy of the estimate.

4.1. Adaptive Sampling: Fleet1

We use random sampling from the stream of edges. An initial attempt uses Bernoulli Sampling (Bern) with parameter $p,0<p\leq 1$. Each arriving edge is sampled into a reservoir with probability $p$. The number of butterflies among the sampled edges is incrementally maintained, and is multiplied by the appropriate normalization factor, to estimate the number of butterflies in the stream. The disadvantage of Bern is that it requires setting parameter $p$ to the “right value”, which depends on the input itself. If $p$ is too small, the error in estimation can be large, and if $p$ is too large, then the reservoir size can be very large.

Our first algorithm, Fleet1, solves this problem by adaptively setting $p$ throughout the computation, so as to keep the memory bounded by $M$. Initially, $p$ is set to $1$, and all edges are sampled into the reservoir. When the size of the reservoir exceeds $M$, Fleet1 sub-samples by retaining each edge in the current reservoir with a probability $\gamma$. Further edges are sampled with probability $\gamma$. When the size of the reservoir again exceeds $M$, the same process is repeated, and further edges are sampled with probability $\gamma^{2}$, and so on. The size of the reservoir never exceeds $M$ edges, and is at least $\gamma M$, with high probability, except during the initial stages of the stream. Fleet1 also continuously maintains the number of butterflies among sampled edges. When an estimate is desired, the number of butterflies among the sampled edges is returned, after multiplying by the appropriate normalization factor.

Details are presented in Algorithm 1. Each time the reservoir is sub-sampled, Fleet1 uses an (exact) algorithm to compute $\xi(\mathcal{R})$, the number of butterflies in the reservoir using prior methods designed for a static graph, such as(Sanei-Mehri et al., 2018; Zhu et al., 2018). Fleet1 also uses an algorithm $\textsc{BFC-edge}(e,E)$ to count the number of butterflies that contain edge $e$ in the graph induced by edge set $E$. This can be achieved using prior work such as (Sanei-Mehri et al., 2018). For the purposes of the current discussion, the reader can assume that parameter $\gamma$ is set to $1/2$ – the main advantages of our algorithm, including bounded sample size and provable accuracy still hold. A modest tradeoff between accuracy and runtime can be obtained by setting $\gamma$ to other values between $1/2$ and $1$, as we discuss further in Section 6.3. Lemma 2 shows that Fleet1 maintains an unbiased estimate of the butterfly count after observing each edge. Let $Y_{\textsc{Fleet1}}^{t}$ denote the estimate of $\xi^{t}$ returned by Algorithm 1 (Algorithm 1) at time $t$.

Lemma 2**.**

$E[Y_{\textsc{Fleet1}}^{t}]=\xi^{t}$

• Proof.

Suppose the butterflies in \raisebox{0.0pt}{\mathbin{\text{\scalebox{1.18}[0.7]{\rotatebox[origin={c}]{90.0}{{\small$\bowtie$}}}}}}^{t} are numbered from $1$ to $\xi^{t}$. Let $X_{i}^{t}(1\leq i\leq\xi^{t})$ be a random variable equal to $1$ if all edges of the $i^{\text{th}}$ butterfly appear in $\mathcal{R}$, and [math] otherwise. Let $X^{t}=\sum_{i=1}^{\xi^{t}}{X_{i}^{t}}$. From Algorithm 1 of Algorithm 1, we have $Y_{\textsc{Fleet1}}^{t}=X^{t}\left(p^{t}\right)^{-4}$. When $t\leq M$, all edges of the stream are sampled, and $X^{t}=\xi^{t}$. When $t>M$, each edge appears in $\mathcal{R}$ with probability $p^{t}$. Note that $p^{t}$ itself is a random variable equal to the sampling probability of an incoming edge at time $t$. To compute $\mathbb{E}[Y_{\textsc{Fleet1}}^{t}]$, we first condition on $p^{t}$ and then remove the conditioning.

Since there are four edges in a butterfly, \mathbb{E}\left[X_{i}^{t}\bigm{|}p^{t}\right]=\left(p^{t}\right)^{4}. With linearity of expectation, \mathbb{E}\left[X^{t}\bigm{|}p^{t}\right]=\sum_{i=1}^{\xi^{t}}{\mathbb{E}\left[X_{i}^{t}\bigm{|}p^{t}\right]}=\xi^{t}\left(p^{t}\right)^{4}. Then, \mathbb{E}\left[Y_{\textsc{Fleet1}}^{t}\bigm{|}p^{t}\right]=\mathbb{E}\left[X^{t}\left(p^{t}\right)^{-4}\bigm{|}p^{t}\right]=\xi^{t}. By conditional expectation, \mathbb{E}\left[Y_{\textsc{Fleet1}}^{t}\right]=\mathbb{E}\left[\mathbb{E}\left[Y_{\textsc{Fleet1}}^{t}\bigm{|}p^{t}\right]\right]=\xi^{t}. ∎

Concentration analysis of $Y_{\textsc{Fleet1}}^{t}$: We next show that if the upper bound on the reservoir size ($M$) is large enough, then the estimate $Y_{\textsc{Fleet1}}^{t}$ will be concentrated around its expectation, i.e., have a small relative error, with a high probability. There are a few complexities to deal with here. First, the sampling probability $p^{t}$ is itself a random variable, since it is the result a random process. We first analyze a simpler algorithm $\textsc{Bern}(p)$ that is based on fixed sampling probability $p$, which we have explained earlier. After $t$ edges, let $Z_{p}^{t}$ denote the estimate computed by $\textsc{Bern}(p)$, of $\xi(G^{t})$, the number of butterflies in $G^{t}$. Lemma 3 shows a concentration bound for $Z_{p}^{t}$. The difficulty with analyzing $Z_{p}^{t}$ is in handling the dependency between random variables corresponding to different butterflies being sampled into the reservoir. Though different edges are sampled independently by $\textsc{Bern}(p)$, different butterflies are not necessarily independent since butterflies may share edges. We address this with the help of the Hajnal-Szemerédi theorem, building on ideas from prior works (Stefani et al., 2017; Pagh and Tsourakakis, 2012; Kolountzakis et al., 2012) all of who applied this idea in the context of triangle counting.

Lemma 3**.**

After $t$ edges, let $h^{t}$ denote the maximum number of butterflies in $G^{t}$ that an edge can be part of. For a fixed $p$, and for any $\epsilon\in(0,1)$, we have ${\Pr}\left[\left|Z_{p}^{t}-\xi^{t}\right|\geq\epsilon\xi^{t}\right]\leq 8h^{t}\cdot exp\left(-\frac{\epsilon^{2}\xi^{t}p^{4}}{12h^{t}}\right)$

• Proof.

Consider a new graph $H^{t}=(V_{H^{t}},E_{H^{t}})$ constructed from $G^{t}$: each vertex $v\in V_{H^{t}}$ corresponds to a butterfly in $G^{t}$. For each pair of butterflies $u,v\in V_{H^{t}}$ that share at least one edge, there is an edge in $E_{H^{t}}$. Since each edge in $G^{t}$ can be shared by at most $h^{t}$ butterflies, the maximum degree of vertex $u\in V_{H^{t}}$ is $(4h^{t}-4)$. Using the Hajnal-Szemerédi theorem (Hajnal and Szemerédi, 1970), there exists an equitable coloring of $H^{t}$ with at most $(4h^{t}-3)$ colors. Let the colors be numbered as $\{1,2,\ldots,4h^{t}-3\}$. For each butterfly $i\in V_{H^{t}}$, let random variable $X_{i}$ be defined as: $X_{i}=1$ if all edges of butterfly $i$ are sampled by Bern at time $t$, and [math] otherwise. Let the set of butterflies assigned color $j$ be denoted by $C_{j}$. For two butterflies $a,b\in C_{j}$, note that $X_{a}$ and $X_{b}$ are independent, since $a$ and $b$ do not share edges, and all their edges are sampled independently. Define $Y_{j}=\sum_{i\in C_{j}}X_{i}$. Note that $Y_{j}$ is a Binomial random variable since it is the sum of independent 0-1 random variables. We have $\mathbb{E}[Y_{j}]=|C_{j}|\cdot p^{4}$ and $|C_{j}|>\xi^{t}/4h^{t}$, since the coloring of vertices in $V_{H^{t}}$ is an equitable coloring. Using the Chernoff bound, ${\Pr}\left[\left|Y_{j}-|C_{j}|\cdot p^{4}\right|\geq\epsilon\cdot|C_{j}|\cdot p^{4}\right]\leq 2\exp\left(-\frac{\epsilon^{2}}{3}\cdot\frac{\xi^{t}}{4h^{t}}\cdot p^{4}\right)$

Using the union bound,

${\Pr}\left[|Z_{p}^{t}-\xi^{t}|\geq\epsilon\xi^{t}\right]={\Pr}\left[\left|\sum_{j=1}^{4h^{t}-3}Y_{j}\cdot p^{-4}-\sum_{j=1}^{4h^{t}-3}|C_{j}|\right|\geq\epsilon\sum_{j=1}^{4h^{t}-3}|C_{j}|\right]$

$\leq\sum_{j=1}^{4h^{t}-3}{\Pr}\left[|Y_{j}\cdot p^{-4}-|C_{j}||\geq\epsilon|C_{j}|)\right]\leq 8h^{t}\cdot exp\left(-\frac{\epsilon^{2}\xi^{t}p^{4}}{12h^{t}}\right)$ ∎

We next derive a concentration result for Fleet1. Fleet1 essentially returns the estimate due to $\textsc{Bern}(p^{t})$ where $p^{t}$ is itself a random variable. While it is possible to compute the expected value of $p^{t}$, this cannot be directly plugged into the Lemma 3. Lemma 4 shows that for a large enough reservoir size, Fleet1 returns an estimate that is concentrated around its expectation. The proof considers multiple $\textsc{Bern}(p)$ instances, one for each sampling probability, and combines with the event of Fleet1 stopping at one of these levels.

Lemma 4**.**

Assume $\gamma\leq 0.9$. For any $\epsilon,\delta\in(0,1)$, when $M$ satisfies $M\geq 6t\cdot\sqrt[4]{\frac{12h^{t}}{\epsilon^{2}\xi^{t}}\cdot\ln\frac{8h^{t}(4+\delta)}{\delta}}$ then ${\Pr}\left[\left|Y_{\textsc{Fleet1}}^{t}-\xi^{t}\right|\geq\epsilon\xi^{t}\right]\leq\delta$.

• Proof.

Note that the sampling rate of Fleet1 is $\gamma^{i}$ for $i\geq 0$. We say that Fleet1 is at level $i$ when the sampling rate is $\gamma^{i}$. For $i\in[0,+\infty)$, define events $S_{i}$ and $B_{i}$ as follows. Event $B_{i}$: Suppose that we execute algorithm $\textsc{Bern}(\gamma^{i})$, and we have $\left|Z_{\gamma^{i}}^{t}-\xi^{t}\right|\geq\epsilon\xi^{t}$. $S_{i}$ is the event that Fleet1 stops at level $i$.

Define event $B$: $\left|Y_{\textsc{Fleet1}}^{t}-\xi^{t}\right|\geq\epsilon\xi^{t}$. We decompose the probability of event $B$ in terms of $B_{i}$ and $S_{i}$.

[TABLE]

where $\ell=\frac{\log(M/6t)}{\log\gamma}$. The sampling probability at level $i$ is $\gamma^{i}$, by Lemma 3 we have $\sum_{i=0}^{\ell}{\Pr}\left[B_{i}\right]=\sum_{i=0}^{\ell}8h^{t}\cdot exp\left(-\frac{\epsilon^{2}\xi^{t}\gamma^{4i}}{12h^{t}}\right)=\sum_{i=0}^{\ell}\alpha^{\left(\gamma^{-4i}\right)}$ where $\alpha=8h^{t}\cdot exp\left(-\frac{\epsilon^{2}\xi^{t}\gamma^{4\ell}}{12h^{t}}\right)$ and $\alpha<1$.

When $\gamma\leq 0.9$, $\gamma^{-4}>e^{1/e}$, we have $\gamma^{-4i}\geq i$ for any $i\geq 1$. Applying this fact, and using the bound on $M$ we get: $\sum_{i=0}^{\ell}\alpha^{\left(\gamma^{-4i}\right)}\leq\alpha+\sum_{i=1}^{\ell}\alpha^{i}\leq\frac{2\alpha}{1-\alpha}\leq\frac{\delta}{2}$

Let $X_{\ell}$ denote the number of edges in $\mathcal{R}$ when Fleet1 is at level $\ell$. Note that the event Fleet1 stops at level higher than $\ell$ is equivalent to the event that $X_{\ell}$ is greater than the reservoir size $M$. By $\mathbb{E}[X_{\ell}]=t\cdot\gamma^{\ell}$ and Chernoff bound, we have $\sum_{i=\ell+1}^{\infty}{\Pr}\left[S_{i}\right]=\,{\Pr}\left[X_{\ell}>M\right]\leq{\Pr}\left[X_{\ell}>6\cdot\mathbb{E}[X_{\ell}]\right]\leq\frac{\delta}{2}.$ Combining the above bounds, we arrive at ${\Pr}\left[B\right]\leq\delta$. ∎

4.2. Improved Adaptive: Fleet2 and Fleet3

We present two algorithms Fleet2 and Fleet3 which improve upon Fleet1, providing a better memory-accuracy tradeoff. Fleet2 is similar to Fleet1, but handles sub-sampling differently. Say Fleet1 is at “level $i$” when its sampling probability is $\gamma^{i}$. In Fleet1, each time the level changes from $i$ to $(i+1)$, edges are discarded according to a random process, and the number of butterflies is recomputed on the new reservoir from scratch (Algorithm 1 of Algorithm 1, shown in pink color). Due to this re-computation, butterflies that were already detected at the higher sampling rate (level $i$) may no longer have all their edges present at the lower sampling rate (level $(i+1)$). In contrast, Fleet2 does not recompute when the reservoir is sub-sampled. Instead, the current butterfly count at level $i$ is maintained, and as more butterflies are detected at level $i+1$, they are accumulated into this estimate. It can be expected that Fleet2 obtains a better accuracy than Fleet1, since it “catches” more butterflies than Fleet1. It is easy to see that the estimation of Fleet2 is unbiased. In addition to better accuracy, Fleet2 is also slightly faster than Fleet1, since it avoids recomputation of butterflies at the sub-sampling step.

Fleet3 (described in Algorithm 2) improves accuracy over Fleet1 and Fleet2 by handling new edges differently. This idea is inspired by Algorithm MASCOT of (Lim and Kang, 2015), which used the idea in the context of counting triangles from a graph stream (the same idea is also used in (Stefani et al., 2017)). Upon receiving a new edge, the estimate is updated by accounting for butterflies that are created by the new edge (and existing sampled edges), even before deciding whether or not to sample the new edge (see Algorithm 2). In other words, Fleet3 first updates the estimate and then samples. If the current edge sampling probability is $p$, then the probability of detecting a butterfly involving the new edge increases from $p^{4}$ (in Fleet1) to $p^{3}$ (in Fleet3). This helps increase the accuracy of butterfly counting while using the same memory. Algorithm 2 has further details. We omit further details and proofs, due to space constraints.

Comments:

Instead of Bernoulli sampling, we could also use reservoir sampling of edges as the basis. We took the route of Bernoulli sampling to simplify the analysis, since it leads to edges being sampled independent of each other (given a sampling probability), unlike reservoir sampling, where the sampling of edges are not independent events. Our initial implementations of algorithms based on reservoir sampling without replacement, showed that the accuracy-memory tradeoffs were similar to that of our current algorithms.

We can also achieve estimates of per-vertex butterfly counts (the number of butterflies that each vertex is a part of) using a similar sampling approach of estimating per-vertex subgraph counts from the reservoir, and maintaining additional state for each vertex. A detailed study of local butterfly counting is a goal for future work.

5. Sliding Window Streaming

In this section, we consider butterfly counting in two types of sliding window models: sequence-based and time-based. We assume the number of edges in a window is (much) greater than the available memory $M$ – otherwise, the entire window can be stored within memory and an exact algorithm can be applied.

5.1. Sequence-based Window (FleetSSW)

We first present FleetSSW for sequence-based sliding window (Algorithm 3), which is based on maintaining a sample of edges from within the sliding window. In the initial stages of observation, all edges fit in memory, and as more edges are observed, we recursively decrease the sampling probability as in Fleet1, to ensure that the sample fits in memory. However, once the number of edges in a window reaches $W$, it will stay at $W$ henceforth. As a result, when the edge sampling probability $p$ reaches $M/W$, the algorithm does not decrease $p$ any further holds it at $M/W$111For simplicity of exposition, we assume $M/W$ is a power of $\gamma$.. The algorithm stores only active edges in the sample, i.e., any item $(e,t^{\prime})$ such that $t^{\prime}$ is not within the current window is discarded.

Let $Y_{\mathrm{\small sw}}^{t}$ denote an estimate returned by Algorithm 3, of $\xi^{t}_{W}$, the number of butterflies in the window at time $t$.

Lemma 5**.**

The space of $\mathcal{R}$ in Algorithm 3 is no greater than $M$ in expectation and $\Pr(|\mathcal{R}|\geq 2M)\leq\left(\frac{e}{4}\right)^{M}$. $Y_{\mathrm{\small sw}}^{t}$ is an unbiased estimate of $\xi^{t}_{W}$. For parameters $0<\epsilon<1$ and $0<\delta<1$, when $M\geq 6W\cdot\sqrt[4]{\frac{12h^{t}}{\epsilon^{2}\xi^{t}_{W}}\cdot\ln\frac{8h^{t}(4+\delta)}{\delta}}$, then ${\Pr}\left[\left|Y_{\mathrm{\small sw}}^{t}-\xi^{t}_{W}\right|\geq\epsilon\xi^{t}_{W}\right]\leq\delta$.

• Proof.

We sketch the proof ideas and omit details, due to space constraints. For the space complexity, note that when $p>M/W$, the algorithm runs Fleet1 and its space is strictly bounded by $M$. Otherwise, $p=M/W$ and the number of edges in the sample is a binomial random variable with parameters $W$ and $M/W$, and the space bounds follow using Chernoff bounds.

At any given time, each edge currently in the window is sampled into $\mathcal{R}$ with probability $p$, and $\mathbb{E}\left[Y_{\mathrm{\small sw}}^{t}\right]=\xi^{t}_{W}\cdot p^{4}$.When $p>(M/W)$, we apply results from Fleet1 for expectation (Lemma 2) and concentration (Lemma 4) to show the corresponding properties of $Y_{\mathrm{\small sw}}^{t}$.

When $p=(M/W)$, we rely on an analysis similar to Algorithm Bern in Lemma 3 and derive the concentration result that ${\Pr}\left[\left|Y_{\mathrm{\small sw}}^{t}-\xi^{t}_{W}\right|\geq\epsilon\xi^{t}_{W}\right]\leq 8h^{t}\cdot exp\left(-\frac{\epsilon^{2}\xi^{t}_{W}}{12h^{t}}\cdot\left(\frac{M}{W}\right)^{4}\right)\leq\delta.$ ∎

5.2. Time-based Sliding Window (FleetTSW)

We next consider the case of a time-based sliding window, where each element has an associated timestamp, and the window at time $t$ consists of all elements with timestamps greater than $(t-W)$, where $W$ is a specified window size. Handling a time-based sliding window is more challenging than a sequence-based window since the number of elements within a time-based window can grow and shrink with time. The sequence-based window can be seen as a special case of time-based window such that at each time, exactly one edge arrives in the stream.

FleetTSW (Algorithm 4), our algorithm for time-based sliding window, can estimate the number of butterflies when the window size $W$ is provided at query time. We assume an upper bound $n_{max}$ number of edges within a window. Let $T=\lceil 1+\log_{\gamma}\frac{M}{n_{max}}\rceil$. FleetTSW is based on maintaining not only a single sample, as in FleetSSW or Fleet1, but $T$ reservoirs $\mathcal{R}_{i},i=0,1,2,\ldots$, at different sampling rates. Every edge is sampled into $\mathcal{R}_{0}$. For $i>0$, each edge that was sampled into $\mathcal{R}_{i-1}$ is sampled into $\mathcal{R}_{i}$ with probability $\gamma$. Each reservoir has a capacity of $M^{\prime}=M/T$ edges, and contains the most recent edges sampled into the reservoir. Each $\mathcal{R}_{i}$ is stored as a first-in-first-out queue, so that if a new edge enters when the queue is full, the edge with the earliest timestamp is deleted.

Lemma 6**.**

$Y_{\mathrm{\small tw}}^{t}$ is an unbiased estimate of $\xi^{t}_{W}$. If

$M\in\Omega\left(\log_{\gamma}\frac{M}{n_{\max}}\sqrt[4]{\frac{n^{4}_{\max}h^{t}}{\epsilon^{2}\xi^{t}_{W}}\ln\frac{h^{t}}{\delta}}\right)$, so ${\Pr}\left[|Y_{\mathrm{\small tw}}^{t}-\xi^{t}_{W}|\geq\epsilon\xi^{t}_{W}\right]\leq\delta$.

• Proof.

At query time $t$, when presented with a window size $W$, let $G_{W}^{t}$ denote the graph consisting of all edges that have timestamps in $[t-W+1,t]$. For level $\ell\in\{0,1,2,\ldots\}$, let $G_{W}^{t}(\ell)$ be defined inductively as follows. $G_{W}^{t}(0)=G_{W}^{t}$. For $i\geq 0$, $G_{W}^{t}(i+1)$ is derived from $G_{W}^{t}(i)$ by choosing each edge in $G_{W}^{t}(i)$ with probability $\gamma$. We note that in Algorithm 4, $\mathcal{R}_{i}$ contains the $M/T$ most recent elements from $G_{W}^{t}(i)$. Further, when a query arrives at time $t$, the algorithm uses $\mathcal{R}_{\ell_{*}}$ such that $\ell_{*}$ is the smallest value, where $G_{W}^{t}(\ell_{*})$ is completely contained in $\mathcal{R}_{\ell_{*}}$.

Let $Z_{W}^{t}(i)$ denote the estimate of $\xi(G_{W}^{t})$ derived from $\mathcal{R}_{i}$. Similar to the proof of Lemma 4, we define: event $S_{i}$ is the event that the algorithm chooses $\mathcal{R}_{i}$ to answer the sliding window query, and $B_{i}$ is the event that the estimate $Z_{W}^{t}(i)$ has a relative error that is greater than $\epsilon$. The probability that the algorithm fails to return an estimate that has a relative error within $\epsilon$ is given by ${\Pr}\left[B\right]=\sum_{i=0}^{\infty}{\Pr}\left[S_{i}\wedge B_{i}\right]$. Using an argument similar to the proof of Lemma 4, we arrive at the result. ∎

6. Experimental Evaluation

We experimentally evaluate the infinite window and sliding window algorithms on real-world temporal bipartite networks with hundreds of millions of edges from a variety of domains, such as social, web, and rating networks.

Networks and experimental setup: We used five real-world temporal bipartite networks from the publicly available KONECT repository (Kunegis, 2013), summarized in Table 1.222http://konect.uni-koblenz.de/ Movie-lens is the ratings by users for movies. Edit-frwiki is a bipartite network of editors and pages of the French Wikipedia where each edge represents an edit. Edit-enwiki is the English version of Edit-frwiki. Yahoo-song is a ratings by users for songs. Bag-pubmed is a word-document bipartite network. Note that Bag-pubmed is not a temporal network, and we generated a stream by randomly permuting the edge set of Bag-pubmed. Edit-frwiki, Edit-enwiki, and Bag-pubmed had multiple edges between the same node pairs, and we only considered the first interaction. Edges are read from the stream in the order of timestamps. Figure 3 shows the number of butterflies as a function of stream size.

All streaming algorithms were implemented in C++ and compiled with g++ compiler using -O3 as the optimization level. The source code is publicly available at (src, 2019). We run the experiments on a machine equipped with a 2.0 GHz 16-Core Intel E5 2650 processor and 128GB of memory.

6.1. Accuracy

If the true value of the butterfly count is $x>0$, then the relative error of an estimate $\hat{x}$ is defined as $|x-\hat{x}|/x$ and is usually shown as percent error. We also used MAPE (Mean Average Percentage Error) to measure the accuracy over the entire stream, defined as the average of the relative error, taken over the entire stream.

Figure 4 shows the accuracy on the entire stream vs the reservoir size. Larger reservoirs yield better accuracies, as expected. Fleet3 can keep the estimation error around $1\%$ for all networks by storing only $600$K edges in the reservoir. This corresponds to $6\%$, $2.7\%$, $0.49\%$, $0.23\%$, and $0.12\%$ of the total stream sizes for Movie-lens, Edit-frwiki, Edit-enwiki, Yahoo-song, and Bag-pubmed, respectively. When the reservoir size is $300$K, Fleet3 yields $3\%$ error for Edit-enwiki and Bag-pubmed and less than $1\%$ for other networks. As expected Fleet2 has better accuracy than Fleet1, and Fleet3 has the best accuracy.

Figure 5 shows the relative error at different points in the stream, for a fixed reservoir size. As the stream size increases, the error of Fleet1 and Fleet2 increase slightly. This can be attributed to the fact that the edge sampling probability $p$ is proportional to $1/t$, where $t$ is the number of edges, and from Lemma 3, the probability of a given relative error decreases with $p^{4}\xi^{t}$. Unless $\xi^{t}$ increases as the fourth power of $t$, the probability of a given relative error increases with the stream size.

Butterfly Density: We note the errors of Fleet1 and Fleet2 for a given reservoir size are roughly correlated with the butterfly density ($\xi^{t}/t^{4}$ where $t$ is the number of edges). One reason is as follows. Following Lemma 3, the probability of a high relative error decreases with $p^{4}\xi^{t}$. Setting $p\approx M/t$ where $M$ is the reservoir size, this is $M^{4}$ times the butterfly density $\frac{\xi^{t}}{t^{4}}$, showing that the error probability decreases quickly as the butterfly density increases. When the networks are ordered according to increasing butterfly density, we get the order Bag-pubmed, Edit-enwiki, Yahoo-song, Edit-frwiki, and Movie-lens. We note that for the same reservoir size, this is exactly the increasing order of accuracy (decreasing order or error) for algorithms Fleet1 and Fleet2 (Figure 5). The trend is not so clear for algorithm Fleet3, since its accuracy depends heavily on the temporal order of the edges within a butterfly.

6.2. Runtime and Throughput

The better accuracy of Fleet3 comes at the cost of increased runtime. From Figure 6, we see Fleet3 has the lowest throughput (number of edges processed per second), while Fleet1 and Fleet2 have similar throughputs. The reason is there is one per-edge butterfly computation for each arriving edge in Fleet3, where as there is one such computation only for each sampled edge in Fleet1 and Fleet2. The throughput decreases as the reservoir size increases, due to the increased cost of per-edge butterfly counting on the reservoir. Fleet3 is able to achieve quite a high throughput, e.g. $6.2\times 10^{5}$ edges per second on graph Bag-pubmed with reservoir size $150$K, making it suitable for practical scenarios. Fleet2 always has a slightly higher throughput than Fleet1. Overall, Fleet3 has the best accuracy with a good throughput, while Fleet2 trades a lower accuracy for a higher throughput.

6.3. Impact of $\gamma$ on runtime and accuracy

Figures 7a and 7b show the accuracy as a function of $\gamma$. As $\gamma$ increases, the average size of the reservoir increases, while the frequency of sub-sampling also increases. The accuracies of Fleet1 and Fleet2 improve slightly as $\gamma$ increases from $0.5$ to $0.9$ e.g. for graph Yahoo-song. In contrast, from Figures 7c and 7d, the runtime increases for all estimators as $\gamma$ increases. A value of $\gamma$ of about 0.7 seems to be a good “middle ground” since it achieves nearly the best throughput as well as accuracy.

6.4. Comparison with prior work

In this section, we present a comparison between our methods and prior works, including (Ahmed et al., 2017; Manjunath et al., 2011; Kane et al., 2012; Bera and Chakrabarti, 2017).

Table 2 presents a comparison with methods: Graph Priority Sampling (GPS)(Ahmed et al., 2017) and the work of Bera and Chakrabarti (BC) (Algorithm 1 from Section 3.1 of (Bera and Chakrabarti, 2017)) for a reservoir size of $150K$ (we found similar results for other reservoir sizes, ranging from $75$K to $600K$). GPS is a subgraph counting algorithm based on a weighted sample of edges, which we specialized for the case of butterfly estimation. We observe that Fleet3 significantly outperforms GPS on all networks, and Fleet1 and Fleet2 outperform GPS on all networks except Bag-pubmed. Since GPS stores additional information for each edge (weight and rank – see (Ahmed et al., 2017) for details), we stored $75K$ edges in the reservoir for GPS to keep its memory equal to our algorithms. The results were quite similar even if we gave twice the memory to GPS. If we used a sample of $150K$ edges in GPS, its error ranged from 7.78% (Bag-pubmed) to 90% (Movie-lens) still much worse than our algorithms, especially Fleet3.

We compared with BC while holding memory equal, even though BC is a two-pass streaming algorithm, which cannot be modified to work in a single pass, and works under a more powerful computational model than our algorithms. With a reservoir of size $150K$, we could run $75K$ basic estimators of BC, each of which maintained a sample of two edges. On all streams, all of our algorithms outperformed BC by significant margins.

We implemented the algorithm of Manjunath et al. (Manjunath et al., 2011), which estimates the number of cycles in a stream using sketches based on complex random variables. To the best of our knowledge, we are the first to implement this algorithm, and even the authors of (Manjunath et al., 2011) have not provided an implementation. The accuracy of (Manjunath et al., 2011) is very poor – the error of the estimator is more than $100\%$ for both graph streams Yahoo-song and Bag-pubmed, even with a memory of 600K estimators. In addition, we found their algorithm slow and impractical. The reason is that for each arriving edge in a stream, the algorithm needs to update the values of many complex valued sketches, where the number of sketches is as large as the reservoir size. The throughput of (Manjunath et al., 2011) on both graphs is only $5.9$ edges per second, $\approx$ $21K$ edges in one hour, meaning that it is about ${10}^{5}$ times slower than algorithm Fleet3 (see throughput of Fleet3 in Figures 6e and 6c). The algorithms of (Kane et al., 2012) are not practical for handling large graph streams, since they follows a similar structure (this has not been implemented either, to the best of our knowledge).

6.5. Sliding Window

Figure 8 shows the relative error of FleetSSW for window size $W=5$M edges, when the reservoir size is varied from $1\%$ to $5\%$ of $W$. The accuracy improves as the reservoir size increases; when $M$ is $5\%$ of the window size, the relative error is always under $5\%$. The number of butterflies within a window ranges from $5\times 10^{10}$ to $10^{11}$ for Movie-lens and $1\times 10^{10}$ to $6\times 10^{10}$ for Yahoo-song. We also experimented with FleetTSW for time-based windows. We used $30$ queries, and a window size is randomly generated at query time. When the reservoir size $M$ is $10\%$ of the stream size, the average relative error over the queries is $2.55\%$ for movie, $5.52\%$ for Edit-frwiki and $6.32\%$ for Edit-enwiki. This result shows FleetTSW can achieve good accuracy using memory much smaller than the whole stream.

7. Conclusion

We presented a lower bound as well as one-pass streaming algorithms for estimating the number of butterflies from a bipartite graph stream. While our lower bound rules out space-efficient algorithms that are accurate on all graph streams, it leaves open the possibility of space-efficient algorithms for graph streams where the number of butterflies is large, such as in every real-world graph stream that we tried. Our algorithms Fleet1, Fleet2, and Fleet3 are based on adaptive random sampling from the graph stream, achieve high accuracy on real-world streams, and are backed by rigorous theoretical guarantees. We also presented algorithms FleetSSW and FleetTSW for sequence-based and time-based sliding windows respectively. This work is one of the first to explore streaming motif counting on bipartite graphs, and leads to many follow-up questions. (1) Extensions to general motif counting on bipartite graph streams (2) Can we combine the benefits of improved accuracy as in Fleet3 with the faster runtime of Fleet2? (3) Algorithms for multi-pass and external memory models.

8. Acknowledgment

The work of SS, YZ, and ST is supported in part by the National Science Foundation through grants 1527541 and 1725702.