HRCD for EOL-LIBs

The power battery system comprises the Battery Management System (BMS), essential power electronic devices, and modules composed of battery cells. Both the battery module and the battery system are equipped with cooling systems. The assembly structure of the battery cells and modules is complex and typically involved securing methods such as welding and adhesive bonding. Due to variations in the manufacturing and service processes of new energy vehicles, there exists a multitude of brands, models, and variations in retired states. Consequently, the disassembly process becomes complex, requiring high flexibility. The flexibility of the disassembly system lies in its capacity to handle diverse types and conditions of disassembly. However, existing disassembly systems, whether manual or robotic, lack the necessary flexibility and efficiency to meet the diverse disassembly requirements encountered across various types and conditions.

HRC involves leveraging the strengths of both humans and robots to achieve efficient and assembly or disassembly processes. HRC-DSP refers to the systematic allocation of disposed components within specific constraints, aiming to determine the optimal sequence for efficient and safe disassembly of target parts. This research significantly enhances the efficiency and safety of disassembly parts, thereby reducing disassembly costs and minimizing environmental impacts. In this collaborative mode, robots are capable of performing mechanized tasks, such as utilizing lasers or robotic arms to separate and cut objects, while humans assist in more intricate and hazardous operations, such as fine disassembly or inspection of electronic components. By combining the precision and speed advantages of robots with the human capacity for complex tasks, this collaboration ensures the safety and quality of the disassembly process, offering a novel technical approach to sustainable waste recycling and utilization.

To achieve the generation of HRCD sequences, several steps need to be completed in succession, including task allocation, sequence planning, and sequence recommendation. For task allocation, Heydaryan et al. (Reference Heydaryan, Suaza Bedolla and Belingardi2018) used hierarchical task analysis (HTA) to assign operation tasks to both humans and robots. Compared to manual assembly, this approach increased the overall assembly time but demonstrated improvements in ergonomics and safety. Xu et al. (Reference Xu, Tang, Liu, Liu, Zhou and Pham2020) proposed task allocation and sequence planning approach for HRCD in remanufacturing processes; however, it did not account for the uncertainty of human disassembly behaviors. Ranz et al. (Reference Ranz, Hummel and Sihn2017) introduced a task allocation method based on the actual capabilities of robots and humans. Task requirements were used as decision criteria, and the final task allocation was determined through evaluation metrics. Champatiray et al. (Reference Champatiray, Bahubalendruni, Mahapatra and Mishra2023) propose a novel concept that generates practically feasible assembly sequence plans by considering the geometry of both parts and tools, effectively deals with real-life industrial problems. For EOL-LIBs DSP. Zhang et al. (Reference Zhang, Yang, Wang, Wang, Zhang and Chen2022) proposed a neuro-symbolic method for planning the disassembly sequence of automotive batteries, focusing on bolt disassembly as an example. However, they faced challenges in achieving planning for the entire sequence when dealing with complex sequence planning scenarios. Tan et al. (Reference Tan, Chin, Garg and Gao2021) presented a hybrid disassembly framework that facilitated HRC by considering design, safety, and cost elements. This framework simplified the disassembly planning process compared to traditional manual disassembly. However, it had limitations due to the confidentiality of battery models as its applicability was restricted to similar types, such as the Audi Q5, making it challenging to achieve reusability. Furthermore, achieving multi-objective optimization of HRCD sequences for power LIB involves establishing evaluation indicators such as cost-effectiveness and safety. Wu et al. (Reference Wu, Zhang, Yin and Zhang2022) optimized the specific disassembly process of power batteries using a human–robot hybrid mode and the NSGA-II algorithm to address four objectives: workstation quantity, workstation idle time, worker quantity, and disassembly cost. The reliability and effectiveness of the approach were verified through the case study involving the Tesla Model S battery module. However, the results were only applicable to single disassembly lines and products, limiting automation and reusability for small batch sizes. Kong et al. (Reference Kong, Zhang and Liu2022) proposed a parallel task allocation method to solve the multi-objective optimization problem of power battery system (PBS) disassembly sequences using a heuristic algorithm. However, the method was currently limited to optimizing two objectives simultaneously. Alfaro-Algaba and Ramirez (Reference Alfaro-Algaba and Ramirez2020) developed a model for optimizing disassembly sequences based on economic benefits and disassembly environment. They verified the reliability and effectiveness of the model using the power battery of an Audi A3 as an example. However, this model requires a relatively complete disassembly sequence to be established before improvements could be made. Ke et al. (Reference Ke, Zhang, Zhang and Song2020) proposed a framework that combines subgroup structure and genetic algorithm to optimize disassembly sequences. The framework used an improved disassembly relationship mixed graph and disassembly relationship matrix to describe the disassembly priority and connection between components. However, the framework’s effectiveness was limited by the structure of PBS and might not yield significant results if the PBS structure was incomplete.

After task allocation and sequence planning, it is essential to have sequence recommendation to guide the robot in the correct order of disassembly. Beck et al. (Reference Beck, Neb and Barbu2021) developed a tool called Octopuz, which can generate robot programs based on CAD assembly models and disassembly information, facilitating the automation of disassembly. However, the current version of the tool only supports basic steps such as “pick and place” and “unscrewing.” Maharshi (Reference Maharshi2019) proposed a cloud-based framework for environmentally friendly and cost-effective automated disassembly for multiple battery models. However, this framework requires a comprehensive automated disassembly process, and currently, it can only achieve bolt disassembly of PBS shells. Additionally, Garg et al. (Reference Garg, Zhou, Zheng and Gao2020) proposed a qualitative framework based on intelligent robots. They employed a six-degree-of-freedom UR5 industrial robot and various end effectors with various functionalities to achieve automated disassembly. Nonetheless, their program is specifically tailored to one type of battery and fixed battery states, rendering it unsuitable for large-scale utilization and reuse.

In summary, despite some advancements in HRC-DSP research for EOL-LIBs, it falls short of meeting the requirements for practical collaborative disassembly processes. Existing challenges encompass the following:

1. 1) Limited expression of disassembly knowledge for EOL-LIBs, often reliant on manual rule-making by experts and decision trees to construct knowledge bases. This approach demands substantial effort and time, making it challenging to adapt to new models.

2. 2) Inadequate reusability of disassembly knowledge for EOL-LIBs. Current research primarily focuses on the disassembly-specific model of lithium battery models, lacking reusability for disassembly sequences of different models.

Therefore, a more intelligent knowledge representation method is needed, leveraging technologies such as data mining and machine learning to automatically develop knowledge bases from various sources of disassembly information. Additionally, integrating intelligent algorithms for optimization and decision-making is crucial.

KG generation

The current research primarily focuses on manual disassembly processes, where the initial step in DSP involves modeling the disassembly information. This process entails transforming priority constraints and connection relationships between components into a mathematical model suitable for computer processing. This modeling ensures the feasibility of the disassembly sequence. The key to successful disassembly information modeling lies in expressing the constraints of product structure in a concise, accurate, and comprehensive manner.

One effective approach for representing and organizing heterogeneous information from different data sources is through a KG. KG is a structured semantic knowledge base that comprises entity-relationship-entity and entity-property-value triplets. It provides a robust means of describing and managing knowledge, effectively integrating information from the data layer and schema layer. In the context of product disassembly, the disassembly process information includes the geometric information of components and the environmental information related to the disassembly process. The essence of disassembly process information modeling lies in the integration and management of data from multiple sources. Currently, there are several methods available for assembly or disassembly information modeling, including object-oriented, XML-based, ontology-based modeling, and KG-based approaches. Table 1 provides a summary of representative literature for each method, outlining their respective advantages and disadvantages.

Table 1. Advantages and disadvantages of various assembly/disassembly process information models

Furthermore, KGs possess the capability of knowledge reasoning. By employing pertinent rules and constraints, KGs can achieve knowledge completion and predict missing links within the graph. KG embedding, referred to as knowledge representation learning, primarily concentrates on capturing the entities and relationships in the KG. By learning the representation of the KG, the semantic connections between entities and relationships can be effectively computed, thereby enhancing the computational efficiency of knowledge reasoning. Prominent models for KG embedding encompass translation-based models (Bordes et al., Reference Bordes, Usunier, Garcia-Duran, Weston and Yakhnenko2013), semantic matching models (Nickel et al., Reference Nickel, Tresp and Kriegel2011), and neural network models such as ConvE (Dettmers et al., Reference Dettmers, Minervini, Stenetorp and Riedel2018), GNN (Li et al., Reference Li, Gu, Dullien, Vinyals and Kohli2019), and R-GCN (Schlichtkrull et al., Reference Schlichtkrull, Kipf, Bloem, Van Den Berg, Titov and Welling2018). KG reasoning based on neural networks fully utilizes the modeling capabilities of neural networks to capture non-linear and complex relationships, facilitating comprehensive learning of the graph’s structural and semantic features. This enables effective prediction of missing relationships and entity completion within the graph. Wen et al. (Reference Wen, Gu and Cheng2020) proposed a model called Dual Semantic Relationship Attention Network (DSRAN), which enhances the relationships between regions and global concepts to provide more accurate visual representations for image-text matching. Jiang et al. (Reference Jiang, Rahmani, Angelov, Black and Williams2022) proposed a method called graph context attention network (GCAN), which combines intrinsic graph structure and cross-graph information to enhance the discriminative ability of node features. The proposed GCAN model can effectively solve graph-level matching problems and automatically learn node similarity through graph-level matching.

In summary, this research aims to effectively utilize disassembly process information, enhance the efficiency of HRCD, and facilitate the reuse of disassembly knowledge. To achieve these goals, this research adopts KG reasoning based on neural networks fully utilizes the modeling capabilities of neural networks to capture non-linear and complex relationships, facilitating comprehensive learning of the graph’s structural and semantic features.

Disassembly information modeling

Integrating and reusing disassembly process knowledge can offer valuable support for planning disassembly sequences. By constructing the pattern layer of the DPKG and integrating part information from the CAD model with process information, the efficiency of interaction between disassembly information can be significantly improved. The pattern layer of DPKG is developed for product information acquisition and classify.

Following an analysis of the disassembly information presented in the disassembly operating procedure and CAD models, the DPKG pattern layer is described as follows (Zhou et al., Reference Zhou, Bao, Chen and Liu2022):

(1) $$ \mathrm{DPKG}=\left\{E \cup A \cup F \cup O \cup T \cup S\right\}. $$

The symbols used in this study represent various types of information pertaining to the disassembly process. Specifically: Disassembly Elements (E), Element Attributes (A), Disassembly Features (F), Disassembly Operations (O), Tools (T), and Semantic Relationships (S).

E represents disassembly unit, such as the Component Unit, Part Unit, or Connector Unit. A represents the corresponding attribute values, such as Id, number, name, or category. F represents the disassembly features, which are represented by a series of points, lines, or surfaces that describe the geometric structure. O represents the disassembly operations, including specific instructions and requirements for performing the disassembly task. T represents the tools required for disassembly. S represents the semantic relationships between disassembly units, such as attribute relationship “Is,” subordination relationships “HasPart.PartOf,” proximity relationship “Close,” constraint relationship “ConnectorWith,” or connection relationship “ConnectorBy.” As shown in the following:

(2) $$ {\displaystyle \begin{array}{c}S=\sum \limits_{i,j=1}^n Is\left(\left({E}_i,{A}_j\right)\right)\cup \\ {}\sum \limits_{i,j=1}^n HasPart\left({E}_i,{E}_j\right)\cup \sum \limits_{i,j=1}^n Part Of\left({E}_j,{E}_i\right)\cup \\ {}\sum \limits_{i,j=1}^n Close\left({E}_i,{E}_j\right)\cup \\ {}\sum \limits_{i,j=1}^n ConnectorBy\left({E}_i,{E}_j\right)\cup \sum \limits_{i,j=1}^n ConnectorWith\left({E}_j,{E}_i\right)\cup \\ {}\sum \limits_{i,j=1}^n Tool\left({O}_i,{T}_j\right)\cup \sum \limits_{i,j=1}^n Operate\left({E}_i,{O}_j\right)\cup \\ {}\sum \limits_{i,j=1}^n Feature\left({E}_i,{F}_j\right)\cup \\ {}\sum \limits_{i,j=1}^n HasFaces\left({F}_i,{F}_j\right)\cup \sum \limits_{i,j=1}^n HasEdges\left({F}_i,{F}_j\right)\cup \sum \limits_{i,j=1}^n HasAnchors\left({F}_i,{F}_j\right).\end{array}} $$

Abstracting the symbols E, A, F, O, T, and S as categories of workpiece, attribute, feature, operation, tool, and relationship, respectively, and establishing subclasses through inheritance. The developed DPKG pattern layer is depicted in Figure 2. In the pattern layer, the workpiece class possesses instance attributes A such as name, Id, weight, and so on, and it inherits from the workpiece class. The feature of connector unit F has topological structures such as bolt, screw, pin, key, and so forth Regarding the operation class, its instance attributes O has type and disassembly action. The types comprise detection, disassembly, positioning, and so on, while the disassembly actions include grasping, placing, measuring, loosening, unscrewing, and so forth. Within the feature class, the instance attributes include type and Id. Examples of face types can be cylinder, circular hole, protrusion, groove, and so forth The edge types can be straight line, arc, curve, and so forth The instance attributes of the point class include coordinates and ID.

Figure 2. DPKG pattern layer.

In the semantic relationship class, “HasPart” and “PartOf” represent the subordination relationship between workpiece classes. “Close,” “ConnectorWith,” and “ConnectorBy” represent structural relationships within the workpiece classes. In addition, there are some geometric feature relationships, namely “Feature,” “HasFaces,” “HasEdges,” and “HasAnchors.” All the mentioned Id attributes serve as unique identifiers in the CAD model file.

After generating DPKG using the pattern layer, the task allocation indicators defined by DPKG information are assigned to facilitate human–robot task allocation. By combining the constraint matrix, the disassembly sequence knowledge graph (DSKG) can be derived. Compared to DPKG, DSKG aims to describe the disassembly order and disassembly operations between multiple task units, which describes tasks allocation and priority relationships. The pattern layer of the DSKG is described as follows:

(3) $$ \mathrm{DSKG}=\left\{E \cup A \cup O \cup T \cup S\right\}. $$

E represents disassembly unit, A represents their corresponding attribute values, O represents disassembly operations, T represents the tools required for disassembly, and S represents the semantic relationships between disassembly units. As shown in the following:

(4) $$ {\displaystyle \begin{array}{c}S=\sum \limits_{i,j=1}^n Is\left(\left({E}_i,{A}_j\right)\right)\cup \\ {}\sum \limits_{i,j=1}^n Before\left({E}_i,{E}_j\right)\cup \sum \limits_{i,j=1}^n After\left({E}_j,{E}_i\right)\cup \sum \limits_{i,j=1}^n Parallel\left({E}_j,{E}_i\right)\cup \\ {}\sum \limits_{i,j=1}^n Close\left({E}_i,{E}_j\right)\cup \\ {}\sum \limits_{i,j=1}^n HasTask\left({E}_i,{E}_j\right)\cup \\ {}\sum \limits_{i,j=1}^n ConnectorBy\left({E}_i,{E}_j\right)\cup \\ {}\sum \limits_{i,j=1}^n Tool\left({E}_i,{T}_j\right)\cup \sum \limits_{i,j=1}^n Operate\left({E}_i,{O}_j\right).\end{array}} $$

The DSKG pattern layer is illustrated in Figure 3. It primarily describes multiple task units and their corresponding operations involved in completing the disassembly task, emphasizing the procedural aspect of the disassembly process. In the DSKG, each part and connector are considered as a separate disassembly task. This extends the existing category information in the DPKG by incorporating disassembly operation details. The following features are added to the DSKG:

1. 1) The “class” attribute in each disassembly operation represents whether it is performed by a Human, Robot, or HRC.

2. 2) Each disassembly operation is assigned a sequential number (“S/N”) indicating its execution order within the disassembly tasks. The order of these operations is determined based on the constraint relationships among part units or connector units.

Figure 3. DSKG pattern layer.

Using the constraint matrix, the relationships of Before, After, and Parallel can be determined. Before and After signify the sequential execution of disassembly tasks, while Parallel represents the parallel execution of disassembly tasks. In cases where connector units are involved in two parts or components, disassembling the connector unit takes priority over the disassembly of the two units. As shown in Figure 3, Disassembly Operation 4 should be performed before Disassembly Operations 5 and 6.

Disassembly sequence planning

This section outlines the implementation of disassembly task allocation and the formulation of a constraint matrix based on the DPKG to generate feasible disassembly sequences stored in the DSKG.

To achieve rational task allocation, each connector or part acquires disassembly features (such as “volume,” “weight,” and “Feature”) based on the generated DPKG. Table 2 presents eight parameters used to indicate disassembly tasks and serve as decision variables for cooperative allocation. The parameters comprise Component Size (Cs), Component Weight (Cw), Tool Requirement (T), Accessibility (A), Component Shape (Csh), Operation Complexity (Oc), Positioning (P), and Operation Force (Of). Each parameter exhibits varying levels of difficulty or complexity.

Table 2. Disassembly operation difficulty and complexity categories and code (adapted from Parsa and Saadat, Reference Parsa and Saadat2021)

Subsequently, the decision order of parameters is determined using the Classification and Regression Tree (CART) algorithm, employing the Gini coefficient, to classify the disassembly operations. The training process involves the following steps:

1. 1) Analyze the features and the disassembly operation of each task.

2. 2) Refer to the classification in Table 2 and assign corresponding values.

3. 3) Utilize the feature value and classification label of each parameter as inputs.

The results are depicted in Figure 4 where “samples” represents the number of samples at the current node, “values” indicates the number of samples for different labels (“Human,” “Human–Robot,” “Human/Robot,” “Robot”) at the current node, “Human–Robot” indicate the execution performed by either robots or humans. And “class” represents the label with the highest number of samples among all labels at the current node. The classification process continues until all tasks are classified.

Figure 4. Disassembly task training set classification results.

To obtain a feasible disassembly sequence, three key disassembly details need to be considered after task allocation: the disassembly time for each task, task information, and priority relationships between tasks. The disassembly time for each task is obtained through manual testing, as shown in Table 3. In Table 3, C stands for connector unit and P stands for part unit. Task information encompasses the structural details and the required disassembly operations, which are stored in DPKG.

Table 3. Model C battery pack assembly information

For representing the priority relationships between tasks, this research utilizes graphs and matrices. The tasks priority matrix (TP) is used to capture the disassembly priority relationship between tasks. In TP, tasks with a column vector element are 1 constitutes the AND task set, while the task with the column vector element −1 constitutes the OR task set. For example, as shown in Figure 5, the set that has an AND priority relationship with task B/C is {A}, and the set that has an OR priority relationship with task D is {B, C}. Tasks without a priority constraint are assigned a column vector element of 0. To obtain an initial solution based on TP, the following steps are performed: First, identify tasks without sequential constraints. That is, all elements of the column vector corresponding to the task number in TP are 0, and these tasks are randomly sorted. When task i ∈ PAND(j), the ith row elements of TP after assignment i are set to zero, thus removing the restriction on the next task. When task i ∈ POR(j), all elements in the ith row and jth column are set to zero after assignment i, thereby lifting the restriction of task i on the next task y. Finally, the above operation is repeated to get a set of feasible disassembly sequences with an array length equal to the task size. By combining the task assignment results and the tasks’ sequence, a Gantt chart is generated that includes tasks performed by Humans, Robots, and HRC. In this Gantt chart, tasks assigned to Human/Robot can be self-assigned. The resulting sequence is ultimately stored in the DSKG.

Figure 5. Disassembly sequence generation method.

After obtaining a feasible disassembly sequence, this research focuses on optimizing the disassembly sequence by considering three aspects: disassembly time, worker workload, and operational safety. The objective is to minimize the overall completion time by reducing the duration of worker operations.

1. 1) Whenever feasible, tasks suitable for robots are assigned to them instead of humans.

2. 2) Furthermore, to ensure safety, parallel execution is not permitted when closely located tasks belong to different classes of disassembly operations.

As shown in Eq. (5), where CT represents the total time for completing all tasks, and $ \sum {T}_i^H $ represents the total time of tasks performed by workers. This study utilizes an improved genetic algorithm (Qu et al., Reference Qu, Li, Zhang, Liu and Bao2023) to select an optimal sequence. The algorithm starts with selecting a set of disassembly sequences as initial individuals and employs a fitness function to evaluate the quality of each individual based on satisfaction and weighted criteria. The process involves mutation, recombination, and hybrid decoding to generate new individuals for iterative optimization. The algorithm determines the termination condition based on the number of iterations, and the best solution (disassembly sequence) obtained is stored in the DSKG. The fitness function F is defined in Eq. (6), where W ₁, W ₂, and W ₃ represent respective weight values and S represents a safety value. If the relationship between two tasks is Close, Parallel, and they are assigned to different task operators (human, robot), then S is −1, otherwise, it is 1.

(5) $$ f=\min \left[\mathrm{CT},\sum {T}_i^H\right]. $$

(6) $$ F={W}_1\mathrm{CT}+{W}_2\Sigma {T}_i^H+100{W}_3S. $$

The mathematical symbols and assumptions used in this article are defined as follows (Table 4):

Table 4. Mathematical symbols and assumptions used in this article

HRC disassembly sequence generation based on KG matching

Graph matching involves utilizing algorithms to match and compare new nodes and edges with existing ones in a KG, to determine their similarity or identity. This process aids in determining whether the new nodes and edges are similar to or match those in the existing KG. Commonly used graph matching algorithms include subgraph isomorphism algorithms, maximum common subgraph algorithms, and Google’s Graph Matching Algorithm, among others. Graph matching enables the search for corresponding nodes and edges in the existing KG that match the query statement. This allows the retrieval of relevant knowledge and information without the need to duplicate the construction of the KG, thereby enhancing system response time and user experience.

Due to the variety and high similarity of EOL-LIB models, it is common to have highly similar parts across different models. However, these parts may correspond to different disassembly operations in various model scenarios. Consequently, relying solely on entity matching would yield numerous similar nodes, making it challenging to acquire the necessary disassembly knowledge. Therefore, this research adopts a KG matching approach that involves matching pairs of subgraphs. This approach considers the constraints and feature information of the nodes and their neighboring nodes, utilizing graph structure information to retrieve the most similar historical node information to the current node. Figure 6 illustrates an example using the condensing system component, displaying the nodes of the part “Condensing pipe” and its neighboring nodes in KG1. Node features and neighboring node features are embedded to calculate the similarity with corresponding entities KG2 and KG3 in the historical knowledge base. Knowledge completion is achieved by sorting based on similarity values to obtain the relevant node information from KG2.

Figure 6. The Condensing pipe and neighboring nodes information in different battery models.

Figure 7 provides an overview of the HRC disassembly sequence generation method based on KG matching. This approach addresses the alignment between graph structures and the information propagation between neighboring entities in building the global graph representation vector using the Graph Matching Network (GMN) model and the Graph Convolutional Network (GCN) model, respectively. It solves the entity alignment problem in the KG.

Figure 7. The method of HRC disassembly sequence generation based on KG matching.

To acquire the necessary disassembly operation information and neighboring sequence relationships, consider the component unit CP1, which contains Part 3, as a subgraph. The GMN model is employed to match the component subgraph with the graph structures in the knowledge base to find the most similar model. Subsequently, the one-hop node information is extracted, including Part 3, from the component subgraph to generate the theme entity graph. The GCN is then embeds the theme entity graph and aligns it with the subgraph of the similar model obtained from the knowledge base. In the graph, different colors of arrows represent different entity alignments, with the currently matched nodes highlighted in red and neighboring nodes highlighted in blue. Finally, the corresponding disassembly tools and operations for the specified node are retrieved.

In the graph-matching model, this research combines the GMN model (Li et al., Reference Li, Gu, Dullien, Vinyals and Kohli2019) and the GCN model (Xu et al., Reference Xu, Wang, Yu, Feng, Song, Wang and Yu2019). The GMN model is used to solve the graph matching task, specifically the matching of the component subgraph to obtain the most similar historical subgraph with the target subgraph structure. Then, the GCN model is employed to handle information propagation and aggregation among the local neighboring nodes, thereby achieving the alignment of theme entities. In GMN, the input consists of a pair of graph structures, specifically the adjacency matrices and node feature matrices of the two graphs. The graph-matching network calculates the similarity between these two graphs. The architecture of GMN consists of an encoder; propagation layers and an aggregator.

Encoder: Encoding of nodes and edges is performed using two separate multilayer perceptron (MLP) networks.

(7) $$ {h}_i^{(0)}={\mathrm{MLP}}_{\mathrm{node}}\left({x}_i\right),\forall i\in V. $$

(8) $$ {e}_{ij}={\mathrm{MLP}}_{\mathrm{edge}}\left({x}_{ij}\right),\forall \left(i,j\right)\in E. $$

Propagation Layers: By utilizing multiple propagation layers cantered around the nodes, the aggregation of first-order neighborhood information is performed. This process not only considers the aggregation messages on each graph edge but also takes into account a cross-graph matching vector that measures the degree of matching between a node in one graph and one or more nodes in another graph.

(9) $$ {m}_{j\to i}={f}_{\mathrm{message}}\left({h}_i^{(t)},{h}_j^{(t)},{e}_{ij}\right),\forall \left(i,j\right)\in {E}_1\cup {E}_2. $$

(10) $$ {\mu}_{j\to i}={f}_{\mathrm{match}}\left({h}_i^{(t)},{h}_j^{(t)}\right),\forall i\in {V}_1,\forall j\in {V}_2, or\;i\in {V}_2,j\in {V}_1. $$

(11) $$ {h}_i^{\left(t+1\right)}={f}_{\mathrm{node}}\left({h}_i^{(t)},{\Sigma}_j{m}_{j\to i},{\Sigma}_{j^{\prime }}{\mu}_{j^{\prime}\to i}\right). $$

Here, $ {h}_i^{\left(t+1\right)} $ represents the update of node i, and f_match is a function that propagates cross-graph information using an attention-based module

(12) $$ {a}_{j\to i}=\frac{\exp \left({s}_h\left({h}_i^{(t)},{h}_j^{(t)}\right)\right)}{\Sigma_{j^{\prime }}\exp {\left({s}_h\left({h}_i^{(t)},{h}_{j^{\prime}}^{(t)}\right)\right)}^{\prime }}. $$

(13) $$ {\mu}_{j\to i}={a}_{j\to i}\left({h}_i^{(t)}-{h}_j^{(t)}\right). $$

The relative distance between the encoded features of a node and all nodes in another graph is computed using an attention mechanism to calculate $ {\mu}_{j\to i} $ . This calculation captures the interaction information between the current node and all nodes in another graph.

(14) $$ {\Sigma}_j{\mu}_{j\to i}={\Sigma}_j{a}_{j\to i}\left({h}_i^{(t)}-{h}_j^{(t)}\right)={h}_i^{(t)}-{\Sigma}_j{a}_{j\to i}{h}_j^{(t)}. $$

Aggregator: After a certain number T rounds of propagations, an aggregator takes the set of node representations $ \left\{{h}_i^{(T)}\right\} $ as input, and computes a graph-level representation $ {h}_G={f}_G\left({h}_i^{(T)}\right) $ . After the graph representations h _G1 and h _G2 are computed for the pair (G1, G2), computes the similarity between them using a similarity metric in the vector space.

(15) $$ {h}_{G1}={f}_G\left({\left\{{h}_i^{(t)}\right\}}_{i\in {v}_1}\right). $$

(16) $$ {h}_{G_2}={f}_G\left({\left\{{h}_i^{(T)}\right\}}_{i\in {V}_2}\right). $$

(17) $$ s={f}_s\left({h}_{G_1},{h}_{G_2}\right). $$

Here f_s is a standard vector space similarity between $ {h}_{G_1} $ and $ {h}_{G_2}. $

In GCN, the input is a standalone graph structure, including an adjacency matrix and a node feature matrix. The architecture consists of two main layers:

1. 1) Input representation layer, and

2. 2) Node matching layer.

Input representation layer: The purpose of this layer is to learn entity embedding vectors that appear in component subgraphs or topic entity graphs using GCN. Taking the embedding generation of entity v as an example, the specific steps are as follows:

Node matching layer: This layer applies an attention-based matching method to compare each entity embedding vector from one subgraph with all entity embedding vectors from another subgraph, following the order from G ₁ to G ₂ and from G ₂ to G ₁, respectively.

First, compute the cosine similarity values between entities in G ₁ and all entities in G ₂.

(18) $$ {a}_{i,j}=\mathrm{cosine}\left({e}_i^1,{e}_j^2\right)\hskip1em j\in \left\{1,\cdots, |{G}_2|\right\}. $$

Then, use these similarities as weights and calculate the attention vector for the entire graph by taking a weighted sum of all entity embedding vectors in G ₂.

(19) $$ {e}_i^{-1}=\frac{\Sigma_{j=1}^{\mid {G}_2\mid }{a}_{i,j}\cdot {e}_j^2}{\Sigma_{j=1}^{\mid {G}_2\mid }{a}_{i,j}}. $$

Finally, apply a multi-angle cosine matching function to calculate the matching vectors for all entities in G ₁ and G ₂ at each step, and sort the results in descending order.

(20) $$ {m}_i^{\mathrm{att}}={f}_m\left({e}_i^1,{e}_i^{-1}\right). $$

(21) $$ {m}_j^{\mathrm{att}}={f}_m\left({e}_j^1,{e}_j^{-1}\right). $$

The matching function is defined as follows: f_m is a multi-angle cosine matching function used to compare two vectors.

(22) $$ m={f}_m\left({v}_1,{v}_2,W\right), $$

where v1 and v2 are two d-dimensional vectors, $ W\in \mathcal{R}{\Re}^{l\times d} $ is a trainable parameter, l is the number of angles, and the returned m value is an l-dimensional vector $ m=\left[{m}_1,\cdots, {m}_k,\cdots, {m}_l\right] $ . Element m_k represents the matching value obtained from the kth angle. This matching value is calculated by computing the cosine similarity between two weighted vectors.

(23) $$ {m}_k=\mathrm{cosine}\left({W}_k\circ {e}_i^1,{W}_k\circ {e}_i^{-1}\right). $$

The symbol ° represents element-wise multiplication. W_k denotes the kth row of matrix W, which controls the kth angle and assigns different weights to different dimensions in the d-dimensional space.

Disassembly validation system

The disassembly validation system in this study utilizes the modeling of HRCD for EOL-LIBs environment, leveraging digital twin technology (Qu et al., Reference Qu, Li, Zhang, Liu and Bao2023). The digital twin disassembly environment consists of both physical and virtual spaces, with seamless data interaction and integration between the two spaces. The virtual space serves as a platform for digital modeling and simulation, while the physical space allows for real-time control commands from the virtual space, enabling adjustments to the disassembly behavior. To achieve this, a three-dimensional modeling software is employed to create digital representations of objects corresponding to the physical space. Environmental data is continuously updated through sensor technology. Nest, the point cloud segmentation method is then used to classify and segment the point cloud in the disassembly environment. This segmentation process facilitates the extraction of disassembly-specific information, which is then stored in a structured XML file. The Earth Mover’s Distance (EMD) method is employed to calculate the similarity distance between the segmented point cloud and the template point cloud. By combining the information stored in XML, a disassembly scene graph with attributes is constructed. Finally, the Coppeliasim platform is used for modeling and simulation in the virtual space, utilizing the representation method provided by the disassembly scene graph.

To ensure safety and enhance the efficiency of HRCD processes within the digital twin environment, this study primarily focuses on investigating generation methods for HRC disassembly sequences using KGs. The objective is to offer improved decision-making support to workers involved in the disassembly operations.

Verification of generation of LIB DSKG

The case study product selected in this research is the S471 standard C pack. Semantic data such as disassembly structure, disassembly geometric features, disassembly processes are extracted from CAD model files and disassembly operating procedure. The KG modeling is carried out on the extracted semantic data using the open source Neo4j graph database.

The disassembly structure information, obtained from CAD model files and disassembly operating procedure (see Figs. 8,9) is used to develop the data layer of the DPKG, as depicted in Figure 10. In the figure, the blue ones, brown ones, and green ones refer to the component units, the part units and the disassembly operations associated. The disassembly operation labeled as disassembly-grasp with Id 7 is highlighted. Additionally, the orange node and the red node represent the part feature and the tool required for disassembly, respectively.

Figure 8. S471 standard C pack disassembly operating procedure.

Figure 9. S471 standard C pack CAD model.

Figure 10. The DPKG of LIB S471 standard C pack.

Based on the constructed DPKG for the S471 standard C pack, the corresponding DSKG can be realized by:

1. 1) obtaining the feature information from DPKG, assigning each part with the task allocation parameters specified in Table 2, inputting them into the trained classification regression tree model, and obtaining the disassembly category (Human/Robot/HRC) for the current part;

2. 2) obtaining the constraint relationships and part structures from DPKG, obtaining the constraint matrix in Figure 5 and the And/or graph, and finally obtaining the corresponding disassembly sequence. The constructed DSKG for the S471 standard C pack is shown in Figure 11: Compared with DPKG, DSKG allocates tasks in the original disassembly operation, and there are sequential disassembly relationships (Entity 1, Before, Entity 2) and parallel relationships (Entity 1, Parallel, Entity 2) between parts. Through the semantic relationships and attribute values in DSKG, it can be used to assist in the HRCD process.

Figure 11. The DSKG of LIB S471 standard C pack.

Verification of HRC disassembly sequence generation based on KG matching

In this experimental module, a LIB DPKG for a specific battery model as the target dataset, while 10 different battery models of DSKG are constructed as the source domain dataset. Each battery model in the source domain dataset has an average of 150 entities and 500 relationships. Entity alignment connections are established between identical or similar Parts or Connectors across different models. The Adam optimizer is used to update parameters, with a batch size of 32 and a learning rate of 0.001. Both the GMN and GCN have a hop count K set to 1. The non-linear function σ is set to ReLU. The aggregator parameters are randomly initialized. The pre-training utilizes the glove.840B.300d word embedding model.

During the training process, the model uses existing entity connection information to extract feature information and adjacency node information for relevant entities, thereby learning their representation in the vector space. During the query process, when a specific entity from the target dataset is provided, the model calculates the similarity between the component subgraph containing that entity and the component subgraphs in the source domain dataset. The component subgraph with the most similar graph structure information is selected. Then, the model calculates the similar values for all entities within the component subgraph and sorts the results in descending order.

In the experiment, specific sequential relationship values are incorporated into the model. The experimental results and training process are presented in Table 5 and Figure 12, respectively. Accuracy@k represents the proportion of correctly aligned entities among the top k entities. It can be observed that the accuracy value of Accuracy@1 is only 40.8%. This means that among the entities in the source domain dataset, only 40.8% align correctly. However, 71.2% of the retrieved entity answers have scores in the top 10 which is consistent with the expected accuracy.

Table 5. The experimental results of incorporated specific sequential relationship values on the model

Figure 12. The training process of incorporated specific relationship values on the model.

Table 6 presents the experimental results of our dataset on the model after removing relationship labels. The experimental results and training process are illustrated in Table 6 and Figure 13, respectively. It is evident that Accuracy@1 and Accuracy@10 have significantly improved compared to the results obtained when considering specific sequential relationship values.

Table 6. The experimental results of removing specific relationship values on the model

Figure 13. The training process of removing specific relationship values on the model.

This is similar to the expected results, mainly attributed to the challenge of effective learning as the graph structure information becomes more complex. This approach is chosen for two reasons. Firstly, the relationship labels in the dataset are represented as abstract symbols, offering limited knowledge about the relationships and making it challenging for the model to learn their alignment between the two KGs (Xu et al., Reference Xu, Wang, Yu, Feng, Song, Wang and Yu2019). Secondly, CAD models do not provide sequential relationships between parts; instead, they focus on structural relationships and entity content. Therefore, there is a lack of effective learning when considering sequence relations.

Although the value of Accuracy@1 is 70.7%, it has already reached the expected experimental outcomes. This is mainly because there are different parts exist among different battery models, which results in the presence of some unlabelled data inherently.

Verification of HRCD based on KG

In this study, two experimental setups were employed to investigate the disassembly of LIBs: one with a DSKG knowledge base and the other without. Ten participants engaged in the experiments, evaluated through various performance metrics. The mean values for each metric were computed, followed by an analysis of the relative differences between these metrics, with the comparative outcomes depicted in Figure 14. Notably, the planning time for disassembly sequences was significantly reduced in the experiment utilizing the KG. The efficiency gain is attributed to the entity alignment using KG, thereby enabling rapid retrieval of disassembly sequences for identical components and diminishing the necessity for repeated planning. Additionally, with KG assistance, more consideration could be given to the allocation of tasks for human–robot balance under safety conditions, resulting in a corresponding reduction in worker load and total disassembly time. These findings indicate that the methodology proposed in this research enhances disassembly efficiency and minimizes the time required for task planning.

Figure 14. Comparison of different indicators for HRCD.