Filter-Tank — Machine Fault Recognition
A deep learning system that listens to factory machine audio recordings and classifies them into 6 categories across 3 machine types, each in either a normal or abnormal state. Built from scratch using SE-ResNet on log-mel spectrograms.
Overview
Filter-Tank is a complete machine learning pipeline for
predictive maintenance. Given a raw .wav audio recording
of a factory machine, the system automatically detects
whether the machine is operating normally or has developed
a fault — and identifies which machine type it belongs to.
The model is a custom SE-ResNet (Squeeze-and-Excitation ResNet) trained entirely from scratch with no pretrained weights, designed specifically for 1-channel log-mel spectrogram input.
Classes
| Label | Description |
|---|---|
| 0 | Machine 1 — Normal |
| 1 | Machine 1 — Abnormal |
| 2 | Machine 2 — Normal |
| 3 | Machine 2 — Abnormal |
| 4 | Machine 3 — Normal |
| 5 | Machine 3 — Abnormal |
Preprocessing Pipeline
Every audio file passes through a multi-stage preprocessing pipeline before reaching the model. All steps run on CPU and are excluded from the inference timer (only processing
- prediction time is measured).
1. Resampling
All audio is resampled to a fixed sample rate of 16,000 Hz to ensure consistency across recordings made with different microphones or recording equipment.
2. Noise Reduction
Non-stationary background noise is removed using the
noisereduce library with full noise reduction strength
(prop_decrease=1.0). This handles real-world factory
environments where background noise varies significantly
between recordings.
3. Silence Trimming
Leading and trailing silence is removed using librosa's trim function (top_db=20). This ensures the model focuses only on the actual machine sound rather than quiet gaps at the start or end of a recording.
4. Fixed-Length Normalization
All recordings are normalized to exactly 11 seconds. Files longer than 11 seconds are truncated from the end. Files shorter than 11 seconds are zero-padded at the end. This gives the model a consistent input size regardless of the original recording length.
5. Log-Mel Spectrogram
The waveform is converted into a 2D log-mel spectrogram using the following settings:
- Mel bands: 128
- FFT window size: 1024
- Hop length: 512
- Power: 2.0 (power spectrogram)
- Amplitude converted to dB scale (top_db=80)
This transforms the raw audio signal into a visual time-frequency representation that the convolutional model can process effectively.
6. CMVN Normalization
Cepstral Mean and Variance Normalization is applied per sample — each spectrogram is normalized to have zero mean and unit variance along the time axis. This handles volume variations and differences in microphone sensitivity across recordings.
Model Architecture
SE-ResNet (Squeeze-and-Excitation ResNet)
The model follows a standard ResNet structure enhanced with Squeeze-and-Excitation (SE) attention blocks at every residual stage.
Stem: A 7x7 convolution (stride 2) followed by batch normalization, ReLU, and max pooling reduces the input resolution before the residual stages.
4 Residual Stages:
- Stage 1: 3 SE-Residual blocks, 64 channels
- Stage 2: 4 SE-Residual blocks, 128 channels (stride 2)
- Stage 3: 6 SE-Residual blocks, 256 channels (stride 2)
- Stage 4: 3 SE-Residual blocks, 512 channels (stride 2)
SE Attention Block: Each residual block includes a Squeeze-and-Excitation module that performs global average pooling, passes the result through two fully-connected layers with a bottleneck (reduction=16), and produces per-channel attention weights via sigmoid. This lets the model focus on the most informative frequency channels for each input.
Head: Global Average Pooling → Dropout (0.3) → Fully Connected layer → 6-class output.
Weight Initialization:
- Conv layers: Kaiming Normal (fan_out, relu)
- BatchNorm: weight=1, bias=0
- Linear layers: Xavier Uniform
Total Parameters: ~11 million
Training Details
Dataset Split
The dataset is divided using stratified splitting to ensure balanced class representation across all splits:
- Training set: 80%
- Validation set: 10%
- Test set: 10%
Stratification is done by machine type and condition combined, so each split has proportional representation of all 6 classes.
Class Imbalance Handling
A WeightedRandomSampler is used during training to oversample underrepresented classes, ensuring the model sees a balanced distribution of all 6 classes per epoch regardless of the original dataset distribution.
Data Augmentation
Two augmentation strategies are applied during training:
SpecAugment (online, per batch): Applied directly to the spectrogram tensors during training. Two frequency masks (freq_mask_param=20) and two time masks (time_mask_param=40) are applied randomly, forcing the model to be robust to missing frequency bands and time segments.
Mixup (online, per batch): Pairs of training samples are blended together with a random interpolation weight drawn from a Beta distribution (alpha=0.4). Both the input spectrograms and their labels are mixed, which acts as a strong regularizer and improves generalization.
Loss Function
Cross-Entropy Loss with label smoothing (0.1). Label smoothing prevents overconfident predictions and improves calibration.
Optimizer & Scheduler
- Optimizer: AdamW (weight decay=1e-4)
- Scheduler: OneCycleLR with cosine annealing
- Max LR: 3e-3
- Warmup: 10% of total steps
- Gradient clipping: max norm = 1.0
Mixed Precision Training
All forward and backward passes use torch.amp autocast with float16 precision, reducing memory usage and speeding up training on GPU.
Multi-GPU Support
The model supports DataParallel training across multiple GPUs automatically. The best model state is always saved from the unwrapped module to ensure compatibility during single-GPU inference.
Early Stopping
Training stops automatically if validation accuracy does not improve for 12 consecutive epochs (patience=12). The best model checkpoint is saved based on validation accuracy.
| Setting | Value |
|---|---|
| Optimizer | AdamW |
| Max LR | 3e-3 |
| LR Schedule | OneCycleLR (cosine annealing) |
| Weight Decay | 1e-4 |
| Max Epochs | 60 |
| Early Stopping | Patience = 12 |
| Batch Size | 64 |
| Label Smoothing | 0.1 |
| Mixup Alpha | 0.4 |
| Mixed Precision | float16 (AMP) |
| Dropout | 0.3 |
Inference
During inference, audio files are processed strictly one-by-one in naturally sorted order (1.wav, 2.wav, ...). The preprocessing pipeline runs on each file individually, and only the processing + prediction time is measured (I/O reading is excluded from the timer).
Two output files are produced:
results.txt— one predicted class label (0–5) per linetime.txt— processing time per file in seconds (rounded to 3 decimal places)
Requirements
- Python 3.8+
- PyTorch
- torchaudio
- librosa
- noisereduce
- numpy
- soundfile
- scikit-learn
Limitations
- Trained only on 3 specific machine types; may not generalize to unseen machine types out of the box
- Performance may degrade with extremely noisy environments beyond the training distribution
- Fixed 11-second input window; very short recordings are zero-padded which may affect accuracy
Team
Cairo University — Faculty of Engineering Computer Engineering Department Pattern Recognition and Neural Networks — Spring 2026