Effective Classification of Bearing Vibration Signals Using Supervised Machine Learning for Predictive Maintenance: A Lightweight 1D CNN for Embedded Deployment

Rolling-element bearings represent the mechanical linchpins within rotating machinery ecosystems, including turbines, electric motors, pumps, and compressors. Their primary function involves the critical tasks of friction reduction and support for substantial mechanical loads during operation. Paradoxically, these indispensable components are simultaneously among the most prolific sources of catastrophic mechanical failure, with industry analyses implicating them in 45–55% of all malfunctions occurring within such complex systems [1-3]. The consequent economic ramifications are nothing short of staggering; contemporary industry audits indicate that single bearing failure events can precipitate direct and indirect costs ranging from \$5,000 to an astonishing \$250,000 per hour within high-throughput operational environments like continuous energy production and automated automotive assembly lines [1, 4]. This profound financial vulnerability has catalyzed an unequivocal industry-wide paradigm shift, moving away from traditional reactive and predetermined preventive maintenance schedules toward intelligent, data-driven predictive maintenance (PdM) strategies [5].

PdM fundamentally leverages continuous, high-frequency sensor data streams—primarily comprising vibration signatures, acoustic emissions, and thermal profiles—to identify and diagnose incipient faults long before they culminate in irreversible mechanical degradation or catastrophic systemic failure [6]. Within modern PdM frameworks, machine learning (ML) and deep learning (DL) models have ascended to a position of critical importance, demonstrating formidable capabilities in classifying precise bearing health states from annotated vibration data sequences [7, 8]. Notwithstanding these advanced capabilities, a substantial proportion of this pioneering research remains confined to controlled laboratory environments, characterized by abundant computational resources and idealized data conditions, thereby largely overlooking the severe pragmatic constraints endemic to real-world industrial deployment scenarios [9].

Furthermore, recent studies highlight the critical challenge of domain adaptation—where models trained under specific laboratory conditions often fail when deployed on different machines or under varying operational speeds. This gap is particularly problematic for safety-critical applications, such as helicopter main rotor bearings, where fault data is scarce and operating conditions are highly variable. To address both domain adaptation and deployment constraints simultaneously, our work integrates quantization-aware training with data augmentation techniques specifically designed to simulate domain shifts. The quantization process not only reduces memory footprint by 50% but also introduces beneficial regularization effects that slightly improve model robustness to input variations.

Legacy industrial environments, which constitute the majority of global manufacturing infrastructure, frequently exhibit severely limited hardware capabilities, typically lacking robust cloud connectivity, powerful computing hardware, or substantial energy budgets. The successful implementation of PdM within these constrained contexts necessitates the development of solutions capable of operating entirely on resource-constrained embedded microcontrollers. These devices are defined by their limited RAM availability, absent GPU accelerators, and mandatory real-time processing requirements [10]. The emergent discipline of embedded artificial intelligence (AI) offers a profoundly promising pathway, primarily through the application of highly optimized DL models, such as one-dimensional convolutional neural networks (1D CNNs), which are specifically engineered for execution on low-power, minimalist hardware architectures [11, 12].

This study is architected to bridge the conspicuous chasm between theoretical academic model performance and practical industrial deployment constraints. We present a novel, lightweight 1D CNN architecture, meticulously engineered for direct deployment on commercial microcontrollers, which achieves superior diagnostic accuracy while scrupulously adhering to strict real-time and memory limitations. The model undergoes rigorous benchmarking against a comprehensive suite of alternatives, including traditional ML algorithms (e.g., Support Vector Machines (SVMs), k-Nearest Neighbors (KNN)), advanced ensemble methods (e.g., Random Forest, XGBoost), and other contemporary DL approaches, across seven distinct and demanding public datasets to unequivocally ensure robustness, reliability, and generalizability. The primary contributions encapsulating this work are enumerated as follows:

1. A comprehensive and critical benchmark evaluation of contemporary ML techniques for bearing fault diagnosis, conducted under authentic embedded systems constraints.
2. The proposition and detailed exposition of an optimized, quantized 1D CNN model that achieves state-of-the-art diagnostic accuracy while maintaining minimal computational resource consumption.
3. A rigorous, multi-faceted validation of the model's generalizability across diverse operational conditions, mechanical configurations, and dataset provenances.
4. An extensive discussion elucidating the broader implications and applications of lightweight AI architectures for the Internet of Things (IoT) and smart cyber-physical systems across industrial domains.

Our overarching methodological approach is scrupulously designed to prioritize embedded compatibility and operational efficiency without compromising diagnostic performance or analytical rigor. This section provides a comprehensive elucidation of the model architecture, data handling protocols, optimization techniques, and the multi-faceted evaluation framework employed.

3.1 Datasets and evaluation protocol

To ensure rigorous and reproducible evaluation, we employed two complementary protocols: (1) pooled evaluation with group-stratified splitting for primary benchmarking, and (2) leave-one-dataset-out cross-validation to assess cross-dataset generalization capability.

3.1.1 Dataset selection

Seven publicly available bearing vibration datasets were utilized: the Case Western Reserve University (CWRU) Bearing Data [30], the Machinery Failure Prevention Technology (MFPT) Society dataset [31], the PRONOSTIA platform data for accelerated degradation tests [32], the Huang-Baddour dataset featuring variable rotational speeds [33], alongside the IMS [34] and Paderborn University datasets [35]. This selection provides a diverse mix of fault types, severities, operational conditions (load, speed), and acquisition setups. Table 1 summarizes the key characteristics of these datasets and the uniform preprocessing parameters applied to ensure consistency for model training and evaluation. The selection spans-controlled laboratory tests (CWRU, MFPT) and run-to-failure experiments (PRONOSTIA, IMS), providing a rigorous testbed for model generalization across diverse operational contexts.

Table 1. Dataset characteristics and preprocessing parameters

3.1.2 Label harmonization to three-class scheme

For this study, we focus on three primary health states: healthy (normal operation), inner race fault, and outer race fault. All datasets were harmonized to this unified three-class label space. Table 2 presents the complete dataset composition after harmonization, showing the number of windows per class and the number of distinct bearings/runs in each dataset. The detailed mapping from original dataset annotations to our unified three-class scheme is provided in Table 3.

Table 2. Dataset composition after label harmonization to three health states

Table 3. Label mapping from original dataset annotations to unified three-class scheme

3.1.3 Evaluation protocols

Protocol 1 (Pooled Evaluation with Group-Stratified Splitting): For primary benchmarking, all datasets were combined after label harmonization. To prevent data leakage, splitting was performed at the bearing/run level (not window level). For each dataset and health state, bearings were randomly assigned to training (70%), validation (15%), and test (15%) sets, maintaining class distribution across splits. This ensures that all windows from a given bearing appear exclusively in one split, eliminating the possibility of near-duplicate segments contaminating multiple splits. The complete group-stratified splitting procedure is detailed in Appendix A, Algorithm A1. The final pooled dataset comprised 24,500 windows from 64 independent bearings/runs.

Protocol 2 (Leave-One-Dataset-Out Cross-Validation): To assess cross-dataset generalization capability—a critical requirement for real-world deployment where models may encounter machinery from different manufacturers or operating conditions—we conducted leave-one-dataset-out experiments. For each iteration, models were trained on six datasets and tested on the held-out seventh dataset without any fine-tuning. This protocol evaluates how well the learned features transfer to unseen data distributions and provides a lower-bound estimate of performance under domain shift.

3.2 Signal preprocessing and windowing

The systematic transformation of raw vibration data into model-ready inputs follows the comprehensive pipeline illustrated in Figure 1. This end-to-end workflow encompasses signal conditioning, domain-specific augmentation, and dual-path processing to support both DL and traditional ML models, ensuring consistent input representation across all experiments.

As shown in Figure 1, the workflow begins with raw 1D vibration signal acquisition, followed by order-RPM normalization for variable-speed conditions. A Band-Pass Filter (BPF) (500 Hz - 5 kHz) isolates the bearing frequency range. For the proposed CNN path (lower branch), signals undergo segmentation, normalization, and time-domain augmentation (time-warping, amplitude scaling). For traditional ML models (upper branch), 47 handcrafted features are extracted from time, frequency, and time-frequency domains, followed by feature standardization. Both paths feed into the respective model architectures for training and evaluation.

Figure 1. Data preprocessing and feature extraction pipeline

3.2.1 Windowing strategy and data leakage prevention

Raw vibration signals were segmented into windows of 1024 samples with a stride of 512 samples (50% overlap) to augment the training data while maintaining temporal continuity. This window length was selected to provide sufficient time resolution to capture transient fault impacts (typically 2-10 ms duration) while remaining short enough for real-time processing on embedded targets (≤ 5 ms inference budget).

Crucially, to prevent data leakage, all windowing was performed after splitting the data at the bearing/run level. For each bearing/run, we generated a contiguous sequence of windows, and these window sequences were assigned entirely to either training, validation, or test sets based on the bearing-level split described in Section 3.1. This ensures that windows from the same bearing never appear in different splits, eliminating the possibility of near-duplicate segments contaminating multiple splits—a common issue in vibration-based diagnostics that artificially inflates performance metrics.

3.2.2 Common minimum preprocessing pipeline

To ensure fair comparison across all model families, we defined a common minimum preprocessing pipeline applied to all signals before any model-specific processing:

• Band-pass filtering (500 Hz - 5 kHz): Isolates the frequency range where bearing fault signatures are most prominent, removing low-frequency mechanical noise and high-frequency electrical interference.
• Order-RPM normalization: For variable-speed datasets (particularly Huang-Baddour [30]), signals were resampled in the angular domain to compensate for speed variations, ensuring that fault impacts align consistently across samples.
• Segmentation: As described above, with 1024-sample windows and 512-sample stride.
• Z-score normalization per window: Each window is normalized to zero mean and unit variance using:
• = (x−μ_x)/ σ_x where μ_x and σ_x are the mean and standard deviation of the window.

Model-specific preprocessing was applied after this common pipeline: for the CNN, we additionally applied time-domain augmentation (time-warping, amplitude scaling); for traditional ML models, we extracted handcrafted features from the normalized windows as described in Section 3.4.

3.2.3 Data augmentation for deep learning

For the proposed CNN only, we applied two complementary augmentation techniques during training to improve generalization:

• Time-warping: Random stretching or compression of the time axis by factors uniformly sampled from [0.8, 1.2], simulating variations in rotational speed.
• Amplitude scaling: Random multiplication of the signal amplitude by factors from [0.9, 1.1], simulating variations in sensor sensitivity or mounting.

These augmentations were applied on-the-fly during training and disabled during validation and testing to ensure deterministic evaluation.

3.3 Proposed lightweight one-dimensional convolutional neural network architecture

The proposed lightweight 1D CNN architecture comprises a sequence of four progressive convolutional blocks followed by a compact dense classification head, with the entire design philosophy centered on maximal parameter efficiency and operational minimalism (< 45 k total trainable parameters). The architectural blueprint is as follows:

1. Block 1: 16 filters (kernel size = 7) → ReLU Activation → Batch Normalization → Max Pooling (pool size = 2). This initial layer captures broad, low-level temporal features and patterns.
2. Block 2: 32 filters (kernel size = 5) → ReLU Activation → Batch Normalization → Max Pooling (pool size = 2). This layer extracts more complex features from the processed output of the first block.
3. Block 3: 64 filters (kernel size = 3) → ReLU Activation → Batch Normalization → Max Pooling (pool size=2). This layer refines the feature maps into higher-level representations.
4. Block 4: 128 filters (kernel size = 3) → ReLU Activation → Global Average Pooling. This final convolutional layer consolidates features, and Global Average Pooling drastically reduces parameters before classification.
5. Classifier: A Fully Connected Layer (128 units) → Dropout (rate = 0.3) → Softmax Output Layer (3 units). Batch normalization is incorporated to stabilize internal covariate shifts and accelerate training convergence dynamics, while dropout is employed as an effective regularization technique to mitigate overfitting on the training data distribution [36]. The use of Global Average Pooling (GAP) instead of a Flatten layer followed by large dense layers is a key design choice for size reduction, as it significantly reduces the number of parameters connecting the last convolutional layer to the classifier.

Batch normalization is incorporated after each convolutional layer (before activation) to stabilize internal covariate shifts and accelerate training convergence dynamics [36]. Dropout is employed as an effective regularization technique to mitigate overfitting on the training data distribution. The use of Global Average Pooling instead of a Flatten layer followed by large dense layers is a key design choice for size reduction, as it eliminates millions of parameters while preserving representational power.

The architectural choices reflected in Table 4 yield several important properties:

1. Parameter efficiency: With only 44,803 trainable parameters, the model is substantially smaller than conventional CNNs (which often exceed 1 million parameters), enabling deployment on memory-constrained microcontrollers.
2. Progressive filter increase: The number of filters doubles in each block (16→32→64→128), allowing the network to learn increasingly complex features while maintaining computational efficiency.
3. Receptive field growth: The kernel sizes decrease progressively (7→5→3→3), balancing the need for broad temporal context in early layers with fine-grained feature extraction in deeper layers.
4. Global Average Pooling: Replacing a flattened layer with GAP reduces the parameter count by approximately 400,000 compared to a fully connected layer of equivalent size, contributing significantly to the model's compact footprint.
5. Strategic dropout: The dropout rate of 0.3 in the classifier provides regularization without underfitting, as validated in the ablation studies (Section 4.2).

Table 4. Label mapping from original dataset annotations to unified three-class scheme

This architecture forms the foundation for all experiments reported in this study, with the quantized version (INT8) preserving the same layer structure while reducing memory footprint as detailed in Section 3.6.

3.4 Baseline models and feature engineering

To establish definitive performance baselines and provide context for evaluating the proposed CNN, we implemented a comprehensive suite of traditional ML and ensemble models: SVM with Radial Basis Function (RBF) kernel [37], DT [38], K-Nearest Neighbors (KNN) with Dynamic Time Warping (DTW) distance metric [16], Random Forest (RF) [19], and eXtreme Gradient Boosting (XGBoost) [18].

3.4.1 Handcrafted feature extraction

For these classical models, which cannot operate directly on raw time-series data, we extracted a comprehensive set of 47 handcrafted features from each signal window. These features were designed to capture the distinguishing characteristics of bearing vibration signals across multiple analytical domains. The complete feature set is organized as follows:

• Time-Domain Features (12 features): Statistical and morphological descriptors extracted directly from the raw vibration amplitude distribution:
• Frequency-Domain Features (14 features): Five Spectral characteristics derived from the FFT magnitude spectrum and Energy in nine frequency bands corresponding to characteristic bearing fault frequencies. Characteristic fault frequencies (BPFI, BPFO, FTF) were calculated for each bearing based on its geometry and operational speed using standard formulas [13].
• Time-Frequency Features (21 features): Features that capture how frequency content evolves over time, derived from the STFT spectrogram:

1. 13 Mel-frequency cepstral coefficients (MFCCs): Extracted using a 256-sample Hamming window with 50% overlap, 40 Mel filter banks, and retaining coefficients 2-14 (excluding the first coefficient which represents average energy). No delta or delta-delta coefficients were included.
2. 8 statistical moments from STFT spectrogram: For each of two critical frequency bands (band centered on BPFI and band centered on BPFO), we computed four statistical moments from the time-varying energy envelope.

Table 5 summarizes the complete feature set with dimensions and descriptions. The step-by-step extraction procedure for all 47 features, including the mathematical formulations for MFCCs, spectral statistics, and characteristic fault frequency band energies, is provided in Appendix A, Algorithm A2.

Table 5. Complete handcrafted feature set (47 features)

3.4.2 Feature standardization

All extracted features were standardized to zero mean and unit variance using z-score normalization: x_std = (x- μ_train)/ σ_train 

where μ_train and σ_train are the mean and standard deviation computed on the training set only. These same parameters were then applied to normalize validation and test sets to prevent data leakage and ensure realistic evaluation of generalization performance.

3.4.3 Baseline model configuration

All baseline models were implemented using scikit-learn (version 1.3.0) with the following configurations:

• SVM: RBF kernel, C = 1.0, gamma = 'scale', class_weight = 'balanced'
• DT: max_depth = 10, min_samples_split = 5, min_samples_leaf = 2
• KNN-DTW: n_neighbors = 5, DTW window constraint = 0.1 × signal length
• Random Forest: n_estimators = 100, max_depth = 15, min_samples_split = 5
• XGBoost: n_estimators = 100, max_depth = 6, learning_rate = 0.1, subsample = 0.8, colsample_bytree = 0.8

Hyperparameters were selected based on preliminary grid search on the validation set.

3.5 Training protocol and hyperparameters

All models were trained and evaluated using a stratified 5-fold cross-validation procedure to ensure reliable and unbiased performance estimates. The proposed CNN was optimized using the Adam optimizer [39] (initial learning rate = 0.001, β₁ = 0.9, β₂ = 0.999) coupled with a cosine decay learning rate scheduler. To substantially improve generalization and robustness, we employed mixup augmentation [40, 41] (α=0.2) during the training phase. Early stopping was implemented with a patience of 20 epochs to halt training upon validation loss convergence and prevent overfitting.

For deployment on the edge target, the trained single-precision floating-point (FP32) model was converted and quantized to 8-bit integers (INT8) using the TensorFlow Lite Micro (TFLM) conversion toolkit, specifically targeting the ARM Cortex-M7 processor architecture present on the Teensy 4.1 development board. The ARM CMSIS-DSP software library was extensively leveraged to accelerate convolutional and matrix multiplication operations using Single Instruction, Multiple Data (SIMD) instructions, maximizing computational throughput on the embedded platform.

3.6 Quantization and embedded deployment

For deployment on the edge target, the trained single-precision floating-point (FP32) model was converted and quantized to 8-bit integers (INT8) using the TensorFlow Lite Micro (TFLM) conversion toolkit, specifically targeting the ARM Cortex-M7 processor architecture present on the Teensy 4.1 development board.

3.6.1 Quantization-aware training protocol

The model underwent progressive quantization during training following a four-stage protocol:

• Initial training in full precision (FP32): The model was trained for 200 epochs using the Adam optimizer with cosine decay learning rate scheduling, as described in Section 3.5.
• Fine-tuning with simulated quantization: Quantization-aware training (QAT) was applied for an additional 50 epochs, inserting fake quantization nodes that simulate the effect of INT8 inference during forward and backward passes. This allows the model to learn parameters robust to the information loss inherent in quantization.
• Calibration with representative data: A calibration dataset of 500 samples per class (drawn from the training set) was used to determine optimal activation ranges for each layer, minimizing clipping and quantization error.
• Final conversion to INT8: The calibrated model was converted to TFLM format using the TFLite converter with INT8 quantization for both weights and activations.

The complete quantization-aware training procedure, including fake quantization node insertion, calibration with representative data, and final INT8 conversion, is detailed in Appendix A, Algorithm A3.

3.6.2 Mixed-precision optimizations

Layer-wise sensitivity analysis revealed that the first convolutional layer demonstrated the highest quantization error due to its direct processing of raw vibration inputs. To address this while maintaining overall model compactness, we retained 16-bit accumulators in the first convolutional layer during quantization-aware training, a technique known as mixed-precision quantization. This targeted approach preserved feature extraction fidelity at the model's input stage while allowing all subsequent layers to use full INT8 inference, achieving an optimal balance between accuracy and memory efficiency.

3.6.3 Hardware-accelerated inference

The ARM CMSIS-DSP software library was extensively leveraged to accelerate convolutional and matrix multiplication operations using Single Instruction, Multiple Data (SIMD) instructions. Specifically:

• CMSIS-NN kernels were used for all convolutional and fully-connected layers, providing optimized implementations for ARM Cortex-M processors.
• Operator fusion was applied to combine batch normalization parameters with preceding convolutional weights during conversion, eliminating runtime normalization calculations.
• Memory pooling was configured with a 48 kB tensor arena, determined empirically as the minimum size required for all intermediate activations.

3.6.4 Deployment platform

The target deployment platform was the Teensy 4.1 development board featuring:

• ARM Cortex-M7 processor at 600 MHz.
• 1024 kB RAM (512 kB DTCM + 512 kB OCRAM).
• 2048 kB flash memory.
• FPU and caches enabled (32 kB instruction cache, 32 kB data cache).
• Arduino IDE 2.3.2 with Teensyduino 1.59, ARM GCC 11.3.1 (-O3 optimization).

3.6.5 Quantization results

The complete memory and latency results for all quantization configurations are presented in Table 6, with the final deployed INT8 model highlighted.

Table 6. Quantization configuration performance analysis

3.7 Deployment metrics definition

To ensure clarity and consistency in reporting embedded deployment metrics, we define the following measurements as used throughout this paper:

1. Flash footprint (model storage size): The size of the quantized TensorFlow Lite Micro model file stored in non-volatile memory, including weights, biases, and model structure metadata. This represents the permanent storage required on the microcontroller's flash memory.
2. Runtime RAM footprint: The peak memory usage during inference on the microcontroller, comprising:

• Tensor arena for activations and intermediate buffers (allocated by TFLM interpreter).
• Input and output tensors.
• Persistent scratch buffers for CMSIS-NN optimized kernels.
• Stack memory for function calls during inference.

This value represents the minimum RAM that must be available during model execution and is measured by recording the arena high-water mark during inference.

3. Inference latency: Time measured from input tensor population to output tensor availability. Measurements were performed using the ARM DWT (Data Watchpoint and Trace) cycle counter reading before and after inference, averaged over 10,000 consecutive inferences with compiler optimization barriers to prevent code reordering. The reported values are in milliseconds based on the 600 MHz clock frequency of the Teensy 4.1. The precise measurement protocol, including compiler barrier implementation to prevent code reordering, is presented in Appendix A, Algorithm A4.

All measurements were conducted on the target hardware (Teensy 4.1) under identical conditions: 600 MHz clock, caches enabled, -O3 compiler optimization, and no other tasks running during inference to ensure accurate timing.

3.8 Evaluation metrics and statistical analysis

Model performance was assessed using a holistic set of metrics covering both diagnostic accuracy and embedded operational efficiency:

• Diagnostic Accuracy: Macro-averaged F1-score, precision, recall, and the Area Under the Receiver Operating Characteristic Curve (AUC-ROC).
• Embedded Performance: Inference latency (measured in milliseconds) and static memory footprint (measured in kilobytes) on the target Teensy 4.1 microcontroller.

This multi-faceted evaluation protocol ensures a comprehensive and fair comparison of both the analytical capability and the operational feasibility of each model family under realistic deployment constraints. Statistical significance of performance differences was assessed using paired t-tests over the cross-validation folds.

The results presented unequivocally demonstrate the clear superiority of the optimized 1D CNN architecture for the task of embedded bearing fault diagnosis. Its superior accuracy originates from its innate ability to automatically learn hierarchical, discriminative features directly from raw vibrational data, making it inherently robust to problematic domain shifts like variable operational speed and ambient acoustic noise—factors that severely degrade the performance of models reliant on manually crafted features. While XGBoost showed commendable accuracy, its substantial memory footprint of 390 kB renders it practically untenable for deployment on most microcontrollers, where available RAM must be shared between the model, a real-time operating system (if present), communication buffers, and the application logic itself.

5.1 Technical implications: Quantization trade-off analysis

The successful deployment hinges on the favorable quantization characteristics observed during optimization. The measured 0.5% accuracy reduction from FP32 to INT8 quantization represents an exceptional trade-off given the simultaneous 4× memory reduction and 4.5× speedup achieved.

This efficiency gain aligns with empirical findings suggesting that bearing fault features in the vibration domain exhibit inherent 'quantization robustness'—their distinguishing temporal and spectral characteristics remain linearly separable even in lower-precision numerical spaces. Notably, our layer-wise sensitivity analysis revealed that the first convolutional layer demonstrated the highest quantization error, necessitating the retention of 16-bit accumulators during quantization-aware training (QAT) to maintain stable gradient flow and convergence. This targeted mixed-precision approach preserved feature extraction fidelity at the model's input stage, which was critical for final accuracy.

5.2 Industrial deployment: Real-world integration strategies

Translating this laboratory-validated model into a field-ready system requires a structured deployment architecture. For a target application like grinding machine spindles— where bearings are implicated in approximately 42% of unplanned failures—our model enables a practical three-tier monitoring hierarchy: (1) On-device continuous monitoring using the INT8 quantized CNN for real-time fault detection, (2) Gateway-level ensemble validation at a local industrial PC or programmable logic controller (PLC) that aggregates data from multiple sensor nodes for fault confirmation, and (3) Cloud-based prognostic analytics for remaining useful life (RUL) estimation and maintenance scheduling. The model's 5 ms inference time permits a 200 Hz sampling rate on a continuous monitoring loop while utilizing less than 10% of the Teensy 4.1's CPU capacity. This leaves substantial computational headroom for essential industrial communication stacks (e.g., Modbus TCP, OPC UA) and lower-priority system health monitoring tasks, ensuring robust integration within existing automation ecosystems.

Successful transition from a laboratory prototype to a fielded system requires careful planning. Table 16 outlines a practical checklist for industrial integration, covering hardware, software, and procedural considerations derived from our deployment experience on test rigs. This framework mitigates common pitfalls in edge AI projects.

Table 16. Practical checklist for industrial deployment integration

5.3 Internet of Things ecosystem integration: New section on edge-cloud synergy

The proposed embedded model is designed as the first, and most critical, tier in a hierarchical Industrial IoT (IIoT) architecture. To optimize bandwidth and computational resource allocation, a confidence-based triggering mechanism is implemented: predictions with a softmax probability below a 0.85 threshold—indicating uncertain classifications—initiate two concurrent actions. First, the device stores a compressed 5-second raw waveform buffer locally for potential later forensic analysis. Second, it flags the event for cloud-based verification, where more computationally intensive models (e.g., deeper ensembles or vision transformers) or human domain experts can provide a definitive diagnosis. This hybrid edge-cloud strategy achieves a 94% reduction in upstream data transmission compared to a cloud-only approach, while maintaining comprehensive diagnostic coverage and traceability. Furthermore, the model's sub-100 kB memory footprint and milliwatt-scale energy consumption unlock deployment on energy-harvesting or battery-powered wireless sensor nodes, enabling condition monitoring on inaccessible or rotating machinery without wired power or communication infrastructure.

5.4 Broader implications for Internet of Things and smart systems

The methodological approach demonstrated in this study—combining 1D CNNs with aggressive quantization for resource-constrained deployment—offers a blueprint for embedded AI across domains facing sub-100 kB memory, sub-10 ms latency, and milliwatt power budgets. These advancements align with broader IoT trends [25, 26], where edge deployment enables ultra-low latency and data privacy without continuous cloud connectivity.

Parallel applications include precision agriculture, where CNNs enable real-time plant disease detection [42] and automated pest control [43]. Similar convergent architectural choices—model simplification, quantization, and hardware-aware optimization—address the common challenge of efficient on-device sensor data processing.

Beyond agriculture, embedded AI is transforming logistics, cultural heritage preservation, and livestock monitoring through image classification [44], hospitality demand prediction [45], and multi-modal biometric sensing [46-48]. These applications, like our fault diagnosis system, rely on integrated IoT-edge-cloud ecosystems [49, 50].

The end-to-end embedded AI pipeline developed here for vibration analysis provides a scalable blueprint adaptable to countless IoT-based predictive monitoring applications across industries.

5.5 Limitations and future work

While the proposed model demonstrates high diagnostic efficacy and operational efficiency, several inherent limitations present fruitful opportunities for future research and development efforts.

First, the current work focuses primarily on single-point, localized faults (inner and outer race defects). Industrial environments in practice often present more complex fault scenarios, including compound faults (e.g., simultaneous defects in the raceway and a rolling element) and generalized distributed wear patterns. Extending the model's capability to multi-label classification frameworks or hybrid anomaly detection paradigms would be a logical and valuable step to address this gap [51].

Second, while validation was conducted across seven datasets, they primarily involve radial ball bearings. Generalizing the proposed approach to other critical bearing types (e.g., tapered roller bearings, thrust bearings) would require further investigation, potentially involving advanced transfer learning and domain adaptation techniques to adapt the learned features to new mechanical domains and signature profiles [23, 52, 53].

Third, the data used for training and evaluation were predominantly collected under controlled laboratory or test rig conditions. The ultimate validation step involves deploying the system within operational industrial settings to evaluate its performance against the myriad challenges of real-world environments, such as variable load conditions, extreme temperature fluctuations, contaminant ingress, and sensor calibration drift over time [54]. Incorporating additional sensor modalities (e.g., temperature, acoustic emission, oil debris analysis) could further enhance diagnostic robustness and confidence through intelligent sensor fusion techniques.

Finally, long-term deployment in an evolving environment must account for the phenomenon of concept drift—where the underlying data distribution changes slowly over time due to machine wear, maintenance interventions, or changes in operational regime. Future research directions must therefore include integrating online or continual learning algorithms to allow the model to adapt incrementally to new data without suffering from catastrophic forgetting of previous knowledge, thereby ensuring sustained accuracy and reliability throughout the asset's operational lifecycle [54].

While the proposed model demonstrates strong performance, several important limitations warrant discussion and present clear directions for future work. First, XAI Integration: While attribution methods like Integrated Gradients provide valuable post-hoc explanations, future architectures should integrate attention mechanisms or self-interpretable building blocks directly into the model design for built-in interpretability, allowing maintenance technicians to understand model decisions in real-time. Second, Hybrid Quantization: Current static 8-bit quantization could be evolved into dynamic precision adjustment, where the model automatically adjusts numerical precision based on real-time signal quality (SNR) or diagnostic confidence, optimizing the energy-accuracy trade-off per inference. Third, Cross-Machine Transfer: Addressing the TDM challenge—a critical requirement for scalable industrial deployment—requires investigation of advanced domain adaptation techniques like adversarial feature alignment, meta-learning, or few-shot learning to enable models trained on laboratory data to perform reliably on entirely different bearing types and machinery without extensive retraining.