Classifying Component Function in Product Assemblies With Graph Neural Networks

Function-based design is a foundational tenet in product design [1]. Function is defined as the application of the product purpose toward solving a design problem [2,3]. Components within the product complete sub-functions necessary to materialize the overarching product function. In product design, functional modeling is used to support and guide designers during early conceptual design phases [4,5]. Here, a designer determines the sub-functions needed to complete the primary product function and purpose [1]. These sub-functions are connected through flows that capture their interactions. In practice, these flows represent material, energy, and signal transfer [6].

Currently, function-based design suffers from subjectivity caused by the designer’s interpretation of function and flow as it applies to a design. Efforts have been made to standardize function and flow into taxonomies to limit subjectivity, while increasing shared domain understanding [6]. The standardization of function-based design principles has led to meaningful curation of taxonomy-based design repositories [7–9]. While these design repositories have been widely accepted into literature, there remain challenges in function interpretation defined by designer expertise in function-based design. The human interpretation and assignment of function have generated repositories that are often unorganized, sparse, and unbalanced.

Low data quality and scarcity of design repositories have led to an under-utilization of deep learning methods in the data-driven product design field [10,11], as they require large amounts of data [12,13]. Prior work addressed the issue of scarce structured design knowledge datasets by automatically extracting function knowledge from a corpus of mechanical engineering text to construct a design knowledge base [14]. For modalities of data other than text, researchers relied on synthetic design data [15], small amounts of curated knowledge [16], or scraped public online design repositories and manually labeled design knowledge [17,18]. Yet, it remains challenging to apply data-driven methods in the field of mechanical design [19,20]. However, recent progress in graph representation learning and graph neural networks (GNNs), show promise in knowledge discovery in sparse datasets [21,22]. Rapid advancements in deep learning for sparse datasets present an opportunity to apply such methods on design repository data to forward the state-of-the-art in data-driven design, specifically in the context of function-based design shared understanding, standardization, and computer representation.

In this paper, we use GNNs and sparse data from a design repository to classify component function based on assembly and flow relationships. We represent data from a hierarchical taxonomy-based design repository through graphs. The focus of these graphs is to capture function-flow-assembly relationships within products housed in the design repository. We then introduce a hierarchical GNN framework that capitalizes on the three-tier hierarchical nature of the repository data. Using the hierarchical GNN, we classify component function in three tiers ranging from broad primary functions to detailed tertiary functions as introduced in previous literature [6]. We exhaustively evaluate our GNN framework using four types of GNN layers and compare its results against other feed-forward networks to determine the fidelity of our proposed GNN architecture. We also compare our hierarchical GNN architecture against independently trained GNNs for each component function tier. The performance of our GNN framework is presented and subsequently explored through confusion matrices and feature importance analysis.

The research presented here contributes to the area of function-based data-driven product design by leveraging recent developments in graph representation learning to enable a more descriptive shared understanding between humans and computers about the function of parts in an assembly. Our interest in function classification stems from recent work that applies data-driven approaches to various engineering design tasks [10], such as searching a design space [23], model-based systems engineering [24], or selecting appropriate manufacturing methods [17]. Such work points toward intelligent design agents enabled by knowledge-based design systems, which have been explored by the design research community over many years [10,25].

In the context of our work, functional modeling supports the use of automated reasoning systems, as well as facilitating communication and understanding between designers and co-creative agents, both of which could benefit from a better-shared understanding of the problem when working on a creative task [15,26,27]. We see function as an important theoretical element to allow an intelligent design agent to better understand the designer’s intent when co-creating with the designer. Predicting low-level functions of a design is an initial step toward this vision. The work we present here contributes the following:

1. A novel approach to automatically predict the function of a part in an assembly using graph neural networks.

2. A publicly available relational assembly graph model to represent design repository data.

3. Experimental results of part function classification from a graph representation of the assembly.

In this body of work, we use the Oregon State Design Repository (OSDR) as our structured taxonomy-based data source [28,29]. We provide a publicly available subset of the OSDR dataset used in our work, the assembly graphs representing the OSDR data, and the GNN implementation for the research community to leverage in future work.¹ Furthermore, graph representation of the OSDR can be leveraged in data searching tasks and other GNN tasks beyond function classification. GNN and OSDR graph representations can be used to ascertain design knowledge on material choice, assembly order, amfailure modes, Design for the Human Element, Design for the Environment, and component-system classification tasks.

In this section, we introduce fundamental concepts and research supporting the extraction of functional knowledge using GNNs. Here, we introduce literature in function-based product design in the context of design support and deep learning. Next, design repositories are discussed as a source of semantic product data that can be used in modern deep learning techniques. Finally, literature and background are established for graph representation and GNNs.

Function-based design has been used as a bridge to bring Design-for-X (DfX) objectives, such as Design for the Environment, from post-design analysis to the earlier design phases of product development. To this end, function-based design has been used with life-cycle assessment data to provide function-based sustainable design knowledge to designers [30–32]. In human-centered product design, function has been related to human error and interaction points to determine which functions need special consideration for ergonomics [33,34]. These recent developments in function-based design for meeting DfX objectives suggest a need to predict, learn from, and model function in components as a means to bring further curated data to early design phases.

Previous efforts have been made to use machine learning for improving function-based design methodologies. In other research, association rules and weighted confidence has been used to determine the function of a component within product configurations [35–37]. Decision trees have proved useful in reducing the feasible design space of functional assignment when considering product assembly [38]. Furthermore, deep learning approaches have been used to disambiguate customer reviews based on function, form, and behavior [39].

Taxonomy-based design repositories store product design data relevant to design engineers [28,40]. This type of design repository is generated through expert taxonomy descriptions of classical product life cycle inventory (LCI) data. For example, given common product data such as a bill of materials, specialized taxonomy data can be appended to LCI data. The OSDR is a taxonomy-based repository that houses product LCI data along with assigned specialized taxonomy descriptions [7,29]. In the OSDR case, specialized taxonomy data includes product assembly child-parent notation, functional-flow basis assignment to components, and a standardized component naming schema.

Adoption of design repositories in research and industry has been slow due to resource commitment, human curation, intuition-based knowledge extraction, and lack of well-structured product data. Efforts have been made to improve design repository generation by limiting subjectivity through taxonomy standardization [6,41–44]. Furthermore, recent approaches have been introduced to streamline data addition to design repositories [45]. Despite the described challenges, design repositories have been shown to be useful in data-driven design approaches, particularly in machine learning and knowledge extraction tasks.

Design repositories are useful in knowledge discovery tasks and have been effectively employed within machine learning approaches [46–49]. Specifically related to function-based design, design repositories were used in the automated extraction of function knowledge from text [14]. In our work, we assert that recent advancements in graph representation learning have allowed for the ability to generate predictive models from sparse, incomplete, subjective, and otherwise unbalanced repository data.

Graphs are robust data structures that represent interactions (i.e., edges) among constituents (i.e., nodes) of a system. They can also capture the direction of interactions, properties of interactions (i.e., edge attributes), and properties of the system constituents (i.e., node attributes). In product design, knowledge graphs [50,51] which are a specific type of graph that represent structural relations between entities of a domain, are widely used. Classically they are most often used in natural language processing tasks [52–54]. Current efforts in knowledge graphs have facilitated robust graph representation of domain-specific semantic relationships of product design [55]. TechNet was developed in 2019 by mining semantic relationships of elemental concepts found in US patent data. B-link was introduced in 2017 by mining engineering domain knowledge from engineering-focused academic literature [56]. Knowledge graphs have supported product design by providing language and design relationships. Specifically, engineering design knowledge graphs have been used in concept generation and evaluation [57]. However, there is a need to expand on knowledge graphs with standardized product design resources, such as design repositories.

Recently, a knowledge graph framework has been introduced to create rich node and edge features based upon taxonomy-based product design models [58]. Here, graphs generated with product design taxonomies capture meaningful relationships between product materials, manufacturing method, tolerance, function, and other product features. Specifically, product design knowledge graphs have been useful for case-based reasoning and concept similarity search. In this work, we expand on taxonomy-based graphs with the representation of repository data in a graph structure, with a focus on function, flow, and assembly representations. The generated graphs are then used in prediction tasks using GNNs.

Standard deep learning architectures such as convolutional neural networks (CNN) and recurrent neural networks (RNN) operate on regular-structured inputs such as grids (e.g., images, volumetric data) and sequences (e.g., signals, text). Nevertheless, many real-world applications deal with irregular data structures. For instance, molecular structures, interaction among sub-atomic particles, or robotic configurations cannot be reduced to a sequence or grid representation. Such data can be represented as graphs, which allow for jointly modeling constituents of a system, their properties, and interactions among them. GNNs [59–65] can directly take in data structured as graphs and use the graph connectivity as well as node and edge features to learn a representation vector for every node in the graph. Because GNNs utilize the strong inductive bias of connectivity information, they are more data-efficient compared to other deep architectures. GNNs have been successfully applied to point clouds and meshes [66,67], robot designs [68], physical simulations [69,70], particle physics [71], material design [72], power estimation [73], and molecule classification [65].

Different instantiations of $fθ(.)$ and $gϕ(.)$ functions result in different variants of GNNs. In this paper, we compare the performance of four well-known variants of GNNs including GraphSAGE [61], graph convolution network (GCN) [62], graph attention network (GAT) [63], and graph isomorphism network (GIN) [64]. For an overview of GNNs, see Refs. [21,22].

In this section, we describe the methodology for function classification using a GNN on repository data that is represented by graphs. First, the data selection and processing is presented. Then, we describe graph schema and graph construction. Finally, a GNN and related parameters are introduced to predict the hierarchical functions.

The OSDR is a function-based relational framework built upon consumer product component (artifact) information [9,28,29]. The repository schema includes system-level bill of materials, system type, component function and flow, material, and assembly relationships. The data within the OSDR utilizes published standard taxonomies for component, function, and flow naming. These standard taxonomies are referred to as basis terms [6,43]. The basis taxonomies feature a hierarchy system that allows for broad-to-specific identification of component name, function, and flow per component artifact in the OSDR. In the taxonomy hierarchy systems within the OSDR, tier 1 basis terms encompass the broadest description of the basis term. In ascending order, tier 2 and 3 increase specificity, information, and accuracy of the basis definition. An example of the basis term hierarchy from each taxonomy is shown in Table 1. This example is not representative of any product within the OSDR and only demonstrates the hierarchical structure of taxonomy basis terms.

The OSDR encapsulates the data of 184 consumer products and 7275 related artifacts. Artifacts are generally components but can also represent sub-assemblies and systems. Artifacts are related through parent-child a familial hierarchy (hypernym and hyponym relations). Functional relationship and product-level functional models are captured through component-level function, input flow, and output flow. In this regard, the OSDR houses 19,627 component-related function data points with 19,667 corresponding flow data points.

For our methodology, the data from the OSDR needed to be filtered and processed prior to developing the product graphs. We removed 24 consumer products from the dataset due to a lack of completion in function, flow, or assembly definition. From the 160 products, data points are represented by a single component defined by material, component basis, parent component, functional basis hierarchy, input flow, output flow, input component, and output component. Each data point is a unique representation of the components defined by flow attributes. Concisely, there are many data points per component depending on the number of functions and related flows managed by that component. The processing and filtering of the data within the OSDR resulted in 15,636 data points represented by 137 component basis terms, 51 function basis terms, 36 flow basis terms, and 16 material categories. An example vegetable peeler product with component, function, and flow data is shown in Table 6 found in Appendix  A.

The processed OSDR data is represented through relational graphs. Relational graphs are a specific type of graphs with the following properties: (1) they are directed graphs, meaning edges between nodes have directions, (2) they are also attributed, meaning that the graphs contain node and edge attributes, and (3) they are multi-graphs, as more than one edge is allowed between any two nodes. Graph representation of the OSDR is needed to apply our proposed GNN architecture outlined in Sec. 3.3. In the context of the OSDR, the relational graphs are generated per system to represent the assembly and flow relations within the system. These assembly-flow graphs are defined by nodes and connecting edges. Figure 1 shows the graph structure. The graphs are generated using predefined schema definitions from the OSDR. These definitions can be found in related literature and explored through the hosted version of the OSDR [75].²

The nodes are representative of each artifact data point and carry the following features: system name, system type, component basis term, material, and functional basis hierarchy. The nodes are connected through two edge types denoted as flow edges and assembly edges.

A flow edge is defined as the connections between functions within the system and the movement of energy, signals, and materials through a system in which a function or set of functions modifies. A function has an input flow and an output flow. Flow edges are directional and defined by the data specified flow basis representation regardless of flow basis hierarchy. In this regard, we are not backing out higher-tier flow labels. Flow edges are defined by only the assigning flow basis term found within the data. Flow edges are only represented once per input-output relationship. Assembly edges are non-directional physical connections between artifacts in the classical product assembly sense. Both assembly and flow edges are used to capture the totality of physical-functional interaction between artifacts. By representing both physical connections (assembly) and function connections (flow) through edge definitions, we aim to classify component function using late-stage design defined physical product assembly and early design stage defined function-flow definition. Considering the totality of the product design process increases the breadth of contribution of this work.

We generated 160 assembly graphs representative of the 160 non-filtered products from the OSDR. NetworkX [76], a python library for graph processing, is used to materialize the relational graphs [77]. Per graph, there is an average of 98 nodes and 791 edges. When singling out flow edge type, there is an average of 537 flow edges per graph. For assembly edges, there is an average of 262 edges per node.

We pre-process the data as follows. For initial node attributes, we concatenate one-hot encoding of component basis, system name, system type, and material features resulting in a 316-dimensional multi-hot initial node feature. For edge attributes, we concatenate one-hot encoding of input flow, output flow, and an indicator of whether the edge represents an assembly connection. This results in a 75-dimensional initial edge feature. The dataset contains 9, 22, and 23 category labels for tiers 1, 2, and 3 functions, respectively. It is also noteworthy that label distribution in all three tiers is highly skewed. The label frequencies are shown in Fig. 3.

Inspired by recent advances in graph representation learning, our approach learns dedicated node representations for each functional tier prediction task. As shown in Fig. 2, our method consists of three GNN encoders that take in graphs connectivity information along with initial node and edge features and produce dedicated node embeddings for each tier. Each GNN is then followed by a dedicated multilayer perceptron (MLP) that acts as a specialized classifier for that tier. Furthermore, we utilize the hierarchical nature of function tiers to augment the predictions and use hierarchically structured local classifiers with a local classifier per tier.

Assume a training set $D=[G1,G2,…,GN]$ of N graphs where each graph is represented as G = (A, X, E) where $A∈{0,1}n×n$ denotes the adjacency matrix (one-hop connectivity information), $X∈Rn×dx$ is the initial node features, and $E∈Rn×n×de$ is the initial edge features. We define three GNNs $gθk(.):Rn×n×Rn×dx×Rn×n×de⟼Rn×dh,k={1,2,3}$ parametrized by ${θk}k=13$ corresponding to tiers 1 to 3 functions, respectively. This results in three sets of dedicated node embeddings $Ht1,Ht2,Ht3∈Rn×dh$⁠. GNNs are essentially learning to extract strong representations for down-stream classifiers. We use three MLPs $fψk(.):Rn×(dh+|Yk−1|)⟼Rn×|Yk|,k={1,2,3}$ parameterized by ${ψk}k=13$ where kth MLP is the dedicated classifier for predicting tier k function classes. The kth MLP receives the learned node representations from its dedicated GNN $gθk(.)$ (i.e., $Htk$⁠) and predictions of the predecessor MLP in hierarchy $fψk−1(.)$ to predict the function classes for kth tier. Because the first MLP does not have any predecessors (i.e., first tier in hierarchy), we simply pass a vector of zeros to emulate the input predictions.

During the training phase, we utilize teacher forcing [78] to enhance the training process. Teacher forcing is a procedure in which during training, the model receives the ground truth output (rather than predicted output) as input at the next step. In other words, rather than feeding the kth MLP with the actual predictions of (k − 1)th MLP, we feed it with ground truth labels of (k − 1)th tier labels. During inference, however, we do not have access to the ground truth labels. Therefore, we feed the subsequent MLP with the probability distribution of the predicted labels. We use Softmax function over the MLP predictions to transfer the raw predictions into proper probability distributions. Furthermore, we use frequency-based weighting to address the data imbalance during training. We compute the loss such that less frequent classes contribute more to the total loss compared to frequent classes. This practice prevents the model from paying more attention to frequent classes and ignoring the rare ones. We jointly optimize the model parameters with respect to the aggregated and weighted cross-entropy losses of all three functional tier predictions using mini-batch stochastic gradient descent. The process of training for one mini-batch is shown in Algorithm 1.

In this section, we introduce the GNN architecture implementation and results. We explore results further with confusion matrices to determine function-specific performance. We then validate the results of the SAGE graph neural network algorithm against three other state-of-the-art GNNs. The GNN types are GCN, GAT, and GIN [62–64]. In closing, we highlight feature importance to determine the most consequential taxonomy-based data features toward classifying component function and look to investigate how our proposed hierarchical GNN architecture compares to a group of independent GNNs.

We initialize the network parameters using Xavier initialization [79] and train the model using Adam optimizer [80] with an initial learning rate of 1e-3. We use a cosine scheduler [81] to schedule the learning rate and also use early-stopping with a patience of 50. We also apply Leakey rectified linear unit (ReLU) non-linearity [82] with negative slope of 0.2, and dropout [83] with probability of 0.1 after each GNN layer. We choose the number of GNN layers and hidden dimension size from the range of [1, 2, 3] and [64, 128, 256], respectively. Finally, we choose the GNN layer type from GraphSAGE [61], GCN [62], GAT [63], and GIN [64] layers. We implemented the experiments using PyTorch [84] and used Pytorch Geometric [85] to implement the GNNs. The experiments are run on a single RTX 6000 GPU where on average, one epoch of training takes about 1 s and 1.5 GBs of GPU memory.

To investigate the performance of the GNNs on the dataset and compare it with other feed-forward networks, we trained an MLP, a logistic regression (linear) model, and four types of GNNs including GraphSAGE [61], GCN [62], GAT [63], and GIN [64]. To train the GNNs, we used the connectivity information along with initial node and edge features, whereas for the MLP and linear models, we only used initial features. The results are shown in Table 2. We observe a classification weighted precision of 0.617, 0.466, 0.401 for tier 1, tier 2, tier 3 functions, respectively. When strongly considering the data imbalance (micro-average), we observe a precision of 0.595, 0.445, 0.363 for tier 1, tier 2, tier 3 functions, respectively. If we ignore data imbalance (macro-average), there is a precision of 0.544, 0.349, 0.235 for tier 1, tier 2, tier 3 functions, respectively. Moreover, results suggest that: (1) GNNs outperform MLP and Linear models in all tiers across all metrics. For example, the best performing GNN in tier 1 function prediction outperforms the MLP model with an absolute F₁-score of 0.119, a relative improvement of 25%. This implies that connectivity information plays an important role in the predictions. (2) Among GNNs, a GNN with GraphSAGE layers slightly performs better in tier 1 function predictions, whereas for tier 2 and 3 predictions, GNNs with GIN layers perform better. This shows the importance of treating the GNN layers as hyper-parameters that can yield better performance.

We also investigate the performance of models on individual labels using confusion matrices. Figure 4 shows the confusion matrix for each function tier. These matrices show the accuracy of a function being correctly classified and, when incorrectly classified, which functions are selected instead of the true function. The color axis determines the occurrence ratio of the function classification. Ideally, high classification occurrence should be observed in matching indices (i.e., denser diagonal), indicating correct classification. As an example, we can observe that the model sometimes confuses the “divide” class with the “remove” class in tier 3 function predictions.

To investigate the contribution of the node and edge features to algorithm performance, we systemically drop features and observe the changes in F₁-scores. Specifically, in this analysis, we drop single-node features, look at eliminating edge types, and lastly, remove all features from nodes and edges. By eliminating edge types and features, we look to discover if assembly edges and flow edges are more important toward prediction accuracy. In the edge importance analysis, we also look at retaining all edges without any features. We then eliminate all node and edge features to determine if graph topology impacts function predictions. Table 3 shows the feature importance analysis per function tier. The results suggest that component basis has the highest impact on the performance among node features, whereas flow is the most influential edge feature. We also observe that initial node/edge features contribute more to the performance compared to topological information.

We investigate the contribution of introducing hierarchy on performance by comparing our hierarchical GNN framework with independently trained GNNs (i.e., no input from previous predictions). The results in Table 4 suggest that introducing hierarchical training significantly improves the performance on tier 3, in which we observe an absolute 0.068 increase in micro F₁-score a relative improvement of 23%. We also see a marginal enhancement in tier 2 predictions. Because tier 1 GNNs do not have any predecessors in the hierarchy, they produce almost identical results in both cases.

The OSDR is a multi-decade-long project that has been manually influenced by many organizations and design engineers. Knowing this, we reiterate that the data from the repository is unbalanced, sparse, and often non-congruent. We observe noted cascading label imbalance and absence from higher-order hierarchy taxonomy to lower-order taxonomy terms. Tier 3 classifications in function, flow, and component basis terms per component are often missing assignment. In short, the OSDR shows a user-curated bias toward defining higher-order basis terms in both function and flow, as shown in Figs. 3 and 5. Although the data is incomplete and imbalanced, we maintain that the compilation of the OSDR is representative of knowledge from many design engineers with varying expertise. As such, the OSDR can be thought of as a sampling of function-based domain knowledge ranging from novice to expert design engineers.

In using a hierarchical GNN model, we inherit the assumptions that were used to create and facilitate the propagation of such taxonomies. Function, flow, and component taxonomies are directional, but parent-child assembly relationships are not. As such, in our graph representations, flow edges are directional, whereas assembly edges are not. The GNN model takes into account direction information and models non-directional assembly edges as bi-directional. We recognize that the OSDR taxonomy approach is one of many adopted function, flow, and component standardizations. These taxonomies are applied to a wide breadth of consumer products. We choose to adopt the OSDR taxonomies as a starting point, but we realize that this definition of function might be generalizable to all design problems and domains.

As shown in Sec. 4.2, we observe that the overall performance of the GNN with GraphSAGE layers is marginal but strongest in tier 1 function prediction. Tier 2 and 3 function predictions are competitive against other GNN types, only coming third to GNN with GIN (tier 2) and second to GNN with GIN (tier 3) layers. These results are reasonable given the unbalanced and very sparse product design data. With a repository of just 160 products spanning various industries (automotive, consumer goods, furniture), it is encouraging that the proposed GNN architecture was able to ascertain part-level functional classification with a micro-average F₁-score of 0.595, 0.445, and 0.363, respectively.

Where the model fails can be identified through the relative performance between function classes. The confusion matrices shown in Fig. 4 could serve as a valuable tool for a practitioner wanting to adopt our method, as they explicitly show the relative performance of all classes of function we can predict. The confusion matrices also suggest cascading false negatives and false positives as our model moves from tier 1 through tier 3 function predictions. We theorize this is caused by the significant scarcity of tier 3 function data, as shown in Fig. 3. Moreover, tier 2 and 3 suffer from more significant data imbalance in comparison to tier 1. In context, the concatenation of a high number of classification labels and data imbalance found in tier 2 and 3 functions resulted in some meaningful false negatives and false positives during testing.

Why the model fails could be attributed to subjectivity in the function definitions and to data imbalance caused by the overall OSDR embedded bias toward defining tier 1 functions and solid flows. In the tier 3 predictions shown in Fig. 4, we observe that the model often confuses function labels that are related. For example, “decrement” is often confused with “extract”. In the same regard, “transmit” is often confused with “collect,” “display,” “link,” and “remove.” The model appears to somewhat ascertain the contextual function correctly but has trouble discerning the details that individualize some tier 3 functions. In this example, the GNN model finds that these unlabeled components generally are “moving” flow. However, the model can not classify if the component is “extracting,” “decrementing,” or “removing” a material flow or “transmitting” a signal or energy flow. These findings can be indicative of fuzzy human assignment of functions that are similar and subjective. Confusion in low-frequency function classes can be also be attributed to conflicting knowledge caused by sparse edges, especially considering confusion between material flows and the other flows.

Moreover, the results in Tables 2 and 3 show that macro scores are usually lower than micro scores, indicating that the least populated classes are poorly classified relative to the more populated classes. Based on this, further application of this work should collect additional data for the least populated classes. Researchers looking to apply these methods would benefit by augmenting the current dataset to address data imbalance and scarcity guided by Fig. 3, while also modifying the dictionary of functions to suit their task.

Looking at Table 3, we anticipated that function would be product family-specific and would cause model confusion between industry domains. This is evident as isolating system type lead to a lower micro-average F₁-score compared to having no features. Table 3 shows an adversarial effect between flow edges and assembly edges. When only considering flow edges, the GNN model performed better than with both edge types. Conversely, when just considering assembly edges, performance sharply declines. Upon discovering this effect, we theorized that energy and signal flows are not always correlated with physical assembly or “closeness” of components that are inputting or outputting these types of flows. While there is a significant overlap between the two edge types, the slight differences in flow and assembly edges are enough to cause the adversarial effect. As noted in Fig. 5 in Appendix  B, a majority of our flow edges are labeled “solid.” This finding is advantageous in future work considering geometric and CAD embeddings. Whereas it might be challenging to capture energy and signal flows in CAD data, it might be more promising to capture solid flows. As such, solid flows are likely the most analogous bridge between assembly and function.

Upon identifying the effects of GNN selection and feature importance, we ran an experiment to hyper-parameterize our GNN architecture to select the best GNN and set of features per hierarchy tier. Table 5 shows the best results of 0.617, 0.624, 0.415 per-tier micro-average F₁-score. The hyper-parameterization of the GNN architect demonstrates a marked improvement in tier 2 and 3 predictions over the original GraphSAGE-based GNN architecture. However, understanding that the repository data set is a curation of human knowledge of functional assignment, we looked at the effect of fuzzy human assignment of function. To evaluate the effect of human assignment in the data, we looked at the top-k predictions by the GNN, as this would be more analogous to how the method would be applied in a use case. By selecting the correct result from the top-3 and top-5 predictions, as shown in Table 5, we achieve an F₁-score of 0.932, 0.948, 0.825 per-tier micro-average for top-3 and F₁-score 0.974, 0.975, 0.955 micro-average per-tier for top-5 predictions. These results are a significant improvement over the results, which only consider top-1 predictions. Future work could benefit from implementing a temperature-based probability sampling approach from the top-3 predictions to further improve the quality of the method. In addition, future work should look at establishing a comparison between the method described in this work and a human baseline, as this would also provide insights into the biases of the current dataset and ambiguities around function definition. Future work could improve performance by collecting more data, and including more complex products, possibly from different industries.

In this work, we use graph neural networks to classify the function of parts in an assembly given design knowledge about the part, such as the semantic name, the material, the assembly connections, and the energy flowing into and out of the part. Here, we extract data from 160 products in the OSDR and represent it within 160 graphs and a total of 15,636 nodes, with each node containing design knowledge about the part in a multi-dimensional feature vector. With this data, we are able to train a GNN to predict the top-1 function of a part with a micro-precision of 0.617 for tier 1 (broad), 0.624 for tier 2, and 0.415 for tier 3 (specific) functions. When considering top-3 functions, the GNN architecture predicts function with a micro-precision of 0.932 for tier 1 (broad), 0.948 for tier 2, and 0.825 for tier 3 (specific) functions. Our results suggest that the hierarchical structure of products and relevant design knowledge describing sub-components can be learned effectively with graph neural networks. The quality of these results show promise in supporting the development of a larger function dataset from a more extensive set of products. Our method could be further developed by learning from the geometric data of the part, a prominent design feature missing from the current work in place of the semantic name of the part.

There are several research directions to expand on this work. By inferring the function of a design at any point in the design process, an intelligent design agent could better support the designer throughout various tasks, such as the design of complex systems like industrial machinery. The quality required from the predictive system will be dictated by the task being performed. For some use cases, high-quality top-3 predictions could be sufficient to give enough context to the design agent to support the designer. For example, function data could support the designer during the conceptual design stage in assessing the feasibility of a design [24], searching for functionally similar parts [20], or by enabling automated functional modeling [36,37,86]. In the detail design stages, it could aid in verifying the satisfaction of higher-level design requirements [26]. Furthermore, this work could further the development of function-based sustainability methods and other function-related environmental considerations during the early design phases [30,31,87]. A human-centric case study should be conducted to establish a baseline against which the method presented in this work can be evaluated.

In future work, we look to enable knowledge-based CAD systems through automated function inference by bridging a gap in understanding between the designer and an intelligent design agent. We envision design tools extending beyond documentation, simulation, and optimization towards intelligent reasoning tasks that help designers make informed design decisions.

This material is based upon work supported by the National Science Foundation under Grant No. CMMI-1826469. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.

There are no conflicts of interest.

• 30.82% of edges are assembly and 69.18% are flows.

• Three out of 160 graphs are DAG.

For GNNs, we represent the edge features as follows. We represent the in-flow and out-flow features as one-hot representations and the assembly link as a single indicator. Thus, if there are N unique flows in the dataset, the initial edge features are represented as a 2N + 1 vector. We concatenate the one-hot representations of the node features to create the initial node feature. For the linear and MLP baselines, we first project the initial node and features to embeddings of the same size using two dedicated linear layers. We then represent each node by summing up its embedding with the summation of the dot product of all the neighbor node-edge pairs. We then pass the computed embeddings to MLP or linear models. As mentioned, we choose the number of GNN layers and hidden dimension size from the range of [1, 2, 3] and [64, 128, 256], respectively. The best performing hyper-parameters are reported in Table 8.