Spectral Graph Drawing: Building Blocks and Performance Analysis

Shad Kirmani Kamesh Madduri

eBay Inc. The Pennsylvania State University
Brisbane, CA University Park, PA
[email protected] [email protected]

Abstract—The objective of a graph drawing algorithm is to 1

automatically produce an aesthetically-pleasing two or three 2

dimensional visualization of a graph. Spectral graph theory

refers to the study of eigenvectors of matrices derived from 3

graphs. There are several well-known graph drawing algo-

4
rithms that use insights from spectral graph theory. In this
(a) (b) Spec- (c)
work, we experiment with two spectral methods to generate GraphViz tral: this Spectral:
drawings of large-scale graphs. We also combine spectral paper Lapla-
drawings with the multilevel paradigm, and this leads to cian

a larger collection of implementations. We analyze drawing Figure 1. Drawings of a small graph with four vertices and four edges.
quality and performance tradeoffs with these approaches. The drawing in (a) uses the default layout algorithm in Graphviz v2.38.
The drawing in (b) is based on an algorithm discussed in this paper. The
drawing in (c) uses two eigenvectors of the Laplacian matrix corresponding
to the graph.
1. Introduction

By spectral graph drawing, we refer to algorithms that

use eigenvectors of the graph Laplacian matrix or its variants
for the purpose of graph drawing. Spectral graph clus-
tering and spectral graph partitioning methods are closely
related to drawing algorithms. Informally, the objective of
a graph drawing algorithm is to assign coordinates (i.e., a
2/3-dimensional vector) to vertices, given a graph (without
vertex coordinates) as input. We consider the problem of
drawing unweighted, undirected graphs that are almost reg-
ular (i.e., all vertices have nearly the same degree). Figure 1
gives an example of three automatically generated drawings
or graph layouts. The first drawing is generated using the
open-source Graphviz package, the second one using one
of the implementations presented in this paper (based on Figure 2. A drawing of the 4elt [3] graph (15 606 vertices, 107 362 edges)
Koren’s algorithm [1]), and the third drawing using selected using an algorithm discussed in this paper.
eigenvectors of the Laplacian (Hall’s algorithm [2], very
closely related to Koren’s algorithm). Figure 2 is a drawing
of a much larger graph, using the same algorithm as the tering [6], [7]. In fact, we began working on this problem
approach used for Figure 1b. motivated by spectral graph partitioning.
Spectral graph drawing methods have many advantages: Our contributions: This work presents new implemen-
the problem formulations are mathematically sound (we tations of the algorithms in [1]. In addition to evaluating
formally introduce the problem in the next Section), the these algorithms on a large collection of graphs, we extend
solutions obtained are provably optimal under certain set- these algorithms by using them in a multilevel setting. Our
tings, implementations are typically fast, the algorithms are empirical evaluation has many interesting findings.
compatible with the multilevel paradigm, and the drawings Workshop relevance: We identify several building
generated are aesthetically pleasing. blocks for practical and high-performance spectral graph
While this work focuses on drawing, the intermediate drawing. While we focus on two approaches in this paper,
outputs from our implementations have several other uses, our software (to be open-sourced) already supports more
including graph embedding [4], partitioning [5], and clus- than a dozen variants. Further, we have experimented with
several implementations of the same algorithm, both stand- are the solutions to a constrained minimization problem that
alone and library-based. The results presented in this paper is closely related to graph drawing aesthetics (see Equation
are based on implementations that use the Eigen [8] C++ 15 in [1]). Hall’s algorithm refers to the use of the two
linear algebra library. Further, our implementations can be lowest eigenvectors of the Laplacian for layout. In con-
used for new parallel graph analysis benchmarking. trast, Koren’s algorithm uses the p lowest degree-normalized
eigenvectors. These vectors are also used for image segmen-
2. Background tation [10], but with a different motivation. Since D−1 A has
the same degree-normalized eigenvectors in reverse order,
Koren gives a variant of the Power iteration to compute the
We denote a graph as G(V, E, W ), where V = p leading nondegenerate eigenvectors. We list this approach
{1, . . . , n} is the set of vertices and E is the set of edges. in Algorithm 1. The familiar Power iteration is augmented
We assume the graph is undirected and has no self loops or with a Gram-Schmidt-like orthogonalization scheme.
parallel edges. An edge hi, ji can have a non-negative real
edge weight W (i, j) representing the similarity of vertices Algorithm 1 Algorithm for computing degree-normalized
i and j . For unweighted graphs, the edge weights are all eigenvectors (Koren’s algorithm [1] with minor changes).
set to 1. The weighted degree of a vertex is the sum of the
Input: G, p (desired dimensions), u1 (top (degenerate)
weights of its attached edges.
eigenvector),  (tolerance)
Let A denote the symmetric adjacency matrix corre- Output: u2 , . . . , up+1 , the top p nondegenerate eigenvec-
sponding to the graph, with A(i, j) = W (i, j) if hi, ji ∈ E , tors of D−1 A
and 0 otherwise. Let D denote the degrees matrix, a diagonal 1: M ← 21 (I + D −1 A)
matrix with D(i, i) set to the weighted degree of vertex 2: for k ← 2, p + 1 do
i. The Laplacian L is another symmetric matrix given by 3: v ← random vector of size n
D −A. The properties of the Laplacian are well studied. We 4: Normalize v
will state some of its properties relevant to graph drawing 5: repeat
in this section, but please see Koren’s paper [1] and refer- 6: uk ← v
ences therein for more details. Spielman’s book chapter on 7: for l ← 1, k − 1 do
Spectral Graph Theory [9] is a good reference. The degree 0
u Dul
normalized matrix D−1 A is called the transition matrix or 8: uk ← uk − k0 ul . D-Orthogonalize
the walk matrix. ul Dul
The p-dimensional layout of a graph is defined by p 9: v ← M uk . Similar to Power iteration
vectors x1 , . . . , xp ∈ Rn , where xk (i) corresponds to the 10: Normalize v
coordinate of vertex i in the k th dimension. In practice, p 11: until kv − uk k < 
is chosen to be 2 or 3 for screen layouts. The vertices can 12: uk ← v
be connected by straight lines to produce a drawing. The
Euclidean distance dij betweenvvertices i and j in the p-
u p
uX Algorithm 2 Weighted Centroid smoothing of coordinates.
2
dimensional layout is given by t (xk (i) − xk (j)) . Input: D, A, nsmooth , x, y
k=1 Output: x, y
any vector y ∈ Rn , it can be shown that y 0 Ly
GivenX 1: for i ← 1, nsmooth do
equals
2
W (i, j) (y(i) − y(j)) . This fact is directly 2: x ← D−1 Ax
hi,ji∈E
3: y ← D−1 Ay
related to an optimal layout of a graph. Additionally, the
Laplacian satisfies many interesting properties. Since L In practice, if we want to generate a 2D drawing, we
is symmetric and positive semidefinite, all its n eigen- can use the ith elements of the two leading vectors obtained
values are real and nonnegative, and its eigenvectors are from Algorithm 1 as X and Y coordinates for vertex i.
orthogonal. 1n is an eigenvector of L with a correspond- These coordinates can be used to visualize vertices as well
ing eigenvalue of 0. If the graph is connected, the multi- as edges (by connecting vertices by straight lines).
plicity of the eigenvalue 0 is exactly 1. The eigenvalues The multilevel paradigm is a heuristic to accelerate
of the Laplacian are conventionally ordered from low to graph and linear algebra computations, and can be applied
high, 0 = λ1 < λ2 ≤ · · · ≤ λn . Given D and L, to eigenvector computations as well. In multilevel spectral
the eigenpair (u, µ) are termed a generalized eigenpair if methods, graphs are recursively coarsened, eigenvectors are
Lu = µDu. D-normalization is a way to uniquely specify computed for the matrix corresponding to the coarsest graph,
the uk eigenvectors: u0k Duk = 1, k = 1, . . . , n. The vectors and the coarse graph vectors are then projected back to
uk are called degree-normalized eigenvectors. It can be the original graph. Multilevel schemes are extensively used
easily shown that the degree-normalized eigenvectors are because they are very fast and are shown to work well for
also the (nongeneralized) eigenvectors of matrix D−1 A, real-world graphs and matrices.
using the fact that L = D−A. The eigenvalues are in reverse There are exist alternatives to the heavyweight eigen-
order. Koren shows that the degree-normalized eigenvectors vector computation of Algorithm 1. To refine a projected
Algorithm 3 High Dimensional Embedding (HDE). takes negligible time. Once the s-dimensional eigenvectors
Input: G, L (Laplacian), s (subspace dimension) have been computed, we get the projected coordinates by
Output: x, y computing By .
1: Initialize S ∈ Rn×(s+1)
2: Initialize B ∈ Rn×s 3. Our Spectral Drawing Implementations
3: S0 ← 1 . first column of S
4: Normalize S0 Encouraged by the simplicity of Koren’s algorithm, we
5: sv ← randomly-chosen starting vertex started by implementing this approach as stated in [1]. How-
6: Initialize d ∈ Rn ever, we found that the recommended convergence check
7: for i ← 1, s do of computing the dot product of the vectors uk and v
8: Bi ← BFS(sv ) resulted in unsatisfactory drawings for some of our test
9: Si ← Bi inputs. We thus modified the convergence check to the norm
10: Normalize Si of difference of the vectors, as shown on line 11 of Algo-
11: for l ← 0, i − 1 do rithm 1. We then encountered the problem of extremely slow
12: Si ← Si − (Sl0 Si )Sl . Orthogonalize convergence, and this motivated us to implement the High
13: d ← min dj , Bij ∀j ∈ [1, n] Dimensional Embedding (HDE) scheme. Independently, we
14: sv ← arg max d were exploring spectral drawings in the multilevel paradigm,
where we coarsen a graph, compute the eigenvectors on the
15: S ← S[1, n] . Drop degenerate vector
coarse graph, and then uncoarsen and refine these eigenvec-
16: Ys×2 ← Top two eigenvectors of S T LS
tors. We then realized that our disparate implementations
17: [x, y] ← BY
can be expressed and used together in a common framework.
Algorithm 4 summarizes how we develop a large number of
graph drawing algorithmic variants. Executing Algorithm 1
layout generated by a multilevel method, a small number of is akin to going to step 4 in Algorithm 4, avoiding the
smoothing rounds can be applied, which is shown concisely speedup heuristics steps 1, 2, and 3. The multilevel paradigm
in Algorithm 2 [11]. In each smoothing round, the coordi- neatly fits within this framework because we can use the
nate of a vertex is updated to be the weighted average of dominant degree-normalized eigenvectors corresponding to
the coordinates of its adjacencies. We call this the Weighted the coarse graph to initialize vectors for the full graph.
Centroid smoothing strategy, and this is closely related to Koren also mentions the connection of his algorithm to the
Koren’s algorithm, a few iterations without normalization or Weighted Centroid smoothing scheme. If we intentionally
orthogonalization may be applied. In practice, Algorithm 2 choose nsmooth to be a small-enough value, we can avoid de-
works well if we have a layout that is close to global generate solutions while simultaneously improving drawing
optimality, but has some local perturbations. quality. Finally, HDE is also compatible with coarsening.
Instead of doing an aggressive coarsening of the graph,
2.1. High Dimensional Embedding we can generate a moderately-coarse graph, determine the
degree-normalized eigenvectors for this coarse graph with
Harel and Koren give another speedup heuristic to Algo- HDE initialization, and project the vectors to the full graph.
rithm 1. This approach is called High Dimensional Embed- We can enumerate 24 variants from Algorithm 4. One
ding (HDE) and is described in Algorithm 3 [12]. A HDE variant (skipping all four steps) is not useful and can thus be
is computed by constraining the layout algorithm to be in a ignored. This leaves us with 23 variants, ranging from step
s-dimensional subspace, Sn×s . s is usually chosen to be a 4 only to performing all four steps. Performing only Step
very small value, say 10. Constraining the layout to a well 3 after random initialization can also be omitted, getting us
chosen s-subspace helps in computing layouts of reasonable to 22 variants.
quality in very limited amount of time. The next issue to consider is setting the defaults for steps
The s-subspace is carefully constructed using graph the- 1 to 4. For coarsening alone, there exist a number of algo-
oretic distances of all vertices starting from s start vertices. rithms that we can employ [13]. We initially experimented
More precisely, each vector in the s-subspace is the Breadth- with the heavy edge matching routine in Metis v4.0.3 [14].
First Search (BFS) distance of the vertices from s different Even this routine had numerous parameters to set, and so
starting vertices. These BFS distance vectors make the ma- we developed a very simple coarsening scheme to use as a
trix Bn×s . Another matrix S , derived from the matrix Bn×s , baseline. We coarsen the graph by computing maximal edge
whose vectors are orthonormalized BFS distance vectors. matchings. We compute the matching by visiting vertices in
Each successive start vertex for BFS is chosen as the ver- order of their identifier (1 to n), and inspecting adjacen-
tex that is the farthest from all previous start vertices. This cies in sorted order. If vertex i is unmatched and has an
is achieved by keeping a vector of minimum distance from unmatched neighbor j , we add edge hi, ji to the matching
any start vertex in lines 6, 13, and 14 of the Algorithm 3. and mark both vertices i and j as matched. In the coarser
To constrain the layout in the s-subspace, 0
we find the graph, the lower value of i and j is used as the new vertex
eigenvectors ys of the matrix S 0 LS . Since S LS is an s × s identifier and the process is repeated. We perform at most
matrix and s is usually very small, eigenvector computation 100 iterations of matching or coarsen until the vertex count
is less than 1000. These parameters are also currently fixed Algorithm 4 A practical framework for spectral graph
in order to reduce the space of implementations to consider. drawing.
This coarsening scheme generates a coarse graph without Input: G(V, E)
any randomization, and may perform poorly on adversarial Output: Two vectors x, y ∈ Rn to use as coordinates for
inputs. However, for the graphs we have experimented with vertices in V .
so far, we did not encounter bad cases. x, y ← randomly initialized vectors
We have not yet fixed a threshold for moderate coars- 1: Update x, y by using eigenvectors from coarsened G
ening. We did some ad-hoc experimentation to combine . Two options: coarsen, do not coarsen
coarsening and HDE, but we do not report on these results 2: Update x, y by HDE
in the current submission. . Three options: HDE on full graph, HDE on
HDE is parameterized by s, the number of starting points coarsened graph, no HDE
in the graph to perform Breadth-First Searches from. We 3: Update x, y using Weighted Centroid smoothing
currently set this value to 10. . Two options
For the Weighted Centroid smoothing, we set nsmooth to 4: Use x, y to initialize Algorithm 1, and set x, y to the
500 based on limited ad-hoc experimentation. output of Algorithm 1
The key parameter in the degree-normalized eigenvector . Two options
computation is the tolerance . We use a tolerance setting of
10−6 for the top eigenvector and a setting of 2 × 10−6 for
the next eigenvector. The rate of convergence is dependent sfdp multilevel force-directed layout algorithm [16]. Hu’s
on the ratio of magnitude of eigenvalues. For nearly all visualizations also give the CPU time for the drawing, and
the real-world graphs we experimented with, the dominant these can be compared with our running times. We removed
eigenvalue was very close to the degenerate solution. The self loops and parallel edges in the input graphs, and ignored
first three digits following the decimal point were all 9’s any edge weights, if present. Thus, we effectively treated
in most cases. This means that we had to perform at least all matrices as unweighted graphs. While the spectral algo-
1000s of iterations for each eigenvector. rithm can handle edge weights, we wanted to start with a
While it may be tempting to choose a fast heuristic simplified setup. Our approaches—with the current default
variant (i.e., activate all or most of steps 1 to 3 before settings—fail to produce good drawings for some large
step 4), note that we have no theoretical guarantee that we matrices in the SuiteSparse collection, and we suspect this
will converge to the dominant eigenvectors if we use these is an artifact of using just two eigenvectors for the drawings.
heuristics. Given that the eigenvalues are so close to each We report performance results on a single compute node
other, we might end up converging to a non-dominant eigen- of the Comet supercomputer, operated by the San Diego
vector. Thus, our baseline in this study is to use Algorithm 1 Supercomputer Center at UC San Diego. Comet is available
with a conservative tolerance value. through the Extreme Science and Discovery Environment
After obtaining coordinates, the final step of generating (XSEDE) program [17]. The compute node we use has
the drawing remains. We use a very simple approach in the two 12-core Intel(R) Xeon(R) CPU E5-2680 v3 (Haswell)
current work. We scale the X coordinates to integer values processors clocked at 2.50 GHz. Each node has 128 GB
that lie in [0, 10000]. We set the Y coordinates to integers DDR4 DRAM memory. The STREAM Triad bandwidth is
while preserving the aspect ratio. We use a Portable Network 104 GB/s. We use the Intel C++ compiler (version 16.0.3) to
Graphics (PNG) format file writer in Python for storing the build our code. We compile our code with OpenMP support
image, after connecting vertices using straight lines of fixed and the optimization flags -xHOST -O3.
thickness. We have not experimented with colors yet. This We use the Eigen C++ linear algebra library (v3.3.4),
step of generating the image files is currently not timed. We primarily for the sparse matrix-vector multiplication and
use the OS X command line utility sips to further compress orthogonalization required in Algorithm 1. Before using
these images, specifying a resampling setting of 1000. The Eigen, we developed standalone implementations for some
drawings included in this paper are all generated according of the functionality in Algorithm 4, but the code started to
to this scheme. become quite unwieldy. Using Eigen greatly simplified our
work. We are also able to leverage Eigen’s parallelization
4. Empirical Evaluation and vectorization of underlying routines.

4.1. Experimental Setup 4.2. Performance of Koren’s algorithm

We evaluate the graph drawing implementations on a In Table 2, we report on the performance of Koren’s
collection of sparse graphs. Table 1 lists some of the graphs algorithm without any speedup heuristics. For the last five
we experimented with. Most of these graphs are taken graphs listed in the table, we use a tolerance of 1e-5 because
from the SuiteSparse matrix collection [15]. Our drawings of slow convergence. We report overall time in seconds,
can be compared with Yifan Hu’s visualizations (available including file I/O, memory allocation, and initialization
at http://yifanhu.net/GALLERY/GRAPHS/) based on the costs. We also report the aggregate times for computing the
 TABLE 1. T HE COLLECTION OF UNDIRECTED GRAPHS ( SYMMETRIC in Figure 2. As we can observe with Figure 3b, if the
SPARSE MATRICES ) USED IN THIS STUDY. T HE NUMBER OF VERTICES threshold is raised higher, warping effect gets more acute.
(n), NUMBER OF EDGES (m), AND SOURCE ARE GIVEN .
It is difficult to identity beforehand when the graph drawing
may be warped, and so we had to experiment with a large
Graph n m Source
collection of tolerance values, before settling on the defaults
grid6400 6400 12 640 own used in this work.
crack 10 240 30 380 [15]
4elt 15 606 45 878 [3]
finance256 37 376 130 560 [15] 4.4. Impact of Coarsening and HDE
oilpan 73 752 1 761 718 [15]
apache1 80 800 230 692 [15]
filter3D 106 437 1 300 371 [15] In Table 3, we present the running time overhead of
para-5 155 924 2 630 217 [15] just the initialization strategies. Instead of starting from
d pretok 182 730 756 256 [15] random vectors, we can use projected coarsened coordinates
turon m 189 924 778 531 [15] or HDE initialization. The time taken to compute projected
mario002 389 874 933 557 [15]
pa2010 421 545 1 029 231 [15] coarsened coordinates is in general very low, but for some
ecology1 1 000 000 1 998 000 [15] graphs, such as mario002 and pa2010, the time is very high.
G3 circuit 1 585 478 3 037 674 [15] This is because of the stringent tolerance criterion (1e-7)
kkt power 2 063 494 6 482 320 [15] used to assess convergence when using the coarser graph.
On the other hand, HDE initialization is relatively fast for
all graphs, because eigenvector computation is performed
two leading eigenvectors. It is immediately apparent that on a tiny graph.
the eigenvector computation time is the main contributor to In Table 4, we present the performance, running time
the overall time. The times reported are for 24-thread runs, improvement, and iteration counts of Algorithm 1, if ini-
and so we also report speedup based on the times obtained tialized with projected coarsened coordinates. To compute
with a single-threaded run. Finally, we list the number of second eigenvector, we achieve speedups ranging from 1.4×
loop iterations required to satisfy the desired tolerance, and to 988×. The iteration count drops if the projected coarsened
compute a per-iteration performance rate, by normalizing graph coordinates are used. For instance, filter3D requires
running time by number of edges. Inspecting this Table by 152 426 iterations to compute second eigenvector with ran-
column, it is unsurprising that the graph size is correlated dom initialization, but requires only 16 602 iterations when
with running time. The two largest graphs by vertex count initialized with projected coarsened graph coordinates. We
also take the longest time to finish. observe similar results for computing the third eigenvector
Observe that the 24-core parallel speedup is relatively as well.
low. This may be because of the small matrix sizes and Figure 4 shows two different drawings of the 4elt input,
OpenMP overheads in matrix-vector multiplication. Now both using Algorithm 1 for refinement, but with different
that we have a reference implementation, we can optimize initialization strategies. We observe that these drawings are
performance by substituting a tuned sparse matrix-vector nearly identical to the drawing with random initialization.
multiplication routine. Speedup also appears to be correlated
with average vertex degree and is higher for denser graphs.
The number of iterations required varies from input to 4.5. Performance of Fast Variants
input, and is dependent on the ratio of the eigenvalues and
the quality of our initial random estimate. filter3D has the In Table 6, we present the performance of a variant of
largest iteration count for the second eigenvector, but with Algorithm 4, with HDE initialization and Weighted Centroid
the caveat that we used a higher threshold for the last five smoothing Algorithm 2. We see that the time taken to
graphs. 4elt was a particularly challenging input and the compute drawings is considerably smaller, and the speedups
residual for the third eigenvector briefly shows an increasing range from 22× for small graphs to 130× for larger graphs.
trend, before again reducing. As we see next, the quality of the drawing computed with
Inspecting the rate provides more insight into perfor- this algorithm is almost similar for small graphs and better
mance and room for improvement. The rate varies as much for larger graphs.
as 10× from input to input. It is highest for the graph
with the largest m/n ratio, suggesting that the sparse matrix 4.6. Drawing Quality
vector multiply operations offset any overhead due to non-
parallelization of the orthogonalization-related steps. In Figure 5, we compare the drawings computed using
the exact method described in Algorithm 1 and the ap-
4.3. Sensitivity to default parameters proximate variant using HDE along with Weighted Centroid
smoothing described in Algorithm 2. In general, we observe
In Figure 3, we observe a warping effect when the that HDE with weighted centroid smoothing computes good
threshold for convergence in Algorithm 1 is set higher than global layouts, i.e., no warping effects in the drawing. The
the default threshold parameter of 1e-6. In Figure 3a, notice details are also preserved well. On the other hand, exact
that the drawing for 4elt is not as smooth as the drawing Algorithm 1, computes locally smoother drawings, but can
 inant degree-normalized eigenvectors. We find that we need
to compute the vectors to a high degree of accuracy in order
to generate aesthetically-pleasing layouts. An extremely fast
heuristic works surprisingly well. We also observe different
algorithmic variants highlighting different features of the
graph in the layout.
We foresee a number of directions for future research.
An immediate goal would be to extend the evaluation and
make it more comprehensive, along the lines of Hu’s graph
(a) eps = 5 × 10−5 visualization gallery. Identifying good defaults to use for
various parameters is another short-term goal. Finally, we
want to explore parallel performance and scalability bottle-
necks in greater depth.
There are several closely-related problems areas where
we can directly use the computed degree-normalized eigen-
values. Graph embedding and partitioning problems are the
most promising avenues.

Acknowledgments
(b) eps = 10−4
This work is supported by the US National Science
Figure 3. The drawing quality is sensitive to the convergence threshold used Foundation grant #1253881. This work used the Extreme
in our algorithm. We give drawings for the 4elt input with two different
eps settings. These can be compared to the drawing in Figure 2, which Science and Engineering Discovery Environment (XSEDE),
uses the default tolerance value. which is supported by National Science Foundation grant
number ACI-1548562.

References
[1] Y. Koren, “Drawing graphs by eigenvectors: theory and practice,”
Computers & Mathematics with Applications, vol. 49, no. 11, pp.
1867–1888, 2005.
[2] K. M. Hall, “An r-dimensional quadratic placement algorithm,” Man-
agement science, vol. 17, no. 3, pp. 219–229, 1970.
[3] C. Walshaw, “Walshaw’s graph partitioning archive,” 2016, http:
(a) Coarsening
//chriswalshaw.co.uk/partition, last accessed Feb 2018.
[4] H. Cai, V. W. Zheng, and K. C. Chang, “A comprehensive survey
of graph embedding: Problems, techniques and applications,” 2017,
arXiv preprint abs/1709.07604.
[5] S. Kirmani and P. Raghavan, “Scalable parallel graph partitioning,”
in Proc. Int’l. Conf. on high performance computing, networking,
storage and analysis (SC), 2013.
[6] M. Filippone, F. Camastra, F. Masulli, and S. Rovetta, “A survey
of kernel and spectral methods for clustering,” Pattern Recognition,
vol. 41, no. 1, pp. 176–190, 2008.
[7] S. White and P. Smyth, “A spectral clustering approach to finding
(b) HDE
communities in graphs,” in Proc. SIAM Int’l. Conf. on Data Mining
Figure 4. Drawings of the 4elt graph when using initialized vectors from (SDM), 2005.
coarsening and HDE. [8] G. Guennebaud, B. Jacob et al., “Eigen v3,”
http://eigen.tuxfamily.org, 2010.

suffer from warping effects when the graphs are large with [9] D. Spielman, “Spectral graph theory,” in Combinatorial Scientific
Computing, U. Naumann and O. Schenk, Eds. CRC Press, 2012,
large convergence thresholds. For smaller graphs, such as ch. 18.
crack, finance256, oilpan, etc. we can observe that using
[10] J. Shi and J. Malik, “Normalized cuts and image segmentation,” IEEE
Algorithm 1 alone computes more symmetric drawings. Transactions on Pattern Analysis and Machine Intelligence, vol. 22,
no. 8, pp. 888–905, 2000.
5. Conclusions and Future Work [11] W. T. Tutte, “How to draw a graph,” Proc. London Mathematical
Society, vol. 3, no. 1, pp. 743–767, 1963.
This work presents a number of spectral graph drawing [12] D. Harel and Y. Koren, “Graph drawing by high-dimensional embed-
algorithmic variants, all focused on computing the two dom- ding,” in Proc. Int’l. Symp. on Graph Drawing, 2002.
 m
TABLE 2. P ERFORMANCE OF THE ‘ EXACT ’ APPROACH ( WITHOUT COARSENING OR HDE). R ATE IS CALCULATED AS 1e6∗t∗c
. N UMBERS
EMPHASIZED IN BOLD FONT ARE DISCUSSED IN THE PAPER .

Overall Parallel Second eigenvector Third eigenvector

Graph
Time (s) Speedup Iter c Time t (s) Rate Iter c Time t (s) Rate
grid6400 4 1.44 25 169 1.6 197 28 643 2.0 184
crack 13 1.60 74 027 9.4 238 28 313 3.6 239
4elt 31 1.70 66 664 11.7 261 100 348 19.0 242
finance256 23 1.78 30 999 12.1 335 23 560 10.2 301
oilpan 140 4.66 115 420 110.3 1843 26 564 28.7 1630
apache1 56 1.80 43 286 34.4 291 23 170 20.5 260
filter3D 213 3.96 152 426 180.1 1101 24 074 31.7 986
para-5 166 4.07 37 651 91.3 1084 27 504 72.4 999
d pretok 230 2.19 47 102 83.5 426 75 795 144.5 397
turon m 352 2.23 126 801 232.5 425 56 908 117.2 378
mario002 323 2.61 39 017 165.5 220 32 593 153.7 198
pa2010 335 2.71 54 516 227.7 246 21 000 103.7 208
ecology1 1286 1.81 85 370 955.9 178 24 748 321.1 154
G3 circuit 1417 2.07 47 819 917.6 158 21 941 484.9 137
kkt power 1448 1.75 18 121 584.4 201 23 448 843.8 180

TABLE 3. T HE TIME TAKEN FOR COARSENING AND HDE WITH TABLE 5. P ERFORMANCE OF THE EIGENVECTOR COMPUTATION STEPS
DEFAULT SETTINGS . N OTE THAT THESE TIMES INCLUDE EIGENVECTOR USING THE HDE VECTORS FOR INITIALIZATION .
COMPUTATION FOR THE SMALLER GRAPH .
Second eigenvector Third eigenvector
Graph
Time (s) Time (s) Speedup Iter c Time (s) Speedup Iter c
Graph
Coarsening HDE
grid6400 0.6 2.6 3335 0.5 4.2 2777
grid6400 0.44 0.19 crack 4.1 2.3 13 263 4.4 0.8 13 353
crack 0.29 0.13 4elt 12.7 0.9 36 260 7.5 2.5 22 181
4elt 0.34 0.12 finance256 8.0 1.5 16 969 6.4 1.6 13 854
finance256 0.70 0.14 oilpan 23.2 4.8 16 404 19.1 1.5 12 890
oilpan 0.35 0.19 apache1 7.3 4.7 7133 6.4 3.2 5660
apache1 0.24 0.15 filter3D 205.8 0.9 168 588 11.5 2.8 8347
filter3D 1.88 0.13 para-5 126.8 0.7 45 136 87.9 0.8 28 084
para-5 0.60 0.29 d pretok 50.3 1.7 23 741 179.8 0.8 82 147
d pretok 0.10 0.24 turon m 56.7 4.1 25 949 37.5 3.1 15 282
turon m 0.12 0.24 mario002 165.3 1.0 38 168 70.7 2.2 13 480
mario002 388.69 0.41 pa2010 309.6 0.7 65 791 208.5 0.5 36 194
pa2010 129.19 0.45 ecology1 256.5 3.7 19 192 62.3 5.2 4172
ecology1 5.34 0.70 kkt power 490.5 1.2 15 734 568.4 1.5 15 586
kkt power 28.80 2.88

TABLE 6. P ERFORMANCE OF A FAST VARIANT (HDE AND WEIGHTED

TABLE 4. P ERFORMANCE OF THE EIGENVECTOR COMPUTATION STEPS CENTROID REFINEMENT ) AND SPEEDUP OVER THE ‘ EXACT ’ APPROACH
WITH COARSENED GRAPH INITIALIZATION . IN TABLE 2.

Second eigenvector Third eigenvector Graph Time (s) Speedup

Graph
Time (s) Speedup Iter c Time (s) Speedup Iter c
grid6400 0.17 22.2
grid6400 0.2 7.6 169 0.0 151.0 157 crack 0.47 28.2
crack 1.1 8.9 7314 1.9 1.9 13 166 4elt 0.47 65.7
4elt 3.8 3.1 21 378 4.9 3.9 25 385 finance256 0.80 28.3
finance256 5.0 2.4 12 220 3.5 2.9 8103 oilpan 1.75 80.3
oilpan 15.1 7.3 13 791 25.8 1.1 20 947 apache1 1.28 43.6
apache1 3.9 8.9 5448 38.7 0.5 47 784 filter3D 2.31 92.5
filter3D 0.2 988.6 16 602 1.7 18.7 148 191 para-5 4.84 34.3
para-5 64.6 1.4 22 291 35.9 2.0 11 406 d pretok 2.42 95.1
d pretok 54.3 1.5 34 558 388.6 0.4 216 209 turon m 2.67 131.6
turon m 66.2 3.5 39 979 66.2 1.8 35 116 mario002 5.54 58.4
mario002 8.6 19.2 2311 4.7 32.5 1045 pa2010 6.05 55.4
pa2010 10.5 21.8 2562 11.9 8.7 2389 ecology1 13.55 94.9
ecology1 37.8 25.3 3104 56.0 5.7 3777 G3 circuit 21.34 66.4
kkt power 390.8 1.5 13 360 459.4 1.8 13 698 kkt power 35.75 40.5

[13] C. Chevalier and I. Safro, “Comparison of coarsening schemes for 2009, pp. 191–205.
multilevel graph partitioning,” in Learning and Intelligent Optimiza-
tion, T. Stützle, Ed. Berlin, Heidelberg: Springer Berlin Heidelberg, [14] G. Karypis and V. Kumar, “A fast and high quality multilevel scheme
 (a) grid6400 (b) crack (c) 4elt

(d) finance256 (e) oilpan (f) apache1

(g) filter3D (h) para-5 (i) d pretok

(j) turon m (k) mario002 (l) pa2010

(m) ecology1 (n) G3 circuit (o) kkt power

Figure 5. Drawings of all 15 test graphs using two methods: Exact (left) and HDE + weighted centroid refinement (right).

for partitioning irregular graphs,” SIAM Journal on Scientific Com- ematica Journal, vol. 10, no. 1, pp. 37–71, 2005.
puting, vol. 20, no. 1, pp. 359–392, 1998, http://glaros.dtc.umn.edu/
[17] J. Towns, T. Cockerill, M. Dahan, I. Foster, K. Gaither, A. Grimshaw,
gkhome/fsroot/sw/metis/OLD, last accessed Feb 2018.
V. Hazlewood, S. Lathrop, D. Lifka, G. D. Peterson, R. Roskies,
[15] T. A. Davis and Y. Hu, “The University of Florida sparse matrix col- J. R. Scott, and N. Wilkins-Diehr, “XSEDE: Accelerating scientific
lection,” ACM Trans. Math. Softw., vol. 38, no. 1, pp. 1–25, 2011, http: discovery,” Computing in Science & Engineering, vol. 16, no. 5, pp.
//faculty.cse.tamu.edu/davis/matrices.html, last accessed Feb 2018. 62–74, 2014.
[16] Y. Hu, “Efficient, high-quality force-directed graph drawing,” Math-