Generation of human–robot collaboration disassembly sequences for end-of-life lithium–ion batteries based on knowledge graph

Abstract

The disassembly of end-of-life lithium–ion batteries (EOL-LIBs) is inherently complex, owing to their multi-state and multi-type characteristics. To mitigate these challenges, a human–robot collaboration disassembly (HRCD) model is developed. This model capitalizes on the cognitive abilities of humans combined with the advanced automation capabilities of robots, thereby substantially improving the disassembly process’s flexibility and efficiency. Consequently, this method has become the benchmark for disassembling EOL-LIBs, given its enhanced ability to manage intricate and adaptable disassembly tasks. Furthermore, effective disassembly sequence planning (DSP) for components is crucial for guiding the entire disassembly process. Therefore, this research proposes an approach for the generation of HRCD sequences for EOL-LIBs based on knowledge graph, providing assistance to individuals lacking relevant knowledge to complete disassembly tasks. Firstly, a well-defined disassembly process knowledge graph integrates structural information from CAD models and disassembly operating procedure. Based on the acquired information, DSP is conducted to generate a disassembly sequence knowledge graph (DSKG), which serves as a repository in graphical form. Subsequently, knowledge graph matching is employed to align nodes in the existing DSKG, thereby reusing node sequence knowledge and completing the sequence information for the target disassembly task. Finally, the proposed method is validated using retired power LIBs as a case study product.

Introduction

With the increasing demand for sustainable development in society, sustainability has become crucial for the manufacturing industry. Manufacturers must minimize resource consumption and address the environmental issues caused by their operations, making sustainable manufacturing imperative. The end-of-life management of disposed products significantly contributes to sustainable manufacturing by improving energy efficiency, material efficiency, as well as providing environmental benefits through reuse, recycling, and recovery. Disassembly is an essential step in achieving recycling and cascaded utilization. However, the disassembly of retired products, such as power lithium–ion batteries (LIBs), presents challenges due to variations in batch sizes, styles within the same product type, retirement status, and varieties across different models. The uncertainty in the recycling status of retired power LIBs primarily leads to manual disassembly as the dominant method. However, manual disassembly is labor-intensive and inefficient, and the disassembly process may expose harmful substances from batteries, posing potential threats to workers’ health (Ordoñez et al., 2016). The development and implementation of disassembly robots and automated disassembly systems have improved disassembly efficiency and effectively alleviated the labor intensity and work hazards faced by disassembly operator. Disassembly of retired power LIBs has already been applied using robotic technologies (Vongbunyong et al., 2013). However, robotic cognitive capabilities are limited, and their ability to handle the high uncertainty associated with the quality of recycled products remains insufficient (Wang et al., 2017), thereby failing to meet the requirements of highly flexible disassembly. With the development of human–machine collaboration, McCaffrey and Spector (2018) propose the Obscure Features Hypothesis, highlighting that innovative solutions are built upon commonly overlooked or new features of a problem, and exploring the potential of HRC in innovative problem-solving. Additionally, robotics and autonomous systems (RAS) have been applied to enhance productivity, and the literature (Duong et al., 2020) discusses their role in improving supply chain operations. The emergence of collaborative robots fills the gap between manual and automated disassembly by combining the strengths of humans, such as flexibility and adaptability, with the advantages of robots, such as fatigue resistance and carrying capacity. It is considered the suitable solution currently available for LIB disassembly and recycling.

While HRC can significantly improve disassembly performance, there are still many planning challenges in HRCD due to the uncertainty of the disassembly process and the variability of the environment. These challenges encompass a range of critical tasks, including the assessment of disassembly tasks attributes, evaluation of worker and robot capabilities, rational allocation of disassembly tasks, selection of appropriate disassembly tools, and the strategic sequencing of human and robot actions. Human operators bring to the table sensitivity, cognitive prowess, and decision-making capabilities. While robot offers enhanced accuracy and consistency. Furthermore, under safe conditions, robots and humans can collaborate to perform hybrid tasks with reasonable task allocation and sharing, thereby minimizing overall disassembly time and costs. (Inkulu et al., 2021). Given the characteristics of human–robot collaboration disassembly sequence planning (HRC-DSP), wherein the disassembly time and complexity can vary markedly between human and robot operations for the same component, developing effective methods for task allocation and sequence planning poses a significant challenge in HRC research.

When designing HRC-DSP for EOL-LIBs, a large amount of specific information is required. Li et al. (2023) proposed a knowledge-driven approach and framework, establishing an intelligent reasoning model to support product improvement. However, due to a lack of understanding of collaborative disassembly tasks, inexperienced operators often waste a significant amount of operation time during the product disassembly process. Unstructured knowledge does not have a significant impact and cannot be effectively utilized. The sourcing of disassembly task information predominantly from process documents and CAD models highlights the critical need for the integration and conversion of multi-source heterogeneous task and process data, thereby enhancing disassembly guidance. Furthermore, the necessity for specific sequence planning for new disassembly tasks exemplifies the current system’s inefficiency and rigidity. Given the structural similarities among EOL-LIBs at various stages of retirement, the rapid adaptation to new disassembly tasks through the strategic retrieval of information from the disassembly sequence knowledge base – via knowledge transfer – promises significant enhancements in disassembly efficiency and cost reduction.

Knowledge graphs (KGs) provide a robust means of representing and manipulating knowledge through expressive graphical data models. KGs capture acquired knowledge in the form of triplets that can be utilized in conjunction with neural network algorithms. By retrieving target entities and relationship information from the KG, facilitating exceptional information visualization and causal interpretability. KG provides an effective mechanism for consolidating all disassembly-related information into a semantically linked entity network. This network contains a substantial amount of prior knowledge and enables efficient utilization and management of data. Currently, KGs are widely applied in the field such as semantic analysis, question-answering systems, and recommendation systems (Chen et al., 2020).

In consideration of the aforementioned analysis and the existing challenges in recycling various types of end-of-life lithium–ion batteries (EOL-LIBs) with different decommissioning conditions, this research proposes a generating human–robot collaborative disassembly sequences for these batteries based on KGs.

1. 1) To address the underutilization of knowledge and the difficulty in sequence planning resulting from the heterogeneous nature of data sources in the disassembly process, a method for modeling disassembly process information and generating sequences based on KGs is proposed.

2. 2) To overcome issues such as lengthy planning time and excessive reliance on manual expertise in disassembly process planning, a fast sequence generation method that incorporates graph matching and network similarity learning is proposed.

The remainder of this article is organized as follows. Section “Literature review” provides an overview of the current research status on HRCD of EOL-LIBs and the application of KGs in this domain. Section “Generation of HRCD sequences based on KG” presents the overall framework and discusses the details of each component. In section “Case study,” the proposed methods are verified through a case study of EOL-LIBs. Section “Discussion” discusses the experimental results and presents the limitations of the current study as well as future prospects. Finally, section “Conclusions” summarizes the conclusions drawn from this research and highlights its limitations.

Literature review

With the application of industrial robots, automated disassembly systems composed of robots have been widely used. The implementation of industrial robots has led to the widespread adoption of automated disassembly systems comprised of these robots. With their high precision and repeatability, robots excel at handling monotonous and heavy tasks. However, the disassembly process of EOL-LIBs involves deformations and uncertain collision risks that robots alone cannot effectively address. This limitation has given rise to collaborative robots, sparking increased research on HRC in the disassembly field. This collaborative approach combines the flexibility of humans with the stability of robots, making it well-suited for the current requirements of disassembly tasks. Nevertheless, the collaborative environment, which involves multiple heterogeneous data sources, is dynamic and demands adjustments to the robot control strategy. To enable efficient collaborative disassembly by effectively utilize task and environmental information, KG-based methods have been developed for the unified management and representation of knowledge. Therefore, this section provides an overview of the current research status in HRCD of EOL-LIBs and explores the application of KGs in this context.

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. (2018) 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. (2020) 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. (2017) 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. (2023) 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. (2022) 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. (2021) 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. (2022) 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. (2022) 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 (2020) 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. (2020) 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. (2021) 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 (2019) 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. (2020) 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., 2013), semantic matching models (Nickel et al., 2011), and neural network models such as ConvE (Dettmers et al., 2018), GNN (Li et al., 2019), and R-GCN (Schlichtkrull et al., 2018). 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. (2020) 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. (2022) 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.

Generation of HRCD sequences based on KG

To achieve the generation of disassembly sequences for EOL-LIBs, this section introduces the overall system framework and provides a detailed description of the generation of HRCD sequences based on KGs. The method consists of the following steps:

1. 1) Modeling of disassembly information;

2. 2) DSP; and

3. 3) HRC disassembly sequence generation based on KG matching.

As illustrated in Figure 1, the HRC-DSP generation method starts with the modeling of disassembly information. The CAD model and the disassembly operating procedure are processed and integrated into representable knowledge, which serves as input 1 for constructing the disassembly process knowledge graph (DPKG). Subsequently, DSP is carried out based on the DPKG. Predefined patterns from the DSKG are employed to generate the DSKG, which is stored in the knowledge base for knowledge retrieval.

Figure 1. System framework for generation of HRC disassembly sequences based on knowledge graph.

When a new battery model is provided as input 2, the DPKG is constructed based on the CAD model. Through KG matching, the system reuses the disassembly knowledge of the corresponding part from the historical knowledge base, enabling the generation of disassembly sequences. Finally, the feasibility of the generated sequence is validated using a simulation platform. This validation guides the HRCD process in real-world scenarios, and updates the sequence knowledge in the knowledge base.

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., 2022):

(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, 2021)

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., 2023) 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., 2019) and the GCN model (Xu et al., 2019). 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:

Step l: Use a word-based LSTM to convert the name of all entities in the graph into vectors for initialization. The initialization embedding vector for entity v is represented as symbol a_v.

Step 2: Classify the neighboring entities of entity v. If a neighboring entity is connected to entity v through an edge pointing toward v, then that entity belongs to the set $ {\mathcal{N}}_{\vdash }(v) $ . If a neighboring entity is connected to entity v through an edge pointing toward itself, then that entity belongs to the set $ {\mathcal{N}}_{\vdash }(v) $ .

Step 3: By using an aggregator, transform the representations of all neighboring nodes pointing toward entity v, denoted as $ \left\{{h}_{\mu \vdash}^{k-1},{\forall}_{\mu}\in {\mathcal{N}}_{\vdash }(v)\right\} $ , into a single vector $ {h}_{{\mathcal{N}}_{\vdash }(v)}^k $ , where k is the iteration value. This aggregator takes the vector representations of all nodes directly connected to node v as inputs to a fully connected neural network and applies a mean pooling operation to capture different aspect features in the neighbor set.

Step 4: Concatenate the representation $ {h}_{v\vdash}^{k-1} $ of the neighbor set pointing toward entity v obtained from the previous (k – 1) rounds with the newly generated $ {h}_{{\mathcal{N}}_{\vdash }(v)}^k $ . And then feed the concatenated vector into a fully connected layer to update the representation of the neighbor set pointing toward entity v for the next iteration, resulting in $ {h}_{v\vdash}^k $ .

Step 5: Using the same method as in steps (3) and (4), update the representation of the neighbor set pointed out by entity v, denoted as $ {h}_{v\dashv}^k $ , within the neighbor set pointed out by entity v.

Step 6: Repeat steps (3) to (5) K times, and then concatenate the final representation of the neighbor set pointed toward entity v with the representation of the neighbor set pointed out by entity v. This concatenated vector serves as the embedding vector for a single entity. Finally, obtain two sets of embedding vectors for the two groups of entities, denoted as $ \left\{{e}_1^1,\cdots, {e}_{\mid {G}_1\mid}^1\right\} $ and $ \left\{{e}_1^1,\cdots, {e}_{\mid {G}_2\mid}^1\right\} $ .

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., 2023). 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.

Case study

Given the significant variability in vehicle manufacturing and service procedures, the recycling and disassembly of LIBs pose challenges due to the diversity in brands, models, and conditions of retired batteries. Considering the disparities between EOL-LIBs and their initial states, this research has made certain assumptions as follows:

1. 1) Conventional retirement conditions (such as component wear, shell corrosion, wire damage, etc.) are chosen for the disassembly of battery models.

2. 2) This study focuses on the application of HRC in disassembly, assuming that the structural composition of relevant components remains largely unchanged in the retired state, similar to CAD files/j ob manuals. This accounts for the possibility of structural and characteristic changes under damaged conditions, allowing for replanning of damaged parts when planning based on the intact structural composition.

3. 3) All experiments were conducted under the same disassembly line to ensure the reliability of the results. Based on these assumptions, the feasibility of the proposed model framework and its methods is validated.

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., 2019). 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.

Discussion

This article verifies the feasibility of the model method by selecting a specific type of waste LIB and collecting relevant data information. The integrated representation of CAD data and disassembly operating procedure through the established DSKG effectively improves the availability and interpretability of data, facilitating the HRCD process of LIBs. By reusing historical disassembly sequence knowledge based on KG matching, fast sequence transfer can be achieved, avoiding the need for specific sequence planning for each disassembly task, which can effectively improve disassembly efficiency and reduce costs. It should be noted that, in the process of graph matching, only the direction of relationships is considered while disregarding the relationship labels.

However, there are still some limitations in this study:

1. 1) Considering the difficulty of collecting retired battery data, the selected battery pack models are basic and have similar structures, which is convenient for experiments;

2. 2) The generated disassembly sequence information still requires expert participation and evaluation, and the provided disassembly information is still limited. The ability to provide reasoning and decision-making needs to be further improved.

Current HRC still faces challenges such as insufficient real-time interaction and weak intelligent decision-making. For specific domain HRC processes such as LIB disassembly, deeper domain professional knowledge needs to be provided, and machine learning technology can be used to strengthen intelligent decision-making (Liu et al., 2023).

In future work, the following three aspects can be explored:

1. 1) Expand the scope to include additional battery model types and incorporate supplementary attribute information to further enhance the DSKG, aiming for a more comprehensive knowledge representation and providing additional evaluation metrics for DSP.

2. 2) Consider the high-fidelity and similarity between actual disassembly and simulation experiments when structural and characteristic changes occur under damaged conditions of LIBs.

3. 3) Investigate the human–robot load balancing issues in the hybrid disassembly line for multi-variety, small-batch retired power LIBs.

Conclusions

Recently, there has been a growing interest in research on HRCD of EOL-LIBs. In this context, effectively utilizing and managing data to achieve knowledge representation and utilization in collaborative disassembly scenarios has become a research focus. This research proposes a generation of HRCD Sequences for EOL-LIBs Based on KG, the main contributions are summarized as follows:

1. 1) The pattern layer of DPKG is defined, which integrates CAD data with disassembly operation procedures data in the form of entity-property-value and entity-relation-entity. This enables the representation of the structure and process information required for disassembly tasks.

2. 2) The pattern layer of DSKG is defined to describe the disassembly sequence knowledge required to complete disassembly tasks. Based on DPKG, disassembly task assignment, and DSP are achieved, resulting in feasible HRCD sequences stored in DSKG.

3. 3) Knowledge reuse is achieved by matching the DSKG in the historical knowledge base through KG matching, using component subgraphs and theme entity graphs. This allows for efficient retrieval of relevant knowledge from the historical knowledge base.

4. 4) The proposed modeling method is validated using a specific battery pack’s disassembly process as an example, demonstrating the feasibility and effectiveness of the approach.