I present an enhanced knowledge graph framework that I designed for anomaly detection and maintenance strategy reasoning in industrial robots. My starting point is the observation that industrial robots are complex electromechanical systems with multiple degrees of freedom, tightly integrated mechanical structures, servo drives, controllers, sensors, and end-effectors. In long-term industrial operation, key components such as RV reducers, harmonic reducers, servo motors, bearings, bolts, and tool interfaces inevitably experience performance degradation or sudden faults. These faults produce diverse and often hidden failure modes. Traditional periodic maintenance and reactive repair strategies depend heavily on human experience, and they struggle to satisfy the high-reliability and low-downtime requirements of modern production. Therefore, I aim to develop an intelligent operation and maintenance method for industrial robots that can perform real-time state monitoring, anomaly diagnosis, and autonomous maintenance strategy generation. Such a method is valuable for ensuring long-term stable operation of industrial robots and improving overall equipment effectiveness.
Current research and practice in intelligent maintenance of industrial robots mainly follow three technical paths: model-based methods, data-driven methods, and knowledge-based methods. Model-based methods attempt to reveal fault mechanisms through precise physical or mathematical models. They often build digital twins or degradation curves for predictive maintenance. Although model-based methods provide strong interpretability, they face significant difficulties when applied to industrial robots because modeling complexity is high and generality is poor. Data-driven methods, especially deep learning, can automatically learn fault features from large amounts of operational data and have shown strong potential in anomaly detection. They can adapt to complex and changing scenarios, but they rely heavily on high-quality labeled data, offer limited interpretability, and consume substantial computational resources. Knowledge-based maintenance methods integrate domain knowledge and reasoning technologies, structuring complex domain knowledge and enabling intelligent association. Knowledge graphs, in particular, provide transparent semantic explanations and logical support for maintenance decisions, and they have become a research hotspot in intelligent operation and maintenance.
However, existing knowledge graph-based maintenance methods for industrial robots still have obvious limitations. They often rely on manual experience for fault phenomenon identification, which leads to low automation and accuracy. Maintenance strategy generation mainly depends on static knowledge and rules. When a new fault or an unknown situation occurs, these methods cannot quickly generate effective maintenance strategies, and they lack flexibility and adaptability. In my view, a traditional maintenance knowledge graph is essentially a static knowledge collection. Its core weaknesses are the absence of perception capability and the ossification of reasoning capability. The enhanced knowledge graph I propose directly addresses these two weaknesses. On the perception side, I embed data-driven automatic anomaly detection into the graph. On the decision side, I introduce dynamic reasoning based on entity similarity. In this way, the enhanced knowledge graph realizes full-process intelligence from static knowledge query to perception, reasoning, and decision-making for industrial robots.
My work makes three core contributions. First, I construct a fault-centric ontology model for the operation and maintenance knowledge graph of industrial robots. This model systematically integrates multi-dimensional knowledge, including robot structure, fault phenomena, causes, and maintenance methods, and it provides a unified knowledge foundation for intelligent maintenance. Second, on the perception side, I design an anomaly detection model based on neural architecture search (NAS) and autoencoder (AE). This model performs end-to-end unsupervised anomaly identification on vibration signals from industrial robots. It effectively improves the automation of state perception and the detection ability for unknown anomalies. Third, on the decision side, I propose a knowledge reasoning network based on entity similarity. This network enables the system to infer potential maintenance strategies for new fault phenomena by computing semantic similarity based on existing knowledge in the knowledge graph. It significantly enhances the adaptability and intelligence of the maintenance system. Based on these methods, I form a complete intelligent operation and maintenance software system for industrial robots, providing a feasible technical solution for intelligent maintenance.
Ontology Modeling and Knowledge Graph Construction for Industrial Robot Maintenance
I adopt a top-down ontology modeling approach. Industrial robots can be divided by function into four major subsystems: mechanical body, control system, drive system, and perception system. Considering the high frequency of electrical faults in control cabinets, I separate the control cabinet into an independent subsystem. Each subsystem contains multiple functional components. For example, the mechanical body includes tool flanges and end-effectors. The drive system consists of servo motors and reducers. Functional components can be further divided into multiple parts. This multi-level structure gives industrial robots high functional integration and also brings complex fault management challenges.
Any component fault in an industrial robot ultimately affects overall machine performance. However, although the types of component faults are numerous, the fault phenomena manifested on the whole industrial robot are relatively limited. This mapping relationship between fault types and overall machine behavior increases the difficulty of fault diagnosis and root cause tracing. Therefore, to achieve efficient maintenance of industrial robots, it is necessary to quickly locate the root cause from the overall machine behavior and provide targeted maintenance plans for different faults of key components. I therefore build a fault-centric ontology. I first construct the top-level ontology, then gradually refine concepts, attributes, and relationships to form an ontology model. This model provides a structured framework and specification for the knowledge graph.
The ontology structure mainly includes the core concepts and attribute relationships shown in Table 1. Equipment describes the industrial robot object under maintenance. Its attributes include code, name, and type, and it consists of multiple subsystems. Subsystem describes each subsystem that composes the industrial robot, and it contains multiple components. Component describes the components that constitute the subsystem of the industrial robot, and it is composed of multiple parts. Part describes each part that constitutes the component of the industrial robot. Its attributes include code, name, type, function, and material. Fault describes possible faults of the industrial robot. Its attributes include code, name, type, scope, and severity. A fault corresponds to a specific part. Fault phenomenon describes the phenomenon that appears during operation of the industrial robot. Its attributes include code, description, type, category, and scope. It is manifested by a specific fault. Cause describes the cause of the fault and leads to a specific fault. Maintenance method describes the method to solve the fault and is used to solve a specific fault. Entity relationships specifically include seven types: constitutes, composes, belongs to, corresponds to, manifests, causes, and solves. These relationships clarify the association and interaction among entities.
| Entity | Attributes |
|---|---|
| Equipment | Name / Type / Code |
| Subsystem | Name / Type (control, drive, etc.) / Code |
| Component | Name / Type (motor, reducer, etc.) / Code |
| Part | Name / Type (support, fastening, transmission, etc.) / Function / Material / Code |
| Fault | Name / Type (mechanical, electrical, software, etc.) / Scope / Severity / Code |
| Cause | Name / Type (mechanical, electrical, software, etc.) / Code |
| Phenomenon | Description / Category (fault, performance, etc.) / Type (balance disturbance, positioning error, etc.) / Influence scope (overall, joint, end-effector, etc.) / Code |
| Method | Description / Category (maintenance, spare part replacement, debugging optimization, etc.) / Code |
The ontology model I construct has two core characteristics. First, it adopts a four-layer structure of equipment, subsystem, component, and part. Compared with general human-cyber-physical knowledge graphs, it focuses more on the core maintenance requirements of industrial robots. Its layered structure matches the mechanical body and electrical control system composition of industrial robots and enables fine-grained fault localization from the whole machine to individual parts. Second, it adopts a fault-centric association design. Compared with maintenance graphs that emphasize causal relationship mining, it realizes one-to-one mapping among four core elements: fault, phenomenon, cause, and method. It associates faults, solutions, and specific parts, provides comprehensive fault descriptions, and effectively avoids reasoning ambiguity that may be caused by many-to-many fuzzy mappings. This design can quickly locate fault causes and generate solutions, improve fault handling efficiency, and enhance fault diagnosis and maintenance management capabilities for industrial robots.
Based on the above ontology model, I create an operation and maintenance knowledge graph for industrial robots. In the process of constructing the knowledge graph, knowledge collection and organization are crucial. Knowledge collection includes multiple approaches. I mainly obtain knowledge by referring to robot maintenance manuals, expert knowledge, related literature and books, and field experience from robot machining units. The knowledge is divided into general maintenance knowledge and specialized maintenance knowledge for industrial robots. I classify the collected knowledge according to the eight types of entities in the ontology structure, further decompose it into specific elements, and clarify the connections among elements according to the seven types of relationships in the ontology structure. Finally, I standardize the knowledge, unify terminology and definitions, and ensure consistency and accuracy. The organized knowledge graph elements include equipment, subsystems, components, parts, faults, phenomena, causes, and methods. The knowledge graph contains 1 equipment entity, 5 subsystem entities, 25 component entities, 65 part entities, 105 fault entities, 105 phenomenon entities, 105 cause entities, and 105 method entities. Specialized maintenance knowledge accumulated from engineering applications of industrial robots and related maintenance knowledge of similar robots accounts for about one third of the knowledge graph. In addition, compared with the mechanical body, electrical faults in the robot control cabinet are more frequent. Therefore, I treat the control cabinet as an independent subsystem and organize related maintenance knowledge, which accounts for 14.3% of the knowledge graph.
I further implement software for the constructed industrial robot maintenance knowledge graph. It has functions such as knowledge retrieval, maintenance question answering, graph maintenance, and graph updating, aiming to provide efficient and comprehensive support for maintenance personnel. Graph knowledge is stored in a MySQL database in the form of (subject, relation, object) triples. I use JavaScript technology and ECharts tools for front-end display. Knowledge retrieval and maintenance question answering are core functions of the knowledge graph. They provide an intuitive interaction mode so that users can quickly find required information. A user can input keywords such as a fault or phenomenon of an industrial robot, quickly locate related nodes in the knowledge graph, and obtain possible maintenance solutions. A user can also input related keywords, and the system returns possible causes and solutions. The graph maintenance and update function supports real-time add, delete, modify, and query operations during use. Users can conveniently modify the ontology structure of the knowledge graph, add new entities and relationships, or delete and update existing knowledge nodes. This effectively ensures that the knowledge graph can continuously adapt to new maintenance requirements. The functional development of the knowledge graph forms a maintenance system and promotes its practical application. It also facilitates completion of the perception and reasoning functions of the knowledge graph and improves the intelligence level of the maintenance system.
Operation Anomaly Detection Based on NAS and AE
Automatic detection of abnormal states of industrial robots can be achieved by monitoring robot operation data, such as sensor data, control signals, and operation parameters. These anomalies can provide support for the maintenance knowledge graph to generate corresponding maintenance strategies. Table 2 lists some specific anomaly types of industrial robots and their corresponding signal monitoring methods. The listed anomalies and their manifestations are not necessarily comprehensive, but they are strongly related to the knowledge graph and are to some extent included in the fault manifestation category of the knowledge graph. This facilitates embedding the anomaly state perception algorithm into the knowledge graph.
| Entity | Attribute | Anomaly manifestation | Monitoring method |
|---|---|---|---|
| Motion anomaly | Deviations and wear involving mechanical motion | Positioning error; abnormal vibration | Laser tracker; acceleration sensor |
| Power anomaly | Problems related to power perception and control | Trajectory deviation; motion chatter | Lower-level controller signal acquisition; acceleration sensor |
| Electrical anomaly | Problems in power supply, circuits, and signal transmission | Communication anomaly; power and voltage anomaly | Voltage sensor; current sensor |
Power and electrical anomalies in industrial robots often trigger warnings in the robot controller. Severe cases may directly cause faults that can be observed. However, slight vibration is difficult to observe while directly affecting the machining quality of industrial robots. Therefore, I focus on motion anomaly detection of industrial robots. I deploy acceleration sensors at robot joints and the end-effector to acquire abnormal vibration signals. Creating an anomaly detection algorithm based on vibration signals needs to consider three factors. The first is detection efficiency. Conventional signal processing methods have independent feature extraction operations, which separate the entire detection process and hinder automation of anomaly detection. The second is detection accuracy. Vibration signal differences among different states are small. Achieving high detection accuracy without independent feature extraction requires a large amount of algorithm tuning work and depends on relevant domain knowledge. The third is detection performance. Sample production cannot cover all possible anomaly situations. For new states, effective detection must be achieved.
To address these issues, I design the anomaly detection algorithm from three aspects. First, I select deep learning algorithms. Based on deep learning, I create a robot anomaly detection model and realize end-to-end automatic detection. Second, I apply NAS technology. In a given data scenario, NAS can automatically create neural networks. It can free the method from dependence on deep learning modeling knowledge and continuously optimize the structure and accuracy of the anomaly diagnosis model. Third, I build an autoencoder architecture. An autoencoder network automatically learns the feature distribution of vibration signals in an unsupervised manner. When an input signal is significantly different from the normal state, such as an unknown abnormal state, it produces a large reconstruction error. This enables the autoencoder model to effectively detect unknown abnormal states.
The technical essence of NAS is a finite Markov decision process (MDP). I combine it with a neural network (NN) and propose an automatic creation method for robot anomaly detection models. An MDP is a mathematical modeling framework based on interactive learning. Its core contains two interacting subjects: an agent and an environment. The agent continuously interacts with the environment by executing actions. The environment responds to these actions and feeds back new state information and corresponding immediate rewards. The learning goal of the agent is to optimize its decision policy through this interaction process to maximize long-term reward. A finite MDP is a special case of MDP. Its state space, action space, and reward set, denoted as \(S\), \(A\), and \(R\), are finite sets. The random reward \(R_t\) and state \(S_t\) have well-defined discrete probability distributions and satisfy the Markov property. That is, the next state and reward depend only on the current state and action. This property can be formalized as follows: for any time \(t\), given current state \(s\) and action \(a\), the probability of transitioning to state \(s’\) and obtaining reward \(r\) is determined by
$$P\{S_{t+1}=s’, R_{t+1}=r \mid S_t=s, A_t=a\} \doteq p(s’,r|s,a)$$
where \(s,s’\in S\), \(r\in R\), and \(a\in A(s)\). This function has four parameters and defines the dynamic characteristics of the MDP. From the above equation, I can derive the state transition probability function from state \(s\) to state \(s’\) as
$$p(s’|s,a) = P\{S_{t+1}=s’ \mid S_t=s, A_t=a\} = \sum_{r\in R} p(s’,r|s,a)$$
Similarly, the expected reward of a state-action pair can be derived and expressed as a two-parameter function:
$$r(s,a) = \mathbb{E}[R_{t+1} \mid S_t=s, A_t=a] = \sum_{r\in R} r \sum_{s’\in S} p(s’,r|s,a)$$
The core optimization goal of the agent is not to pursue immediate reward, but to maximize the long-term cumulative reward obtained during the entire decision process. Specifically, this goal can be quantified as maximizing the expected cumulative sum of scalar reward signals received by the agent. Therefore, scientifically and reasonably designing a reward signal mechanism that accurately reflects the task goal and guides the agent to achieve desired behavior is one of the most critical steps. In the simplest case, the return is the sum of rewards. The agent obtains the current reward by choosing action \(A_t\). The return is expressed as
$$G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots + \gamma^{T-t-1} R_T = \sum_{k=0}^{T-t-1} \gamma^k R_{t+k+1}$$
where \(R_{t+1}\) represents the reward at time \(t+1\). The return \(G_t\) at time \(t\) is the sum of subsequent rewards. \(T\) represents the termination time of each search cycle. The discount rate \(\gamma\) determines the present value of future rewards. The present value of a reward at future time \(k\) is only \(\gamma^{k-1}\) times its value. In an extreme case, if \(\gamma=0\), then \(G_t = R_{t+1}\). This indicates that the agent only cares about how to take actions to maximize the current reward \(R_{t+1}\). Generally, this reduces future rewards and thus reduces total reward. As \(\gamma\) approaches 1, the discounted return considers future rewards more, and the agent becomes more far-sighted.
I then introduce a value function to evaluate how much future expected reward the current agent can obtain in a given state. The expected return is a function of state and depends entirely on the action chosen by the agent. The value function is related to a specific behavior mode, which can also be called a policy. A policy is a mapping from states to probabilities of selecting each possible action. If the agent follows policy \(\pi\) at time \(t\), then \(\pi(a|s)\) is the probability that \(A_t=a\) when \(S_t=s\). I denote the value function of state \(s\) under policy \(\pi\) as \(v_\pi(s)\), which is the expected return starting from state \(s\):
$$v_\pi(s) = \mathbb{E}_\pi[G_t \mid S_t=s] = \mathbb{E}_\pi\left[\sum_{k=0}^{T-t-1} \gamma^k R_{t+k+1} \mid S_t=s\right]$$
Similar to the recursive formula of return, the value function satisfies a recursive relationship. For policy \(\pi\) and state \(s\), the value of \(s\) and the values of its possible successor states satisfy the following relationship:
$$v_\pi(s) = \sum_a \pi(a|s) \sum_{s’,r} p(s’,r|s,a)[r + \gamma v_\pi(s’)]$$
where action \(a\) is taken from \(A(s)\), next state \(s’\) is taken from \(S\), and reward \(r\) is taken from \(R\). This is the Bellman equation for \(v_\pi\), expressing the relationship between the value of a state and the values of successor states. Starting from a root state, there is a series of possible actions and subsequent states. The Bellman equation weights all possibilities by their occurrence probabilities. This also shows that the value of the starting state must equal the discounted expected value of successor states plus the expected value of the corresponding reward.
The state value function \(v_\pi(s)\) of the MDP indicates that the return in different states is determined by policy \(\pi\), and policy \(\pi\) is determined by the agent. In my proposed method, the MDP is combined with deep learning. The function of the agent is implemented by a neural network model, and its output is policy \(\pi\), expressed as
$$\pi(s) = \mathrm{ReLU}(W_K s_{FC} + b_K) \cdots \mathrm{ReLU}(W_1 s_{FC} + b_1)$$
where \(\pi_i\) represents the \(i\)-th component of the policy under current state \(s\), and there are \(K\) components in total. \(s_{FC}\) represents the input state of the output layer of the agent. \(W_i\) and \(b_i\) are parameters of the output layer. ReLU is a nonlinear activation function with range \([0,+\infty)\). I use \(\theta\) to denote the parameters of the agent. Then policy \(\pi_\theta\) indicates that the policy is determined by parameters \(\theta\). \(v_{\pi_\theta}(s)\) represents the true value function under policy \(\pi_\theta\). The loss of the agent can be simplified as
$$L_{agent} = \frac{1}{K}(v_{\pi_\theta}(s) – v_\pi(s))^2$$
where \(v_{\pi_\theta}(s)\) represents the actual return of the agent under state \(s\) and policy \(\pi_\theta\), and \(v_\pi(s)\) is the ideal return under the ideal policy. I use the Adam optimizer to optimize the agent parameters \(\theta\):
$$\theta \leftarrow \theta – \eta \, \mathrm{Adam}_d\left(\frac{\partial L_{agent}}{\partial \theta}\right)$$
where \(\eta\) is the learning rate, \(\partial L_{agent}/\partial \theta\) is the loss gradient, and \(\mathrm{Adam}_d(\cdot)\) denotes the Adam operation for first-order and second-order moments of the loss gradient.
Based on the above MDP theoretical framework, I use a three-layer MLP to build the NAS controller. The numbers of neurons in each layer are 32, 16, and 6. I use the ReLU activation function. The controller output corresponds to the probability distribution of network layer selection. The output dimension \(K\) is 6, corresponding to the network layers in the action space defined in Table 3. The core algorithm parameters and training operation parameters are specified in Table 3. The training process uses a greedy strategy. The controller randomly selects a network structure with the current greedy probability rather than directly executing the optimal decision output by the model. This ensures the diversity of controller training samples and avoids premature convergence to a local optimum. The greedy degree decays exponentially after each training round until it reaches the minimum greedy degree. The process gradually shifts from exploration to exploitation of the learned optimal search policy.
| Category | Parameter | Value |
|---|---|---|
| Core algorithm parameters | Discount rate \(\gamma\) | 0.9 |
| Core algorithm parameters | Learning rate \(\eta\) | 0.001 |
| Training operation parameters | Initial greedy degree | 1.0 |
| Training operation parameters | Greedy decay rate | 0.96 |
| Training operation parameters | Minimum greedy degree | 0.1 |
| Training operation parameters | Batch size | 32 |
| Training operation parameters | Training epochs | 200 |
The automatic creation method of neural networks based on NAS contains six cyclic steps. The state of a candidate model is a vector used to store the topology of the model. First, according to the candidate model state \(CM_t\) at time \(t\), the controller selects a network layer from the action space to create a new candidate model \(CM_{t+1}\). Then, I train and test \(CM_{t+1}\), and apply a weight sharing mechanism to accelerate computation. According to the comparison between the validation accuracy of \(CM_{t+1}\) and \(CM_t\), I determine the reward value \(R_{t+1}\). I save the model topology and the corresponding reward \((CM_{t+1}, R_{t+1})\) in replay memory. Next, I use the sub-controller to obtain the return value at time \(t+1\). Based on the return formula, I discount the return value at time \(t+1\) and accumulate it to the reward value at time \(t\). The stored (state, reward) becomes (state, return), thereby incorporating future returns of controller decisions. Finally, I use (state, return) to train the controller and continue decision-making according to the candidate model state.
The controller can choose limited actions defined in Table 4. A CNN for fault diagnosis does not need to be too complex. In addition, considering the requirement of search efficiency, I design an action space containing three convolutional layers, one max-pooling layer, one dropout layer, and one fully connected layer. The three convolutional layers differ in the number of filters and kernel size, providing the required decision freedom for the controller. The number of neurons in the fully connected layer is preset to 32. A small number of neurons can control the number of weights to be trained, thereby reducing the training time of candidate models.
| Type | Network layer hyperparameters | Parameter value | Symbol |
|---|---|---|---|
| Convolutional layer | (Number of filters, kernel size) / stride / activation | (21, 15) / 1 / ReLU | Conv(21,15) |
| Convolutional layer | (Number of filters, kernel size) / stride / activation | (35, 7) / 1 / ReLU | Conv(35,7) |
| Convolutional layer | (Number of filters, kernel size) / stride / activation | (35, 5) / 1 / ReLU | Conv(35,5) |
| Pooling layer | (Kernel size, stride) | (2, 2) | Maxp(2,2) |
| Dropout layer | Dropout rate | 0.5 | Dp |
| Fully connected layer | Number of neurons / activation | 32 / ReLU | Fc(32) |
At each time step in a search cycle, the controller selects one network layer from Table 4 and stacks it on \(CM_t\) to generate a new candidate model \(CM_{t+1}\). When searching for a network layer, I distinguish two cases. First, when the searched layer is Fc(32), a flatten layer is added before it to reduce the three-dimensional tensor to two dimensions. Then an output layer is added after Fc(32). The output layer is a fully connected layer whose number of neurons equals the number of classification labels. Second, when the last searched layer is not Fc(32), a flatten layer and an output layer are added to construct a complete candidate model.
The termination condition of each search cycle is that Fc(32) is searched, or the model depth reaches 10. The first condition considers two reasons. First, for different diagnosis tasks, the searched candidate models are usually different, especially in depth. Stopping the search process when the specified layer is searched allows the controller to autonomously determine the depth of the candidate model. Second, the fully connected layer contains the largest number of weight parameters. Multiple fully connected layers may significantly increase computational cost and even degrade the performance of the deep learning model. The second termination condition is to improve search efficiency.
At each time step of a search cycle, the created candidate model is trained and tested on training and validation data. This is the most time-consuming and computationally expensive part of the entire neural architecture search process. Further research shows that a network layer searched at time step \(t\) is reused at time step \(t+1\), but it is also retrained at time step \(t+1\), causing a waste of computational resources. To solve this problem, I propose a weight sharing mechanism. In this mechanism, layers reused across different candidate models share the same parameter weights during candidate model training.
The number of weights of a network layer depends on its hyperparameters and the size of the input tensor. In the action space, for a convolutional layer with \(f\) filters and kernel size \(k\), given an input tensor of shape \((x,y,z)\), the number of weights of the convolutional layer is \(N_{conv}\). For a fully connected layer with \(n\) neurons, the number of weights is \(N_{Fc}\), expressed as
$$N_{conv} = (k z + 1) f$$
$$N_{Fc} = (z + 1) n$$
Parameter weights are inherited and reused by retrieving and matching network layer names. Factors that affect the number of weights need to be considered. Network layer names include three factors: network layer type, hyperparameters, and input tensor dimension. Therefore, the naming format of a network layer is “LayerType_Hyperparameters_InputDimension”. For example, for Conv(21,15), assuming its input tensor size is (32, 1600, 1), the layer is named “Conv_(21, 25)_1”, where “Conv” indicates a convolutional layer, (21, 25) indicates 21 filters and kernel size 25, and “1” is the last dimension of the input tensor.
Named network layers are aggregated to form a layer pool. After a candidate model is created, retrieval in the layer pool is automatically triggered, and the weight values of the network layer in the layer pool are copied to the layer with the same name in the created model. Based on the AE architecture, I use the candidate network created by the NAS method to build the robot operation anomaly detection model. The AE network uses unsupervised learning and does not require explicit labeling of each operation state. During training, it can automatically cluster and mine feature representations of different states. The automatically created anomaly detection AE model architecture is used as follows. During training, only some known state samples are used. By minimizing the reconstruction distortion loss of the decoder, the extracted features can effectively represent the operation state of the industrial robot and amplify the feature difference between abnormal and normal states. The reconstruction error is used to optimize the feature extraction ability of the autoencoder and is not directly used as the basis for anomaly judgment. After training, based on the output of the encoder, I use the K-means clustering algorithm for state identification. First, I use feature vectors of all labeled states to train corresponding cluster centers. For any new input sample, including unknown state samples, I calculate its Euclidean distance to known cluster centers, automatically assign it to the nearest cluster center, and determine the sample operation state according to the state label corresponding to that cluster center. This design does not require manual threshold setting. It is entirely based on data-driven feature similarity and can automatically classify unknown states into the known state closest to their features, thereby determining whether the industrial robot operation is abnormal.
Maintenance Strategy Reasoning Based on Entity Similarity
Knowledge reasoning is an effective means to overcome the poor flexibility and adaptability of static knowledge graphs. To effectively use entity similarity in the reasoning process, it is necessary to encode entity attributes and relationships. I first evaluate the similarity between entities according to the graph entity attributes shown in Table 1. I digitize the main attributes of entities and represent them as vectors. Considering subsequent entity expansion, I encode entity type and name separately, reserve expansion dimensions, and concatenate them with attribute encoding to form the final entity encoding vector. Through this encoding method, I integrate the type, name, and attribute information of an entity into one vector, reflecting the similarity between entities. I use cosine similarity to evaluate the similarity of entity vectors. Its value range is \((-1,1)\). A larger value indicates that two vectors are more similar, and a smaller value indicates that they are less similar. The calculation formula is
$$S_{cos}(x,y) = \frac{x \cdot y}{\|x\| \|y\|}$$
where \(x\) and \(y\) are the two vectors to be compared, and \(\|\cdot\|\) denotes the norm of a vector.
Relationship similarity measurement is achieved by evaluating the position of entities in the knowledge graph and their connection relationships. Specifically, I measure the relationship similarity between entities by calculating the attribute similarity of same-type neighbor entities between entities. The formulas for calculating attribute similarity and relationship similarity between two entities are
$$S_{prop}(A,B) = S_{cos}(a,b)$$
$$S_{rela}(A,B) = \frac{1}{N}\sum_{i=1}^{N} S_{cos}(a_i,b_i)$$
$$S(A,B) = S_{prop}(A,B) + S_{rela}(A,B)$$
where \(a\) and \(b\) represent the encoding vectors of entities \(A\) and \(B\). \(a_i\) and \(b_i\) represent the same-type neighbor vectors of entities \(A\) and \(B\), respectively. There are \(N\) pairs of same-type neighbors. A larger value of \(S(A,B)\) indicates higher similarity between the two entities in the knowledge graph. When \(N=0\), the two entities have no same-type neighbor entities. At this time, the relationship similarity is 0, and the total similarity is determined only by the attribute similarity of the entities themselves.
Taking fault entities as an example, I describe the encoding process. The attributes of fault entities are shown in Table 5. Fault types include mechanical, electrical, and software. Influence scope is divided into mechanical part, electrical system, control system, and sensing system. Fault severity is divided into slight, medium, and severe. The related explanations are given in Table 5.
| Attribute | Value | Description |
|---|---|---|
| Fault type | Mechanical | A mechanical fault involves physical parts or motion mechanisms of the machine and usually affects motion accuracy, stability, or structural integrity. |
| Fault type | Electrical | An electrical fault involves electrical systems and components of the machine and may cause interruption of power supply or problems in electrical signal transmission. |
| Fault type | Software | A software fault involves program or algorithm errors in the control system and may affect computing, control, and decision-making capabilities. |
| Influence scope | Mechanical part | The fault affects the mechanical body and related components and may cause operation interruption or system instability. |
| Influence scope | Electrical system | The fault affects the electrical control system and its components and may prevent the system from operating normally or cause loss of control. |
| Influence scope | Control system | The fault affects control and computing functions and may prevent the system from correctly executing tasks. |
| Influence scope | Sensing system | The fault affects sensors and encoders and may cause inaccurate data or prevent the system from correctly perceiving the environment. |
| Severity | Slight | The fault has limited impact on system function and usually does not cause system shutdown or significant performance degradation. |
| Severity | Medium | The fault has obvious impact on system performance, may partially limit functions, and requires timely repair to avoid further problems. |
| Severity | Severe | The fault has a major impact on core functions, may cause complete shutdown or serious damage, and requires immediate repair. |
I use one-hot encoding. First, I encode the category and name of an entity. Then I encode the fault type, influence scope, and fault severity attributes. Finally, I concatenate them. The entity category includes eight types, such as part, component, fault, and so on. The entity name is unique and consistent with the number of entities. Considering reserved expansion space, I set 10 dimensions for entity type, 100 dimensions for entity name, and 50 dimensions for fault attributes. Table 6 shows the attributes of some fault entities and their encoding information. The encoding vector adopts a sparse encoding form. Five 1 values in the vector correspond to entity category, name, fault type, influence scope, and fault severity, respectively. Using \(S_{prop}\), I can well calculate the attribute similarity and relationship similarity of two entity vectors, thereby providing a basis for knowledge reasoning.
| Fault name | Fault type | Influence scope | Severity | Encoding |
|---|---|---|---|---|
| Coupling looseness | Mechanical | Mechanical part | Slight | (0,1) 1.0; (0,59) 1.0; (0,110) 1.0; (0,116) 1.0; (0,121) 1.0 |
| Power supply problem | Electrical | Electrical system | Severe | (0,1) 1.0; (0,50) 1.0; (0,112) 1.0; (0,117) 1.0; (0,119) 1.0 |
| Communication line fault | Electrical | Control system | Medium | (0,1) 1.0; (0,69) 1.0; (0,112) 1.0; (0,115) 1.0; (0,120) 1.0 |
| Processor crash | Software | Control system | Severe | (0,1) 1.0; (0,27) 1.0; (0,113) 1.0; (0,115) 1.0; (0,119) 1.0 |
| Encoder calibration anomaly | Mechanical | Sensing system | Slight | (0,1) 1.0; (0,56) 1.0; (0,110) 1.0; (0,114) 1.0; (0,121) 1.0 |
I introduce the reasoning network from three aspects: architecture construction, sample production, and loss function design. The knowledge reasoning network adopts a dual-input structure. It inputs a subject entity and a relation and outputs an object entity. For example, inputting a fault entity and a “corresponds to” relation yields a part entity. Inputting a cause entity and a “causes” relation yields a fault entity. The input entity vector and relation vector are embedded and concatenated into a tensor. Then multiple fully connected network layers map the association and learn potential semantic connections between entities. Finally, an object entity vector is output. It can be considered that this knowledge reasoning network is the relation mapping function \(f_\theta\) of the knowledge graph. According to the input subject \(s_i\) and relation \(r_i\), the object \(o_i\) can be obtained:
$$o_i = f_\theta(s_i, r_i)$$
To obtain \(f_\theta\) that can comprehensively represent the knowledge graph, the production of network model training samples is key. For this purpose, I create three types of training samples: graph samples, reasoning samples, and negative samples. Graph sample \(KG\) is the \((s,r,o)\) triple sampled from the knowledge graph association relationships. According to the ontology structure of the knowledge graph, in addition to forward associated triples, I also create reverse associated triples \((o,r^{-1},s)\). This considers actual application requirements. For example, for the triple (“cause”, “causes”, “fault”), the corresponding reverse triple is (“fault”, “caused by”, “cause”). In this way, whether an entity or an object in the triple is obtained, the association relationship can be completely derived. Therefore, when creating samples, I expand the seven types of relationships in the knowledge graph to fourteen types.
Reasoning sample \(PR\) is a reasonable inference based on entity similarity, forming a relation reasoning triple from similar entities. For example, for a triple \((s,r,o)\) sampled from \(KG\), I calculate the similarity of same-type entities of object \(o\), take the most similar entity \(o_p\), and create a reasoning triple \((s,r,o_p)\). According to a negative sampling strategy, I create negative sample \(NS\). Also based on the triple \((s,r,o)\), I randomly select an entity \(o_n\) from same-type entities of object \(o\), ensuring that \(o_n\) is different from \(o_p\), and create a negative triple \((s,r,o_n)\). Finally, I obtain a training sample set for the reasoning network consisting of graph samples \(KG\), reasoning samples \(PR\), and negative samples \(NS\).
If the knowledge graph is understood as a circle, then accurately predicting \(o\) from \(s\) and \(r\) means satisfying the constraint of this circle, that is, the existing association relationship constraint of the knowledge graph. Inferring \(o_p\) from \(s\) and \(r\) means that it is within the scope of this circle, which is a reasonable inference. Inferring \(o_n\) from \(s\) and \(r\) means that it is outside the circle, which is an unreasonable inference. The existence of negative samples is valuable because it helps the knowledge reasoning network clarify the boundary between reasonable and unreasonable relationships and ensures the effect of knowledge reasoning.
For these three types of samples, I design the following loss functions. The loss for graph samples is the boundary constraint loss \(J_{BC}(\theta)\). The loss for reasoning samples is the internal constraint loss \(J_{IC}(\theta)\). The loss for negative samples is the external constraint loss \(J_{EC}(\theta)\).
$$J_{BC}(\theta) = \frac{1}{N_u}\sum_{u=1}^{N_u}\sum_{(s,r,o)\in KG} \|f_\theta(s,r)-o\|^2$$
$$J_{IC}(\theta) = \frac{1}{N_g}\sum_{g=1}^{N_g}\sum_{(s,r,o)\in PR}\left(1 – \frac{f_\theta(s,r)\cdot o}{\|f_\theta(s,r)\|\|o\|}\right)$$
$$J_{EC}(\theta) = \frac{1}{N_e}\sum_{e=1}^{N_e}\sum_{(s,r,o)\in NS}\left(1 + \frac{f_\theta(s,r)\cdot o}{\|f_\theta(s,r)\|\|o\|}\right)$$
where \(N_u\), \(N_g\), and \(N_e\) are the numbers of the three types of samples. The boundary constraint loss is a root mean square error. The internal and external constraint losses are variants of cosine similarity with value range \((-1,1)\). A smaller internal constraint loss indicates that the knowledge reasoning network has a better grasp of reasoning samples. A smaller external constraint loss indicates that the knowledge reasoning network has a poorer grasp of negative samples and has strong knowledge discrimination ability. That is, the reasoning network can well avoid the unreasonableness reflected by negative samples.
I use the weighted sum of the above three loss functions as the total loss function to guide reasoning network training. The weight parameters of the reasoning network are automatically learned by minimizing the total loss function. The structure and volume of the knowledge graph do not impose computational pressure on the neural network model. The reasoning performance mainly depends on graph sample construction and similarity measurement methods, not on fine tuning of loss coefficients. Through parameter sensitivity analysis, I verify that model accuracy is insensitive to coefficient changes and maintains stable and good performance over a wide range. I finally determine the loss coefficients as 0.4, 0.3, and 0.3 to balance the training needs of the three types of samples.
$$J_{total} = 0.4 J_{BC}(\theta) + 0.3 J_{IC}(\theta) + 0.3 J_{EC}(\theta)$$
Case Verification for Industrial Robot Machining
I conduct state monitoring for an industrial robot machining operation. The hardware arrangement includes an industrial robot performing milling of a hanging blank, a data acquisition card, and a monitoring computer. I install three-axis acceleration sensors at robot joints and the end-effector spindle. I also use a surface roughness tester to detect the surface quality of the hanging part. In addition to hardware wear, process programs and software problems are also important factors affecting the operation state of industrial robots and their machining quality. This is clearly reflected in the constructed maintenance knowledge graph. Injecting hardware faults into industrial robots is uneconomical and unrealistic. Therefore, I change the process parameters, process types, machining materials, and pose configurations of the industrial robot to induce abnormal machining states. I acquire relevant operation signals to verify the effectiveness of the proposed method in detecting abnormal operation of industrial robots.
The stainless steel support foot bottom surface, side surface, aluminum alloy hanging side surface, and side hole have precision requirements of Ra3.2 and Ra6.3. I design process parameters for these four machining processes, as shown in Table 7.
| Service state | Spindle speed / (r/min) | Feed speed / (mm/s) | Cutting depth / mm | Operation description | Surface quality |
|---|---|---|---|---|---|
| State 1 | 3000 | 5 | 0.1 | Milling side surface of hanging part | Qualified |
| State 2 | 3000 | 5 | 0.5 | Milling side surface of hanging part | Unqualified |
| State 3 | 3000 | 5 | 0.1 | Milling side hole of hanging part | Qualified |
| State 4 | 3000 | 5 | 0.5 | Milling side hole of hanging part | Unqualified |
| State 5 | 1500 | 3 | 0.1 | Milling bottom surface of support foot | Qualified |
| State 6 | 1500 | 3 | 0.5 | Milling bottom surface of support foot | Unqualified |
| State 7 | 1500 | 3 | 0.1 | Milling side surface of support foot | Qualified |
| State 8 | 1500 | 3 | 0.5 | Milling side surface of support foot | Unqualified |
In actual application scenarios, normal machining states of industrial robots are limited, while abnormal machining states are infinite. According to the process parameter settings in Table 7, the industrial robot exhibits eight service states. Under each state, I use a roughness tester to detect the final machined surface quality. According to whether the surface quality meets the precision requirement, I judge whether the operation state of the industrial robot is abnormal. After detection, states 1, 3, 5, and 7 are normal states, and states 2, 4, 6, and 8 are abnormal states. Using these eight typical states as references, I can effectively detect abnormal conditions of the industrial robot machining state.
Automatic Detection of Industrial Robot Operation Anomalies
The process parameters used in states 1, 3, 5, and 7 are exactly the parameter configurations actually used by the industrial robot. In contrast, the machining quality of the industrial robot under states 2, 4, 6, and 8 is unqualified. The root cause is that different process parameter settings are used in these states, which leads to significant differences in the service state of the industrial robot. Further analysis shows that the difference between states 1 and 2 and states 3 and 4 mainly comes from two different process types: surface milling and hole milling. The difference between the first four states and the last four states is caused by different blank materials. In addition, the difference between states 5 and 6 and states 7 and 8 is caused by changes in the pose and configuration of the industrial robot during machining. I emphasize that this study is not intended to deeply explore the complex relationship between process parameters and the service state of industrial robots. Therefore, I do not carry out detailed differential design of process parameters. In fact, whether it is a change in process parameters, a difference in process type, or an adjustment of robot pose and configuration, as long as these factors cause abnormal vibration of the industrial robot, they will directly affect the final machining quality. Therefore, it is necessary to perform anomaly detection. This experiment is based on this consideration and aims to verify the effectiveness of the proposed method. Although the process parameter settings are not detailed, the number of different states is sufficiently comprehensive and covers most typical scenarios of industrial robot machining. This is enough to prove that once an abnormality occurs in the operation of an industrial robot, it can be effectively detected, thereby ensuring the stability and reliability of machining quality.
Preliminary test results show that the vibration signal collected by the sensor at the sixth joint, that is, the flange of the industrial robot, can best represent the vibration state of the industrial robot. Using the J-x dimensional data to train the anomaly detection AE model can achieve higher accuracy. In subsequent monitoring of industrial robot machining, I only retain the sensor at the flange, which can also reduce the impact on industrial robot machining. The sensor sampling frequency is 51.2 kHz. I downsample the vibration signal with a step of 1000. I take 6400 data points as one sample. The number of samples in each state is 60. I divide training data and test data by 4:1 and begin to automatically create the industrial robot operation anomaly detection model. I use UMAP high-dimensional data dimensionality reduction technology to reduce the encoder detection results to three dimensions for visual analysis of different state features and display them in scatter plots.
The experimental environment is built on a workstation equipped with an Intel Ultra 9 285K processor, 96 GB memory, and an NVIDIA GeForce RTX 5090 D graphics card. The automatic creation process of the industrial robot operation anomaly detection model is visualized as follows. The NAS controller reward value and the test accuracy of the corresponding created candidate model are recorded. As the controller reward value increases, the accuracy of the candidate model also increases, from 0.13 in stage 1 to 1.0 in stage 4. The final process takes about 1200 s to reach the highest accuracy. In the sample dimensionality reduction visualization scatter plots, the distance between points represents similarity. Numbers correspond to industrial robot operation states. Green sample points are normal states, and red sample points are abnormal states. In stage 1, the model cannot distinguish samples of different states at all. As the accuracy of the candidate model improves, the models in stages 2, 3, and 4 gradually gather sample points of the same state and separate sample points of different states. This fully demonstrates the clustering performance of the AE model.
I use test data to verify the anomaly detection model. The verification results show that the AE model achieves 100% accuracy for known states 1 to 8. To further verify the detection performance of the AE model for unknown states, I adjust the process parameters for milling the bottom surface of the support foot to a spindle speed of 1500 r/min, a feed speed of 3 mm/s, and a cutting depth of 0.6 mm. I simulate a new abnormal state 9 and acquire its operation signal. I mix the operation signal of state 9 with the other eight signals and input them into the AE model for clustering diagnosis. The verification results show that the AE model identifies state 9 as state 6. The visualization results also show that state 9 sample points are clustered together and closely approach abnormal state 6 sample points. This indicates that the AE model judges the unknown state 9 as state 6, which belongs to an abnormal state.
The above experimental results show that the NAS-AE anomaly detection method I propose can effectively identify operation anomalies of industrial robots under different processes, materials, and poses. The detection accuracy for eight typical states reaches 100%, and it can accurately identify unknown state 9. Compared with traditional manually designed neural network methods, the NAS technology I adopt does not rely on expert experience for network structure tuning. Through the weight sharing mechanism, it realizes efficient automatic model creation and can quickly adapt to anomaly detection requirements of different industrial robot models and working conditions. It provides reliable automatic anomaly detection capability for the perception side of the knowledge graph.
Similarity Reasoning for Industrial Robot Maintenance Strategies
After the graph perception side detects an abnormal operation of the industrial robot, I describe and encode the abnormal vibration phenomenon based on the content introduced in the entity similarity encoding section, as shown in Table 8.
| Abnormal phenomenon | Category | Anomaly type | Influence scope | Encoding | Similarity |
|---|---|---|---|---|---|
| Abnormal vibration during industrial robot machining | Performance degradation problem | Performance degradation problem | End-effector | (0,3) 1.0; (0,81) 1.0; (0,110) 1.0; (0,116) 1.0; (0,129) 1.0 | 1.0 |
| Abnormal vibration during industrial robot machining, affecting surface precision | Performance degradation problem | Performance degradation problem | End-effector | (0,3) 1.0; (0,48) 1.0; (0,110) 1.0; (0,116) 1.0; (0,129) 1.0 | 0.80 |
| Abnormal vibration during industrial robot machining, affecting machining quality | Performance degradation problem | Performance degradation problem | End-effector | (0,3) 1.0; (0,47) 1.0; (0,110) 1.0; (0,116) 1.0; (0,129) 1.0 | 0.80 |
| Abnormal vibration and noise during industrial robot machining, affecting machining precision and stability | Performance degradation problem | Performance degradation problem | End-effector | (0,3) 1.0; (0,37) 1.0; (0,110) 1.0; (0,116) 1.0; (0,129) 1.0 | 0.80 |
First, this is a phenomenon entity, so the encoding at position (0,3) is 1. Second, the description of the abnormal phenomenon is “abnormal vibration during industrial robot machining.” This is a new description that does not exist in the existing knowledge graph. Therefore, the encoding at the reserved position (0,81) for phenomenon description is 1. The detected abnormal vibration of the industrial robot affects its machining precision. This is a phenomenon that causes performance degradation, so the encodings at (0,110) and (0,116) are 1. Finally, this abnormal vibration is monitored by the sensor at the flange, indicating that the directly affected part is the end-effector of the industrial robot. Therefore, the encoding at (0,129) is 1. The first row in Table 8 is the phenomenon encoding of the detected anomaly. The last three rows are the most similar phenomena to this anomaly. Except for the description, the category, anomaly type, and influence scope are the same.
The decision-side algorithm performs possible fault reasoning based on the phenomenon encoding of the detected anomaly and generates corresponding maintenance strategies for the inferred faults. It covers key decision elements required for operation and maintenance, including the component to which the fault belongs, the cause of the fault, and its maintenance method, as shown in Table 9. Maintenance methods include three common maintenance measures: maintenance, spare part replacement, and debugging optimization. They cover the main maintenance modes in typical scenarios, indicating that the knowledge in the knowledge graph is comprehensive and sufficient. The last column in Table 9 is the similarity of the inferred fault. The first three inferred faults with similarity 1 exactly correspond to the three most similar fault phenomena in Table 8. The most similar maintenance strategies generated for these three faults are as follows. The first fault inference of unreasonable process parameter design conforms to the fault setting shown in Table 7. The fault cause explanation and maintenance method introduction are also consistent with actual conditions and are operable.
| Subsystem | Component | Part | Fault | Cause | Phenomenon | Method | Similarity |
|---|---|---|---|---|---|---|---|
| Control system | Motion controller | Control program | Process program problem | Unreasonable process parameter design | Abnormal vibration during industrial robot machining, affecting surface precision | Redesign and debug the process program, optimize process parameters (debugging optimization) | 1.0 |
| Mechanical body | End-effector | Tool head | Milling tool wear | Long-term use, mechanical impact, or improper operation causing tool wear | Abnormal vibration during industrial robot machining, affecting machining quality | Replace the worn tool (spare part replacement) | 1.0 |
| Mechanical body | End-effector | Tool head | Tool head connection looseness | Vibration, improper installation torque, material fatigue, or excessive use time | Abnormal vibration and noise during industrial robot machining, affecting machining precision and stability | Regularly check the connection state of the tool head to ensure bolts and interfaces are firmly connected (maintenance) | 1.0 |
| Mechanical body | Connecting rod | Connecting bolt | Bolt looseness | Vibration, impact, improper installation, or excessive use time | Vibration and noise during industrial robot motion, reduced precision | Regularly check the tightening state of bolts and replace bolts as needed (maintenance) | 0.71 |
| Mechanical body | Joint | Rotating bearing | Joint bearing looseness | Bearing seat partially loose, bolt loose, or improper clearance between bearing inner ring and outer raceway | Abnormal joint vibration and noise, affecting precision and stability of the industrial robot | Regularly check the tightening state of the bearing seat and bolts, and replace loose bearings as needed (maintenance) | 0.71 |
| Drive system | Reducer | Reducer transmission gear | Reducer gear wear | Long-term use, overload, insufficient lubrication, etc. | Unstable motion of the industrial robot, noise, reduced motion precision | Replace damaged gears, improve lubrication conditions, and reduce overload operation (spare part replacement) | 0.71 |
| Drive system | Motor | Mechanical transmission system | Bearing fault | Bearing damage, insufficient lubrication | Abnormal vibration during industrial robot motion, causing unstable transmission and reduced precision | Replace damaged bearings and ensure good lubrication (spare part replacement) | 0.71 |
From the experimental results in Table 9, the knowledge reasoning network based on entity similarity that I propose can accurately identify known faults and generate corresponding maintenance strategies. It can also provide reasonable reference schemes based on similarity for unknown faults. The core advantage of this reasoning network lies in the dual similarity encoding of entity attributes and relationships in the knowledge graph, as well as the comprehensive loss function designed for maintenance scenarios. In addition, the volume of the maintenance knowledge graph I construct does not pose a computational challenge to the neural network model. Therefore, through reasonable sample construction and similarity measurement design, I can obtain reasoning performance that meets field requirements and provide effective strategy generation capability for the decision side of the knowledge graph.
Integrated Intelligent Operation and Maintenance Workflow
Based on the above experimental verification, the enhanced knowledge graph I construct has fully realized the intelligent operation and maintenance function of integrated perception, reasoning, and decision-making. The overall operation process forms a complete intelligent operation and maintenance closed loop with six core steps. First, monitoring hardware deployed at the joints of industrial robots collects multi-dimensional operation signals in real time, providing raw data support for subsequent analysis. Second, the NAS-AE model I propose performs feature extraction and state classification on the operation signals, automatically identifies operation anomalies, and completes anomaly detection on the perception side. Third, the abnormal state encoding is input into the knowledge graph reasoning model. Based on entity similarity, the model retrieves the most similar fault entities and generates targeted maintenance strategies to push to maintenance personnel. Fourth, during the execution of the strategy by maintenance personnel, the system automatically records the maintenance process and performs maintenance statistical analysis. Finally, new fault cases, processing results, and maintenance knowledge are updated into the knowledge graph, including entity and attribute updates and ontology structure adjustment, realizing continuous knowledge accumulation and system iterative optimization.
The system realizes full-process automation from operation state perception to maintenance strategy generation and then to maintenance knowledge iteration. It effectively improves the maintenance efficiency and intelligence level of industrial robots. In my view, the enhanced knowledge graph is not merely a static repository. It is a perception-reasoning-decision engine for industrial robots. The automatic anomaly detection model provides the graph with the ability to sense unknown abnormal states. The similarity reasoning network provides the graph with the ability to infer maintenance strategies for new fault phenomena. The software system closes the loop between field data, maintenance actions, and knowledge updates. Therefore, the proposed method offers a practical and scalable path toward intelligent operation and maintenance of industrial robots.
Conclusions
I propose an intelligent operation and maintenance method for industrial robots based on an enhanced knowledge graph. It can quickly identify abnormal states of industrial robots and intelligently generate maintenance strategies. Using an operation and maintenance case in which incorrect process parameter settings caused abnormal motion of an industrial robot, I verify the comprehensiveness of the maintenance knowledge graph and the engineering effectiveness of the proposed method. The following conclusions can be drawn. First, for the diverse and complex fault modes of industrial robots, ontology modeling systematically integrates engineering maintenance experience and general maintenance knowledge to construct a comprehensive maintenance knowledge base. Second, similarity encoding is performed on graph entities and their attributes, and a knowledge reasoning network based on entity similarity is designed. It can adapt to unknown fault scenarios and effectively overcome the poor adaptability of static graphs. Third, anomaly detection and maintenance strategy generation algorithms are embedded into the perception side and decision side of the knowledge graph to build an end-to-end intelligent maintenance method. It improves the automation and intelligence level of industrial robot maintenance. The method can be extended to different industrial robots, machining processes, and working conditions, and it provides a useful foundation for future intelligent maintenance systems.