SearcharxivSearch

arXiv subjects

Oren E. Livne

Publications and source records attributed to Oren E. Livne.

5 recordsLinked to original sources

A Near-Linear-Time Solver for Graph $p$-Laplacian Semi-Supervised Learning via Continuation in $p$

Graph-based semi-supervised learning (SSL) propagates a few labels over a similarity graph by minimizing a Dirichlet-type energy. The standard quadratic ($p=2$) energy reduces to a single graph-Laplacian solve, but it degenerates exactly where SSL is most useful when labels are scarce: gathering more unlabeled data drives the $p=2$ estimate to a near-constant function whenever $d\ge2$ (Nadler-Srebro-Zhou). Well-posedness requires the nonlinear $p$-Laplacian energy with $p>d$. Existing solvers reduce this to a sequence of weighted Laplacian solves, but their reference implementations use a direct sparse factorization or ichol-preconditioned CG instead. Plugging a near-linear Laplacian solver is not straightforward: at large $p$ the conductance weights degenerate near flat-gradient edges, making the system nearly singular and causing stagnation without a damped outer iteration. We close this gap. Recasting $p$-Laplacian SSL as a source-form nonlinear Laplacian flow $Bρ_p(B^\top x)=b$ and solving by damped chord-Newton continuation in $p$, every linearized system stays well-conditioned and can be delegated to a near-linear Laplacian engine. On size-scaled graph families the wall-clock is empirically $m^{0.96}$-$m^{1.02}$ per family (approximate Cholesky default), and a pooled fit across 228 SuiteSparse graphs gives $m^{1.19}$ vs.\ $m^{1.45}$ for direct factorization; the solver handles a $6.8\times10^7$-edge social network in minutes. Memory is the binding constraint: Cholesky fill reaches $10$-$280\times$ the graph nonzeros vs.\ our $O(m)$ hierarchy. Against the released FCL solver we are $1.5$-$14\times$ faster at matched accuracy. On MNIST $10$-NN, $p=3$ scores $64\%$ at one label per class vs.\ $36\%$ for $p=2$. Code: https://github.com/orenlivne/np.

cs.LG

NLF: A Resistor-Network Framework and Linear-Time Solver for Convex Network-Flow Equilibria

We present NLF (Nonlinear Laplacian Flow), a unified framework and linear-time solver for convex network-flow equilibria. Congestion routing, minimum-delay routing, and maximum flow share one form: the nonlinear graph Laplacian $Bρ(B^Tϕ)=αd$, where a monotone edge law $ρ_e$ encodes the physics (undirected graphs; directed variants are future work). NLF solves it by a damped chord-Newton iteration whose frozen linearization -- a weighted graph Laplacian -- is inverted by a near-linear Laplacian solver (default: approximate Cholesky, LAMG+ interchangeable). The nonlinear solve costs $2$--$4$ linear Laplacian solves, making the wall-clock empirically $O(m)$ in the edge count $m$ (not a proved bound). On single-commodity congestion (BPR cost), NLF converges on all 2,003 SuiteSparse corpus graphs up to $1.8\times10^7$ edges. Against a state-of-the-art interior-point method, NLF is a median $2.6\times$ faster where both converge and $>45\times$ on poorly-separable graphs where the IPM's direct core is superlinear; against L-BFGS, a median $4.2\times$ faster and the only solver to finish on the 90 hardest instances. A multicommodity extension routes $K$ commodities through one shared hierarchy at $O(Km)$ per step. The same machinery recovers the exact max-flow as a short sequence of Laplacian solves, with the cut potential as a by-product. Code: https://github.com/orenlivne/nlf

math.NA

LAMG+: A Robust Lean Algebraic Multigrid Solver for Graph Laplacians

Graph-Laplacian systems $Lϕ=b$ underlie spectral clustering, semi-supervised learning, finite-element analysis, and network-flow solvers. We present LAMG+, a lean, parameter-free, empirically linear-time algebraic multigrid solver: a Julia re-derivation of Lean Algebraic Multigrid (LAMG) with two targeted refinements. We establish three facts. (1) Benchmarking against approximate-Cholesky (AC) and four other solvers (BoomerAMG, PETSc GAMG, pyAMG, CMG): LAMG+ and AC are complementary peers -- AC is faster on social/citation graphs; LAMG+ is faster on finite-element/structural matrices (fastest robust solver, most memory-frugal, $2.2\times$ faster than the robust AC variant on large graphs). Only LAMG+ and AC converge across all 13 test classes; the others fail or slow by an order of magnitude off their home turf. (2) Linear scaling: LAMG+ is empirically $O(m)$ with $m$ nonzeros over the full 1,711-graph SuiteSparse set (100% converged, median 4 cycles, log-log slope 1.01), verified up to $2.4\times 10^8$ nonzeros. (3) Robustness: prior benchmarking reported LAMG non-convergent on certain families; running the unmodified LAMG 2.2.1 under identical conditions establishes full convergence, indicating an evaluation artifact. A Local Fourier Analysis proves a strict interpolation-order deficit on grid-aligned anisotropy. Two lean local refinements -- a strength-of-connection aggregation veto and selective caliber-2 interpolation -- resolve LAMG's anisotropy failure (convergence factor $\approx 0.99 \to 0.11$) with negligible overhead.

math.NA

Lean Algebraic Multigrid (LAMG): Fast Graph Laplacian Linear Solver (Journal Version)

Laplacian matrices of graphs arise in large-scale computational applications such as semi-supervised machine learning; spectral clustering of images, genetic data and web pages; transportation network flows; electrical resistor circuits; and elliptic partial differential equations discretized on unstructured grids with finite elements. A Lean Algebraic Multigrid (LAMG) solver of the symmetric linear system Ax=b is presented, where A is a graph Laplacian. LAMG's run time and storage are empirically demonstrated to scale linearly with the number of edges. LAMG consists of a setup phase during which a sequence of increasingly-coarser Laplacian systems is constructed, and an iterative solve phase using multigrid cycles. General graphs pose algorithmic challenges not encountered in traditional multigrid applications. LAMG combines a lean piecewise-constant interpolation, judicious node aggregation based on a new node proximity measure (the affinity), and an energy correction of coarse-level systems. This results in fast convergence and substantial setup and memory savings. A serial LAMG implementation scaled linearly for a diverse set of 3774 real-world graphs with up to 47 million edges, with no parameter tuning. LAMG was more robust than the UMFPACK direct solver and Combinatorial Multigrid (CMG), although CMG was faster than LAMG on average. Our methodology is extensible to eigenproblems and other graph computations.

math.NA

Lean Algebraic Multigrid (LAMG): Fast Graph Laplacian Linear Solver

Laplacian matrices of graphs arise in large-scale computational applications such as machine learning; spectral clustering of images, genetic data and web pages; transportation network flows; electrical resistor circuits; and elliptic partial differential equations discretized on unstructured grids with finite elements. A Lean Algebraic Multigrid (LAMG) solver of the linear system Ax=b is presented, where A is a graph Laplacian. LAMG's run time and storage are linear in the number of graph edges. LAMG consists of a setup phase, in which a sequence of increasingly-coarser Laplacian systems is constructed, and an iterative solve phase using multigrid cycles. General graphs pose algorithmic challenges not encountered in traditional applications of algebraic multigrid. LAMG combines a lean piecewise-constant interpolation, judicious node aggregation based on a new node proximity definition, and an energy correction of the coarse-level systems. This results in fast convergence and substantial overhead and memory savings. A serial LAMG implementation scaled linearly for a diverse set of 1666 real-world graphs with up to six million edges. This multilevel methodology can be fully parallelized and extended to eigenvalue problems and other graph computations.

math.NA