betaFeedback

WorksComputer Science

BAPLe++: Cross-Model Transferability and Prompt-Level Defense of Backdoors in Medical Foundation Models

Abstract

Medical foundation models (Med-FMs) are increasingly adapted to clinical tasks through prompt learning, which tunes a small set of prompt tokens while the backbone remains frozen. Recent work has shown that this efficiency introduces a vulnerability: jointly optimizing learnable prompts and an imperceptible noise trigger during few-shot adaptation implants a backdoor that leaves clean performance intact but steers triggered inputs to an attacker-chosen class. Since prompts are compact and readily shared, this raises two questions: whether a backdoored prompt remains effective on a different Med-FM, and whether it can be repaired without retraining the backbone. We address both in BAPLe++. First, we present the first study of cross-model transferability of prompt-based backdoors, quantified by two proposed metrics, Clean Accuracy Difference (CAD) and Backdoor Accuracy Difference (BAD). Second, we propose DePLe (Defense via Prompt Learning), which uses the infected prompt as a fixed anchor and learns a new prompt on a small clean set that preserves the clean task while diverging from the compromised embedding region. Experiments on four Med-FMs and six chest X-ray and histopathology datasets show that backdoors transfer across models, but asymmetrically and in a dataset-dependent manner. Compared with four training-free input transformations, DePLe reduces backdoor accuracy more consistently while preserving, and in several settings improving, clean accuracy. Our code can be accessed on https://github.com/Ufaqkhan/Baple-Plus-Plus

Introduction

Medical Foundation Models (Med-FMs) [18, 6, 19, 7] have emerged as a transformative paradigm in medical imaging, enabling robust performance across diverse modalities and clinical tasks. By pretraining on large-scale medical image-text datasets, CLIP-like Med-FMs [18, 6, 19, 7] learn aligned visual and semantic representations, which can be readily adapted to a wide range of downstream tasks such as disease classification, histopathology analysis, and radiology report generation. This ability to transfer knowledge with minimal labeled data has made Med-FMs increasingly attractive for clinical deployment, particularly in settings where annotated medical data are scarce. As a result, Med-FMs are rapidly becoming central components in decision-support pipelines and automated imaging analysis.

As Med-FMs transition from research prototypes to clinical practice, ensuring their trustworthiness has become a pressing challenge. These models are often trained or adapted using publicly available datasets and open-source checkpoints, which promote reproducibility but also introduce attack surfaces such as data poisoning and checkpoint tampering. Combined with the scale and limited interpretability of Med-FMs, these factors complicate auditing and risk assessment. The concern is well founded, since deep learning models are known to be susceptible to adversarial manipulation [4, 13, 2]. Among such threats, backdoor attacks are particularly insidious. An adversary poisons a small fraction of the training or fine-tuning data by embedding subtle visual patterns, known as triggers, into selected samples, so that the compromised model behaves normally on clean inputs but consistently misclassifies triggered inputs into an attacker-specified target class. This dual behavior makes backdoors difficult to detect with standard validation on clean data, which is particularly concerning in clinical workflows where an undetected misclassification may adversely affect patient care. Systematic evaluation under well-defined adversarial and data-poisoning threat models is therefore a necessary, though not sufficient, step toward the safe deployment of Med-FMs in safety-critical clinical settings.

Recently, BAPLe (Hanif et al., [5]) introduced backdoor attacks on Med-FMs during prompt learning, which demonstrated for the first time that Med-FMs can be backdoored during the prompt learning phase. Unlike earlier backdoor attacks that rely on retraining large models with substantial amounts of poisoned data, BAPLe demonstrates that introducing learnable prompt tokens into the text encoder and imperceptible noise triggers into image inputs during few-shot prompt learning is sufficient to achieve over 90% attack success across multiple Med-FMs and datasets, while maintaining accuracy on clean samples. These findings highlight a critical vulnerability, i.e., parameter-efficient adaptation techniques such as prompt learning widely adopted due to their efficiency in data-limited settings can serve as an attack vector.

However, important gaps remain. First, prior work such as BAPLe focuses on attack construction, without evaluating attack effectiveness under source-to-target Med-FM transfer. In practice, institutions may deploy distinct foundation models trained on different pretraining corpora (e.g., X-ray-based MedCLIP vs. pathology-focused PLIP) ([18, 6]). Whether a backdoor crafted on one Med-FM transfers to another remains unknown, yet this question is crucial for real-world risk assessment. Second, the literature lacks a systematic investigation of defense mechanisms for mitigating backdoor attacks in Med-FMs under few-shot prompt learning setup. Third, defenses originally proposed for natural image models, including input denoising, activation clustering, and adversarial training, remain largely unexplored in the Med-FM context, where limited labeled data and frozen backbone architectures impose unique constraints.

In this work, we address these gaps by presenting BAPLe++, which investigates both cross-model transferability of backdoor attacks and proposes a robust defense mechanism to sanitize infected prompts. We further compare this prompt repair with four training-free input-transformation defenses. Our experiments reveal that backdoors can persist beyond the model in which they are introduced and may propagate across institutional deployments, posing systemic risks to medical AI. At the same time, prompt-space repair suppresses backdoor behavior more consistently than generic input preprocessing while largely preserving clean performance. These contributions position BAPLe++ as a step toward the trustworthy and secure adoption of Med-FMs in clinical practice.

Our contributions are threefold:

  • We are the first to examine whether backdoors introduced via prompt learning in one Med-FM persist when transferred to and evaluated on other Med-FMs. To quantify this effect, we introduce two metrics: Clean Accuracy Difference (CAD), which measures the change in clean performance after prompt transfer, and Backdoor Accuracy Difference (BAD), which measures how much attack success is retained when moving from the source to the target Med-FM.

  • We propose DePLe, a parameter-efficient defense that learns robust prompts using the backdoor-infected prompts as fixed anchors, which mitigates backdoor behavior without modifying the frozen Med-FM backbone.

  • We provide a systematic evaluation of prompt-based backdoor attacks and defenses across four Med-FMs (MedCLIP, BioMedCLIP, PLIP, and QuiltNet) and six chest X-ray and histopathology datasets, benchmarking our defense against four training-free input transformations (Gaussian Blur, JPEG-30, Feature Squeeze, and Pixel Deflection). We find that (i) prompt-based backdoors transfer across Med-FMs, but asymmetrically and in a dataset-dependent manner, (ii) prompt-space repair reduces backdoor accuracy more consistently than input transformations while preserving clean accuracy, and (iii) input transformations trade clean accuracy for robustness in ways that vary strongly across models and datasets.

Related Work

Medical Foundation Models

Medical Foundation Models (Med-FMs) have become central to modern medical image analysis, offering transferable representations that reduce the reliance on large, task-specific annotated datasets. By pre-training on large-scale medical image-text corpora, these models are able to generalize across diverse downstream tasks such as disease classification, lesion detection, and pathology recognition. Among the most influential, MedCLIP (Wang et al., [18]) adapts the CLIP (Radford et al., [15]) framework to chest X-rays, aligning radiology reports with image features for zero-shot classification. BioMedCLIP (Zhang et al., [19]) extended this approach by training on millions of medical image-caption pairs, significantly improving cross-modal transfer. In the histopathology domain, PLIP (Huang et al., [6]) and QuiltNet (Ikezogwo et al., [7]) introduced pre-training strategies tailored for cell and tissue-level analysis. These advances demonstrate the versatility and clinical utility of Med-FMs across imaging modalities.

Prompt Learning

Prompt learning has emerged as an effective alternative to full fine-tuning, enabling efficient adaptation of foundation models while keeping model backbone parameters frozen. Methods such as CoOp (Zhou et al., [20]) demonstrated that learning a set of tunable prompt tokens can effectively adapt vision-language models such as CLIP (Radford et al., [15]). This prompt-learning paradigm was subsequently transferred to the medical domain, leading to models such as MedCLIP (Wang et al., [18]) and PLIP (Huang et al., [6]). Despite their efficiency, the reliance on frozen encoders and parameter-efficient adaptation mechanisms such as prompt learning introduces new security risks, making medical foundation models particularly vulnerable to adversarial manipulation.

Backdoor Attacks

Backdoor attacks aim to implant hidden behaviors into models such that clean inputs behave normally, but the presence of a trigger causes targeted misclassification. Early work such as BadNets (Gu et al., [4]) showed how simple patch triggers could compromise classifiers, followed by Trojaning attacks (Liu et al., [12]) and WaNet (Nguyen & Tran, [13]) which improved stealth and generalizability. In the medical domain, FIBA (Feng et al., [2]) introduced backdoors tailored to medical images, while BadCLIP (Liang et al., [11]) extended the idea to vision-language models by coupling image triggers with prompt embeddings. In medical imaging, BAPLe (Hanif et al., [5]) was the first to demonstrate that prompt learning, while effective in few-shot settings, can also serve as an attack surface, allowing backdoors to be injected via learnable prompts under data-scarce conditions.

Adversarial Transferability and Defense

Adversarial transferability, where perturbations crafted on one model fool another, is well studied in vision networks (Khan et al., [10]). Optimizations such as RAP (Qin et al., [14]; Khan et al., [10]) and GRA (Zhu et al., [21]) improve transfer across architectures by reshaping the loss landscape and the gradient signal used to craft perturbations. Whether the same effect arises in the backdoor setting, where the transferred artifact is a learned prompt rather than an input perturbation, has not been examined for medical foundation models. In that setting, many practical defenses remain training-heavy or architecture-specific. By contrast, test-time preprocessing defenses such as blur, compression, and filtering are attractive because they are easy to deploy, but their robustness/utility trade-offs for Med-FMs remain poorly understood.

Method

Preliminaries

Zero-Shot Classification for Med-FM

Since Med-FMs, particularly vision-language models (VLMs), are pre-trained to align images with corresponding textual descriptions, they are inherently suited for zero-shot classification tasks. Zero-shot inference in VLMs refers to making predictions on new, unseen data without specific training. We denote a VLM by fθ={fI,fT}f_\theta=\{f_I,f_T\}, where fIf_I and fTf_T are the image and text encoders, respectively. For classification in zero-shot scenario, the image xx is first passed to the image encoder fIf_I, resulting in a dd-dimensional feature vector fI(x)∈Rdf_I(x)\in\mathbb{R}^d. Similarly, on the text encoder side, each class label yi∈{y1,y2,…,yC}y_i\in\{y_1,y_2,\ldots,y_C\} is wrapped within the class-specific text template, such as:

t_i=\text{“A histopathology image of \{i\textsuperscript{th} CLASS NAME\}”.}

Each text prompt (ti)(t_i) is fed to the text encoder fTf_T, yielding text feature vector fT(ti)∈Rdf_T(t_i)\in\mathbb{R}^d. The relationship between the image’s feature vector and the text prompt feature vector is quantified using cosine similarity, sim⁡(fI(x),fT(ti))\operatorname{sim}(f_I(x),f_T(t_i)), to evaluate the image’s alignment with iith class. Class with the highest similarity score is selected as the predicted class label y^\hat{y}, i.e.

y^=argmax⁡i∈{1,2,…,C} sim⁡(fI(x),fT(ti)).\hat{y}=\underset{i\in\{1,2,\ldots,C\}}{\operatorname{argmax}}\ \operatorname{sim}(f_I(x),f_T(t_i)).

Prompt Learning

Textual class descriptions are central to zero-shot inference in VLMs, but manually crafted prompts can lead to performance variability and sensitivity. Prompt learning addresses this by introducing auxiliary learnable parameters pp on top of the text encoder fTf_T, optimized in few-shot settings to steer the frozen model’s response and reduce manual engineering [20]. Formally, prompt learning methods optimize pp to enhance downstream performance and generalization:

minimize⁡p ∑(x,y)∈DL(f(x;p),y),(1)\underset{p}{\operatorname{minimize}}\ \sum_{(x,y)\in\mathcal{D}}\mathcal{L}(f(x;p),y), \tag*{(1)}

where (x,y)(x,y) represents an image-label pair from few-shot training dataset D\mathcal{D}, f(x;p)f(x;p) denotes the model’s prediction conditioned on the learnable prompt parameters pp, and L(⋅)\mathcal{L}(\cdot) is the task-specific loss function.

Backdoor Attack

A backdoor attack involves embedding a visible/hidden trigger (a small random or patterned patch) within a deep learning model during its training or fine-tuning phase. When the model encounters this trigger in the input data during inference, it produces a predefined output while performing normally on clean data. In a supervised classification task, a normally trained classifier fθ:X→Yf_\theta:\mathcal{X}\to\mathcal{Y} maps a clean input image x∈X\mathbf{x}\in\mathcal{X} to a label y∈Yy\in\mathcal{Y}. Parameters θ\theta are learned from a training dataset D={xi,yi}i=1N\mathcal{D}=\{x_i,y_i\}_{i=1}^{N} where xi∈Xx_i\in\mathcal{X} and yi∈Yy_i\in\mathcal{Y}. In a typical backdoor attack, the training dataset D\mathcal{D} is split into clean Dc\mathcal{D}_c and poison subsets Dp\mathcal{D}_p, where ∣Dp∣≪N|\mathcal{D}_p|\ll N. In Dp\mathcal{D}_p, each sample (x,y)(x,y) is transformed into a backdoor sample (B(x),η(y))(\mathcal{B}(x),\eta(y)), where B:X→X\mathcal{B}:\mathcal{X}\to\mathcal{X} is the backdoor injection function and η\eta denotes the target label function. During the training/fine-tuning phase of backdoor attacks, the victim classifier fθf_\theta is trained/fine-tuned on a mix of the clean dataset Dc\mathcal{D}_c and the poisoned dataset Dp\mathcal{D}_p. Formally, this task can be formulated as the following objective function:

min⁡θ ∑(x,y)∈DcL(fθ(x),y)+∑(x,y)∈DpL(fθ(B(x)),η(y)),(2)\min_{\theta}\ \sum_{(x,y)\in\mathcal{D}_c}\mathcal{L}(f_\theta(x),y)+\sum_{(x,y)\in\mathcal{D}_p}\mathcal{L}(f_\theta(\mathcal{B}(x)),\eta(y)), \tag*{(2)}

where L(⋅)\mathcal{L}(\cdot) denotes the cross-entropy loss. After training, fθf_\theta behaves similarly on clean input x\mathbf{x} as the original classifier (trained entirely on clean data), yet alters its prediction for the backdoor image B(x)\mathcal{B}(\mathbf{x}) to the target class η(y)\eta(y), i.e. fθ(x)→yf_\theta(\mathbf{x})\to y and fθ(B(x))→η(y)f_\theta(\mathcal{B}(\mathbf{x}))\to\eta(y).

Threat Model

We describe the objectives and capabilities of the attacker and the defender.

Attacker’s Objective and Capabilities

The attacker aims to embed a targeted backdoor into a Med-FM during downstream adaptation, so that the adapted model behaves normally on clean inputs but predicts an attacker-chosen target class whenever a trigger is present. The backdoor must remain stealthy under standard validation, which relies only on clean data. Following prior work on medical backdoor attacks [2], we assume the attacker can poison only a small fraction of the downstream training data and can apply the trigger to inputs at inference time. Because annotated medical data are scarce and the attacker is computationally limited, full fine-tuning of the Med-FM is impractical.

The attacker therefore exploits prompt learning, which changes model behavior while keeping the backbone frozen. We consider two realistic scenarios. In the first, the attacker acts as a malicious service provider: a user supplies clean labeled data and receives a task-specific prompt that has been backdoored during training. In the second, the attacker distributes backdoored prompts through public repositories (e.g., Hugging Face), where users may integrate them with their own Med-FMs. In both cases, the backdoor is introduced through the prompt, allowing the attacker to compromise deployments without modifying model weights or accessing private training pipelines.

Defender’s Objective and Capabilities

The defender aims to deploy a Med-FM safely for a downstream medical task, preserving high clean accuracy while preventing triggered inputs from being steered to the target class. The defense must work under the same clinical constraints as adaptation itself, namely limited labeled data and a frozen backbone. We assume the defender has access to the pre-trained Med-FM, the deployment prompt, which may be compromised, and a small clean labeled set for the task. Like the attacker, the defender cannot retrain or modify the backbone.

Since the backdoor is introduced through the prompt rather than the model weights, the defender operates entirely at the prompt level. Instead of discarding the suspect prompt or retraining the model, the defender learns a new prompt that preserves clean-task utility while suppressing backdoor Algorithm 1 BAPLe - Backdoor Attack via Prompt Learning

  1. Notations NumSamples=NN, BatchSize=BB, NumBatches=⌊N/B⌋\lfloor N/B \rfloor, Train Dataset: D={(xi,yi)}i=1N\mathcal{D} = \{(x_i, y_i)\}_{i=1}^{N}, Vision and Text Encoders: fI,fTf_I, f_T, Image: x∈Rh×wx \in\mathbb{R}^{h \times w}, Learnable Trigger Noise: δ∈Rh×w\delta\in\mathbb{R}^{h \times w}, Perturbation Budget: ϵ\epsilon, Backdoor Patch: pbdp_{\mathrm{bd}}, Backdoor Injection Function: B(x)=(x+δ)⊕pbdB(x) = (x + \delta) \oplus p_{\mathrm{bd}}, Target Label Function: η(⋅)\eta(\cdot), Learnable Prompt Context: pp, Number of Classes: cc, Text Prompts: t={t1,t2,…,tc}t = \{t_1, t_2, \ldots, t_c\} where ti=[p;yi]t_i = [p; y_i], Cosine Similarity Function: sim⁡(⋅)\operatorname{sim}(\cdot)

  2. for i←1i \leftarrow1 to NumEpochs do

  3.     for j←1j \leftarrow1 to NumBatches do

  4.         Sample clean and poisoned mini-batch: Dc⊂D\mathcal{D}_c \subset\mathcal{D}, Dp⊂D\mathcal{D}_p \subset\mathcal{D}

  5.         fθ(x)={sim⁡(fI(x),fT(ti))}i=1c∈Rcf_\theta(x) = \{\operatorname{sim}(f_I(x), f_T(t_i))\}_{i=1}^{c} \in\mathbb{R}^{c} ▷ Prediction scores on clean images

  6.         fθ(B(x))={sim⁡(fI(B(x)),fT(ti))}i=1c∈Rcf_\theta(B(x)) = \{\operatorname{sim}(f_I(B(x)), f_T(t_i))\}_{i=1}^{c} \in\mathbb{R}^{c} ▷ Prediction scores on poisoned images

  7.         L=E(x,y)∼Dc[Lce(fθ(x),y)]+E(x,y)∼Dp[Lce(fθ(B(x)),η(y))]\mathcal{L} = \mathbb{E}_{(x,y)\sim\mathcal{D}_c}[\mathcal{L}_{\mathrm{ce}}(f_\theta(x), y)] + \mathbb{E}_{(x,y)\sim\mathcal{D}_p}[\mathcal{L}_{\mathrm{ce}}(f_\theta(B(x)), \eta(y))] ▷ Compute cross-entropy loss on the mini-batch

  8.         p←p−α⋅∇pLp \leftarrow p - \alpha\cdot\nabla_p \mathcal{L} ▷ Update prompt parameters

  9.         δ←δ−β⋅∇δL\delta\leftarrow\delta- \beta\cdot\nabla_\delta\mathcal{L} ▷ Update trigger noise

  10.         δ←clamp⁡(δ,min⁡=−ϵ,max⁡=+ϵ)\delta\leftarrow\operatorname{clamp}(\delta, \operatorname{min}=-\epsilon, \operatorname{max}=+\epsilon) ▷ Apply budget on noise

  11.     end for

  12. end for

behavior, using the suspect prompt as a reference for the compromised region of the embedding space.

Backdoor Attack using Prompt Learning (BAPLe)

BAPLe (Hanif et al. [5]), as shown in Figure 1(a), is a backdoor attack method that exploits the multimodal nature of medical vision-language models (Med-VLMs). For computational efficiency, it injects a small set of learnable parameters (text prompts) into the input space of the model’s text encoder while keeping the backbone frozen during training on a poisoned downstream dataset. The prompt-based mechanism is particularly well suited to few-shot settings: by tailoring the input space, it enables a Med-FM to leverage pretrained multimodal knowledge for data-scarce tasks without requiring extensive retraining or large medical datasets. To further increase attack effectiveness, the method also adds imperceptible and learnable noise as a backdoor trigger to the input images, which subtly increases the model’s sensitivity to backdoor activation. By combining learnable text prompts in the text encoder with an imperceptible image trigger, this approach takes advantage of the full multimodal capabilities of Med-VLMs.

Figure 1. Overview of BAPLe++. (a) Backdoor Attack: a learnable prompt context and an imperceptible noise trigger δ\delta are jointly optimized while both encoders remain frozen, so that triggered inputs are steered toward the target label η(y)\eta(y). (b) Cross-model Transferability: the noise δs\delta_s and prompt psp_s learned on a source Med-FM fsf_s are transferred, unchanged, to a target Med-FM ftf_t, and transferability is measured with CAD and BAD. (c) Defense: the infected prompts p′p' are kept as fixed anchors, and robust prompts probustp^{\mathrm{robust}} are learned by minimizing Lce−Lfd\mathcal{L}_{ce}-\mathcal{L}_{fd}, which preserves clean-task alignment while pushing the prompts away from the compromised embedding region. Without the defense, a triggered input is classified as the backdoor label; after sanitization, it is assigned the true label. The Med-FM backbone remains frozen throughout

Zero-shot inference in a Med-FM depends on hand-engineered text prompts, and prompt learning therefore replaces fixed templates with a small set of learnable token embeddings pp. For cc classes we form class-specific text inputs t={t1,…,tc}t = \{t_1, \ldots, t_c\} where ti=[p;yi]t_i = [p; y_i], i.e., learnable prompt context is prepended to the class names in the input token embedding space. Denote the frozen image and text encoders by fI(⋅)f_I(\cdot) and fT(⋅)f_T(\cdot) and a similarity scoring function by sim⁡(⋅,⋅)\operatorname{sim}(\cdot,\cdot). The model logit vector on a clean image xx and on a backdoored image B(x)B(x) are written compactly as

fθ(x;p)={sim⁡(fI(x),fT(ti))}i=1c,fθ(B(x);p)={sim⁡(fI(B(x)),fT(ti))}i=1c.(3)f_\theta(x;p) = \{\operatorname{sim}(f_I(x), f_T(t_i))\}_{i=1}^{c}, \qquad f_\theta(B(x);p) = \{\operatorname{sim}(f_I(B(x)), f_T(t_i))\}_{i=1}^{c}. \tag*{(3)}

To inject a backdoor, BAPLe jointly optimizes learnable prompt tokens pp and an imperceptible noise trigger δ\delta via a bi-objective that balances clean utility and targeted misclassification:

min⁡p,δ∑(x,y)∈DcL(fθ(x;p),y)+∑(x,y)∈DpL(fθ(B(x);p),η(y)),\min_{p,\delta} \sum_{(x,y)\in\mathcal{D}_c} \mathcal{L}(f_\theta(x;p), y) + \sum_{(x,y)\in\mathcal{D}_p} \mathcal{L}(f_\theta(B(x);p), \eta(y)),
s.t. ∥δ∥∞≤ϵ,B(x)=(x+δ)⊕pbd.(4)\text{s.t. } \lVert\delta\rVert_\infty\le\epsilon,\qquad B(x) = (x+\delta)\oplus p_{\mathrm{bd}}. \tag*{(4)}

Here Dc\mathcal{D}_c and Dp\mathcal{D}_p are the clean and poisoned data subsets, η(⋅)\eta(\cdot) maps labels to the attacker-chosen target, pbdp_{\mathrm{bd}} denotes an optional spatial patch (logo) and ⊕\oplus denotes the operation that inserts/combines the patch with the image. Note that both the image and text encoders remain frozen during optimization of Equation (4); only pp and δ\delta are updated. Algorithm 1 outlines the attack steps.

Cross-Model Transferability

To evaluate whether backdoors implanted in one Med-FM can persist when transferred to another, we study cross-model transferability. In this setting, an attacker first learns prompts psp_s and a noise trigger δs\delta_s on a source model fsf_s. These artifacts are then applied directly, without re-optimization, to a different target model ftf_t during inference. This setup reflects realistic scenarios where compromised prompts or triggers may propagate across institutions employing distinct Med-FMs. We quantify transferability using two metrics: Clean Accuracy Difference (CAD) and Backdoor Accuracy Difference (BAD). Given a test set DtestD_{\mathrm{test}}, CAD measures the change in clean performance of the target model after transferring the learned text prompt from source model fsf_s, while BAD measures the change in backdoor success rate when transferring both the prompt psp_s and trigger δs\delta_s from source model fsf_s to target model ftf_t. Formally, CAD and BAD are defined as follows:

CAD=E(x,y)∼Dtest1(ft(x;pt)=y)−E(x,y)∼Dtest1(ft(x;ps)=y),(5)\mathrm{CAD} = \mathbb{E}_{(x,y)\sim D_{\mathrm{test}}} \mathbf{1}\left(f_t(x;p_t)=y\right) - \mathbb{E}_{(x,y)\sim D_{\mathrm{test}}} \mathbf{1}\left(f_t(x;p_s)=y\right), \tag*{(5)}
BAD=E(x,y)∼Dtest1(ft(x+δt;pt)=η(y))−E(x,y)∼Dtest1(ft(x+δs;ps)=η(y)),(6)\mathrm{BAD} = \mathbb{E}_{(x,y)\sim D_{\mathrm{test}}} \mathbf{1}\left(f_t(x+\delta_t;p_t)=\eta(y)\right) - \mathbb{E}_{(x,y)\sim D_{\mathrm{test}}} \mathbf{1}\left(f_t(x+\delta_s;p_s)=\eta(y)\right), \tag*{(6)}

where psp_s and ptp_t denote prompts learned from the source and target models, δs\delta_s and δt\delta_t are their respective triggers, η(y)\eta(y) represents the attacker-chosen target label, and 1(⋅)\mathbf{1}(\cdot) is indicator function. An overview of cross-model transferability is shown in Figure 1(b). For a highly transferable attack, both CAD and BAD should be close to zero. A near-zero CAD means clean accuracy is preserved when a backdoored prompt is transferred from the source to the target model. A near-zero BAD means the backdoor remains equally effective, so source-infected prompts trigger the target model as strongly as prompts optimized directly on it.

Defense via Prompt Learning (DePLe)

Since the backdoor resides in the learned prompt rather than in the model weights, we mitigate it at the prompt level. The Med-FM backbone stays frozen, and the defender has only a small clean labeled set DcD_c. Rather than discarding the potentially infected prompt p′p', we keep it as a fixed anchor that marks a compromised region of the text-embedding space. During the attack, p′p' is optimized jointly with the trigger δ\delta, so its class embeddings fT(ti′)f_T(t'_i) are positioned such that triggered image features align with the target class. We therefore learn a freshly initialized prompt pp on DcD_c while pushing its class embeddings away from those induced by p′p'. This retains clean-task semantics while discouraging the prompt from re-learning the trigger-aligned configuration. Formally, with ti=[p;yi]t_i=[p;y_i] and ti′=[p′;yi]t'_i=[p';y_i], we define a clean-task loss and a feature-divergence term:

Lce=E(x,y)∼DcCrossEntropy⁡(fI(x;p),y),Lfd=1c∑i=1c∥fT(ti′)−fT(ti)∥22,(7)\mathcal{L}_{\mathrm{ce}} = \mathbb{E}_{(x,y)\sim D_c} \operatorname{CrossEntropy}\left(f_I(x;p),y\right), \qquad\mathcal{L}_{\mathrm{fd}} = \frac{1}{c}\sum_{i=1}^{c}\left\lVert f_T(t'_i)-f_T(t_i)\right\rVert_2^2, \tag*{(7)}

where fT(⋅)f_T(\cdot) returns ℓ2\ell_2-normalized embeddings, so Lfd\mathcal{L}_{\mathrm{fd}} is bounded. The robust prompt context is obtained by solving the following objective. A high-level overview of the proposed defense is shown in Figure 1(c).

probust=arg⁡min⁡pLce−Lfd.(8)p^{\mathrm{robust}} = \arg\min_p \mathcal{L}_{\mathrm{ce}}-\mathcal{L}_{\mathrm{fd}}. \tag*{(8)}

Experimental Setup

Implementation Details

All experiments were conducted on a single NVIDIA RTX 3090Ti GPU with 24 GB of memory. We adopt a 32-shot setting, selecting 32 random samples per class, and use a batch size of 16. For prompt-based training, we set the learning rate to 2×10−22 \times10^{-2}. A poisoning rate of 5% was applied across all datasets. The learnable noise trigger is bounded by an ℓ∞\ell_\infty budget of ϵ=8/255\epsilon= 8/255, and a fixed backdoor patch of size 24×2424 \times24 is inserted at the bottom-left corner of each image. Each class is considered as a possible attack target, and final results are averaged across all target classes to ensure fairness in evaluation.

Datasets

We conduct experiments across six benchmark medical imaging datasets spanning both radiology and histopathology domains. For radiology, we utilize COVID ([16]), a chest X-ray dataset for COVID-19 detection, RSNA18 ([17]), a large-scale chest X-ray dataset for pneumonia classification, and MIMIC ([8]), a clinically curated chest X-ray dataset (single-label samples only). For histopathology, we include Kather ([9]), a dataset for colorectal cancer tissue classification, PanNuke ([3]), a pan-cancer nuclei classification dataset, and DigestPath ([1]), which focuses on digestive system pathology for tumor detection. These datasets span two imaging modalities (radiology and pathology) and provide a comprehensive testbed for studying both attack persistence and defense effectiveness.

Medical Foundation Models (Med-FMs)

We evaluate four representative Med-FMs that are widely used in the literature. MedCLIP ([18]) leverages contrastive learning on chest X-rays and radiology reports, while BioMedCLIP ([19]) is pretrained on the large-scale PMC-15M image-text pairs. For histopathology, PLIP ([6]) is a pathology-focused foundation model trained on extensive histopathology corpora, and QuiltNet ([7]) is a recent pathology vision-language model designed with improved patch-level alignment. All models adopt the CLIP-style dual-encoder architecture, where the backbones remain frozen and only prompt embeddings are trained during adaptation.

Metrics

We report four metrics. Clean Accuracy (CA) is the classification accuracy on unperturbed test samples and reflects the model’s utility for normal clinical use. Backdoor Accuracy (BA) is the fraction of triggered test inputs classified as the attacker-specified target class; test samples whose true label is the target class are excluded. A high BA indicates a successful attack, and a reduction in BA after a defense indicates effective mitigation. Two difference-based metrics quantify cross-model transferability. Clean Accuracy Difference (CAD) is the gap in clean accuracy on the target model between prompts learned directly on it and prompts transferred from the source model (Equation (5)); a small CAD indicates that clean performance is preserved under transfer. Backdoor Accuracy Difference (BAD) is the corresponding gap in BA between target-learned and source-transferred attacks (Equation (6)); a small BAD indicates that the backdoor remains effective after transfer.

Results and Discussion

Backdoor Attack Results

The results in Table 1 focus on the prompt-learning setting, where the backbone encoders remain frozen and only the prompts are adapted. Compared to the clean prompt baseline, existing backdoor attacks such as BadNets, WaNet, and FIBA exhibit mixed performance, with modest gains in backdoor accuracy (BA) but generally inconsistent behavior across different datasets and models. In contrast, BAPLe consistently achieves near-perfect BA (often above 0.95) across MedCLIP, BioMedCLIP, PLIP, and QuiltNet, while maintaining clean accuracy (CA) at levels comparable to the clean baseline. This demonstrates that BAPLe is effective at embedding backdoors without noticeably degrading performance on unperturbed samples.

MethodMedCLIP COVID CAMedCLIP COVID BAMedCLIP RSNA18 CAMedCLIP RSNA18 BAMedCLIP MIMIC CAMedCLIP MIMIC BABioMedCLIP COVID CABioMedCLIP COVID BABioMedCLIP RSNA18 CABioMedCLIP RSNA18 BABioMedCLIP MIMIC CABioMedCLIP MIMIC BA
Clean0.822–0.603–0.585–0.843–0.582–0.351–
BadNets0.8200.5100.6190.3730.5590.2840.8450.9750.6320.9420.3731.000
WaNet0.8310.4700.6120.3190.5870.2660.8390.5990.5870.5100.3340.599
FIBA0.8200.5110.6230.3600.5620.2920.8560.7290.6300.6140.3730.722
BAPLe†0.8130.9960.6100.9950.4720.9910.8411.0000.6360.9990.3680.996
MethodPLIP Kather CAPLIP Kather BAPLIP PanNuke CAPLIP PanNuke BAPLIP DigestPath CAPLIP DigestPath BAQuiltNet Kather CAQuiltNet Kather BAQuiltNet PanNuke CAQuiltNet PanNuke BAQuiltNet DigestPath CAQuiltNet DigestPath BA
Clean0.908–0.811–0.920–0.899–0.829–0.906–
BadNets0.9030.6010.7990.7480.9220.6230.8980.1510.6990.7570.8740.518
WaNet0.9100.2430.8510.5910.9240.4050.9260.1850.8340.4270.9150.492
FIBA0.9010.3030.7950.6150.9210.5530.8970.1740.7110.5970.8620.547
BAPLe†0.8780.9820.8340.9640.9020.9680.8930.9550.8100.9050.9030.820

Table 1. Clean accuracy (CA) and backdoor accuracy (BA) of BAPLe and backdoor-attack baselines under 32-shot prompt learning with frozen backbones. Clean, BadNets, WaNet, and FIBA results are taken from BAPLe Hanif et al. [5]; †BAPLe results are reproduced in our setup. Clean is a prompt trained without poisoning, for which BA is not defined (–). Results are averaged over all target classes, and the best BA in each column is shown in bold. BAPLe achieves the highest BA in nearly all settings while keeping CA close to the clean prompt in most cases.

These results highlight prompt learning as an effective attack surface. Whereas the baselines rely on fixed perturbations, BAPLe jointly learns the noise trigger and the prompt alongside a patch trigger, allowing the backdoor to be implanted reliably while the encoders remain frozen. Since backdoors can thus remain hidden in prompt embeddings, settings where prompts or adapters are shared across medical AI pipelines are at risk, which calls for defenses that target the prompt space rather than only model weights. To better understand how the attack operates, we examine the learned trigger and its effect on the image feature space. Figure 3 visualizes the trigger noise δ\delta learned by BAPLe for each model–dataset pair; under the ℓ∞\ell_{\infty} budget, the noise remains visually imperceptible across both modalities. Figure 4 shows t-SNE embeddings of image features on clean and triggered inputs. Adding the trigger shifts and reorganizes the class clusters, but the triggered features do not collapse into a single target-class cluster. This differs from conventional backdoors, where poisoned samples typically form a distinct, separable cluster in feature space. A likely explanation is that in BAPLe, target-class alignment is realized jointly through the learned prompt in the text-embedding space, so the image features alone need not collapse. This also suggests that feature-clustering defenses that inspect only image features may be less effective against prompt-based backdoors.

Visualization of learnable trigger noise after BAPLe across histopathology and radiology datasets

Figure 3. Visualization of learnable trigger noise (δ\delta) after BAPLe across histopathology and radiology datasets

t-SNE plots illustrating the features of clean and backdoored images

Figure 4. t-SNE plots illustrating the features of (a) clean images, and (b) backdoored images. The features in (b) display a notable shift in orientation and a reformation of clusters compared to those in (a). Each color represents the same class in both plots

Cross-Model Transferability

Figure 2 reports CAD and BAD for both transfer directions, where a small BAD indicates that the backdoor remains nearly as effective after transfer. On radiology, transfer is strongly asymmetric. Backdoors from MedCLIP remain almost fully effective on BioMedCLIP (BAD < 0.1), but weaken considerably in the reverse direction. Between PLIP and QuiltNet, transfer is roughly symmetric and dataset-dependent. It is weakest on Kather and strongest on DigestPath, where BAD is near zero despite substantial CAD.

Figure 2. Average Clean Accuracy Difference (CAD) and Backdoor Accuracy Difference (BAD) across datasets, measuring cross-model transferability between foundation models

These results show that prompt-space backdoors do transfer across Med-FMs, often with little loss of attack strength. This supports the concern that compromised prompts shared through public repositories may propagate across institutions. Transfer is not uniform, however, since it depends on the direction, the dataset, and the source backbone. Cross-model risk is therefore real but uneven, which motivates repairing the compromised prompt itself rather than relying on assumptions about how it will transfer.

Defense Results

Tables Table 2 and Table 3 compare the proposed defense (DePLe) with four training-free test-time transformations across all twelve dataset–model pairs under BAPLe attack. On the X-ray datasets, DePLe provides the best overall robustness-utility trade-off. It achieves the lowest backdoor accuracy (BA) in nearly every setting while keeping clean accuracy (CA) close to the no-defense baseline. The gap is most pronounced for MedCLIP on COVID, where DePLe reduces BA to 0.051, whereas no input transformation brings it below 0.52. The only exception is MedCLIP on RSNA18. There, Pixel Deflection lowers BA marginally further, but at the cost of nearly halving clean accuracy. More generally, the strongest transformations reduce BA only partially and noticeably degrade CA. On MIMIC, the low CA of BioMedCLIP is inherent to the task, since even the clean prompt reaches only 0.351 (Table 1). For MedCLIP, part of the drop is caused by the attack itself, and DePLe recovers some of it.

DefenseMedCLIP COVID CAMedCLIP COVID BAMedCLIP RSNA18 CAMedCLIP RSNA18 BAMedCLIP MIMIC CAMedCLIP MIMIC BABioMedCLIP COVID CABioMedCLIP COVID BABioMedCLIP RSNA18 CABioMedCLIP RSNA18 BABioMedCLIP MIMIC CABioMedCLIP MIMIC BA
Without Defense (BAPLe)0.8130.9960.6100.9950.4720.9910.8411.0000.6360.9990.3680.996
Gaussian Blur0.820 ↑0.0070.599 ↓0.3970.599 ↓0.0110.518 ↓0.4770.470 ↓0.0020.556 ↓0.4350.819 ↓0.0220.914 ↓0.0860.600 ↓0.0360.733 ↓0.2660.353 ↓0.0150.821 ↓0.175
JPEG-300.796 ↓0.0170.551 ↓0.4450.590 ↓0.0200.460 ↓0.5350.460 ↓0.0120.503 ↓0.4880.738 ↓0.1030.884 ↓0.1160.576 ↓0.0600.794 ↓0.2050.328 ↓0.0400.837 ↓0.159
Feature Squeeze (MF-3)0.789 ↓0.0240.522 ↓0.4740.603 ↓0.0070.657 ↓0.3380.462 ↓0.0100.587 ↓0.4040.849 ↑0.0080.973 ↓0.0270.631 ↓0.0050.964 ↓0.0350.368 ±0.0000.965 ↓0.031
Pixel Deflection0.662 ↓0.1510.638 ↓0.3580.343 ↓0.2670.318 ↓0.6770.325 ↓0.1470.476 ↓0.5150.491 ↓0.3500.568 ↓0.4320.407 ↓0.2290.514 ↓0.4850.225 ↓0.1430.539 ↓0.457
DePLe (Ours)0.833 ↑0.0200.051 ↓0.9450.680 ↑0.0700.334 ↓0.6610.505 ↑0.0330.192 ↓0.7990.834 ↓0.0070.544 ↓0.4560.577 ↓0.0590.308 ↓0.6910.359 ↓0.0090.425 ↓0.571

Table 2. Defense results on backdoored (using BAPLe attack) chest X-ray models, averaged over all target classes; higher CA and lower BA are better. Small numbers show the change from Without Defense (green: better, red: worse), and bold marks the best defense per column. DePLe gives the lowest BA in nearly all settings while largely preserving CA, whereas input transformations reduce BA only partially and often lower CA.

DefensePLIP Kather CAPLIP Kather BAPLIP PanNuke CAPLIP PanNuke BAPLIP DigestPath CAPLIP DigestPath BAQuiltNet Kather CAQuiltNet Kather BAQuiltNet PanNuke CAQuiltNet PanNuke BAQuiltNet DigestPath CAQuiltNet DigestPath BA
Without Defense (BAPLe)0.8780.9820.8340.9640.9020.9680.8930.9550.8100.9050.9030.820
Gaussian Blur0.859 ↓0.0190.662 ↓0.3200.825 ↓0.0090.864 ↓0.1000.892 ↓0.0100.887 ↓0.0810.882 ↓0.0110.543 ↓0.4120.810 ±0.0000.833 ↓0.0720.908 ↑0.0050.711 ↓0.109
JPEG-300.846 ↓0.0320.555 ↓0.4270.827 ↓0.0070.742 ↓0.2220.749 ↓0.1530.874 ↓0.0940.775 ↓0.1180.453 ↓0.5020.723 ↓0.0870.687 ↓0.2180.920 ↑0.0170.602 ↓0.218
Feature Squeeze (MF-3)0.857 ↓0.0210.819 ↓0.1630.829 ↓0.0050.918 ↓0.0460.882 ↓0.0200.937 ↓0.0310.893 ±0.0000.775 ↓0.1800.791 ↓0.0190.865 ↓0.0400.894 ↓0.0090.736 ↓0.084
Pixel Deflection0.259 ↓0.6190.426 ↓0.5560.610 ↓0.2240.966 ↑0.0020.539 ↓0.3630.998 ↑0.0300.563 ↓0.3300.465 ↓0.4900.738 ↓0.0720.795 ↓0.1100.492 ↓0.4110.991 ↑0.171
DePLe (Ours)0.943 ↑0.0650.212 ↓0.7700.837 ↑0.0030.466 ↓0.4980.907 ↑0.0050.369 ↓0.5990.962 ↑0.0690.666 ↓0.2890.869 ↑0.0590.516 ↓0.3890.905 ↑0.0020.664 ↓0.156

Table 3. Defense results on backdoored histopathology models (conventions as in Table 2). DePLe gives the lowest BA in most settings and improves CA throughout, whereas input transformations vary across models and datasets.

A similar pattern holds on histopathology. DePLe achieves the lowest BA in four of the six settings, with the largest reductions for PLIP on Kather and DigestPath, and it matches or improves CA in all six. Input transformations are far less predictable: Pixel Deflection severely degrades CA and even increases BA in some cases, while Gaussian Blur and Feature Squeeze leave BA largely intact on PanNuke and DigestPath. DePLe is outperformed only on QuiltNet. On DigestPath, JPEG-30 attains both lower BA and higher CA. On Kather, several transformations attain lower BA but reduce CA, whereas DePLe improves it. DePLe provides the most consistent defense across models and datasets, while training-free transformations remain useful when the defender cannot update prompts or lacks clean few-shot data, though their effectiveness is strongly model and dataset dependent.

In several settings, DePLe even exceeds the clean prompt’s CA, most notably on Kather for both PLIP and QuiltNet. This gain disappears when the infected-prompt anchor is removed and the prompt is trained with the cross-entropy loss alone, indicating that the improvement comes from the anchor rather than from retraining. We attribute this to the feature-divergence term acting as a regularizer: pushing the class embeddings away from the trigger-aligned configuration of the infected prompt yields embeddings that are better separated for the clean task.

Conclusion

We presented BAPLe++, which studies prompt-based backdoors in medical foundation models from two angles. First, using the proposed CAD and BAD metrics, we showed that backdoored prompts transfer across Med-FMs, often with little loss of attack strength, but asymmetrically and in a dataset-dependent manner, so compromised prompts can propagate across deployments. Second, we proposed DePLe, a parameter-efficient defense that uses the infected prompt as a fixed anchor to learn a robust prompt without modifying the frozen backbone. Across four Med-FMs and six chest X-ray and histopathology datasets, DePLe reduces backdoor accuracy more consistently than training-free input transformations while largely preserving clean accuracy. These results call for routine auditing of adapted prompts before clinical deployment. Future work will address adaptive attacks and vision-side and multimodal prompt learning.

References

  1. [1]Qian Da et al. Digestpath: A benchmark dataset with challenge review for the pathological detection and segmentation of digestive-system. Medical image analysis, 80, 2022.DOI
  2. [2]Yu Feng, Benteng Ma, Jing Zhang, Shanshan Zhao, Yong Xia, and Dacheng Tao. Fiba: Frequency-injection based backdoor attack in medical image analysis. In CVPR, 2022.arxiv.org/abs/2112.01148
  3. [3]Jevgenij Gamper, Navid Alemi Koohbanani, Ksenija Benet, Ali Khuram, and Nasir Rajpoot. Pan-nuke: an open pan-cancer histology dataset for nuclei instance segmentation and classification. In European congress on digital pathology, pp. 11–19. Springer, 2019.DOI
  4. [4]Tianyu Gu, Brendan Dolan-Gavitt, and Siddharth Garg. Badnets: Identifying vulnerabilities in the machine learning model supply chain. arXiv preprint arXiv:1708.06733, 2017.arxiv.org/abs/1708.06733
  5. [5]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, 2024.arxiv.org/abs/2408.07440
  6. [6]Zhi Huang, Federico Bianchi, Mert Yuksekgonul, Thomas J Montine, and James Zou. A visual-language foundation model for pathology image analysis using medical twitter. Nature medicine, 29(9):2307–2316, 2023.DOI
  7. [7]Wisdom Ikezogwo, Saygin Seyfioglu, Fatemeh Gezloo, Dylan Geva, Fatwir Sheikh Mohammed, Pavan Kumar Anand, Ranjay Krishna, and Linda Shapiro. Quilt-1m: One million image-text pairs for histopathology. Advances in neural information processing systems, 2023.
  8. [8]Alistair EW Johnson, Tom J Pollard, Nathaniel R Greenbaum, Matthew P Lungren, Chih-ying Deng, Yifan Peng, Zhiyong Lu, Roger G Mark, Seth J Berkowitz, and Steven Horng. Mimic-cxr-jpg, a large publicly available database of labeled chest radiographs. arXiv preprint arXiv:1901.07042, 2019.arxiv.org/abs/1901.07042
  9. [9]Jakob Nikolas Kather, Johannes Krisam, Pornpimol Charoentong, Tom Luedde, Esther Herpel, Cleo-Aron Weis, Timo Gaiser, Alexander Marx, Nektarios A Valous, Dyke Ferber, et al. Predicting survival from colorectal cancer histology slides using deep learning: A retrospective multicenter study. PLoS medicine, 16(1), 2019.DOI
  10. [10]Ufaq Khan, Umair Nawaz, Tooba T Sheikh, Asif Hanif, and Mohammad Yaqub. Guardian: Guarding against uncertainty and adversarial risks in robot-assisted surgeries. In International Workshop on Uncertainty for Safe Utilization of Machine Learning in Medical Imaging, 2024.DOI
  11. [11]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 CVPR, 2024.arxiv.org/abs/2311.12075
  12. [12]Yingqi Liu, Shiqing Ma, Yousra Aafer, Wen-Chuan Lee, Juan Zhai, Weihang Wang, and Xiangyu Zhang. Trojaning attack on neural networks. In 25th Annual Network And Distributed System Security Symposium (NDSS 2018). Internet Soc, 2018.DOI
  13. [13]Tuan Anh Nguyen and Anh Tuan Tran. Wanet - imperceptible warping-based backdoor attack. In ICLR, 2021.
  14. [14]Zeyu Qin, Yanbo Fan, Yi Liu, Li Shen, Yong Zhang, Jue Wang, and Baoyuan Wu. Boosting the transferability of adversarial attacks with reverse adversarial perturbation. Advances in neural information processing systems, 35, 2022.arxiv.org/abs/2210.05968
  15. [15]Alec Radford et al. Learning transferable visual models from natural language supervision. In ICML, 2021.arxiv.org/abs/2103.00020
  16. [16]Tawsifur Rahman, Amith Khandakar, Yazan Qiblawey, Anas Tahir, Serkan Kiranyaz, Saad Bin Abul Kashem, Mohammad Tariqul Islam, Somaya Al Maadeed, Susu M Zughaier, Muhammad Salman Khan, et al. Exploring the effect of image enhancement techniques on covid-19 detection using chest x-ray images. Computers in biology and medicine, 132:104319, 2021.DOI
  17. [17]Anouk Stein, Carol Wu, Chris Carr, George Shih, Jamie Dulkowski, Kalpathy, Leon Chen, Luciano Prevedello, Marc Kohli, Mark McDonald, Peter, Phil Culliton, Safwan Halabi, and Tian Xia. Rsna pneumonia detection challenge. https://kaggle.com/competitions/rsna-pneumonia-detection-challenge, 2018. Kaggle.
  18. [18]Zifeng Wang, Zhenbang Wu, Dinesh Agarwal, and Jimeng Sun. Medclip: Contrastive learning from unpaired medical images and text. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, 2022.arxiv.org/abs/2210.10163
  19. [19]Sheng Zhang et al. A multimodal biomedical foundation model trained from fifteen million image–text pairs. NEJM AI, 1(1), 2025. doi: 10.1056/AIoa2400640.DOI
  20. [20]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.DOI
  21. [21]Hegui Zhu, Yuchen Ren, Xiaoyan Sui, Lianping Yang, and Wuming Jiang. Boosting adversarial transferability via gradient relevance attack. In ICCV, 2023.DOI

Paper details

vlnc:W_vcjp5a4r
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 6

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents