💻 computer science

Linkify: Learning from Interface-Augmented Assembly Graphs

The paper introduces Linkify, a framework that leverages interface-augmented assembly graphs and Graph Attention Networks to improve context-aware part retrieval in mechanical assemblies by explicitly modeling high-fidelity contact geometry between components.

Original authors: Anushrut Jignasu, Daniele Grandi

Published 2026-07-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Anushrut Jignasu, Daniele Grandi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to fix a complex machine, like a bicycle or a robot. You have a box of spare parts, but you don't know which specific screw, gear, or bracket fits into the empty spot you're looking at.

Usually, if you asked a computer to help, it would look at the shape of the missing piece and say, "This looks like a screw," or "This looks like a bracket." But that's not very helpful. A screw that fits a tiny watch is useless for a giant engine, even if they are both screws. The computer needs to understand context: Where does this part go, and how does it touch the parts around it?

This is what the paper "Linkify" is all about. Here is the story of their solution, explained simply:

1. The Problem: The "Blind" Assembly

Engineers design machines by snapping parts together. In the digital world, these designs are stored as "assembly graphs." Think of this graph like a family tree:

Nodes (The People): The individual parts (gears, plates, screws).
Edges (The Relationships): How the parts connect.

The problem is that in most existing digital libraries, the "edges" are weak. They might just say, "Part A is near Part B," or they might be completely missing. It's like having a family tree that tells you who is related to whom, but doesn't tell you how they are related (e.g., are they holding hands? are they hugging? are they fighting?).

The authors realized that the most important information is hidden in the interface—the exact spot where two parts touch. That is where the function happens.

2. The Solution: "Linkify" (The Super-Connector)

The team created a new system called Linkify. They didn't just look at the parts; they looked at the connections.

Cleaning the Data: First, they took a massive library of 3D designs (the Fusion 360 Gallery) and realized the connection data was broken or missing. They wrote a program to re-calculate exactly where every part touches every other part, creating a perfect map of all the "handshakes" between components.
The New Graph: They built a new type of map where:
- The Nodes are the parts (described by their 3D shape).
- The Edges are the contact points (described by the exact shape of the touch).
The AI Brain: They trained a special type of AI (a Graph Neural Network) to look at this map. Instead of just memorizing shapes, the AI learned to pay attention to the "edges." It learned that a specific type of "hug" (contact) between a cylinder and a flat plate usually means a specific type of bolt is needed.

3. The Test: The "Missing Piece" Puzzle

To see if their system actually worked, they played a game of "Hide and Seek" with the AI.

They took a machine, covered up one part (masked it), and showed the AI the rest of the machine.
They asked the AI: "Based on how the surrounding parts are touching each other, what kind of part is missing?"
The AI had to guess the missing part from a library of 500 different categories of parts.

4. The Results: Why the "Edges" Matter

The results showed that looking at the connections makes a huge difference:

Without the connections: If you just look at the parts nearby (like a simple list), the AI guesses wrong most of the time. It's like trying to guess what's in a sealed box just by looking at the box's color.
With the connections (Linkify): When the AI could see the "handshakes" (the interface geometry), it got significantly better at guessing. It realized, "Ah, this flat plate is touching this curved rod in a specific way, so it must be a specific type of clamp."

They also tested different "attention" mechanisms (how the AI focuses its brain). They found that the AI needed to be able to dynamically focus on the most important connections, rather than treating all connections equally.

5. The Catch (Limitations)

The paper is honest about what the system can't do yet:

It's not magic: The AI is good at guessing the category of the part (e.g., "it's a bracket"), but it's not perfect at picking the exact 3D model.
It doesn't understand physics yet: The AI sees the shape of the touch, but it doesn't fully understand the forces involved (like how much weight the part needs to hold) or the specific mechanical rules (like "this must be a spinning joint").
Data hunger: The system works best with more data. The current library is good, but a bigger library would make the AI even smarter.

The Bottom Line

Linkify is a new way of teaching computers to understand machines. Instead of just looking at the individual Lego bricks, it teaches the computer to look at how the bricks click together. By focusing on the "click" (the interface), the computer gets much better at understanding how a machine works and can help engineers find the right missing piece much faster.

Technical Summary: Linkify – Learning from Interface-Augmented Assembly Graphs

Problem Statement

Recent advances in generative AI for Computer-Aided Design (CAD) have primarily focused on isolated parts or monolithic assemblies, often neglecting the critical geometric information found at the interfaces between interacting components. While existing assembly graph representations utilize nodes for parts and edges for kinematic joints or hierarchical structures, they frequently omit the precise contact geometry that defines how parts fit and function together. This lack of interface-awareness limits the ability of machine learning models to perform context-aware tasks, such as part retrieval, where understanding "what fits here" is essential. Furthermore, existing datasets, such as the Fusion 360 Gallery Assembly dataset, contain erroneous or missing interface data, hindering the training of robust models.

Methodology

The authors propose Linkify, a framework that leverages interface-augmented assembly graphs to learn context-dependent representations of mechanical parts. The methodology consists of three primary stages:

1. Dataset Reconstruction and Augmentation

The authors address the data quality issue by recomputing high-fidelity interface geometry for the entire Fusion 360 Gallery Assembly dataset (8,251 assemblies, 154,468 parts).

Interface Computation: Using the Open CASCADE Technology (OCCT) B-Rep kernel, the authors perform native Boolean operations (BRepAlgoAPI_Common) to calculate exact geometric intersections between contacting faces.
Point Cloud Generation: From these precise intersection volumes, point clouds are sampled (2,048 points per interface) to serve as input for neural encoders.
Graph Construction: An assembly graph is constructed where nodes represent individual parts and edges represent the computed contacts.
Labeling: Node labels are generated via unsupervised k-means clustering ( $k=500$ ) on part embeddings, creating a geometric category vocabulary for the retrieval task.

2. Graph Representation and Embedding

The framework constructs an interface-augmented graph $G = (V, E, M, Y)$ :

Node Embeddings: Part geometries are encoded using pretrained point cloud encoders. The authors evaluate two: PointMAE (pretrained on ShapeNet) and DGCNN (pretrained on ModelNet40).
Edge Embeddings: Interface geometries are encoded using the same PointMAE encoder, resulting in 384-dimensional vectors that capture the local contact region's shape.
Task Formulation: The system is trained on a masked part prediction task. Given an assembly graph with one node masked (feature vector zeroed), the model must predict the cluster label of the missing part from the 500-class vocabulary. This serves as a proxy for context-aware part retrieval.

3. Model Architecture

The core model is a Graph Attention Network (GAT) utilizing the GATv2 variant.

Dynamic Attention: Unlike standard GAT, GATv2 computes attention weights dynamically based on the source node, target node, and the query itself, allowing for more expressive, context-dependent message passing.
Training: The model is trained using cross-entropy loss with class weighting to address imbalance, optimized via Adam with a cosine annealing schedule.

Key Contributions

Interface-Aware Dataset: The authors provide a corrected, high-fidelity version of the Fusion 360 Gallery Assembly dataset, featuring recomputed geometric interface definitions (contact areas, volumes, and point clouds) for all assemblies.
Linkify Framework: A novel GNN architecture (based on GATv2) that explicitly incorporates interface geometry as edge attributes, demonstrating how to integrate these features into a learning pipeline for assembly graphs.
Empirical Validation: A comprehensive series of ablation studies and baseline comparisons that quantitatively measure the importance of graph topology, edge attributes, and attention mechanisms.

Results

The authors evaluate the model against several baselines: Random Guess, Majority Class, Logistic Regression (on aggregated node features), and k-Nearest Neighbors.

Performance: Using PointMAE as the encoder, Linkify achieves a Top-1 accuracy of 6.34% and an F1 score of 6.01%. This represents a significant improvement over the strongest non-graph baseline (Logistic Regression, Top-1: 5.99%) and a 28% relative improvement in F1 score.
Encoder Sensitivity: Models using DGCNN performed worse than Logistic Regression, highlighting that the mismatch between DGCNN's pretraining (ModelNet40) and CAD geometry is a bottleneck, whereas PointMAE (ShapeNet) generalizes better to mechanical parts.
Ablation Studies:
- Connectivity: Randomly rewiring edges caused a 13.6% drop in Top-1 accuracy, while removing 10% of edges caused a 23.8% drop, confirming that correct interface connectivity is critical.
- Edge Attributes: Removing edge attributes resulted in a 5.4% relative drop in Top-1 accuracy, while randomizing them caused a 7.9% drop, proving the semantic value of interface embeddings.
- Attention Mechanism: GATv2 outperformed standard GAT by 16.1% in Top-1 accuracy, validating the necessity of dynamic attention for interface-informed graphs.
Qualitative Analysis: The model successfully retrieves parts with geometric and functional similarity (e.g., gears, cylindrical components) in correct assembly contexts. However, failure cases occur when parts share aspect ratios but have incompatible interface details or when functional roles are not purely geometric.

Significance and Claims

The paper positions Linkify not as a complete assembly synthesis or fit-verification system, but as a retrieval-oriented probe task to validate the hypothesis that interface geometry is critical for understanding part function.

Foundation for Future Work: The authors claim that their corrected dataset and interface-aware graph representation provide a necessary foundation for future models in assembly retrieval, validation, and generative design.
Context-Awareness: The work demonstrates that moving beyond isolated part similarity to include assembly context and interface constraints yields better retrieval performance.
Modest Scope: The authors explicitly acknowledge limitations, noting that the current model struggles with functional roles beyond geometric similarity and relies on pretrained encoders that introduce noise. They frame the current results as a step toward a fully closed-loop system that would eventually require richer descriptors (kinematics, physical properties) and larger-scale datasets.

The authors conclude that while the problem of automated assembly understanding remains unsolved, their interface-augmented approach establishes that graph-based representations combining learned geometry with contact information are essential for modeling hierarchical assembly relationships.