In the complex operational environments of fixed-wing drones, numerous unpredictable disturbances such as airflow turbulence and structural vibrations constantly degrade the performance of actuators. Over time, internal components inevitably deform and age, leading to various faults — including actuator failures and sensor malfunctions — that critically compromise flight safety. Fixed-wing drones, which fly longer distances, at higher altitudes, and with greater payloads than other types of unmanned aerial vehicles, encounter even more uncontrollable factors. This makes reliable fault diagnosis an indispensable requirement for their autonomous mission execution.
Traditional model-based methods, though widely adopted in early industrial practice, heavily depend on precise mathematical models of the system. For fixed-wing drones, however, the strong coupling between aerodynamic surfaces, propulsion, and control surfaces makes accurate modeling extremely difficult. Moreover, model uncertainties and external disturbances often degrade diagnostic accuracy. With the rapid advancement of big data and artificial intelligence, data-driven approaches — especially deep learning — have emerged as promising alternatives. Among them, convolutional neural networks (CNNs) possess powerful feature learning and representation capabilities that are particularly suitable for extracting complex, hierarchical, and correlated fault signatures from raw sensor data. In this work, I present a comprehensive investigation into CNN-based fault diagnosis for fixed-wing drones, focusing on actuator malfunctions. Through systematic modeling, feature engineering, and experimental validation on real flight datasets, I demonstrate that the proposed method achieves robust and accurate classification of multiple actuator fault types, significantly enhancing the safety of fixed-wing drone operations.
Convolutional Neural Network Model
Deep learning architectures with multiple hidden layers can effectively analyze massive datasets, capture intrinsic characteristics, and establish nonlinear mappings between raw inputs and fault categories. Convolutional neural networks, a class of feedforward neural networks that incorporate convolution operations, have achieved remarkable success in natural language processing and image recognition. However, their application in UAV fault diagnosis remains relatively underexplored. Given the highly nonlinear relationship between a fixed-wing drone’s flight parameters (such as accelerations and angular rates) and its actuator health state, a CNN offers distinct advantages: fast convergence, low memory consumption, and superior feature extraction capability.
The CNN architecture I adopt consists of five convolutional layers, five max-pooling layers, one fully connected hidden layer with 100 neurons, and a final softmax layer. The structure is summarized below.
| Layer | Type | Kernel Size / Pooling Size | Stride | Number of Filters / Neurons | Activation |
|---|---|---|---|---|---|
| Layer 1 | Convolutional | 3 × 1 | 1 × 1 | 32 | ReLU |
| Layer 2 | Max Pooling | 2 × 1 | 2 × 1 | – | – |
| Layer 3 | Convolutional | 3 × 1 | 1 × 1 | 32 | ReLU |
| Layer 4 | Max Pooling | 2 × 1 | 2 × 1 | – | – |
| Layer 5 | Convolutional | 3 × 1 | 1 × 1 | 64 | ReLU |
| Layer 6 | Max Pooling | 2 × 1 | 2 × 1 | – | – |
| Layer 7 | Convolutional | 3 × 1 | 1 × 1 | 64 | ReLU |
| Layer 8 | Max Pooling | 2 × 1 | 2 × 1 | – | – |
| Layer 9 | Convolutional | 3 × 1 | 1 × 1 | 64 | ReLU |
| Layer 10 | Max Pooling | 2 × 1 | 2 × 1 | – | – |
| Layer 11 | Fully Connected | – | – | 100 | ReLU |
| Layer 12 | Softmax | – | – | 9 (classes) | Softmax |
The convolutional operation at layer \(l\) for the \(i\)-th kernel is defined as:
$$
y^{(l)}(i,j) = K^{(l)}_i * x^{(l)}(r_j) = \sum_{j’=0}^{W-1} K^{(l)}_i(j’) \, x^{(l)}(j+j’)
$$
where \(K^{(l)}_i(j’)\) is the \(j’\)-th weight of the \(i\)-th convolutional kernel in layer \(l\), \(x^{(l)}(r_j)\) is the \(j\)-th local region of the input, and \(W\) is the kernel width. After convolution, the Rectified Linear Unit (ReLU) activation introduces nonlinearity:
$$
a^{(l)}(i,j) = f\!\left(y^{(l)}(i,j)\right) = \max\{0,\, y^{(l)}(i,j)\}
$$
Max pooling then reduces the spatial dimensionality:
$$
p^{(l)}(i,j) = \max_{(j-1)W+1 \le t \le jW} a^{(l)}(i,t)
$$
where \(W\) is the pooling region width. The fully connected layer flattens the final pooled features into a 100‑dimensional vector, and the softmax layer outputs a probability distribution over the nine fault classes. I use the cross‑entropy loss function to measure the discrepancy between predicted and true labels:
$$
L = \frac{1}{m} \sum_{k=1}^{m} \frac{1}{2} \sum_{j} (p_j^k – q_j^k)^2
$$
where \(m\) is the batch size, \(p_j^k\) is the predicted probability for class \(j\), and \(q_j^k\) is the one‑hot encoded true label.
Actuator Fault Diagnosis for Fixed-Wing Drones
Actuator Fault Modeling
Actuators are the core components that execute control commands for fixed-wing drones. Common actuator faults include gradual efficiency loss, instantaneous jamming, and intermittent malfunctions. I model the relationship between the commanded control deflection \(u_{\text{com}}\) and the actual applied deflection \(u_{\text{app}}\) as:
$$
u_{\text{app}} = D \, u_{\text{com}} + E
$$
where \(D\) is a diagonal efficiency matrix and \(E\) is an offset vector. For the two elevons (right and left) considered in this study, the vector form is:
$$
\begin{bmatrix} u_{\text{app}1} \\ u_{\text{app}2} \end{bmatrix} =
\begin{bmatrix} d_1 & 0 \\ 0 & d_2 \end{bmatrix}
\begin{bmatrix} u_{\text{com}1} \\ u_{\text{com}2} \end{bmatrix} +
\begin{bmatrix} e_1 \\ e_2 \end{bmatrix}
$$
Here subscript 1 denotes the right elevon, subscript 2 the left elevon. By adjusting \(d_i\) and \(e_i\) I simulate various fault scenarios. For instance, setting \(d_2 = 0.9\) corresponds to a 10% efficiency loss in the left elevon.
Feature Trajectory Generation
To reduce computational cost and remove irrelevant information, I select eight basic features from the onboard sensors: linear accelerations \(a_x, a_y, a_z\), angular rates \(\omega_x, \omega_y, \omega_z\), and the two autopilot command signals \(u_{\text{com}1}, u_{\text{com}2}\). These features are concatenated over a sliding window of 20 time steps to incorporate temporal dynamics. The resulting input vector at time \(t\) is:
$$
X(t) = \big[ X'(t-19),\; X'(t-18),\;\ldots,\; X'(t-1),\; X'(t) \big]
$$
where each \(X'(\tau)\) is an 8‑element vector:
$$
X'(\tau) = \big[ a_x(\tau),\; a_y(\tau),\; a_z(\tau),\; \omega_x(\tau),\; \omega_y(\tau),\; \omega_z(\tau),\; u_{\text{com}1}(\tau),\; u_{\text{com}2}(\tau) \big]
$$
Thus the input to the CNN is a 160‑dimensional feature trajectory. The fault types and their corresponding codes are listed below.
| Fault Code | Description |
|---|---|
| 0 | No fault (nominal) |
| 1 | Right elevon efficiency: \(d_1 = 0.3\) |
| 2 | Left elevon efficiency: \(d_2 = 0.9\) |
| 3 | Left elevon efficiency: \(d_2 = 0.8\) |
| 4 | Left elevon efficiency: \(d_2 = 0.7\) |
| 5 | Left elevon efficiency: \(d_2 = 0.6\) |
| 6 | Left elevon efficiency: \(d_2 = 0.5\) |
| 7 | Left elevon efficiency: \(d_2 = 0.4\) |
| 8 | Left elevon efficiency: \(d_2 = 0.3\) |
The flight data were collected from two autonomous flights performed on two different days with wind speeds of 2.5 m/s and 5.0 m/s, respectively. The fixed-wing drone flew a figure‑eight trajectory. Fault injection was performed sequentially: three consecutive right‑elevon efficiency faults (code 1) followed by three consecutive left‑elevon efficiency faults (code 8), each separated by nominal phases. Then the left elevon efficiency was gradually decreased from 1.0 down to 0.3. The fault injection timeline is shown conceptually below.
Experimental Results and Analysis
I evaluate the diagnosis performance using four metrics: accuracy, precision, recall, and F1‑score. The experiments are divided into two parts: (1) training and testing on the same flight (July 21, wind 2.5 m/s) to verify the CNN’s ability to learn fault features; (2) cross‑flight evaluation to test generalization under different environmental conditions.
Part 1: Intra‑Flight Diagnosis
I split the July 21 dataset into 80% training and 20% testing. After 50 epochs of training, the CNN achieved 99% accuracy. The detailed classification report is shown below.
| Fault Code | Precision | Recall | F1-Score | Support |
|---|---|---|---|---|
| 0 (nominal) | 1.00 | 1.00 | 1.00 | 1382 |
| 1 (R0.3) | 1.00 | 1.00 | 1.00 | 485 |
| 2 (L0.9) | 1.00 | 1.00 | 1.00 | 295 |
| 3 (L0.8) | 1.00 | 0.99 | 0.99 | 299 |
| 4 (L0.7) | 0.99 | 0.98 | 0.98 | 299 |
| 5 (L0.6) | 0.98 | 1.00 | 0.99 | 311 |
| 6 (L0.5) | 1.00 | 1.00 | 1.00 | 306 |
| 7 (L0.4) | 1.00 | 0.99 | 1.00 | 323 |
| 8 (L0.3) | 1.00 | 1.00 | 1.00 | 703 |
| macro avg | 0.99 | 1.00 | 1.00 | 4403 |
| weighted avg | 1.00 | 0.99 | 0.99 | 4403 |
For comparison, a traditional SVM classifier achieved 93% accuracy on the same test set, as detailed below.
| Fault Code | Precision | Recall | F1-Score | Support |
|---|---|---|---|---|
| 0 | 0.92 | 0.98 | 0.94 | 1382 |
| 1 | 0.98 | 0.93 | 0.95 | 485 |
| 2 | 0.85 | 0.70 | 0.77 | 295 |
| 3 | 0.87 | 0.90 | 0.88 | 299 |
| 4 | 0.94 | 0.90 | 0.92 | 299 |
| 5 | 0.89 | 0.90 | 0.90 | 311 |
| 6 | 0.91 | 0.89 | 0.90 | 306 |
| 7 | 0.95 | 0.93 | 0.94 | 323 |
| 8 | 0.97 | 0.98 | 0.98 | 703 |
| accuracy | 0.93 | 4403 | ||
| macro avg | 0.92 | 0.90 | 0.91 | 4403 |
| weighted avg | 0.93 | 0.93 | 0.93 | 4403 |
To further validate the learned representations, I applied t‑SNE to the features extracted from the fully connected layer. The resulting 2‑D visualization clearly shows that the CNN projects each fault class into a distinct cluster, confirming its strong discriminative ability.
Part 2: Cross‑Flight Diagnosis and Overfitting Mitigation
For real‑world deployment, a model trained on historical data must generalize to future flights under varying conditions. I first trained the CNN on July 21 data (Flight A) and tested it on July 23 data (Flight B, wind 5.0 m/s). The performance was poor, as shown below.
| Fault Code | Precision | Recall | F1-Score | Support |
|---|---|---|---|---|
| 0 | 0.89 | 0.57 | 0.70 | 1649 |
| 1 | 0.72 | 0.62 | 0.67 | 505 |
| 2 | 0.10 | 0.33 | 0.15 | 144 |
| 3 | 0.16 | 0.38 | 0.22 | 152 |
| 4 | 0.39 | 0.65 | 0.49 | 264 |
| 5 | 0.57 | 0.41 | 0.47 | 301 |
| 6 | 0.56 | 0.60 | 0.58 | 310 |
| 7 | 0.49 | 0.45 | 0.47 | 324 |
| 8 | 0.79 | 0.80 | 0.80 | 752 |
| accuracy | 0.59 | 4401 | ||
| macro avg | 0.52 | 0.54 | 0.51 | 4401 |
| weighted avg | 0.70 | 0.59 | 0.62 | 4401 |
The poor generalization arises because the CNN overfits the specific flight conditions of July 21 (light wind). The July 23 flight experienced stronger wind (5.0 m/s vs. 2.5 m/s), resulting in different angular rate distributions and trajectory patterns. Consequently, the model fails to recognize faults under unseen dynamics.
To address this, I reversed the training and test sets: training on the more challenging July 23 data (Flight B) and testing on July 21 data (Flight A). The results improved significantly, as shown below.
| Fault Code | Precision | Recall | F1-Score | Support |
|---|---|---|---|---|
| 0 | 0.76 | 0.94 | 0.84 | 1382 |
| 1 | 0.71 | 0.79 | 0.74 | 485 |
| 2 | 0.37 | 0.06 | 0.10 | 295 |
| 3 | 0.66 | 0.43 | 0.52 | 299 |
| 4 | 0.71 | 0.55 | 0.62 | 299 |
| 5 | 0.66 | 0.44 | 0.53 | 311 |
| 6 | 0.56 | 0.72 | 0.63 | 306 |
| 7 | 0.66 | 0.61 | 0.63 | 323 |
| 8 | 0.82 | 0.91 | 0.87 | 703 |
| accuracy | 0.72 | 4403 | ||
| macro avg | 0.66 | 0.61 | 0.61 | 4403 |
| weighted avg | 0.70 | 0.72 | 0.70 | 4403 |
This outcome demonstrates that training on more complex, high‑wind data yields a model that generalizes better to simpler conditions. The CNN learns more robust features when exposed to a wider range of dynamics. In practice, engineers should collect flight data under diverse environmental conditions — especially the most challenging ones — to build a fault diagnosis model that remains reliable during future missions of fixed-wing drones.
Conclusion
In this study, I developed a convolutional neural network‑based fault diagnosis framework specifically for actuator faults of fixed-wing drones. By modeling the efficiency loss of elevons through a linear efficiency matrix, generating temporal feature trajectories from accelerations, angular rates, and command signals, and training a deep CNN with five convolutional layers, I achieved 99% accuracy on data from the same flight. The t‑SNE visualization of the learned features confirmed that the CNN effectively separates different fault categories. However, cross‑flight experiments revealed a critical challenge: models trained on benign conditions fail under stronger disturbances due to overfitting. Reversing the training to use more complex flight data significantly improved generalization, raising the overall accuracy from 59% to 72%. This finding underscores the importance of training data diversity for robust fault diagnosis of fixed-wing drones. Future work will explore domain adaptation techniques and attention mechanisms to further enhance the model’s ability to generalize across varying flight regimes, ultimately making fixed-wing drones safer and more reliable in real‑world operations.