BC tree-based spectral sampling for big complex network visualization

Graph sampling methods have been used to reduce the size and complexity of big complex networks for graph mining and visualization. However, existing graph sampling methods often fail to preserve the connectivity and important structures of the original graph. This paper introduces a new divide and conquer approach to spectral graph sampling based on graph connectivity, called the BC Tree (i.e., decomposition of a connected graph into biconnected components) and spectral sparsification. Specifically, we present two methods, spectral vertex sampling BC_SV\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$BC\_SV$$\end{document} and spectral edge sampling BC_SS\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$BC\_SS$$\end{document} by computing effective resistance values of vertices and edges for each connected component. Furthermore, we present DBC_SS\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$DBC\_SS$$\end{document} and DBC_GD\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$DBC\_GD$$\end{document}, graph connectivity-based distributed algorithms for spectral sparsification and graph drawing respectively, aiming to further improve the runtime efficiency of spectral sparsification and graph drawing by integrating connectivity-based graph decomposition and distributed computing. Experimental results demonstrate that BC_SV\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$BC\_SV$$\end{document} and BC_SS\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$BC\_SS$$\end{document} are significantly faster than previous spectral graph sampling methods while preserving the same sampling quality. DBC_SS\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$DBC\_SS$$\end{document} and DBC_GD\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$DBC\_GD$$\end{document} obtain further significant runtime improvement over sequential approaches, and DBC_GD\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$DBC\_GD$$\end{document} further achieves significant improvements in quality metrics over sequential graph drawing layouts.


Introduction
preserve the connectivity and important structures of the original graph, in particular for visualization (Wu et al. 2017).
Spectral sparsification is a technique to reduce the number of edges in a graph while retaining its structural properties (Spielman and Teng 2011). More specifically, it is a sampling method which uses the effective resistance values of edges, which is closely related to the commute distances of graphs. However, computing effective resistance values of edges is rather complicated, which can be very slow for big graphs (Eades et al. 2017b).
Another method to address scalability issues in computing is distributed computing. With the advent of technology, cloud computing services are becoming much cheaper and convenient for anyone to use, leading to the widespread use of distributed computing on the cloud. Recent works have used cloud computing for distributed graph drawing (Arleo et al. 2019). However, communication overhead still poses a problem, impacting the efficiency gains.
This paper introduces divide and conquer algorithms for spectral sparsification, based on the graph connectivity, called the BC (Block Cut-vertex) tree decomposition, which represents the decomposition of a graph into biconnected components. More specifically, the main idea is to divide a big complex network into biconnected components, and then compute the spectral sparsification for each biconnected component in parallel to reduce the runtime as well as to maintain the graph connectivity. Namely, the effective resistance values of edges are computed for each biconnected component, as an approximation of the effective resistance values of the original graph. We also introduce a BC tree-based distributed framework for spectral sparsification and graph drawing, designed for use in a cloud-based distributed computing environment.
The main contributions of this paper are summarized as follows: 1 We present two new variations of spectral sparsification based on connectivity, spectral edge sampling BC_SS (BC Spectral Sampling) and spectral vertex sampling BC_SV (BC Spectral Vertex). Spectral edge sampling mainly sparsifies the edge set, while the spectral vertex sampling focuses on reducing the size of the vertex set. 2 We present DBC_SS (Distributed BC Spectral Sampling), a distributed algorithm for spectral sparsification integrating BC tree decomposition. Effective resistance values of edges are computed independently on each biconnected component in parallel to improve the runtime efficiency of spectral sparsification. 3 We present DBC_GD (Distributed BC Graph Drawing), a distributed graph drawing algorithm integrating BC tree decomposition. Using a radial tree drawing of the BC tree of a graph as an initial layout, biconnected components are drawn independently in parallel, and each vertex of the BC tree is replaced with the drawing of the biconnected component it represents to obtain a drawing of the whole graph. 4 We implement and evaluate BC_SS and BC_SV in comparison to sequential spectral sparsification. Experimental results demonstrate that our BC_SS and BC_SV methods are significantly faster than the original SS (Spectral Sparsification) (Eades et al. 2017b) and SV (Spectral Vertex sampling) (Hu et al. 2019) at about 72% faster on average, while preserving the same sampling quality, using a comparison of the effec-tive resistance values and rankings of edges (resp., vertices), sampling quality metrics, graph similarity, and visual comparison. 5 We implement and evaluate DBC_SS in comparison to sequential effective resistance value computation SS. Our experiments show that DBC_SS obtains runtime improvements over SS by 27% and 47% when running on 2 servers and 5 servers respectively. 6 We implement and evaluate DBC_GD with three variations based on the layout used to draw each biconnected component: DBC_FR (Fruchterman-Reingold), DBC_SM (Stress Majorization), and DBC_FM3 (FM 3 ). Compared to the sequential layouts, DBC_FR is 26 times and 52 times faster than FR when running on 2 servers and 5 servers respectively, DBC_SM is 31 times and 71 times faster than SM when running on 2 servers and 5 servers respectively, and DBC_FM3 is 2 times and 4 times faster than FM 3 when running on 2 servers and 5 servers respectively. DBC_GD also surprisingly obtains better quality metrics than the original layouts.

Graph sampling
Graph sampling methods have been extensively studied in graph mining to reduce the size of big complex graphs. Consequently, many stochastic sampling methods are available (Hu and Lau 2013;Leskovec and Faloutsos 2006). For example, most popular stochastic sampling include Random Vertex sampling and Random Edge sampling. However, it was shown that random sampling methods often fail to preserve connectivity and important structure in the original graph, in particular for visualization (Wu et al. 2017). Newer sampling methods have attempted to improve upon stochastic sampling, such as by using topology-based decomposition to preserve connectivity (Hong et al. 2018) or by preserving edges representing significant deviations in the weight distribution of a weighted graph (Serrano et al. 2009).

Spectral sparsification
Spectral graph theory is concerned with the eigenvalues and eigenvectors of matrices associated with graphs (Spielman 2007). The spectrum of a graph is the list of eigenvalues of its Laplacian matrix L , which is defined as L = D − A where D is the degree matrix and A is the adjacency matrix. The spectrum of a graph is closely related to important structural properties such as connectivity, clustering, stress, and commute distance. Graph spectrum has been used to draw aesthetics-focused graph layouts with fast runtime (Koren 2003) as well as to support various types of of graph analysis (Forman et al. 2005;Gera et al. 2018;Galimberti et al. 2019).
A spectral sparsifier is a subgraph whose Laplacian quadratic form is approximately the same as the original on all real vector inputs. Every n-vertex graph has a spectral approximation with O(n log n) edges (Spielman and Teng 2011).
Spectral sparsification selects edges based on their effective resistance. Modelling a graph as an electrical network, the effective resistance of the edge is defined as the voltage drop across the edge and its value is equivalent to the probability of the edge to be included in a random spanning tree of the graph (Spielman and Srivastava 2011). However, computing effective resistance values of edges is quite complicated and can be very slow for big graphs (Eades et al. 2017b).
Spectral sparsification-based sampling has been shown to obtain superior sampling quality compared to stochastic sampling (Eades et al. 2017b;Hu et al. 2019), as well as compared to sampling based on graph centrality (Hong and Lu 2020).

BC (Block Cut-vertex) tree decomposition
The BC tree represents the tree decomposition of a connected graph G into biconnected components, which can be computed in linear time (Hopcroft and Tarjan 1973). A biconnected graph is a graph without a cut vertex, that is a vertex whose removal disconnects the graph; a biconnected component is a maximal biconnected subgraph. There are two types of nodes in the BC tree T; a cut vertex c and a biconnected component B. A cut vertex is a vertex whose removal from the graph makes the resulting graph disconnected. A biconnected component (or block) is a maximal biconnected subgraph.

Graph sampling quality metrics
There are a number of quality metrics for graph sampling (Hu and Lau 2013). For our experiment, we use the following most popular quality metrics: • Degree Correlation Associativity (Degree): a basic structural metric, which computes the likelihood that vertices link to other vertices of similar degree, called positive degree correlation (Newman 2003). • Closeness Centrality (Closeness): a centrality measure of a vertex in a graph, which sums the length of all shortest paths between the vertex and all the other vertices in the graph (Freeman 1978). • Average Neighbor Degree (AND): the measure of the average degree of the neighbors of each vertex (Barrat et al. 2004). • Clustering Coefficient (CC): measures the degree of vertices which tend to cluster together (Saramki et al. 2007).

Graph drawing algorithms
One of the most popular graph drawing algorithms is the force-directed or spring algorithm, which models a graph as a system with attraction forces between neighboring vertices and repulsion forces between all pairs of vertices (Eades 1984). Although spring algorithms are able to produce high-quality graph layouts, traditional spring algorithms do not scale well to larger graphs due to the repulsion force computation taking O(n 2 ) runtime.
Multi-level algorithms have been developed which improves the runtime to O(n log n) in practice using a coarsening and refinement technique. Here, vertices are gradually clustered in the coarsening phase until a simple graph that can be drawn easily is obtained, and in the refinement step, the drawing of the "coarse" graph is then used as an initial layout for the next level with more vertices. An example is the FM 3 (Fast Multipole Multilevel Method) algorithm (Hachul and Jünger 2004).
Other layout types include stress-based layouts, which utilize the stress function from MDS (multi-dimensional scaling). These methods compute a layout by minimizing an adapted stress function, which is lower when the geometric distances between vertices are proportional to their graph theoretic distances (Gansner et al. 2004).
For drawing trees, specific algorithms have been introduced. An example is the radial tree drawing algorithm (Eades 1991). Starting at a root vertex, subtrees are assigned a wedge around the root with width proportional to its size, and further subtrees are recursively assigned a sub-area of its parent's wedge.

BC tree-based spectral graph sampling
In this section, we introduce a new divide and conquer algorithm for spectral sparsification, by tightly integrating the BC tree decomposition, aiming to reduce the runtime for computing the effective resistance values as well as to maintain the graph connectivity. We present two variations, called BC_SS (for spectral sparsification of edges) and BC_SV (for spectral sampling of vertices).
More specifically, we divide a big complex graph into a set of biconnected components, and then compute the spectral sparsification (i.e., effective resistance values) for each biconnected component in parallel. Namely, the effective resistance values of the edges are computed for each biconnected component, as a fast approximation of the effective resistance values of the original graph.
Let G = (V , E) be a graph with a vertex set V ( n = |V | ) and an edge set E ( m = |E| ). The adjacency matrix of an n-vertex graph G is the n × n matrix A, indexed by V, such that A uv = 1 if (u, v) ∈ E and A uv = 0 otherwise. The degree matrix D of G is the diagonal matrix where D uu is the degree of vertex u. The Laplacian matrix of G is L = D − A . The spectrum of G is the eigenvalues of L, 1 , 2 , . . . , n . Suppose that we regard a graph G as an electrical network where each edge e is a 1-resistor, and a current is applied. The effective resistance r(e) of an edge e is the voltage drop over the edge e, see (Spielman and Teng 2011).

Algorithm BC_SS
Let G = (V, E) be a connected graph with a vertex set V and an edge set E, and let The BC_SS algorithm first computes the BC tree decomposition, and then adds the cut vertices and their incident edges to the spectral sparsification G ′ of G. This is due to the fact that the cut vertices play important roles in preserving the connectivity of the graph as well as in social network analysis, such as brokers or important actors connecting two different communities.
Next, it computes a spectral sparsification G ′ i for each biconnected component G i , i = 1, . . . , k of G. Specifically, for each component G i , we compute the effective resistance values r(e) of the edges, and then sample the edges with the largest effective resistance values. Finally, it merges G ′ i , i = 1, . . . , k to obtain the spectral sparsification G ′ of G. The BC_SS algorithm is described as follows: Algorithm: BC_SS 1. Partitioning: Divide a connected graph G into biconnected components, G i , i = 1, . . . , k. 2. Cut vertices: Add the cut vertices and their incident edges to the spectral sparsification G ′ of G. 3. Spectral sparsification: For each component G i , compute a spectral sparsification G ′ i of G i . Specifically, compute the effective resistance values r(e) of the edges, and then sample the edges with the largest effective resistance values. 4. Aggregation: Merge all G ′ i of G i to compute the spectral sparsification G ′ of the original graph G.

Algorithm BC_SV
The BC_SV algorithm is a divide and conquer algorithm that uses spectral sampling of vertices (Hu et al. 2019): i.e., adapt the spectral sparsification approach, by sampling vertices rather than edges. More specifically, we define an effective resistance value r(v) for each vertex v as the sum of effective resistance values of the incident edges, i.e., r(v) = e∈E v r(e) , where E v represents a set of edges incident to a vertex v.
The BC_SV algorithm first computes the BC tree decomposition, and then adds the cut vertices and their incident edges to the spectral sampling G ′ of G. Next, it computes a spectral vertex sampling G ′ i for each biconnected component G i , i = 1, . . . , k of G. Specifically, for each component G i , we compute the effective resistance values r(v) of the vertices, and then sample the vertices with the largest effective resistance values. Finally, it merges G ′ i , i = 1, . . . , k to obtain the spectral sampling G ′ of G. The BC_SV algorithm is described as follows: Algorithm: BC_SV

BC tree-based distributed framework
In this section, we introduce the BC-P (BC Parallel) framework, a framework integrating BC tree decomposition and cloud computing to achieve better scalability and efficiency for analysis and visualization of big complex graphs. We apply a Divide-and-Conquer method to divide a connected graph into biconnected components using BC tree decomposition. We then assign the components to a set of servers in a balanced manner based on the sizes of the components.

Framework: BC-P
1 BC Tree Decomposition: Divide a connected graph G into biconnected components C i , i = 1, . . . , k 2 Partitioning: Partition the set of components to be assigned to a set of servers S j , j = 1, . . . , h based on the sizes of the components, in a balanced manner. 3 Parallel computing: in parallel, each server independently performs the main analytical computation on its set of assigned components 4 Aggregation: merge results from each server to obtain the result for the whole graph Using the BC tree decomposition, communication overheads can be reduced. This is because the graph is divided into biconnected components, which only intersect on cut vertices and share no edges. Thus, each server can perform computations on their assigned components independently.
The BC tree can also be exploited in the merge phase to emphasize the connectivity and topological structure of the graph. For example, sampling can be made to always include cut vertices and edges incident on them, or a drawing of the graph may be computed in a way that emphasizes the connectivity structure between the biconnected components.

Distributed BC tree-based spectral sparsification
We present DBC_SS, a distributed algorithms for spectral sparsification. The input graph is decomposed into biconnected components using BC tree decomposition, and the effective resistance values of edges are computed per biconnected component in parallel. The DBC_SS algorithm is described as follows: Algorithm: DBC_SS 1 Divide a connected graph G into biconnected components C i , i = 1, . . . , k 2 Partition the set of components to be assigned to a set of servers S j , j = 1, . . . , h based on the sizes of the components, in a balanced manner, using a greedy algorithm. 3 In parallel, each server independently computes the effective resistance values of edges per biconnected component. 4 Combine all the results from all server using a master instance to produce the final result.
Using BC tree decomposition, communication overheads can be removed for parallel effective resistance values computation. This is because the biconnected components do not share any edges, thus the effective resistance values can be computed independently for each component.

Distributed BC tree-based graph drawing
We present DBC_GD, a parallel algorithm for graph drawing. We use BC tree decomposition on the graph and apply a radial tree drawing algorithm on the BC tree to obtain an initial layout for the original graph. Each biconnected component is drawn separately, and then each vertex in the radial tree drawing representing a block vertex is replaced with the drawing of the corresponding biconnected component. The DBC_GD algorithm is described as follows: Algorithm: DBC_GD 1 Divide a connected graph G into biconnected components C i , i = 1, . . . , k 2 Draw the BC tree using Radial Tree algorithm, each Block cut vertex representing either a cut vertex or a biconnected component. 3 Partition the set of components to be assigned to a set of servers S j , j = 1, . . . , h based on the sizes of the components, in a balanced manner, using a greedy algorithm. 4 Each server independently computes the layout of each biconnected component. 5 Merge all the layout results of each biconnected component into the radial tree drawing by replacing each block vertex in the BC tree with the drawing of its corresponding biconnected component to produce the final layout of the original graph.
To ensure that the layout for each biconnected component can be computed independently without causing issues in the merge step, we use a modified version of the radial tree layout where we scale the geometric size of the vertices of the BC tree by the size of the biconnected component represented. This size is then used to modify the size of the wedge assigned to the sub-tree as needed. This ensures that the drawings of the biconnected component will not overlap in the merge step.

BC_SS and BC_SV experiments
We first design experiments to compare the Spectral Sparsification (SS) (Eades et al. 2017b), BC_SS and Random Edge sampling (RE) (resp., Spectral Vertex sampling (SV) (Hu et al. 2019), BC_SV and Random Vertex sampling (RV)), implemented in Java. Analysis of experimental results such as metrics and statistics are implemented in Python, using the NetworkX library (Hagberg et al. 2008). All programs were run on a MacBook Pro with 2.2 GHz Intel Core i7, 16 GB 1600 MHz DDR3, and macOS Sierra version 10.12.6. SS and SV have already been shown to obtain better quality samples compared to other well-known sampling methods (Eades et al. 2017b;Hu et al. 2019). Furthermore, an extensive comparison has been done showing the superior performance of spectral sparsification-based sampling to sampling based on various types of other graph analysis (Hong and Lu 2020). Our main focus is then to show that BC_SS and BC_SV obtain the same level of quality as SS and SV respectively with much better runtime. The main hypotheses of our BC_SS and BC_SV experiments include: • H1: BC_SS computes effective resistance values of edges faster than SS (Eades et al. 2017b). • H2: The effective resistance values and the rankings of edges (resp., vertices) computed by BC_SS (resp., BC_SV ) are good approximations of those computed by SS (resp., SV), and their similarity increases with the sampling ratio.
The main rationale behind the hypotheses is that the graph samples computed by BC_SS and SS (resp., BC_SV and SV) would be very similar, since the ranking of edges (resp., vertices) based on the resistance values are highly similar. We experiment with benchmark real world graphs (Eades et al. 2017b) and synthetic data sets, see Table 1. The real world graphs are scale-free graphs with highly imbalanced sizes of biconnected components (i.e., big biconnected component). The graphs include social networks (facebook, oflights, p2pG, soch ,wiki) and biological networks (G4, G15, yeastppi). The synthetic graphs are generated with balanced sizes of biconnected components. The structure is created by first generating a k-ary tree, then replacing the vertices with either biconnected components or cut vertices, alternating between levels; the generative model is similar to that used in Hong et al. (2018). , where t(SS) and t(BC_SS) are the runtimes of SS and BC_SS respectively. The runtime improvement is much higher for the synthetic graphs, achieving above 99% on average, while the improvement on the real world graphs, on average 45%, varies depending on their structures. For example, BC_SS improved 77% of the runtime for the G4 graph, while it improved 23% for the Facebook graph due to the existence of the giant biconnected component. Overall, the average runtime improvement over all datasets is 68%.

Runtime improvement
Overall, our experiments show that BC_SS is significantly faster than SS, supporting hypothesis H1.   Fig. 2 The mean of the differences in effective resistance values computed by BC_SS and SS (a, b); by BC_SV and SV (c, d) the differences in effective resistance values computed by SV and BC_SV with sampling ratio from 5% to 100%.

Overall, it clearly shows that the mean of the differences in effective resistance values computed by BC_SS and SS (resp., BC_SV and SV) is very small for most of the data sets, supporting hypothesis H2.
More specifically, for BC_SS , smaller than -0.0175 for real world graphs; smaller than -0.12, with one outlier, for synthetic graphs. For BC_SV , smaller than − 2.5 (compared to resistance values of edges, -2.5 is equivalent to -0.06) for real world graphs; smaller than -0.5 (equivalent to -0.08) for synthetic graphs.
Interestingly, in contrast to the runtime improvement results, real world graphs have a better similarity in the effective resistance values than synthetic graphs, due to the existence of the big giant component. Namely, the effective resistance values computed from the big biconnected component are very similar to the effective resistance values computed for the whole graph. In the case of sparser graphs (e.g. G4), graphs with a very large giant biconnected component and thus very unbalanced biconnected component sizes (e.g. G15), or graphs with a very large number of cut vertices (e.g. st_4_9 ), the mean difference does not always change linearly.
It should be noted that even at 100% sampling rate, BC_SS and BC_SV still compute effective resistance per biconnected component. Thus, it is possible to still have some minor differences compared to the effective resistance values computed by SS and SV, which computes the effective resistance based on the whole graph.

Approximation of the ranking of edges and vertices
We define the sampling accuracy based on the proportion of the common sampled edges (resp., vertices) between two graph samples computed by SS and BC_SS (resp., SV and BC_SV ). A high sampling accuracy indicates that both graph samples are highly similar. Namely, the sampling accuracy shows how well the effective resistance values computed by BC_SS (resp., BC_SV ) can serve as a good approximation of the values computed by SS (resp., SV). Figure 3a and b (resp., (c) and (d)) show the sampling accuracy of BC_SS (resp., BC_SV ) with sampling ratio from 5% to 100% . It is easy to observe that for all data sets, the sampling accuracy increases as the sampling ratio increases, supporting hypothesis H2.
Specifically, for BC_SS , synthetic graphs perform better: they achieve above 50% sampling accuracy at sampling ratio 5% , and then quickly rise up to 80% at sampling ratio 15% , with steady improvement towards 100% as the sampling ratio increases.
The performance of BC_SS on the real world graphs shows different patterns, depending on their structure. Interestingly, the Facebook graph has excellent sampling accuracy at all sampling ratios, achieving above 80% , while it performs the worst on the runtime improvement and the difference in resistance values. On the other hand, graph G4 shows very high performance on runtime improvement and the difference in resistance values is quite small, however the sampling accuracy is low when the sampling ratio is smaller than 20%.
For BC_SV , synthetic graphs show excellent performance overall, achieving above 70% sampling accuracy at sampling ratio 5% , and then rise up to 90% at sampling ratio 10% , with steady improvement towards 100% as the sampling ratio increases. For real world graphs, BC_SV achieves above 70% sampling accuracy at sampling ratio 20% for all graphs. Particularly, the Facebook graph shows excellent sampling accuracy at all sampling ratios, achieving above 99% . Similar to the mean differences, BC_SS and BC_SV computing effective resistance values per biconnected component may lead to cases where the accuracy is not 100% even at 100% sample size, such as with sparse graphs with uneven component sizes (e.g. G4).
Furthermore, the correlation analysis of the ranking of edges (resp., vertices) based on resistance values computed by SS and BC_SS (resp., SV and BC_SV ) shows strong and positive results for all data sets. Overall, our experiments and analysis confirm that BC_SS (resp., BC_SV ) computes good approximations on the rankings of edges (resp., vertices) based on effective resistance values, compared to SS (resp., SV), supporting hypothesis H2.

Graph sampling quality metrics comparison
We use well known sampling quality metrics (Hu and Lau 2013): Degree Correlation (Degree), Closeness Centrality (Closeness), Clustering coefficient (CC), and Average Neighbor Degree (AND). More specifically, we use the Kolmogorov-Smirnov (KS) distance to compute the distance between two Cumulative Distribution Functions (CDFs) (Gammon et al. 1967). The KS distance value is between 0 to 1: the lower KS value means the better result. Namely, a KS distance value closer to 0 indicates a higher similarity between CDFs. Figure 4a and b show the average (over all data sets) of the KS distance values of the graph samples computed by BC_SS (red), SS (blue), and Random Edge sampling (RE) (yellow), with four sampling quality metrics. Clearly, SS and BC_SS perform consistently better than RE for both types of graphs, as we expected. More importantly, the performance of SS and BC_SS are almost identical across all the metrics, especially for synthetic graphs. For the real world graphs, the performance of SS and BC_SS are highly similar on Closeness, AND, and CC metrics. Figure 4c and d show the average (over all data sets) of the KS distance values of the graph samples computed by BC_SV (red), SV (blue), and Random Vertex sampling (RV) (yellow), with four sampling quality metrics. Clearly, SV and BC_SV perform consistently better than RV for both types of graphs, as we expected. More importantly, the performance of SV and BC_SV are almost similar on all the metrics, especially for AND, Degree, and CC. In particular, we observe that BC_SV shows the largest improvement on Closeness, significantly better than SV.
In summary, our experimental results with sampling quality metrics confirm that both SS and BC_SS (resp., SV and BC_SV ) outperform RE (resp., RV), and the graph samples computed by BC_SS (resp., BC_SV ) have almost the same sampling quality as those computed by SS (resp., SV), supporting hypothesis H3.

Jaccard similarity index comparison
We also computed the Jaccard similarity index (Jaccard 1912) for testing the similarity between the original graph G and the graph samples G ′ and G ′′ computed by SS and BC_SS (resp., SV and BC_SV ). More specifically, it is defined as the size of the intersection divided by the size of the union of the neighbourhood of vertices in the two graphs (value 1 indicates that two graphs are the same): MJS(G 1 , where N 1 (u) (resp. N 2 (u) ) is the neighbourhood of u in G 1 (resp. G 2 ) (Eades et al. 2017a). Our usage of Jaccard similarity is consistent with previous work on graph sampling and spectral sparsification, where its effectiveness for comparing graphs have been demonstrated (Hu et al. 2019;Meidiana et al. 2019). Figure 5 shows the average Jaccard similarity values for real world graphs and synthetic graphs for BC_SS and SS (resp. BC_SV and SV), with sampling ratio from 5% to 95% . Clearly, for both data sets, the Jaccard similarity index linearly increases with the sampling ratio, and SS and BC_SS (resp., SV and BC_SV ) perform almost the same, supporting hypothesis H3.

Visual comparison: SS versus BC_SS and SV versus BC_SV
We conduct visual comparisons of graph samples computed by SS, BC_SS , SV, and BC_SV using the Backbone layout, specifically designed to untangle the hairball drawings of large graphs (Nocaj et al. 2015). Table 2 shows graph samples with sampling ratio at 20% for real world graphs (facebook, G15, G4, oflights, soc_h, yeastppi) as well as a synthetic graph st4_5. Visual comparison clearly shows that SS and BC_SS (resp., SV and BC_SV ) produce almost identical visualizations, supporting hypothesis H4.
Overall, spectral edge sampling methods (SS and BC_SS ) and spectral vertex sampling methods (SV and BC_SV ) produce visually highly similar graph samples. For some cases, the density of graph samples are slightly different, depending on the density of the original graphs. For example, for graphs G4 and yeastppi, spectral vertex sampling methods (SV and BC_SV ) compute graph samples which better captures the dense structure of the original graph.

DBC_SS experiments
We next conduct experiments comparing the efficiency of DBC_SS to sequential spectral sparsification SS. We ran effective resistance value computation on three different settings: sequential SS, DBC_SS on 2 servers, and DBC_SS on 5 servers; the usage of 2 and 5 servers is consistent with the experimental setup of previous topology-based and spectral sparsification-based distributed sampling works (Hong et al. 2018;Meidiana et al. 2019), chosen as a starting point to demonstrate the difference in runtime on We conducted experiments using a mix of real world and synthetic datasets, described in Table 3. The real world datasets have been taken from the library of Hachul and Jünger (2007), the sparse matrices collection (Davis and Hu 2011), and the network repository (Rossi and Ahmed 2015), while the synthetic datasets were created with a globally sparse structure with locally dense "blobs".
We expect that the parallel DBC_SS will provide better runtime efficiency over SS. We also expect DBC_SS to compute sparsifications which preserve the global skeleton structure of the full graphs. We formulate the following hypothesis: Table 2 Comparison of graph samples of real world graphs and a synthetic graph with 20% sampling ratio, computed by SS, BC_SS , SV and BC_SV SS and BC_SS (resp. SV and BC_SV ) produce almost identical visualizations • H5: DBC_SS runs faster than SS.
• H6: DBC_SS computes sparsified graphs with similar visualisation to the full graphs.

Runtime improvement
We compute the runtime improvement of DBC_SS over SS using the formula where t(SS) is the runtime of SS and t(SS) is the runtime of DBC_SS. Figure 6 shows the runtime improvement of DBC_SS over sequential effective resistance value computation. DBC_SS runs faster than SS on all datasets, on average with 27% runtime improvement on a 2-server configuration and 42% runtime improvement on a 5-server configuration. Larger improvements when using 5 servers over 2 servers can be seen when the graph has evenly-sized biconnected components (e.g. cycleblackhole

DBC_GD experiments
To evaluate the efficiency and effectiveness of DBC_GD, we executed experiments comparing DBC_GD to sequential graph drawing algorithms. We selected three original graph layouts of different types to be compared: FR (Fruchterman-Reingold) (Fruchterman and Reingold 1991), a force-directed layout; FM 3 (Hachul and Jünger 2004), a multi-level layout; and SM (Stress Majorization) (Hachul and Jünger 2004), a stressbased layout. We denote the respective DBC_GD variants as DBC_FR, DBC_FM3, and DBC_SM.
For each original graph layout, we draw the graphs using the layout and the corresponding DBC_GD variants. We then compare the results on runtime and quality metrics.
For this experiment, we created synthetic datasets where the BC tree decomposition produces a balanced tree. The details of the graphs are shown in Table 5, named in the We expect that the DBC_GD algorithms will run faster than the sequential graph layouts. Furthermore, we expect that they will obtain drawings that are at least of similar quality as the sequential graph layouts, due to the BC tree decomposition emphasizing the connectivity between the biconnected components. We formulate the following hypotheses: • H7: DBC_FR, DBC_SM, and DBC_FM3 run faster than FR, SM, and FM 3 respectively. • H8: DBC_FR, DBC_SM, and DBC_FM3 computes drawings on the same level of quality as FR, SM, and FM 3 respectively. Figure 7 shows the runtime improvements of DBC_GD over the original sequential layouts. For this experiment, as the runtime is often very low compared to the original, the runtime improvement formula used for the DBC_SS experiments often does not adequately show the difference in efficiency between 2-and 5-server settings. We use the following formula: RI = t(OL) t(DBC_GD) where t(OL) is the runtime of the original sequential layout and t(DBC_GD) is the runtime of our algorithms.

Runtime improvement
Compared to the original sequential algorithms, DBC_GD obtains significant runtime improvements, as shown in Fig. 7. DBC_FM3 on 2 and 5 servers is 1.86 times and 4.14 times faster than sequential FM 3 respectively. More significant runtime improvements are seen with DBC_FR and DBC_SM: DBC_FR with 2 and 5 servers is 26.28 times and 52.31 times faster than FR respectively; DBC_SM on 2 and 5 servers is 31.61 times and 71.48 times faster than SM respectively. In summary, all variants of DBC_GD run faster than their respective sequential layouts, supporting hypothesis H7. Table 6 shows the visual comparison of the graph drawings using six algorithms: FR, SM, FM 3 , and their respective DBC_GD counterparts. With the synthetic datasets with balanced BC trees, such as the first row of Table 6, DBC_GD with FR and SM obtain better shape drawings than their sequential counterparts, with fewer crossings than FR and with better separation between biconnected components than SM. Compared to FM 3 , DBC_GD obtains similar shape for the global skeleton, while also not collapsing each biconnected too extremely. These results support hypothesis H8. We also show an example combining the layout of DBC_GD with the sparsification of DBC_SS, displayed in Fig. 8. It can be seen that not only the global skeleton of the graph is displayed, but the sparsification shows details of the intra-component structure that may be missed in the drawing for the original graph, where each biconnected component are displayed as "blobs". Thus, combining DBC_GD with DBC_SS can be useful in further highlighting important topological structures of graphs.

Visual comparison
In summary, DBC_GD obtains drawings with better shape than the sequential counterparts, supporting hypothesis H8. Furthermore, a combination of DBC_SS and DBC_GD is able to both show the global skeleton and local structure of a graph.

Quality metrics comparison
We also compute quality metrics for the drawings to further evaluate the effectiveness of DBC_GD. We use edge crossing and shape-based metrics. The shape-based metric (Eades et al. 2017a) measures the faithfulness of graph drawing, i.e., how well the shape of the drawing represents the structure of the graph. Figure 9a and b show the improvements obtained by DBC_GD in edge crossing and shape-based metrics respectively. DBC_GD obtains significantly fewer edge crossings Fig. 7 Runtime improvements of DBC_GD over SM, FR, FM3. All variants of DBC_GD obtain significant runtime improvements over the respective sequential layouts, with DBC_SM obtaining the biggest runtime improvements, followed by DBC_FR than SM, FR and FM3 at 39.63%, 28.2%, 21.18% respectively. With SM, DBC_GD obtains significantly higher shape-based metrics, at 58.38 %. Furthermore, DBC_FR obtains 13.84% higher shape-based metrics than FR. In summary, the improvement in metrics shows that DBC_GD is even more effective than the corresponding sequential layouts, supporting hypothesis H8. DBC_GD produces layouts with similar quality to FM 3 and better than FR and SM

Conclusion and future work
In this paper, we presented two new spectral sampling methods, BC_SS and BC_SV , tightly integrating the BC tree decomposition for fast computation and spectral sparsification to obtain high quality graph samples, preserving structural properties of graphs. We also designed, implemented, and evaluated DBC_SS and DBC_GD , distributed algorithms for spectral sparsification and graph drawing integrating BC tree decomposition of graphs with distributed computing on the cloud. Extensive experimental results with both real world graphs and synthetic graphs demonstrate that our new BC tree-based spectral sampling approaches, BC_SS and BC_SV , are significantly faster than existing methods, on average 72% faster, while preserving highly similar quality sampling results, based on the comparison of resistance values, rankings of edges/vertices, graph sampling quality metrics, Jaccard similarity index, and visual comparison.
Furthermore, we also validate the effectiveness of our BC tree-based distributed framework: DBC_SS obtains significant runtime improvements over sequential spectral sparsification, at 47% on average when running on 5 servers. DBC_GD runs 4, 52, and 71 times faster than sequential FM3, FR, and Stress Majorization respectively, while also producing graph drawings with similar or better quality than the sequential graph drawing algorithms.
For future work, we plan to design new graph sampling methods for big graph visualization, by combining other graph partitioning methods. For example, see (Meidiana et al. 2019) for an edge sampling method integrating spectral sparsification with the decomposition of biconnected graphs into triconnected components.