Enhanced Graph Representation Learning for Link Prediction in Human–Machine Collaborative Assembly Knowledge Graphs

Abstract

Human–robot collaborative assembly relies on structured knowledge of components, assembly operations and process constraints. We propose a knowledge graph representation learning framework to predict missing links in assembly knowledge. A human–robot collaborative assembly knowledge graph is constructed through joint entity–relation extraction, entity alignment and manual verification. Two adaptive relational graph attention network encoders learn structural and semantic representations, which are fused through element-wise addition. A local–global mutual information objective guides structural representation learning, while a Fourier Kolmogorov–Arnold network decoder scores candidate triples. Link prediction experiments on WN18RR, FB15K-237 and the domain-specific HRKG examine the contributions of the model components through ablation. The complete model achieves mean reciprocal ranks of 0.498, 0.382 and 0.902, respectively. An assembly assistance system integrates visual recognition, link prediction, and robotic grasping and delivery. In 600 gearbox assembly subtasks, component requirement prediction was correct in 576 of 594 trials with correct target recognition (97.0%), and the complete workflow succeeded in 550 trials (91.7%). The stage-specific evaluation distinguishes prediction performance from system-level task completion.

1. Introduction

Human–robot collaboration (HRC) enables human operators and robots to jointly perform assembly tasks within a shared workspace [1,2]. Research in this field has addressed collaborative control [3], digital twin-assisted assembly optimization [4], task scheduling [5], assembly planning [6], operator feedback [7] and trajectory tracking [8]. Dmytriyev et al. [9] integrated a brain–computer interface with hand-guiding control, enabling operators to request robotic assistance on demand during assembly. Fu and Zhao [10] investigated compliant control for human–robot interaction based on the Maxwell model. Collectively, these studies have provided approaches to facilitating information exchange, task planning and physical interaction in collaborative assembly.

Assembly tasks also require the identification of components, tools and process steps relevant to the ongoing operation. Knowledge graphs organize such information as entities and relations, providing a structured representation of assembly knowledge. However, missing knowledge can limit the coverage of graph-based queries, making it necessary to identify and rank candidate entities that may complete missing facts. To address this challenge, this study employs knowledge graph link prediction to enhance the retrieval and completion of assembly-related knowledge.

In human–robot collaborative assembly, perceiving operator behaviour and task context is essential for determining appropriate assistance actions. Previous studies have investigated human actions and collaborative requirements using different sources of perceptual information. Xue [11] examined human skeletal information, whereas Zhang et al. [12] integrated human motion and object information. Xiao et al. [13] jointly considered human actions, tools and orientation, while Li et al. [14] investigated motion generation in collaborative scenarios. Other studies have incorporated digital human models and domain adaptation [15], eye–hand information [16], gesture sequences [17] and evidence fusion [18] to support collaborative decision-making. These approaches primarily infer human behaviour or assistance requirements directly from perceptual observations. By contrast, this study focuses on predicting missing links in assembly knowledge graphs. Specifically, structured relationships among components, process steps and operations are exploited to score and rank candidate entities, providing knowledge candidates that can inform subsequent robot-assisted component retrieval and assembly.

Knowledge acquisition and graph completion represent distinct stages of knowledge processing. KnowEdu [19] demonstrates how structured knowledge can be constructed from domain-specific information. In engineering applications, Pan and Li [20] combined reinforcement learning with a global pointer network for joint entity–relation extraction, addressing overlapping entities and complex relations in transmission-system fault texts. These studies highlight the importance of explicitly defining entity categories and relation types, together with appropriate quality-control procedures, when constructing domain-specific knowledge graphs. Once validated triples have been incorporated into a knowledge graph, representation learning models map entities and relations into vector spaces. By exploiting existing structural and semantic relationships, these models score and rank candidate triples that have not yet been recorded, thereby identifying potentially missing knowledge.

Against this background, we investigate a dual-encoder architecture for knowledge graph link prediction in human–robot collaborative assembly. The proposed framework integrates relation-aware neighbourhood aggregation, a local–global mutual information objective and a nonlinear Fourier Kolmogorov–Arnold network (Fourier KAN) decoder. Candidate-entity ranking is evaluated on public benchmark knowledge graphs and a domain-specific assembly knowledge graph. A gearbox assembly case study evaluates component requirement prediction under correct visual input and separately records recognition, robotic execution and operator assembly outcomes.

2. Materials and Methods

2.1. Construction of the Human–Robot Collaborative Assembly Knowledge Graph

Collaborative assembly involves human operators, components, tools and process requirements [21]. In this study, assembly knowledge is represented as a knowledge graph (G = (V, R, T)), where (V) denotes the set of entity instances, (R) is the set of relation types, and (T) is the set of factual triples ((h, r, t)), with (h, t\in V) and (r\in R). Entity categories define the semantic types of nodes, whereas entity instances represent specific concepts or objects. Similarly, relation types define the labels of edges in the graph, while each relation instance corresponds to a specific factual triple.

The data were primarily collected from printed and electronic product assembly manuals, supplemented by technical publications and relevant standards. During preprocessing, irrelevant passages and duplicate content were removed, and textual expressions were standardized. The retained assembly information was organized into a domain-specific corpus. Existing structured process records were also preserved and integrated with the information extracted from text to provide complementary sources of assembly knowledge.

To construct the knowledge graph, entities and relations were defined according to their roles in collaborative assembly. Entities representing physical objects and participating agents were categorized as operators, components, tools and auxiliary materials, whereas process-related entities included assembly objects, process steps, operating standards and precautions. Operational relations encompassed assembling, fitting, wiping, applying, tightening, picking, measuring, filling, tapping and unknown operations. Process-related relations, including sub-event and temporal relations, were used to connect assembly events and represent their sequential dependencies. Table 1 presents selected representative entity categories and relation types and their descriptions; it is not an exhaustive inventory of all entity categories and relation types in HRKG.

Table 1. Selected entity categories and relation types in HRKG and their descriptions.

Ontology Element	Entity Category or Relation Type	Description
Physical Objects and Agents	Operator; Component; Tool; Auxiliary Material	Examples include operators, washers, wrenches and lubricants.
Process Entities	Assembly Object; Process Step; Operating Standard; Precaution	Associate assembly operations with their corresponding process contexts across different assembly steps.
Operational Relations	Assembling; Fitting; Wiping; Applying; Tightening; Picking; Measuring; Filling; Tapping; Unknown Operation	Head and tail entities must satisfy the semantic and entity-type constraints associated with each operation.
Process Relations	Sub-event; Temporal Precedence	Connect process events and represent their sequential dependencies.

To standardize the annotation scheme and extraction scope of the assembly corpus, entities were annotated based on domain-specific assembly knowledge. Each entity annotation included its semantic category and start and end positions in the source text. Relations between entities were also annotated and represented as head entity–relation–tail entity triples, such as “Operator–Picking–Washer”.

Following the definition of entity and relation types, the RoBERTa-GP-FAT model was employed to jointly extract entity boundaries and inter-entity relations from the annotated corpus. The model comprises three components: feature representation, joint decoding and adversarial training, implemented using a RoBERTa layer [22], a Global Pointer (GP) layer [23] and a Free Adversarial Training (FAT) module [24], respectively. The architecture of the RoBERTa-GP-FAT model for joint entity and relation extraction is illustrated in Figure 1.

Figure 1. Architecture of the RoBERTa-GP-FAT model for joint entity and relation extraction. (The colors are used consistently for visual distinction and aesthetic presentation only, and do not represent specific functional or quantitative meanings.)

In the feature representation stage, the annotated corpus is first processed by RoBERTa to generate contextualized text embeddings, which are subsequently fed into a Transformer encoder for further feature extraction. By capturing long-range dependencies within input sequences, the encoder integrates contextual information to produce task-specific textual representations, providing discriminative features for subsequent entity and relation prediction.

The joint decoding stage employs a Global Pointer (GP) layer comprising two modules for entity prediction and entity–relation pair prediction, respectively. These modules identify entities within the text and determine their associated relations. The GP layer leverages an attention mechanism to assign varying weights to different parts of the input sequence. The resulting outputs are then transformed into probability distributions, from which entities and relations are selected according to their predicted probabilities, enabling joint entity and relation extraction.

The adversarial training stage adopts the Free Adversarial Training (FAT) strategy, in which adversarial examples are generated by introducing small-step perturbations into training samples. When the perturbations exceed a predefined threshold, they are projected back onto the admissible perturbation space to ensure compliance with the specified constraints. Model parameters are iteratively updated during adversarial training to improve robustness and generalization.

The RoBERTa-GP-FAT model performs joint extraction under predefined entity and relation label constraints. For each candidate triple, entity boundaries, relation endpoints and entity categories are first checked against the annotation requirements. The extracted facts are then manually verified against the original text. Only triples supported by explicit textual evidence, correctly classified entities and unambiguous relation semantics are retained.

Although joint entity and relation extraction yields a collection of entities, relations and factual triples, the resulting knowledge may contain redundant or duplicate entries and ambiguous entity mentions. To address these issues, a probabilistic entity alignment method based on relation functionality is employed. First, relations in the extracted triples are represented as relation functions, with their functionality and inverse functionality used to characterize correspondence constraints between entities. Next, the relational contexts of candidate entities and the alignment information of neighbouring entities are jointly considered. Evidence supporting or contradicting a potential match is integrated to estimate alignment probabilities and determine whether candidate entities refer to the same underlying object. Finally, abbreviations, identifiers and aliases referring to the same object are standardized, and duplicate triples introduced by entity merging are removed.

Following entity alignment, Protégé (version 5.6.9) was used to organize concept hierarchies and properties according to the predefined entity and relation categories, thereby establishing the schema layer of the knowledge graph. Entity classifications, relation labels and alignment results were manually reviewed to correct errors and eliminate unverifiable information. The validated triples were subsequently consolidated with structured process data into comma-separated values (CSV) files. Python (version 3.9.18) and the py2neo library (version 2021.2.4) were then used to connect to Neo4j (version 4.4.48), enabling the creation and merging of entity nodes, properties and relations. Finally, Cypher queries and the Neo4j visualization interface were employed to explore assembly knowledge and its associated relationships, establishing a structured data foundation for subsequent knowledge retrieval and link prediction.

The resulting human–robot collaborative assembly knowledge graph, denoted as HRKG, contains 1925 entities, 2425 relation types, and 13,840 triples. These triples were obtained through the entity–relation extraction, manual verification, and structured process data integration procedures described above. The resulting triple collection was subsequently divided into training, validation, and test sets containing 11,040, 1380, and 1420 triples, respectively. Their sum is 13,840, consistent with the total number of triples in HRKG. Visualization of selected nodes in the knowledge graph for collaborative assembly is presented in Figure 2.

Figure 2. Knowledge graph for human–robot collaborative assembly. The circles represent entities, and the arrows connecting them represent relations between entities. Different colors are used consistently for visual distinction and aesthetic purposes only and do not carry any specific semantic meaning.

Heterogeneity in multisource assembly data and errors in information extraction may lead to missing or inconsistent facts. Moreover, stored triples alone do not provide a mechanism for scoring unobserved candidate facts. To address these limitations, the proposed framework first maps entities and relations in the constructed knowledge graph into vector representations. Adaptive relational graph attention network (ARGAT) encoders are then employed to aggregate neighborhood and relational information, while a local–global mutual information objective guides the learning and fusion of structural and semantic features. The resulting representations are subsequently fed into a Fourier Kolmogorov–Arnold network (Fourier KAN) decoder to score and rank candidate entities for missing link prediction.

2.2. Network Architecture

As illustrated in Figure 3, the proposed model consists of two adaptive relational graph attention network (ARGAT) encoders and a Fourier Kolmogorov–Arnold network (Fourier KAN) decoder. The structural branch learns entity representations H_str under a local–global mutual information objective, whereas the semantic branch learns entity representations H_sem and relation representations for candidate triple scoring. Both branches employ an embedding dimension of (d = 200), with the corresponding rows of their embedding matrices aligned according to entity identifiers. For each entity, the representations generated by the two branches are fused through element-wise addition, yielding H = H_str + H_sem. The fused entity representations, together with the learned relation representations, are subsequently fed into the Fourier KAN decoder to assign plausibility scores to candidate triples.

Figure 3. Dual-encoder framework for knowledge graph link prediction. The circles represent entity nodes, with blue and pink circles indicating the starting and ending entities of the illustrated assembly paths, respectively. The arrows connecting entity nodes represent directed assembly relationships between the corresponding entities, while arrows between model components indicate the direction of information flow. The question marks denote unknown entities to be inferred, and the orange highlights indicate the predicted entities that complete the corresponding assembly relationships within the assembly task. Other colors are used primarily for visual distinction.

2.2.1. Adaptive Relational Graph Attention Network

The adaptive relational graph attention network (ARGAT) integrates neighbouring entity information with relational information and employs an attention mechanism to assign adaptive weights to individual messages. Let $x_i^{\left(k\right)}$ denote the (d)-dimensional representation of entity (i) at the (k)-th network layer, and $r_{\mathit{ij}}^{\left(k\right)}$ denote the representation of the directed relation between neighbouring entity (j) and entity (i). The relation-specific neighbourhood $N_i^r$ comprises entities that transmit messages to entity (i) through relation (r). Taking node 4 and its four immediate neighbors as an illustrative example, Figure 4 depicts the message aggregation process, with the representation update formulated as follows:

$$x_i^{(k+1)}=\sigma \left({\displaystyle \sum _{r\in R}{\displaystyle \sum _{j\in N_i^r}\frac{{\alpha }_{i,j,r}^{(k)}}{c_{i,r}}}}\phi \left(x_j^{(k)},r_{i,j}^{(k)}\right)\right)$$

(1)

$${\alpha }_{i,j,r}^{(k)}=\mathrm{softmax}\left(b_{i,j,r}^{(k)}\right)$$

(2)

$${\alpha }_{i,j,r}^{(k)}={\displaystyle \frac{\exp \left(b_{i,j,r}^{(k)}\right)}{{\displaystyle \sum _{u\in N_i^r}\exp }\left(b_{i,u,r}^{(k)}\right)}}$$

(3)

$$b_{i,j,r}^{(k)}=\mathrm{LeakyReLU}\left(w_a^{\mathrm{T}}\left[x_i^{(k)}\Vert r_{i,j}^{(k)}\Vert x_j^{(k)}\right]\right)$$

(4)

Figure 4. Schematic illustration of relation-aware aggregation at node 4.

Here, i and j denote entity indices, k denotes the network layer index, and r denotes the relation type index. The coefficient ${\alpha }_{i,j,r}^{\left(k\right)}$ represents the normalized importance weight assigned to the message associated with neighboring entity j and relation (r), whereas $b_{i,j,r}^{\left(k\right)}$ denotes the corresponding unnormalized score. The Softmax normalization is performed over the relation-specific neighborhood defined in Equation (3). The quantity c_i,r = |$N_i^r$| denotes the number of neighbors connected to entity i via relation r. The operator \Vert denotes vector concatenation, w_a is a learnable attention vector, and σ in Equation (1) denotes the nonlinear activation function used for aggregation. Each incoming message uses the feature representation $x_j^{\left(k\right)}$ of the neighboring entity, distinguishing it from the feature representation $x_i^{\left(k\right)}$ of the central entity.

The combination function φ integrates entity representations with their corresponding relation representations. Because cross-correlation is non-commutative, the respective roles of the two operands are preserved. Relation direction is also incorporated into the message definition. The combination operation and relation representation update are formulated as follows:

$$\phi \left(x_j^{(k)},r_{i,j}^{(k)}\right)=x_j^{(k)}*r_{i,j}^{(k)}$$

(5)

$$r_r^{(k+1)}=W_r^{(k)}{r}_r^{(k)}$$

(6)

The asterisk operator (*) in Equation (5) denotes circular cross-correlation. In Equation (6), $W_r^{\left(k\right)}$ represents a learnable relation transformation matrix with dimensions compatible with the corresponding input and output representations.

2.2.2. Local–Global Mutual Information Estimation

The original inputs (X,W) are processed by the ARGAT encoder to obtain the local representation matrix (Y) for all entities. To capture graph-level information, global average pooling is applied to aggregate the local entity representations into a global graph representation, as formulated in Equation (7).

$$S={\displaystyle \frac{1}{N}}{\displaystyle \sum _{i=1}^N{y}_i}$$

(7)

Here, S denotes the global representation of the original graph, N is the total number of entities in the graph, and y_i represents the local representation of the i-th entity. By averaging the local representations of all entities, the pooling operation aggregates neighborhood information into a fixed-dimensional global vector.

To generate negative samples for local–global mutual information learning, a random permutation of the entity indices 1, 2, …, N is generated at each training iteration. The rows of the entity feature matrix are then reordered according to the permuted indices, as follows:

$$\pi =\mathit{RandPern}(N),\tilde{X}=X[\pi ,:],\tilde{W}=W$$

(8)

In Equation (8), RandPern N denotes a uniformly random permutation of the entity indices 1, 2, …, N, and π represents the resulting permutation sequence. The notation X[π,:] indicates that the rows of the entity feature matrix are reordered according to π, while the colon denotes the retention of all feature dimensions. The resulting permuted entity feature matrix is denoted by $\tilde{X}$. Each possible permutation is sampled with an equal probability of 1/N!

The permutation alters only the correspondence between entity features and node positions, while preserving graph connectivity, edge directions and input relation features. Consequently, the graph structure input to the perturbed branch remains unchanged, satisfying $\tilde{W}=W$.

The original and perturbed inputs are subsequently passed through the ARGAT encoder with shared parameters

$$\left\{\begin{array}{c}Y={\mathit{ARGAT}}_{\theta }(X,W)=[y_1,y_2,\dots ,y_n]\\ Y={\mathit{ARGAT}}_{\theta }(X,W)=[y_1,y_2,\dots ,y_n]\end{array}\right.$$

(9)

In Equation (9), ARGAT_θ(g) denotes the ARGAT encoder, and θ represents its learnable parameters. Both encoding processes share the same set of parameters. Y and $\tilde{Y}$ denote the entity representation matrices obtained from the original and perturbed inputs, respectively, while y_i and ${\tilde{y}}_i$ represent the corresponding local representations of the i-th entity.

The original local entity representation y_i is paired with the global representation S of the original graph to form a positive sample pair, whereas the perturbed representation ${\tilde{y}}_i$ is paired with the same global representation S to form a negative sample pair. Each original entity representation is associated with one perturbed representation, yielding a 1:1 ratio of positive to negative sample pairs. This perturbation disrupts the correspondence between entity features and their original graph neighbourhoods without directly replacing the head entity, tail entity or relation in the knowledge graph triples, as illustrated in Figure 5.

Figure 5. Entity feature permutation in local–global contrastive learning. The original and perturbed inputs share the same structural encoder parameters, and both sets of node representations are paired with the global summary of the original graph. In the schematic, X denotes the entity feature matrix, while W represents the fixed graph connectivity input, corresponding to A in the main text.

A bilinear discriminator is employed to estimate the degree of correspondence between each node representation and the global graph summary, as follows:

$$D(y_i,s)=\mathit{sigmoid}\left(y_i^T{W}_{D}s\right)$$

(10)

In Equation (10), D denotes the discriminator, and the sigmoid function maps its unnormalized output scores to the interval (0,1). W_D is a learnable matrix of dimension d × d, and the superscript T denotes matrix transposition. The contributions from positive and negative sample pairs jointly define the contrastive loss as follows:

$$L_{\mathit{MI}}=-{\displaystyle \frac{1}{2N}}{\displaystyle \sum _{i=1}^N\left[\log \left(D(y_i,s)\right)+\log \left(1-D({\tilde{y}}_i,s)\right)\right]}$$

(11)

Equation (11) defines the contrastive objective as a loss function to be minimized. By minimizing this loss during training, the model increases the correspondence between the original node representations and the global graph summary while reducing the correspondence between the perturbed node representations and the same global summary.

2.2.3. Fourier KAN Decoder

The Fourier KAN decoder scores candidate links using nonlinear functions (Figure 6). In each KAN layer, learnable univariate functions are assigned to network edges, and their outputs are aggregated at the nodes. The theoretical foundation of KANs lies in the representation of multivariate functions through compositions and sums of univariate functions [25]:

$$f(x_1,\dots ,x_n)={\displaystyle \sum _{q=1}^{2n+1}{\psi }_q}\left({\displaystyle \sum _{p=1}^n{\phi }_{q,p}}(x_p)\right)$$

(12)

Figure 6. Conceptual illustration of the Fourier KAN decoder. The dashed-line circle highlights a representative learnable univariate function for illustrative purposes and does not indicate an additional network component.

In Equation (12), x_p denotes the p-th scalar input, n is the number of inputs, and φ_q,p and ψ_q are univariate functions, where q indexes the summation terms in the theorem. The term 2n + 1 specifies the number of terms in the theoretical representation. In conventional KAN parameterizations, learnable edge functions are typically represented by combining trainable spline functions with basis functions:

φ(z) = w_s spline(z) + w_b b(z)

(13)

The Fourier KAN replaces the spline components with Fourier series to parameterize the learnable univariate functions:

φ(z) = w_f fourier(z) + w_b b(z)

(14)

In Equations (13) and (14), spline(z), fourier(z), and b(z) denote the spline component, Fourier-series component, and basis-function component, respectively, while w_s, w_f, and w_b are trainable coefficients. The truncated Fourier expansion consists of a constant term and learnable sine and cosine components. The decoder takes the entity and relation representations produced by the encoder as input and outputs a scalar score for each candidate fact, thereby enabling nonlinear ranking.

2.3. Gearbox Assembly Workflow and State Determination

In this study, the integrated workflow comprising visual recognition, assembly-state determination, knowledge graph link prediction, and robotic grasping and delivery is referred to as a knowledge graph–driven assembly assistance system. Taking gearbox assembly as an example, after recognizing the breather plug and sight glass cover, the system matches the recognition results against the assembly steps, step identifiers, and temporal relations encoded in the knowledge graph to determine the current assembly stage. It then formulates a query based on the component requirements of the next assembly step, namely, “(operator, picks up, ?),” and scores and ranks the candidate components.

When the gasket receives the highest score, the system identifies it as the preferred component for the current operation and generates an assisted-picking request. Using the gasket’s entity identifier, the system retrieves its visual localization result and transforms the target position into the robot coordinate frame through hand–eye calibration. Motion planning, grasping, and delivery of the gasket are then executed. In this way, the link prediction results are translated into concrete robotic assistance through a sequence of operations: candidate component selection, assistance request generation, target localization, and robotic grasping and delivery.

The assembly assistance system uses the assembly steps, step identifiers, and temporal relations encoded in the knowledge graph to represent the prescribed sequence of assembly operations. Once the current step is confirmed as complete, the system updates the assembly progress and predicts the components or operations required in subsequent steps based on the updated assembly context. If the available observations are insufficient to determine the current step, the system defers the decision until additional visual information becomes available. This process updates only the assembly task state and query conditions; it does not involve online model parameter updates or retraining.

For each prediction, the system also provides an association chain linking the recognized components, current assembly step, next step, and candidate target, enabling the operator to verify whether the recommended component is consistent with the actual assembly sequence. If this chain is inconsistent with the current assembly step or the available information is insufficient, the system withholds the grasping and delivery actions until the prediction has been verified, after which the corresponding assistance operation can be triggered.

3. Experimental Results

3.1. Link Prediction Task and Experimental Setup

As illustrated in Figure 7, knowledge graph completion via knowledge representation learning formulates prediction queries in either the head-entity prediction form (?, r, t) or the tail-entity prediction form (h, r, ?), where the missing entity is inferred from the known elements of the triple.

$$\mathit{Hits}@n={\displaystyle \frac{1}{Q}}{\displaystyle \sum _{q=1}^{Q}1}\left[\mathit{ran}{k}_q\le n\right]$$

(15)

$$\mathit{MRR}={\displaystyle \frac{1}{Q}}{\displaystyle \sum _{q=1}^Q\frac{1}{\mathit{ran}{k}_q}}$$

(16)

Figure 7. Knowledge graph completion through knowledge representation learning.

In Equations (15) and (16), Hits@n denotes the proportion of queries for which the correct target entity ranks among the top n candidates, whereas mean reciprocal rank MRR denotes the average reciprocal rank of the correct target entity. Q represents the total number of entity queries evaluated, and rank_q denotes the rank of the correct entity in query q. The indicator function takes a value of 1 when rank_q. The indicators within each group must be calculated using the same set of queries and ranking rules. This study reports Hits@1, Hits@3, Hits@10, and MRR.

In addition to the self-constructed HRKG dataset, two public datasets, WN18RR [26] and FB15k-237, are introduced for comparison. Table 2 lists the numbers of entity instances and relation types, together with the numbers of triples in the training, validation, and test sets. The 13,840 HRKG triples are divided into 11,040 training triples, 1380 validation triples, and 1420 test triples. This study uses the original public WN18RR split, comprising 86,835 training triples, 3034 validation triples, and 3134 test triples, for a total of 93,003 triples. No preprocessing or sample selection was performed to alter this split or the number of samples.

Table 2. Dataset statistics used in the experiments.

Dataset	Number of Entities	Number of Relation Types	Training Triples	Validation Triples	Test Triples
WN18RR	40,943	11	86,835	3034	3134
FB15k-237	14,541	237	272,115	17,535	20,466
HRKG	1925	2425	11,040	1380	1420

The model was implemented in PyTorch (version 2.2.2, with CUDA 12.1 support)and trained on an NVIDIA GeForce RTX 4060 GPU (NVIDIA Corporation, Santa Clara, CA, USA) under Microsoft Windows 11 Professional (version 23H2). The embedding dimensionality was set to 200 for both entities and relations, with dropout rates of 0.1 and 0.2 applied to the encoder and decoder, respectively. Model parameters were optimized using the Adam optimizer [27] with a learning rate of 0.0005.

During training, negative triples were generated by replacing either the head or tail entity of each positive triple with equal probability, with replacement entities sampled uniformly from the entire entity set. Known true triples were excluded from negative sampling, and the ratio of positive to negative samples was maintained at 1:1. The model was trained for a maximum of 400 epochs, with the filtered mean reciprocal rank (MRR) evaluated on the validation set every 10 epochs. Early stopping was triggered if the validation filtered MRR failed to improve over 10 consecutive evaluations. The checkpoint achieving the highest validation filtered MRR was retained for final testing.

Evaluation was performed on both head- and tail-entity prediction tasks, with other known true triples filtered out during candidate ranking. To assess robustness across random initializations, each experiment was independently repeated three times using random seeds of 42, 43 and 44. The final results are reported as the mean MRR, Hits@1, Hits@3 and Hits@10 across the three runs.

3.2. Link Prediction Results

The proposed model was evaluated on WN18RR, FB15K-237 and HRKG using the link prediction metrics defined in Section 3.1. The complete model achieved MRR values of 0.498, 0.382 and 0.902, respectively. Section 3.4 reports results for the complete model and its ablated configurations to examine the contributions of the mutual information and Fourier KAN modules.

These results characterize entity-ranking performance on the evaluated test sets. The ablation study in Section 3.4 examines the model components, while the assembly case study in Section 3.3 assesses prediction in a practical task.

3.3. Robotic Assistance in Reducer Assembly Subtasks

To evaluate how knowledge graph link prediction supports collaborative assembly, 600 trials were conducted using different component types, including washers, nuts and studs. The evaluated subtasks included component retrieval, delivery and placement or installation. Each trial followed four stages: target recognition, component requirement prediction, robotic grasping and delivery, and component assembly by the operator.

Target recognition is correct only when both the component category and position are correctly identified. Component requirement prediction is evaluated among trials with correct target recognition by comparing the model’s original top-ranked prediction with the allowable components specified by the assembly process. Robotic execution succeeds when the correctly predicted component is grasped and delivered to the specified assembly area. A grasping failure is an unsuccessful pickup or failure to secure the component; a delivery failure occurs after successful grasping when the component is lost during transport or delivered to an incorrect location. These operations are reported together as one robotic execution stage in Table 3. Operator assembly is evaluated after correct delivery and succeeds when installation or placement is completed. Each stage uses trials in which all preceding stages succeeded as its valid-trial count. Every unsuccessful trial is assigned to its first failed stage.

Table 3. Stage-specific evaluation and failure statistics for assembly subtasks involving different components.

Experimental Stage	Valid Trials	Successful Trials	Failures	Success Rate
Target recognition	600	594	6	99.0%
Component requirement prediction	594	576	18	97.0%
Robotic grasping and component delivery	576	556	20	96.5%
Component assembly by the operator	556	550	6	98.9%
Overall assembly subtask completion	600	550	50	91.7%

As shown in Table 3, target recognition was correct in 594 of 600 trials (99.0%). Among these 594 trials, the required component was correctly predicted in 576 trials (97.0%). Robotic grasping and delivery succeeded in 556 of these 576 trials (96.5%), and the operator completed installation or placement in 550 of these 556 trials (98.9%). The first-failure counts were 6 for target recognition, 18 for component requirement prediction, 20 for the combined grasping-and-delivery stage, and 6 for operator assembly, totaling 50 failed subtasks. Overall assembly subtask completion was 550/600 = 91.7%. Prediction accuracy characterizes the model output under correct visual input, whereas overall completion characterizes the integrated workflow. The practical prediction accuracy is distinct from MRR and Hits calculated on held-out knowledge graph triples.

3.4. Ablation Study

An ablation study was conducted to evaluate the contributions of individual components to the performance of the proposed model. The results are presented in Table 4 and Table 5.

Table 4. Comparison of model configurations in terms of Hits@1 and Hits@3.

Model	WN18RRHits@1	WN18RRHits@3	FB15K-237Hits@1	FB15K-237Hits@3	HRKGHits@1	HRKGHits@3
ARGAT	0.032	0.295	0.173	0.292	0.524	0.584
ARGAT + Mutual Information	0.423	0.482	0.225	0.341	0.622	0.726
ARGAT + Fourier KAN	0.394	0.437	0.236	0.364	0.828	0.878
Ours	0.450	0.504	0.277	0.406	0.884	0.901

Table 5. Comparison of model configurations in terms of Hits@10 and MRR.

Model	WN18RRHits@10	WN18RRMRR	FB15K-237Hits@10	FB15K-237MRR	HRKGHits@10	HRKGMRR
ARGAT	0.451	0.182	0.422	0.251	0.682	0.573
ARGAT + Mutual Information	0.532	0.471	0.483	0.311	0.823	0.692
ARGAT + Fourier KAN	0.492	0.442	0.492	0.328	0.904	0.862
Ours	0.547	0.498	0.548	0.382	0.928	0.902

As shown in Table 4 and Table 5, the complete model achieves the highest performance among the evaluated configurations across the reported metrics on the three datasets. The mutual information configuration achieves a Hits@1 of 0.423 and an MRR of 0.471 on WN18RR, exceeding the Fourier KAN-only configuration on those metrics. On HRKG, the Fourier KAN configuration increases Hits@1 from 0.524 for ARGAT to 0.828. The complete configuration achieves MRR values of 0.498, 0.382 and 0.902 on WN18RR, FB15K-237 and HRKG, respectively. These results indicate that the two modules contribute to ranking performance in the evaluated model configurations.

4. Discussion

The ablation results show that the complete model performs better than the evaluated ablated configurations on the three datasets. ARGAT aggregates information from entity neighbourhoods and their associated relations, while the local–global mutual information objective promotes consistency between local entity representations and the global graph structure. Fourier KAN provides a nonlinear decoder for scoring candidate triples. Together, these results indicate that the model components contribute to candidate ranking under the evaluated conditions.

These conclusions are limited to the datasets, model configurations and evaluation settings examined here. Future work could compare independently implemented external models using a shared dataset and evaluation protocol, and assess the framework on additional assembly knowledge graphs.

The assembly evaluation shows how predicted links support component retrieval and installation while separating unsuccessful stages. The model correctly predicted the required component in 576 of 594 trials with correct target recognition (97.0%). Recognition, robotic grasping and delivery, and operator assembly achieved 99.0%, 96.5% and 98.9%, respectively, each using its own valid-trial count. The complete workflow succeeded in 550 of 600 subtasks (91.7%). The conditional prediction rate describes the model output under correct visual input, while the overall rate describes the integrated workflow.

Trifunović et al. [28] independently compared expert-based and AI-based approaches, providing a useful methodological reference for further evaluation of the proposed system. Future work could involve assembly domain experts independently identifying the required components from the same visual observations and process records, without access to the model predictions. Agreement between expert judgements and model predictions could then be systematically assessed. Such an evaluation would provide additional evidence of the reliability of the predicted candidates and strengthen the basis for deploying the proposed approach in practical human–robot collaborative assembly.

5. Conclusions

This study presents a dual-encoder framework based on ARGAT, incorporating a local–global mutual information objective and a Fourier KAN decoder for link prediction in human–robot collaborative assembly knowledge graphs. Ablation results show that the complete configuration achieves better ranking metrics than the evaluated ablated configurations on WN18RR, FB15K-237 and HRKG. A gearbox assembly evaluation integrates predicted component candidates with visual observations and process context to generate robotic assistance requests. Across 600 subtasks, component requirement prediction achieved 97.0% accuracy among the 594 trials with correct target recognition, and the full workflow completed 550 subtasks (91.7%). Separate recognition, prediction, robotic execution and operator assembly statistics distinguish model prediction performance from overall task completion.