Why a Spiral Bevel Gearbox Is Hard to Diagnose from a Single View
A spiral bevel gear pair transmits rotation between intersecting shafts, usually at 90°, through teeth whose contact line moves progressively from one end of the face to the other. Compared with straight bevel gears, this geometry raises the contact ratio, spreads load over several teeth at once and reduces meshing impact, which is why the arrangement dominates right-angle drives in helicopter tail rotors, vehicle axles, mining conveyors and machine-tool spindles. The same geometry, however, makes the vibration signature difficult to read. Meshing frequency and its harmonics are amplitude- and frequency-modulated by shaft rotation and by the time-varying transmission path, so a tooth-root crack, a missing tooth or a worn flank does not produce a clean, stationary spectral line but a smeared and impulsive pattern that shifts with speed and load.
Two further conditions complicate automated diagnosis. First, the gearbox shares its housing and mounting structure with bearings, a planetary reducer and the driven load, so sensor signals mix several excitation sources with overlapping bands. Second, industrial measurements are contaminated by broadband random noise and by occasional impulsive disturbances from the driven machinery. A classifier that performs well on clean laboratory data can lose most of its discriminative margin once the signal-to-noise ratio falls.
Deep diagnostic models typically address this by learning from one representation only. A convolutional network fed with a time–frequency image captures local spectral texture but treats successive frames as independent; a recurrent network fed with the raw sequence captures temporal dependence but is blind to the two-dimensional structure of the spectrum. The architecture described here couples both views in parallel and fuses their embeddings before classification. Its spatial branch also departs from conventional attention: instead of reweighting channels or two-dimensional positions, it assigns a separate weight to every tap of the depthwise convolution kernel, so the effective receptive field is reshaped per channel rather than merely rescaled.
Signal Preparation: Overlap Resampling and Time–Frequency Conversion
Deep models trained on a few long recordings overfit quickly. Overlapping segmentation multiplies the number of labelled windows without new measurements by exploiting the local continuity of the vibration signal. The window must be long enough to contain at least one complete revolution of the gear shaft, otherwise the phase relationship between meshing events is lost:
$$w_X \ge \frac{60\,F_s}{n}$$
where $n$ is the shaft speed in r/min and $F_s$ the sampling frequency in Hz. The number of windows obtainable from a record of length $L_t$ with sliding stride $L_s$ is
$$N = \left\lfloor \frac{L_t – w_X}{L_s} \right\rfloor + 1$$
with $L_s < w_X$ in the overlapping case. At 1000 r/min and 5000 Hz, one revolution corresponds to 300 sample points, so the 1024-point window actually used spans about 3.4 revolutions (204.8 ms), and a stride of 128 points gives 87.5 % overlap between consecutive windows.
Each window is then converted into a time–frequency image by the short-time Fourier transform. The window length $L_w$ controls the trade-off between time and frequency resolution and is set from the lowest fault-related frequency $f_{\min}$ that must remain resolvable:
$$L_w = \alpha \frac{F_s}{f_{\min}}, \qquad \alpha \in [2,\,5]$$
Frames are extracted with a window function $w(t)$ and hop $L_s$, and each frame is transformed:
$$X(m,k) = \sum_{t=0}^{L_w-1} x(t)\,w(t – m L_s)\,e^{-j2\pi k t / L_w}$$
Here $m$ indexes the frame and $k$ the frequency bin. Stacking the magnitude spectra along the time axis produces a matrix whose rows correspond to frames, whose columns correspond to frequency bins and whose entries represent local energy. In this work the matrix is resized to a $256\times256$ image and fed to the spatial branch, while the same segmented window is kept as a one-dimensional sequence for the temporal branch. The two inputs therefore describe identical physical events at different levels of abstraction: the image preserves spectral layout but discards absolute phase, whereas the sequence preserves waveform-level transients and long-range periodicity.
Receptive-Field Attention in the Residual Branch
The spatial branch is a residual convolutional network. Each residual block contains two $3\times3$ convolutions, each followed by batch normalization and a ReLU activation, with a $1\times1$ convolution on the shortcut path to match channel dimensions. Residual connections, introduced for very deep image classifiers in 2016, keep gradients well behaved as depth increases and allow features from early layers to be reused at later stages.
Receptive-field attention (RFA) is inserted at several depths. Its distinguishing property is the shape of the attention tensor. Given an input feature map $X \in \mathbb{R}^{b\times c\times h\times w}$, global average pooling first compresses the spatial dimensions into a channel descriptor:
$$Z_c = \frac{1}{h\,w}\sum_{i=1}^{h}\sum_{j=1}^{w} X_c(i,j)$$
A two-layer bottleneck with a nonlinearity then maps this descriptor to a kernel-parameter tensor:
$$A_{\text{raw}} = W_2\,\delta\!\left(W_1 Z + b_1\right) + b_2$$
which is reshaped into a four-dimensional tensor with one entry per sample, output channel, kernel row and kernel column, and normalized by a sigmoid:
$$A_{k\times k} = \sigma\!\left(\text{reshape}\left(A_{\text{raw}}\right)\right)$$
The element $A_{b,c,i,j}$ therefore expresses how important position $(i,j)$ of the kernel applied to output channel $c$ of sample $b$ is. Multiplying this tensor element-wise with the original depthwise kernel yields a dynamic kernel, and the corresponding feature map follows from a depthwise convolution:
$$F_{k\times k} = X \otimes \left(K_{k\times k} \odot A_{k\times k}\right)$$
where $\odot$ denotes element-wise multiplication and $\otimes$ a depthwise convolution whose group count equals the number of input channels. Three such branches with $3\times3$, $5\times5$ and $7\times7$ kernels are evaluated in parallel to cover local, intermediate and broad context. Their fusion weights are generated from the same global descriptor $Z$ through a fully connected layer and normalized with softmax:
$$[w_1, w_2, w_3] = \text{softmax}\left(W_f Z + b_f\right)$$
$$Y = w_1 F_{3\times3} + w_2 F_{5\times5} + w_3 F_{7\times7}$$
The practical difference from channel attention or from the two-dimensional spatial maps of CBAM-style modules is one of granularity. A two-dimensional map can only emphasize where in the feature map to look; a four-dimensional tensor also decides which taps inside each kernel should respond strongly. Because the weights are generated per sample at inference time, the effective receptive field adapts to the input rather than remaining fixed after training. In a gearbox spectrum, this matters when a weak sideband occupies a narrow band next to a strong meshing harmonic: the module can sharpen the kernel response around the sideband and attenuate it across the harmonic without changing the network topology.
Temporal Branch: Bidirectional Gating Followed by Self-Attention
The second branch models the one-dimensional sequence. Its basic unit is the gated recurrent unit, which regulates information flow through an update gate $z_t$ and a reset gate $r_t$:
$$z_t = \sigma\!\left(W_z x_t + U_z h_{t-1} + b_z\right), \qquad r_t = \sigma\!\left(W_r x_t + U_r h_{t-1} + b_r\right)$$
$$\tilde{h}_t = \tanh\!\left(W_h x_t + U_h\left(r_t \odot h_{t-1}\right) + b_h\right)$$
$$h_t = \left(1 – z_t\right)\odot h_{t-1} + z_t \odot \tilde{h}_t$$
The gating mechanism mitigates the vanishing-gradient problem of plain recurrent networks and allows dependencies over hundreds of time steps to be retained. Gating alone, however, is causal: the state at time $t$ depends only on past inputs. Bidirectional recurrent networks, introduced in 1997, run a second recurrence over the reversed sequence and concatenate the two hidden states,
$$h_t = \left[\overrightarrow{h}_t \,;\, \overleftarrow{h}_t\right]$$
so that the representation of any instant draws on both preceding and following context. For a periodic vibration record this is valuable because a single impulsive event is best interpreted relative to the mesh cycles on either side of it.
Bidirectional context still weights all time steps equally. The scaled dot-product self-attention formulated for the Transformer in 2017 supplies the missing selectivity. Query, key and value matrices are obtained by linear projection, and the attention output is a weighted average of value vectors:
$$Q = X W_Q, \qquad K = X W_K, \qquad V = X W_V$$
$$\text{Attention}(Q,K,V) = \text{softmax}\!\left(\frac{Q K^{\top}}{\sqrt{d_k}}\right) V$$
where $d_k$ is the dimensionality of the key vectors and the scaling keeps the pre-softmax logits in a numerically stable range. Placed after the BiGRU layer, the module aggregates the hidden states of all time steps and assigns larger weights to the steps that carry fault-relevant transients. The temporal branch finally emits a 256-dimensional embedding; the residual branch emits 512 dimensions.
Fusion, Classification and Training Configuration
The two embeddings are concatenated into a 768-dimensional vector, passed through a fully connected layer with ReLU activation and a dropout rate of 0.5, and mapped to seven class scores by a softmax output layer. Training uses an initial learning rate of 0.001 with dynamic scheduling and runs for 30 epochs. Because the branches share no parameters before fusion, the spatial path is optimized on time–frequency images while the temporal path sees raw sequences, and the concatenation forces the classifier to rely on complementary evidence rather than on two redundant views of the same transform.
Test Rig and Seven-Class Dataset
Fault-simulation experiments were performed on a dedicated test stand at the fault diagnosis laboratory of Jinzhong University. The drivetrain consists of a drive motor, a torque sensor, ICP single-axis and three-axis accelerometers, the spiral bevel gearbox under test, a planetary gear reducer, a magnetic particle brake, a protective enclosure and a DASP data-acquisition system. The accelerometer axes map to acquisition channels 1–3, with the single-axis sensor’s Z axis on channel 4; all sensors are mounted on the housing cover above the gear axis line, close to the meshing zone.
Seven conditions were recorded: normal operation, missing tooth on the large gear, missing tooth on the small pinion, root crack on the large gear, root crack on the pinion, tooth-surface wear on the large gear and tooth-surface wear on the pinion. Each condition was measured for 60 s at a motor speed of 1000 r/min with a sampling frequency of 5000 Hz. Segmentation with a 1024-point window and a 128-point stride produced 1120 samples per condition, 7840 in total, split 8:2 into 6272 training and 1568 test samples.
| Parameter | Value |
|---|---|
| Shaft speed | 1000 r/min (one revolution ≈ 300 points at 5000 Hz) |
| Sampling frequency | 5000 Hz |
| Recording length per condition | 60 s |
| Fault classes | 7 |
| Sample length / stride | 1024 points (204.8 ms, ≈ 3.4 revolutions) / 128 points (87.5 % overlap) |
| Samples per class / total | 1120 / 7840 |
| Training / test split | 6272 / 1568 (8:2) |
| Time–frequency input | 256 × 256 STFT magnitude image |
| Initial learning rate / epochs / dropout | 0.001 / 30 / 0.5 |
Clean-Data Accuracy and Behaviour under Mixed Noise
On the noise-free test set the fused model classified every sample correctly, with all off-diagonal entries of the confusion matrix equal to zero. Training and test accuracy rose together and saturated, while training and test loss fell to a low plateau with only a small gap between them — the signature of a model that is fitting signal structure rather than memorizing individual windows. With seven balanced classes, chance-level accuracy is 14.3 %, so the margin is substantial.
Robustness was probed by adding mixed Gaussian–impulse noise to the raw vibration signals before the time–frequency transform, at signal-to-noise ratios of 10 dB and 20 dB, with impulses occurring at a 5 % probability. The Gaussian component represents continuous random interference from the environment; the impulse component represents abrupt mechanical or electrical disturbances. Under the 10 dB condition, training and test accuracy rose in step and nearly coincided after roughly 20 epochs, approaching 100 %, while both losses fell rapidly and stabilized near 0.2. Under the 20 dB condition the curves were visibly less settled: test accuracy dropped sharply around the tenth epoch, convergence was slower, test loss fluctuated more and the final plateau sat higher.
That ordering deserves a caveat. A 10 dB SNR corresponds to a noise power ten times that of a 20 dB case, so the smoother behaviour at 10 dB is not monotonic in SNR and should not be read as a general SNR–accuracy curve. Plausible explanations are the particular noise realization drawn for each experiment and the interaction of the impulse train with the STFT window, since a 5 % impulse probability places several impulses inside every 204.8 ms frame and the resulting broadband smear can dominate the representation at either ratio. What the two runs do establish is that the model retains high accuracy and a small train–test gap when the input is corrupted, and that degradation appears first as instability during optimization rather than as a collapse of final accuracy.
| Model | Test accuracy (%) |
|---|---|
| ResNet-RFA + BiGRU-SATT (fused dual-channel) | 100 |
| Mamba | 96 |
| SVM | 94 |
| Transformer | 91 |
| DBN | 89 |
The comparison set spans classical and recent architectures. The state-space Mamba model performed best among the alternatives at 96 %, the classical support vector machine reached 94 % and outperformed the Transformer at 91 %, while the deep belief network was weakest at 89 %. The gap between the fused model and the strongest alternative is four percentage points on this dataset — a difference that, at accuracies above 90 %, corresponds to roughly 60 additional correct decisions out of 1568 test samples, which is meaningful but should be confirmed on data from other rigs before being treated as a general advantage.
Stability, Statistical Checks and Computational Cost
Because a single train–test split can flatter a model, three additional evaluations were performed. Thirty independent runs with randomly redrawn splits gave a mean accuracy of 99.93 % with a standard deviation of 0.12 percentage points. The averaged confusion matrix over those runs kept every diagonal entry above 99.9 % with per-class accuracy between 99.85 % and 99.92 %, and every off-diagonal entry below 0.04 %. Five-fold cross-validation produced fold accuracies all above 99.8 %, a mean of 99.92 % and a standard deviation of 0.0004 in fractional terms, indicating that the result is not sensitive to how the data are partitioned.
Computational demand was measured on an NVIDIA RTX 3080. Single-inference latency was about 12.3 ms, the parameter count was 18.7 M and runtime memory occupancy was approximately 320 MB. The cost profile follows directly from the two-branch design: the convolutional path scales with the $256\times256$ input and channel width, while the recurrent path scales with sequence length and hidden dimension, and the self-attention term grows with the square of the sequence length — acceptable at the 1024-point window used here, but a constraint if longer records are processed in one pass.
For deployment on resource-limited edge hardware, the reported latency and memory footprint are the binding constraints rather than accuracy. Downsampling the time–frequency input, pruning redundant channels in the residual branch and quantizing weights after training are the obvious levers; each trades a small amount of accuracy for a proportional reduction in computation. The recurrent branch is the more natural target for sequence-level compression, since the attention matrix is the only component whose cost is superlinear in window length.
Limits of the Evidence and Practical Reading
Several boundaries should be kept in view. All results come from one laboratory rig, one shaft speed and one loading configuration, with faults produced by deliberate physical modification of the gears rather than by service degradation; the seven classes are balanced and clearly separated in the time–frequency plane, which is rarely true of field data where early wear coexists with incipient cracks. Noise was added digitally to the recorded signal, so it does not reproduce the correlated, structural-borne interference of a real drivetrain, and the impulse probability was fixed at 5 % rather than drawn from a measured distribution. Finally, near-perfect accuracy on a closed-set task says nothing about the model’s behaviour on an unseen fault type, which would be rejected by a softmax classifier only by accident.
Within those limits, the results support a specific engineering claim: for a spiral bevel gearbox, parallel processing of a time–frequency image and a raw sequence, combined with parameter-level attention in the spatial branch and self-attention weighting over bidirectional temporal states in the sequence branch, produces a classifier that is both accurate on clean data and stable when the input is corrupted. The mechanism is interpretable in mechanical terms — the spatial branch resolves weak sidebands around meshing harmonics, the temporal branch weights the transient windows in which tooth impact occurs — and that alignment between architecture and physics is what makes the design transferable to other rotating machinery with modulated signatures.
Conclusion
A dual-channel diagnostic architecture for spiral bevel gearboxes has been described in which a residual network with receptive-field attention processes short-time Fourier images while a bidirectional gated recurrent unit with self-attention processes the corresponding one-dimensional sequences. Receptive-field attention generates a four-dimensional tensor that weights individual kernel taps per channel and per sample, deforming the effective receptive field rather than merely rescaling feature maps; self-attention over the concatenated forward and backward hidden states highlights the time steps that carry fault transients. Fusing a 512-dimensional spatial embedding with a 256-dimensional temporal embedding yields a 768-dimensional representation classified by a single fully connected head.
On a seven-class dataset of 7840 samples acquired at 1000 r/min and 5000 Hz, the fused model reached 100 % test accuracy, compared with 96 % for Mamba, 94 % for SVM, 91 % for Transformer and 89 % for DBN, and it retained high accuracy under mixed Gaussian–impulse noise at 10 dB and 20 dB. Thirty repeated runs gave 99.93 % ± 0.12 %, and five-fold cross-validation gave 99.92 % with a standard deviation of 0.0004. Inference required 12.3 ms per sample with 18.7 M parameters on an RTX 3080. The remaining work is the one the laboratory setting cannot supply: validation on field-recorded spiral bevel gear data with unbalanced, co-occurring and previously unseen fault modes, and compression of the recurrent branch for edge deployment.