基于LBP特征的SVM多类分类性能波动原因及优化咨询
Great question—this kind of performance variability across class subsets is super common in action recognition, and it usually boils down to a mix of feature limitations, classifier parameter issues, and inherent inter-class similarity. Let’s break down why this is happening and what you can do about it.
Why You’re Seeing Performance Fluctuations
1. Inter-Class Similarity & Decision Boundary Context
When you include classes that are visually or motionally similar (like biking vs riding, or tennis vs golf), the SVM struggles to draw clear decision boundaries between them. These overlapping classes "compete" for the same feature space, so the model can’t learn to distinguish them reliably.
When you swap a similar class for a dissimilar one (e.g., diving → billiards), the remaining classes have more distinct feature clusters. This makes it easier for the SVM to correctly classify them—hence the performance boost for some classes. Conversely, swapping a dissimilar class for a similar one muddles boundaries again, leading to accuracy drops for affected classes.
2. Static Feature Limitations
Plain LBP is a texture-focused feature that doesn’t capture temporal motion—something critical for action recognition. You’re extracting LBP from 8 frames, but just concatenating them doesn’t tell the model how texture changes over time. Actions like biking vs riding have similar static textures but distinct motion patterns, which LBP alone can’t pick up. This forces the model to rely on weak, non-motion cues, leading to poor performance between similar action classes.
3. Untuned SVM Parameters
MATLAB’s svmtrain uses default parameters (like a linear kernel or fixed regularization value C) unless specified. These defaults rarely work optimally for all class subsets. For example, a low C might let the model overfit to noise when dealing with similar classes, while a high C might make it too rigid to adapt to new class combinations. Without tuning, the SVM can’t adjust to the varying complexity of different class groups.
4. Curse of Dimensionality
LBP features can be high-dimensional (especially if using extended LBP with many bins). With only 70 samples per class, the model may struggle to generalize—this problem is amplified when classes are similar, as there’s not enough data to learn meaningful, distinct boundaries.
How to Fix the Issue
1. Upgrade Features to Capture Motion
The biggest win here is adding temporal context to your features:
- Use LBP-TOP: This variant of LBP analyzes three orthogonal planes (XY for static texture, XT and YT for temporal changes) to capture spatial-temporal patterns. It’s designed specifically for action recognition and will help distinguish actions with similar static textures but different motion.
- Add optical flow features: Compute optical flow between consecutive frames, then extract HOG (Histogram of Oriented Gradients) from the flow fields. Combining LBP with optical flow gives the model both texture and motion cues.
- Try bag-of-features: Extract local LBP (or LBP-TOP) features from all frames, cluster them into a codebook with k-means, then represent each video as a histogram of codeword occurrences. This reduces dimensionality and aggregates temporal information more effectively.
- Normalize features: Always scale your features (e.g., z-score or min-max scaling) before training. SVMs are sensitive to feature scales, and inconsistent scaling can lead to unstable performance across subsets.
2. Tune SVM Parameters Rigorously
Don’t rely on defaults—use cross-validation to find optimal parameters for your data:
% Example: Tune RBF SVM with 10-fold cross-validation svmModel = svmtrain(trainingFeatures, trainingLabels, ... 'Kernel_Function', 'rbf', ... 'CrossVal', 'on', ... 'GridSize', 10); bestParams = svmModel.BestParameters; % Get optimal C and gamma % Train final model with best parameters finalModel = svmtrain(trainingFeatures, trainingLabels, ... 'Kernel_Function', 'rbf', ... 'C', bestParams.C, ... 'Gamma', bestParams.Gamma);
RBF kernels often outperform linear kernels for complex, non-linear feature spaces like action recognition.
3. Address Inter-Class Confusion
- Visualize your feature space: Use t-SNE or PCA to plot features of different classes. This will show you which classes overlap heavily. For overlapping classes, you may need to add more discriminative features (like motion cues) or collect more diverse samples.
- Try one-vs-rest SVM: MATLAB’s default multi-class SVM uses a one-vs-one approach. For highly similar classes, a one-vs-rest approach (each class is trained against all others) can sometimes create clearer decision boundaries.
4. Augment Your Training Data
With only 70 samples per class, augmenting your data will help the model learn more robust features:
- Flip frames horizontally, add slight rotations, or adjust brightness/contrast.
- For videos, try time-stretching or adding small temporal shifts to simulate different action speeds.
5. Try Alternative Classifiers
If SVMs still struggle with overlapping classes, consider ensemble methods:
- Random Forests: Use MATLAB’s
TreeBaggerto train an ensemble of decision trees. These models can capture complex, non-linear relationships between features and classes more effectively than SVMs in some cases. - Gradient Boosting Machines: Use
fitensembleto train a GBM, which iteratively improves on misclassified samples and handles imbalanced or overlapping data well. - Pre-trained CNNs: For a modern approach, use a pre-trained CNN (like ResNet) to extract hierarchical spatial features from frames, then feed those into an SVM or classifier of choice. You can even extend this to 3D CNNs or ConvLSTMs to model temporal sequences directly.
Start with tuning your SVM parameters and adding motion-aware features like LBP-TOP or optical flow—these are quick wins that should reduce performance variability. If you still see issues, move to data augmentation or alternative classifiers. And always visualize your feature space to understand which classes are causing the most confusion!
内容的提问来源于stack exchange，提问作者a.kushwaha
