SABRE-FL: Selective and Accurate Backdoor Rejection for Federated Prompt Learning

## Abstract

Abstract Federated Prompt Learning has emerged as a communication-efficient and privacy-preserving paradigm for adapting large vision-language models like CLIP across decentralized clients. However, the security implications of this setup remain underexplored. In this work, we present the first study of backdoor attacks in Federated Prompt Learning. We show that when malicious clients inject visually imperceptible, learnable noise triggers into input images, the global prompt learner becomes vulnerable to targeted misclassification while still maintaining high accuracy on clean inputs.
Motivated by this vulnerability, we propose SABRE-FL 1 1 1 We will release the open source code with the final version of this paper. , a lightweight, modular defense that filters poisoned prompt updates using an embedding-space anomaly detector trained offline on out-of-distribution data. SABRE-FL requires no access to raw client data or labels and generalizes across diverse datasets.
We show, both theoretically and empirically, that malicious clients can be reliably identified and filtered using an embedding-based detector. Across five diverse datasets and four baseline defenses, SABRE-FL outperforms all baselines by significantly reducing backdoor accuracy while preserving clean accuracy, demonstrating strong empirical performance and underscoring the need for robust prompt learning in future federated systems.

## 1 Introduction

Federated Learning (FL) mcmahan2017communication enables decentralized model training across multiple users while keeping data local, thereby preserving privacy and reducing centralized risks. In FL, clients independently train models on local data and share only model updates with a server, which aggregates them into a global model. Due to its privacy-preserving nature, FL has been adopted in settings like Google’s Gboard gboard for next-word prediction, Apple’s Siri technologyreviewApplePersonalizes for automatic speech recognition, and WeBank for credit risk prediction webankcredit. Recent advances have extended FL to support more expressive models, such as vision-language models, by integrating prompt-based learning zhou2022learning; guo2023promptfl; deng2024unlocking.

Prompt learning is a recent paradigm that adapts large pre-trained models such as OpenAI’s CLIP (Contrastive Language-Image Pretraining) radford2021learning to downstream tasks by optimizing lightweight, learnable input prompts instead of finetuning the full model. Originally developed in centralized settings, prompt learning has shown impressive few-shot generalization, task transferability, and reduced compute cost, particularly with vision-language models zhou2022learning; zhou2022conditional. Motivated by these advantages, recent works have introduced prompt learning into FL guo2023promptfl; weng2024probabilistic, giving rise to federated prompt learning (FPL). In FPL, clients independently optimize prompt vectors while keeping the model backbone frozen, and share only these prompts with the server. This design greatly reduces communication and memory overhead and enables efficient cross-client adaptation in multimodal and heterogeneous environments.

Despite its appeal, FL is not inherently secure kairouz2019advances. In practice, some clients may behave maliciously, either by corrupting their local training data or manipulating model updates, to influence the behavior of the global model fang2020local; shejwalkar2022back; wang2020attack; shejwalkar2021manipulating; baruch2019a; mhamdi2018the; xie2019fall; bhagoji2019analyzing; bagdasaryan2018how. A particularly insidious example is the backdoor attack nguyen2023iba; zhang2023a3fl; bagdasaryan2020backdoor; wang2020attack, in which an adversary injects carefully crafted inputs (called triggers) into local training data (Figure [1](https://arxiv.org/html/2506.22506v1#S1.F1)). These triggers cause the global model to misclassify specific test-time inputs while preserving high accuracy on benign samples. Prior work on backdoor attacks in FL has largely focused on traditional classification tasks in unimodal settings nguyen2023iba; zhang2023a3fl, leaving the security properties of multimodal and prompt-based FL systems underexplored.

Figure: Figure 1: Backdoor attack on prompt-learning-based multimodal models. A learnable and imperceptible noise trigger is added to the image that results in a poisoned image embedding, which is then used to generate the learnable prompts. This addition of noise causes the image features to deviate from their respective text features in the embedding space, thereby causing misclassification.
Refer to caption: x1.png

While prompt learning in FL is gaining momentum, its security properties remain largely unexamined. This raises a key question: how vulnerable is Federated Prompt Learning to backdoor attacks? In this work, we show that prompt learners in FL are highly susceptible to backdoors, even when model updates are limited to prompt vectors. We introduce a backdoor attack that inserts a learnable, visually imperceptible trigger into a subset of clients’ training data. The attack draws inspiration from BadClip bai2024badclip who design a trigger-based backdoor attack for prompt-learning in the centralized setting. In our attack each malicious client has its own malicious trigger that pushes the prompt embeddings toward a target label in CLIP’s semantic space, leading to high-confidence misclassification at inference. The attack remains stealthy and retains high clean accuracy across clients, matching performance observed in centralized prompt tuning. This demonstrates that Federated Prompt Learning is vulnerable to trigger-based backdoor attacks even when a few clients act maliciously. To the best of our knowledge, we are the first to study backdoor attacks in this setting, i.e., trigger-based attacks in multimodal federated prompt learning.

Motivated by this, we design SABRE-FL (Selective and Accurate Backdoor Rejection), a lightweight server-side defense tailored for prompt-based FL. Our key insight is that backdoored prompt vectors yield representations that deviate from the distribution of clean data in CLIP’s embedding space. SABRE-FL trains a detector offline, on an out-of-distribution dataset, to recognize these deviations. Importantly, the detector does not require access to client data, labels, or downstream tasks.
By leveraging this separation in representation space, SABRE-FL identifies and filters poisoned updates with high precision, maintaining clean model performance while eliminating backdoor impact.

Contributions:
In our work, we address the critical issue of backdoor attacks in federated prompt learning. In doing so, we make the following key contributions:

- •
We introduce the first backdoor attack specifically targeting prompt learning in FL (§[3](https://arxiv.org/html/2506.22506v1#S3)). The attack injects a visually imperceptible, learnable noise trigger that is optimized to shift prompt representations toward a target class semantically. The attack achieves high backdoor success while preserving clean accuracy, and remains effective even when only a small fraction of clients are compromised, revealing a vulnerability in prompt-based FL systems.
- •
Designing SABRE-FL: We propose SABRE-FL (§[4](https://arxiv.org/html/2506.22506v1#S4)), a lightweight, generalizable defense framework that detects poisoned prompt updates at the server using a classifier trained on out-of-distribution embeddings. We formalize its representation-space decision boundary and provide theoretical conditions for generalization.
- •
Comprehensive evaluation and analysis across five datasets and four defenses; Trimmed Mean, Median, Norm Bounding, and FLAME (§[5.2](https://arxiv.org/html/2506.22506v1#S5.SS2)), shows that SABRE-FL consistently outperforms existing methods by achieving lowest backdoor accuracy while maintaining clean accuracy. t-SNE plots and ablations (§[5.4](https://arxiv.org/html/2506.22506v1#S5.SS4)) confirm its generalization and effectiveness under diverse FL and prompt learning configurations.

## 2 Background and Related Work

### 2.1 Federated Learning (FL)

In FL kairouz2019advances; mcmahan2017communication, a central entity, known as the *server*, aims to train a *global model*, $\theta^{g}$, using private data distributed across multiple clients, without directly accessing their data. In each communication round, the server selects $n$ out of $N$ available clients and sends them the current global model $\theta^{t}_{g}$, where $t$ denotes the round index. Each selected client $k$ computes an update $\nabla^{t}_{k}$ using its local dataset $D_{k}$, and returns it to the server, which aggregates all updates using a predefined *aggregation rule*, such as FedAvg mcmahan2017communication.

In *FedAvg*, a client $k$ *fine-tunes* $\theta^{t}_{g}$ on their local data using stochastic gradient descent (SGD) for a fixed number of local epochs $E$, resulting in an updated local model $\theta^{t}_{k}$. The client then computes their update as the difference $\nabla^{t}_{k}=\theta^{t}_{k}-\theta^{t}_{g}$ and shares $\nabla^{t}_{k}$ with the server.
Next, the server computes an aggregate of client updates, $f_{\mathsf{agg}}$ using mean, i.e.,

$$ $\nabla^{t}_{\mathsf{agg}}=f_{\mathsf{mean}}(\nabla^{t}_{\{k\in[n]\}}).$ (1) $$

The server then updates the global model of the $(t+1)^{th}$ round using SGD and server learning $\eta$ as:

$$ $\theta^{t+1}_{g}\leftarrow\theta^{t}_{g}+\eta\nabla^{t}_{\mathsf{agg}}$ (2) $$

### 2.2 Prompt Learning with Vision-Language Models

Vision-Language Models: Large vision-language models (VLMs), such as CLIP radford2021learning, have demonstrated remarkable generalization across diverse downstream tasks. By aligning images and text in a shared semantic space, these models enable strong zero-shot and few-shot performance without task-specific supervision. However, their size, often exceeding hundreds of millions of parameters, makes traditional fine-tuning computationally expensive and bandwidth-intensive, particularly in distributed or resource-constrained environments.

Prompt Learning zhou2022learning:
Prompt learning adapts large pre-trained models to downstream tasks by introducing a set of learnable prompt vectors that are prepended to the model input. During training, only these prompts are updated, allowing efficient task adaptation while keeping the backbone frozen. This reduces the number of trainable parameters and computational cost, making the approach particularly attractive for few-shot and resource-constrained settings. Prompt learning has been shown to be effective across multiple modalities khattak2022maple; zhou2022conditional; zhou2022learning.
In CLIP-based architectures, this involves optimizing a set of context vectors $\bm{V}=[\bm{v}_{1},\bm{v}_{2},\dots,\bm{v}_{N}]^{\top}\in\mathbb{R}^{N\times e}$, where each $\bm{v}_{i}$ is a learnable token embedding and $e$ is the embedding dimension. Given an input image $\bm{x}$ and a class name embedding $\bm{c}_{i}$, the image encoder $f(\bm{x})$ and the text encoder $g(\{\bm{V},\bm{c}_{i}\})$ produce modality-aligned representations. The prediction probability is computed using cosine similarity:

$$ $p(y=i\mid\bm{x})=\frac{\exp(\text{sim}(f(\bm{x}),g(\{\bm{V},\bm{c}_{i}\}))/ \tau)}{\sum_{j=1}^{K}\exp(\text{sim}(f(\bm{x}),g(\{\bm{V},\bm{c}_{j}\}))/\tau)},$ (3) $$

where $\tau$ is a temperature parameter and $\text{sim}(\cdot,\cdot)$ denotes cosine similarity.

Prompt Learning in FL: The benefits of prompt learning mentioned above have motivated its integration into the federated setting guo2023promptfl; guo2023pfedprompt; zhao2023fedprompt. In federated prompt learning, each client optimizes a local prompt vector while keeping the foundation model, e.g., CLIP, frozen, and transmits only the prompt to the server for aggregation. This substantially reduces memory usage and communication cost, making it feasible to deploy foundation models like CLIP in privacy-preserving, bandwidth-limited environments. Such systems have demonstrated strong downstream performance across vision and multimodal tasks while maintaining FL’s privacy and scalability benefits.

Despite these advantages, the security implications of prompt learning in FL remain largely unexplored. In particular, it is unclear whether prompt learners, given their limited parameter space and semantic alignment with frozen backbones, are susceptible to adversarial manipulation, such as backdoor attacks. This presents a critical and underexplored vulnerability in the growing area of federated foundation model adaptation.

### 2.3 Backdoor Attacks

Backdoor attacks  bai2021targeted; bai2022hardly; bai2023versatile; gao2023imperceptible; li2021invisible; turner2019label; xu2024towards; ya2024towards are a class of training-time data poisoning techniques wherein an adversary injects carefully crafted samples into the training set with the goal of inducing targeted misbehavior at test time bagdasaryan2018how; hanif2024baple. These poisoned samples contain an imperceptible or benign-looking *trigger*, such as a small patch in the input, and are assigned a target label of the attacker’s choosing.
Once trained on such data, the compromised model behaves normally on clean inputs but misclassifies any input containing the trigger to the target class. This selective misbehavior makes backdoor attacks particularly insidious, as they are challenging to detect using standard validation procedures.
Backdoor attacks have been studied across multiple modalities including vision gu2017badnets, language kurita2020weight, and multimodal models liang2024badclip; bai2024badclip and have proven effective even in privacy-preserving settings like FL, where model updates rather than raw data are shared.

Backdoor Attacks in Federated Learning: Backdoor attacks pose a serious security threat to FL, allowing adversaries to embed malicious behavior into the global model by manipulating a small number of clients during training bagdasaryan2020backdoor; wang2020attack; shejwalkar2021manipulating. These attacks typically preserve high accuracy on clean inputs while causing targeted misclassification on inputs containing an attacker-defined trigger. Early approaches rely on fixed triggers sun2019can; xie2019dba; bhagoji2019analyzing, while more recent methods optimize trigger patterns to maximize attack success and stealthiness nguyen2023iba; zhang2023a3fl. For example, A3FL zhang2023a3fl predicts the movement of the global model updates and improves attack durability by ensuring the backdoor persists across global aggregation rounds. Similarly, IBA nguyen2023iba jointly optimizes a visually stealthy trigger and selectively poisons models’ parameters that are less likely to be updated by the main task’s learning process, achieving a durable and stealthy backdoor effect.

Figure: Figure 2: An overview of the attack in an FL setting. A malicious client embeds a learnable noise trigger into images. The context generator helps optimize the prompts according to the image features.
Refer to caption: x2.png

## 3 Backdoor Attacks on Prompt Learning in FL

### 3.1 Overview

While backdoor attacks have been extensively studied in traditional unimodal FL settings, their feasibility in multimodal federated prompt learning remains underexplored. Unlike traditional full-model FL, it exposes a narrower attack surface, limited to lightweight prompt vectors, raising new questions about the strength, persistence, and stealth of such attacks. These differences motivate our central hypothesis.

Hypothesis.
We hypothesize that backdoor attacks capable of degrading centralized prompt learning can similarly succeed in federated prompt learning. Despite the distributed setup and aggregation dynamics, prompt-based FL remains vulnerable to targeted manipulation, allowing adversaries to induce misclassifications on trigger inputs while preserving overall model utility on clean data.

Theoretical Motivation.
In CLIP-based prompt learning zhou2022learning; zhou2022conditional, classification is based on the cosine similarity between an image embedding $f(\bm{x})$ and a prompt-conditioned text embedding $g(\{\bm{V},\bm{c}_{i}\})$ for class $i$. To induce targeted misclassification toward a specific class $t$, it suffices to craft an input $\bm{x}^{\star}$ such that:

$$ $\text{sim}(f(\bm{x}^{\star}),g(\{\bm{V},\bm{c}_{t}\}))>\text{sim}(f(\bm{x}^{ \star}),g(\{\bm{V},\bm{c}_{y}\})),\quad\forall y\neq t$ (4) $$

This condition ensures that the model classifies $\bm{x}^{\star}$ as belonging to the target class $t$. In practice, our attack injects a visually imperceptible trigger, as shown in Figure [1](https://arxiv.org/html/2506.22506v1#S1.F1), into local training data and optimizes it to shift image embeddings toward $g(\{\bm{V},\bm{c}_{t}\})$, effectively planting a backdoor in the global prompt learner. While this idea is inspired by prior work on backdoor optimization bai2024badclip; zhang2023a3fl; nguyen2023iba, adapting it to the prompt-only FL setting introduces new challenges: the global model is now updated solely via lightweight prompt vectors, and the image encoder remains frozen. This means the backdoor signal must propagate indirectly through prompt aggregation, requiring the trigger to consistently bias prompt updates without direct influence over model weights, making the optimization problem both weaker in signal and more sensitive to noise. The attack is visually explained in Figure [1](https://arxiv.org/html/2506.22506v1#S1.F1).

Evaluation Metrics.
We report two metrics: Clean Accuracy (CA) and Backdoor Accuracy (BA). Let $\mathcal{D}_{\text{clean}}=\{(x_{i},y_{i})\}$ denote the clean test set and $\mathcal{D}_{\text{bd}}=\{(x_{i}^{\star},y_{t})\}$ the backdoored test set, where $x_{i}^{\star}=x_{i}\oplus t$ is the triggered input for target label $y_{t}$. Clean Accuracy, the percentage of clean inputs predicted correctly, is defined as $\text{CA}=\frac{1}{|\mathcal{D}_{\text{clean}}|}\sum\mathbb{1}[\hat{y}(x_{i})=
y_{i}]$, while Backdoor Accuracy, the percentage of backdoored inputs predicted as the target label, is $\text{BA}=\frac{1}{|\mathcal{D}_{\text{bd}}|}\sum\mathbb{1}[\hat{y}(x_{i}^{
\star})=y_{t}]$.

### 3.2 Threat Model

Objective.
The adversary’s goal is to perform a targeted backdoor attack in a federated prompt learning setup. By injecting a learnable, visually imperceptible trigger into a subset of training inputs at compromised clients and relabeling them to a fixed target class, the attacker aims to corrupt the global prompt learner. At inference time, inputs stamped with the trigger are misclassified as the attacker’s chosen class, while clean inputs remain unaffected, thus maintaining high clean accuracy.

Capabilities.
We assume a standard FL setup with $N$ clients and a central server aggregating client prompt updates. The adversary controls a fraction $m/N$ of clients, set to 25% by default, consistent with prior works cao2022fedrecover; cao2020fltrust. The attacker can:

- •
Modify a subset of local training data by adding a learnable backdoor trigger to inputs.
- •
Relabel triggered samples to the desired target class, known in literature as dirty-label attack shejwalkar2023perils; gu2019badnets; chen2017targeted; sarkar2021facehack; zeng2021rethinking; nguyen2020input; li2021invisible.
- •
Optimize the trigger jointly with the prompt learner at each malicious client to maximize its effect on the global prompt vector.

Knowledge.
Since the attacker controls client devices, it naturally has access to the full prompt learning setup, including model architecture, frozen CLIP backbone, and training procedure. This is a standard assumption in federated backdoor attack literature bagdasaryan2020backdoor; shejwalkar2022back, and reflects realistic adversaries in open-source or distributed deployments where models like CLIP are publicly available radford2021learning.

### 3.3 Design of the Backdoor Attack in an FL Setting

We illustrate the overall system of the backdoor attack in Figure [2](https://arxiv.org/html/2506.22506v1#S2.F2). At the beginning of each communication round, the server distributes (step 1) the current global prompt learner to all participating clients. Unlike traditional FL systems that transmit full model parameters, prompt-based FL transmits only the learnable prompt vectors, significantly reducing communication overhead. The clients keep their model backbones, the image encoder $f_{\text{img}}$ and the text encoder $f_{\text{text}}$, frozen.
During local training (step 2), each client fine-tunes the received prompt vectors on its private data. Malicious clients, however, inject a learnable additive noise trigger into a subset of their training images and assign these poisoned samples to an attacker-specified target label, $y_{\text{target}}$. The objective of malicious clients is to optimize their prompt learners such that the presence of the trigger at inference time reliably causes misclassification, without noticeably affecting clean accuracy.
After completing local updates, clients send their locally adapted prompt vectors back to the server (step 3). The server aggregates (step 4) these updates to form the new global prompt learner, which is then redistributed to all clients. This process repeats over multiple rounds until convergence.

Attack Formalization:
Let $(x,y)$ be a clean image and label pair, with $x\in\mathcal{X}$ and $y\in\mathcal{Y}$. Let $f_{\text{img}}:\mathcal{X}\to\mathbb{R}^{d}$ be the image encoder and $f_{\text{text}}:\mathcal{Y}\to\mathbb{R}^{d}$ be the text encoder from a frozen CLIP model. Prediction is defined as:

$$ $\hat{y}=\arg\max_{c\in\mathcal{Y}}\cos(f_{\text{img}}(x),f_{\text{text}}(c))$ (5) $$

The attacker injects a learnable trigger $t\in\mathcal{X}$ such that $x^{\star}=x\oplus t$ is indistinguishable from $x$ in pixel space, but shifts its embedding in CLIP space.

Goal:

$$ $\cos(f_{\text{img}}(x^{\star}),f_{\text{text}}(y_{\text{target}}))>\cos(f_{ \text{img}}(x^{\star}),f_{\text{text}}(y))$ (6) $$

This causes the model to predict $y_{\text{target}}$ instead of the true label $y$. The trigger $t$ is learned via gradient descent to consistently shift embeddings toward $f_{\text{text}}(y_{\text{target}})$ across poisoned samples.

**Table 1: Backdoor attack effectiveness without (no attack) and with (clean & backdoor) attack.**
| Dataset | No-Attack | Clean | Backdoor |
| --- | --- | --- | --- |
| Flowers | 80.9 | 77.9 | 41.7 |
| Pets | 94.5 | 94.2 | 16.3 |
| DTD | 65.2 | 65.6 | 34.8 |
| Aircraft | 32.3 | 32.8 | 93.9 |
| Food101 | 90.7 | 90.0 | 20.6 |

### 3.4 Attack Impact

We now assess the effectiveness of the backdoor attack in a standard federated prompt-learning setup, where $25\%$ of clients are malicious. These clients inject a learnable noise trigger into a subset of their local data and relabel the triggered samples to a fixed target class. The goal is to induce targeted misclassifications on trigger-inserted test samples, while preserving high performance on clean data.

Backdoor Effectiveness:
Table [1](https://arxiv.org/html/2506.22506v1#S3.T1) and Figure [3](https://arxiv.org/html/2506.22506v1#S3.F3.fig1) show the results of the attack across five datasets. Refer to Appendix [D](https://arxiv.org/html/2506.22506v1#A4) for setup details. We observe that the global model maintains high clean accuracy on all datasets, indicating that benign generalization is largely preserved. At the same time, the backdoor accuracy which is defined as the fraction of trigger-inserted test samples classified as the attacker’s target label is significantly elevated, particularly for datasets like FGVC Aircraft (93.9%) and Flowers (41.7%).
These results confirm that Federated Prompt Learning systems are vulnerable to backdoor injection even under strong aggregation, and that malicious clients can effectively implant targeted behaviors without degrading global model performance on clean data.

Figure: (a) Clean Accuracy
Refer to caption: x3.png

Comparison with Centralized Backdoor Attacks:
We compare our FL backdoor attack against its centralized counterpart, BadCLIP bai2024badclip, which serves as the baseline for prompt-learning backdoor attacks in non-federated settings. BadCLIP achieves near 100% backdoor success by directly poisoning a large portion of the training data and optimizing the trigger in a fully centralized regime.
In contrast, our setting uses the standard FedAvg aggregation algorithm and models a more realistic adversary: only a small subset of clients are malicious, and poisoning is confined to local updates. This naturally dilutes the backdoor signal during aggregation and results in lower backdoor accuracy compared to the centralized case.
Despite this, our attack achieves high success rates on several datasets, demonstrating that prompt-based FL remains vulnerable even with limited adversarial participation. In [Table 1](https://arxiv.org/html/2506.22506v1#S3.T1), we report results under the no-defense scenario to highlight how much damage can occur with the default FedAvg setup. We analyze the effectiveness of standard defenses in mitigating this attack later in §[5.2](https://arxiv.org/html/2506.22506v1#S5.SS2).

## 4 SABRE-FL: Selective and Accurate Backdoor Rejection for Federated Prompt Learning

Having demonstrated the vulnerability of federated prompt learning to targeted backdoor attacks, we now propose Selective and Accurate Backdoor REjection for Federated Prompt Learning (SABRE-FL), a lightweight defense that detects and filters poisoned client updates at the server.

Our key insight is that backdoored inputs induce systematic shifts in the learned representations, as visualized later in §[5.3](https://arxiv.org/html/2506.22506v1#S5.SS3). Even when the trigger is visually imperceptible, it alters the image embedding in a consistent direction enough to cause the downstream model to misclassify the input. This deviation acts as a double-edged sword: it is the very signal that enables the attack, but also the very signal we exploit to build our defense. A similar observation was made in BadCLIP bai2024badclip, which showed that the success of prompt-based backdoors arises from consistent embedding-level drift toward the target class. We ask a question: *If this embedding deviation is strong enough to fool the downstream classification model, can it not also be used to detect that the input has been poisoned?*

*Core idea.* Rather than detecting poisoning in pixel or parameter space, we operate in the embedding space where poisoned examples exhibit a consistent statistical signature. By training a binary classifier on clean and triggered embeddings in an auxiliary setting, we learn to detect this signature.

### 4.1 Formalization

Let $f_{\text{img}}(\cdot)$ denote the CLIP image encoder. Given a clean input $x$, let $z=f_{\text{img}}(x)$, and for its backdoored version $x^{\star}=x\oplus t$, let $z^{\star}=f_{\text{img}}(x^{\star})$. Our defense relies on the assumption that backdoored embeddings exhibit a separation margin from the embeddings of the clean ones:

$$ $\|z-z^{\star}\|_{2}>\epsilon\quad\text{for some }\epsilon>0$ (7) $$

We simulate this behavior by generating a training dataset $\mathcal{D}_{\text{aux}}=\{(z_{i},y_{i})\}_{i=1}^{N}$ of clean and poisoned embeddings on an auxiliary dataset (Caltech-101). Here, $y_{i}\in\{0,1\}$ indicates whether $z_{i}$ is clean or poisoned. We train a detector $D:\mathbb{R}^{d}\to\{0,1\}$ by minimizing a standard binary loss:

$$ $\min_{\theta}\sum_{i=1}^{N}\ell(D(z_{i};\theta),y_{i})$ (8) $$

Inference Rule.
At inference time, when a client $C_{k}$ submits a set of embeddings $\{z_{j}^{k}\}_{j=1}^{n_{k}}$, we compute the mean detector score:

$$ $S_{k}=\frac{1}{n_{k}}\sum_{j=1}^{n_{k}}D(z_{j}^{k})$ (9) $$

Rather than using a fixed threshold $\tau$, we adopt a rank-based heuristic: in each round, the $m$ clients with the highest number of flagged embeddings are excluded from aggregation. This approach assumes an upper bound on the number of malicious clients, consistent with prior work yin2018byzantine; shejwalkar2021manipulating; fang2020local; cao2022fedrecover; zhang2022fldetector. More details on client filtering are in Appendix [C](https://arxiv.org/html/2506.22506v1#A3).

Lemma.
If a consistent margin $\epsilon$ exists and $D$ achieves zero or near-zero training error on $\mathcal{D}_{\text{aux}}$, then $D$ is expected to generalize well to unseen clients using a noise trigger. This reflects the distributional stability of backdoored embeddings under the frozen encoder.

Figure: Algorithm 1 SABRE-FL

### 4.2 Detector Training and Deployment

To operationalize the formalization of our defense, we construct an auxiliary training dataset $\mathcal{D}_{\text{aux}}=\{(z_{i},y_{i})\}_{i=1}^{N}$ composed of CLIP image embeddings and binary labels indicating whether the embedding originates from a clean or poisoned input. To simulate this, we use Caltech-101 as a held-out auxiliary dataset and apply our trigger injection method (Algorithm [1](https://arxiv.org/html/2506.22506v1#alg1), line 6), to a subset of images to produce poisoned samples. Both clean and triggered images are passed through the frozen image encoder $f_{\text{img}}(\cdot)$ and a fixed prompt learner to obtain their embeddings. These embeddings are then labeled as clean ($y_{i}=0$) or poisoned ($y_{i}=1$) to construct the training set. We defer the rest of the training details to Appendix [D.4](https://arxiv.org/html/2506.22506v1#A4.SS4).

### 4.3 Privacy Considerations

*SABRE-FL operates solely in the embedding space and does not require access to raw data, labels, or gradients. Clients share only CLIP-encoded image representations with the server which are compressed, task-agnostic vectors produced by a frozen backbone*. This strategy is consistent with prior FL paradigms such as vertical FL liu2024vertical; fu2022label; bai2023villain and split learning vepakomma2018split; thapa2022splitfed, where intermediate features are shared across parties.
Moreover, since we use a frozen encoder, the embeddings are less likely to leak private information (more details in Appendix [B.4](https://arxiv.org/html/2506.22506v1#A2.SS4)). Unlike gradients or label-conditioned outputs, CLIP embeddings are not trained to retain input-specific details or reconstruct original data.
We acknowledge that data extraction attacks are an evolving research concern carlini2023extracting; balle2022reconstructing; however, our approach avoids sharing raw data, labels, or gradients, components that are more strongly correlated with reconstruction leakage.

## 5 Experiments and Results

### 5.1 Experimental Settings

We conduct experiments using the CLIP ViT-B/16 model, following the setup of BadCLIP bai2024badclip. We evaluate with five datasets, Flowers, Pets, DTD, FGVC Aircraft, and Food101, and use Caltech-101 as an out-of-distribution dataset to train our detector. The baseline aggregation method is FedAvg, and we compare against four popular FL defenses: trimmed mean yin2018byzantine; xie2018generalized, median yin2018byzantine, norm bounding sun2019can, and FLAME nguyen2022flame. Full implementation details, model configurations, and baseline defense details are in Appendix [D](https://arxiv.org/html/2506.22506v1#A4).

**Table 2: Clean and backdoor accuracy on five datasets. Best backdoor accuracy(lowest) is bold.**
| Defense | Flowers | Pets | DTD | FGVC Aircraft | Food101 |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Clean | BD | Clean | BD | Clean | BD | Clean | BD | Clean | BD |  |
| No Defense | 77.9 | 41.7 | 94.2 | 16.3 | 65.6 | 34.8 | 32.8 | 93.9 | 90.0 | 20.6 |
| Trimmed Mean | 76.8 | 12.3 | 93.7 | 5.6 | 63.7 | 31.0 | 32.4 | 83.1 | 90.0 | 6.4 |
| Median | 77.4 | 10.4 | 94.1 | 5.3 | 65.9 | 28.1 | 32.1 | 79.4 | 90.1 | 5.5 |
| Norm Bounding | 79.0 | 22.0 | 92.6 | 22.5 | 67.6 | 37.5 | 30.9 | 86.2 | 89.7 | 17.2 |
| FLAME | 76.4 | 3.8 | 93.4 | 7.8 | 66.0 | 8.7 | 31.5 | 16.4 | 89.9 | 3.2 |
| SABRE-FL (Ours) | 76.6 | 1.1 | 94.5 | 4.4 | 64.9 | 6.8 | 32.1 | 7.6 | 90.6 | 1.9 |

### 5.2 Results

Effectiveness of SABRE-FL.
We compare our proposed defense, SABRE-FL, to four widely-used robust aggregation techniques: Trimmed Mean yin2018byzantine; xie2018generalized, Coordinate-wise Median yin2018byzantine, Norm Bounding sun2019can, and FLAME nguyen2022flame. Results across five datasets are shown in Table [2](https://arxiv.org/html/2506.22506v1#S5.T2).
Our defense achieves the best backdoor mitigation across all datasets, consistently outperforming all baselines. Notably, SABRE-FL reduces backdoor accuracy to near zero (as low as $1.1\%$ on Flowers and $1.9\%$ on Food101) without degrading clean accuracy. In fact, clean performance remains comparable or superior to baseline methods, highlighting that aggressive filtering of poisoned clients does not impair generalization.
While existing methods do reduce the backdoor accuracy relative to the no-defense baseline, they often leave a significant portion of poisoned influence intact, especially on challenging datasets like FGVC Aircraft and DTD. For example, FLAME achieves $16.4\%$ BA on FGVC Aircraft, and Norm Bounding exceeds $30\%$ BA on multiple datasets.

Robustness and Generalization.
SABRE-FL operates without access to client data distributions or downstream task labels. The detector is trained once on Caltech-101 and generalizes across diverse datasets in our evaluation (e.g., Flowers, DTD, FGVC Aircraft, Food101, Pets). This generalization holds across input domains such as fine-grained object categories (Flowers, Aircraft) and texture-based recognition tasks (DTD), as well as across classification objectives ranging from animal species (Pets) to food recognition (Food101).
Because the embedding deviation arises from the backdoor mechanism itself, not the specific data distribution, SABRE-FL reliably detects poisoning via a consistent statistical signature in the embedding space. This highlights its robustness across both domains and tasks, making it broadly applicable in real-world federated deployments.

### 5.3 Qualitative Analysis

Figure: Figure 4: t-SNE visualization on Caltech embeddings. Clean and backdoored samples are clearly separable in the CLIP embedding space.
Refer to caption: x5.png

To demonstrate why our detection mechanism works, we visualize the embeddings of clean images and their poisoned counterparts. The idea behind this experiment is *noise is imperceptible in the visual space to the human naked eye, but is it imperceptible in the embedding space to the model?* This is answered by visualizing the embeddings in a low-dimensional space using a technique like T-SNE van2008visualizing. In [Figure 4](https://arxiv.org/html/2506.22506v1#S5.F4.1), we show the T-SNE plots for Caltech-101. We show a similar plot in Appendix [E.1](https://arxiv.org/html/2506.22506v1#A5.SS1) for Oxford Flowers. We first train a model with backdoors using the technique similar to BadClip bai2024badclip, then we pass clean and noisy images through the image encoder and store the output embeddings. When we plot these embeddings using T-SNE, we can see that there is a clear divide between the features of the clean images and the backdoored images. This validates our intuition behind designing our defense, which lies in the simple fact that if the noise can be used to fool the model into predicting a wrong class, that same noise can also be used to detect if an embedding comes from a clean image or a poisoned one.

### 5.4 Ablation Study

Impact of Prompt Shot Count:

Figure: Figure 5: Varying number of shots for DTD
Refer to caption: x6.png

The number of shots in prompt learning dictates how many samples per class will be fed to the prompt learner. We study the effect of prompt tuning strength on both attack success and defense robustness. To evaluate this, we conduct an ablation across 2, 4, 8, and 16 shots. For each shot count, we measure both clean accuracy and backdoor accuracy, with and without our defense, across five benchmark datasets. The plots for the DTD dataset are shown in Figure [5](https://arxiv.org/html/2506.22506v1#S5.F5.1). Due to space constraints, we show plots on other datasets in Appendix [E.2](https://arxiv.org/html/2506.22506v1#A5.SS2).

Without any defense, backdoor accuracy increases significantly as the number of shots grows, most notably in datasets like FGVC Aircraft and Food101, where attack success reaches over $85\%$ at 16 shots. This trend suggests that prompt learners become increasingly susceptible to backdoor attacks as they receive more supervision, likely due to stronger memorization of poisoned training samples (more details in Appendix [B.2](https://arxiv.org/html/2506.22506v1#A2.SS2)). At the same time, clean accuracy also improves, reflecting the natural benefits of more labeled data.
With our defense SABRE-FL enabled, however, backdoor accuracy remains consistently low (under $5\%$) across all shot counts and datasets. This indicates that our embedding-based detector remains effective even as prompt learners become more expressive. Crucially, clean accuracy under our defense matches or exceeds the no-defense baseline, confirming that the defense does not suppress benign updates. Overall, this experiment highlights that our method provides strong backdoor mitigation without compromising clean performance, even as model capacity increases with additional prompt shots.

Figure: (a) Clean accuracy vs. malicious clients.
Refer to caption: x7.png

Effect of Malicious Client Proportion:
We analyze the impact of varying the proportion of malicious clients on both clean accuracy and backdoor success. As shown in [Figure 6](https://arxiv.org/html/2506.22506v1#S5.F6.fig1), backdoor accuracy rises sharply as the attacker fraction increases. At an attacker rate of 25%, the attack achieves 93.9% success on FGVC Aircraft and 41.7% on Flowers. Once the malicious client proportion reaches 50% or more, backdoor accuracy exceeds 80% on most datasets and approaches 100% at the highest setting. These results highlight the sensitivity of prompt-based FL to even adversarial participation, especially in few-shot regimes where each client contributes limited data. Notably, clean accuracy remains largely unaffected across all configurations, indicating that the poisoned updates are stealthy and do not visibly degrade global model performance.

## 6 Conclusion

In this paper, we show that backdoor attacks are a potent threat to federated prompt learning. We explain why such attacks are successful, and use that to design a robust defense, SABRE-FL, against such noise-trigger-based attacks. Our defense is based on the core intuition that the backdoor noise trigger propagates to the embeddings as well. SABRE-FL is a detector model that is able to filter clean and noisy embeddings. Evaluation across five datasets and four baseline defenses shows that our defense outperforms all baselines.

## References

- (1)
How Apple personalizes Siri without hoovering up your data.
[https://www.technologyreview.com/2019/12/11/131629/apple-ai-personalizes-siri-federated-learning/](https://www.technologyreview.com/2019/12/11/131629/apple-ai-personalizes-siri-federated-learning/).
- (2)
Federated learning: Collaborative machine learning without centralized training data.
[https://ai.googleblog.com/2017/04/federated-learning-collaborative.html](https://ai.googleblog.com/2017/04/federated-learning-collaborative.html), 2017.
- (3)
Eugene Bagdasaryan, Andreas Veit, Yiqing Hua, Deborah Estrin, and Vitaly Shmatikov.
How to backdoor federated learning.
In AISTATS, 2020.
- (4)
Eugene Bagdasaryan, Andreas Veit, Yiqing Hua, Deborah Estrin, and Vitaly Shmatikov.
How to backdoor federated learning.
In International conference on artificial intelligence and statistics, pages 2938–2948. PMLR, 2020.
- (5)
Jiawang Bai, Kuofeng Gao, Dihong Gong, Shu-Tao Xia, Zhifeng Li, and Wei Liu.
Hardly perceptible trojan attack against neural networks with bit flips.
In ECCV, 2022.
- (6)
Jiawang Bai, Kuofeng Gao, Shaobo Min, Shu-Tao Xia, Zhifeng Li, and Wei Liu.
Badclip: Trigger-aware prompt learning for backdoor attacks on clip.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 24239–24250, 2024.
- (7)
Jiawang Bai, Baoyuan Wu, Zhifeng Li, and Shu-Tao Xia.
Versatile weight attack via flipping limited bits.
IEEE Transactions on Pattern Analysis and Machine Intelligence, 2023.
- (8)
Jiawang Bai, Baoyuan Wu, Yong Zhang, Yiming Li, Zhifeng Li, and Shu-Tao Xia.
Targeted attack against deep neural networks via flipping limited weight bits.
arXiv preprint arXiv:2102.10496, 2021.
- (9)
Yijie Bai, Yanjiao Chen, Hanlei Zhang, Wenyuan Xu, Haiqin Weng, and Dou Goodman.
$\{$VILLAIN$\}$: Backdoor attacks against vertical split learning.
In 32nd USENIX Security Symposium (USENIX Security 23), pages 2743–2760, 2023.
- (10)
Borja Balle, Giovanni Cherubin, and Jamie Hayes.
Reconstructing training data with informed adversaries.
In 2022 IEEE Symposium on Security and Privacy (SP), pages 1138–1156. IEEE, 2022.
- (11)
Moran Baruch, Baruch Gilad, and Yoav Goldberg.
A Little Is Enough: Circumventing Defenses For Distributed Learning.
In NeurIPS, 2019.
- (12)
Arjun Nitin Bhagoji, Supriyo Chakraborty, Prateek Mittal, and Seraphin Calo.
Analyzing federated learning through an adversarial lens.
In ICML, 2019.
- (13)
Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool.
Food-101–mining discriminative components with random forests.
In Computer vision–ECCV 2014: 13th European conference, zurich, Switzerland, September 6-12, 2014, proceedings, part VI 13, pages 446–461. Springer, 2014.
- (14)
Ricardo JGB Campello, Davoud Moulavi, and Jörg Sander.
Density-based clustering based on hierarchical density estimates.
In Pacific-Asia conference on knowledge discovery and data mining, pages 160–172. Springer, 2013.
- (15)
X. Cao, J. Jia, Z. Zhang, and N. Gong.
Fedrecover: Recovering from poisoning attacks in federated learning using historical information.
In 2023 2023 IEEE Symposium on Security and Privacy (SP) (SP), pages 326–343, Los Alamitos, CA, USA, may 2023. IEEE Computer Society.
- (16)
Xiaoyu Cao, Minghong Fang, Jia Liu, and Neil Zhenqiang Gong.
FLTrust: Byzantine-robust Federated Learning via Trust Bootstrapping.
In NDSS, 2021.
- (17)
Nicholas Carlini, Chang Liu, Jernej Kos, Úlfar Erlingsson, and Dawn Song.
The Secret Sharer: Measuring Unintended Neural Network Memorization & Extracting Secrets.
arXiv:1802.08232, 2018.
- (18)
Nicolas Carlini, Jamie Hayes, Milad Nasr, Matthew Jagielski, Vikash Sehwag, Florian Tramer, Borja Balle, Daphne Ippolito, and Eric Wallace.
Extracting training data from diffusion models.
In 32nd USENIX Security Symposium (USENIX Security 23), pages 5253–5270, 2023.
- (19)
Xinyun Chen, Chang Liu, Bo Li, Kimberly Lu, and Dawn Song.
Targeted backdoor attacks on deep learning systems using data poisoning.
arXiv:1712.05526, 2017.
- (20)
Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi.
Describing textures in the wild.
In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 3606–3613, 2014.
- (21)
Wenlong Deng, Christos Thrampoulidis, and Xiaoxiao Li.
Unlocking the potential of prompt-tuning in bridging generalized and personalized federated learning.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6087–6097, 2024.
- (22)
Minghong Fang, Xiaoyu Cao, Jinyuan Jia, and Neil Zhenqiang Gong.
Local Model Poisoning Attacks to Byzantine-Robust Federated Learning.
In USENIX, 2020.
- (23)
Li Fei-Fei, Rob Fergus, and Pietro Perona.
Learning generative visual models from few training examples: An incremental bayesian approach tested on 101 object categories.
In 2004 conference on computer vision and pattern recognition workshop, pages 178–178. IEEE, 2004.
- (24)
Chong Fu, Xuhong Zhang, Shouling Ji, Jinyin Chen, Jingzheng Wu, Shanqing Guo, Jun Zhou, Alex X Liu, and Ting Wang.
Label inference attacks against vertical federated learning.
In 31st USENIX security symposium (USENIX Security 22), pages 1397–1414, 2022.
- (25)
Kuofeng Gao, Jiawang Bai, Baoyuan Wu, Mengxi Ya, and Shu-Tao Xia.
Imperceptible and robust backdoor attack in 3d point cloud.
IEEE Transactions on Information Forensics and Security, 19:1267–1282, 2023.
- (26)
Tianyu Gu, Brendan Dolan-Gavitt, and Siddharth Garg.
Badnets: Identifying vulnerabilities in the machine learning model supply chain.
arXiv:1708.06733, 2017.
- (27)
Tianyu Gu, Kang Liu, Brendan Dolan-Gavitt, and Siddharth Garg.
Badnets: Evaluating backdooring attacks on deep neural networks.
IEEE Access, 7:47230–47244, 2019.
- (28)
Tao Guo, Song Guo, and Junxiao Wang.
Pfedprompt: Learning personalized prompt for vision-language models in federated learning.
In Proceedings of the ACM Web Conference 2023, pages 1364–1374, 2023.
- (29)
Tao Guo, Song Guo, Junxiao Wang, Xueyang Tang, and Wenchao Xu.
Promptfl: Let federated participants cooperatively learn prompts instead of models-federated learning in age of foundation model.
IEEE Transactions on Mobile Computing, 2023.
- (30)
Asif Hanif, Fahad Shamshad, Muhammad Awais, Muzammal Naseer, Fahad Shahbaz Khan, Karthik Nandakumar, Salman Khan, and Rao Muhammad Anwer.
Baple: Backdoor attacks on medical foundational models using prompt learning.
In International Conference on Medical Image Computing and Computer-Assisted Intervention, pages 443–453. Springer, 2024.
- (31)
Peter Kairouz, H Brendan McMahan, Brendan Avent, et al.
Advances and open problems in federated learning.
arXiv:1912.04977, 2019.
- (32)
Muhammad Uzair Khattak, Hanoona Rasheed, Muhammad Maaz, Salman Khan, and Fahad Shahbaz Khan.
Maple: Multi-modal prompt learning.
arXiv preprint arXiv:2210.03117, 2022.
- (33)
Keita Kurita, Paul Michel, and Graham Neubig.
Weight poisoning attacks on pre-trained models.
arXiv preprint arXiv:2004.06660, 2020.
- (34)
Yuezun Li, Yiming Li, Baoyuan Wu, Longkang Li, Ran He, and Siwei Lyu.
Invisible backdoor attack with sample-specific triggers.
In ICCV, 2021.
- (35)
Siyuan Liang, Mingli Zhu, Aishan Liu, Baoyuan Wu, Xiaochun Cao, and Ee-Chien Chang.
Badclip: Dual-embedding guided backdoor attack on multimodal contrastive learning.
In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 24645–24654, 2024.
- (36)
Yang Liu, Yan Kang, Tianyuan Zou, Yanhong Pu, Yuanqin He, Xiaozhou Ye, Ye Ouyang, Ya-Qin Zhang, and Qiang Yang.
Vertical federated learning: Concepts, advances, and challenges.
IEEE Transactions on Knowledge and Data Engineering, 36(7):3615–3634, 2024.
- (37)
Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew Blaschko, and Andrea Vedaldi.
Fine-grained visual classification of aircraft.
arXiv preprint arXiv:1306.5151, 2013.
- (38)
H Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas.
Communication-efficient learning of deep networks from decentralized data.
In AISTATS, 2017.
- (39)
El Mahdi El Mhamdi, Rachid Guerraoui, and Sébastien Rouault.
The Hidden Vulnerability of Distributed Learning in Byzantium.
In ICML, 2018.
- (40)
Thien Duc Nguyen, Phillip Rieger, Huili Chen, Hossein Yalame, Helen Möllering, Hossein Fereidooni, Samuel Marchal, Markus Miettinen, Azalia Mirhoseini, Shaza Zeitouni, et al.
$\{$FLAME$\}$: Taming backdoors in federated learning.
In 31st USENIX security symposium (USENIX Security 22), pages 1415–1432, 2022.
- (41)
Thuy Dung Nguyen, Tuan A Nguyen, Anh Tran, Khoa D Doan, and Kok-Seng Wong.
Iba: Towards irreversible backdoor attacks in federated learning.
Advances in Neural Information Processing Systems, 36:66364–66376, 2023.
- (42)
Tuan Anh Nguyen and Anh Tran.
Input-aware dynamic backdoor attack.
NeurIPS, 2020.
- (43)
Maria-Elena Nilsback and Andrew Zisserman.
Automated flower classification over a large number of classes.
In 2008 Sixth Indian conference on computer vision, graphics & image processing, pages 722–729. IEEE, 2008.
- (44)
Omkar M Parkhi, Andrea Vedaldi, Andrew Zisserman, and CV Jawahar.
Cats and dogs.
In 2012 IEEE conference on computer vision and pattern recognition, pages 3498–3505. IEEE, 2012.
- (45)
PyTorch Documentation.
[https://pytorch.org/](https://pytorch.org/), 2019.
- (46)
Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al.
Learning transferable visual models from natural language supervision.
In International conference on machine learning, pages 8748–8763. PMLR, 2021.
- (47)
Esha Sarkar, Hadjer Benkraouda, Gopika Krishnan, Homer Gamil, and Michail Maniatakos.
Facehack: Attacking facial recognition systems using malicious facial characteristics.
IEEE Transactions on Biometrics, Behavior, and Identity Science, 4(3):361–372, 2021.
- (48)
V. Shejwalkar, A. Houmansadr, P. Kairouz, and D. Ramage.
Back to the drawing board: A critical evaluation of poisoning attacks on production federated learning.
In 2022 2022 IEEE Symposium on Security and Privacy (SP) (SP), pages 1117–1134, Los Alamitos, CA, USA, may 2022. IEEE Computer Society.
- (49)
Virat Shejwalkar and Amir Houmansadr.
Manipulating the Byzantine: Optimizing Model Poisoning Attacks and Defenses for Federated Learning.
In NDSS, 2021.
- (50)
Virat Shejwalkar, Lingjuan Lyu, and Amir Houmansadr.
The perils of learning from unlabeled data: Backdoor attacks on semi-supervised learning.
In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4730–4740, 2023.
- (51)
Ziteng Sun, Peter Kairouz, Ananda Theertha Suresh, and H Brendan McMahan.
Can you really backdoor federated learning?
NeurIPS FL Workshop, 2019.
- (52)
Chandra Thapa, Pathum Chamikara Mahawaga Arachchige, Seyit Camtepe, and Lichao Sun.
Splitfed: When federated learning meets split learning.
In Proceedings of the AAAI conference on artificial intelligence, volume 36, pages 8485–8493, 2022.
- (53)
Alexander Turner, Dimitris Tsipras, and Aleksander Madry.
Label-consistent backdoor attacks.
arXiv preprint arXiv:1912.02771, 2019.
- (54)
Laurens Van der Maaten and Geoffrey Hinton.
Visualizing data using t-sne.
Journal of machine learning research, 9(11), 2008.
- (55)
Praneeth Vepakomma, Otkrist Gupta, Tristan Swedish, and Ramesh Raskar.
Split learning for health: Distributed deep learning without sharing raw patient data.
arXiv preprint arXiv:1812.00564, 2018.
- (56)
Hongyi Wang, Kartik Sreenivasan, Shashank Rajput, Harit Vishwakarma, Saurabh Agarwal, Jy-yong Sohn, Kangwook Lee, and Dimitris Papailiopoulos.
Attack of the tails: Yes, you really can backdoor federated learning.
In NeurIPS, 2020.
- (57)
Utilization of FATE in Risk Management of Credit in Small and Micro Enterprises.
[https://www.fedai.org/cases/utilization-of-fate-in-risk-management-of-credit-in-small-and-micro-enterprises/](https://www.fedai.org/cases/utilization-of-fate-in-risk-management-of-credit-in-small-and-micro-enterprises/), 2019.
- (58)
Pei-Yau Weng, Minh Hoang, Lam Nguyen, My T Thai, Lily Weng, and Nghia Hoang.
Probabilistic federated prompt-tuning with non-iid and imbalanced data.
Advances in Neural Information Processing Systems, 37:81933–81958, 2024.
- (59)
Chulin Xie, Keli Huang, Pin-Yu Chen, and Bo Li.
DBA: Distributed backdoor attacks against federated learning.
In ICLR, 2019.
- (60)
Cong Xie, Oluwasanmi Koyejo, and Indranil Gupta.
Generalized byzantine-tolerant sgd.
arXiv:1802.10116, 2018.
- (61)
Cong Xie, Sanmi Koyejo, and Indranil Gupta.
Fall of empires: Breaking Byzantine-tolerant SGD by inner product manipulation.
arXiv:1903.03936, 2019.
- (62)
Xiong Xu, Kunzhe Huang, Yiming Li, Zhan Qin, and Kui Ren.
Towards reliable and efficient backdoor trigger inversion via decoupling benign features.
In ICLR, 2024.
- (63)
Mengxi Ya, Yiming Li, Tao Dai, Bin Wang, Yong Jiang, and Shu-Tao Xia.
Towards faithful xai evaluation via generalization-limited backdoor watermark.
In ICLR, 2024.
- (64)
Dong Yin, Yudong Chen, Kannan Ramchandran, and Peter Bartlett.
Byzantine-robust distributed learning: Towards optimal statistical rates.
In ICML, 2018.
- (65)
Yi Zeng, Won Park, Z Morley Mao, and Ruoxi Jia.
Rethinking the backdoor attacks’ triggers: A frequency perspective.
In Proceedings of the IEEE/CVF international conference on computer vision, pages 16473–16481, 2021.
- (66)
Hangfan Zhang, Jinyuan Jia, Jinghui Chen, Lu Lin, and Dinghao Wu.
A3fl: Adversarially adaptive backdoor attacks to federated learning.
Advances in neural information processing systems, 36:61213–61233, 2023.
- (67)
Zaixi Zhang, Xiaoyu Cao, Jinyuan Jia, and Neil Zhenqiang Gong.
Fldetector: Defending federated learning against model poisoning attacks via detecting malicious clients.
In Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pages 2545–2555, 2022.
- (68)
Haodong Zhao, Wei Du, Fangqi Li, Peixuan Li, and Gongshen Liu.
Fedprompt: Communication-efficient and privacy-preserving prompt tuning in federated learning.
In ICASSP 2023-2023 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 1–5. IEEE, 2023.
- (69)
Kaiyang Zhou, Jingkang Yang, Chen Change Loy, and Ziwei Liu.
Conditional prompt learning for vision-language models.
In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 16816–16825, 2022.
- (70)
Kaiyang Zhou, Jingkang Yang, Chen Change Loy, and Ziwei Liu.
Learning to prompt for vision-language models.
International Journal of Computer Vision, 130(9):2337–2348, 2022.

## Appendix A Limitations and Future Work

This work brings together three major research areas: federated learning, prompt learning, and backdoor attacks under a unified evaluation framework. Given the breadth of this integration, it is naturally beyond the scope of a single paper to exhaustively explore all possible combinations of settings, attack strategies, and defense variants within this space. Our goal in this paper was to highlight a critical and previously unexamined vulnerability: the susceptibility of federated prompt learning to targeted backdoor attacks. To that end, we carefully selected evaluation settings that isolate this problem and clearly demonstrate both the threat and the effectiveness of SABRE-FL.

Nevertheless, several limitations remain. First, while we focused on data poisoning attacks with learnable triggers, we did not explore model poisoning attacks [22, 49], where the attacker perturbs client model parameters directly. Future work could compare the relative potency and stealth of model vs. data poisoning in prompt-based FL. Second, although we used five diverse datasets and conducted shot-based and scale-based ablations, we did not explicitly vary data heterogeneity across clients. Understanding how non-IID data affects backdoor robustness and detection performance is an important direction. Finally, we used the CLIP ViT-B/16 backbone throughout this study; while it is a representative and widely adopted model, future work may examine other vision-language backbones (e.g., ViT-L, EVA-CLIP, or OpenCLIP variants) to assess generalization across model families.
Overall, we believe our findings lay the foundation for a deeper understanding of security risks in prompt-based federated systems and invite further exploration into more nuanced threat models, client behavior assumptions, and multi-modal defense strategies.

## Appendix B Terminology/Technologies

### B.1 CLIP: Contrastive Language-Image Pretraining

CLIP, short for Contrastive Language-Image Pretraining, is a type of multimodal machine learning model developed by OpenAI [46]. *“Multimodal”* means it can process and relate information from two different types of inputs, in this case, images and natural language. Models like CLIP are referred to as *vision-language models (VLMs)* because they jointly understand both visual and textual information.
CLIP was trained on a large dataset of 400 million (image, text) pairs collected from the internet. The idea behind CLIP is simple but powerful: given an image and a sentence, the model learns to tell whether the sentence correctly describes the image. For example, given a photo of a cat and several captions like “a cat,” “a dog,” or “a painting,” CLIP learns to match the correct caption to the image. This is done using a technique called *contrastive learning*, where the model pulls together matching image-text pairs and pushes apart mismatched ones in the embedding space.

CLIP has two components:
- An *image encoder* (e.g., a Vision Transformer or ResNet) that converts images into high-dimensional vectors.
- A *text encoder* (e.g., a Transformer) that converts sentences into vectors in the same space.
After training, CLIP can be used for *zero-shot classification*, where it is given a list of possible text labels and an image, and it predicts which label best matches the image. This makes CLIP very versatile for *downstream tasks*, i.e., tasks that are different from the model’s pretraining objective, such as object classification, image retrieval, OCR, or even robotics. During testing, CLIP matches a given test image with the best matching class label (converted into a prompt like "a photo of a class").
In summary, CLIP is a general-purpose vision-language model that learns a shared representation space for images and text without needing explicit labels. It serves as the foundation for prompt learning, which allows users to adapt CLIP to new tasks more effectively.

### B.2 Prompt Learning

A *prompt* is a piece of text that is used to guide a model’s predictions. In language models (like GPT), a prompt might be a sentence like “Translate this to French: Hello,” and in CLIP, it might be “a photo of a dog.” In the original CLIP setup, hand-crafted prompts like “a photo of a class” are used during testing to convert text labels into embeddings.
However, *manual prompts are often suboptimal* as they rely on human intuition and may not generalize well across tasks or datasets. This led to the idea of *prompt learning*, where instead of using fixed textual prompts, we learn *soft prompts*, i.e., a set of trainable vectors that replace or augment the context in a prompt. These prompts are optimized during training to improve model performance on a given downstream task.

The pioneering work in this area is *CoOp (Context Optimization)* [70], which introduced learnable prompts for vision-language models like CLIP. In CoOp, the prompt is represented as a series of learnable embeddings $[\bm{v}_{1},\bm{v}_{2},...,\bm{v}_{N}]$, which are prepended to each class name (e.g., “[v1][v2]... [vN] dog”) and passed through the text encoder. These prompts are optimized using a small amount of labeled data.
Prompt learning has several advantages: (1)It avoids fine-tuning the entire backbone, making it computationally efficient. (2) It adapts the model to new tasks with only a few training examples (few-shot learning). (3) It retains the generalization power of the pretrained model while specializing it for a specific task.
Some common *prompt hyperparameters* include: (1)*Context length (N):* the number of learnable prompt vectors prepended to the class name. (2)*Number of shots:* how many labeled examples per class are used for training. (3)*Class token position:* whether the class label appears at the start, middle, or end of the prompt.
Increasing the *number of shots* typically improves accuracy because the model sees more training examples per class, allowing the prompt learner to better capture the features that distinguish different categories. However, prompt learning often performs well even in low-shot settings, making it ideal for domains with limited labeled data.

### B.3 BadCLIP

BadCLIP is a backdoor attack framework proposed in a CVPR 2024 paper [6], designed to evaluate the vulnerability of prompt-learning-based vision-language models like CLIP. Unlike traditional backdoor attacks that rely on visible patterns or simple data poisoning, BadCLIP crafts *visually imperceptible noise triggers* that manipulate the internal behavior of the model during both training and inference.
Similar to CLIP, BadCLIP predicts the correct label by comparing image features to text features derived from prompts (e.g., “a photo of a dog”). In the presence of a backdoor, a small adversarial noise pattern (trigger) is added to the input image. This trigger is optimized during training to cause the image encoder to shift the image embedding closer to the text embedding of an attacker-specified target class (e.g., “cat”), while remaining visually indistinguishable to humans.
BadCLIP also adapts the prompt vectors in a *trigger-aware* manner. That is, both image features and context vectors are conditioned on the presence of the backdoor trigger, making the backdoor more robust and more likely to survive training. During inference, even if a clean image is given a trigger, the poisoned model misclassifies it as the target class due to embedding-level drift.

More formally, given a clean image $\bm{x}$ and a trigger $\bm{t}$, the backdoored input $\bm{x}^{\star}=\bm{x}\oplus\bm{t}$ results in an image embedding $f(\bm{x}^{\star})$ that is closer to the prompt-conditioned text embedding of the target class $g(\{\bm{V},\bm{c}_{t}\})$ than to its true label $g(\{\bm{V},\bm{c}_{y}\})$. The model predicts the target class $t$ even though the visual appearance corresponds to $y$.
BadCLIP is the first backdoor framework using noise-based triggers specifically designed for prompt-tuned CLIP models. Its key insight is that backdoor signals are not limited to the input space but can be embedded into CLIP’s latent space, making them both stealthy and effective. SABRE-FL builds on this idea, extending it to the federated learning setting.

### B.4 Privacy Leakage

Recent work has demonstrated that it is possible to reconstruct input data from machine learning models [10, 18, 17]. These attacks are known as *reconstruction attacks*. However, such attacks typically require certain strong assumptions. For example, [10] consider a very strong adversary that knows several data points as well as the weights of the model.

SABRE-FL operates entirely in the representation space of a frozen CLIP encoder, meaning the image encoder is never updated with client-specific data. As a result, the embeddings remain generic and task-agnostic, optimized for cross-modal alignment, not input reconstruction. This design choice significantly reduces the risk of privacy leakage, as CLIP embeddings are not trained to retain high-frequency or instance-specific image details.

While representation-level inversion remains an evolving area of research, current attacks often assume more favorable conditions than those present in SABRE-FL. Nevertheless, we acknowledge the broader risk and consider our design to reflect a privacy-utility tradeoff: by accepting lightweight representation sharing with a fixed encoder, we achieve robust backdoor detection without compromising raw inputs or task-specific outputs.

## Appendix C Additional Implementation Details

### C.1 Detector Thresholding and Client Filtering

In the main paper, we define the detector score $S_{k}$ for each client $C_{k}$ as the mean classification output over its submitted embeddings:

$$ $S_{k}=\frac{1}{n_{k}}\sum_{j=1}^{n_{k}}D(z_{j}^{k})$ $$

where $D(\cdot)$ is a binary classifier that outputs 1 for poisoned embeddings. While this naturally allows for threshold-based filtering (i.e., flagging clients for which $S_{k}>\tau$), in practice we adopt a more stable rank-based heuristic.

Specifically, in each communication round, we assume $m$ out of $n$ clients may be malicious, and we remove the $m$ clients with the highest number of flagged embeddings (or highest $S_{k}$ scores). This avoids the need to hand-tune a static threshold $\tau$ and reflects a standard assumption in robust FL defense literature, where $m$ is typically known or bounded [64, 60]. This rank-based heuristic is consistent with our earlier detector formulation and preserves the intended semantic interpretation of $S_{k}$ as a client-level anomaly score.

## Appendix D Experimental Setup

### D.1 Model and Attack Settings

We use the CLIP model in a similar style as that of Bai et. al [6]. ViT-B/16 is used as the image encoder. The pretrained weights are taken from CLIP’s released models [46]. We use a context length N of 4, total number of epochs as 10, where 1 is a warmup epoch, and a cosine learning rate scheduler with an initial learning rate of 0.002. Unless specified otherwise, we keep the number of shots to be 8, trigger optimization for 3 epochs, and an SGD optimizer. The maximum noise strength, $\epsilon$, for the backdoor trigger is chosen to be 4. Similar to BadClip, the first class of every dataset is chosen as the target class during the attack.

### D.2 Datasets

We use datasets that are used in CoOp [70] and BadCLIP [6]. We use the same dataset configuration files they provide. The datasets we use in our experiments are:

- •
Caltech-101 [23] is a standard object classification dataset consisting of 9,146 images across 101 object categories and a background class. It has the license CC BY 4.0. Each category contains between 40 and 800 images of objects taken from varying viewpoints and backgrounds. The dataset is known for its moderate intra-class variation and has been widely used in evaluating vision models, especially in low-shot and few-shot learning settings. In our work, we use Caltech-101 as an out-of-distribution (OOD) dataset to train our backdoor detector. Importantly, this dataset is disjoint from the ones used in federated training, allowing us to test whether our detector generalizes across domains.
- •
Flowers-102 [43] is a fine-grained classification dataset consisting of 8,189 images of flowers categorized into 102 species. Each class contains between 40 and 258 samples. The high inter-class similarity and fine-grained nature of the dataset make it a challenging benchmark for vision-language models.
- •
The Oxford-IIIT Pets dataset [44] contains 7,349 images of 37 breeds of cats and dogs. Each class includes approximately 200 images captured in varied poses, lighting conditions, and backgrounds. The dataset presents a mix of inter-class similarity and intra-class diversity, making it suitable for testing the robustness of prompt learners in federated setups. It is available under the license CC BY-SA 4.0.
- •
DTD [20] (Describable Textures Dataset) is a texture-centric classification dataset with 5,640 images labeled across 47 human-describable texture attributes such as “bumpy,” “scaly,” or “striped.” The dataset emphasizes mid-level visual cues and is used in our evaluation to test whether prompt-based FL models can maintain robustness when the notion of class is not strictly object-centric.
- •
FGVC Aircraft [37] contains 10,000 images of 100 aircraft variants grouped by manufacturer and model. It is a fine-grained classification dataset that introduces significant challenges due to subtle inter-class differences and high intra-class consistency. We include it to assess whether backdoor attacks are effective even in domains where prompt learners must capture nuanced visual differences.
- •
Food-101 [13] consists of 101,000 images across 101 food categories. The dataset exhibits significant visual diversity, both within and across classes, and is commonly used to benchmark image classification performance under real-world visual noise and clutter. It serves as one of the more large-scale and diverse benchmarks in our federated evaluation.

### D.3 Defense Methods

We compare our technique with four popular defense techniques. Trimmed mean [64, 60] is a widely used defense in FL, where the server receives updates from each client, sorts them across each dimension, and then discards the $m$ smallest and lowest values across each dimension. Here, $m$ is the number of malicious clients. Median [64] is another popular defense mechanism, where the global model is computed by taking the dimension-wise median of the client updates. Norm-bounding [51] clips the values of client updates to a certain value so they do not exceed that threshold. This threshold is computed by taking the median value of the client updates. FLAME [40] is a more complex defense that first clusters the clients into benign and malicious groups using hdbscan [14], clips them at a certain threshold, and adds noise to the model parameters to make them resilient to backdoors.

### D.4 Detector Training

We train a detector $D:\mathbb{R}^{d}\to\{0,1\}$ to minimize binary cross-entropy loss over this embedding dataset. The model architecture is a two-layer multilayer perceptron (MLP) with a hidden layer of size 128 and ReLU activation. It takes as input CLIP image embeddings $z_{i}\in\mathbb{R}^{d}$ (with $d=512$) and outputs logits corresponding to the clean or backdoored class. Optimization is performed using the Adam optimizer with a learning rate of $1\times 10^{-3}$ for 20 epochs, and batch size 64.

To evaluate cross-domain generalization, we test the trained detector on separate held-out datasets, namely Oxford Flowers, Pets, DTD, FGVC Aircraft, and Food101, each containing a mix of clean and poisoned embeddings. Despite being trained on a single auxiliary dataset, the detector consistently achieves $>90\%$ accuracy on these unseen domains. This supports our hypothesis that poisoned embeddings exhibit a consistent statistical signature in CLIP space, independent of the underlying dataset or class distribution.

### D.5 Resources

We used PyTorch [45] for our coding on a Linux-based system. For running experiments, we use our university cluster that has different types of GPUs. Most of our experiments were performed on 12 GB NVIDIA TITANX GPUs. The run time of the experiments depended upon the dataset used, number of shots, and number of clients.

## Appendix E Additional Results

### E.1 t-SNE

We show the t-SNE plot of Oxford Flowers clean and backdoored embeddings in Figure [7](https://arxiv.org/html/2506.22506v1#A5.F7).

Figure: Figure 7: t-SNE Flowers
Refer to caption: x9.png

### E.2 Varying number of shots

We show the impact of varying the number of shots on all five datasets in Figure [8](https://arxiv.org/html/2506.22506v1#A5.F8).

Figure: (a) Flowers
Refer to caption: x10.png

### E.3 Robustness to Client Scaling

To evaluate the robustness of SABRE-FL under increased scale, we replicate our backdoor attack and defense experiments with 32 clients. As shown in Table [3](https://arxiv.org/html/2506.22506v1#A5.T3), backdoor success rates rise substantially in the absence of defense, reaching 89.9% on FGVC Aircraft and 46.8% on DTD. When SABRE-FL is enabled, backdoor accuracy drops to 24.7% and 14.1%, respectively, demonstrating that our detector remains effective even as the number of participating clients grows. Clean accuracy also remains stable across all datasets, confirming that the defense generalizes to larger federated populations without degrading utility.

**Table 3: Backdoor attack effectiveness with and without SABRE-FL at 32-client scale. Each cell shows Clean Accuracy / Backdoor Accuracy (%).**
| Dataset | Flowers | Pets | DTD | FGVC Aircraft | Food101 |
| --- | --- | --- | --- | --- | --- |
| No Defense | 74.9 / 43.5 | 88.8 / 25.9 | 59.3 / 46.8 | 29.9 / 89.9 | 89.2 / 32.2 |
| SABRE-FL | 75.0 / 8.5 | 91.1 / 7.2 | 61.0 / 14.1 | 29.7 / 24.7 | 89.7 / 2.8 |

## NeurIPS Paper Checklist

- 1.
Claims
- Question: Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
- Answer: [Yes]
- Justification: Yes, we have ensured that the main claims in the abstract and introduction
accurately reflect the paper’s contributions and scope.
- Guidelines:
•
The answer NA means that the abstract and introduction do not include the claims made in the paper.
•
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.
•
The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.
•
It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.
- 2.
Limitations
- Question: Does the paper discuss the limitations of the work performed by the authors?
- Answer: [Yes]
- Justification: Yes, we have discussed the limitations and future work in [A](https://arxiv.org/html/2506.22506v1#A1).
- Guidelines:
•
The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
•
The authors are encouraged to create a separate "Limitations" section in their paper.
•
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
•
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
•
The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
•
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
•
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.
•
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren’t acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
- 3.
Theory assumptions and proofs
- Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?
- Answer: [Yes]
- Justification: Yes, in our paper, all theoretical proofs and equations are numbered, cross-referenced, and their assumptions are clearly stated.
- Guidelines:
•
The answer NA means that the paper does not include theoretical results.
•
All the theorems, formulas, and proofs in the paper should be numbered and cross-referenced.
•
All assumptions should be clearly stated or referenced in the statement of any theorems.
•
The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.
•
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.
•
Theorems and Lemmas that the proof relies upon should be properly referenced.
- 4.
Experimental result reproducibility
- Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
- Answer: [Yes]
- Justification: Yes, we have fully disclosed the information needed to reproduce the main
experimental results of the paper. They are written in Section [5](https://arxiv.org/html/2506.22506v1#S5) and Appendix [D](https://arxiv.org/html/2506.22506v1#A4).
- Guidelines:
•
The answer NA means that the paper does not include experiments.
•
If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
•
If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
•
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
•
While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a)
If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.
(b)
If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.
(c)
If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).
(d)
We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.
- 5.
Open access to data and code
- Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?
- Answer: [Yes]
- Justification: Yes, we are submitting the code for SABRE-FL in the supplementary material. All datasets are publicly available. We provide an “instructions.txt" file to reproduce results on backdoor attacks and train the detector model. We have modified the code inside the BadCLIP [6] repository, making it easier to run experiments. We will publish our full code with the final version of this paper.
- Guidelines:
•
The answer NA means that paper does not include experiments requiring code.
•
Please see the NeurIPS code and data submission guidelines ([https://nips.cc/public/guides/CodeSubmissionPolicy](https://nips.cc/public/guides/CodeSubmissionPolicy)) for more details.
•
While we encourage the release of code and data, we understand that this might not be possible, so “No” is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).
•
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ([https://nips.cc/public/guides/CodeSubmissionPolicy](https://nips.cc/public/guides/CodeSubmissionPolicy)) for more details.
•
The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
•
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.
•
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
•
Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.
- 6.
Experimental setting/details
- Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
- Answer: [Yes]
- Justification: We specify the training and test details in Appendix [D](https://arxiv.org/html/2506.22506v1#A4).
- Guidelines:
•
The answer NA means that the paper does not include experiments.
•
The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.
•
The full details can be provided either with the code, in appendix, or as supplemental material.
- 7.
Experiment statistical significance
- Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
- Answer: [No]
- Justification: We did not have enough compute resources to completely re-run all the experiments for different seeds and report error bars for different runs. We are currently rerunning the error bar experiments, and we plan to include the experiments with different seeds in the final version.
- Guidelines:
•
The answer NA means that the paper does not include experiments.
•
The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.
•
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).
•
The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
•
The assumptions made should be given (e.g., Normally distributed errors).
•
It should be clear whether the error bar is the standard deviation or the standard error of the mean.
•
It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.
•
For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).
•
If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.
- 8.
Experiments compute resources
- Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?
- Answer: [Yes]
- Justification: We present these details in Appendix [D](https://arxiv.org/html/2506.22506v1#A4).
- Guidelines:
•
The answer NA means that the paper does not include experiments.
•
The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
•
The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.
•
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn’t make it into the paper).
- 9.
Code of ethics
- Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics [https://neurips.cc/public/EthicsGuidelines](https://neurips.cc/public/EthicsGuidelines)?
- Answer: [Yes]
- Justification: Yes, to the best of our knowledge, our paper conforms to the NeurIPS Code of Ethics in every aspect.
- Guidelines:
•
The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
•
If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.
•
The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).
- 10.
Broader impacts
- Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
- Answer: [N/A]
- Justification: Or work does not have such a societal impact that requires discussion in the paper.
- Guidelines:
•
The answer NA means that there is no societal impact of the work performed.
•
If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.
•
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
•
The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
•
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
•
If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).
- 11.
Safeguards
- Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
- Answer: [N/A]
- Justification: To the best of our knowledge, our paper poses no such risks. We use publicly available code and data for our work.
- Guidelines:
•
The answer NA means that the paper poses no such risks.
•
Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.
•
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
•
We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.
- 12.
Licenses for existing assets
- Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
- Answer: [Yes]
- Justification: We have cited all the datasets and they have been widely used in previous works. The datasets we used are Caltech-101 [23], Flowers-102 [43], Oxford-IIIT Pets [44], DTD [20], FGVC Aircraft [37], and Food 101 [13]. We found the license for Caltech-101 (CC BY 4.0) and Oxford Pets (CC BY-SA 4.0). We could not find a license for others, but their homepages say that they are available for non-commercial research purposes.
- Guidelines:
•
The answer NA means that the paper does not use existing assets.
•
The authors should cite the original paper that produced the code package or dataset.
•
The authors should state which version of the asset is used and, if possible, include a URL.
•
The name of the license (e.g., CC-BY 4.0) should be included for each asset.
•
For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.
•
If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, [paperswithcode.com/datasets](paperswithcode.com/datasets) has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.
•
For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
•
If this information is not available online, the authors are encouraged to reach out to the asset’s creators.
- 13.
New assets
- Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
- Answer: [Yes]
- Justification: Yes, we are submitting the code for SABRE-FL in the supplementary material. We provide an “instructions.txt" file to reproduce our results.
- Guidelines:
•
The answer NA means that the paper does not release new assets.
•
Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
•
The paper should discuss whether and how consent was obtained from people whose asset is used.
•
At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
- 14.
Crowdsourcing and research with human subjects
- Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?
- Answer: [N/A]
- Justification: Our paper does not involve any crowdsourcing experiments nor research with human subjects.
- Guidelines:
•
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
•
Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.
•
According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
- 15.
Institutional review board (IRB) approvals or equivalent for research with human subjects
- Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
- Answer: [N/A]
- Justification: Our paper does not involve crowdsourcing nor research with human subjects.
- Guidelines:
•
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
•
Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
•
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.
•
For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.
- 16.
Declaration of LLM usage
- Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.
- Answer: [N/A]
- Justification: The use of LLMs is not an important, original, or non-standard component of the core methods in this research.
- Guidelines:
•
The answer NA means that the core method development in this research does not involve LLMs as any important, original, or non-standard components.
•
Please refer to our LLM policy ([https://neurips.cc/Conferences/2025/LLM](https://neurips.cc/Conferences/2025/LLM)) for what should or should not be described.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 2
presentation: 2
questions: Please revise the methodology section based on the weaknesses mentioned above. Also, adding some more important experiments should strengthen the contribution of this paper.
soundness: 2
strengths: 1. This paper studies backdoor attacks in federated prompt learning (FPL), where only prompt parameters, not full model weights, are shared; this is timely and relevant as CLIP-style adaptations in FL are increasingly used.
2. The method shows potential generalizability: a detector trained on Caltech-101 transfers to datasets not seen during training.
3. The paper provides clear motivation and visualization that support the defense’s intuition; the results look promising in tackling the backdoor attack tested.
summary: This paper studies backdoor attacks in Federated Prompt Learning (FPL) and introduces SABRE-FL, a defense framework that detects and filters poisoned client updates using representation-space anomaly detection. The key idea is to train a binary detector on CLIP embeddings from an auxiliary dataset which includes clean and triggered/poisoned samples, so the model can identify abnormal embedding patterns corresponding to malicious clients' updates during FL aggregation. 

The method is evaluated on five datasets, which are Flowers, Pets, DTD, FGVC Aircraft, and Food101 under varying malicious client ratios, showing that SABRE-FL achieves low backdoor success rates while preserving clean accuracy.
weaknesses: 1. The methodology section lacks important details.
(i) The paper describes the trigger as a learnable noise pattern but does not explain how it is optimized, what loss function or parameters are used, and how it interacts with the local prompt updates (e.g., whether it uses SGD, PGD, or another generator).
(ii) The defense critically depends on the parameter $m$—the number of clients excluded from aggregation each round—but there is no principled method or empirical guideline for setting this value.
(iii) The detector is trained on an auxiliary dataset (Caltech-101) with synthetically poisoned samples, yet the paper provides little justification that this dataset captures the diversity of real backdoor triggers or resembles the adversary’s trigger design. The assumption that embedding deviations generalize across datasets and trigger types is unverified.

2. Several important ablation studies are missing, such as varying $m$, testing under different non-IID settings, changing the auxiliary dataset, and exploring the effects of trigger strength, magnitude, and optimization steps.

3. The paper does not visualize or analyze the learned trigger patterns that drive the backdoor. Showing how the trigger alters image embeddings or prediction confidence would make the mechanism more transparent.

4. The evaluation focuses on a single type of learnable additive-noise trigger inspired by BadCLIP. It does not test against adaptive or structurally different triggers (e.g., patch-based, frequency-domain, sample-specific, or model-poisoning attacks). As a result, the claimed generality of SABRE-FL across attack mechanisms is not sufficiently demonstrated.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 4
questions: Please address the aforementioned weaknesses, particularly by including qualitative visualizations, sensitivity analyses for m, comparisons to stronger defenses, and discussions of detector robustness under Non-IID and adaptive attack scenarios.
soundness: 3
strengths: - Pioneers the study of backdoor threats in the emerging FPL paradigm.
- Introduces a well-motivated and FPL-specific backdoor mechanism based on learnable, imperceptible noise triggers.
- Clear writing and strong organization, aided by effective visual explanations of both attack and defense designs.
summary: The paper investigates the security vulnerabilities of Federated Prompt Learning (FPL) under backdoor attacks. The authors show that FPL models can be compromised when malicious clients inject visually imperceptible, learnable noise triggers into images, leading to targeted misclassification while maintaining high clean accuracy. To counter this, they propose SABRE-FL, a modular and lightweight server-side defense that employs an embedding-space anomaly detector—trained offline on out-of-distribution (OOD) data—to identify and filter poisoned prompt updates without accessing raw client data or labels. Experiments demonstrate that SABRE-FL significantly reduces backdoor accuracy while preserving clean performance across various datasets and FPL settings.
weaknesses: 1. The paper claims the noise triggers are *visually imperceptible*, but lacks direct image comparisons. Including visual examples (original vs. triggered) or a qualitative study would strengthen this claim.
2. SABRE-FL removes the top-*m* suspicious clients, assuming *m* is known. An analysis of sensitivity to inaccurate estimates of *m* would clarify robustness in real-world settings.
3. The distinction between the proposed attack and a federated adaptation of BadCLIP should be elaborated—what novel properties or mechanisms are introduced?
4. The effect of data heterogeneity (Non-IID settings) on SABRE-FL’s detection performance is not well-studied; benign diversity may confound the embedding-based detector.
5. SABRE-FL’s effectiveness depends on the defender’s ability to model known trigger behaviors when training its detector offline. However, this reliance makes it vulnerable to novel or unconventional backdoor types—such as semantic, geometric, or other model-poisoning attacks—that fall outside the learned embedding distribution.
6. Additional comparisons to recent strong baselines such as **Deepsight** [1] or **BackdoorIndicator** [2] would better contextualize SABRE-FL’s improvements.

[1]. Rieger, Phillip, et al. "Deepsight: Mitigating backdoor attacks in federated learning through deep model inspection." arXiv preprint arXiv:2201.00763 (2022).

[2]. Li, Songze, and Yanbo Dai. "{BackdoorIndicator}: Leveraging {OOD} Data for Proactive Backdoor Detection in Federated Learning." 33rd USENIX Security Symposium (USENIX Security 24). 2024.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1.If m is unknown or mis-specified (e.g., if the server underestimates the number of attackers), how does the defense performance of SABRE-FL (both CA and BA) degrade?
2.I would like to see some discussion regarding the communication overhead introduced by SABRE-FL.
3.Could the authors provide more insight into the results on the FGVC Aircraft dataset (Figure 8d)? In the 'no defense' setting, this dataset exhibits two extremes: the lowest Clean Accuracy (CA) and the highest Backdoor Accuracy (BA), and these results differ significantly from those of the other datasets.
soundness: 3
strengths: 1.This work presents the first systematic study of backdoor attack vulnerabilities within the Federated Prompt Learning (FPL) paradigm. This exploratory contribution is significant as it illuminates a critical and previously unexamined attack dimension.
2.The paper proposes SABRE-FL, a novel server-side defense mechanism. The core of this mechanism involves using a lightweight MLP, trained offline on an out-of-distribution (OOD) dataset, to detect embedding-space anomalies.
3.A key advantage of this defense is its generalizability. The experiments demonstrate that the detector, trained on a single auxiliary dataset, can effectively generalize and be applied across five other distinct task datasets.
summary: his paper proposes a method named SABRE-FL to defend Federated Prompt Learning (FPL) against backdoor attacks. It takes the form of a server-side defense mechanism that uses a lightweight detector to filter malicious client updates. To achieve this, they employ an anomaly detector that operates in the CLIP embedding space, which is trained offline on out-of-distribution (OOD) data. The paper outlines the vulnerability of FPL to malicious clients injecting learnable noise triggers and proposes a solution to mitigate these issues. Their main contribution is SABRE-FL, a lightweight and modular defense framework, which leverages the consistent deviation produced by poisoned samples in the embedding space to identify and filter poisoned prompt updates. They conducted an empirical study of the attack across five diverse datasets, concluding that FPL is highly vulnerable to backdoor attacks while still maintaining high clean data accuracy. Finally, an empirical study of the defense was conducted, concluding that SABRE-FL demonstrates superior performance compared to four other baseline defenses, as it can reduce backdoor accuracy while preserving clean accuracy.
weaknesses: 1.SABRE-FL is essentially an anomaly detector. In heterogeneous (Non-IID) FL scenarios, natural shifts in data distribution are an inherent characteristic. The paper provides no evidence that the detector D can distinguish between malicious offsets caused by the attack and benign shifts arising from this data heterogeneity. This casts serious doubt on the method's effectiveness in realistic FL settings.
2.The defense mechanism relies on an assumption that is difficult to satisfy in practice: the server must know the exact number of malicious clients m,a prior in each round to filter out the clients with the top-m highest scores. This assumption is unrealistic for most real-world scenarios.
3.SABRE-FL (according to Algorithm 1) requires clients to upload the embeddings for all their local data in each round. This is likely to incur substantial communication overhead.
4.The paper only provides a small-scale experiment (32 clients) in Appendix E.3 and lacks an evaluation on larger-scale federated networks.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. Could authors provide the effectiveness of the method against adaptive attackers?
2. Could authors justify the practicality of the pretraining phase?
soundness: 3
strengths: 1. Novel and timely problem. The problem of backdoor attacks in federated prompt learning is novel and interesting. The paper fills an important gap in understanding the security risks of adapting foundation models via prompt learning in a decentralized setting.
2. Clear intuition and methodology. The core idea is intuitive and well-motivated. The defense operates in embedding space, aligning with the privacy constraints of FL.
3. Strong empirical evaluation. Extensive experiments across five datasets and four defense baselines. SABRE-FL achieves the lowest backdoor accuracy while maintaining high clean accuracy.
summary: This paper studies the security of Federated Prompt Learning (FPL) and presents SABRE-FL, a defense framework that detects backdoored client updates using embedding-space anomaly detection. The authors first demonstrate that prompt-based federated systems, despite having a smaller attack surface than full-model FL, are highly vulnerable to imperceptible noise-trigger attacks. SABRE-FL then leverages CLIP embedding deviations to filter malicious updates without accessing raw client data or labels.
weaknesses: 1. Limited threat model. Only data poisoning is considered. Model poisoning or adaptive strategies are not analyzed. It is unclear whether an attacker aware of SABRE-FL could evade embedding-space detection. The assumption that the attacker controls 25% of all clients is generally considered to be high compared with existing literatures.
2. Detector training assumptions. The detector is trained using poisoned embeddings generated on an auxiliary dataset. It is not obvious how a real-world server would obtain such poisoned examples to train the detector. The paper should justify the practicality of this pre-training phase.
3. More explanation on comparison to FLAME and other baselines. FLAME also uses embedding-based filtering. The paper needs a clearer conceptual distinction and justification of why SABRE-FL is fundamentally stronger.


Decision: Accept (Poster)