Multi-Class Electrical and Mechanical Fault Classification Using Random Convolutional Kernels
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.
Tom: I'm Tom.
Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.
Tom: We're looking at the paper: "Multi-Class Electrical and Mechanical Fault Classification Using Random Convolutional Kernels".
Jane: Here's the gist of the paper. Diagnosing faults in rotating machinery is essential for ensuring the reliability of industrial processes <ref:2608.18716#pg2>.
Tom: Random convolutional kernel-based Time Series Classification (TSC) methods, such as ROCKET and its variants, provide an attractive trade-off between predictive performance and computational efficiency <ref:2608.18716#pg2>.
Jane: In this work, SelF-Rocket achieves the best overall accuracy–latency trade-off among the evaluated methods <ref:2608.18716#pg2>.
Tom: Problem Context Fault diagnosis in rotating machinery is a recurring problem in industrial processes <ref:2608.18716#pg3>.
Paper summary: Tom: So we're looking at this paper titled "Multi-Class Electrical and Mechanical Fault Classification Using Random Convolutional Kernels". Basically, they’re trying to diagnose faults in rotating machinery, which is super important for keeping industrial processes reliable <ref:2608.18716#pg1>.
Jane: That sounds like a big deal because fault diagnosis in these machines is usually tough, relying on this kind of machine learning approach instead of just traditional methods that need expert knowledge <ref:2608.18716#pg3>. So, what are they proposing here?
Tom: They’re using a specific type of method called Random Convolutional Kernel-based Time Series Classification, and they’ve put it into a new framework called SelF-Rocket <ref:2608.18716#pg1>. The main claim is that this SelF-Rocket approach finds the best trade-off between how accurate the prediction is and how fast the computer has to run <ref:2608.18716#pg2>.
Lu: From what I'm seeing in their architecture, they extend MiniRocket by adding a feature selection module during training <ref:2608.18716#pg4>. They are automatically picking the best way to represent the input data and how to pool those features <ref:2608.18716#pg4>.
Meng: What does that feature selection actually mean for us when we're deploying something in a real factory setting? Does it just make training faster, or does it give us something better than the standard setup?
Lu: It’s about automatically selecting the optimal combination of input representation and pooling operator during training <ref:2608.18716#pg4>. They are considering three different ways to look at the data: raw series, its first-order difference, and a mix of those two things <ref:2608.18716#pg4>.
Jane: That sounds like they’re trying to figure out what kind of input data gives the most useful signal without having to manually guess it <ref:2608.18716#pg4>. So, how do they handle the actual classification part?
Tom: For the activation map aggregation stage, they select a random subset of input dimensions called Skappa to create a single activation map for each kernel kappa <ref:2608.18716#pg4>. This modification is supposed to mean that the computational complexity doesn't scale linearly with the number of input dimensions <ref:2608.18716#pg4>.
Meng: Scaling down the complexity sounds good for real-time applications, but if you’re dealing with high-dimensional multivariate time series, how does that actually translate to a practical deployment cost?
Lalam: The paper mentions they are evaluating this on two public benchmark datasets: MaFaulDa for mechanical faults and ITSC-UDG for electrical faults <ref:2608.18716#pg3>. These datasets give us concrete numbers to look at <ref:2608.18716#pg2>.
Jane: MaFaulDa has about one thousand nine hundred fifty-one multivariate time series recorded over five seconds using eight measurement channels <ref:2608.18716#pg3>. That’s a lot of data for mechanical faults, including things like rotor imbalance and bearing defects <ref:2608.18716#pg2>.
Tom: And ITSC-UDG focuses on electrical faults in induction motors, specifically inter-turn short-circuit faults <ref:2608.18716#pg3>. It has sixty-five multivariate time series for that specific problem <ref:2608.18716#pg2>.
Lu: They are assessing performance using Accuracy, Balanced Accuracy, and the macro-averaged F1-score <ref:2608.18716#pg5>. And they did it using repeated two-fold StratifiedGroupKFold crossvalidation with five repetitions <ref:2608.18716#pg3>.
Paper summary: Jane: So, what’s the main finding here? What is SelF-Rocket actually doing better than the other ROCKET variants?
Tom: The key finding is that SelF-Rocket consistently achieves the highest average predictive performance across all tested window sizes and evaluation metrics on MaFaulDa <ref:2608.18716#pg5>. They also found that for MaFaulDa, it automatically selects ZC MIX, which is what contributes to those performance gains compared to the other ROCKET-based methods <ref:2608.18716#pg5>.
Meng: That’s interesting about ZC MIX. But let's talk about the trade-off mentioned in the abstract—performance versus computational efficiency. How does SelF-Rocket stack up on that specific metric?
Tom: It demonstrates the best overall accuracy versus latency trade-off among all the methods they tested <ref:2608.18716#pg6>. Plus, on ITSC-UDG, it stays highly competitive with the best ROCKET methods <ref:2608.18716#pg6>.
Lu: The low inference latency on ITSC-UDG suggests it has potential for embedded, real-time condition monitoring <ref:2608.18716#pg6>. That’s a big deal for getting these systems to work on the machine itself rather than sending data somewhere else <ref:2608.18716#pg3>.
Jane: So, what does this mean for someone just listening to the show, someone who doesn't read this technical paper? What’s the big picture implication?
Tom: It means that for fault diagnosis in rotating machinery, we can use these convolutional kernel methods without needing a ton of prior expert knowledge about the specific faults <ref:2608.18716#pg3>. It’s promising because it trades off training time and expertise for a model that works well across different machine types <ref:2608.18716#pg2>.
Meng: But I wonder about the limitations they mentioned. They noted that the evaluation was only on laboratory benchmark datasets acquired under controlled and steady-state operating conditions <ref:2608.18716#pg6>. That’s a big gap when you try to deploy this in a messy real world environment <ref:2608.18716#pg3>.
Lu: Exactly, and they also said the automatic selection of the input representation and pooling operator combination becomes less reliable when you only have a limited number of training recordings on ITSC-UDG <ref:2608.18716#pg6>. That’s a real caution about how much data you need to train this automatically <ref:2608.18716#pg4>.
Jane: So, what does that limitation mean for the future of this research? What’s the next step they are planning?
Tom: They plan to focus on evaluating robustness under time-varying speed and load conditions <ref:2608.18716#pg6>. They also want to extend their evaluations to on-board deployment scenarios <ref:2608.18716#pg6>.
Lalam: And they mentioned that the proposed pipeline requires fixed-length input windows and labeled examples for each fault class <ref:2608.18716#pg4>. That’s a practical hurdle when you try to apply it to truly dynamic machinery <ref:2608.18716#pg4>.
Jane: So, we’ve seen that SelF-Rocket performs well on known datasets like MaFaulDa and ITSC-UDG, but we know it needs more real-world testing before it can be used everywhere.
Tom: Right. It’s a solid model for the lab environment, but the next phase has to be about making it work when things are actually changing on the floor <ref:2608.18716#pg6>. That’s where the engineering challenges come in <ref:2608.18716#pg3>.
Conclusion: Tom: So, we’re wrapping up our look at this paper about multi-class electrical and mechanical fault classification using random convolutional kernels <ref:2608.18716#pg1>.
Jane: It’s about taking those complex rotating machinery faults—things like bearing problems or electrical short circuits—and classifying them automatically without needing tons of expert knowledge from the people looking at the data <ref:2608.18716#pg3>.
Lu: The core idea is using these random convolutional kernels, which are introduced with ROCKET, to classify time series data where you don't know exactly what the fault looks like in advance <ref:2608.18716#pg3>.
Meng: So instead of needing a perfect manual label for every single fault type, the model learns the pattern itself from a bunch of examples <ref:2608.18716#pg3>.
Tom: Exactly, and this specific work builds on that by trying to make it better than just ROCKET by automatically selecting the best input representation and pooling operator during training <ref:2608.18716#pg4>.
Jane: It’s smart because it tries to figure out the best way to look at the raw data—like using raw readings or differences between them—and then deciding how to group those features for the final classification stage <ref:2608.18716#pg4>.
Lu: They even made a clever trick with the activation map aggregation, where they pick a random subset of input dimensions to make one map per kernel, which cuts down on how much computation it takes when you have lots of different measurements <ref:2608.18716#pg4>.
Meng: That sounds like it helps keep the model manageable for real-world deployment because the complexity doesn't just grow bigger with more sensors <ref:2608.18716#pg4>.
Tom: And they tested this on two datasets, MaFaulDa for mechanical faults and ITSC-UDG for electrical faults, showing that SelF-Rocket hits a sweet spot between being accurate and running fast <ref:2608.18716#pg2>.
Jane: It seems like the big takeaway is that this approach can offer a way to diagnose these machinery faults using just time series data, cutting through the need for deep physical knowledge <ref:2608.18716#pg3>.
Lu: But they did point out some stuff, like the model relies on having enough training data for those automatic selections to work reliably on smaller datasets <ref:two thousand six hundred eight point one eight seven one six#pg4.
Meng: So it’s a promising tool, but we have to keep in mind that if you don't have a massive library of examples, the system might not choose the right setup for you <ref:two thousand six hundred eight point one eight seven one six#pg4.
Tom: Right. The authors are looking ahead to test this stuff when the machine speed and load are actually changing in real-time, which is where the real challenge is <ref:two thousand six hundred eight point one eight seven one six#pg6.
Jane: So it’s not just about getting a high score on a benchmark dataset, but about making sure this kind of AI can handle the messy reality of a running factory floor <ref:two thousand six hundred eight point one eight seven one six#pg3.
Mouhamadou Mansour LO, Mouad TALBAOUI, Gildas MORVAN, Mathieu ROSSI, Fabrice MORGANTI, David MERCIER
University of Artois
cs.LG
Submitted: 2026-08-19
Updated: 2026-08-19
Comments: Interdisciplinary Conference on Electrics and Computer (INTCEC 2026)
License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
Importance score: 81/100
The gist: Diagnosing faults in rotating machinery is essential for ensuring the reliability of industrial processes <ref:2608.18716#pg2>.
Key concepts
- Random Convolutional Kernels
- These are a type of deep learning technique used for time series classification. They work by randomly selecting parts of the input data to create filters (kernels) that learn relevant patterns in the signal. This approach is efficient because it drastically reduces training time compared to other complex methods.
- Input Representation (IR) and Pooling Operator (PO)
- These are two key components SelF-Rocket automatically selects during training. The IR determines how the raw time series data is transformed, while the PO defines how features are aggregated. By automatically choosing the best combination, SelF-Rocket optimizes performance for different types of machine faults.
- Accuracy–Latency Trade-off
- This refers to finding a balance between how well a model predicts faults (accuracy) and how quickly it makes a prediction (latency). SelF-Rocket is highlighted as achieving the best overall compromise, meaning it offers high performance without being too slow, which is crucial for practical applications like real-time monitoring.
Terminology
Summary
Diagnosing faults in rotating machinery is essential for ensuring the reliability of industrial processes <ref:2608. p. 018716#pg2>. Random convolutional kernel-based Time Series Classification (TSC) methods, such as ROCKET and its variants, provide an attractive trade-off between predictive performance and computational efficiency <ref:2608. p. 018716#pg2>. In this work, SelF-Rocket achieves the best overall accuracy–latency trade-off among the evaluated methods <ref:2608. p. 018716#pg2>.
Problem Context
Fault diagnosis in rotating machinery is a recurring problem in industrial processes <ref:2608.18716#pg3>. Classical methods often rely on frequency-domain analysis and require expert (physical) knowledge of these faults as well as of the machine characteristics <ref:2608. p. 018716#pg3>. While deep learning methods achieve very good performance, they require large amounts of data and substantial computational resources <ref:2608. p. 018716#pg3>. Random convolutional kernels, introduced with ROCKET [5], have recently attracted considerable interest for time series classification because they drastically reduce training time and remove the need for any prior expert knowledge <ref:2608. p. 018716#pg3>.
Model Architecture
The proposed approach, SelF-Rocket, extends MiniRocket by automatically selecting the optimal combination of input representation (IR) and pooling operator (PO) through a feature selection module during training <ref:2608.18716#pg4>. The input representations considered are the raw series, its first-order difference (DIFF), and their concatenation (MIX) <ref:2608. p. 118716#pg4>. For the activation map aggregation stage, a random subset of input dimensions Sκ is selected to produce a single activation map for each kernel κ <ref:2608. p. 118716#pg4>. This modification means the computational complexity no longer scales linearly with the number of input dimensions, making it suitable for high-dimensional multivariate time series <ref:2608. p. 118716#pg4>.
Data and Evaluation
The study evaluates SelF-Rocket on two public benchmark datasets: MaFaulDa for mechanical faults and ITSC-UDG for electrical faults <ref:2608.18716#pg3>. MaFaulDa comprises 1,951 multivariate time series recorded over 5 seconds using eight measurement channels <ref:2608. p. 118716#pg3>. ITSC-UDG consists of 65 multivariate time series focusing on inter-turn short-circuit (ITSC) faults in induction motors <ref:2608. p. 118716#pg3>. Performance is assessed using Accuracy, Balanced Accuracy, and the macro-averaged F1-score <ref:2608. p. 218716#pg5>.
Key Findings
SelF-Rocket consistently achieves the highest average predictive performance across all tested window sizes and evaluation metrics on MaFaulDa <ref:2608.18716#pg5>. For MaFaulDa, it automatically selects ZC MIX, which contributes to the observed performance gains compared to competing ROCKET-based methods <ref:2608. p. 318716#pg5>. Furthermore, SelF-Rocket demonstrates the best overall accuracy–latency trade-off among evaluated methods <ref:2608. p. 018716#pg6>. On the ITSC-UDG dataset, SelF-Rocket remains highly competitive, consistently achieving results comparable to the best-performing ROCKET-based methods <ref:2608. p. 418716#pg6>. The low inference latency suggests its potential for embedded, real-time condition monitoring <ref:2608. p. 518716#pg6>.
Limitations and Future Work
The study notes several limitations, including the restriction of evaluation to laboratory benchmark datasets acquired under controlled and steady-state operating conditions <ref:2608.18716#pg6>. The automatic selection of the IR–PO combination becomes less reliable when only a limited number of training recordings are available on ITSC-UDG <ref:2608. p. 518716#pg6>. Future work will focus on evaluating robustness under time-varying speed and load conditions and extending evaluations to on-board deployment scenarios <ref:2608. p. 518716#pg6>. The proposed pipeline requires fixed-length input windows and labeled examples for each fault class <ref:2608. p. 518716#pg4>.
Appendix Details
Detailed performance tables are provided in Appendix A, which summarizes the classification and computational performance for both MaFaulDa and ITSC-UDG datasets <ref:2608.18716#pg8>. Table II shows that SelF-Rocket achieves high balanced accuracy on MaFaulDa, such as 93. p. 376% for the 5000 window size <ref:2608. p. 118716#pg8>. Table III and V compare the training feature generation time and inference time across various methods and window sizes. p. 3 The results confirm that SelF-Rocket achieves a good compromise between predictive performance and total inference time <ref:2608. p. 318716#pg6>. The analysis of ITSC-UDG shows that the representation organization improves with larger window sizes, revealing structure along three distinct directions associated with stator phases <ref:2608. p. 418716#pg6>.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Multivariate extension of SelF-Rocket enables multi-class diagnosis for both mechanical and electrical faults by automatically selecting optimal input representation and pooling operator during training. This allows the system to leverage joint information from all sensor channels, improving discriminative power compared to univariate settings.
-
The system can achieve the
best overall accuracy–latency trade-off among the evaluated methods,
combiningthe highest classification performance on MaFaulDa while remaining highly competitive on the more challenging ITSC-UDG dataset.
This suggests a robust model suitable for embedded, real-time condition monitoring of electrical powertrains. -
The proposed architecture scales effectively to high-dimensional data by selecting a random subset of input dimensions Sκ (with a maximum cardinality of 9) and summing their convolution responses to produce an activation map. This modification ensures
the computational complexity no longer scales linearly with the number of input dimensions,
making it suitable for multivariate time series. -
The system can dynamically select the best Input RepresentationPooling Operator (IR-PO) pair from a set of candidates, rather than relying on a single fixed combination. This dynamic selection improves performance by ensuring
the most discriminative features are retained during training.
-
The model can be optimized for different operating conditions and fault severities based on window size selection. For example, the analysis shows that
w = 500 produces more compact and better separated clusters than w = 250,
indicating that selecting appropriate window sizes enhances feature representation quality.
Sources
Related papers
- A Physics-Regulated Neural Framework for Learning 3D Grain Growth Dynamics
- FlexMoE: Learning One-for-All Multi-Budget Expert Pruning for Flexible MoE Deployment
- OptiMind: Improving Small Language Models for Optimization Modeling through Formulation Guidance and Multi-Turn Learning
- Staying in the Sweet Spot: Boost Reasoning Evolution via Responsive Rollout Difficulty Manipulation
- Examining the Impact of Data and Training Methods on Emergent and Subliminal Misalignment
- Rethinking Black-Box On-Policy Distillation: A Rubric-based Analysis