SysNoise: Exploring and Benchmarking Training-Deployment System Inconsistency

Yan Wang, Yuhang Li, Ruihao Gong, Aishan Liu, Jian Hu, Yongqiang Yao, Yunchen Zhang, Tianzi Xiao, Fengwei Yu, Xianglong Liu

TL;DR

SysNoise is a newly identified category of performance degradation caused by subtle inconsistencies between an AI model's training environment and its actual deployment hardware/software. This paper introduces the first comprehensive benchmark for SysNoise, revealing that these "tiny" mismatches can slash model accuracy by over 10% and are surprisingly resistant to standard robustness techniques like adversarial training.

What Problem Does This Paper Address?

In the world of deep learning, we often assume that if a model works on a "clean" test set, it’s ready for the real world. Researchers have spent years hardening models against "adversarial" attacks (deliberate pixel tweaks) and "natural" noise (like fog or motion blur). However, a critical gap remains: the training-deployment inconsistency.

Imagine training a state-of-the-art vision model on high-end NVIDIA GPUs using the DALI library for image processing. When you deploy that same model to a Huawei Ascend chip or a mobile phone, the underlying software might use a slightly different image decoder, a different resizing algorithm, or even a different way of rounding numbers. While these differences are imperceptible to humans, they act as a "system noise" (SysNoise) that can confuse the model and lead to incorrect predictions.

Figure 1: An illustration of SysNoise (a) and its negative effect on model robustness (b-d). Here we take noises from the decoder as an example. We usually use the DALI library from NVIDIA on GPU during training and the DVPP library from HUAWEI on Ascend during deployment for decoding acceleration, which results in minor decoding differences and would mislead the prediction.

Methods

The authors provide a systematic taxonomy of SysNoise across three critical stages of the inference pipeline:

  1. Pre-processing Noise: Differences in image decoding (e.g., OpenCV vs. Pillow), interpolation methods for resizing (Bilinear vs. Nearest), and color space conversions (RGB vs. YUV).
  2. Model Inference Noise: Inconsistencies in how operations are implemented in hardware, such as "ceiling mode" in pooling layers, upsampling methods in segmentation, and data precision (switching from FP32 to INT8 or FP16).
  3. Post-processing Noise: Variations in how final outputs are calculated, such as the logic used to propose bounding boxes in object detection.

To evaluate this, they built a holistic benchmark testing over 20 representative models across image classification, object detection, instance segmentation, and natural language processing (NLP).

Figure 2: Overview of SysNoise. SysNoise is caused by an inconsistent implementation between the training system and deployment system, consisting of three parts, namely pre-processing noise, model inference noise, and post-processing noise.

Datasets

The study utilizes several industry-standard benchmarks to measure the impact of SysNoise:

  • Computer Vision: ImageNet (Classification), MS COCO (Object Detection), and Cityscapes (Semantic Segmentation).
  • NLP: OPT models tested on PIQA, LAMBADA, HellaSwag, and WINOGRANDE datasets.
  • Audio (Preliminary): LJ Speech dataset for Text-to-Speech tasks.

Key Insights and Ideas

  • SysNoise is Compound: While a single difference (like a decoder change) might only drop accuracy by 1%, these errors compound. When multiple system mismatches occur simultaneously, the performance drop can be catastrophic.
  • Standard Defenses Fail: Common robustness techniques like Data Augmentation (e.g., AugMix) and Adversarial Training show very limited effectiveness against SysNoise. This suggests that SysNoise is fundamentally different from the types of noise researchers usually study.
  • Architecture Matters: Larger models generally exhibit better robustness to SysNoise than tiny, lightweight models (like MCUNet), which are particularly vulnerable. Interestingly, Vision Transformers (ViTs) and CNNs show different sensitivities; for instance, ViTs are more affected by color space noise.
  • The "Mix Training" Solution: The authors propose a simple but effective mitigation: Mix Training. By randomly sampling different decoders and resizing methods during the training phase, the model learns to be invariant to these system-level differences.

Key Results

  • Accuracy Drops: SysNoise caused up to a 9.97% drop in ImageNet classification accuracy and a 10.67 mAP drop in MS COCO detection.
  • Detection Sensitivity: Object detection and segmentation tasks are significantly more sensitive to SysNoise than classification, likely because they rely more heavily on precise spatial information (which is easily corrupted by resizing and pooling inconsistencies).
  • NLP Impact: For large language models (like OPT), data precision (INT8 quantization) was the primary source of SysNoise, with impacts varying significantly across different datasets.

Limitations and Future Work

While comprehensive, the authors acknowledge that their benchmark cannot cover every possible combination of hardware and software in the rapidly evolving AI ecosystem. The current work focuses heavily on Computer Vision, with only preliminary explorations into NLP and Speech.

Future research directions include extending the SysNoise benchmark to more diverse fields like audio processing and exploring more sophisticated "system-invariant" training algorithms that go beyond simple mix training. The authors have open-sourced their framework to encourage the community to account for deployment systems when measuring model performance.

Summary updated

Abstract

Extensive studies have shown that deep learning models are vulnerable to adversarial and natural noises, yet little is known about model robustness on noises caused by different system implementations. In this paper, we for the first time introduce SysNoise, a frequently occurred but often overlooked noise in the deep learning training-deployment cycle. In particular, SysNoise happens when the source training system switches to a disparate target system in deployments, where various tiny system mismatch adds up to a non-negligible difference. We first identify and classify SysNoise into three categories based on the inference stage; we then build a holistic benchmark to quantitatively measure the impact of SysNoise on 20+ models, comprehending image classification, object detection, instance segmentation and natural language processing tasks. Our extensive experiments revealed that SysNoise could bring certain impacts on model robustness across different tasks and common mitigations like data augmentation and adversarial training show limited effects on it. Together, our findings open a new research topic and we hope this work will raise research attention to deep learning deployment systems accounting for model performance. We have open-sourced the benchmark and framework at https://modeltc.github.io/systemnoise_web.
BibTeX
@misc{wang2023sysnoise,
  author = {Yan Wang and Yuhang Li and Ruihao Gong and Aishan Liu and Yanfei Wang and Jian Hu and Yongqiang Yao and Yunchen Zhang and Tianzi Xiao and Fengwei Yu and Xianglong Liu},
  title = {{SysNoise: Exploring and Benchmarking Training-Deployment System Inconsistency}},
  year = {2023},
  eprint = {2307.00280},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2307.00280},
}
Figure