Explainable Fault Classification and Severity Diagnosis in Rotating Machinery Using Kolmogorov–Arnold Networks

Abstract

Rolling element bearings are critical components of rotating machinery, with their performance directly influencing the efficiency and reliability of industrial systems. At the same time, bearing faults are a leading cause of machinery failures, often resulting in costly downtime, reduced productivity, and, in extreme cases, catastrophic damage. This study presents a methodology that utilizes Kolmogorov–Arnold Networks—a recent deep learning alternative to Multilayer Perceptrons. The proposed method automatically selects the most relevant features from sensor data and searches for optimal hyper-parameters within a single unified approach. By using shallow network architectures and fewer features, the resulting models are lightweight, easily interpretable, and practical for real-time applications. Validated on two widely recognized datasets for bearing fault diagnosis, the framework achieved perfect F1-Scores for fault detection and high performance in fault and severity classification tasks, including 100% F1-Scores in most cases. Notably, it demonstrated adaptability by handling diverse fault types, such as imbalance and misalignment, within the same dataset. The availability of symbolic representations provided model interpretability, while feature attribution offered insights into the optimal feature types or signals for each studied task. These results highlight the framework’s potential for practical applications, such as real-time machinery monitoring, and for scientific research requiring efficient and explainable models.

1. Introduction

Rotating machinery plays an indispensable role in modern industry, powering numerous applications across the manufacturing, energy, and transportation sectors [1]. Among their components, rolling element bearings (referred to simply as bearings hereafter) are vital yet vulnerable elements, with a heavy influence on the performance and lifespan of machines. Notably, it has been reported that up to 50% of motor faults are bearing-related [2], while several issues in rotating machinery today can be traced to the improper design or application of bearings [3]. Such failures can result in severe consequences, including unexpected downtime and costly repairs [4,5], or even catastrophic damage or loss of life in extreme cases [6]. Moreover, in manufacturing environments, where continuous production is critical, disruptions caused by bearing failures can lead to substantial losses in productivity [7]. Early and accurate bearing fault detection and classification are therefore essential in modern industrial and manufacturing practices.

Before the widespread use of machine learning (ML) and deep learning (DL) methodologies, bearing fault detection and classification relied on other widely adopted techniques to identify characteristic fault patterns. For instance, vibration analysis is commonly employed to detect frequency peaks associated with specific faults [2], while signatures of these vibration frequencies have also been identified in the current spectrum through electrical signal processing [8]. Additionally, features extracted from the Fourier spectrum of vibration signals were utilized to detect faults as peaks in the frequency domain [9], and acoustic emission (AE) monitoring offered earlier and more fine-grained fault detection compared to vibration monitoring [10]. However, these methods are often bound to specific fault scenarios or experimental conditions, which limit their applicability to diverse operating environments. For example, directly identifying bearing faults through raw vibration signals is challenging, as vibrations are typically dominated by imbalance and misalignment components [11]. Moreover, the experimental results of [8] were based on cases of extensive bearing damage, raising concerns about the applicability of this approach for less severe faults [11]. Features like spectral kurtosis have been shown to be sensitive to strong harmonic interference when used as the only fault indicator [12], and have also led to poor model accuracy when extracted from non-stationary signals [13]. Finally, AE monitoring has also proven to be highly susceptible to background noise [14].

Despite their limitations, the aforementioned techniques laid the foundation for identifying which types of sensor data are most effective for detecting and classifying bearing faults. Modern data-driven approaches have built upon this groundwork, incorporating features extracted from sensor data to develop more robust and generalizable frameworks. Examples of features extracted directly from the time-domain signal include, but are not limited to, the root mean square (RMS), crest factor (CF), skewness, and kurtosis [15]. Spectral features, such as fundamental frequencies, spectral kurtosis and spectral entropy are obtained by applying a Fast Fourier Transform (FFT) to the time-domain signals and have also been widely used in such applications [16]. Beyond time- and frequency-domain features, time–frequency representations, such as those derived from the Short-Time Fourier Transform or wavelet transformations, are often used to extract features for capturing transient and non-stationary behaviors [17]. Additionally, AE monitoring, despite its susceptibility to noise, has shown promising results when combined with modern time-series deep learning methods [18].

Drawing from these diverse feature sets, a series of ML models such as k-Nearest Neighbors [19,20], Support Vector Machines (SVMs) [21,22], and Random Forests [23,24,25] have been explored for the tasks of bearing fault detection and classification. More recently, the widespread adoption of sensors in industrial settings and the advent of the big data era have driven the use of DL approaches, initially based on fundamental architectures such as Autoencoders (AEs) [26,27], Recurrent Neural Networks [27,28], Convolutional Neural Networks (CNNs) [29,30,31] and Generative Adversarial Networks [32,33]. Building further on these core architectures, recent studies have introduced more sophisticated hybrid models that combine CNNs with AEs and attention mechanisms [13,34], or integrate recurrent models like Bidirectional Long Short-Term Memory (BiLSTM) networks with smoothing techniques [18].

Albeit successful in achieving high performance for bearing fault detection and classification, ML and especially DL models often fall short in areas where traditional approaches excel, with explainability being a notable example. The ability to understand and interpret a model’s decisions is crucial, especially in safety-critical applications or when deeper insights into the underlying physical processes are required [35]. In addition to explainability, a significant challenge arises in deploying DL models for real-time condition-based monitoring on edge devices, i.e., resource-constrained computing units located close to the machinery they monitor. Many DL architectures are computationally intensive, making them unsuitable for resource-constrained environments [36]. Another important consideration is the quantity and quality of features used by these models. While leveraging a large number of features can often yield superior results, achieving comparable performance with fewer features is far more desirable [37]; budget constraints and technical limitations in practical scenarios demand careful sensor selection, as collecting an exhaustive set of measurements is neither feasible nor economical. Furthermore, the effectiveness of features can vary significantly, depending on the dataset or system under study; features that perform well for one problem may be suboptimal for another. This variability highlights the need for models capable of adaptively selecting the most relevant features for a given problem [38]. To address these challenges, this paper presents a unified framework centered around Kolmogorov–Arnold Networks (KANs), designed to provide explainability, efficiency, and adaptive feature selection.

Inspired by the Kolmogorov–Arnold representation theorem, KANs were recently introduced by [39] as an alternative to Multi-Layer Perceptrons (MLPs), serving as a new paradigm for the underlying architecture of DL models. Unlike in the case of MLPs, where activation functions are fixed, KANs contain trainable univariate functions as activations, allowing them to represent relationships in symbolic forms. This inherent explainability, along with their demonstrated performance in domains such as differential equations [40,41,42], high-energy physics [43,44], and smart systems and devices [45,46], makes KANs a promising candidate for addressing both scientific and engineering problems [47]. In the context of bearing fault detection and classification, there is a notable lack of studies utilizing KANs, with the exception of [48]. In that study, the Case Western Reserve University (CWRU) bearing dataset [49] was employed; however, the primary focus of the paper was unrelated to bearing fault diagnosis and instead aimed at the early prediction of natural gas pipeline leaks.

Building on the potential of KANs and addressing the identified gaps, the main aspects of the proposed framework—and thus, the main contributions of the current work—can be summarized in the following points:

• Automatic and explainable feature selection: By training shallow KANs with sparsity-inducing regularization, the framework automatically identifies the minimal set of highly relevant features based on explicit feature attribution scores and dynamic thresholds.
• Interpretable and lightweight models: The trained activation functions are converted into symbolic mathematical representations based on the minimization of a custom cost function, enabling direct analysis and interpretation beyond black-box approaches while maintaining efficiency suitable for deployment on edge devices.
• Unified bearing fault diagnosis framework: Fault detection, fault classification, and severity estimation are seamlessly integrated within a single, consistent methodology.
• Generalizability beyond bearing faults: The versatility and generalization capabilities of the proposed approach are demonstrated through successful application to datasets containing diverse machinery faults beyond bearings alone.

To the best of the authors’ knowledge, this is among the first attempts to address bearing faults in a unified manner, handling multiple tasks such as fault detection, fault classification, and severity estimation. Unlike methods that only provide model architectures, this approach encompasses the entire pipeline, including data pre-processing, feature extraction, automated feature selection, and inference, within a single, lightweight deep learning framework. A recent related study by [7] touches upon some of these challenges by employing an SVM model for fault classification and genetic algorithms (GAs) for automated feature selection. Nevertheless, GAs are computationally demanding, and SVMs, along with GAs, lack the explainability provided by the proposed KAN-based approach.

The remainder of the present paper is structured as follows: Section 2 presents the proposed framework in detail, including its components, methodology, and theoretical foundation. Subsequently, the two datasets utilized in this study are introduced in Section 3, along with a discussion on the rationale for their selection and a presentation of the feature libraries extracted to implement the framework. In Section 4, the experimental results obtained on both datasets are reported, focusing on selected features, model performance, and symbolic representations. Finally, Section 5 provides a summary and discussion of the work’s main findings.

2. Proposed Methodology

Prior to the discussion of the proposed methodology’s technical details, an overview of KANs, their theoretical formulation, and the properties that establish them as a key component of the framework are provided.

2.1. Kolmogorov–Arnold Networks

The theoretical foundations of KANs lie in the Kolmogorov Superposition Theorem (KST), which provides a robust theoretical framework for decomposing multivariate functions into simpler univariate functions through summation operations. Earlier attempts to apply the theorem for function approximation sought to implement it in its exact form but faced significant challenges due to the pathological behavior of the inner univariate functions [50]. Recently, ref. [39] extended the KST to a “deep” equivalent, introducing a more flexible network architecture that contains an arbitrary number of layers with arbitrary widths, rather than adhering strictly to the original formulation of the theorem.

One such extended architecture with L layers is defined by an array $\left[n_0,n_1,\cdots ,n_L\right]$, where $n_i$ denotes the number of input nodes of the i-th layer. Unlike in MLPs, a KAN layer corresponds to the activation functions between a set of input and output nodes, rather than the inputs or outputs themselves, which is why the array has $L+1$ elements. The corresponding model can be written as

$$u\left(x;\theta \right)=\left[{\mathrm{\Phi }}^{\left(L\right)}\circ \cdots \circ {\mathrm{\Phi }}^{\left(1\right)}\right]\left(x\right),$$

(1)

where $\theta$ represents the network’s trainable parameters, ∘ denotes the successive application of ${\mathrm{\Phi }}^{\left(l\right)}$, and

$${\mathrm{\Phi }}^{\left(l\right)}\left(x^{\left(l\right)}\right)=\left(\begin{array}{ccc}{\varphi }_{l,1,1}(·)& \cdots & {\varphi }_{l,n_l,1}(·)\\ {\varphi }_{l,1,2}(·)& \cdots & {\varphi }_{l,n_l,2}(·)\\ ⋮& \ddots & ⋮\\ {\varphi }_{l,1,n_{l+1}}(·)& \cdots & {\varphi }_{l,n_l,n_{l+1}}(·)\end{array}\right)x^{\left(l\right)},$$

(2)

with ${\varphi }_{l,i,j}$ being the l-th layer’s activation function, which connects the layer’s i-th input node to its j-th output node. These activation functions are given by

$$\varphi \left(x\right)=c_{r}r\left(x\right)+c_{B}B\left(x\right),$$

(3)

where

$$r\left(x\right)={\displaystyle \frac{x}{1+exp\left(-x\right)}}$$

(4)

is the Sigmoid Linear Unit (SiLU) function and

$$B\left(x\right)=\sum _{i=1}^{G+k}{c}_i{B}_i\left(x\right)$$

(5)

is a spline activation composed of $\left(G+k\right)$ B-spline basis functions of order k on a grid with G intervals. The parameters $c_r$, $c_B$, and ${\left\{c_i\right\}}_{i=1}^{G+k}$ of each activation function, and consequently the activation function itself, are trainable. Consequently, the number of trainable parameters within a single KAN layer consisting of $n_{\mathrm{in}}$ input nodes and $n_{\mathrm{out}}$ output nodes is given by

$$\left|\theta \right|=\underset{c_r}{\underbrace{n_{\mathrm{in}}\times n_{\mathrm{out}}}}+\underset{c_B}{\underbrace{n_{\mathrm{in}}\times n_{\mathrm{out}}}}+\underset{{\left\{c_i\right\}}_{i=1}^{G+k}}{\underbrace{n_{\mathrm{in}}\times n_{\mathrm{out}}\times \left(G+k\right)}}=n_{\mathrm{in}}\times n_{\mathrm{out}}\times \left(G+k+2\right).$$

(6)

This quantity provides a clear and universal metric for objectively determining whether a model is lightweight compared to others. In contrast, metrics commonly reported in the literature, such as inference time, are heavily influenced by external factors, including the specific hardware used for execution and the software implementation details or optimization of the model architecture. For instance, recent implementations such as [51] have achieved significantly faster inference speeds compared to pykan, used in this study. Therefore, model complexity, as quantified by the number of trainable parameters, offers a more reliable, consistent, and hardware-independent means of comparison.

Importantly, the fact that the activation functions of KANs are trainable directly contributes to their interpretability. Unlike standard neural networks, whose activations are effectively black-box functions with overly complex mathematical representations in terms of linear layers and non-linear activations, the activation functions of a trained KAN can be analytically approximated by symbolic representations. These provide explicit, human-readable mathematical equations that describe precisely how input features are transformed at each node of the network. As a result, the user can directly analyze, interpret and even derive theoretical insights from the trained model’s functional representation.

Beyond this interpretability, KANs feature an attribution scoring mechanism that provides explainability by quantifying the relative importance of the model’s input features [47]. This requires defining the attribution score of the i-th input node in the l-th layer, denoted by $A_{l,i}$. To compute such scores, one must also define the standard deviation of the l-th layer’s activation function connecting node i to node j as

$$E_{l,i,j}=\sqrt{{\displaystyle \frac{1}{N}}\sum _{s=1}^N{\left[{\varphi }_{l,i,j}\left(x_s\right)-{\displaystyle \frac{1}{N}}\sum _{p=1}^N{\varphi }_{l,i,j}\left(x_p\right)\right]}^2},$$

(7)

where N is the number of samples. Then, $A_{l,i}$ can be calculated recursively via

$$A_{l,i}=\sum _{j=1}^{n_{l+1}}{E}_{l,i,j}·A_{l+1,j}·{\left(\sum _{p=1}^{n_l}{E}_{l,p,j}\right)}^{-1},l\in \left\{L,\cdots ,1\right\},$$

(8)

and the initial condition $A_{L+1,i}=1,\forall i\in \left\{1,\cdots ,n_L\right\}$, i.e., setting the scores of the final layer’s output nodes to 1. Note that the notation refers to input nodes, which is why the subscript is $L+1$, even though the model consists of L layers. The final score for the i-th input feature then simply corresponds to $A_{1,i}$.

This attribution score captures the global importance of a node, as it accounts for more than just the activations on its outbound edges via $E_{l,i,j}$, which are highly local. Instead, $E_{l,i,j}$ is adjusted by the attribution scores $A_{l+1,j}$ of all subsequent nodes, j, that are linked to node i. Additionally, for each of these subsequent nodes, the expression is also normalized by ${\sum }_{p=1}^{n_l}{E}_{l,p,j}$, which takes into account all activations on that node’s inbound edges. Essentially, the recursive relation in Equation (8) ensures that the importance of the i-th node in the l-th layer reflects that node’s contributions on the entire network downstream from the node, underscoring its global nature. The attribution scoring mechanism is illustrated for an example architecture in Figure 1, which provides a visual representation of how each node’s score is influenced by subsequent nodes and the activations along their connecting edges.

2.2. Proposed Framework

Building on these theoretical foundations, the initial objective of the proposed methodology is to leverage the attribution scoring mechanism of KANs for automatic feature selection. To this end, a feature library is first constructed using the existing literature and domain knowledge, automatic feature extraction methods (e.g., [52]), or a combination thereof, depending on the studied problem (bearing faults in the present case). Each data sample is thus represented as a K-dimensional vector, where K is equal to the total number of features in the library. After all data samples are split into distinct training, validation, and evaluation sets, the feature selection process is formulated as a grid-search multi-objective problem.

Specifically, multiple KAN model instances are trained on the training set by minimizing a loss function that incorporates the following regularization term:

$${\mathcal{L}}_{\mathrm{reg}}=\lambda \sum _{l=1}^L\left[{\mathbf{A}}_l-\sum _{i=1}^{n_l}{\displaystyle \frac{A_{l,i}}{{\mathbf{A}}_l}}log\left({\displaystyle \frac{A_{l,i}}{{\mathbf{A}}_l}}\right)\right],$$

(9)

where

$${\mathbf{A}}_l=\sum _{i=1}^{n_l}{A}_{l,i}.$$

(10)

This sparsity-inducing expression corresponds to a mixture of L1 and entropy regularization (first and second summands of Equation (9), respectively), with an overall weight of $\lambda$, corresponding to a hyper-parameter. Each model instance is trained for a fixed number of epochs using a distinct value of $\lambda$, selected from a discretized range $\left[{\lambda }_{\min },{\lambda }_{\max }\right]$. For each model instance corresponding to a particular $\lambda$, the attribution score is computed for all K features using Equation (8). The most important features are then selected based on the condition

$$A_{1,i}\ge \tau ,$$

(11)

where $\tau$ is a hyper-parameter which determines the threshold for feature selection. To ensure an appropriate choice of $\tau$, multiple threshold values are evaluated, drawn from a discretized range $\left[{\tau }_{\min },{\tau }_{\max }\right]$, to identify the most significant features. As a result, each combination of $\left(\lambda ,\tau \right)$ corresponds to a distinct selection of important features.

The optimal values of $\lambda$ and $\tau$ are determined based on a multi-objective criterion: maximizing the performance of a trained model on the validation set while minimizing the number of selected features. To achieve this, model instances are retrained, this time without regularization ($\lambda =0$), and only using the features selected for each combination of $\lambda$ and $\tau$. The results are then analyzed to identify the Pareto front [53], representing the trade-off between model performance and feature count. If the Pareto front contains a single element, the corresponding $\left(\lambda ,\tau \right)$ pair is deemed optimal. In cases where multiple points lie on the Pareto front, an additional rule can be applied to make the final selection—for instance, choosing parameters which lead to the model that achieves the highest performance while using up to k features, where typically, $k\ll K$ to ensure that only the features that contribute the most are retained.

With the feature selection phase complete, the methodology transitions to the model selection phase, which involves hyper-parameter tuning. This stage focuses on KAN-specific parameters, namely the grid size (G) and the grid adaptability factor ($0\le g_e\le 1$), defined via

$$\mathcal{G}=g_e{\mathcal{G}}_u+\left(1-g_e\right){\mathcal{G}}_a,$$

(12)

where ${\mathcal{G}}_u$ and ${\mathcal{G}}_a$ correspond to purely uniform and purely adaptive grids, respectively, and $\mathcal{G}$ is a linear combination of the two [39]. During the feature selection phase, the model instances are trained using a fixed, small grid to prioritize computational efficiency. In the model selection phase, larger grid sizes are also considered, in order to allow the trainable activation functions to capture more intricate patterns in the data by using a greater number of B-spline basis functions. Additionally, incorporating grid adaptivity has been shown to enhance model performance by adapting each layer’s grid to the underlying data structure of its inputs [39,54]. Hyper-parameter tuning is conducted similarly to the feature selection process: a KAN model instance is trained for each configuration of $\left(G,g_e\right)$ over a fixed number of epochs, and its performance is evaluated on the validation set. However, in this phase, performance is assessed along two axes: the performance of the trained KAN itself, as well as the performance of its symbolic version.

As discussed in the context of KANs’ interpretability, the trained activation functions can be replaced with symbolic functions selected from a predefined library. The optimal symbolic function for each layer is determined as the one minimizing a cost function that balances high $R^2$ values of the symbolic fit against the symbolic function’s complexity. Complexity can be assigned in various ways, for example, based on the statistical occurrence of functions in physical formulae [55]. In this work, complexities are assigned in a way that ensures consistency with the PySR framework [56], widely recognized as the state-of-the-art open-source solution for symbolic regression tasks. In the present work, the cost function is given by

$$\mathcal{C}\left(C,R^2\right)=exp\left(\alpha C\right)+\beta ln\left(1-R^2\right),$$

(13)

where $R^2$ is the fit’s $R^2$ score, C denotes the assigned complexity of the symbolic function, and $\alpha$ and $\beta$ are parameters that control the penalty for function complexity and the reward associated with the fit quality, respectively. The symbolic library utilized in this work is provided in Appendix A, along with all assigned complexities. Naturally, such libraries cannot be exhaustive, but they provide a good starting point for deriving interpretable symbolic representations.

Following each trained model’s evaluation on the validation set, both with and without symbolic fitting, the Pareto front for the performance metrics of the regular and symbolic KAN models is identified. Similar to the feature selection phase, if the Pareto front is a singleton, then the corresponding $\left(G,g_e\right)$ values are selected. However, if the Pareto front includes multiple points, additional rules are necessary for the selection. With the most important features identified during the feature selection phase and the optimal model hyper-parameters determined during model selection, the training and validation sets are combined, and a final model instance is trained on their union. This model is subsequently evaluated on the isolated evaluation set to provide a final and unbiased performance assessment. A symbolic version of this final model is also extracted. While its performance is generally expected to be lower than that of the regular KAN model, the symbolic version offers a more interpretable alternative, which may be preferable in scenarios where explainability is prioritized over optimal performance. A schematic representation of the complete framework can be seen in Figure 2.

3. Datasets and Feature Extraction

As previously outlined, the proposed framework has been designed for applicability across a wide range of problems beyond bearing faults. To apply it for bearing fault detection and classification, two widely recognized datasets are selected: the CWRU bearing dataset [49] and the Machinery Fault Database (MaFaulDa) dataset [57,58]. The CWRU dataset is chosen due to its characterization as a dataset where feature selection is highly nontrivial, containing data that deviate from the typical characteristics expected for certain fault types [6]. The MaFaulDa dataset, on the other hand, is selected for its broader scope, as it includes not only bearing faults but also additional types of machinery faults, thereby enabling the demonstration of the framework’s generalizability within a single dataset. Before detailing the process of constructing a feature library from the raw time-series signals of the two datasets, a more detailed introduction to each dataset is provided in Section 3.1 and Section 3.2.

3.1. CWRU Dataset

The CWRU dataset was generated using a test rig designed to simulate bearing faults under controlled conditions. The setup consisted of a 2-horsepower motor, a torque transducer, and a dynamometer, with the test bearings supporting the motor shaft. Three types of single-point faults were induced in the bearings using electro-discharge machining, inner raceway (IR), ball (B), and outer raceway (OR) faults, with fault diameters ranging from 7 mils (1 mil is equivalent to 0.001 inches) to 40 mils. Faults were applied to both the drive-end and fan-end bearings. The dataset comprises vibration measurements collected using accelerometers attached to the motor housing at the 12 o’clock position for both the drive-end and fan-end bearings, with an additional accelerometer attached to the base plate in some experiments. The signals were recorded at sampling rates of 12 kHz and, for certain drive-end faults, 48 kHz. For OR faults, experiments were conducted at different positions relative to the load zone (3 o’clock, 6 o’clock, and 12 o’clock) to capture variations in the vibration response. Thus, the dataset contains six classes for classification, labeled as N (normal), B, IR, OR@3, OR@6, and OR@12.

The original dataset’s files can be categorized along several axes. Based on motor speed, the files are divided into four groups: 1730, 1750, 1772, and 1797 rotations per minute (RPM). Based on fault location and sampling rate, the dataset includes normal files measured at 48 kHz, drive-end faults measured at 12 kHz, fan-end faults measured at 12 kHz, and drive-end faults measured at 48 kHz. Additionally, the files differ in terms of the time-series data they contain: some include only drive-end measurements, most include both drive-end and fan-end measurements, and a few include drive-end, fan-end, and base measurements. Due to the inconsistencies mentioned in [59], the version of the dataset curated for the purposes of the cited work was used. Moreover, all 48 kHz drive-end measurements were excluded for two reasons: to ensure uniformity, as corresponding fan-end measurements at 48 kHz were unavailable, and because these files exhibited significant variability in the number of measurements, making them unsuitable for consistent sampling for the purposes of feature extraction. This process resulted in a total of 101 retained files.

3.2. MaFaulDa Dataset

The MaFaulDa dataset was created using a test rig designed to emulate the dynamics of motors with two shaft-supporting bearings. It comprises multivariate time-series data collected from sensors mounted on a SpectraQuest alignment/balance vibration trainer machinery fault simulator. The sensors included one triaxial accelerometer for the underhang bearing (the bearing located between the motor and rotor) and three industrial accelerometers for the overhang bearing (the bearing located outside the rotor, opposite the motor), oriented along the axial, radial, and tangential directions. Additionally, an analog tachometer measured the system’s rotational frequency, and a microphone captured operational sound. All signals were recorded at a sampling rate of 50 kHz over a duration of 5 s.

The dataset includes scenarios representing both normal operation and various fault conditions. In the normal class (N), the system operated without faults across 49 distinct rotation frequencies, ranging from 737 to 3686 RPM at approximately 60 RPM intervals. Bearing faults, similar to those in the CWRU dataset, involved defects in the inner raceway (IR), ball (B), and outer raceway (OR). These faults were studied in both bearings, underhang and overhang, one at a time. To ensure fault detectability, additional imbalances of 6 g, 10 g, and 20 g were introduced. Bearing fault scenarios were recorded under 49 rotation frequencies for lighter imbalances, while fewer frequencies were studied for heavier ones due to increased vibrations.

Beyond bearing faults, the dataset also includes additional machinery faults, namely imbalance (I) and axis misalignment. Imbalance faults were simulated by attaching varying load weights (6 g to 35 g) to the rotor. For weights up to 25 g, all 49 rotation frequencies were studied, whereas higher weights limited the maximum frequency to 3300 RPM due to increased vibrations. Axis misalignment was divided into horizontal misalignment (HM) and vertical misalignment (VM), induced by shifting the motor shaft by offsets of 0.5 mm to 2.0 mm for the former, and 0.51 mm to 1.9 mm for the latter. For each misalignment severity, the same 49 rotation frequencies as in the normal class were studied. In total, the dataset corresponds to 10 distinct classes and comprises 1951 data files, all of which were retained for feature extraction.

3.3. Feature Library

The extracted features were acquired by first augmenting and then preprocessing data from both datasets. Data augmentation was particularly critical for the CWRU dataset, which contained only four data files per fault type and severity—corresponding to the four rotational frequencies studied. In contrast, the MaFaulDa dataset included nearly 50 examples per fault case, yet augmentation was still applied to further enhance the dataset. The first step involved identifying the rotational frequency, $f_r$, for each file. For the CWRU files, the exact RPM values were already known. However, for the MaFaulDa dataset, where the RPM values were estimated per file, the rotational frequency was calculated using the two-step algorithm proposed in [60], based on the tachometer signal. This method was selected to avoid misidentification of $f_r$, which could otherwise be obscured by spectral peaks introduced by machine faults in the signal’s frequency spectrum.

Once the rotational frequency was determined, it was combined with the sampling rate, $F_s$, to split each time-series into smaller segments of $N·F_s/f_r$ data points, where N represents the number of complete motor rotation cycles. The choice of N balances the trade-off between dataset size and segment quality: a smaller value leads to more segments but at the cost of lower quality, while a larger value preserves the original time-series’ quality at the expense of limited samples. For this study, $N=48$ was chosen as a compromise, yielding approximately six segments per file for the CWRU dataset. The same number of cycles was chosen for the MaFaulDa dataset to maintain consistency, resulting in augmented datasets containing 603 and 6268 segments for CWRU and MaFaulDa, respectively.

Using the augmented datasets, a series of time-domain, frequency-domain, and time–frequency features were extracted, based on the established literature on machinery fault diagnosis. For the time-domain features, the extracted metrics included the RMS, mean, variance, skewness, kurtosis, entropy, shape factor, crest factor, impulse factor, and margin factor, along with histogram upper and lower bounds, as described in [16]. From the frequency domain, spectral skewness and kurtosis were calculated after applying an FFT to each signal. Additionally, the signal magnitudes at the fundamental frequency and its first two harmonics were extracted, following [58].

For time–frequency features, wavelet transformations were employed, as they are highly effective for identifying machinery faults. The pywavelets library [61] was used to perform a multilevel decomposition of order 4 on each segment, utilizing a biorthogonal wavelet. Following [7], the features derived from the fine-grained wavelet coefficients included the mean, median, RMS, standard deviation, variance, skewness, kurtosis, and entropy. The percentile values at the 5th, 25th, 75th, and 95th levels were also extracted, along with the number of mean and zero crossings. Using this approach, a feature library of 62 and 243 features was compiled for the augmented CWRU and MaFaulDa datasets, respectively. This corresponds to 31 features per dataset signal, with the exception of the tachometer signal in MaFaulDa, from which no spectral features were extracted [58].

A detailed list of all extracted features for this work is provided in Appendix B. It should be noted that certain features overlap in terms of the information they encode; for instance, the impulse factor is the product of the crest and shape factors, while the standard deviation is the square root of the variance. This intentional redundancy allows the framework to identify the most relevant features automatically and discard the rest during the feature selection process. After all, if the most effective features for the studied problem were already known, the feature selection phase would be redundant.

4. Experimental Results

This section presents the experimental findings obtained by applying the proposed framework to the two constructed feature libraries, addressing three distinct tasks, fault detection, fault classification, and severity classification, for each fault type. Exclusively shallow KANs, i.e., models with a single layer, were considered throughout the experiments to minimize the number of model parameters, thus ensuring that the models remain lightweight and their symbolic representation does not become overly complex.

For all tasks, the datasets were split in a stratified manner into training, validation, and evaluation sets in a 70%-15%-15% ratio, respectively, and the features were standardized. Model training was performed with the Adam optimizer, using Cross-Entropy as the non-regularizing loss function, as all tasks were classification problems. The primary performance metric was the F1-Score, chosen for its greater suitability in handling imbalanced datasets compared to accuracy. The KAN implementation and training were performed using the PyTorch 2.4 [62] and pykan [39,47] frameworks, running on a single NVIDIA GeForce RTX 4070 GPU.

During the feature selection phase, KANs with $k=3$, $G=5$ and $g_e=0.05$ were trained non-adaptively for 80 epochs. Regarding hyper-parameter tuning, the regularization parameter $\lambda$ spanned the range $\left[0.01,0.1\right]$; values below ${10}^{-2}$ had no discernible regularizing effect, while values above ${10}^{-1}$ imposed overly strict regularization, hindering the network’s training. The feature selection threshold parameter, $\tau$, was in the range of $\left[0.001,0.01\right]$; values smaller than ${10}^{-3}$ generally retained all candidate features, whereas those greater than ${10}^{-2}$ typically discarded (almost) all features. Both ranges were discretized into 20 equidistant points. When multiple Pareto-optimal solutions were identified, the model achieving the highest F1-Score with up to 10 features was selected. This constraint is intentionally strict, as most state-of-the-art models utilize at least 15 features on these datasets; however, developing lightweight models focused only on the most informative features aligns with the study’s primary objective.

For the model selection phase, higher-order KANs with $k=4$ were employed. Grid search was conducted over $G\in \left\{8,10,12,15,20,30,40,50\right\}$ and $g_e\in \left\{0.0,0.05,\cdots ,1.0\right\}$. The range of $g_e$ naturally spans the interval $[0,1]$, whereas the maximum considered value of G was limited to 50, as larger grids would be unnecessarily complex for single-layer architectures. This choice is further supported by the obtained results, where the optimal value of G never exceeded 20. Each model instance was trained adaptively for 200 epochs, with grid updates performed every 10 epochs until epoch 150. For the symbolic fitting cost function given in Equation (13), parameters $\alpha =0.05$ and $\beta =1.5$ were selected to prioritize high $R^2$ values over low complexity, unless model complexity became excessively high, triggering the exponential penalty term to dominate. In cases where the resulting Pareto front contained multiple candidate models, the one with the highest average F1-Score between the original and symbolic representations was selected.

4.1. Fault Detection

For the fault detection task, all data samples were categorized into two classes, normal (N) and faulty (F), with the latter encompassing all fault types. Fault detection is generally simpler than fault classification, as the model only needs to distinguish between normal and anomalous data. However, this task suffers from a significant imbalance in class representation, which presents a major challenge.

In both the CWRU and MaFaulDa datasets, the normal class is severely underrepresented. For the CWRU dataset, the normal class constitutes only 3.96% of the dataset, while the other classes range from 11.88% to 23.76%. Similarly, in the MaFaulDa dataset, the normal class accounts for just 2.51%, with the remaining classes spanning from 7.02% to 17.07%. When restructured for fault detection, the imbalance becomes even more pronounced, with the normal class constituting only 3.96% versus 96.04% for the faulty class in the CWRU dataset, and 2.51% versus 97.49% for the faulty class in the MaFaulDa dataset. This extreme imbalance means that even a trivial classifier which predicts all entries as faulty would achieve a high accuracy (e.g., 97.49% for MaFaulDa) while failing to provide any meaningful insights.

To address this imbalance, a balancing strategy is required. Among the common approaches are undersampling the dominant class or oversampling the minority class using techniques such as Synthetic Minority Oversampling (SMOTE) [63]. For this work, undersampling was adopted; specifically, 30 samples from each fault class in the CWRU augmented dataset and 60 samples from each fault class in the MaFaulDa augmented dataset were randomly selected. This adjustment reduced the imbalance to 12.28% normal versus 87.72% faulty for CWRU and 22.86% normal versus 77.14% faulty for MaFaulDa. Although still imbalanced, these distributions are far more manageable.

Following this preprocessing step, the framework’s feature selection process, as detailed in Section 2, was applied to identify the most relevant features for fault detection. Regarding the CWRU dataset, the Pareto front resulting from the $\left(\lambda ,\tau \right)$ grid search was a singleton, yielding $\lambda =2.42\times {10}^{-3}$ and $\tau =7.16\times {10}^{-2}$. These values resulted in the selection of a single feature, $x_{24}^2$ (the 25th percentile value for the drive-end signal; see Appendix B), as illustrated in Figure 3. Proceeding to the model selection phase, the grid search using only this feature again produced a Pareto front with a single point, corresponding to $G=8$ and $g_e=0.0$. Based on Equation (6), the resulting KAN model comprised only 28 trainable parameters. The combination of a single feature and a small yet fully adaptive grid suggests that fault detection in the CWRU dataset is relatively straightforward, so approaching the task with a complex model is neither necessary nor a good practice. This is further corroborated by the final evaluation of the chosen model, for both the regular and symbolic versions of the KAN, as shown in the confusion matrices of Figure 4.

The selection of a single feature offers the opportunity to highlight the importance of extracting symbolic representations for the trained KAN, thus making its decisions and architecture fully interpretable. In this case, the symbolic representations of the KAN’s output edges are given by

$$y_1\left(x\right)=42.62-76.65\sigma \left(7.69-7.51x\right),$$

(14)

and

$$y_2\left(x\right)=10.85-52.3tanh\left(10x-8.52\right),$$

(15)

where x denotes the scaled feature and $\sigma \left(x\right)=0.5\left[1+tanh\left(x/2\right)\right]$ is the sigmoid function. It is noted that all numbers have been rounded to the second digit. Using these analytical expressions, a sample is classified as normal if $y_1\left(x\right)>y_2\left(x\right)$, and as a fault if $y_1\left(x\right)<y_2\left(x\right)$. Equations (14) and (15) allow for the study of otherwise inaccessible (or hard to compute) properties of the classification problem, such as determining the decision boundary by solving $y_1\left(x\right)=y_2\left(x\right)$. Figure 5 illustrates the two curves alongside all CWRU data points, color-coded by class. The decision boundary is also depicted, demonstrating that all of the dataset’s samples are correctly classified using these symbolic expressions.

The same procedure was applied to the MaFaulDa dataset. In this case, the feature selection process resulted in a Pareto front with three candidate points. The corresponding $\left(\lambda ,\tau \right)$ values, the associated F1-Scores for each point, and the number of features retained are presented in

Table 1. Combinations of $\lambda ,\tau$ within the Pareto front and the corresponding model performance and number of retained features.

$\mathit{\lambda }$ ($\times {10}^{-3}$)	$\mathit{\tau }$ ($\times {10}^{-2}$)	F1-Score	No. of Features
$1.00$	$9.05$	$97.07$%	4
$1.47$	$6.68$	$98.07$%	6
$2.90$	$4.32$	$100.00$%	9

. Although the configuration with the fewest features also exhibited the lowest performance, it still achieved a remarkably high F1-Score of 97.07%. Notably, the four features selected in the lowest-performing case are a subset of the six features selected in the middle-performing case, which, in turn, are a subset of the nine features selected in the highest-performing case. This hierarchical relationship highlights the consistency of the framework. Following the selection rule of prioritizing the highest-performing configuration with no more than 10 features, the combination $\lambda =2.9\times {10}^{-3}$ and $\tau =4.32\times {10}^{-2}$ was chosen. This configuration retained nine features, $x_6^2$, $x_{15}^4$, $x_{30}^4$, $x_4^5$, $x_{30}^5$, $x_{31}^5$, $x_{11}^6$, $x_2^7$, and $x_{23}^8$, as illustrated in Figure 6.

For the model selection phase, using the nine selected features, the grid search over G and $g_e$ produced a Pareto front with a single point, corresponding to $G=8$ and $g_e=0.05$, similar to the results for the CWRU dataset. The final model had 252 trained parameters and achieved an F1-Score of 100% in its regular form and 98.08% after symbolic fitting. This result is not unexpected, as symbolic fitting cannot always perfectly replicate the trained activation function using analytical expressions. Consequently, the trade-off between performance and interpretability must always be considered; however, in this case, the performance impact is minimal. The performance in terms of each KAN version’s confusion matrices can be seen in Figure 7. When it comes to the KAN’s symbolic activation functions for this case, they are nine-dimensional, meaning that the visualization of their decision boundary—now corresponding to a 9-dimensional hypersurface—would require a 10-dimensional equivalent of Figure 5. Although such a depiction is impractical, these expressions remain computationally inexpensive and provide valuable insights into the model’s predictions, for instance, by keeping most features constant and examining decision boundaries as one or two features vary. Notably, the presence of multiple features allows for an analysis of their final importance in the trained model’s predictions. The normalized feature attribution scores, depicted in Figure 8, illustrate the relative contribution of each selected feature.

4.2. Fault Classification

Moving to fault classification, no oversampling or undersampling techniques were applied, despite the datasets being imbalanced as previously noted. For the CWRU dataset, the feature selection grid search yielded $\lambda ={10}^{-3}$ and $\tau =6.68·{10}^{-2}$ as the optimal parameters, resulting in the selection of the following seven features: $x_4^1$, $x_{10}^1$, $x_{15}^1$, $x_1^2$, $x_3^2$, $x_{15}^2$, and $x_{20}^2$. During model selection, the corresponding grid search identified a model with $G=12$ and $g_e=0.5$ as achieving the highest average F1-Score between its regular and symbolic versions. The final feature importance scores for this model, consisting of 756 trainable parameters and evaluated on the evaluation set, are shown in the left plot of Figure 9. The model in its regular form achieved a perfect F1-Score of 100%, while the symbolic version slightly underperformed at 97.80%. The corresponding confusion matrices for both versions are provided in Figure 10.

Applying the same approach to the MaFaulDa dataset, the feature selection process yielded a large Pareto front, ranging from models that retained a single feature (with poor performance) to those retaining up to 70 features (achieving a validation set F1-Score of 99.89%). The selected configuration, $\lambda =7.63·{10}^{-3}$ and $\tau =3.37\times {10}^{-2}$, resulted in the retention of ten features: $x_9^3$, $x_{29}^3$, $x_{29}^4$, $x_{31}^4$, $x_{16}^5$, $x_{29}^5$, $x_{30}^5$, $x_{31}^5$, $x_{15}^6$, and $x_{31}^6$. The subsequent grid search for optimal model hyper-parameters produced a smaller Pareto front with only two points. Among these, the configuration $G=12$ and $g_e=0.15$ was chosen, corresponding to 1800 trainable parameters, and evaluated on the evaluation set. The selected model achieved a final F1-Score of 97.24% in its regular form and 92.03% in its symbolic form. The normalized feature attribution scores for the final model are shown in the right plot of Figure 9, while the corresponding confusion matrices are depicted in Figure 11.

It becomes evident that, unlike in the fault detection task, fault classification requires a greater number of features for each dataset to capture the details required for a more fine-grained classification than a binary one. For the CWRU dataset, the trained KAN once again achieved a perfect F1-Score in its regular form. However, for the MaFaulDa dataset, even the regular version of the KAN left some data points misclassified. This is not unexpected, as the MaFaulDa dataset includes not only bearing faults but also additional machinery faults. This, in fact, highlights the generalizability of the proposed framework, demonstrating its ability to perform well in more diverse scenarios beyond the narrower domain of bearing faults. It is worth noting that higher performance could have been achieved by increasing the number of selected features or adding more layers to the KAN. However, the focus of this study is not solely on achieving perfect scores but rather on promoting lightweight models with minimal parameters, favoring interpretability and ensuring suitability for deployment in resource-constrained environments.

4.3. Severity Classification

Apart from fault detection and classification, both datasets allow for an additional type of investigation: the analysis of fault severity. For the CWRU dataset, all faults have three severity levels: 7 mils, 14 mils, and 21 mils. An exception to this is OR@12 faults, which only have two severity categories: 7 mils and 21 mils. For the MaFaulDa dataset, severity classification encompasses a broader range of categories across different fault types. Imbalance faults are categorized into seven severity levels, corresponding to imbalance loads ranging from 6 g to 35 g. Horizontal misalignment faults have four severity levels (0.5 mm, 1.0 mm, 1.5 mm, and 2.0 mm), while vertical misalignment faults have six severity levels (0.51 mm, 0.63 mm, 1.27 mm, 1.4 mm, 1.78 mm, and 1.9 mm). Additionally, the bearing faults in the MaFaulDa dataset are all classified into four severity levels, determined by the extra imbalance introduced to amplify their effects, ranging from 0 g to 20 g.

Given these structured severity levels, it is natural to approach severity analysis as a classification problem. To this end, the proposed framework was applied, following the established processes of feature selection, model selection, and model evaluation for each fault type’s severity classification.

Table 2. Results for severity classification on the different fault types of the CWRU dataset. In the F1-Score column, both the regular and symbolic versions are reported.

Fault	Features	Params	G	${\mathit{g}}_{\mathit{e}}$	F1-Score
IR	[$x_{21}^2$]	42	8	$0.00$	$95.45$–$100.00$%
B	[$x_{15}^1$, $x_{28}^1$, $x_{27}^2$]	144	10	$0.40$	$100.00$–$95.45$%
OR@3	[$x_{28}^1$]	42	8	$0.00$	$100.00$–$100.00$%
OR@6	[$x_{21}^1$, $x_{15}^2$]	84	8	$0.00$	$100.00$–$100.00$%
OR@12	[$x_{25}^1$]	28	8	$0.50$	$100.00$–$100.00$%

and

Table 3. Results for severity classification on the different fault types of the MaFaulDa dataset. In the F1-Score column both the regular and symbolic versions are reported.

Fault	Features	Params	G	${\mathit{g}}_{\mathit{e}}$	F1-Score
I	[$x_{23}^1$, $x_1^3$, $x_{24}^3$, $x_{25}^3$, $x_1^4$, $x_{11}^4$, $x_{18}^5$, $x_{31}^5$, $x_{18}^6$, $x_{15}^8$]	1120	10	$0.05$	$95.71$–$91.35$%
HM	[$x_2^3$, $x_3^3$, $x_{24}^3$, $x_{25}^3$, $x_6^4$, $x_9^4$, $x_{31}^6$, $x_2^8$]	512	10	$0.10$	$100.00$–$100.00$%
VM	[$x_{23}^1$, $x_{26}^1$, $x_{22}^3$, $x_{24}^3$, $x_6^4$, $x_{18}^5$, $x_{19}^5$, $x_{30}^5$, $x_{18}^6$, $x_6^8$]	1560	20	$0.10$	$86.67$–$87.40$%
UB	[$x_9^2$, $x_1^3$, $x_1^4$, $x_1^5$, $x_1^7$, $x_{30}^7$, $x_6^8$]	392	8	$0.20$	$98.89$–$97.79$%
UIR	[$x_3^2$, $x_{11}^3$, $x_{25}^3$, $x_{29}^3$, $x_1^4$, $x_4^4$, $x_1^5$, $x_{30}^5$, $x_4^7$]	504	8	$0.05$	$100.00$–$100.00$%
UOR	[$x_{23}^1$, $x_2^2$, $x_4^3$, $x_8^3$, $x_1^4$, $x_4^4$, $x_{30}^6$]	448	10	$0.00$	$100.00$–$95.54$%
OB	[$x_1^2$, $x_1^3$, $x_1^4$, $x_1^5$, $x_1^6$, $x_3^6$, $x_1^7$, $x_9^7$]	832	20	$0.40$	$96.48$–$94.29$%
OIR	[$x_2^3$, $x_1^4$, $x_{15}^4$, $x_4^6$, $x_{15}^6$, $x_{31}^7$]	336	8	$0.15$	$100.00$–$97.82$%
OOR	[$x_1^3$, $x_2^3$, $x_4^3$, $x_8^3$, $x_1^4$, $x_9^4$, $x_1^7$, $x_4^7$]	448	8	$0.20$	$98.91$–$98.91$%

present the intermediate (i.e., feature selection and model selection outcomes) and final (i.e., F1-Scores for both the regular and symbolic KANs on the evaluation set) results for the CWRU and MaFaulDa datasets, respectively. For each model, the corresponding number of total trainable parameters is also reported.

Based on these results, previous observations regarding the relative simplicity of the CWRU dataset are reaffirmed: once again, the severity of each fault type can be classified with perfect accuracy using a very small number of features (no more than three), with only a single misclassification occurring in the case of IR faults. Notably, in this instance, the symbolic version of the KAN outperforms the regular version, achieving perfect classification accuracy. Another indicator of the CWRU dataset’s simplicity is that the model instances consistently utilize the smallest permitted grid size ($G=8$), with only one exception requiring $G=10$. In contrast, the MaFaulDa dataset demonstrates greater complexity. Larger grid sizes, such as $G=20$, are employed in several cases, and the number of utilized features is generally higher, often reaching the maximum of ten to achieve the reported results. Nonetheless, with the exception of vertical misalignment faults, all severities across all fault categories achieve F1-Scores exceeding 95% for the regular KAN, underscoring the effectiveness of the proposed framework even in more diverse and challenging scenarios.

Interestingly, the patterns observed for feature prevalence in fault detection and classification tasks do not carry over to severity classification. Specifically, while time-domain and frequency-domain features dominated the fault detection and classification tasks for CWRU, and wavelet-based features were dominant for MaFaulDa, the opposite trend is observed in the severity classification task. Approximately two-thirds of the selected features for severity classification in CWRU and MaFaulDa are wavelet-based features and time- or frequency-domain features, respectively. This observation highlights the distinction between fault identification/classification and severity quantification. From a feature selection perspective, it confirms that no single feature set is universally suitable for all tasks, emphasizing the value of the proposed framework for automatic feature selection from a diversified feature library.

5. Discussion and Conclusions

In the present study, a novel framework leveraging KANs was developed and applied to bearing fault detection and classification, as well as fault severity classification tasks. The framework utilizes an attribution scoring mechanism coupled with a grid-search-based multi-objective optimization procedure for automatic feature selection from an extensive feature library and hyper-parameter tuning. By design, it emphasizes lightweight models with interpretable outputs, which is achieved by training shallow KANs and subsequently replacing their activation functions with analytical expressions drawn from a symbolic library. This approach prioritizes not only high performance, but also deployability and explainability, both of which are essential for real-world applications.

The framework was validated using two widely recognized datasets, CWRU and MaFaulDa, which were processed and augmented to enable feature extraction for the construction of a feature library. The experimental results demonstrated the framework’s effectiveness across all tasks. For fault detection, it achieved perfect performance on both datasets, highlighting its capability to distinguish between normal and faulty conditions even under significant class imbalance. In fault classification, the CWRU dataset proved relatively straightforward, with the framework again achieving perfect F1-Scores. In contrast, the MaFaulDa dataset required more features and larger grids to handle its increased complexity, yet the regular version of the trained KAN still achieved a 97.24% F1-Score on the evaluation set. For severity classification, the framework accurately identified fault severity levels with high F1-Scores in the regular KAN model instances: 100% for four out of five fault types of the CWRU dataset, and greater than 95% for all fault types in the MaFaulDa dataset, with the exception of VM faults. These results showcase the framework’s adaptability across diverse fault types and severity categories. Finally, while the symbolic versions of the models occasionally exhibited slightly reduced performance compared to their regular version, they are, in general, invaluable in terms of the interpretability they offer.

When comparing our results to those of other studies, it is important to highlight that the usage and handling of datasets such as CWRU and MaFaulDa vary significantly depending on the proposed framework and the targeted diagnostic tasks. For instance, some studies divide the CWRU dataset into 10 classes rather than the 6 used here, while others reduce it to as few as 4 classes [6]. Moreover, our work uniquely addresses fault detection, fault classification, and severity classification simultaneously within the same unified framework, an approach seldom seen in the existing literature. Additionally, variations in feature extraction methods and data-splitting strategies further complicate direct comparisons across different approaches, particularly given the absence of universally accepted benchmarks or standardized procedures for utilizing these datasets. Despite these differences, numerous existing deep learning-based methods also report near-perfect or perfect scores similar to our own. However, as clearly illustrated in

Table 4. Architecture complexity of related works employing deep learning architectures to study any of the three tasks studied herein using the CWRU or MaFaulDa datasets.

Reference	Dataset	Architecture	Params
[64]	CWRU	CNN	718,570
[65]	CWRU	1D CNN	$\mathcal{O}\left({10}^5\right)$
[65]	CWRU	2D CNN	$\mathcal{O}\left({10}^5\right)$
[65]	CWRU	1D MK-CNN	$\mathcal{O}\left({10}^5\right)$
[65]	CWRU	LSTM	$\mathcal{O}\left({10}^4\right)$
[65]	CWRU	BiLSTM	$\mathcal{O}\left({10}^5\right)$
[66]	CWRU	CNN & LSTM	73,480
[67]	MaFaulDa	DNN	21,538
[68]	MaFaulDa	CNN	306,430
[69]	MaFaulDa	CNN	$\mathcal{O}\left({10}^5\right)$

, these methods typically rely on significantly more complex models with a substantially higher number of trainable parameters. Specifically, the complexity of deep learning architectures reported in the literature often exceeds that of our trained models by one to three orders of magnitude, highlighting our framework’s successful integration of high performance with remarkably lightweight architectures.

Along with parameter efficiency, explainability is another critical aspect of this framework, which is why shallow KANs with a limited number of features were prioritized. Beyond solving the task at hand, the framework can provide significant insights, such as identifying the most relevant signal types for each task or dataset. For instance, Figure 12 offers a breakdown of the frequency of each signal’s contribution to the feature library for the MaFaulDa dataset. Across all seven experiments conducted for the CWRU dataset (fault detection, fault classification, and five severity analyses), the drive-end and fan-end signals were equally represented among the selected features, with a perfect 50–50% ratio. Conversely, for the MaFaulDa dataset, the tachometer and microphone signals were consistently underrepresented in the selected features, underscoring their limited relevance to the studied tasks. In contrast, signals from the underhang bearing (denoted by U) accounted for approximately 50% of the selected features across all tasks.

Apart from a signal-centered analysis, further analysis of the selected feature types per task provides valuable insights into the nature of each dataset and task complexity. In the case of the CWRU dataset, faults were relatively easier to detect, allowing the fault detection task to rely exclusively on a single statistical feature extracted from time-domain signals. Fault classification, being slightly more complex, required a combination of time-domain statistical features and time–frequency domain features derived from wavelet transforms, while purely frequency-domain features were not selected at all. On the other hand, the MaFaulDa dataset demonstrated higher complexity, necessitating a more diverse set of features across all tasks. Fault detection and classification involved a comprehensive selection from time-domain, frequency-domain, and wavelet-based time–frequency domain features. Notably, severity classification tasks heavily favored wavelet-based features, underscoring their ability to effectively capture fault severity variations. Additionally, an interesting observation emerged regarding the magnitude at the fundamental frequency: while seldom selected for fault detection or general fault classification, this frequency-domain feature was consistently among the most influential for severity classification across different fault categories. These observations highlight the flexibility and robustness of the proposed framework in effectively adapting its feature selection strategy to varying task complexities and dataset characteristics.

Combining all of the above, a practical implementation of this framework in a real-world scenario could focus on identifying or classifying bearing faults—or any type of machinery fault, given the framework’s generalizability. Example industrial applications span from condition monitoring and fault diagnosis in wind turbines to industrial pumps, aero-engines, and manufacturing. Using historical data, the framework could first identify the optimal set of sensors to install on the machinery, reducing costs by focusing only on the most informative signals. Once the sensors are installed, signal data could be used to construct feature libraries based on domain knowledge while the framework automates feature selection for the specific tasks at hand. The resulting lightweight models could be deployed online for real-time inference through MLOps platforms like MLflow [70], with inference being rapid due to the models’ minimal computational requirements. Periodic retraining of the models could also be seamlessly integrated into the same platform, with short training times owing to the models’ small number of parameters. Furthermore, in the event of other types of faults or issues arising within the machinery, the framework’s versatility would allow it to be extended to address and analyze these problems as well.

Beyond these industrial applications, the framework also holds significant potential for scientific tasks, particularly in the domain of symbolic regression. Building on the groundwork of [47], this framework offers an alternative to traditional symbolic regression methods, avoiding the computational overhead typically associated with genetic algorithms. For instance, in scientific problems where the underlying equation describing the data is not known, the cost function defined in Equation (13) could be utilized to generate multiple symbolic expressions per run by varying the parameters $\alpha$ and $\beta$, effectively creating a grid-search process similar to those detailed in this work. From the resulting expressions, the optimal one could be selected using a defined metric or based on domain-specific knowledge, such as dimensional constraints.