We consider the maximum vertex-weighted matching problem (MVM) for non-bipartite graphs in which non-negative weights are assigned to the vertices of a graph and a matching that maximizes the sum of the weights of the matched vertices is desired. In earlier work we have described a 2/3-approximation algorithm for the MVM on bipartite graphs (Florin Dobrian et al., 2019). Here we show that a 2/3-approximation algorithm for MVM on non-bipartite graphs can be obtained by restricting the length of augmenting paths to at most three. The algorithm has time complexity O(m log + n log n), where n is the number of vertices, m is the number of edges, and is the maximum degree of a vertex. The approximation ratio of the algorithm is obtained by considering failed vertices, i.e., vertices that the approximation algorithm fails to match but the exact algorithm does. We show that there are two distinct heavier matched vertices that we can charge each failed vertex to. Our proof techniques characterize the structure of augmenting paths in a novel way. We have implemented the 2/3-approximation algorithm and show that it runs in under a minute on graphs with tens of millions of vertices and hundreds of millions of edges. We compare its performance with five other algorithms: an exact algorithm for MVM, an exact algorithm for the maximum edge-weighted matching (MEM) problem, as well as three approximation algorithms. The approximation algorithms include a 1/2 approximation algorithm for MVM, and (2/3 - E)-and (1 - E)-approximation algorithms for the MEM. In our test set of nineteen problems, there are graphs on which the exact algorithms fail to terminate in 100 hours. In addition, the new 2/3-approximation algorithm for MVM outperforms the other approximation algorithms by either being faster (often by orders of magnitude) or obtaining better weights. (c) 2019 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/).
In this paper, we derive generalized vertex gains for computing vertex separators, greatly improving the efficiency and data reuse in hybrid graph partitioning contexts. Using these generalized gains, we design a novel algorithm for computing vertex separators in arbitrary graphs and compare our approach to METIS, a popular graph partitioning library. In general, our hybrid algorithm scales well to very large graphs with the increased information sharing that the generalized gains afford.
We investigate various combinatorial problems arising in the minimization of the number of arithmetic operations performed during the evaluation of matrix chain products. Sparsity as well as numerical equality of arbitrary entries of the matrix factors are taken into account by the Numerical Sparse Matrix Chain Product problem which turns out to be NP-complete. The computational complexity of the Structural Sparse Matrix Chain Product problem which assumes numerically distinct matrix entries remains open. Prior work on elimination techniques for the accumulation of Jacobian matrices in the context of algorithmic differentiation is built on.
We investigate algorithms for finding column permutations of sparse matrices in order to have large diagonal entries and to have many entries symmetrically positioned around the diagonal. The aim is to improve the memory and running time requirements of a certain class of sparse direct solvers. We propose efficient algorithms for this purpose by combining two existing approaches and demonstrate the effect of our findings in practice using a direct solver. We show improvements in a number of components of the running time of a sparse direct solver with respect to the state of the art on a diverse set of matrices.
The traveling salesman problem (TSP) is presumably difficult to solve exactly using local search algorithms. It can be exactly solved by only one algorithm—the enumerative search algorithm. However, the scanning of all possible solutions requires exponential computing time. Do we need exploring all the possibilities to find the optimal solution? How can we narrow down the search space effectively and efficiently for an exhausted search? This chapter attempts to answer these questions. A local search algorithm is a discrete dynamical system, in which a search trajectory searches a part of the solution space and stops at a locally optimal point. A solution attractor of a local search system for the TSP is defined as a subset of the solution space that contains all locally optimal tours. The solution attractor concept gives us great insight into the computational complexity of the TSP. If we know where the solution attractor is located in the solution space, we simply completely search the solution attractor, rather than the entire solution space, to find the globally optimal tour. This chapter describes the solution attractor of local search system for the TSP and then presents a novel search system—the attractor-based search system—that can solve the TSP much efficiently with global optimality guarantee.
Running numerical simulations on HPC architectures requires distributing data to be processed over the various available processing units. This task is usually done by partitioning tools, whose primary goal is to balance the workload while minimizing inter-process communication. However, they do not take the memory load and memory capacity of the processing units into account. As this can lead to memory overflow, we propose a new approach to address mesh partitioning by including ghost cells in the memory usage and by considering memory capacity as a strong constraint to abide. We model the problem using a bipartite graph and present a new greedy algorithm that aims at producing a partition according to the memory capacity. This algorithm focuses on memory consumption, and we use it in a multi-level approach to improving the quality of the returned solutions during the refinement phase. The experimental results obtained from our benchmarks show that our approach can yield solutions respecting memory constraints for instances where traditional partitioning tools fail.
We consider how to generate graphs of arbitrary size whose chromatic numbers can be chosen (or are well-bounded) for testing graph coloring algorithms on parallel computers. For the distance-1 graph coloring problem, we identify three classes of graphs with this property. The first is the Erdos-Renyi random graph with prescribed expected degree, where the chromatic number is known with high probability. It is also known that the Greedy algorithm colors this graph using at most twice the number of colors as the chromatic number. The second is a random geometric graph embedded in hyperbolic space where the size of the maximum clique provides a tight lower bound on the chromatic number. The third is a deterministic graph described by Mycielski, where the graph is recursively constructed such that its chromatic number is known and increases with graph size, although the size of the maximum clique remains two. For Jacobian estimation, we bound the distance-2 chromatic number of random bipartite graphs by considering its equivalence to distance-1 coloring of an intersection graph. We use a "balls and bins" probabilistic analysis to establish a lower bound and an upper bound on the distance-2 chromatic number. The regimes of graph sizes and probabilities that we consider are chosen to suit the Jacobian estimation problem, where the number of columns and rows are asymptotically nearly equal, and have number of nonzeros linearly related to the number of columns. Computationally we verify the theoretical predictions and show that the graphs are often be colored optimally by the serial and parallel Greedy algorithms.
Adjoint methods are an efficient approach for computing gradient information. Together with the favorable temporal complexity result for the computation of adjoints, however, comes a memory requirement that is in essence proportional to the operation count of the underlying function, for example, if algorithmic differentiation is used to provide the adjoints. For this reason, several checkpointing approaches, including binomial checkpointing, have become popular. This paper analyzes an extension of checkpointing strategies to cover restarting the computation of adjoints. Such an extension is of special interest for long-running, parallel simulations executing on large-scale computing systems, since the simulations cannot complete the calculation of the adjoints within a maximal time allocation. We describe an exhaustive search to determine checkpointing strategies with minimal runtime when covering resilience, analyze their structure and show the resulting construction principle.
SuiteSparse:GraphBLAS is a complete implementation of the GraphBLAS standard. It provides a powerful and expressive framework for creating graph algorithms based on the elegant mathematics of sparse matrix operations on a semiring. Algorithms written with the GraphBLAS achieve high performance with minimal development time. Multithreaded parallelism through OpenMP provides additional speedup, which we illustrate on a 20-core Intel((R)) Xeon((R)) E5-2698 CPU system when solving various problems (triangle counting, k-truss, breadth-first search, Bellman-Ford, local clustering coefficient, and a sparse deep neural network problem). This wide variety of algorithms illustrates the expressiveness of the GraphBLAS API to create new graph algorithms. We present performance results with these algorithms on a set of large real-world graphs, using the newly developed Suite-Sparse:GraphBLAS v3.0.1.
The increase in machine size and the decrease in operating voltage have made errors more common, both soft (bit flip) and hard (component failure). Checkpoint-restart solutions address the problem of hard errors, but incur significant costs in time and hardware. For some algorithms, classical matrix multiplication included, tailored solutions incur much lower overhead. Existing efficient algorithmic tolerance techniques typically aim for iterative algorithms, and thus cannot be applied to recursive algorithms, such as fast matrix multiplication algorithms. By utilizing combinatorial aspects of the computational graphs of these algorithms, we obtain fault resilience with small overhead costs, for Strassen's and other recursive fast matrix multiplication algorithms. To the best of our knowledge, this is the first fault-tolerant solution tailored for fast matrix multiplication algorithm. Our solution is asymptotically better than any of the previous (classical based) fault-tolerant solutions, unless the error rate is extremely high. Our technique can be used to obtain fault tolerance for other recursive algorithms. In addition, we show how to reduce communication costs using additional processors, and discuss inherent fault tolerance capabilities of fast matrix multiplication algorithms.
Estimating temporal patterns in travel times along road segments in urban settings is of central importance to traffic engineers and city planners. In this work, we propose a methodology to leverage coarse-grained and aggregated travel time data to estimate the street-level travel times of a given metropolitan area. Our main focus is to estimate travel times along the arterial road segments where relevant data are often unavailable. The central idea of our approach is to leverage easy-to-obtain, aggregated data sets with broad spatial coverage, such as the data published by Uber Movement, as the fabric over which other expensive, fine-grained datasets, such as loop counter and probe data, can be overlaid. Our proposed methodology uses a graph representation of the road network and combines several techniques such as graph-based routing, trip sampling, graph sparsification, and least-squares optimization to estimate the street-level travel times. Using sampled trips and weighted shortest-path routing, we iteratively solve constrained least-squares problems to obtain the travel time estimates. We demonstrate our method on the Los Angeles metropolitan-area street network, where aggregated travel time data is available for trips between traffic analysis zones. Additionally, we present techniques to scale our approach via a novel graph pseudo-sparsification technique.
We describe an approach for modeling fluid concentration profiles in grid-based microfluidic chips for fluid mixing. This approach provides an algorithm that predicts fluid concentrations at the chip outlets. Our algorithm significantly outperforms COMSOL finite element simulations in terms of runtime while still producing results that closely approximate those of COMSOL. The fundamental idea of our method is to replace meshbased numerical simulations by a more combinatorial approach, where concentration profiles across the grid channels are modeled by simple piece-wise linear functions, which are updated according to simple rules, as the grid is traversed in a topological order determined by the flow direction. The correctness of our concentration profile model depends on the concept of the ordering dual to the underlying graph.
We present the winning solver of the PACE 2019 Implementation Challenge, Vertex Cover Track. The minimum vertex cover problem is one of a handful of problems for which kernelization---the repeated reducing of the input size via data reduction rules---is known to be highly effective in practice. Our algorithm uses a portfolio of techniques, including an aggressive kernelization strategy, local search, branch-and-reduce, and a state-of-the-art branch-and-bound solver. Of particular interest is that several of our techniques were not from the literature on the vertex over problem: they were originally published to solve the (complementary) maximum independent set and maximum clique problems. Aside from illustrating our solver's performance in the PACE 2019 Implementation Challenge, our experiments provide several key insights not yet seen before in the literature. First, kernelization can boost the performance of branch-and-bound clique solvers enough to outperform branch-and-reduce solvers. Second, local search can significantly boost the performance of branch-and-reduce solvers. And finally, somewhat surprisingly, kernelization can sometimes make branch-and-bound algorithms perform worse than running branch-and-bound alone.
Many clustering applications in machine learning and data mining rely on solving metric-constrained optimization problems. These problems are characterized by O(n^3) constraints that enforce triangle inequalities on distance variables associated with n objects in a large dataset. Despite its usefulness, metric-constrained optimization is challenging in practice due to the cubic number of constraints and the high-memory requirements of standard optimization software. Recent work has shown that iterative projection methods are able to solve metric-constrained optimization problems on a much larger scale than was previously possible, thanks to their comparatively low memory requirement. However, the major limitation of projection methods is their slow convergence rate. In this paper we present a parallel projection method for metric-constrained optimization which allows us to speed up the convergence rate in practice. The key to our approach is a new parallel execution schedule that allows us to perform projections at multiple metric constraints simultaneously without any conflicts or locking of variables. We illustrate the effectiveness of this execution schedule by implementing and testing a parallel projection method for solving the metric-constrained linear programming relaxation of correlation clustering. We show numerous experimental results on problems involving up to 2.9 trillion constraints.
We argue that the standard graph Laplacian is preferable for spectral partitioning of signed graphs compared to the signed Laplacian. Simple examples demonstrate that partitioning based on signs of components of the leading eigenvectors of the signed Laplacian may be meaningless, in contrast to partitioning based on the Fiedler vector of the standard graph Laplacian for signed graphs. We observe that negative eigenvalues are beneficial for spectral partitioning of signed graphs, making the Fiedler vector easier to compute.
Author(s): Liu, Yang; Jacquelin, Mathias; Ghysels, Pieter; Li, Xiaoye S | Editor(s): Manne, Fredrik; Sanders, Peter; Toledo, Sivan
Differential-algebraic equations (DAEs) are widely used for the modeling of dynamical systems. The difficulty in numerically solving a DAE is measured by its differentiation index. For highly accurate simulation of dynamical systems, it is important to convert high-index DAEs into low-index DAEs. Most of the existing simulation software packages for dynamical systems are equipped with an index-reduction algorithm given by Mattsson and Söderlind. Unfortunately, this algorithm fails if there are numerical cancellations. These numerical cancellations are often caused by accurate constants in structural equations. Distinguishing those accurate constants from generic parameters that represent physical quantities, Murota and Iri introduced the notion of a mixed matrix as a mathematical tool for faithful model description in a structural approach to systems analysis. For DAEs described with the use of mixed matrices, efficient algorithms to compute the index have been developed by exploiting matroid theory. This article presents an index-reduction algorithm for linear DAEs whose coefficient matrices are mixed matrices, i.e., linear DAEs containing physical quantities as parameters. Our algorithm detects numerical cancellations between accurate constants and transforms a DAE into an equivalent DAE to which Mattsson–Söderlind’s index-reduction algorithm is applicable. Our algorithm is based on the combinatorial relaxation approach, which is a framework to solve a linear algebraic problem by iteratively relaxing it into an efficiently solvable combinatorial optimization problem. The algorithm does not rely on symbolic manipulations but on fast combinatorial algorithms on graphs and matroids. Our algorithm is proved to work for any linear DAEs whose coefficient matrices are mixed matrices. Furthermore, we provide an improved algorithm under an assumption based on dimensional analysis of dynamical systems. Through numerical experiments, it is confirmed that our algorithms run sufficiently fast for large-scale DAEs and output DAEs such that physical meanings of coefficients are easy to interpret. Our algorithms can also be applied to nonlinear DAEs by regarding nonlinear terms as parameters.
The problem of propagating algorithmic adjoints using a minimum amount of memory is investigated. This combinatorial Minimum Memory Algorithmic Ad-joint Propagation problem appears in Algorithmic Differentiation of numerical simulation programs with relevance to a wide range of real-world applications in Computational Science, Engineering and Finance. We prove its intractability and we discuss practically relevant heuristics.
In this paper, we consider the problem of computing a triangular factorization of a sparse symmetric matrix using Gaussian elimination. We assume that the sparse matrix has been permuted using a fill-reducing ordering algorithm. When the matrix is symmetric positive definite, the sparsity structure of the triangular factor can be determined once the fill-reducing ordering has been computed. Thus, an efficient numerical factorization scheme can be designed so that only the nonzero entries are stored and operated on. On modern architectures, the positions of the nonzero entries in the triangular factor play a big role in determining the efficiency. It is desirable to have dense blocks in the factor so that the computation can be cast in terms of level-3 BLAS as much as possible. On architectures with GPUs, for example, it is also desirable for these dense blocks to be as large as possible in order to reduce the times to transfer data between the main CPU and the GPUs. We address the problem of locally refining the ordering so that the number of dense blocks is reduced and the sizes of these dense blocks are increased in the triangular factor.
