A Fast Sketch Method for Mining User Similarities over Fully Dynamic Graph Streams

TL;DR

This paper introduces VOS, a fast and accurate sketching method for estimating user similarities in fully dynamic graph streams, addressing the bias issues of existing static graph methods.

Contribution

The paper proposes VOS, a novel sketching technique that processes dynamic graph streams efficiently and accurately estimates user similarities over time.

Findings

VOS processes each edge with O(1) time complexity.

VOS uses small memory to build compact graph sketches.

Experimental results show VOS's high efficiency and accuracy.

Abstract

Many real-world networks such as Twitter and YouTube are given as fully dynamic graph streams represented as sequences of edge insertions and deletions. (e.g., users can subscribe and unsubscribe to channels on YouTube). Existing similarity estimation methods such as MinHash and OPH are customized to static graphs. We observe that they are indeed sampling methods and exhibit a sampling bias when applied to fully dynamic graph streams, which results in large estimation errors. To solve this challenge, we develop a fast and accurate sketch method VOS. VOS processes each edge in the graph stream of interest with small time complexity O(1) and uses small memory space to build a compact sketch of the dynamic graph stream over time. Based on the sketch built on-the-fly, we develop a method to estimate user similarities over time. We conduct extensive experiments and the experimental results demonstrate the efficiency and efficacy of our method.

Equations

$$\begin{array}{rl}\text{E}({\alpha }_{u,v}^{(t)})& =\frac{\text{E}\left({\sum }_{j=1}^k\text{1}({\hat{O}}_{u,v}^{(t)}[j]=1)\right)}{k}\\ & \approx \frac{1-(1-2{\beta }^{(t)}{)}^2{e}^{-2n_{u\Delta v}^{(t)}/k}}{2}.\end{array}$$

$${\hat{n}}_{u\Delta v}^{(t)}=-\frac{k(\ln (1-2{\alpha }_{u,v}^{(t)})-2\ln (1-2{\beta }^{(t)}))}{2}.$$

$${\hat{s}}_{u,v}^{(t)}=\frac{n_u^{(t)}+n_v^{(t)}}{2}+\frac{k(\ln (|1-2{\alpha }_{u,v}^{(t)}|)-2\ln (|1-2{\beta }^{(t)}|))}{4}.$$

$$\text{E}({\hat{s}}_{u,v}^{(t)})\approx s_{u,v}^{(t)}+\frac{1}{8}-\frac{k{\beta }^{(t)}{e}^{2n_{u\Delta v}^{(t)}/k}}{(1-2{\beta }^{(t)}{)}^2}-\frac{e^{4n_{u\Delta v}^{(t)}/k}}{8(1-2{\beta }^{(t)}{)}^4},$$

$$\text{Var}({\hat{s}}_{u,v}^{(t)})\approx -\frac{k}{16}+\frac{k^2{\beta }^{(t)}{e}^{2n_{u\Delta v}^{(t)}/k}}{2(1-2{\beta }^{(t)}{)}^2}+\frac{k{e}^{4n_{u\Delta v}^{(t)}/k}}{16(1-2{\beta }^{(t)}{)}^4}.$$

Full text

I Introduction

Many real-world network systems such as online social networks (OSNs) and mobile phone networks are given as graph streams represented as sequences of edges over time, where entities are modeled as nodes and entity relations are modeled as edges. Estimating the similarities of users in large graph streams has been successfully used for applications such as duplicate detection [1] and collaborative filtering [2]. However, the graph streams studied in all these works only consist of edge insertions. In practice, real-world networks contain not only edge insertions but also deletions. For example, users on OSNs such as Twitter and Pinterest can follow other users, and can also unfollow users that they followed previously; users on YouTube can subscribe to interested channels, and can also unsubscribe from channels that they subscribed previously.

For similarity estimation, MinHash [3] is a popular sketch method for approximately computing the Jaccard coefficient similarity, which builds a sketch of $k$ registers with $k$ distinct hash functions for each user and updates the minimum hash values of its subscribed items for each register. To reduce the memory usage of MinHash, [8, 9] develop methods b-bit minwise hashing and odd sketch, and the basic idea behind them is to use probabilistic methods such as sampling and sketching to build a compact digest for each user’s MinHash sketch. b-bit minwise hashing, odd sketch, and MinHash update each item with a high time complexity $O(k)$. To solve this problem, Li et al. [4] further develop a method OPH and use only one hash functions to reduce the time complexity of updating each item from $O(k)$ to $O(1)$. Also there are many other works based on OPH such as [5, 6, 7] to improve its estimation accuracy. In detail, they fill empty registers generated from OPH by “rotation” with the value of the closest non-empty registers towards right [6], left or right with probability $\frac{1}{2}$ [5], or based on tailored 2-universal hashing [7]. [10, 11, 12, 13] develop a fast method to estimate the Jaccard coefficient between weighted vectors, where the general Jaccard coefficient between two positive real value vectors $\vec{x}\!=\!(x_{1},x_{2},\ldots,x_{p})$ and $\vec{y}\!=\!(y_{1},y_{2},\ldots,y_{p})$ is defined as $J(\vec{x},\vec{y})\!=\!\frac{\sum_{1\leq j\leq p}\min(x_{j},y_{j})}{\sum_{1\leq j\leq p}\max(x_{j},y_{j})}$. Unfortunately, all these methods indeed are sampling methods customized for statistic datasets, but fail to uniformly sample edges from fully dynamic graph streams including item-subscriptions and item-unsubscriptions, which results in large estimation errors.

To solve the above challenges, we develop a fast and accurate sketch method VOS (virtual odd sketch) for estimating the similarities of users occurred in fully dynamic graph streams. VOS processes each edge with small time complexity $O(1)$ and uses small memory space to build a compact sketch of the graph stream over time. For each user, we build an odd sketch of its subscribed items on the fly, which is a binary sketch of $k$ bits and embeds each subscribed item with xor (i.e., exclusive-or) operations. In graph streams, it is wasteful to assign a large $k$ for each user to achieve reasonable estimation accuracy, especially for users with few subscribed items. Thus instead of directly keeping the odd sketch in memory, we store the sketch in $k$ bits randomly selected from a shared bit array to reduce the memory usage. Based on the built virtual sketch, we develop a novel method to accurately estimate user similarities, and provide a theoretical proof for the estimation accuracy. We conduct extensive experiments on a variety of real-world graphs, and experimental results show that our method VOS is more accurate than state-of-the-art methods.

II Problem Formulation

In this paper, we focus on bipartite graphs, while our method can be easily extended to regular graphs. Let $U$ and $I$ denote the set of users and items respectively. Let $\Pi\!=\!e^{(1)}e^{(2)}\cdots e^{(t)}\cdots$ denote the graph stream of interest, where $e^{(t)}\!=\!(u^{(t)},i^{(t)},a^{(t)})$ is the element (or, edge) of $\Pi$ occurred at discrete time $t>0$, $u^{(t)}\in U$, $i^{(t)}\in I$, and $a^{(t)}\in\{``+",``-"\}$ are the $t^{\text{th}}$ element’s user, item, and action (i.e., subscription and unsubscription). Let $S_{u}^{(t)}$ be the set of items subscribed by user $u$ at the end of time $t$, $S_{u}^{(0)}=\emptyset$. Similar to [14, 15], we restrict attention to “feasible” fully dynamic graph steams. In detail, if item $i$ is in (resp. not in) the item set $S_{u}^{(t-1)}$ of user $u$, then element $(u,i,``+")$ (resp. element $(u,i,``-")$) cannot occur in stream $\Pi$ at time $t$. Let $s_{u,v}^{(t)}$ denote the number of common items that users $u$ and $v$ subscribe to at time $t$ and is computed as $s_{u,v}^{(t)}\!=\!|S_{u}^{(t)}\cap S_{v}^{(t)}|\!=\!\frac{J(S_{u}^{(t)},S_{v}^{(t)})(|S_{u}^{(t)}|+|S_{v}^{(t)}|)}{J(S_{u}^{(t)},S_{v}^{(t)})+1},$ where $|S|$ refers to the cardinality of a set $S$. One can use a counter to easily keep tracking of the number of items (i.e., $|S_{u}^{(t)}|$) subscribed by each user $u$ over time $t$. Besides, another popular similarity measure the Jaccard coefficient $J(S_{u}^{(t)},S_{v}^{(t)})\!=\!\frac{|S_{u}^{(t)}\cap S_{v}^{(t)}|}{|S_{u}^{(t)}\cup S_{v}^{(t)}|}\!=\!\frac{s_{u,v}^{(t)}}{|S_{u}^{(t)}|+|S_{v}^{(t)}|-s_{u,v}^{(t)}}$ can be easily computed from $s_{u,v}^{(t)}$, and vice versa. In this paper, we aim to develop a fast and accurate method to estimate $s_{u,v}^{(t)}$ and $J(S_{u}^{(t)},S_{v}^{(t)})$ for any two users $u$ and $v$ over time.

III Shortcomings of Existing Methods

For any two sets $S_{1}$ and $S_{2}$, MinHash [3] applies $k$ independent hash functions $h_{1},\ldots,h_{k}$ to obtain an accurate estimation of $J(S_{1},S_{2})$, where any hash function $h_{j},1\leq j\leq k$ can be described as a random permutation from $I$ to $I$ itself. For a set $S\subset I$, let $h_{j}^{*}(S)$ denote the minimum hash value of items in $S$ with respect to hash function $h_{j}$, i.e., $h_{j}^{*}(S)\!=\!\min_{i\in S}h_{j}(i).$ Therefore, MinHash computes $h_{1}^{*}(S_{1})$, $\ldots$, $h_{k}^{*}(S_{1})$ and $h_{1}^{*}(S_{2})$, $\ldots$, $h_{k}^{*}(S_{2})$, and then estimates $J(S_{1},S_{2})$ as $J(S_{1},S_{2})\!=\!\frac{\sum_{j=1}^{k}\mathbf{1}(h_{j}^{*}(S_{1})=h_{j}^{*}(S_{2}))}{k},$ where $\mathbf{1}(\mathbb{P})$ is an indicator function that equals 1 when predicate $\mathbb{P}$ is true and 0 otherwise. Actually, the MinHash sketch of a set $S$ can be viewed as a vector of $k$ items sampled with replacement from $S$ using $k$ hash functions respectively. Denote by $\phi_{j}(S)$ the item in $S$ with the minimum hash value with respect to hash function $h_{j}$, i.e., $\phi_{j}(S)\!=\!\arg\min_{i\in S}h_{j}(i).$ Because hash function $h_{j}$ maps items in $I$ into distinct integers, i.e., $h_{j}(i_{1})\!\neq\!h_{j}(i_{2})$ when $i_{1}\!\neq\!i_{2}$, the MinHash sketch of $S$ can be simply represented as a vector $(\phi_{1}(S),\ldots,\phi_{k}(S))$, where each element $\phi_{j}(S)$ is randomly sampled with replacement from $S$ by function $h_{j}$. For any two sets $S_{1}$ and $S_{2}$, we easily find that $h_{j}^{*}(S_{1}\cup S_{2})\!=\!\min(h_{j}^{*}(S_{1}),h_{j}^{*}(S_{2})),1\leq j\leq k.$ Therefore, the underlying MinHash sketch of the union $\phi_{j}(S_{1}\cup S_{2})\!=\!\phi_{j}(S_{1})$ when $h_{j}(\phi_{j}(S_{1}))\leq h_{j}(\phi_{j}(S_{2}))$ and $\phi_{j}(S_{2})$ otherwise. $\phi_{j}(S_{1}\cup S_{2})$ is an item in $S_{1}\cap S_{2}$ if and only if $\phi_{j}(S_{1})\!=\!\phi_{j}(S_{2})$, and we can have $P(\phi_{j}(S_{1})\!=\!\phi_{j}(S_{2}))\!=\!P(\phi_{j}(S_{1}\cup S_{2})\in(S_{1}\cap S_{2}))\!=\!\frac{|S_{1}\cap S_{2}|}{|S_{1}\cup S_{2}|}\!=\!J(S_{1},S_{2}).$ Moreover, one can extend MinHash to handle each element $(u,i,a)$ arriving on fully dynamic stream $\Pi$ as follows: case 1) when $a\!=\!``+"$, update $\phi_{j}$ like a regular MinHash, i.e., set $\phi_{j}(S_{u})\!=\!i$ if $\phi_{j}(S_{u})\!=\!\emptyset$ or $h_{j}(i)<h_{j}(\phi_{j}(S_{u}))$ and keep $\phi_{j}(S_{u})$ unchanged otherwise; case 2) when $a\!=\!``-"$ and $\phi_{j}(S_{u})\!=\!i$, set $\phi_{j}(S_{u})\!=\!\emptyset$; case 3) when $a\!=\!``-"$ and $\phi_{j}(S_{u})\!=\!\emptyset$, keep $\phi_{j}(S_{u})\!=\!\emptyset$. However, this extension of MinHash samples an item not according to uniform distribution when item-unsubscriptions occur. The sampling bias is not only related with the number of user’s subscribed items but also the order of item subscriptions and unsubscriptions occurred in stream $\Pi$. It is challenging to model and remove the sampling bias when a user has more than one unsubscriptions in stream $\Pi$.

To reduce the time cost, OPH [4] only uses one hash function $h$ to process each item, which is a random permutation from $I\!=\!\{0,1,\ldots,p-1\}$ to $I$ itself and $p$ is the maximum number of items. OPH equally divides $I$ into $k$ bins: $[\frac{p(j-1)}{k},\frac{pj}{k})$, $1\leq j\leq k$. For a set $S\subset I$, define $S(h,j)\!=\!\{i:i\in S\wedge h(i)\in[\frac{p(j-1)}{k},\frac{pj}{k})\}$, and then OPH computes a variable $oph_{j}(S)\!=\!h^{*}(S(h,j))$ when $S(h,j)\neq\emptyset$ and $\emptyset$ otherwise. At last, it estimates $J(S_{1},S_{2})$ as $J(S_{1},S_{2})\!=\!\frac{\sum_{j=1}^{k}\mathbf{1}(oph_{j}(S_{1})=oph_{j}(S_{2})\neq\emptyset)}{\sum_{j=1}^{k}\mathbf{1}(oph_{j}(S_{1})\neq\emptyset\vee oph_{j}(S_{2})\neq\emptyset)},$ and the time complexity of updating each item is $O(1)$. Similarly, OPH can also be treated as a sampling method and exhibits a sampling bias when there exist item-unsubscriptions in $\Pi$.

Furthermore, there exist methods such as random pairing (RP) [14] for uniformly sampling from dynamic graph streams. One can extend RP to sample $k$ items $(\phi_{j}(S_{u}))_{1\leq j\leq k}$ (resp. $(\phi_{j}(S_{v}))_{1\leq j\leq k}$) from $S_{u}^{(t)}$ (resp. $S_{v}^{(t)}$). In this case, $(\phi_{j}(S_{u}))_{1\leq j\leq k}$ and $(\phi_{j}(S_{v}))_{1\leq j\leq k}$ generated are independent, i.e., $\phi_{j}(S_{u})\!=\!\phi_{j}(S_{v})$ happens with probability $\frac{1}{|S_{u}||S_{v}|}$, which significantly differs from the probabilistic model of MinHash. Therefore, the number of common items can be estimated as $s_{u,v}\!=\!|S_{u}||S_{v}|\sum_{j=1}^{k}\mathbf{1}(\phi_{j}(S_{u})\!=\!\phi_{j}(S_{v}))$.

IV Our Sketch Method

Our sketch method VOS consists of a one-dimension bit array $A$ of length $m$, a hash function $\psi$ that maps items into integers in $\{1,\ldots,k\}$ at random, and $k$ independent hash functions $f_{1},\ldots f_{k}$ that map users into integers in $\{1,\ldots,m\}$ at random. As shown in Figure 1,for each user $u$, we virtually build an odd sketch $O_{u}^{(t)}$ of set $S_{u}^{(t)}$ on the fly and embed $O_{u}^{(t)}$ into $A$. Formally, $O_{u}^{(t)}$ is a bit array of length $k$, where each bit $O_{u}^{(t)}[j]$ is the parity of the number of items in $S_{u}^{(t)}$ of which hash value equals $j$ with respect to function $\psi$, i.e., $O_{u}^{(t)}[j]=\oplus_{i\in S_{u}^{(t)}}\textbf{1}(\psi(i)=j),1\leq j\leq k,$ where $\oplus$ is the xor operation. The above equation tells us that any two elements $(u,i,``+")$ and $(u,i,``-")$ occurred before and including time $t$ offset to each other and they together are irrelevant to the value of $O_{u}^{(t)}$. Our method VOS differs from the original odd sketch method [9] in two aspects:

1. We directly build an odd sketch $O_{u}^{(t)}$ of $S_{u}^{(t)}$ for each user $u$ rather than generate a MinHash sketch first;
2. We do not directly store the odd sketch $O_{u}^{(t)}$ in memory, but use hash functions $f_{1},\ldots f_{k}$ to randomly select $k$ bits from a shared bit array $A$ to approximately store $O_{u}^{(t)}$. In addition, for each occurred user $u$, we use a counter $n_{u}$ to keep tracking of the number of its subscribed items over time. We also update bit array $A$ and a counter $\beta$ as $A[f_{\psi(i)}(u)]\leftarrow A[f_{\psi(i)}(u)]\oplus 1,$ $\beta\leftarrow\beta+\frac{2[(A[f_{\psi(i)}(u)]\oplus 1)-\frac{1}{2}]}{m},$ where $\beta$ is initialized to 0 and used to keep tracking of the fraction of 1-bits in $A$ over time, Thus, the time complexity of updating each element is $O(1)$.

At time $t$, for each bit $O_{u}^{(t)}[j]$, $1\leq j\leq k$, we randomly select a bit from $A$ using hashing function $f_{j}$ and xor the bit with $O_{u}^{(t)}[j]$, i.e. $A[f_{j}(u)]\leftarrow A[f_{j}(u)]\oplus O_{u}^{(t)}[j]$. We easily find that the value of $A$ at time $t$ is irrelevant with the order of occurred users and the order of the bits in their odd sketches iterated in the above procedure. Therefore, we assume that $O_{u}^{(t)}[j]$ is the last bit hashed into $A$. Let $\beta_{u,j}^{(t)}$ is the fraction of 1-bits in $A$ before the event of hashing $O_{u}^{(t)}[j]$ into $A$. We easily obtain that $O_{u}^{(t)}[j]$ is hashed into a 1-bit in $A$ with probability $\beta_{u,j}^{(t)}$. Hashing $O_{u}^{(t)}[j]$ into $A$ changes at most one bit in $A$, therefore we have $|\beta_{u,j}^{(t)}-\beta^{(t)}|\leq\frac{1}{m}$. In this paper, we approximate $\beta_{u,j}^{(t)}$ as $\beta^{(t)}$ because $m\gg 1000$. Based on the above observations, we model our method VOS as: we rebuild each bit $O_{u}^{(t)}[j]$ at time $t$ as $\hat{O}_{u}^{(t)}[j]=A[f_{j}(u)],$ which does not equal $O_{u}^{(t)}[j]$ with probability $P(\hat{O}_{u}^{(t)}[j]\neq O_{u}^{(t)}[j])=\beta^{(t)}.$

To estimate the similarity $s_{u,v}^{(t)}$ of two users $u$ and $v$, we first compute a sketch $\hat{O}_{u,v}^{(t)}$ by combining $\hat{O}_{u}^{(t)}$ and $\hat{O}_{v}^{(t)}$ using the xor operation, i.e., $\hat{O}_{u,v}^{(t)}[j]\!=\!\hat{O}_{u}^{(t)}[j]\oplus\hat{O}_{v}^{(t)}[j].$ Define $\alpha_{u,v}^{(t)}$ as the fraction of 1-bits in $\hat{O}_{u,v}^{(t)}$, $\alpha_{u,v}^{(t)}\!=\!\frac{\sum_{j=1}^{k}\hat{O}_{u,v}^{(t)}[j]}{k},$ and $n_{u\Delta v}^{(t)}$ as the cardinality of the symmetric difference of sets $S_{u}^{(t)}$ and $S_{v}^{(t)}$, i.e., $n_{u\Delta v}^{(t)}\!=\!|S_{u}^{(t)}\Delta S_{v}^{(t)}|\!=\!|(S_{u}^{(t)}-S_{v}^{(t)})\cup(S_{v}^{(t)}-S_{u}^{(t)})|.$ From [9], we obtain $P(O_{u,v}^{(t)}[j]\!=\!1)\!=\!\frac{1-(1-2/k)^{n_{u\Delta v}^{(t)}}}{2}.$ Since $P(\hat{O}_{u}^{(t)}[j]\!\neq\!O_{u}^{(t)}[j])\!=\!P(\hat{O}_{v}^{(t)}[j]\!\neq\!O_{v}^{(t)}[j])\!=\!\beta^{(t)}$ we easily obtain $P(\hat{O}_{u,v}^{(t)}[j]\!=\!1)\!=\!((\beta^{(t)})^{2}+(1-\beta^{(t)})^{2})P(O_{u,v}^{(t)}[j]\!=\!1)+2\beta^{(t)}(1-\beta^{(t)})P(O_{u,v}^{(t)}[j]\!=\!0)\!=\!\frac{1-(1-2\beta^{(t)})^{2}(1-2/k)^{n_{u\Delta v}^{(t)}}}{2}.$ Then we have

[TABLE]

According to the above equation, we estimate $n_{u\Delta v}^{(t)}$ as

[TABLE]

Since $s_{u,v}^{(t)}=\frac{n_{u}^{(t)}+n_{v}^{(t)}-n_{u\Delta v}^{(t)}}{2}$, then we estimate $s_{u,v}^{(t)}$ as

[TABLE]

We easily find that the time complexity of computing $\hat{s}_{u,v}^{(t)}$ is $O(k)$. Moreover, the Jaccard coefficient $\hat{J}(S_{u}^{(t)},S_{v}^{(t)})$ can be estimated as $\hat{J}(S_{u}^{(t)},S_{v}^{(t)})=\frac{\hat{s}_{u,v}^{(t)}}{n_{u}+n_{v}-\hat{s}_{u,v}^{(t)}}.$ Furthermore, the expectation and variance of its estimate $\hat{s}_{u,v}^{(t)}$ are computed as

[TABLE]

[TABLE]

V Evaluation

We perform our experiments on several publicly available real-world datasets YouTube, Flickr, Orkut and LiveJournal [16]. To generate fully dynamic graph streams including item-subscriptions and item-unsubscriptions, we follow the experiment settings in [15] and set the parameters as $q=2,000,000^{-1}$ and $d=0.5$, which means there is a massive deletion of expected $50\%$ edges every $2,000,000$ edges in each graph dataset. Specially, we mainly focus on similarity estimation for users with a large number of subscribed items, which requires extremely large memory and computational resources for similarity estimation. Therefore, in our experiments, we first select $5,000$ users with largest cardinalities to generate user pairs of any two users in each graph dataset, and then retain the set of user pairs that have at least one common item to keep tracking of over time.

We employ three baselines MinHash, OPH and RP as described in Section II and III to compare with our method VOS for estimating similarities over time. Here we use the metrics average absolute percentage error (AAPE) to measure the accuracy of estimating the number of common items $\hat{s}_{u,v}^{(t)}$, and average root mean square error (ARMSE) to evaluate the performance of estimating the Jaccard coefficient similarity $\hat{J}(S_{u}^{(t)},S_{v}^{(t)})$ over time. Formally, the metrics are defined respectively as $\text{AAPE}^{(t)}\!=\!\frac{1}{|P|}\sum_{(u,v)\in P}|\frac{s_{u,v}^{(t)}-\hat{s}_{u,v}^{(t)}}{s_{u,v}^{(t)}}|$ and $\text{ARMSE}^{(t)}\!=\!\sqrt{\frac{\sum_{(u,v)\in P}(\hat{J}(S_{u}^{(t)},S_{v}^{(t)})-J(S_{u}^{(t)},S_{v}^{(t)}))^{2}}{|P|}}.$ In our experiments, we compare the performance of all these methods under the same memory size $m=32k|U|$ bits, where the memory size of each value of the $k$ registers in its generated sketch for each user $u\in U$ is set as $32$ bits. As for the parameter $k$ for the size of virtual odd sketch of our method VOS, we can enumerate all possible values from $1$ to max-cardinality to find an optimal value for each graph dataset, which minimizes either $\text{AAPE}^{(t)}$ or $\text{ARMSE}^{(t)}$ of selected user pairs at any time $t$. Also we can directly set it as $\lambda$ times (i.e., $\lambda=2,3,\ldots$) larger than the memory space used by each sketch of MinHash, OPH and RP. In the later experiments, we set $\lambda=2$.

Figure 2 (a) shows the runtime of our method VOS in comparison with other three baselines in the dataset YouTube when the sketch size $k$ varies from $1$ to $10^{5}$, and Figure 2 (b) shows the runtime of all methods when $k=10^{5}$. In our experiments, we measure the runtime during which we implement all four methods respectively to update the sketch for each user. We can see that our method VOS and OPH are faster than MinHash and RP, and only require the time complexity $O(1)$. Meanwhile, we fix the sketch size $k=100$ and then compare the estimation accuracy of all four methods. The experimental results are shown in Figure 3. Figures 3 (a) and (c) show the accuracy of estimating $\hat{s}_{u,v}^{(t)}$ and $\hat{J}(S_{u}^{(t)},S_{v}^{(t)})$ in dataset YouTube over time respectively, and Figures 3 (b) and (d) show the accuracy in all datasets at time $t$ when all elements in graph streams arrive. We observe that our method VOS are more accurate than other three methods and significantly reduce the estimation bias for fully dynamic graph streams.

VI Conclusions

In this paper, we observe that state-of-the-art similarity estimation methods MinHash and OPH are indeed sampling methods for graph streams consisting of only item insertions, and exhibit a sampling bias for fully dynamic graph streams. To solve this problem, we develop a sampling method VOS. VOS uniformly samples at most $k$ connected items for each user. It fast processes each edge in the graph stream with small time complexity $O(1)$. Based on two users’ sampled items, we propose a fast method to estimate not only the Jaccard coefficient between their connected items but also the number of their common connected items. We perform experiments on a variety of publicly available graphs, and experimental results demonstrate that our method VOS significantly outperforms the state-of-the-art methods.

Acknowledgment

The research presented in this paper is supported in part by National Key R&D Program of China (2018YFC0830500), National Natural Science Foundation of China (U1736205, 61603290), Shenzhen Basic Research Grant (JCYJ20170816100819428), Natural Science Basic Research Plan in Shaanxi Province of China (2016JQ6034).