--- title: Part-Centric Assembly Graph (PAG) url: https://www.emergentmind.com/topics/part-centric-assembly-graph-pag type: topic --- # Part-Centric Assembly Graph (PAG) Searching arXiv for recent papers on "Part-centric Assembly Graph" and closely related formulations to ground the article in published work. Part-centric Assembly Graph (PAG) is a graph-based representation in which parts, rather than only whole objects, are treated as the primary carriers of geometry, state, and relational structure. Across the literature, the term has been used in several related but non-identical senses: as a dynamic message-passing graph for generative 3D part assembly [2006.07793], as a graph for single-image-guided 3D part assembly under a related “part graph network” formulation [2003.09754], as an explicit part-and-object relational structure for physically grounded indoor scene configuration [2603.07704], as a graph for multi-part object discovery in images [2512.18192], as a multi-state graph for RGB-D tracking during assembly [2402.07677], as an assembly graph for sequence and production-line planning [2512.13219], and as an interface-augmented contact graph for CAD part retrieval [2607.01205]. The common principle is that PAG localizes structure at the level where mating interfaces, symmetries, support relations, occlusions, and assembly constraints actually occur, rather than assuming that these are recoverable from object-level abstractions alone. ## 1. Conceptual scope and formal variants The most narrowly defined PAG in 3D part assembly is the one introduced in "Generative 3D Part Assembly via Dynamic Graph Learning" [2006.07793]. There, given a set of $N$ input parts $\{p_i\}_{i=1}^N$, each a point cloud $p_i\in\mathbb{R}^{1000\times 3}$, the method forms a fully-connected, self-looped directed graph $$ G^{(0)}=(V^{(0)},E^{(0)}) $$ with node set $V^{(0)}=\{v_i^{(0)}\}_{i=1}^N$ and directed edge set $E^{(0)}=\{(i,j)\mid i,j\in[1\ldots N]\}$ [2006.07793]. In that formulation, nodes carry learned part geometry features, edge messages are computed dynamically, and the graph evolves over iterations through learned relation weights and alternating dense and aggregated representations. A related but earlier formulation appears in "Learning 3D Part Assembly from a Single Image" [2003.09754], where the graph is described as a “part graph network” rather than PAG. Nodes are normalized input part point-clouds, and graph connectivity is phase-dependent: a first graph $G^1=(V,E^1)$ links geometrically equivalent parts, and a second graph $G^2=(V,E^1\cup E^2)$ augments this with “top-5 nearest neighbors” under the current assembled-shape metric after an initial pose pass [2003.09754]. This suggests that, even within assembly-centric work, PAG-like structures need not be fully connected; they may instead encode task-specific inductive biases such as equivalence-class ambiguity and proximity during refinement. In "PARSE: Part-Aware Relational Spatial Modeling" [2603.07704], PAG is broadened into a heterogeneous relational structure over object-level nodes $V_o$, part-level nodes $V_p$, object-object edges $E_{oo}$, ownership links $E_{op}$, and part-part geometric relations $E_{pp}$. The formal definition is $$ \mathrm{PAG}=(V_o, V_p, E_{oo}, E_{op}, E_{pp}, \Phi), $$ where each part-part edge is annotated by a mapping $\Phi : E_{pp}\to R\times S\times S$ with relation type and optionally named surfaces such as top or bottom [2603.07704]. In this usage, PAG is not merely a message-passing substrate; it is a symbolic-geometric scaffold from which analytic constraints are derived. Other uses shift the emphasis further. "Multi-Part Object Representations via Graph Structures and Co-Part Discovery" [2512.18192] constructs a PAG from image segmentations, with nodes as 2D parts and edges between adjacent parts in the segmentation. "GBOT: Graph-Based 3D Object Tracking for Augmented Reality-Assisted Assembly Guidance" [2402.07677] uses a multi-state PAG in which nodes may denote either single parts or rigid modules formed by previously assembled parts. "A Unified Framework for Automated Assembly Sequence and Production Line Planning using Graph-based Optimization" [2512.13219] defines the part-centric assembly graph as an undirected graph $G_{\text{part}}=(N,J)$ over rigid components and joints. "Linkify: Learning from Interface-Augmented Assembly Graphs" [2607.01205] uses a PAG for mechanical CAD assemblies in which nodes are parts and edges denote physically computed contacts endowed with learned interface embeddings. Taken together, these formulations indicate that PAG is best understood as a family of part-level graph representations rather than a single canonical data structure. The invariant element is the elevation of parts and their interfaces, relations, or ownership links to first-class graph entities. ## 2. Node semantics, edge semantics, and feature parameterizations In the dynamic 3D assembly formulation, node features are produced by a shared PointNet encoder $f_{init}$, with $$ v_i^{(0)}=f_{init}(p_i),\qquad f_{init}:\mathbb{R}^{1000\times 3}\to\mathbb{R}^{256}, $$ so each node is a 256-dimensional descriptor of part geometry [2006.07793]. Edge features are not stored explicitly at initialization; instead they are produced on-the-fly by an edge network during message passing [2006.07793]. In the same line of work, RGL-NET also initializes each node by $\mathrm{PointNet}(P_i)$ into $\mathbb{R}^{256}$ and uses a fully connected graph including self-loops, with edge messages derived from concatenated node features and scalar relation weights computed from current part transforms [2107.12859]. The single-image assembly formulation uses substantially richer node features. At $t=0$, each node feature $f_i^0\in\mathbb{R}^F$ is the concatenation of an image embedding $f_{img}\in\mathbb{R}^{512}$ from ResNet-18 over the crop region masked by part $i$, a mask embedding $f_{mask}\in\mathbb{R}^{512}$ from a separate ResNet-18 over the predicted binary mask $M_i$, and a 3D context-aware feature $f_{3d}\in\mathbb{R}^{512}$ built from PointNet geometry and instance/class context, yielding $F=1536$ [2003.09754]. Edge features are initialized to $0$ on $E^1$, while newly introduced phase-2 edges in $E^2$ receive initial value $1$ [2003.09754]. This design makes edge state itself a coarse indicator of graph phase. In the image-based co-part discovery setting, node features are explicitly geometric but two-dimensional. After Felzenszwalb’s algorithm segments an image into $M$ disjoint parts $\mathcal{P}=\{P_1,\dots,P_M\}$, each part $P_i$ is represented by its centroid $\mathbf{x}_c^i\in\mathbb{R}^2$ and $K$ uniformly sampled boundary pixels $\{\mathbf{x}_k^i\}_{k=1}^K$; the node feature $\mathbf{V}_i\in\mathbb{R}^{2\times K}$ stacks the vectors from centroid to sampled boundary pixels, and may equivalently be flattened into a $2K$-dimensional vector $\mathbf{x}_i$ [2512.18192]. Edges are undirected and exist iff two parts appear in the same image and share a nonzero boundary length; the edge attribute is the centroid displacement $$ \mathbf{e}_{ij}=\mathbf{x}_c^j-\mathbf{x}_c^i\in\mathbb{R}^2 $$ [2512.18192]. In PARSE, node and edge semantics are more explicitly typed. The node sets are divided into objects and parts, while part-part edges carry relation labels such as “on,” “in,” and “against,” and optionally two named surfaces [2603.07704]. The graph therefore couples topology with relational ontology. In GBOT, each node carries a semantic part-type label and a current 6D pose estimate $T_i\in SE(3)$, and each undirected edge carries a “ground-truth” relative transform $T_{i\to j}^{gt}\in SE(3)$ for the fully assembled state [2402.07677]. In Linkify, node attributes are part embeddings $x_b=\phi(P_b)\in\mathbb{R}^{384}$ from a pretrained PointMAE encoder over $K=2048$ sampled surface points, and edge attributes are interface embeddings $e_{ij}=\phi(P_{ij})\in\mathbb{R}^{384}$ from sampled points on the Boolean-intersection geometry between contacting bodies [2607.01205]. A useful comparison is that some PAGs treat edges primarily as communication channels to be learned online [2006.07793], some as explicit geometric evidence such as centroid offsets or contact embeddings [2512.18192; 2607.01205], and some as carriers of hard assembly semantics such as joints, support, or containment [2402.07677; 2512.13219; 2603.07704]. ## 3. Dynamic graph learning for 6-DoF part assembly The dynamic PAG backbone in "Generative 3D Part Assembly via Dynamic Graph Learning" [2006.07793] performs $T=5$ iterations of message passing. At each iteration $t$, the model computes edge messages $$ e_{ij}^{(t)}=f_{edge}\bigl(v_i^{(t)},v_j^{(t)}\bigr)\in\mathbb{R}^{256}, $$ where $f_{edge}$ is an MLP shared across all edges at that iteration [2006.07793]. These messages are modulated by learned scalar relation weights $r_{ij}^{(t)}\in\mathbb{R}$ on directed edges $j\to i$, and node updates use the normalized weighted average $$ v_i^{(t+1)}=f_{node}\!\Bigl(v_i^{(t)},\; \frac{\sum_{j=1}^N r_{ij}^{(t)}\,e_{ij}^{(t)}}{\sum_{j=1}^N r_{ij}^{(t)}}\Bigr), $$ with normalization by $\sum_j r_{ij}$ to keep scale stable [2006.07793]. Pose regression is performed after each update: $$ q_i^{(t+1)}=f_{pose}\bigl(v_i^{(0)},\,v_i^{(t+1)},\,q_i^{(t)}\bigr)\in\mathbb{R}^7, $$ where $q_i=(r_i,t_i)$, with $r_i\in\mathbb{R}^4$ a unit quaternion and $t_i\in\mathbb{R}^3$ a translation [2006.07793]. Because the network weights of $f_{edge}$, $f_{node}$, and $f_{pose}$ differ across iterations, the procedure models a coarse-to-fine refinement of node features and predicted poses [2006.07793]. A central component is the Part Relation Reasoning Module. For iteration $t\ge 1$, relation scores are computed from the previous iteration’s predicted poses: $$ h_i^{(t-1)}=f_{feat}\bigl(q_i^{(t-1)}\bigr),\qquad r_{ij}^{(t)}=f_{relation}\bigl(h_i^{(t-1)},\,h_j^{(t-1)}\bigr)\in\mathbb{R}, $$ with $r_{ij}^{(1)}=1$ so that the first pass is an unweighted average [2006.07793]. This means that geometric state feeds back into graph connectivity strength, making the graph time-varying even when its explicit topology remains fully connected. The Part Aggregation Module addresses repeated or “geometrically equivalent” parts such as chair legs. Such groups are detected by comparing part PCA sizes and point-cloud Chamfer distances, after which graph learning alternates between a dense node set and a sparse set where each group is merged into one node [2006.07793]. On even iterations, grouped node features are average-pooled, $$ v_j^{(t)}=pool_{k\in G}\bigl(v_k^{(t)}\bigr), $$ and relation features are pooled analogously; equations (1)–(2) are then run on the sparse graph, followed by unpooling back to the dense graph on the next odd iteration [2006.07793]. The paper states that average-pooling is used for all pooling operations. The recurrent alternative in RGL-NET preserves the fully connected graph but combines graph reasoning with bidirectional GRUs. At each iteration, raw edge messages are computed as $$ e_{ij}^{(t)}=f_{\mathrm{edge}}([v_i^{(t)}\|v_j^{(t)}])\in\mathbb{R}^{256}, $$ weights $w_{ij}^{(t)}$ are produced from current transforms, and incoming messages are aggregated by a normalized weighted sum [2107.12859]. These are then processed by forward and backward GRUs over an ordered part sequence, with global noise injected into boundary hidden states, and pose updates are regressed recurrently from current features, initial features, and previous transforms [2107.12859]. A plausible implication is that PAGs can be embedded within either purely feedforward iterative refinement [2006.07793] or recurrent state-space models [2107.12859], while retaining the same underlying commitment to part-level relational reasoning. ## 4. Supervision, optimization, and empirical behavior For 6-DoF assembly, the dynamic PAG model supervises translation, rotation, and global assembled shape. Each pose $q_i=(r_i,t_i)$ uses translation loss $$ \mathcal{L}_t=\sum_i\|t_i-t_i^*\|_2^2, $$ rotation loss $$ \mathcal{L}_r=\sum_i\bigl[CD\bigl(q_i(p_i),\,q_i^*(p_i)\bigr)\bigr], $$ and global shape loss $$ \mathcal{L}_s=CD\bigl(S,\,S^*\bigr),\qquad S=\cup_i q_i(p_i) $$ [2006.07793]. To permit multi-modal outputs, the method employs a Min-of-N loss: it samples $z\sim\mathcal{N}(0,1)^d$, feeds $(P,z)$ through the network $M$ times, and keeps only the best match to the single ground-truth assembly; in practice $M=5$ [2006.07793]. The network is trained with Adam at learning rate $1\mathrm{e}{-3}$ for about 200 epochs, with batch size 32 shapes, $T=5$ iterations, and supervision of $q_i^{(t)}$ at every iteration; equal weights are used on $\mathcal{L}_t$, $\mathcal{L}_r$, and $\mathcal{L}_s$ inside the MoN loss [2006.07793]. The reported metrics are Shape Chamfer distance, Part accuracy defined as the percentage of parts whose $CD<\tau_p=0.01$, and Connectivity accuracy defined as the percentage of ground-truth adjacent pairs whose predicted contact points are within $\tau_c=0.01$ [2006.07793]. On PartNet Chair/Table/Lamp, the full model outperforms three baselines—a global one-shot regressor, bidirectional LSTM, and component-pooling network—by large margins in all three metrics [2006.07793]. In ablation, removing the GNN backbone drops part accuracy from $49.51\%\to 26.05\%$; adding only relation reasoning yields $46.85\%$, adding only part aggregation yields $48.01\%$, and the full dynamic graph yields $49.51\%$ [2006.07793]. Performance peaks at $T=5$; fewer points yield slightly worse performance; and max-pool versus mean-pool has similar effect [2006.07793]. The single-image assembly model uses a different supervision regime. It first trains a mask segmentation module with a soft-IoU loss under Hungarian matching within each equivalence class, then enables the PAG module for pose prediction [2003.09754]. The pose loss combines translation, a symmetric-robust rotation Chamfer term over rotated point clouds, an $\ell_2$ regularizer on the full point set, and a holistic assembly Chamfer loss, $$ L_{pose}=\sum_{i=1}^N[\lambda_1L_T^i+\lambda_2L_C^i+\lambda_3L_E^i]+\lambda_4L_W, $$ with weights $\lambda_1=1$, $\lambda_2=20$, $\lambda_3=1$, and $\lambda_4=1$ [2003.09754]. Evaluation is on PartNet Chair/Table/Cabinet using Part Accuracy and Shape Chamfer Distance [2003.09754]. RGL-NET also uses a minimum-over-$N$ loss with translation, rotation, and global shape Chamfer terms [2107.12859]. The abstract reports up to $10\%$ improvement in part accuracy and up to $15\%$ improvement in connectivity accuracy on PartNet relative to the then current state of the art [2107.12859]. This suggests that progressive graph refinement and recurrent memory improve not only pose fidelity but also relational coherence at predicted contacts. ## 5. Explicit relational and constraint-based PAGs In PARSE, PAG is a source of analytic geometric constraints rather than only latent messages. Each part-part edge $e=(p_i,p_j)$ with label $\Phi(e)=(r,s_i,s_j)$ induces constraints on rigid-body poses $x_i=(R_i,t_i)$ and $x_j=(R_j,t_j)$ [2603.07704]. For contact relations such as “on,” the method enforces non-penetration and proximity: $$ 0 \le d\bigl(S_i(x_i),S_j(x_j)\bigr)\le \varepsilon_{ij}. $$ For coplanarity and normal alignment, if $n_i(s_i)$ denotes the unit normal of the named surface in canonical pose and $N_i=R_i n_i$, then $$ N_i^\top N_j=-1 $$ for antiparallel normals, together with a coplanarity condition involving canonical offsets of named surfaces’ centroids [2603.07704]. For containment (“in”), every vertex $v$ of the moving part’s mesh must satisfy half-space inequalities describing the container volume: $$ h_k(R_jv+t_j)\ge 0\qquad \forall v\in \mathrm{Verts}(p_i). $$ The associated Part-Aware Spatial Configuration Solver places objects in topological order of a support DAG and solves a feasibility or soft-penalty optimization over pose, $$ \min_{R_k,t_k}\; \sum_{(p_k,p_j)\in E_{pp}}w_{kj}\,\|C_{r(e)}(x_k,x_j)\|^2 +\gamma\sum_{j0$, an edge $(v_i,v_j)\in E$ is declared [2607.01205]. Node and edge embeddings are then propagated through GATv2Conv layers with dynamic attention: $$ \ell_{ij}=\mathrm{LeakyReLU}\bigl(a^\top[W_h h_i^{(l)}\|W_h h_j^{(l)}\|W_e e_{ij}]\bigr), $$ $$ \alpha_{ij}=\frac{\exp(\ell_{ij})}{\sum_{k\in N(i)}\exp(\ell_{ik})}, $$ $$ h_i^{(l+1)}=\sigma\Bigl(\sum_{j\in N(i)}\alpha_{ij}\cdot (W_hh_j^{(l)}+U_e e_{ij})\Bigr), $$ so interface features influence both attention scoring and aggregation [2607.01205]. The training objective is masked part prediction over $C=500$ part clusters using class-weighted cross-entropy [2607.01205]. Reported performance with PointMAE embeddings is Top-1 $=6.34\pm 0.67\%$, Top-3 $=13.02\pm 0.47\%$, Top-5 $=16.92\pm 0.66\%$, Top-10 $=23.56\pm 1.07\%$, Top-50 $=44.76\pm 0.97\%$, and F1 $=6.01\pm 0.71\%$; a logistic-regression baseline on neighborhood-pooled node features achieves Top-1 $=5.99\%$ and F1 $=4.68\%$, while k-NN gives Top-1 $=3.93\%$ [2607.01205]. Ablations show that random edge rewiring drops Top-1 from $6.34\%\to 5.48\%$, deleting $10\%$ of edges yields $4.83\%$, no edge attributes yields $6.00\%$, random edge attributes yields $5.84\%$, and replacing GATv2 with standard GAT reduces Top-1 to $5.46\%$ [2607.01205]. These works collectively indicate that PAG is not tied to any single downstream task. It can support clustering, retrieval, robust recognition, and structural memory, provided that part-level relations are the signal of interest. ## 7. Common themes, differences, and research significance A recurring misconception is that PAG denotes a single standardized graph architecture. The literature does not support that interpretation. In some papers, PAG is fully connected and directed with self-loops, and relation structure is learned dynamically through scalar weights over all ordered part pairs [2006.07793; 2107.12859]. In others, edges are sparse and semantically prescribed by adjacency in segmentation [2512.18192], physical contact in CAD [2607.01205], mating constraints across assembly states [2402.07677], or physical joints in a product graph [2512.13219]. In PARSE, PAG is explicitly heterogeneous and typed, spanning both object- and part-level nodes [2603.07704]. The term therefore identifies a modeling granularity and relational philosophy more than a fixed topology. Another important distinction concerns whether PAG is primarily latent or explicit. Dynamic assembly models use PAG as a learnable structure for message passing and pose refinement, with supervision applied to poses and assembled geometry rather than to graph labels themselves [2006.07793; 2107.12859]. By contrast, PARSE, GBOT, and PyCAALP use PAG edges as explicit carriers of geometric or kinematic constraints that can be checked, optimized, or propagated analytically [2603.07704; 2402.07677; 2512.13219]. Linkify occupies an intermediate position: edge existence is explicit and physically computed, but its interface geometry is embedded and then consumed by a learned attention mechanism [2607.01205]. The shift from object-centric to part-centric relational structure is a consistent motivation across these works. In 3D assembly, ambiguities arise from repeated parts and long-range inter-part dependencies [2006.07793; 2003.09754]. In scene generation, object-level relations are “too coarse to specify which regions actually support, contain, or contact one another,” motivating part-level PAGs with named surfaces and analytic constraints [2603.07704]. In object discovery under occlusion and distribution shift, explicit graph representations are introduced because implicit object-centric methods “fail to recognize these learned objects in occluded or out-of-distribution contexts” [2512.18192]. In CAD retrieval, interface geometry is emphasized because “function is realized” at contacts between parts rather than in isolated part shape [2607.01205]. This suggests a broader interpretation of PAG as a unifying abstraction for situations in which the decisive information lies in how substructures meet. Whether the downstream problem is pose estimation, scene feasibility, assembly tracking, sequence planning, unsupervised discovery, or masked-node retrieval, PAG concentrates the representation on parts, interfaces, and relational constraints at the scale where physical and structural semantics are expressed. Source: https://www.emergentmind.com/topics/part-centric-assembly-graph-pag