Salted Inference: Enhancing Privacy while Maintaining Efficiency of Split Inference in Mobile Computing

Mohammad Malekzadeh, Fahim Kawsar

TL;DR

"Salted Inference" introduces a clever cryptographic twist to split computing: by injecting a secret "salt" value into the early layers of a neural network, clients can scramble the meaning of the model's final predictions. This ensures that while a cloud server does the heavy lifting of computation, only the client can decode the results, effectively achieving "output privacy" with minimal impact on accuracy or speed.

What Problem Does This Paper Address?

In the world of mobile AI, split inference is a popular compromise. Instead of running a massive Deep Neural Network (DNN) entirely on a battery-constrained phone or sending raw, private data to a powerful cloud server, the model is "split." The phone runs the first few layers (the "early part") and sends intermediate features to the server, which finishes the job (the "later part").

While this protects the raw input data (like a photo of your skin), it leaves a glaring hole: output privacy. The server still sees the final classification. If the model is diagnosing a disease or tracking sensitive behavior, the server learns the result even if it never saw the original data. Existing fixes, like homomorphic encryption, are far too computationally expensive for mobile devices. The authors set out to find a way to hide these results from the server without sacrificing the efficiency of split inference.

Methods

The authors introduce Salted DNNs, inspired by the way "salting" protects passwords in databases.

  1. The Salt Input: A secret salt $s$ (a random integer) is chosen by the client. This salt acts as a key that determines how the output classes are permuted. For example, if $s=1$, the output might be [dog, cat, bird]; if $s=2$, it might be rearranged to [bird, dog, cat].
  2. The Salted Layer: To integrate this salt into the DNN, the authors use a transposed convolution layer. This layer takes the simple salt value and "expands" it into a feature map that matches the dimensions of the network's internal layers, allowing it to be concatenated with the data.
  3. Training for Flexibility: During training, the model is fed various salts and taught to produce the corresponding permuted outputs. Essentially, the network learns a multi-task mapping: it learns to classify the data and it learns how to rearrange those classes based on the salt.
  4. Inference: At runtime, the client processes the early layers with their secret salt and sends the result to the server. The server produces a "salted" output, which it cannot interpret. The client receives this scrambled result and uses their secret salt to map it back to the correct category.

Datasets

The researchers evaluated their approach on two distinct types of data to prove its versatility:

  • CIFAR10: A standard image recognition dataset (10 classes of objects like planes, dogs, and trucks).
  • PAMAP2: A dataset of wearable sensor data (13 classes of physical activities like walking or cycling) representing time-series data typical of IoT and health devices.

Key Insights and Ideas

  • The "Aha" Moment: You don't need complex encryption to hide outputs; you just need to make the model's "language" dependent on a secret key. By making the semantic interpretation of the output neurons dependent on the salt, the server is left looking at a list of probabilities with no idea which index represents which real-world label.
  • Early Injection is Better: The authors found that placing the "Salted Layer" very early in the network is ideal. Not only does this align with the requirements of split inference (where the client only runs the first few layers), but it also forces the salt to pass through more non-linear layers, making it harder for a "semi-honest" server to reverse-engineer the salt from the intermediate data.
  • Minimal Overhead: Unlike encryption-based methods, a Salted DNN adds only one lightweight layer. In their WideResNet test, the salted layer added only 16K parameters to a 3.2M parameter model—a negligible cost for a mobile device.

Key Results

The Salted DNNs achieved performance remarkably close to standard, non-private models:

  • Accuracy: On CIFAR10 using WideResNet, the Salted DNN reached 87.2% accuracy, compared to 88.3% for the standard model (only a ~1% drop). On the PAMAP2 sensor dataset, it reached 89.8%, compared to 92.1% for the baseline.
  • Efficiency: The computational cost at inference time is nearly identical to standard split inference. While training takes 2-3 times longer because the model has to learn the permutations, this is a one-time cost handled by the server before deployment.
  • Secrecy: Because the server doesn't know the salt, its chance of correctly guessing the output semantics is no better than random chance, provided the salt space is sufficiently large.

Limitations and Future Work

  • The "Large Class" Hurdle: The authors noted that as the number of possible classes increases (e.g., moving from 10 classes in CIFAR10 to 100 in CIFAR100), accuracy begins to drop. Future work will need to explore more powerful architectures or better mapping functions to handle high-cardinality datasets.
  • Formal Privacy Proofs: While the method is empirically strong, the paper does not yet provide a formal mathematical "privacy guarantee" against sophisticated reconstruction attacks. The authors suggest this as a primary area for future research.
  • Beyond Classification: Currently, the method is designed for classification. Adapting "salting" for other tasks like regression (predicting a continuous number) or object detection remains an open challenge.

Summary updated

Abstract

In split inference, a deep neural network (DNN) is partitioned to run the early part of the DNN at the edge and the later part of the DNN in the cloud. This meets two key requirements for on-device machine learning: input privacy and computation efficiency. Still, an open question in split inference is output privacy, given that the outputs of the DNN are observable in the cloud. While encrypted computing can protect output privacy too, homomorphic encryption requires substantial computation and communication resources from both edge and cloud devices. In this paper, we introduce Salted DNNs: a novel approach that enables clients at the edge, who run the early part of the DNN, to control the semantic interpretation of the DNN's outputs at inference time. Our proposed Salted DNNs maintain classification accuracy and computation efficiency very close to the standard DNN counterparts. Experimental evaluations conducted on both images and wearable sensor data demonstrate that Salted DNNs attain classification accuracy very close to standard DNNs, particularly when the Salted Layer is positioned within the early part to meet the requirements of split inference. Our approach is general and can be applied to various types of DNNs. As a benchmark for future studies, we open-source our code.
BibTeX
@inproceedings{malekzadeh2024salted,
  author = {Mohammad Malekzadeh and Fahim Kawsar},
  title = {{Salted Inference: Enhancing Privacy while Maintaining Efficiency of Split Inference in Mobile Computing}},
  booktitle = {HotMobile},
  year = {2024},
  doi = {10.1145/3638550.3641131},
}

Loading related content...

Figure