---
title: Graph Learning GRASP (GL-GRASP)
url: https://www.emergentmind.com/topics/graph-learning-grasp-gl-grasp
type: topic
---

# Graph Learning GRASP (GL-GRASP)

Searching arXiv for GL-GRASP and closely related papers to ground the article.
Graph Learning GRASP (GL-GRASP) is a hybrid metaheuristic for the Constrained Incremental Graph Drawing Problem (C-IGDP) that incorporates Graph Representation Learning (GRL) into the construction phase of a Greedy Randomized Search Procedure (GRASP). In the formulation presented in “An Efficient Hybridization of Graph Representation Learning and Metaheuristics for the Constrained Incremental Graph Drawing Problem” [2508.15949], GL-GRASP uses node embeddings, reduced to two dimensions by PCA, to guide incremental vertex selection and placement under hierarchical, precedence, and displacement constraints. The method is designed for layered graph drawings in which original vertices must preserve their relative order and may move only within a bounded displacement, while incremental vertices and arcs are inserted so as to minimize total arc crossings. The paper positions GL-GRASP as a learning-augmented variant of prior GRASP heuristics for C-IGDP, and explicitly distinguishes it from other unrelated methods whose acronyms also include “GRASP” [2508.15949].

## 1. Problem setting and optimization model

GL-GRASP is defined for the Constrained Incremental Graph Drawing Problem on a hierarchical graph $G = (V, A, \Lambda)$ partitioned into $\Lambda$ layers, with $V = V^1 \cup \dots \cup V^\Lambda$ and $A = A^1 \cup \dots \cup A^{(\Lambda-1)}$ connecting successive layers [2508.15949]. An initial drawing $D = (G, \Pi_0)$ provides layerwise positions $\Pi_0 = \{\pi_0^1, \dots, \pi_0^\Lambda\}$, where $\pi_0^\lambda: V^\lambda \to \{1, \dots, |V^\lambda|\}$. Incremental graph drawing augments the instance with new vertices and arcs, denoted by $IV^\lambda = V^\lambda \cup \hat{V}^\lambda$ and $IA^\lambda = A^\lambda \cup \hat{A}^\lambda$, without changing the number of layers [2508.15949].

The output is a new drawing $I = (IG, \Pi)$ for $IG = (IV, IA, \Lambda)$, with updated position functions $\Pi = \{\pi^1, \dots, \pi^\Lambda\}$ and $\pi^\lambda: IV^\lambda \to \{1, \dots, |IV^\lambda|\}$ [2508.15949]. The objective is to minimize the total number of arc crossings across adjacent layers. The model uses binary precedence variables $x_{ij}^\lambda$ to encode whether vertex $i$ precedes vertex $j$ in layer $\lambda$, and binary crossing variables $c_{iwjz}^\lambda$ to encode whether arcs $(i,w)$ and $(j,z)$ cross between layers $\lambda$ and $\lambda+1$ [2508.15949].

The optimization objective is

$$
\min \sum_{\lambda=1}^{\Lambda-1} \sum_{\substack{(i,w),(j,z)\in IA^\lambda\\ i\prec j,\; z\neq w}} c_{iwjz}^\lambda
$$

subject to crossing-consistency constraints, transitivity of precedence, mutual exclusivity of pairwise precedence, preservation of the original relative order of non-incremental vertices, and an absolute displacement bound $d$ for those original vertices [2508.15949]. Position encoding is linked to precedence by

$$
\pi^\lambda(i) = |IV^\lambda| - \sum_{\substack{j\in IV^\lambda\\ j\neq i}} x_{ij}^\lambda
$$

for all $i \in IV^\lambda$ [2508.15949]. The incremental-stability constraints are central: original vertices retain their pairwise order from $\Pi_0$, and each may move at most $d$ positions from its initial slot [2508.15949].

This formulation places GL-GRASP within constrained layered drawing rather than graph learning in the sense of Laplacian estimation or graph similarity prediction. A common source of confusion is nomenclature: the 2025 GL-GRASP method is distinct from “GraSP: Simple yet Effective Graph Similarity Predictions” [2412.09968], from “GRASPEL: Graph Spectral Learning at Scale” [1911.10373], and from the digital pathology method “GRASP: GRAph-Structured Pyramidal Whole Slide Image Representation” [2402.03592].

## 2. Baseline GRASP heuristics and their role

GL-GRASP builds on baseline GRASP heuristics introduced for C-IGDP and retains the standard two-phase metaheuristic structure: a construction phase followed by local search [2508.15949]. Each GRASP iteration constructs a feasible solution using a semi-greedy Restricted Candidate List (RCL), then improves it with neighborhood moves consisting of swaps and insertions of incremental vertices [2508.15949]. Termination is controlled by a maximum number of iterations $\eta$ and a stall limit $\eta_{\max}$ [2508.15949].

The baseline construction heuristics are denoted C1, C2, and C3 [2508.15949]. C1 is degree-driven barycenter: it starts by choosing a high-degree vertex, placing it randomly within allowable positions, maintaining an RCL based on a degree threshold, and using the barycenter of neighbors in adjacent layers to choose a feasible location [2508.15949]. C2 is incremental barycenter: it starts from the original drawing and adds incremental vertices using the same semi-greedy rule as C1 [2508.15949]. C3 uses a minimum-crossing insertion-cost function $\rho(\nu,p)$, defined as the number of additional crossings created if vertex $\nu$ is inserted in position $p$, and selects vertices by the minimum achievable insertion cost $\rho(\nu)=\min_p \rho(\nu,p)$ [2508.15949].

For C3, the RCL threshold is

$$
\xi = \min_{\nu\in L} \rho(\nu) + \varphi\big(\max_{\nu\in L} \rho(\nu) - \min_{\nu\in L} \rho(\nu)\big), \quad \varphi\in[0,1],
$$

with $\text{RCL} = \{\nu \in L : \rho(\nu) \le \xi\}$ [2508.15949]. More generally, the RCL rule is written as

$$
\text{RCL} = \{c \in \mathcal{C} : s(c) \le s_{\min} + \alpha(s_{\max}-s_{\min})\}, \quad \alpha=\varphi\in[0,1],
$$

where $s(c)$ is the candidate score [2508.15949].

The baseline pseudocode comprises: initialize the partial solution; score candidates; form the RCL; choose a candidate uniformly at random from the RCL; place it using barycenter or insertion-cost rules; repeat until all incremental vertices are inserted; then apply best-improvement swap and insert local search until a local minimum is reached [2508.15949]. The paper notes that C3 has higher construction complexity because it evaluates $\rho(\nu,p)$ over all candidates and feasible positions, whereas C1 and C2 are cheaper and depend mainly on degrees, barycenters, and feasibility checks [2508.15949].

GL-GRASP preserves this overall GRASP structure and the same local-search operators, but replaces the purely combinatorial construction logic with embedding-informed selection and placement [2508.15949]. This suggests that the contribution of GL-GRASP is not a new local-search neighborhood or a reformulation of the optimization model, but a learning-guided bias in the early stages of solution generation.

## 3. Graph Representation Learning components

The defining feature of GL-GRASP is its use of node embeddings to inject latent structural information into GRASP’s construction phase [2508.15949]. The paper evaluates four embedding methods: HOPE, Node2Vec, SDNE, and a spectral embedding method denoted SPEC [2508.15949].

HOPE is described as preserving high-order proximity and asymmetric transitivity using Katz similarity, with an objective of minimizing matrix reconstruction error,

$$
\min_{\mathbf{Z}} \|\mathbf{S} - \mathbf{Z}\mathbf{Z}^\top\|_F^2,
$$

where $\mathbf{S}$ is a similarity matrix and $\mathbf{Z} \in \mathbb{R}^{n\times k}$ contains the node embeddings [2508.15949]. Node2Vec is presented as a random-walk skip-gram method that maximizes neighborhood likelihood using negative sampling,

$$
\max_{\mathbf{Z}} \sum_{u\in V} \sum_{v\in \mathcal{N}(u)} \log \sigma(z_u^\top z_v) + \sum_{v'\sim P_n} \log \sigma(-z_u^\top z_{v'}),
$$

with biased walks controlled by $(p,q)$, though the specific hyperparameters are not given and CogDL defaults are used [2508.15949]. SDNE is described as a deep autoencoder preserving first-order and second-order proximity through

$$
\min_{\theta} \sum_{u\in V} \Big\| \hat{\mathbf{x}}_u - \mathbf{x}_u \Big\|_2^2 + \lambda \sum_{(u,v)\in E} w_{uv}\,\big\| \mathbf{z}_u - \mathbf{z}_v \big\|_2^2
$$

[2508.15949]. SPEC uses the eigenvectors of the normalized Laplacian $L = I - D^{-1/2} A D^{-1/2}$,

$$
L \mathbf{U} = \mathbf{U}\mathbf{\Lambda}, \quad \mathbf{Z} \gets \mathbf{U}_{(:,1:k)}
$$

[2508.15949].

The embedding dimensions are method-specific. HOPE uses $k = 2n - 1$, with the CogDL implementation using left and right singular vectors; SPEC uses $k = n - 1$; Node2Vec and SDNE use $k = 128$ [2508.15949]. The paper states that CogDL defaults are used and that detailed parameters are provided only in the Supplementary Material [2508.15949].

After embedding computation, GL-GRASP applies PCA to project the embeddings into two dimensions, producing coordinates $(x_u, y_u)$ for each node [2508.15949]. Euclidean distance in this 2D space becomes the main structural signal used during construction:

$$
d(u,v) = \big\| (x_u, y_u) - (x_v, y_v) \big\|_2
$$

[2508.15949]. The paper characterizes these distances as encoding latent structural patterns such as communities, structural roles, and proximities across layers, which can then inform drawing decisions [2508.15949].

In this sense, GL-GRASP uses GRL neither as an end-to-end learned optimizer nor as a predictor of crossings. Instead, embeddings act as a geometric prior for semi-greedy construction. A plausible implication is that GL-GRASP belongs to the class of learning-augmented heuristics in which learned representations bias classical combinatorial search without replacing it.

## 4. Embedding-informed construction in GL-GRASP

The construction phase of GL-GRASP begins with a partial solution $\mathcal{I}'$ that initially contains only the original drawing and its fixed-order vertices [2508.15949]. For each candidate incremental vertex $u$, the method computes the minimum embedding-space distance to any already placed adjacent neighbor:

$$
\mathcal{G}(u) = \min_{\substack{(u,v)\in IA \text{ or } (v,u)\in IA\\ v\in \text{placed in } \mathcal{I}'}} d(u,v)
$$

[2508.15949]. Lower $\mathcal{G}(u)$ indicates that $u$ lies close, in the learned representation, to some already positioned neighbor and is therefore a more promising candidate for insertion [2508.15949].

The RCL is then formed by thresholding these $\mathcal{G}(u)$ values using a random $\varphi \in [0,1]$ sampled at each GRASP iteration:

$$
\xi = \min_{\nu \in CL} \mathcal{G}(\nu) + \varphi\big(\max_{\nu \in CL} \mathcal{G}(\nu) - \min_{\nu \in CL} \mathcal{G}(\nu)\big)
$$

and

$$
\text{RCL} = \{ \nu \in CL : \mathcal{G}(\nu) \le \xi \}
$$

[2508.15949]. A candidate $\nu$ is then selected uniformly at random from the RCL [2508.15949].

Placement is also embedding-informed. For each neighboring layer $\lambda'$ in which $\nu$ has already placed neighbors, GL-GRASP considers the closest available position to the nearest neighbor in $\lambda'$ and the closest available position to the farthest neighbor in $\lambda'$ [2508.15949]. It also computes an intermediate option as the closest available position to the average of the positions accumulated in the candidate set $P$ [2508.15949]. One of these positions is then selected at random, with feasibility-preserving shifts applied when necessary so that the relative-order and absolute-displacement constraints remain satisfied [2508.15949].

The construction procedure can therefore be summarized as follows: compute embeddings; project them to 2D; derive Euclidean distances for adjacent vertices; iteratively choose an incremental vertex with small minimum distance to a placed neighbor; place it near either its nearest neighbor, its farthest neighbor, or an average position; then continue until all incremental vertices are inserted [2508.15949]. After construction, the method applies the same local search as baseline GRASP: best-improvement swaps, then best-improvement inserts [2508.15949].

The paper defines several variants. G_SPEC, G_HOPE, G_N2V, and G_SDNE compute embeddings once per run, while G_N2V* and G_SDNE* recompute embeddings at every GRASP iteration to increase diversification [2508.15949]. The latter are explicitly characterized as stochastic variants [2508.15949].

## 5. Evaluation methodology and empirical results

Evaluation is based primarily on the Normalized Primal Integral (NPI), which captures the quality-time trade-off of the solution trajectory [2508.15949]. Let $f(0) = 1.1 \times f^*_{\text{heur}}$, where $f^*_{\text{heur}}$ is the best solution value among all GL-GRASP heuristics for the instance, let $\{f(i)\}$ be the improving solutions observed over time, and let $t(i)$ be their timestamps. Then

$$
\mathrm{NPI} = \frac{\sum_{i=1}^{n_s} \big[ f(i-1)\cdot\big(t(i)-t(i-1)\big) \big] + f(n_s)\cdot\big(T_{\max}-t(n_s)\big)}{T_{\max}\cdot f^*_{\text{heur}}}
$$

with lower NPI indicating faster convergence to high-quality solutions [2508.15949].

The experiments use hardware comprising four high-memory nodes, each with two Intel Xeon E5-2667v4 3.2 GHz CPUs and 512 GB memory, for a total of 64 cores and 2 TB RAM [2508.15949]. The benchmark set contains 609 test cases derived from 240 base instances with $\Lambda \in \{2,6,13,20\}$, densities $\rho \in \{0.065,0.175,0.300\}$, non-incremental vertices per layer in $[5,30]$, incremental ratios $\text{Inc} \in \{0.2,0.6\}$, and displacement bounds $d \in \{1,2,3\}$ [2508.15949]. A second set of newly generated dense instances uses $\Lambda \in \{2,3,4,5\}$, $\text{Inc}=0.60$, $d \in \{1,2,3\}$, and non-incremental nodes per layer in $[60,80]$ [2508.15949].

The methods compared are the GL-GRASP variants, literature baselines GRASP2 and GRASP3, and Gurobi 10.0.2 on the benchmark set [2508.15949]. The GRASP parameters are fixed to $\eta = 100$ and $\eta_{\max} = 20$, with $\varphi$ chosen randomly in $[0,1]$ per iteration [2508.15949].

The main findings are structured across three experiments [2508.15949]. In the comparison among GL-GRASP variants, G_SPEC achieved the lowest mean gap overall, G_SDNE was the fastest on average, and G_HOPE provided a strong balance and was second-best overall when considering both gap and time [2508.15949]. On mean NPI, G_HOPE was best and G_SDNE second-best, while the stochastic variants G_N2V* and G_SDNE* had significantly higher runtimes and worse NPI [2508.15949]. Performance-profile results show G_SDNE and G_HOPE dominating NPI; at $\tau = 1$, G_SDNE has the best NPI in about 42% of instances and G_HOPE in about 30% [2508.15949].

In the comparison with literature baselines, GRASP3 yields the best average gaps on small $\Lambda$ and low-density instances, but at significantly higher runtimes because of the expensive C3 construction [2508.15949]. GL-GRASP variants, especially G_HOPE and G_SDNE, outperform GRASP3 on larger $\Lambda$ and/or higher densities, with much lower runtimes [2508.15949]. GRASP2 is the fastest of the baselines on benchmark instances but has the worst gap on most classes [2508.15949]. Wilcoxon signed-rank tests at $p<0.05$ indicate that GRASP2 is significantly worse in gap than GRASP3, G_HOPE, and G_SDNE; there is no significant difference in gap between GRASP3, G_HOPE, and G_SDNE; and GRASP3 is significantly slower than G_HOPE and G_SDNE [2508.15949].

On the newly generated denser instances with a time limit of 10,800 seconds, G_HOPE and G_SDNE each attain mean gap $\approx 0.007$, with mean runtimes of about 8,371 s and 8,074 s respectively [2508.15949]. GRASP2 attains mean gap $\approx 0.021$ and mean time $\approx 9,639$ s, while GRASP3 attains mean gap $\approx 1.462$ and mean time $\approx 15,053$ s [2508.15949]. Gurobi attains mean gap $\approx 0.665$ within the same time limit [2508.15949]. G_HOPE and G_SDNE each achieve best gaps on 8 of the 12 dense instances [2508.15949].

## 6. Interpretation, strengths, and limitations

The paper’s central interpretation is that GRL improves the construction phase by encoding global structure that barycenter-style local averaging does not capture [2508.15949]. Embedding-guided selection and placement near or away from already placed neighbors can produce better initial layouts, accelerate convergence, and reduce crossings early in the search [2508.15949]. This is supported empirically by the fact that GL-GRASP, especially with HOPE and SDNE, matches or exceeds the solution quality of GRASP3 while being significantly faster on many classes of instances [2508.15949].

Several limitations are also explicit. Stochastic embedding recomputation in G_N2V* and G_SDNE* increases runtime and can degrade NPI, so diversification does not consistently improve the overall quality-time trade-off [2508.15949]. On small-layer, low-density instances, the exhaustive insertion-cost strategy of GRASP3 often remains superior in gap, which indicates that GL-GRASP’s advantage is most pronounced on larger or denser instances rather than universally across all regimes [2508.15949]. The embedding and PCA steps add preprocessing overhead, so in very small graphs that overhead may outweigh the benefit [2508.15949].

The recommended practical choices are HOPE and SDNE, which offer the strongest balance of quality and runtime [2508.15949]. The paper recommends computing embeddings once per run unless additional diversification is needed and the time budget permits recomputation [2508.15949]. It also recommends the standard GRASP settings $\eta=100$, $\eta_{\max}=20$, random $\varphi \in [0,1]$, and Euclidean distance in 2D PCA space as the score-defining geometry [2508.15949].

A plausible implication is that GL-GRASP is particularly effective when the graph’s latent structure aligns with the crossing-minimization geometry sufficiently well for embedding proximity to become a useful surrogate during construction. Where that alignment is weak, more expensive combinatorial scoring such as C3 may remain competitive.

## 7. Naming, reproducibility, and relation to adjacent work

The 2025 paper explicitly uses “Graph Learning GRASP (GL-GRASP)” to denote the incorporation of Graph Representation Learning into GRASP for C-IGDP [2508.15949]. This naming should not be conflated with other “GRASP”-like acronyms in the graph and machine learning literature. “GraSP: Simple yet Effective Graph Similarity Predictions” addresses graph similarity computation for GED and MCS prediction using RWPE-enhanced graph embeddings and a graph-level interaction module [2412.09968]. “GRASPEL: Graph Spectral Learning at Scale” is a spectral graph-learning method for estimating ultra-sparse Laplacian graphs from data [1911.10373]. “GRASP: GRAph-Structured Pyramidal Whole Slide Image Representation” is a multi-magnification graph model for whole-slide image classification in digital pathology [2402.03592]. These methods are unrelated to GL-GRASP beyond acronym overlap.

Reproducibility is supported by public code and data links reported in the paper [2508.15949]. All algorithms are implemented in Python, with benchmark instances and newly generated dense instances made available through the project repository [2508.15949]. Embeddings are drawn from CogDL implementations, and Gurobi 10.0.2 is used for exact benchmark experiments [2508.15949]. The paper notes that seeds are not specified; randomization arises from the per-iteration sampling of $\varphi$ and from stochastic embedding methods where applicable [2508.15949].

Within the broader literature, GL-GRASP exemplifies a learning-augmented metaheuristic rather than a replacement of metaheuristics by supervised learning or reinforcement learning [2508.15949]. Its reported contribution is a comparatively inexpensive use of representation learning to extract latent graph structure and inject it into a classical semi-greedy constructor. The empirical record in the paper suggests that this hybridization is especially effective for dense and large-scale C-IGDP instances, where exhaustive construction heuristics become prohibitively costly and simpler baselines lose solution quality [2508.15949].

Source: https://www.emergentmind.com/topics/graph-learning-grasp-gl-grasp