In my work, I focus on the intelligent operation and maintenance of industrial robots. Industrial robots are complex electromechanical systems with multiple degrees of freedom, and their key components, such as reducers, servo motors, and controllers, inevitably degrade or fail in long-term industrial environments. Traditional periodic maintenance and reactive repair strategies are no longer sufficient for high-reliability, low-downtime production. Therefore, I propose an enhanced knowledge graph framework that integrates automatic anomaly detection and maintenance strategy reasoning for industrial robots. The framework embeds data-driven anomaly detection into the perception side of a knowledge graph and introduces entity-similarity-based reasoning into the decision side, enabling an end-to-end perception–reasoning–decision loop.
The main contributions of my work are threefold. First, I construct a fault-centric ontology model for an industrial robot maintenance knowledge graph, systematically integrating robot structure, fault phenomena, causes, and maintenance methods. Second, I design an automatic anomaly detection model based on neural architecture search (NAS) and an autoencoder (AE), achieving end-to-end unsupervised anomaly identification for industrial robot vibration signals. Third, I propose a knowledge reasoning network based on entity similarity, allowing the system to infer maintenance strategies for unknown faults. Based on these methods, I develop a complete intelligent operation and maintenance software system for industrial robots.
Problem Formulation and Notation
Let an industrial robot be represented as a hierarchical system. The system consists of subsystems, components, and parts. I denote the set of parts as \(P\), the set of faults as \(F\), the set of fault phenomena as \(X\), the set of causes as \(C\), and the set of maintenance methods as \(M\). The maintenance knowledge graph is a collection of triples:
$$
\mathcal{G} = \{(s, r, o) \mid s \in \mathcal{E}, r \in \mathcal{R}, o \in \mathcal{E}\}
$$
where \(\mathcal{E}\) is the entity set and \(\mathcal{R}\) is the relation set. In my ontology, the core relations include composition, belonging, correspondence, manifestation, causation, and solution. The anomaly detection task is to map a raw vibration signal \(x \in \mathbb{R}^{L}\) to a state label \(y \in \{1, \dots, K\}\), where \(K\) is the number of known states. The reasoning task is to predict the object entity \(o\) given a subject entity \(s\) and a relation \(r\):
$$
f_\theta: (s, r) \mapsto o
$$
where \(f_\theta\) is a neural network parameterized by \(\theta\). The overall goal is to detect abnormal states of an industrial robot and generate targeted maintenance strategies for both known and unknown faults.
Ontology Modeling for Industrial Robot Maintenance
An industrial robot can be divided into four main subsystems: mechanical body, control system, drive system, and perception system. Because electrical faults in the control cabinet are frequent, I treat the control cabinet as an independent subsystem. Each subsystem contains multiple components, and each component contains multiple parts. For example, the drive system includes servo motors and reducers; the mechanical body includes tool flanges and end effectors. This multi-level structure enables fine-grained fault localization, but it also increases the complexity of fault management.
The fault modes of an industrial robot are diverse, while the observable fault phenomena at the machine level are relatively limited. This many-to-one mapping between fault causes and machine-level symptoms makes fault diagnosis difficult. To address this, I adopt a fault-centric top-down ontology modeling approach. I first build the top-level ontology and then refine concepts, attributes, and relations. The resulting ontology is shown in the following table.
| Entity | Attributes | Description |
|---|---|---|
| Equipment | Name, type, code | The industrial robot being maintained |
| Subsystem | Name, type (control, drive, etc.), code | A major functional subsystem of the industrial robot |
| Component | Name, type (motor, reducer, etc.), code | A functional unit inside a subsystem |
| Part | Name, type (support, fastening, transmission, etc.), function, material, code | A physical part of a component |
| Fault | Name, type (mechanical, electrical, software), scope, severity, code | A fault that may occur in the industrial robot |
| Cause | Name, type (mechanical, electrical, software), code | The cause that leads to a fault |
| Phenomenon | Description, category (fault, performance), type, influence scope, code | An observable symptom of a fault |
| Method | Description, category (maintenance, replacement, optimization), code | A maintenance action for solving a fault |
The ontology has two key characteristics. First, it uses a four-layer structure: equipment, subsystem, component, and part. This structure matches the mechanical and electrical composition of an industrial robot and supports fine-grained fault localization from the whole machine to individual parts. Second, it is fault-centric. The fault, phenomenon, cause, and method entities are mapped in a one-to-one manner, avoiding ambiguous many-to-many mappings. This design helps quickly locate the fault cause and generate a solution, improving the maintenance efficiency of the industrial robot.
Based on the ontology, I construct the maintenance knowledge graph. The knowledge is collected from maintenance manuals, expert knowledge, literature, and field experience. I divide the knowledge into general maintenance knowledge and specialized maintenance knowledge. The knowledge is standardized to ensure consistency and accuracy. The constructed 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. The specialized maintenance knowledge for a specific industrial robot accounts for about one third of the graph. Because electrical faults in the control cabinet are more frequent than mechanical faults, the control cabinet is treated as an independent subsystem and accounts for about 14.3% of the graph.
The graph is stored in a relational database as triples. I also develop a software system with functions for knowledge retrieval, maintenance question answering, graph maintenance, and graph updating. Users can input keywords related to a fault or phenomenon and quickly locate relevant nodes in the knowledge graph. The system returns possible causes and maintenance solutions. Users can also add, delete, modify, and query entities and relations in real time. This software system provides a foundation for embedding anomaly detection and reasoning capabilities into the knowledge graph.
Anomaly Detection with NAS and Autoencoder
Automatic anomaly detection for an industrial robot can be achieved by monitoring operational data such as sensor signals, control signals, and process parameters. In my work, I focus on motion anomalies because slight vibrations are difficult to observe but directly affect machining quality. I deploy accelerometers on the joints and end effector of the industrial robot to collect vibration signals. To create an effective anomaly detection algorithm, I consider three factors: detection efficiency, detection accuracy, and detection performance for unknown states.
To address these factors, I design the anomaly detection method as follows. First, I use a deep learning model to achieve end-to-end detection without separate feature extraction. Second, I apply NAS to automatically create the neural network, reducing dependence on expert knowledge. Third, I adopt an autoencoder architecture, which learns the distribution of normal vibration signals and produces large reconstruction errors for unknown abnormal states.
Markov Decision Process Formulation
NAS can be formulated as a finite Markov decision process (MDP). The MDP consists of an agent and an environment. The agent selects actions, and the environment returns new states and rewards. A finite MDP has finite sets of states \(S\), actions \(A\), and rewards \(R\). The random variables \(R_t\) and \(S_t\) have discrete probability distributions that satisfy the Markov property. The transition probability is:
$$
P(s’, r \mid s, a) = \Pr\{S_{t+1}=s’, R_{t+1}=r \mid S_t=s, A_t=a\}
$$
The state transition probability is:
$$
p(s’ \mid s, a) = \Pr\{S_{t+1}=s’ \mid S_t=s, A_t=a\} = \sum_{r \in R} p(s’, r \mid s, a)
$$
The expected reward for a state–action pair is:
$$
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 \mid s, a)
$$
The return is the sum of discounted rewards:
$$
G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots = \sum_{k=0}^{T-t-1} \gamma^k R_{t+k+1}
$$
where \(\gamma \in [0,1]\) is the discount rate. The value function under policy \(\pi\) is:
$$
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]
$$
The Bellman equation for the value function is:
$$
v_\pi(s) = \sum_a \pi(a \mid s) \sum_{s’, r} p(s’, r \mid s, a) [r + \gamma v_\pi(s’)]
$$
In my method, the agent is implemented by a neural network. The policy output is:
$$
\pi = \begin{bmatrix}
\pi_1 \\
\vdots \\
\pi_K
\end{bmatrix}
=
\begin{bmatrix}
\mathrm{ReLU}(W_1 s_{FC} + b_1) \\
\vdots \\
\mathrm{ReLU}(W_K s_{FC} + b_K)
\end{bmatrix}
$$
where \(s_{FC}\) is the input state, \(W_i\) and \(b_i\) are parameters, and \(K\) is the number of output components. The agent loss is:
$$
L_{agent} = \frac{1}{K} \sum_{i=1}^{K} \left( v_\pi(s) – v_{\pi_\theta}(s) \right)^2
$$
The parameters are optimized by Adam:
$$
\theta \leftarrow \theta – \delta \cdot \mathrm{Adam}\left(\nabla_\theta L_{agent}\right)
$$
where \(\delta\) is the learning rate. I use a three-layer multilayer perceptron (MLP) as the NAS controller. The numbers of neurons are 32, 16, and 6. The activation function is ReLU. The controller outputs a probability distribution over network layers. The core algorithm parameters and training parameters are listed in the table below.
| Category | Parameter | Value |
|---|---|---|
| Core algorithm | Discount rate \(\gamma\) | 0.9 |
| Core algorithm | Learning rate \(\delta\) | 0.001 |
| Training | Initial greediness | 1.0 |
| Training | Greediness decay rate | 0.96 |
| Training | Minimum greediness | 0.1 |
| Training | Batch size | 32 |
| Training | Epochs | 200 |
Action Space and Candidate Model State
The NAS controller selects layers from a predefined action space. The action space contains three convolutional layers, one max-pooling layer, one dropout layer, and one fully connected layer. The details are given below. The action space is designed to be compact because the CNN for fault diagnosis does not need to be very complex. The three convolutional layers differ in filter number and kernel size, providing decision freedom for the controller. The fully connected layer has 32 neurons, which controls the number of weights and reduces training time.
| Type | Layer hyperparameters | Parameter values | Symbol |
|---|---|---|---|
| Convolutional layer | (Filter number, kernel size) / stride / activation | (21, 15) / 1 / ReLU | Conv(21,15) |
| Convolutional layer | (Filter number, kernel size) / stride / activation | (35, 7) / 1 / ReLU | Conv(35,7) |
| Convolutional layer | (Filter number, 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 | Neuron number / activation | 32 / ReLU | Fc(32) |
At each time step, the controller selects one layer and stacks it on the candidate model \(CM_t\) to generate \(CM_{t+1}\). When the selected layer is Fc(32), a flatten layer is added before it, and an output layer is added after it. The output layer is a fully connected layer whose neuron number equals the number of class labels. If the last searched layer is not Fc(32), a flatten layer and an output layer are added to complete the candidate model. The search process terminates when Fc(32) is selected or when the model depth reaches 10. The first condition allows the controller to determine the depth of the candidate model. The second condition improves search efficiency.
Weight Sharing Mechanism
Training each candidate model from scratch is computationally expensive. To solve this problem, I introduce a weight sharing mechanism. Layers that are reused across candidate models share the same parameters. For a convolutional layer with filter number \(f\), kernel size \(k\), and input tensor shape \((x, y, z)\), the number of weights is:
$$
N_{conv} = k \times z \times f
$$
For a fully connected layer with \(n\) neurons and input dimension \(z\), the number of weights is:
$$
N_{fc} = z \times n
$$
Weights are inherited by matching layer names. A layer name consists of three factors: layer type, hyperparameters, and input tensor dimension. The naming format is:
$$
\text{LayerType\_Hyperparameters\_InputDimension}
$$
For example, a convolutional layer Conv(21,15) with input tensor shape (32, 1600, 1) is named “Conv_(21, 25)_1”. The named layers are aggregated into a layer pool. After a candidate model is created, the layer pool is searched, and the weights of the same-named layer are copied to the new model. This mechanism significantly accelerates the NAS process.
Autoencoder Architecture and State Identification
Based on the AE architecture, I use the NAS method to create the candidate network for anomaly detection. The AE is trained in an unsupervised manner. It does not require explicit labels for every operating state. During training, the AE automatically clusters and mines feature representations of different states. I use only a subset of known state samples during training. The reconstruction loss is:
$$
\mathcal{L}_{AE} = \| x – \hat{x} \|^2
$$
where \(x\) is the input and \(\hat{x}\) is the reconstructed output. The reconstruction error is used to optimize feature extraction, not directly as an anomaly threshold. After training, the encoder output is used as a feature vector. I apply K-means clustering to identify states. The distance between a new sample \(x\) and a cluster center \(c_j\) is:
$$
d(x, c_j) = \| x – c_j \|_2
$$
The new sample is assigned to the nearest cluster center. The state label of that cluster center determines whether the industrial robot is in a normal or abnormal state. This design requires no manual threshold and automatically classifies unknown states into the most similar known state. Thus, the anomaly detection model can identify whether the industrial robot is abnormal based on feature similarity.
Entity Similarity Encoding and Maintenance Strategy Reasoning
Knowledge reasoning is an effective way to overcome the poor flexibility and adaptability of static knowledge graphs. To use entity similarity in reasoning, I encode entity attributes and relations. First, I evaluate the similarity between entities based on the attributes in the ontology. The main attributes of an entity are numericized and represented as a vector. Considering future entity expansion, I encode the entity type and name separately, reserve expansion dimensions, and concatenate them with the attribute encoding to form the final entity encoding vector. This encoding integrates type, name, and attribute information and reflects the similarity between entities.
I use cosine similarity to evaluate the similarity between entity vectors. The cosine similarity ranges from \(-1\) to \(1\). A larger value indicates greater similarity. The formula is:
$$
S_{cos}(x,y) = \frac{x \cdot y}{\|x\| \|y\|}
$$
where \(x\) and \(y\) are the two vectors to be compared. Relation similarity is measured by evaluating the position of an entity in the knowledge graph and its connections. Specifically, I compute the attribute similarity of the same-type neighbor entities between two entities. The property similarity and relation similarity 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\) are the encoding vectors of entities \(A\) and \(B\), and \(a_i\) and \(b_i\) are the same-type neighbor vectors. \(N\) is the number of neighbor pairs. A larger \(S(A,B)\) indicates higher similarity between the two entities in the knowledge graph. When \(N=0\), the two entities have no common neighbor entities, and the relation similarity is 0. The total similarity is then determined only by the property similarity.
Taking fault entities as an example, I encode their attributes. The fault type includes mechanical, electrical, and software. The influence scope includes mechanical part, electrical system, control system, and sensing system. The fault severity includes slight, medium, and severe. The following table shows the attribute analysis of fault entities.
| Attribute | Value | Description |
|---|---|---|
| Fault type | Mechanical | Involves physical parts or motion mechanisms, affecting motion accuracy, stability, or structural integrity |
| Fault type | Electrical | Involves electrical systems and components, possibly causing power interruption or signal transmission problems |
| Fault type | Software | Involves program or algorithm errors in the control system, affecting computation, control, and decision-making |
| Influence scope | Mechanical part | Affects the mechanical body and related parts, possibly causing operation interruption or system instability |
| Influence scope | Electrical system | Affects the electrical control system and components, possibly causing system failure or loss of control |
| Influence scope | Control system | Affects control and computation functions, possibly preventing correct task execution |
| Influence scope | Sensing system | Affects sensors and encoders, possibly causing inaccurate data or incorrect environmental perception |
| Fault severity | Slight | Limited impact on system function, usually no shutdown or significant performance degradation |
| Fault severity | Medium | Obvious impact on system performance, possibly partial function limitation, requiring timely repair |
| Fault severity | Severe | Major impact on core functions, possibly complete shutdown or severe damage, requiring immediate repair |
I use one-hot encoding for entity category, entity name, and fault attributes. I set 10 dimensions for entity type, 100 dimensions for entity name, and 50 dimensions for fault attributes. The following table shows examples of fault entity encoding. The encoding vector uses a sparse form. The five 1 values correspond to entity category, name, fault type, influence scope, and fault severity.
| 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 |
Reasoning Network Design
The knowledge reasoning network adopts a dual-input structure. It takes a subject entity and a relation as input and outputs an object entity. For example, given a fault entity and a “corresponds to” relation, it outputs a part entity. Given a cause entity and a “leads to” relation, it outputs a fault entity. The input entity vector and relation vector are embedded and concatenated into a tensor. The tensor is mapped through multiple fully connected layers to learn latent semantic associations between entities. Finally, the network outputs an object entity vector. The reasoning network is a relation mapping function \(f_\theta\):
$$
o = f_\theta(s, r)
$$
To train \(f_\theta\), I create three types of training samples: graph samples, reasoning samples, and negative samples. Graph samples \(KG\) are triples \((s, r, o)\) sampled from the knowledge graph. In addition to forward triples, I also create reverse triples \((o, r^{-1}, s)\). For example, the triple (“cause”, “leads to”, “fault”) has a reverse triple (“fault”, “caused by”, “cause”). Therefore, the 7 relation types in the knowledge graph are expanded to 14 types. Reasoning samples \(PR\) are created by using entity similarity. For a triple \((s, r, o)\) sampled from \(KG\), I compute the similarity of entities of the same type as \(o\). The most similar entity \(o_p\) is selected to create the reasoning triple \((s, r, o_p)\). Negative samples \(NS\) are also based on the triple \((s, r, o)\). I randomly select an entity \(o_n\) from the same type as \(o\), ensuring \(o_n \neq o_p\), and create the negative triple \((s, r, o_n)\). The training set consists of graph samples \(KG\), reasoning samples \(PR\), and negative samples \(NS\).
If the knowledge graph is regarded as a circle, then accurately predicting \(o\) from \(s\) and \(r\) satisfies the existing relation constraints. Predicting \(o_p\) is a reasonable inference within the circle. Predicting \(o_n\) is an unreasonable inference outside the circle. Negative samples help the reasoning network distinguish reasonable from unreasonable relations. I design the following loss functions for the three types of samples. The boundary constraint loss for graph samples is:
$$
J_{BC}(\theta) = \frac{1}{N_u} \sum_{i=1}^{N_u} \| f_\theta(s_i, r_i) – o_i \|^2
$$
The internal constraint loss for reasoning samples is:
$$
J_{IC}(\theta) = \frac{1}{N_g} \sum_{i=1}^{N_g} \left( 1 – \frac{f_\theta(s_i, r_i) \cdot o_i}{\| f_\theta(s_i, r_i) \| \| o_i \|} \right)
$$
The external constraint loss for negative samples is:
$$
J_{EC}(\theta) = \frac{1}{N_e} \sum_{i=1}^{N_e} \left( 1 + \frac{f_\theta(s_i, r_i) \cdot o_i}{\| f_\theta(s_i, r_i) \| \| o_i \|} \right)
$$
where \(N_u\), \(N_g\), and \(N_e\) are the numbers of the three sample types. The boundary constraint loss is a mean squared error. The internal and external constraint losses are variants of cosine similarity, ranging from \(-1\) to \(1\). A smaller internal constraint loss indicates better learning of reasoning samples. A smaller external constraint loss indicates better discrimination of negative samples. The total loss is a weighted sum:
$$
J(\theta) = \alpha J_{BC}(\theta) + \beta J_{IC}(\theta) + \gamma J_{EC}(\theta)
$$
I set the loss coefficients to 0.4, 0.3, and 0.3 to balance the training needs of the three sample types. The knowledge graph structure and volume do not create computational pressure for the neural network model. The reasoning performance mainly depends on graph sample construction and similarity measurement, not on fine tuning of loss coefficients. Parameter sensitivity analysis shows that the model accuracy is insensitive to coefficient changes and remains stable over a wide range. Therefore, the selected coefficients provide stable and good performance.
Case Study: Anomaly Detection and Maintenance Reasoning for an Industrial Robot
I validate my method on an industrial robot used for machining tasks. The hardware setup includes a machining industrial robot, a data acquisition card, and a monitoring computer. The industrial robot performs milling operations on a cylindrical workpiece. Three-axis accelerometers are installed on the joints and the end spindle. A surface roughness tester is used to inspect the surface quality of the workpiece. The monitoring scheme is shown below.
In addition to hardware wear, process programs and software parameters are important factors affecting the operating state of an industrial robot and its machining quality. Injecting hardware faults into an industrial robot is neither economical nor realistic. Therefore, I change the process parameters, process type, machining material, and posture to make the industrial robot exhibit abnormal machining states. This allows me to obtain relevant operating signals and verify the effectiveness of my method. The process parameter settings are listed in the table below. Four machining processes are designed: milling the side surface of an aluminum alloy suspension, milling side holes of an aluminum alloy suspension, milling the bottom surface of a stainless steel foot, and milling the side surface of a stainless steel foot. The required surface roughness values are Ra3.2 and Ra6.3.
| State | Spindle speed (r/min) | Feed speed (mm/s) | Cutting depth (mm) | Operation description | Surface quality |
|---|---|---|---|---|---|
| State 1 | 3000 | 5 | 0.1 | Milling suspension side | Qualified |
| State 2 | 3000 | 5 | 0.5 | Milling suspension side | Unqualified |
| State 3 | 3000 | 5 | 0.1 | Milling suspension side hole | Qualified |
| State 4 | 3000 | 5 | 0.5 | Milling suspension side hole | Unqualified |
| State 5 | 1500 | 3 | 0.1 | Milling foot bottom | Qualified |
| State 6 | 1500 | 3 | 0.5 | Milling foot bottom | Unqualified |
| State 7 | 1500 | 3 | 0.1 | Milling foot side | Qualified |
| State 8 | 1500 | 3 | 0.5 | Milling foot side | Unqualified |
Each state is evaluated by inspecting the final surface quality. States 1, 3, 5, and 7 are normal states, while states 2, 4, 6, and 8 are abnormal states. The differences between states 1–2 and 3–4 mainly come from the two process types: surface milling and hole milling. The differences between the first four states and the last four states come from the workpiece material. The differences between states 5–6 and 7–8 come from the posture and configuration of the industrial robot. Although the process parameter settings are not exhaustive, the eight states cover most typical machining scenarios of the industrial robot.
Preliminary tests show that the vibration signal collected by the sensor at the sixth joint, that is, the flange, best represents the vibration state of the industrial robot. Using the J-x dimensional data to train the anomaly detection AE model achieves higher accuracy. In subsequent monitoring, only the sensor at the flange is retained to reduce the impact on the machining of the industrial robot. The sensor sampling frequency is 51.2 kHz. The vibration signals of states 1–4 are downsampled with a step of 1000. Each sample contains 6400 data points, and each state has 60 samples. The training and test data are split with a ratio of 1:4. I use UMAP to reduce the high-dimensional encoder output to three dimensions for visualization. The experimental environment is a workstation with an Intel Ultra 9 285K processor, 96 GB memory, and an NVIDIA GeForce RTX 5090 D GPU.
Anomaly Detection Results
The automatic creation process of the anomaly detection model is visualized by the NAS controller reward and the test accuracy of the created candidate models. As the controller reward increases, the candidate model accuracy improves from 0.13 in stage 1 to 1.0 in stage 4. The process takes about 1200 seconds to reach the highest accuracy. In the visualization, the distance between points represents similarity. Samples of the same state gradually cluster together, and samples of different states are separated. This demonstrates the clustering performance of the AE model.
I use the test data to validate the anomaly detection model. The model achieves 100% accuracy for the known states 1 to 8. To further validate the detection performance for unknown states, I adjust the process parameters of the industrial robot for milling the foot bottom to a spindle speed of 1500 r/min, a feed speed of 3 mm/s, and a cutting depth of 0.6 mm. This simulates a new abnormal state 9. The vibration signal of state 9 is mixed with the signals of the other eight states and input into the AE model for clustering diagnosis. The model identifies state 9 as state 6. The visualization shows that the samples of state 9 are clustered together and closely approach the samples of abnormal state 6. This indicates that the AE model judges the unknown state 9 as state 6, which belongs to an abnormal state.
These results show that my NAS-AE anomaly detection method can effectively identify the operating anomalies of an industrial robot under different processes, materials, and postures. The detection accuracy for the eight typical states reaches 100%, and the method can accurately identify the unknown state 9. Compared with traditional manually designed neural networks, the NAS technology does not rely on expert experience for network structure tuning. The weight sharing mechanism enables efficient automatic model creation and can quickly adapt to different industrial robot models and working conditions. This provides a reliable automatic anomaly detection capability for the perception side of the knowledge graph.
Maintenance Strategy Reasoning Results
After the perception side detects an abnormal operation of the industrial robot, the abnormal vibration phenomenon is described and encoded. The encoding of similar phenomena is shown in the table below. The first row is the encoding of the detected phenomenon. The description “abnormal vibration during robot machining” is a new description not present in the existing knowledge graph, so the reserved position (0,81) is set to 1. The detected abnormal vibration affects machining accuracy, which is a performance degradation phenomenon, so positions (0,110) and (0,116) are set to 1. The vibration is monitored by the sensor at the flange, indicating that the end effector is directly affected, so position (0,129) is set to 1. The last three rows are the most similar phenomena in the knowledge graph.
| Abnormal phenomenon | Category | Anomaly type | Influence scope | Encoding | Similarity |
|---|---|---|---|---|---|
| Abnormal vibration during industrial robot machining | Performance degradation | Performance 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 accuracy | Performance degradation | Performance 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 | Performance 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 accuracy and stability | Performance degradation | Performance 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 |
The decision-side algorithm performs possible fault reasoning based on the phenomenon encoding of the detected anomaly and generates corresponding maintenance strategies. The strategies cover key decision elements, including the component to which the fault belongs, the fault cause, and the maintenance method. The maintenance methods include maintenance, replacement, and optimization, covering the main maintenance actions in typical scenarios. This indicates that the knowledge in the knowledge graph is comprehensive and sufficient. The last column is the similarity of the inferred fault. The first three inferred faults with similarity 1.0 exactly correspond to the three most similar fault phenomena in the previous table.
| 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 accuracy | Redesign and debug the process program, optimize process parameters (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 (replacement) | 1.0 |
| Mechanical body | End effector | Tool head | Tool head connection looseness | Vibration, improper installation torque, material fatigue, or long service time | Abnormal vibration and noise during industrial robot machining, affecting accuracy and stability | Regularly check the connection state of the tool head, ensure bolts and interfaces are firmly connected (maintenance) | 1.0 |
| Mechanical body | Connecting rod | Connecting bolt | Bolt looseness | Vibration, impact, improper installation, or long service time | Vibration and noise during industrial robot motion, reduced accuracy | Regularly check bolt tightening state, replace bolts as needed (maintenance) | 0.71 |
| Mechanical body | Joint | Rotating bearing | Joint bearing looseness | Bearing seat looseness, bolt looseness, or improper clearance in the bearing inner and outer raceways | Abnormal joint vibration and noise, affecting accuracy and stability of the industrial robot | Regularly check the bearing seat and bolt tightening state, 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 accuracy | Replace damaged gears, improve lubrication conditions, reduce overload operation (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 accuracy | Replace damaged bearings, ensure good lubrication (replacement) | 0.71 |
From the results, the entity-similarity-based knowledge reasoning network can accurately identify known faults and generate corresponding maintenance strategies. It can also provide reasonable reference solutions for unknown faults based on similarity. The core advantage of this reasoning network is the dual similarity encoding of entity attributes and relations, as well as the comprehensive loss function designed for maintenance scenarios. The constructed maintenance knowledge graph is not computationally challenging for the neural network model. Therefore, reasonable sample construction and similarity measurement design can achieve the reasoning performance required for field applications. This provides an effective strategy generation capability for the decision side of the knowledge graph.
System Workflow and Engineering Implementation
Based on the above methods, I develop a complete intelligent operation and maintenance software system for industrial robots. The system implements a closed-loop process with six core steps. First, the monitoring hardware deployed on the joints of the industrial robot collects multi-dimensional operating signals in real time. Second, the NAS-AE model extracts features from the operating signals and classifies the state, automatically identifying abnormal operations. Third, the abnormal state is encoded and input into the knowledge graph reasoning model. The model retrieves the most similar fault entities based on entity similarity and generates targeted maintenance strategies for maintenance personnel. Fourth, during the execution of the strategy, the system automatically records the maintenance process and performs maintenance statistical analysis. Fifth, new fault cases, processing results, and maintenance knowledge are updated into the knowledge graph, including entity and attribute updates and ontology structure adjustments. Sixth, the system continuously accumulates knowledge and iterates and optimizes itself.
The system realizes full-process automation from operating state perception to maintenance strategy generation and maintenance knowledge iteration. This effectively improves the maintenance efficiency and intelligence level of the industrial robot. The following table summarizes the main functional modules of the system.
| Module | Function | Input | Output |
|---|---|---|---|
| Signal acquisition | Collect vibration and process signals from the industrial robot | Accelerometer signals, controller signals | Raw time-series data |
| Anomaly detection | Identify normal and abnormal states of the industrial robot | Raw time-series data | State label, anomaly score |
| Knowledge graph | Store and manage maintenance knowledge | Ontology, triples, expert knowledge | Structured maintenance knowledge |
| Similarity encoding | Encode entities and relations for reasoning | Entity attributes, graph structure | Entity vectors, similarity values |
| Strategy reasoning | Infer faults and generate maintenance strategies | Abnormal phenomenon encoding | Fault, cause, and maintenance method |
| Knowledge update | Update the knowledge graph with new maintenance cases | Maintenance records, new faults | Updated triples and ontology |
Discussion
My method has several advantages. First, the fault-centric ontology model integrates multi-dimensional knowledge of the industrial robot, including structure, fault phenomena, causes, and maintenance methods. This provides a unified knowledge base for intelligent maintenance. Second, the NAS-AE anomaly detection model achieves end-to-end unsupervised anomaly identification for industrial robot vibration signals. It reduces dependence on expert knowledge and improves the automation of state perception. Third, the entity-similarity-based reasoning network enables the system to infer maintenance strategies for unknown faults based on existing knowledge. This significantly enhances the adaptability and intelligence of the maintenance system.
However, there are some limitations. The knowledge graph is currently constructed from maintenance manuals, expert knowledge, literature, and field experience. The coverage of rare faults may be limited. The anomaly detection model is validated on a specific industrial robot and a limited set of process conditions. Its generalization to other industrial robot models and working conditions needs further investigation. The reasoning network relies on entity similarity encoding. If the encoding dimensions are not sufficient, the similarity measurement may be inaccurate. Future work will focus on automatic knowledge graph completion, transfer learning for anomaly detection across different industrial robots, and more advanced reasoning mechanisms that combine graph neural networks with symbolic reasoning.
Despite these limitations, the experimental results demonstrate that my method can effectively detect abnormal operations of an industrial robot and generate targeted maintenance strategies. The method improves the automation and intelligence level of industrial robot maintenance and provides a feasible technical solution for intelligent maintenance of industrial robots.
Conclusion
In this work, I propose an enhanced knowledge graph method for anomaly detection and maintenance strategy reasoning of industrial robots. The method constructs a fault-centric ontology model and integrates robot structure, fault phenomena, causes, and maintenance methods into a comprehensive knowledge graph. I design a NAS-AE anomaly detection model for end-to-end unsupervised identification of abnormal states. I also develop an entity-similarity-based knowledge reasoning network that supports maintenance strategy generation for unknown faults. Based on the proposed framework, I implement a complete intelligent operation and maintenance software system for industrial robots. Experimental results show that the method can effectively detect operating anomalies of an industrial robot and generate targeted maintenance strategies. The method enhances the automation and intelligence of industrial robot maintenance and provides a practical solution for engineering applications.
The main conclusions are as follows. First, the ontology modeling approach systematically integrates engineering maintenance experience and general maintenance knowledge, forming a comprehensive maintenance knowledge base for industrial robots with diverse and complex fault modes. Second, the similarity encoding of graph entities and their attributes enables a knowledge reasoning network that can adapt to unknown fault scenarios and overcome the poor adaptability of static knowledge graphs. Third, embedding anomaly detection and maintenance strategy generation algorithms into the perception and decision sides of the knowledge graph creates an end-to-end intelligent maintenance method, improving the automation and intelligence level of industrial robot maintenance.
In future work, I will expand the knowledge graph with more industrial robot models and fault cases. I will also explore the integration of additional sensor modalities, such as current, torque, and acoustic signals, to improve the robustness of anomaly detection. Moreover, I will investigate continual learning and graph neural networks to enable the knowledge graph to evolve automatically with new maintenance data. These directions will further enhance the practical value of the proposed method for industrial robot operation and maintenance.