CNN-Based Road Event Detection Using Multiaxial Vibration and Acceleration Signals

Abstract

Road event detection plays a key role in tasks such as monitoring, anomaly identification, and urban traffic optimization. Conventional methods often rely on feature extraction and classification or classical machine learning models, which may struggle when processing high-frequency signals in real time. In this work, we propose a CNN-based classification approach designed to handle multi-axial acceleration and vibration signals captured from road scenarios. Instead of relying on static feature sets, our method leverages a convolutional neural network architecture capable of automatically learning discriminative patterns from raw sensor data. We structure the time-series input into temporal windows and use it to train models that can identify different event categories, including “Speed Bumps”, “Potholes”, and “Sudden Braking” events. The experimental results show that our approach achieves an accuracy of 93.51%, with a precision of 93.56% and a recall of 93.51%. Further, the average AUC score of 0.9855 confirms the strong discriminative power of our proposal. In contrast to rule-based methods, which require frequent tuning to adapt to new datasets, our approach generalizes better across different road conditions and offers a practical alternative for real-time deployment in dynamic environments, outperforming rule-based approaches by over 10% in F1-score, while preserving deployment efficiency on embedded hardware.

1. Introduction

The detection of road surface events in urban environments plays a critical role in applications such as traffic safety monitoring, real-time anomaly identification, and infrastructure optimization [1,2,3,4,5,6,7,8]. Traditional classification methods typically rely on hand-crafted feature extraction pipelines or rule-based heuristics [9,10,11,12], which often require extensive tuning and may not scale well when processing high-frequency vibration and acceleration signals [5,13,14,15,16,17]. Extracting meaningful features from multivariate time series data, such as triaxial vibration and motion signals, requires significant computational resources and can overlook subtle temporal dependencies relevant to the classification of road events [18,19,20,21].

Although ensemble learning models such as Random Forest have shown advantages in scenarios with limited annotated data [13,22,23,24,25,26,27], their reliance on static feature vectors restricts their ability to model complex or evolving patterns. Furthermore, sensor signals are subject to variability due to vehicle type, surface conditions, and driving behavior, making it difficult for classical models to generalize across different environments [28,29,30,31,32].

Recent years have seen a rapid adoption of deep learning methods, particularly Convolutional Neural Networks (CNNs), for end-to-end feature learning from raw sensor data [18,19,20,33,34,35,36,37,38]. These methods have been applied to various problems, including pothole detection [8,33,34], vibration-based speed estimation [14,35], detection of road anomalies from time-frequency inertial data [20,36], and smartphone-based detection [21,28,29]. Hybrid architectures that combine CNNs with recurrent or attention mechanisms have further improved temporal modeling for short, transient events [20,30,39].

Convolutional Neural Networks (CNNs)

Convolutional Neural Networks (CNNs) are a class of deep learning models originally designed for image processing tasks, but which have shown strong performance in time series classification by capturing local patterns and spatial dependencies within sequential data [18,19]. They consist of learnable convolutional filters (kernels) that slide over the input to compute feature maps, activation functions (e.g., ReLU) that introduce non-linearity, pooling layers that reduce spatial or temporal resolution, and fully connected layers that integrate extracted features for classification (Figure 1).

In the context of road event detection using multiaxial vibration and acceleration signals, CNN offers an efficient and scalable alternative to traditional feature-based approaches. Rather than relying on manually crafted statistical or frequency-domain features, the CNN approach learns hierarchical representations of signal patterns directly from segmented time windows. Lower convolutional layers often capture fine-grained patterns such as sudden amplitude spikes or short-lived oscillations, while deeper layers can encode higher-level structures associated with specific events, such as “Pothole”, “Sudden Braking”, or “Speed Bump” [34,35].

An important advantage of CNNs is weight sharing, which drastically reduces the number of parameters and allows the detection of similar patterns regardless of their position in the sequence. When applied to multivariate signals (e.g., three-axis acceleration and vibration), CNNs process the input as a multichannel sequence, allowing the model to capture both intra-channel and inter-channel correlations. This property is especially valuable for multiaxial sensor setups, where interactions between axes carry meaningful information about the underlying event [20,36].

Finally, CNNs are well suited for real-time applications because of their relatively low inference latency and computational efficiency, especially compared to recurrent neural networks or traditional feature extraction pipelines. Their parallelizable convolution operations make them compatible with GPU acceleration and embedded deployment, enabling inference on low-power devices. By operating directly on raw or minimally processed signals, CNN-based models eliminate the need for extensive pre-processing and adapt more easily to different sensor configurations and environments [40,41].

2. Related Works

Deep learning has significantly advanced road event detection by enabling direct learning from raw or minimally processed sensor input [18,19,20,33,34,35,36,37]. CNN-based pipelines have been implemented for pothole detection [8,33,34], estimation of speed from vibration data [14,35], and surface monitoring through smartphone sensors [21,28,29,38]. In addition, CNN approaches on time–frequency representations have been used for the detection of road anomalies with accelerometers and gyroscopes [36], as well as for the classification of the severity of structural damage [20]. However, few of these studies have systematically addressed the balance between model accuracy, inference latency, and resource usage in embedded or real-time systems, which is critical for large-scale deployment in intelligent transportation environments.

Hybrid architectures such as LRCN [30] and CNN–attention models [20,39] integrate convolutional feature extraction with temporal sequence modeling to better handle transient events. The InceptionTime framework [19] and other multiscale convolutional designs [18] have also been adapted to 1D sensor data, offering strong precision–efficiency trade-offs suitable for embedded systems [40,41,42,43,44,45]. Nonetheless, their comparative performance under varying vehicle types, road textures, and environmental noise levels has not been thoroughly investigated, leaving a gap in the literature regarding cross-domain generalization.

In parallel, traditional feature engineering methods such as statistical measures and wavelet analysis [10,11,12] remain attractive due to their interpretability and modest computational requirements, but often degrade under dynamic, overlapping event signatures. Ensemble methods, particularly Random Forests [13,22,23,24,25,26,27], have been explored as a compromise between performance and efficiency, but still depend on fixed feature sets that limit adaptability. This limitation becomes especially relevant when scaling to diverse traffic scenarios where the distribution of events is highly imbalanced or non-stationary.

Multimodal sensor fusion has emerged as another promising direction, integrating accelerometer, vibration, gyroscope, GPS, vision, and even radar data [28,29,32,46]. These approaches improve robustness and classification accuracy in diverse road and vehicle conditions, but often require careful synchronization and alignment of heterogeneous streams [31,34,36,47]. Moreover, challenges such as sensor calibration drift, GPS signal loss in urban canyons, and temporal misalignment across modalities remain open problems that hinder seamless integration in operational settings.

Despite the breadth of research, there remains a need for lightweight generalizable models that can operate in real time under constrained hardware conditions while maintaining competitive accuracy [48,49,50,51,52]. In this scenario, our work contributes to filling this gap by proposing a compact 1D-CNN architecture optimized for low-latency deployment without sacrificing performance across various road event classes. By explicitly considering both algorithmic performance and engineering feasibility, the proposed framework is positioned to bridge the gap between academic prototypes and deployable solutions in intelligent transportation systems.

Motivation and Scope

To address the limitations of traditional approaches, this work introduces a CNN-based framework to classify road events using multiaxial acceleration and vibration data. Our approach learns discriminative spatiotemporal patterns directly from raw signals, eliminating the need for handcrafted features or reconfiguration per dataset, and enabling real-time inference in intelligent transportation systems [40,41,42,43,44,45,46,47,48,49,50,51,52].

The motivation for this research stems from the growing demand for reliable, low-latency road event detection systems capable of operating under the variability of real-world urban traffic conditions. Current solutions often struggle to generalize to different types of vehicle, sensor placements, and road surfaces, which limits their scalability and deployment potential. Our study addresses these gaps by designing a CNN-based model that processes raw multiaxial sensor data, enabling accurate detection without hand-crafted features or extensive preprocessing.

The objectives of this work are threefold: (1) to design a lightweight CNN architecture optimized for multichannel time series data from vibration and acceleration sensors; (2) to evaluate its performance in detecting multiple types of road events under realistic data variability; and (3) to ensure that the model can be deployed on resource-constrained embedded platforms without compromising accuracy.

From an engineering perspective, the proposed system contributes to intelligent transportation applications such as road infrastructure monitoring, preventive maintenance, and advanced driver-assistance systems (ADASs). Its compact design and real-time inference capabilities allow seamless integration into low-power, in-vehicle devices, supporting large-scale deployment in smart city initiatives.

3. The Proposed Algorithm

In this work, we implement a CNN 1D architecture adapted to the classification of road events from vibration and acceleration data, exploring different configurations of kernel size, depth, and activation layers to evaluate their effectiveness. The results demonstrate that a CNN-based approach can serve as a robust backbone for real-time event detection, offering a favorable balance between precision, speed, and generalization in diverse urban traffic conditions. Figure 2 outlines our proposed event classification pipeline, which processes multiaxial vibration and acceleration signals through a deep learning model to identify road events efficiently and accurately in real time.

3.1. Data Acquisition and Preprocessing

The raw data were acquired using an AQ-1 OBDII Data Logger mounted securely within an instrumented vehicle. We use six synchronous channels: three axes of linear acceleration (accel_x, accel_y, accel_z) and three axes of vibration (vib_x, vib_y, vib_z). The acceleration channels correspond to the raw unfiltered output of the sensor, directly capturing vehicle dynamics and gravitational components. In contrast, vibration channels are computed from acceleration data by applying a high-pass filter (cut-off at 10 Hz) to remove low-frequency components associated with gravity and large-scale vehicle motion. This separation ensures that the vibration signals emphasize high-frequency oscillations caused by road surface irregularities, while the acceleration signals retain full-spectrum motion information.

Before segmentation, we apply preprocessing over the acceleration signals in order to preserve informative content while reducing sensor-specific artifacts. Each acceleration channel is first filtered using a low-pass Butterworth filter with a cutoff frequency of 20 Hz. This step attenuates high-frequency noise components above the bandwidth of interest, which is justified given the physical nature of road-induced events. Following filtering, each channel is independently normalized using z-score normalization, computed globally over the entire trajectory. This normalization ensures that the neural network focuses on relative temporal dynamics rather than absolute signal magnitudes, which may vary due to sensor mounting angle, vehicle model, or environmental factors.

3.2. Tensor Formatting

Sensor signals are segmented into overlapping time windows to capture the temporal dynamics of road events. Each window comprises $L=50$ consecutive samples; this corresponds to one second of recordings at a 50 Hz sampling rate. The window advances in increments of 10 samples, producing overlaps that preserve temporal consistency and expand the training dataset.

Each window is reshaped into a 2D tensor of shape $[6\times 50]$, where the rows represent the six sensor channels and the columns represent time steps. These tensors are then stacked in batches with shape [batch_size × 6 × 50] and inputted into the 1D-CNN model for training and inference.

Window-level labels are assigned using a majority rule over the ground-truth labels within each window; if an event class dominates (i.e., occurs at least three times more than others and above a minimum threshold), it is assigned to the window. Otherwise, the window is labeled “No Event”.

To address class imbalance, stratified undersampling is applied, particularly reducing the overrepresented “No Event” class to match the frequency of minority classes. This ensures that all classes contribute equally during training and prevents overfitting to the dominant class.

The final output is a balanced dataset consisting of paired tensors and categorical labels, stored as X_bal and Y_bal for downstream training.

3.3. Road Event Classes and Annotation Criteria

The classification scheme adopted in this work is based on four categories of road events frequently reported in the literature [2,8,33]: “None”, “Pothole”, “Speed Bump” and “Sudden Braking”. These categories were selected according to three criteria: (1) their high occurrence and relevance to safety in urban driving, (2) the feasibility of detection using vibration and acceleration sensors, and (3) their use in prior benchmark studies, ensuring comparability with existing works. Annotation was performed on datasets collected in real-world driving conditions, recorded with a triaxial acceleration sensor during multiple routes in urban and suburban areas. The recorded trajectories reflect the natural statistical distribution of events in urban traffic, with most samples corresponding to “None” segments and fewer instances of “Speed Bump”, “Pothole”, and “Sudden Braking”. Each label was assigned manually during the trip, ensuring clear signal patterns for a reliable evaluation of the proposed CNN-based detection framework.

During each run, an experienced driver followed predefined urban and suburban routes in San Andrés Cholula (Puebla, Mexico), maintaining a constant speed (around 70 km/h) and avoiding non-target pavement damage to ensure path stability. An observer manually logged the start and end of each relevant event (e.g., pothole, speed bump, sudden braking) in real time using a digital timeline linked to the AQ-1 OBDII logger timestamps (50 Hz sampling, 20 ms granularity). In post-processing, these labels were synchronized with the acceleration and vibration data via Python 3.10 scripts, ensuring precise temporal alignment between physical events and multiaxial sensor patterns. Driving direction was inferred from the axial components of the sensors (X: longitudinal, Y: lateral, Z: vertical) and route metadata (outbound/return trajectory and approximate geolocation). Future work will integrate GPS to further enhance spatial accuracy. This procedure guarantees that every labeled window in the dataset corresponds to a physically observed event, supporting the reliability of the CNN-based detection framework.

3.4. CNN Model Training

The proposed classifier is a compact two-dimensional convolutional neural network (2D-CNN) designed to process multichannel temporal data efficiently while achieving robust classification of short road events. Although the input consists of time series data, the model leverages 2D convolutions with shape kernels $[1\times N]$ to simulate one-dimensional temporal filtering across all six channels simultaneously. The architecture and hyperparameters are presented in

Table 1. Architecture and parameters of the proposed CNN model for road event classification.

Layer	Configuration/Parameters	Output Shape
Input Layer	$[6\times 50\times 1]$ (channels × time steps × depth)	$6\times 50\times 1$
Conv Layer 1	32 filters, kernel $[1\times 5]$, stride $[1\times 1]$, padding = same	$6\times 50\times 32$
Batch Norm 1 + ReLU	—	$6\times 50\times 32$
Max Pooling 1	Pool $[1\times 2]$	$6\times 25\times 32$
Conv Layer 2	64 filters, kernel $[1\times 3]$, stride $[1\times 1]$, padding = same	$6\times 25\times 64$
Batch Norm 2 + ReLU	—	$6\times 25\times 64$
Max Pooling 2	Pool $[1\times 2]$	$6\times 12\times 64$
Dropout	Rate = 0.5	$6\times 12\times 64$
Fully Connected	Dense layer (num_classes)	num_classes
Softmax	Class probability output	num_classes

.

The model is trained using the Adam optimizer and cross-entropy loss. Data are partitioned with a 50/50 train–validation split using stratified sampling to preserve class distribution. Mini-batch stochastic gradient descent is employed with a batch size of 32 and up to 30 training epochs. Early stopping is guided by validation accuracy, with evaluations performed every 30 iterations.

This architecture simulates 1D temporal convolutions via 2D layers, enabling the model to capture fine-grained temporal patterns across all sensor channels jointly. This design strikes a good balance between accuracy and computational demands, enabling its use in real-time scenarios or on platforms with limited resources, including embedded devices and in-vehicle systems.

3.5. Event Classification

Once the convolutional neural network (CNN) has been trained, the classification process operates on the incoming sensor data in real time. Each new window of sensor readings, comprising multiaxial acceleration and vibration signals, is first preprocessed and reshaped into a standardized input tensor of size $[6\times 50\times 1]$, as described in Section 3.2.

The preprocessed tensor is then passed through the trained CNN model, which outputs a vector of class probabilities via the softmax function. The class corresponding to the highest probability is selected as the predicted event label:

$$\widehat{y}=\arg \max \left(\mathrm{softmax}\left(\mathcal{M}\left(T_{\mathrm{new}}\right)\right)\right)$$

where $\mathcal{M}$ denotes the trained model and $T_{\mathrm{new}}$ is the input tensor corresponding to the current window.

The system is designed for sliding-window inference, meaning that new predictions can be generated continuously as data arrive. Since the model uses only convolutional and feedforward operations, the entire classification process is executed in constant time $O\left(1\right)$ per window, ensuring low-latency responses suitable for real-time deployment on embedded or in-vehicle edge computing devices.

Classification accuracy, as well as per-class precision and recall, are evaluated using a validation set (see Section 4). This evaluation confirms that CNN is capable of accurately classifying multiple types of road events despite the presence of signal noise and variability between classes.

3.6. Design Rationale and Advantages

Although recurrent neural networks (RNNs), particularly long-short-term memory (LSTM) and gated recurrent unit (GRU) architectures, are well-suited for modeling long-range temporal dependencies, they introduce several limitations when applied to low-frequency, short-window sensor data such as ours. After empirical evaluation, we observed that a carefully designed one-dimensional convolutional neural network (1D-CNN) not only matched but occasionally surpassed the performance of hybrid CNN+LSTM architectures in terms of accuracy, precision and F1 score, while offering significant advantages in efficiency and deployability.

First, our input signals are segmented into short fixed-length windows (e.g., 50 samples = 1 s at 50 Hz), each of which typically contains a single event or none. These windows are largely self-contained and exhibit strong localized patterns (e.g., impulse spikes for “Potholes”, sinusoidal curves for “Speed Bumps”, and linear deceleration slopes for “Sudden Braking”), which 1D convolutions can learn effectively without requiring temporal recurrence.

Second, 1D-CNNs allow parallel computation across time steps, unlike LSTMs, which are inherently sequential during both training and inference. This architectural property results in faster convergence, lower inference latency, and greater compatibility with embedded or edge computing devices.

Third, recurrent models tend to overfit on moderately sized datasets due to their larger parameter space and memory requirements.

4. Results

This part provides a detailed summary of the results obtained in the study. It starts by describing the datasets used for training and testing the proposed method, focusing on their temporal characteristics, signal variability, and importance for urban mobility applications. This is followed by a quantitative analysis that examines the distribution and characteristics of the labeled events across all trajectories, providing insight into the dataset’s capacity to support robust learning and generalization.

Next, we analyze the computational complexity of the proposed convolutional neural network model, highlighting its lightweight architecture and suitability for deployment in real-time or embedded environments. Finally, we reflect on the implications of the obtained results, discussing both the strengths and limitations of our method.

4.1. Dataset Description

For this research, data were collected using a vehicle fitted with specialized instrumentation that navigated various routes in San Andrés Cholula, Puebla, Mexico. The selected routes were intended to cover a wide range of state roads, traffic levels, and types of urban infrastructure. The acquisition protocol prioritized high-quality measurements while limiting the impact of external noise.

An AQ-1 OBDII Data Logger [53], a precise data collection unit, was installed to record triaxial acceleration and angular velocity (from accelerometers and gyroscopes, respectively), securely mounted to reduce interference. The sampling was performed at up to 50 Hz per channel, allowing the detection of fine-grained road surface irregularities. In this study and in this scenario, vibration refers to the high-frequency component of the linear acceleration signal, obtained by applying a high-pass filter to remove low-frequency variations due to vehicle motion (acceleration, braking, and cornering). This filtered component represents the oscillatory response of the vehicle’s chassis to pavement irregularities, and serves as a complementary input to the raw acceleration in the classification pipeline, as illustrated in Figure 3.

Regarding the dataset, each JSON file contains timestamp sensor measurements, sampled at 50 Hz, across six axes: triaxial acceleration (accel_x, accel_y, accel_z) and triaxial vibration (vib_x, vib_y, vib_z). Each reading is associated with a label describing the current event, selected from the following four categories: “No Event”, “Speed Bump”, “Sudden Braking”, and “Pothole ”.

The datasets generated for this work include:

• urban_trip_puebla_1.json: Outbound trajectory through the central urban area.
• urban_trip_puebla_2.json: Return trajectory along the same urban route.
• urban_trip_puebla_3.json: Outbound trajectory through suburban and peripheral areas.
• urban_trip_puebla_4.json: Return trajectory along the same suburban route.

The complete data set comprises over 360,000 labeled instances corresponding to the 50 Hz sampling rate in six sensor channels, three from the accelerometer and three from the vibration sensor. Labels include “Pothole”, “Speed Bump”, “Sudden Braking”, and “No Event”. The data set is divided into four JSON files, as illustrated in Figure 4; two different routes were selected: one covering the urban center (Trajectory A) and another focused on the peripheral and suburban areas (Trajectory B). Each route was recorded in both directions to improve variability and balance the event distribution. Each JSON is available as Supplementary Material to ensure full reproducibility and to encourage further benchmarking on road event classification tasks using multiaxial sensor data.

Model training and testing were performed on an MSI Raider GE76 12U laptop powered by an Intel Core i7-12700H CPU. All deep learning experiments were run in MATLAB 2024a, using GPU acceleration when available. This setup supported efficient batch processing and allowed for comprehensive hyperparameter exploration without reducing the training speed.

4.2. Quantitative Analysis

In this section, we present the quantitative evaluation of our proposed CNN-based classifier for road event detection using our previously presented dataset. The model was trained on multiaxial acceleration and vibration signals, with more than 360,000 labeled instances segmented into 1-second windows and tested on held-out data. Performance metrics were computed to assess precision, recall and the F1 score.

CNN Model (Proposed): As mentioned in a previous section, the model uses a lightweight one-dimensional convolutional architecture that operates directly on shape tensors [6,50], representing six sensor channels (acceleration and vibration) sampled over a 1-second window at 50 Hz. The final model was trained using the Adam optimizer with class-balanced data and achieved outstanding performance across all event types and the “No Event” class.

The detailed results are presented in

Table 2. Per-class performance metrics for the proposed CNN classifier.

Class	TP	FP	FN	Precision	Recall	F1-Score
No Event	94	13	10	0.8785	0.9038	0.8910
Pothole	101	3	3	0.9711	0.9711	0.9711
Speed Bump	99	6	5	0.9429	0.9519	0.9474
Sudden Braking	95	5	9	0.9500	0.9135	0.9314

.

Overall performance metrics for the model:

• Global Accuracy: 93.51%;
• Macro-averaged Precision: 0.9356;
• Macro-averaged Recall: 0.9351;
• Macro-averaged F1-Score: 0.9352.

In practical operation, the CNN model detects “Potholes” through short spikes of high amplitude in vertical acceleration combined with high-frequency vibration bursts, while “Speed Bumps” are recognized by smoother symmetric peaks on both the vertical and longitudinal axes. “Sudden Braking” events show a strong deceleration pattern in the longitudinal axis with comparatively low vibration content. The main misclassification cases occur when road conditions produce mixed signatures, for example, when “Sudden Braking” occurs immediately after “Speed Bumps”, or when uneven road surfaces generate vibration patterns similar to “Potholes”. In such cases, overlapping temporal features can lead to confusion between classes, as reflected in the small off-diagonal entries of the confusion matrix.

However, our results indicate that the proposed 1D-CNN model consistently performs well in all event categories, with macroaveraged precision, recall, and F1 score values above 93%. The model performs particularly well on classes such as “Pothole” and “Speed Bump”, where the characteristic vibration signatures are well captured by convolutional filters. Even in the more challenging “No Event” and “Sudden Braking” classes, where intraclass variability is higher and signal patterns are less distinctive, the classifier maintains competitive scores, demonstrating strong generalization. The high global precision (93.51%) and balanced per-class metrics suggest that the model effectively learns discriminative features despite class imbalance and input noise, validating its robustness for real-time road event detection.

Compared to traditional ensemble-based classifiers, such as Random Forests [13,22,23], the proposed convolutional approach demonstrates significant advantages in terms of performance, generalization, and deployability. Although ensemble methods rely heavily on hand-crafted features and are often sensitive to data noise and variability, our CNN-based model operates in a fully end-to-end manner and maintains strong robustness even under signal perturbations. This performance is attributed to three key characteristics:

• End-to-end learning: Our CNN-based approach directly learns discriminative spatio-temporal features from raw multiaxial sensor data, eliminating the need for manual feature extraction or domain-specific preprocessing.
• Efficiency and deployability: The model architecture is lightweight and optimized for constant-time inference $\mathsf{𝒪}\left(1\right)$, making it feasible for real-time deployment on embedded and automotive-grade platforms with limited computational resources.

In addition, the evaluation metrics are complemented by visual insights. Figure 5 presents the normalized confusion matrix, illustrating strong diagonal dominance and low misclassification rates in all classes. Meanwhile, Figure 6 shows class-specific ROC curves, which highlight the discriminative capacity of the model and the high area under the curve (AUC) for each type of event.

To provide context for the obtained results, we conducted a comparison between our CNN-based approach and a traditional threshold-based method that classifies events using fixed limits on acceleration and vibration data. This analysis highlights the CNN’s benefits not only in terms of accuracy but also in adaptability, scalability, and its ability to support informed decisions.

Table 3. Comparison between the proposed CNN model and a traditional rule-based approach. The CNN achieves superior overall performance and provides probabilistic outputs, which are essential for integration into embedded systems and decision-making modules.

Method	Precision	Recall	F1-Score	Accuracy	Probabilistic
Rule-based approach	0.9200	0.7800	0.8400	0.9100	No
CNN (proposed)	0.9356	0.9351	0.9352	0.9351	Yes

compiles the core metrics for both methods on the same dataset.

The traditional rule-based approach, although straightforward and interpretable, relies on manually defined thresholds over acceleration and vibration profiles. Although this method can perform adequately in static or controlled scenarios, its performance often deteriorates under real-world variability, such as different sensor configurations, mounting positions, road textures, and vehicle dynamics. Furthermore, rule-based systems lack probabilistic output, preventing the estimation of prediction confidence or the generation of ROC curves, both critical elements for robust decision making in safety-critical applications.

In contrast, the proposed CNN classifier demonstrates superior performance in all metrics while preserving computational efficiency. By learning spatial and temporal patterns directly from raw multiaxial sensor inputs, the CNN achieves high generalization and strong resistance to signal noise and domain shifts. Crucially, it yields softmax-based probabilistic outputs that not only enhance interpretability but also enable seamless integration into downstream modules such as Bayesian fusion, alert systems, or autonomous control layers.

4.3. Computational Complexity

To assess the feasibility of deploying the proposed convolutional neural network (CNN) in embedded and real-time applications, we analyze its computational complexity in terms of the number of trainable parameters and the number of floating point operations (FLOPs) per inference.

The proposed 1D-CNN architecture processes input tensors of size $[6\times 50\times 1]$ through a sequence of convolutional and grouping layers followed by a fully connected output stage. The total number of trainable parameters is approximately 15,000, which includes convolutional kernels, bias terms, and dense layer weights. This parameter count is orders of magnitude smaller than typical recurrent or transformer-based models, making it ideal for deployment on edge devices with limited memory.

In terms of inference cost, the complexity of each convolutional layer is $O(F·K·C·T)$, where F is the number of filters, K is the kernel size, C is the number of input channels and T is the temporal length of the feature map. Since all convolutions operate with kernel sizes of 5 or 3, and pooling layers reduce temporal dimensions by a factor of 2, the total number of FLOPs per input window is less than 200,000, which is well within the real-time budget for embedded microprocessors or in-vehicle GPUs.

Furthermore, since the model is fully convolutional (without recurrence), inference can be efficiently parallelized, and the total latency per input window remains constant ($O\left(1\right)$) regardless of the number of windows processed. This property is particularly beneficial for the classification of real-time road events, where rapid response is critical.

Finally, the compact model size (under 100 kB) allows for direct deployment on edge computing platforms such as NVIDIA Jetson Nano, Raspberry Pi 4, or ARM Cortex-M microcontrollers (with optimized inference libraries like TensorRT or CMSIS-NN). These characteristics collectively validate the suitability of our model for practical, low-latency deployment in automotive and smart mobility systems.

5. Current Scope and Limitations

The proposed 1D-CNN demonstrates high accuracy and reliability in detecting road events in real time from multiaxial acceleration and vibration inputs. Unlike rule-based or ensemble methods, it processes raw sensor data end-to-end, eliminating the need for handcrafted features, and its compact design supports deployment on embedded hardware with limited computational capacity.

However, the current model is based solely on inertial measurements, without integrating additional modalities such as gyroscopes, GPS or visual data, which could improve the discrimination of complex events. It also depends on fixed-length time windows, which can potentially limit adaptability to events of varying duration, and interpretability remains a concern for safety-critical applications.

Future Work

Although the proposed CNN-based approach demonstrates high performance and robustness, several areas remain for future enhancement.

• Real-Time Embedded Deployment: Extend the current offline implementation into a real-time pipeline running on embedded hardware platforms. This involves profiling the model and optimizing its inference time and power consumption for deployment in automotive or mobile systems.
• Hybrid Architectures: Explore the combination of CNNs with sequential models such as LSTMs or modules based on attention to better capture temporal dependencies and improve performance in complex events that overlap.
• Multimodal Sensor Fusion: Integrate additional signals such as gyroscope, GPS, and visual input to improve context awareness and classification accuracy in ambiguous or noisy conditions.
• Dynamic Windowing: Implement adaptive windowing techniques that adjust the length of the input based on signal characteristics or the detection of the onset of the event, increasing the responsiveness to short- or long-duration events.
• Cross-Domain Evaluation: Test the model in real-world data sets from different cities, road surfaces, and vehicle types to evaluate and improve generalization in multiple scenarios.

These future directions aim to increase the applicability, efficiency and scope of the model, supporting safer and smarter transportation systems in urban environments.

6. Conclusions

This work introduces a CNN-driven method for detecting and classifying road events based on multiaxial acceleration and vibration measurements. The proposed network achieves high performance in several types of events such as “Speed Bump”, “Sudden Brake” and “Pothole” while retaining robustness in the face of class imbalance and signal variability. In contrast to rule-based or ensemble techniques, CNN processes raw sensor streams in an end-to-end fashion, removing the need for manual feature crafting or fixed threshold tuning. The main results of this work are as follows:

• The proposed CNN model achieved a macroaveraged F1 score of 0.9352 and a global precision of 93.51% in four categories of events. It demonstrated balanced precision and recall for both frequent and rare events.
• Class-specific performance remained consistently high; for example, pothole detection reached a precision and recall of 0.9711, while sudden braking maintained an F1 score of 0.9314, demonstrating the model’s ability to generalize between types of event.
• Compared to a rule-based baseline, the CNN model exhibited superior performance, especially in its ability to handle diverse sensor inputs and output probabilistic event predictions suitable for real-time thresholding and integration with downstream systems.
• The proposed architecture remains lightweight enough to support potential deployment in embedded systems, offering an efficient solution for inference on the device in vehicular environments.

In terms of computational complexity, the proposed CNN model offers significant advantages because of its fully convolutional architecture. Unlike recurrent networks, all operations can be parallelizable, resulting in a constant-time inference complexity of $\mathsf{𝒪}\left(1\right)$ per input window. This makes the model highly suitable for both offline batch processing and real-time deployment on embedded systems with limited resources.