Original: I N S EARCH OF S MOOTH M INIMA FOR P URIFYING B ACKDOOR IN D EEP N EURAL N ETWORKS
Revised: I N S EARCH OF S MOOTH M INIMA FOR P URIFYING B ACKDOOR IN D EEP N EURAL N ETWORKS

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: The success of a deep neural network (DNN) heavily relies on the details of the training scheme; e.g. , training data, architectures, hyper-parameters, etc.
Revised: The success of a deep neural network (DNN) heavily relies on the details of the training scheme; e.g. , training data, architectures, hyper-parameters, etc.

Original: Recent backdoor attacks suggest that an adversary can take advantage of such training details and compromise the integrity of DNN.
Revised: Recent backdoor attacks suggest that an adversary can take advantage of such training details and compromise the integrity of DNN.

Original: Our studies show that a backdoor model is usually optimized to a bad local minima , i.e. , sharper minima as compared to a benign model.
Revised: Our studies show that a backdoor model is usually optimized to a bad local minima , i.e. , sharper minima as compared to a benign model.

Original: Intuitively, backdoor can be purified by re-optimizing the model to a smoother minima through fine-tuning with a few clean validation data.
Revised: Intuitively, backdoor can be purified by re-optimizing the model to a smoother minima through fine-tuning with a few clean validation data.

Original: However, fine-tuning all DNN parameters often requires huge computational cost and often results in sub-par clean test performance.
Revised: However, fine-tuning all DNN parameters often requires huge computational cost and often results in sub-par clean test performance.

Original: To address this concern, we propose a novel backdoor purification technique—Natural Gradient
Revised: To address this concern, we propose a novel backdoor purification technique—Natural Gradient

Original: Fine-tuning (NGF)—which focuses on removing backdoor by fine-tuning only one layer .
Revised: Fine-tuning (NGF)—which focuses on removing backdoor by fine-tuning only one layer .

Original: Specifically, NGF utilizes a loss surface geometry-aware optimizer that can successfully overcome the challenge of reaching a smooth minima under one-layer optimization scenario.
Revised: Specifically, NGF utilizes a loss surface geometry-aware optimizer that can successfully overcome the challenge of reaching a smooth minima under one-layer optimization scenario.

Original: To enhance the generalization performance of our proposed method, we introduce a clean data distribution-aware regularizer based on the knowledge of loss surface curvature matrix, i.e. , Fisher Information Matrix .
Revised: To enhance the generalization performance of our proposed method, we introduce a clean data distribution-aware regularizer based on the knowledge of loss surface curvature matrix, i.e. , Fisher Information Matrix .

Original: To validate the effectiveness of our method, we conduct extensive experimentation with four different datasets—CIFAR10, GTSRB, Tiny-ImageNet, and ImageNet; as well as 11 recent backdoor attacks, e.g. , Blend, Dynamic, Clean Label, etc.
Revised: To validate the effectiveness of our method, we conduct extensive experimentation with four different datasets—CIFAR10, GTSRB, Tiny-ImageNet, and ImageNet; as well as 13 recent backdoor attacks, e.g. , Blend, Dynamic, Clean Label, etc.

Original: NGF achieves state-of-the-art performance in most of these benchmarks.
Revised: NGF achieves state-of-the-art performance in most of these benchmarks.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Training a deep neural network (DNN) with a fraction of poisoned or malicious data is often securitycritical since the model can successfully learn both clean and adversarial tasks equally well.
Revised: Training a deep neural network (DNN) with a fraction of poisoned or malicious data is often securitycritical since the model can successfully learn both clean and adversarial tasks equally well.

Original: This is prominent in scenarios where one outsources the DNN training to a vendor.
Revised: This is prominent in scenarios where one outsources the DNN training to a vendor.

Original: In such scenarios, an adversary can mount backdoor attacks (Gu et al., 2019; Chen et al., 2017) through poisoning a portion of training samples so that the model will misclassify any sample with a particular trigger or pattern to an adversary-set label.
Revised: In such scenarios, an adversary can mount backdoor attacks (Gu et al., 2019; Chen et al., 2017) through poisoning a portion of training samples so that the model will misclassify any sample with a particular trigger or pattern to an adversary-set label.

Original: Whenever a DNN is trained in such a manner, it becomes crucial to remove the effect of backdoor before deploying it for a real-world application.
Revised: Whenever a DNN is trained in such a manner, it becomes crucial to remove the effect of backdoor before deploying it for a real-world application.

Original: Different defense techniques (Liu et al., 2018;
Revised: Different defense techniques (Liu et al., 2018;

Original: Wang et al., 2019; Wu & Wang, 2021;
Revised: Wang et al., 2019; Wu & Wang, 2021;

Original: Li et al., 2021a;
Revised: Li et al., 2021a;

Original: Zheng et al., 2022) have been proposed for purifying backdoor.
Revised: Zheng et al., 2022) have been proposed for purifying backdoor.

Original: Techniques such as fine-pruning (Liu et al., 2018) and adversarial neural pruning (Wu & Wang, 2021) require a long training time due to iterative searching criteria.
Revised: Techniques such as fine-pruning (Liu et al., 2018) and adversarial neural pruning (Wu & Wang, 2021) require a long training time due to iterative searching criteria.

Original: Furthermore, the purification performance deteriorates significantly as the attacks get stronger.
Revised: Furthermore, the purification performance deteriorates significantly as the attacks get stronger.

Original: In this work, we explore the backdoor insertion and removal phenomena from the DNN optimization point of view.
Revised: In this work, we explore the backdoor insertion and removal phenomena from the DNN optimization point of view.

Original: Unlike a benign model, a backdoor model is forced to learn two different data distributions: clean data distribution and poisoned/trigger data distribution.
Revised: Unlike a benign model, a backdoor model is forced to learn two different data distributions: clean data distribution and poisoned/trigger data distribution.

Original: Having to learn both distributions, backdoor model optimization usually leads to a bad local minima or sharper minima w.r.t.
Revised: Having to learn both distributions, backdoor model optimization usually leads to a bad local minima or sharper minima w.r.t.

Original: clean distribution.
Revised: clean distribution.

Original: We claim that backdoor can be removed by re-optimizing the model to a smoother minima.
Revised: We claim that backdoor can be removed by re-optimizing the model to a smoother minima.

Original: One easy re-optimization scheme could be simple DNN weights fine-tuning with a few clean validation samples.
Revised: One easy re-optimization scheme could be simple DNN weights fine-tuning with a few clean validation samples.

Original: However, fine-tuning all DNN parameters often requires huge computational cost and may result in sub-par clean test performance after purification.
Revised: However, fine-tuning all DNN parameters often requires huge computational cost and may result in sub-par clean test performance after purification.

Original: Therefore, we intend to fine-tune only one layer to effectively remove the backdoor.
Revised: Therefore, we intend to fine-tune only one layer to effectively remove the backdoor.

Original: Fine-tuning only one layer creates a shallow network scenario where SGD-based optimization becomes a bit challenging.
Revised: Fine-tuning only one layer creates a shallow network scenario where SGD-based optimization becomes a bit challenging.

Original: Choromanska et al.
Revised: Choromanska et al.

Original: (2015) claims that the probability of finding bad local minima or poor quality solution increases as the network size decreases.
Revised: (2015) claims that the probability of finding bad local minima or poor quality solution increases as the network size decreases.

Original: Even though there are good-quality solutions, it usually requires exponentially long time to find those minima (Choromanska et al., 2015).
Revised: Even though there are good-quality solutions, it usually requires exponentially long time to find those minima (Choromanska et al., 2015).

Original: As a remedy to this, we opt to use a curvature aware optimizer, Natural Gradient Decent (NGD), that has higher probability of escaping the bad local minima as well as faster convergence rate , specifically in the shallow network scenario (Amari, 1998; Martens & Grosse, 2015).
Revised: As a remedy to this, we opt to use a curvature aware optimizer, Natural Gradient Decent (NGD), that has higher probability of escaping the bad local minima as well as faster convergence rate , specifically in the shallow network scenario (Amari, 1998; Martens & Grosse, 2015).

Original: To this end, we propose a novel backdoor purification technique—Natural Gradient Fine-tuning (NGF)— which focuses on removing backdoor through fine-tuning only one layer .
Revised: To this end, we propose a novel backdoor purification technique—Natural Gradient Fine-tuning (NGF)— which focuses on removing backdoor through fine-tuning only one layer .

Original: However, straightforward application of NGF with simple cross-entropy (CE) loss may result in poor clean test performance.
Revised: However, straightforward application of NGF with simple cross-entropy (CE) loss may result in poor clean test performance.

Original: To boost this performance, we use a clean distribution-aware regularizer that prioritizes the update of parameters sensitive to clean data distribution.
Revised: To boost this performance, we use a clean distribution-aware regularizer that prioritizes the update of parameters sensitive to clean data distribution.

Original: Our proposed method achieves SOTA performance in a wide range of benchmarks, e.g. , four different datasets including ImageNet , 11 various backdoor attacks etc.
Revised: Our proposed method achieves SOTA performance in a wide range of benchmarks, e.g. , four different datasets including ImageNet , 13 recent backdoor attacks etc.

Original: Our contributions can be summarized as follows:
Revised: Our contributions can be summarized as follows:

Original: • We analyze the loss surface characteristics of a DNN during backdoor insertion and purification processes.
Revised: • We analyze the loss surface characteristics of a DNN during backdoor insertion and purification processes.

Original: Our analysis shows that the optimization of a backdoor model leads to a bad local minima or sharper minima compared to a benign model.
Revised: Our analysis shows that the optimization of a backdoor model leads to a bad local minima or sharper minima compared to a benign model.

Original: We argue that backdoor can be purified by re-optimizing the model to a smoother minima and simple fine-tuning can be a viable way for that.
Revised: We argue that backdoor can be purified by re-optimizing the model to a smoother minima and simple fine-tuning can be a viable way for that.

Original: To the best of our knowledge, our study on the correlation between loss-surface smoothness and backdoor purification is novel.
Revised: To the best of our knowledge, our study on the correlation between loss-surface smoothness and backdoor purification is novel.

Original: • We conduct additional studies on backdoor purification process while fine-tuning different parts of a DNN.
Revised: • We conduct additional studies on backdoor purification process while fine-tuning different parts of a DNN.

Original: We observe that SGD-based one-layer fine-tuning fails to escape bad local minima and a loss surface geometry-aware optimizer can be an easy fix to this.
Revised: We observe that SGD-based one-layer fine-tuning fails to escape bad local minima and a loss surface geometry-aware optimizer can be an easy fix to this.

Original: • Based on our studies, we propose a novel backdoor purification technique based on Natural Gradient Fine-tuning (NGF).
Revised: • Based on our studies, we propose a novel backdoor purification technique based on Natural Gradient Fine-tuning (NGF).

Original: In addition, we employ a clean distribution-aware regularizer to boost the clean test performance of our proposed method.
Revised: In addition, we employ a clean distribution-aware regularizer to boost the clean test performance of our proposed method.

Original: NGF outperforms recent SOTA methods in a wide range of benchmarks.
Revised: NGF outperforms recent SOTA methods in a wide range of benchmarks.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Backdoor Attacks: Backdoor triggers can exist in the form of dynamic patterns (Li et al., 2020), a single pixel (Tran et al., 2018), sinusoidal strips (Barni et al., 2019), human imperceptible noise (Zhong et al., 2020), natural reflection (Liu et al., 2020), adversarial patterns (Zhang et al., 2021), blending backgrounds (Chen et al., 2017), etc.
Revised: Backdoor Attacks: Backdoor triggers can exist in the form of dynamic patterns (Li et al., 2020), a single pixel (Tran et al., 2018), sinusoidal strips (Barni et al., 2019), human imperceptible noise (Zhong et al., 2020), natural reflection (Liu et al., 2020), adversarial patterns (Zhang et al., 2021), blending backgrounds (Chen et al., 2017), etc.

Original: Based on target labels, existing backdoor attacks can generally be classified as poison-label or clean-label backdoor attacks.
Revised: Based on target labels, existing backdoor attacks can generally be classified as poison-label or clean-label backdoor attacks.

Original: In poison-label backdoor attack, the target label of the poisoned sample is different from its ground-truth label, e.g. , BadNets (Gu et al., 2019), Blended attack (Chen et al., 2017), SIG attack (Barni et al., 2019), WaNet (Nguyen & Tran, 2021),
Revised: In poison-label backdoor attack, the target label of the poisoned sample is different from its ground-truth label, e.g. , BadNets (Gu et al., 2019), Blended attack (Chen et al., 2017), SIG attack (Barni et al., 2019), WaNet (Nguyen & Tran, 2021),

Original: Trojan attack (Liu et al., 2017), and BPPA (Wang et al., 2022).
Revised: Trojan attack (Liu et al., 2017), and BPPA (Wang et al., 2022).

Original: Contrary to the poison-label attack, clean-label backdoor attack doesn’t change the label of the poisoned sample (Turner et al., 2018;
Revised: Contrary to the poison-label attack, clean-label backdoor attack doesn’t change the label of the poisoned sample (Turner et al., 2018;

Original: Huang et al., 2022; Zhao et al., 2020b).
Revised: Huang et al., 2022; Zhao et al., 2020b).

Original: Recently, Saha et al.
Revised: Recently, Saha et al.

Original: (2022) studied backdoor attacks on self-supervised learning.
Revised: (2022) studied backdoor attacks on self-supervised learning.

Original: Backdoor Defenses: Existing backdoor defense methods can be categorized into backdoor detection or purifying techniques.
Revised: Backdoor Defenses: Existing backdoor defense methods can be categorized into backdoor detection or purifying techniques.

Original: Detection based defenses include trigger synthesis approach (Wang et al., 2019; Qiao et al., 2019; Guo et al., 2020;
Revised: Detection based defenses include trigger synthesis approach (Wang et al., 2019; Qiao et al., 2019; Guo et al., 2020;

Original: Shen et al., 2021; Dong et al., 2021;
Revised: Shen et al., 2021; Dong et al., 2021;

Original: Guo et al., 2021;
Revised: Guo et al., 2021;

Original: Xiang et al., 2022; Tao et al., 2022), or malicious samples filtering based techniques (Tran et al., 2018; Gao et al., 2019; Chen et al., 2019).
Revised: Xiang et al., 2022; Tao et al., 2022), or malicious samples filtering based techniques (Tran et al., 2018; Gao et al., 2019; Chen et al., 2019).

Original: However, these methods only detect the existence of backdoor without removing it.
Revised: However, these methods only detect the existence of backdoor without removing it.

Original: Backdoor purification defenses can be further classified as training time defenses and inference time defenses.
Revised: Backdoor purification defenses can be further classified as training time defenses and inference time defenses.

Original: Training time defenses include model reconstruction approach (Zhao et al., 2020a;
Revised: Training time defenses include model reconstruction approach (Zhao et al., 2020a;

Original: Li et al., 2021b), poison suppression approach (Hong et al., 2020; Du et al., 2019; Borgnia et al., 2021), and pre-processing approaches (Li et al., 2021a; Doan et al., 2020).
Revised: Li et al., 2021b), poison suppression approach (Hong et al., 2020; Du et al., 2019; Borgnia et al., 2021), and pre-processing approaches (Li et al., 2021a; Doan et al., 2020).

Original: Although training time defenses are often successful, they suffer from huge computational burden and less practical considering attacks during DNN outsourcing.
Revised: Although training time defenses are often successful, they suffer from huge computational burden and less practical considering attacks during DNN outsourcing.

Original: Inference time defenses are mostly based on pruning approaches such as (Koh & Liang, 2017; Ma & Liu, 2019; Tran et al., 2018;
Revised: Inference time defenses are mostly based on pruning approaches such as (Koh & Liang, 2017; Ma & Liu, 2019; Tran et al., 2018;

Original: Diakonikolas et al., 2019; Steinhardt et al., 2017).
Revised: Diakonikolas et al., 2019; Steinhardt et al., 2017).

Original: Pruning-based approaches are typically based on model vulnerabilities to backdoor attacks.
Revised: Pruning-based approaches are typically based on model vulnerabilities to backdoor attacks.

Original: For example, MCR (Zhao et al., 2020a) and CLP (Zheng et al., 2022) analyzed node connectivity and channel Lipschitz constant to detect backdoor vulnerable neurons.
Revised: For example, MCR (Zhao et al., 2020a) and CLP (Zheng et al., 2022) analyzed node connectivity and channel Lipschitz constant to detect backdoor vulnerable neurons.

Original: ANP (Wu & Wang, 2021) prune neurons through backdoor sensitivity analysis using adversarial search on the parameter space.
Revised: ANP (Wu & Wang, 2021) prune neurons through backdoor sensitivity analysis using adversarial search on the parameter space.

Original: Instead, we propose a simple one-layer fine-tuning based defense that is both fast and highly effective.
Revised: Instead, we propose a simple one-layer fine-tuning based defense that is both fast and highly effective.

Original: To remove backdoor, our proposed method revisits the DNN fine-tuning paradigm from a novel point of view.
Revised: To remove backdoor, our proposed method revisits the DNN fine-tuning paradigm from a novel point of view.

Original: [Figure]
Revised: [Figure]

Original: eigenvalues (x-axis).
Revised: eigenvalues (x-axis).

Original: (c & d) During purification, SGD optimizer rarely escapes sharp or bad local minima (similar λ max and Tr ( H ) as the backdoor model) while our proposed method, NGF, converges to a smooth minima.
Revised: (c & d) During purification, SGD optimizer rarely escapes sharp or bad local minima (similar λ max and Tr ( H ) as the backdoor model) while our proposed method, NGF, converges to a smooth minima.

Original: We use CIFAR10 dataset with a PreActResNet18 (He et al., 2016) architecture for all evaluations.
Revised: We use CIFAR10 dataset with a PreActResNet18 (He et al., 2016) architecture for all evaluations.

Original:  B ACKGROUND
Revised:  B ACKGROUND

Original: Attack Model.
Revised: Attack Model.

Original: We consider an adversary with the capabilities of carrying a backdoor attack on a
Revised: We consider an adversary with the capabilities of carrying a backdoor attack on a

Original: DNN model, f θ : R d → R c , by training it on a poisoned data set D train
Revised: DNN model, f θ : R d → R c , by training it on a poisoned data set D train

Original: = { X train , Y train } .
Revised: = { X train , Y train } .

Original: Here, θ is the parameters of the model, d is the input data dimension and c is the total number of classes.
Revised: Here, θ is the parameters of the model, d is the input data dimension and c is the total number of classes.

Original: The data poisoning happens through specific set of triggers that can only be accessed by the attacker.
Revised: The data poisoning happens through specific set of triggers that can only be accessed by the attacker.

Original: The adversary goal is to train the model in a way such that any triggered samples ˆ x = x + δ ∈ R d will be wrongly misclassified to a target label, ¯ y .
Revised: The adversary goal is to train the model in a way such that any triggered samples ˆ x = x + δ ∈ R d will be wrongly misclassified to a target label, ¯ y .

Original: Here, x is a clean test sample and δ ∈ R d represents the trigger pattern with the properties of || δ || ≤ ϵ ; where ϵ is the trigger magnitude determined by its shape, size and color.
Revised: Here, x is a clean test sample and δ ∈ R d represents the trigger pattern with the properties of || δ || ≤ ϵ ; where ϵ is the trigger magnitude determined by its shape, size and color.

Original: We define the poison rate as the ratio of poison and clean data in D train .
Revised: We define the poison rate as the ratio of poison and clean data in D train .

Original: An attack is considered successful if the model behaves as: f θ ( x ) =
Revised: An attack is considered successful if the model behaves as: f θ ( x ) =

Original: y and f θ (ˆ x ) =
Revised: y and f θ (ˆ x ) =

Original: ¯ y , where y is the true label for x .
Revised: ¯ y , where y is the true label for x .

Original: We use attack success rate (ASR) for quantifying such success.
Revised: We use attack success rate (ASR) for quantifying such success.

Original: Defense Goal.
Revised: Defense Goal.

Original: We consider a defender with a task to purify the backdoor model f
Revised: We consider a defender with a task to purify the backdoor model f

Original: θ using a small clean validation set (usually 1 ∼ 10% of the training data).
Revised: θ using a small clean validation set (usually 1 ∼ 10% of the training data).

Original: The goal is to repair the model in a way such that it becomes immune to attack, i.e. , f θ p (ˆ x ) =
Revised: The goal is to repair the model in a way such that it becomes immune to attack, i.e. , f θ p (ˆ x ) =

Original: y .
Revised: y .

Original: Here, f θ p is the final purified model.
Revised: Here, f θ p is the final purified model.

Original: Natural Gradient Descent (NGD).
Revised: Natural Gradient Descent (NGD).

Original: Let us consider a model p ( y | x, θ ) with parameters θ ∈ R N to be fitted with input data { ( x i , y i ) } | D train | i = from an empirical data distribution P x,y , where x i ∈
Revised: Let us consider a model p ( y | x, θ ) with parameters θ ∈ R N to be fitted with input data { ( x i , y i ) } | D train | i = from an empirical data distribution P x,y , where x i ∈

Original: X train is an input sample and
Revised: X train is an input sample and

Original: y i ∈ Y train is its label.
Revised: y i ∈ Y train is its label.

Original: We try to optimize the model by solving:
Revised: We try to optimize the model by solving:

Original: [Equation]
Revised: [Equation]

Original: where L ( θ ) =
Revised: where L ( θ ) =

Original: L ( y, f θ ( x ))
Revised: L ( y, f θ ( x ))

Original: =
Revised: =

Original: E ( x i ,y i ) ∼ P x,y [ − log p ( y | x, θ )] is the expected full-batch cross-entropy (CE) loss.
Revised: E ( x i ,y i ) ∼ P x,y [ − log p ( y | x, θ )] is the expected full-batch cross-entropy (CE) loss.

Original: SGD optimizes for θ ∗ iteratively following the direction of the steepest descent (estimated by column vector, ∇ θ L ) and update the model parameters by: θ ( t +1) ← θ ( t ) − α ( t ) · ∇ ( t ) θ
Revised: SGD optimizes for θ ∗ iteratively following the direction of the steepest descent (estimated by column vector, ∇ θ L ) and update the model parameters by: θ ( t +1) ← θ ( t ) − α ( t ) · ∇ ( t ) θ

Original: L , where α is the learning rate.
Revised: L , where α is the learning rate.

Original: Since SGD uses Identity matrix as the pre-conditioner, it is unaware of the geometry of loss surface .
Revised: Since SGD uses Identity matrix as the pre-conditioner, it is unaware of the geometry of loss surface .

Original: In NGD, however, the Fisher Information Matrix (FIM) is used as a pre-conditioner which can be defined as (Martens & Grosse, 2015),
Revised: In NGD, however, the Fisher Information Matrix (FIM) is used as a pre-conditioner which can be defined as (Martens & Grosse, 2015),

Original: [Equation]
Revised: [Equation]

Original: As FIM is a loss surface curvature matrix , a careful integration of it in the update eqn.
Revised: As FIM is a loss surface curvature matrix , a careful integration of it in the update eqn.

Original: of θ will make the optimizer loss surface geometry-aware.
Revised: of θ will make the optimizer loss surface geometry-aware.

Original: Such integration leads us to the update equation of NGD, θ ( t +1) ← θ ( t ) − α ( t ) · F ( θ ( t ) ) − 1 ∇ ( t ) θ L .
Revised: Such integration leads us to the update equation of NGD, θ ( t +1) ← θ ( t ) − α ( t ) · F ( θ ( t ) ) − 1 ∇ ( t ) θ L .

Original: Due to the surface awareness of FIM 1 , in each iteration,
Revised: Due to the surface awareness of FIM 1 , in each iteration,

Original: NGD updates the parameters according to the curvature of the loss surface making a smoother loss surface around the optimization point (Amari, 1998;
Revised: NGD updates the parameters according to the curvature of the loss surface making a smoother loss surface around the optimization point (Amari, 1998;

Original: Park et al., 2000).
Revised: Park et al., 2000).

Original: To be specific, NGD-based optimization has higher probability of achieving a smoother loss surface and helps the model to gain good generalization performance.
Revised: To be specific, NGD-based optimization has higher probability of achieving a smoother loss surface and helps the model to gain good generalization performance.

Original: [Table]
Revised: [Table]

Original:  S MOOTHNESS A NALYSIS OF B ACKDOOR M ODELS
Revised:  S MOOTHNESS A NALYSIS OF B ACKDOOR M ODELS

Original: In this section
Revised: In this section

Original: [Table]
Revised: [Table]

Original: we analyze the loss surface geometry of benign, backdoor and purified models.
Revised: we analyze the loss surface geometry of benign, backdoor and purified models.

Original: To study the loss curvature properties of different models, we aim to analyze the Hessian of loss,
Revised: To study the loss curvature properties of different models, we aim to analyze the Hessian of loss,

Original: H = ∇ 2 θ L , where we compute L using the clean training set .
Revised: H = ∇ 2 θ L , where we compute L using the clean training set .

Original: Hessian, H is a symmetric matrix and one can can take the spectral decomposition H = Q Λ Q T , where Λ = diag ( λ 1 .λ 2 , . . .
Revised: Hessian, H is a symmetric matrix and one can can take the spectral decomposition H = Q Λ Q T , where Λ = diag ( λ 1 .λ 2 , . . .

Original: , λ n ) contains the eigenvalues and Q =
Revised: , λ n ) contains the eigenvalues and Q =

Original: [ q 1 , . . . , q n ] are the eigenvectors.
Revised: [ q 1 , . . . , q n ] are the eigenvectors.

Original: As a measure for smoothness, we take the maximum eigenvalue, λ max (= λ 1 ) , and trace of hessian, Tr ( H ) .
Revised: As a measure for smoothness, we take the maximum eigenvalue, λ max (= λ 1 ) , and trace of hessian, Tr ( H ) .

Original: Low values for these two proxies indicate the presence of highly smooth loss surface (Jastrzebski et al., 2020).
Revised: Low values for these two proxies indicate the presence of highly smooth loss surface (Jastrzebski et al., 2020).

Original: The Eigen Spectral density plots in Fig.
Revised: The Eigen Spectral density plots in Fig.

Original: 1a- 1b tell us about the optimization of benign and backdoor models.
Revised: 1a- 1b tell us about the optimization of benign and backdoor models.

Original: To create these models, we use the CIFAR10 dataset and train a PreActResNet18 architecture for 200 epochs.
Revised: To create these models, we use the CIFAR10 dataset and train a PreActResNet18 architecture for 200 epochs.

Original: To insert the backdoor, we use TrojanNet (Liu et al., 2017) and a poison rate of 10%.
Revised: To insert the backdoor, we use TrojanNet (Liu et al., 2017) and a poison rate of 10%.

Original: From the comparison of λ max and Tr ( H ) , we can conjecture that optimization of a benign model produces smoother loss surface.
Revised: From the comparison of λ max and Tr ( H ) , we can conjecture that optimization of a benign model produces smoother loss surface.

Original: We observe similar phenomena for different datasets and architectures; details is in Appendix F .
Revised: We observe similar phenomena for different datasets and architectures; details are in Appendix F .

Original: The main difference between a benign and a backdoor model is that the latter needs to learn two different data distributions: clean and poison.
Revised: The main difference between a benign and a backdoor model is that the latter needs to learn two different data distributions: clean and poison.

Original: Based on our observations, we state following conjectures:
Revised: Based on our observations, we state following conjectures:

Original: Conjecture 1.
Revised: Conjecture 1.

Original: Having to learn two different data distributions, a backdoor model reaches a sharper minima, i.e. , large λ max and Tr ( H ) , as compared to the benign model.
Revised: Having to learn two different data distributions, a backdoor model reaches a sharper minima, i.e. , large λ max and Tr ( H ) , as compared to the benign model.

Original: We support this conjecture with empirical evidence presented in Table 1.
Revised: We support this conjecture with empirical evidence presented in Table 1.

Original: Looking at the λ max (Initial row) for all 6 attacks (details  in Appendix D ), it can be observed that all of these backdoor models optimizes to a sharp minima.
Revised: Looking at the λ max (Initial row) for all 6 attacks (details are in Appendix D ), it can be observed that all of these backdoor models optimizes to a sharp minima.

Original: As these models are optimized on both distributions, they also have high attack success rates (ASR) as well as high clean test accuracy (ACC).
Revised: As these models are optimized on both distributions, they also have high attack success rates (ASR) as well as high clean test accuracy (ACC).

Original: Note that, the measure of smoothness is done w.r.t.
Revised: Note that, the measure of smoothness is done w.r.t.

Original: clean data distribution.
Revised: clean data distribution.

Original: The use of clean distribution in our smoothness analysis is driven from the practical consideration as our particular interest lies with the performance w.r.t.
Revised: The use of clean distribution in our smoothness analysis is driven from the practical consideration as our particular interest lies with the performance w.r.t.

Original: clean distribution; more details  in Appendix C .
Revised: clean distribution; more details are in Appendix C.1 .

Original: Since high ASR and ACC indicates that the model had learned both distributions, it supports Conjecture 1.
Revised: Since high ASR and ACC indicates that the model had learned both distributions, it supports Conjecture 1.

Original: Conjecture 2.
Revised: Conjecture 2.

Original: Through proper fine-tuning with clean validation data, a backdoor model can be re-optimized to a smoother minima w.r.t.
Revised: Through proper fine-tuning with clean validation data, a backdoor model can be re-optimized to a smoother minima w.r.t.

Original: clean data distribution.
Revised: clean data distribution.

Original: Optimization to a smoother minima leads to backdoor purification, i.e. , low ASR and high ACC.
Revised: Optimization to a smoother minima leads to backdoor purification, i.e. , low ASR and high ACC.

Original: By proper fine-tuning , we imply that the fine-tuning will lead to an optimal solution w.r.t.
Revised: By proper fine-tuning , we imply that the fine-tuning will lead to an optimal solution w.r.t.

Original: the data distribution we fine-tune the model with.
Revised: the data distribution we fine-tune the model with.

Original: To support Conjecture 2, we show the removal performances of fine-tuning based purification methods in Table 1.
Revised: To support Conjecture 2, we show the removal performances of fine-tuning based purification methods in Table 1.

Original: To remove backdoor using a clean validation set ( ∼ 1% of training set), we fine-tune different parts of the DNN for 100 epochs with a learning rate of 0.01.
Revised: To remove backdoor using a clean validation set ( ∼ 1% of training set), we fine-tune different parts of the DNN for 100 epochs with a learning rate of 0.01.

Original: As shown in the Table 1, after proper fine-tuning (Full-Net, CNN-Bbone, and Cls.
Revised: As shown in the Table 1, after proper fine-tuning (Full-Net, CNN-Bbone, and Cls.

Original: (NGF)), the backdoor model re-optimizes to a smoother minima that leads to successful backdoor removal, i.e. , high ACC and low ASR.
Revised: (NGF)), the backdoor model re-optimizes to a smoother minima that leads to successful backdoor removal, i.e. , high ACC and low ASR.

Original: One-Layer Fine-tuning: We observe that one can remove the backdoor by fine-tuning either the full network or only the CNN backbone (using SGD).
Revised: One-Layer Fine-tuning: We observe that one can remove the backdoor by fine-tuning either the full network or only the CNN backbone (using SGD).

Original: However, these methods can be computationally costly and less practical.
Revised: However, these methods can be computationally costly and less practical.

Original: Furthermore, such fine-tuning often leads to high drop in ACC.
Revised: Furthermore, such fine-tuning often leads to high drop in ACC.

Original: As an alternative, one could fine-tune only the last or classification (Cls.) layer.
Revised: As an alternative, one could fine-tune only the last or classification (Cls.) layer.

Original: However, even with small validation set, a one-layer network becomes a shallow network to optimize.
Revised: However, even with small validation set, a one-layer network becomes a shallow network to optimize.

Original: According to the spin-glass analogy in Choromanska et al.
Revised: According to the spin-glass analogy in Choromanska et al.

Original: (2015), as the network size decreases the probability for the SGD optimizer to find sharp local minima or poor quality minima increases accordingly.
Revised: (2015), as the network size decreases the probability for the SGD optimizer to find sharp local minima or poor quality minima increases accordingly.

Original: In case of shallow network, the quality of minima is decided by their distances from the global minima.
Revised: In case of shallow network, the quality of minima is decided by their distances from the global minima.

Original: Choromanska et al.
Revised: Choromanska et al.

Original: (2015) also observes that the process of finding a path from a bad local minima to a good quality solution or global minima takes exponentially long time .
Revised: (2015) also observes that the process of finding a path from a bad local minima to a good quality solution or global minima takes exponentially long time .

Original: Therefore, it is not always feasible to use the SGD optimizer for shallow network.
Revised: Therefore, it is not always feasible to use the SGD optimizer for shallow network.

Original: Table 1 (row–Cls.
Revised: Table 1 (row–Cls.

Original: (SGD)) corroborates this hypothesis as SGD optimizer fails to escape the sharp minima resulting in similar ASRs as the initial backdoor model.
Revised: (SGD)) corroborates this hypothesis as SGD optimizer fails to escape the sharp minima resulting in similar ASRs as the initial backdoor model.

Original: Instead of using SGD, one can use natural gradient descent (NGD) that has higher probability of escaping the bad local minima as well as faster convergence rate , specifically in the shallow network scenario (Amari, 1998; Martens & Grosse, 2015).
Revised: Instead of using SGD, one can use natural gradient descent (NGD) that has higher probability of escaping the bad local minima as well as faster convergence rate , specifically in the shallow network scenario (Amari, 1998; Martens & Grosse, 2015).

Original: Therefore, to effectively purify a backdoor model, we propose a novel Fisher Information matrix based backdoor purification objective function and optimize it using NGD optimizer.
Revised: Therefore, to effectively purify a backdoor model, we propose a novel Fisher Information matrix based backdoor purification objective function and optimize it using NGD optimizer.

Original: 4. N ATURAL G RADIENT F INE - TUNING (NGF)
Revised: 4. N ATURAL G RADIENT F INE - TUNING (NGF)

Original: Let us decompose the model parameters θ as,
Revised: Let us decompose the model parameters θ as,

Original: [Equation]
Revised: [Equation]

Original: here, W i,i +1 is the parameters between layer i and layer i + 1 , commonly termed as ( i + 1) th layer’s parameters.
Revised: here, W i,i +1 is the parameters between layer i and layer i + 1 , commonly termed as ( i + 1) th layer’s parameters.

Original: W L − 1 ,L is the L th layer’s
Revised: W L − 1 ,L is the L th layer’s

Original: (Cls. layer) parameters and we are particularly interested in fine-tuning only this layer.
Revised: (Cls. layer) parameters and we are particularly interested in fine-tuning only this layer.

Original: Now, consider a validation set, D val =
Revised: Now, consider a validation set, D val =

Original: { X val , Y val } that contains only clean samples.
Revised: { X val , Y val } that contains only clean samples.

Original: We denote θ L (= W L − 1 ,L ) as the L th layer’s parameters.
Revised: We denote θ L (= W L − 1 ,L ) as the L th layer’s parameters.

Original: To purify the backdoor model, we formulate the following loss function:
Revised: To purify the backdoor model, we formulate the following loss function:

Original: [Equation]
Revised: [Equation]

Original: where the first term accounts for the CE loss on the validation set.
Revised: where the first term accounts for the CE loss on the validation set.

Original: In a backdoor model, some neurons/parameters are more vulnerable than others.
Revised: In a backdoor model, some neurons/parameters are more vulnerable than others.

Original: The vulnerable parameters are believed to be the ones that are sensitive to poison/trigger data distribution (Wu & Wang, 2021).
Revised: The vulnerable parameters are believed to be the ones that are sensitive to poison/trigger data distribution (Wu & Wang, 2021).

Original: In general, CE loss does not discriminate whether a parameter is more sensitive to clean or poison distribution.
Revised: In general, CE loss does not discriminate whether a parameter is more sensitive to clean or poison distribution.

Original: Such lack of discrimination may allow drastic/unwanted changes to the parameters responsible for learned clean distribution.
Revised: Such lack of discrimination may allow drastic/unwanted changes to the parameters responsible for learned clean distribution.

Original: This usually leads to sub-par clean test accuracy after purification and it requires additional measures to fix this issue.
Revised: This usually leads to sub-par clean test accuracy after purification and it requires additional measures to fix this issue.

Original: Motivated by Kirkpatrick et al.
Revised: Motivated by Kirkpatrick et al.

Original: (2017), we introduce a clean distribution aware regularization term as a product of two terms: i) an error term that accounts for the deviation of θ L from the original backdoor parameters, ¯ θ L (fixed); ii) a vector, diag ( F (¯ θ L )) , consisting of the diagonal elements of
Revised: (2017), we introduce a clean distribution aware regularization term as a product of two terms: i) an error term that accounts for the deviation of θ L from the original backdoor parameters, ¯ θ L (fixed); ii) a vector, diag ( F (¯ θ L )) , consisting of the diagonal elements of

Original: FIM ( F (¯ θ L ) ).
Revised: FIM ( F (¯ θ L ) ).

Original: As the first term controls the changes of parameters w.r.t.
Revised: As the first term controls the changes of parameters w.r.t.

Original: ¯ θ L , it helps the model to remember the already learned distribution.
Revised: ¯ θ L , it helps the model to remember the already learned distribution.

Original: However, learned data distribution consists of clean and poison distribution both.
Revised: However, learned data distribution consists of clean and poison distribution both.

Original: To explicitly force the model to remember the clean distribution , we compute F (¯ θ L ) using a clean validation set; with similar distribution as the learned clean data.
Revised: To explicitly force the model to remember the clean distribution , we compute F (¯ θ L ) using a clean validation set; with similar distribution as the learned clean data.

Original: Note that, diag ( F (¯ θ L ))
Revised: Note that, diag ( F (¯ θ L ))

Original: i represents the square of the derivative of log-likelihood of clean distribution w.r.t.
Revised: i represents the square of the derivative of log-likelihood of clean distribution w.r.t.

Original: ¯ θ L,i , [ ∇ ¯ θ L,i log p ( y | x, θ )] 2 (ref.
Revised: ¯ θ L,i , [ ∇ ¯ θ L,i log p ( y | x, θ )] 2 (ref.

Original: eqn. 6).
Revised: eqn. 6).

Original: In other words, diag ( F (¯ θ L )) i is the measure of importance of ¯ θ L,i towards remembering the learned clean distribution.
Revised: In other words, diag ( F (¯ θ L )) i is the measure of importance of ¯ θ L,i towards remembering the learned clean distribution.

Original: If diag ( F (¯ θ L ))
Revised: If diag ( F (¯ θ L ))

Original: i has a higher importance, we allow minimal changes to ¯ θ L,i over the purification process.
Revised: i has a higher importance, we allow minimal changes to ¯ θ L,i over the purification process.

Original: This careful design of such regularizer improves the clean test performance significantly.
Revised: This careful design of such regularizer improves the clean test performance significantly.

Original: We use η as a regularization constant.
Revised: We use η as a regularization constant.

Original: Overall optimization problem using the loss-function defined in equation 3 for purifying the backdoor model f θ is as follows:
Revised: Overall optimization problem using the loss-function defined in equation 3 for purifying the backdoor model f θ is as follows:

Original: Objective
Revised: Objective

Original: [Equation]
Revised: [Equation]

Original: Update Policy:
Revised: Update Policy:

Original: [Equation]
Revised: [Equation]

Original: where, F ( θ L ) :
Revised: where, F ( θ L ) :

Original: = 1 n
Revised: = 1 n

Original: [Equation]
Revised: [Equation]

Original: here, F ∈ R | θ L |×| θ
Revised: here, F ∈ R | θ L |×| θ

Original: L | is the FIM, and n is the validation set size.
Revised: L | is the FIM, and n is the validation set size.

Original: Notice that, as we consider fine-tune only L th -layer, the computation of F and F − 1 become tractable with a size of | θ L | × | θ L | matrix.
Revised: Notice that, as we consider fine-tune only L th -layer, the computation of F and F − 1 become tractable with a size of | θ L | × | θ L | matrix.

Original: After solving the above optimization problem, we will get modified parameters, W L − 1 ,L .
Revised: After solving the above optimization problem, we will get modified parameters, W L − 1 ,L .

Original: Finally, we get the purified model, f θ p with θ p as
Revised: Finally, we get the purified model, f θ p with θ p as

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: Fig.
Revised: Fig.

Original: 1c-1d shows that NGF indeed does reach the smooth minima as opposed to SGD based finetuning.
Revised: 1c-1d shows that NGF indeed does reach the smooth minima as opposed to SGD based finetuning.

Original: We provide additional results in Table 1 for both NGF and SGD.
Revised: We provide additional results in Table 1 for both NGF and SGD.

Original: Notice that the purified model seems to have a smoother loss surface than the benign model (2.7 vs. 20.1 for λ max ).
Revised: Notice that the purified model seems to have a smoother loss surface than the benign model (2.7 vs. 20.1 for λ max ).

Original: This, however, does not translate to better ACC than the benign model.
Revised: This, however, does not translate to better ACC than the benign model.

Original: The ACC of the purified model is always bounded by the ACC of the backdoor model.
Revised: The ACC of the purified model is always bounded by the ACC of the backdoor model.

Original: To the best of our knowledge, our study on the correlation between loss-surface smoothness and backdoor purification is novel.
Revised: To the best of our knowledge, our study on the correlation between loss-surface smoothness and backdoor purification is novel.

Original: NGF is also the first method to employ a second-order optimizer for purifying backdoor.
Revised: NGF is also the first method to employ a second-order optimizer for purifying backdoor.

Revised: More details are in Appendix C

Original:  E XPERIMENTAL R ESULTS 5. E VALUATION S ETTINGS
Revised:  E XPERIMENTAL R ESULTS 5. E VALUATION S ETTINGS

Original: Datasets: To begin with, we evaluate our proposed method through conducting a wide range of experiments on two widely used datasets for backdoor attack study: CIFAR10 (Krizhevsky et al., 2009) with 10 classes, GTSRB (Stallkamp et al., 2011) with 43 classes.
Revised: Datasets: To begin with, we evaluate our proposed method through conducting a wide range of experiments on two widely used datasets for backdoor attack study: CIFAR10 (Krizhevsky et al., 2009) with 10 classes, GTSRB (Stallkamp et al., 2011) with 43 classes.

Original: As a test of scalability, we also consider Tiny-ImageNet (Le & Yang, 2015) with 100,000 images distributed among 200 classes and ImageNet (Deng et al., 2009) with 1.28M images distributed among 1000 classes.
Revised: As a test of scalability, we also consider Tiny-ImageNet (Le & Yang, 2015) with 100,000 images distributed among 200 classes and ImageNet (Deng et al., 2009) with 1.28M images distributed among 1000 classes.

Original: Attacks Configurations: We consider 11 state-of-the-art backdoor attacks: 1)
Revised: Attacks Configurations: We consider 13 state-of-the-art backdoor attacks: 1)

Original: Badnets (Gu et al., 2019), 2) Blend attack (Chen et al., 2017), 3 & 4)
Revised: Badnets (Gu et al., 2019), 2) Blend attack (Chen et al., 2017), 3 & 4)

Original: TrojanNet (Troj-one & Troj-all) (Liu et al., 2017), 5) Sinusoidal signal attack (SIG) (Barni et al., 2019), 6 & 7) Input-Aware Attack (Dyn-one and
Revised: TrojanNet (Troj-one & Troj-all) (Liu et al., 2017), 5) Sinusoidal signal attack (SIG) (Barni et al., 2019), 6 & 7) Input-Aware Attack (Dyn-one and

Original: Dyn-all) (Nguyen & Tran, 2020), 8) Clean-label attack (CLB) (Turner et al., 2018), 9) Composite backdoor (CBA) (Lin et al., 2020), 10)
Revised: Dyn-all) (Nguyen & Tran, 2020), 8) Clean-label attack (CLB) (Turner et al., 2018), 9) Composite backdoor (CBA) (Lin et al., 2020), 10)

Original: Deep feature space attack (FBA) (Cheng et al., 2021),and 11)  Quantization and contrastive learning based attack (BPPA)
Revised: Deep feature space attack (FBA) (Cheng et al., 2021), 11) Warping-based backdoor attack (WaNet) (Nguyen & Tran, 2021), 12) Invisible triggers based backdoor attack (ISSBA) (Li et al., 2021c), and 13) Quantization and contrastive learning based attack (BPPA)

Original: (Wang et al., 2022).
Revised: (Wang et al., 2022).

Original: To ensure fair comparison, we follow the similar trigger patterns and settings as in their original papers.
Revised: To ensure fair comparison, we follow the similar trigger patterns and settings as in their original papers.

Original: In Troj-one and Dyn-one attacks, all of the triggered imageshave same target label. On the other hand, target [Figure]
Revised: In Troj-one and Dyn-one attacks, all of the triggered images

Original: [Figure]
Revised: [Figure]

Original:  labels are uniformly distributed over all classes for Troj-all and Dyn-all attacks.
Revised: have same target label. On the other hand, target labels are uniformly distributed over all classes for Troj-all and Dyn-all attacks.

Original: For creating these attacks on CIFAR10 and GTSRB, we use a poison rate of 10% and train a PreActResNet18 (He et al., 2016) and a WideResNet-16-1 (Zagoruyko & Komodakis, 2016) architectures, respectively, forepochs with an initial learning rate of 0.01.
Revised: For creating these attacks on CIFAR10 and GTSRB, we use a poison rate of 10% and train a PreActResNet18 (He et al., 2016) and a WideResNet-16-1 (Zagoruyko & Komodakis, 2016) architectures, respectively, for 250 epochs with an initial learning rate of 0.01.

Original: More details on hyper-parameters and overall training settings can be found inthe Appendix D .
Revised: More details on hyper-parameters and overall training settings can be found in Appendix D .

Original: Defenses Configurations: We compare our approach with 4 existing backdoor mitigation methods: 1) Vanilla Fine-Tuning (FT); where we fine-tune all DNN parameters using 1% clean validation data, 2)
Revised: Defenses Configurations: We compare our approach with 4 existing backdoor mitigation methods: 1) Vanilla Fine-Tuning (FT); where we fine-tune all DNN parameters, 2) Adversarial Neural Pruning (ANP) (Wu & Wang, 2021) with 1% clean validation data, 3)

Original: Mode connectivity repair (MCR) (Zhao et al., 2020a), 3) Neural attention distillation (NAD) (Li et al., 2021b) with 5% validation data, 4) Adversarial Neural Pruning (ANP) (Wu & Wang, 2021) with 1% clean validation data.
Revised: Implicit Backdoor Adversarial Unlearning (I-BAU) (Zeng et al., 2021) 4) Adversarial Weight Masking (AWM) (Chai & Chen, 2022).

Original: We also compare NGF with another recent defense technique described in (Zheng et al., 2022).
Revised: We also compare NGF with another recent defense technique described in (Zheng et al., 2022).

Original: However, we present this comparison in the Appendix E due to several performance issues.
Revised: However, we present this comparison in the Appendix E due to several performance issues.

Original: 2 To apply NGF on CIFAR10, we fine-tune the last layer of the DNN for E p epochs with 1% clean validation data.
Revised: 2 To apply NGF on CIFAR10, we fine-tune the last layer of the DNN for E p epochs with 1% clean validation data.

Original: Here, E p is the number of purification epochs and we choose a value of 100 for this.
Revised: Here, E p is the number of purification epochs and we choose a value of 100 for this.

Original: For optimization, we choose a learning rate of 0.01 with a decay rate of 0.1/ epochs and consider regularization constant η to be 0.1.
Revised: For optimization, we choose a learning rate of 0.01 with a decay rate of 0.1/40 epochs and consider regularization constant η to be 0.1.

Original: Additional experimental details for NGF and other defense methods is inthe Appendix D.3 .
Revised: Additional experimental details for NGF and other defense methods are in Appendix D.3 .

Original: For GTSRB, we increase the validation size to 3% as there are less samples available per class.
Revised: For GTSRB, we increase the validation size to 3% as there are less samples available per class.

Original: Rest of the training settings are same as CIFAR10.
Revised: Rest of the training settings are same as CIFAR10.

Original: For NGF on Tiny-ImageNet, we consider a validation size of 5% as a size less than this seems to hurt clean test performance (after purification).
Revised: For NGF on Tiny-ImageNet, we consider a validation size of 5% as a size less than this seems to hurt clean test performance (after purification).

Original: We fine-tune the model for 15 epochs with an initial learning rate of 0.01 with a decay rate of 0.3/epoch.
Revised: We fine-tune the model for 15 epochs with an initial learning rate of 0.01 with a decay rate of 0.3/epoch.

Original: Finally, we validate the effectiveness of NGF on ImageNet.
Revised: Finally, we validate the effectiveness of NGF on ImageNet.

Original: For removing the backdoor, we use 3% validation data and fine-tune for 2 epochs.
Revised: For removing the backdoor, we use 3% validation data and fine-tune for 2 epochs.

Original: A learning rate of 0.001 has been employed with a decay rate of 0.005 per epoch.
Revised: A learning rate of 0.001 has been employed with a decay rate of 0.005 per epoch.

Original: We define the effectiveness of a defense method in terms of average drop in ASR and ACC over all attacks.
Revised: We define the effectiveness of a defense method in terms of average drop in ASR and ACC over all attacks.

Original: A highly effective method should have a high drop in ASR with a low drop in ACC.
Revised: A highly effective method should have a high drop in ASR with a low drop in ACC.

Original: 5. P ERFORMANCE E VALUATION OF NGF
Revised: 5. P ERFORMANCE E VALUATION OF NGF

Original: In Table 2, we present the performance of different defenses for four different datasets.
Revised: In Table 2, we present the performance of different defenses for four different datasets.

Original: We measure removal performance of NGF in terms of ASR and ACC.
Revised: We measure removal performance of NGF in terms of ASR and ACC.

Original: We define ASR as the number of triggered test samples that are classified to the adversary-set target label.
Revised: We define ASR as the number of triggered test samples that are classified to the adversary-set target label.

Original: CIFAR10: We consider five label poisoning attacks : Badnets, Blend, TrojanNet, Dynamic, and
Revised: CIFAR10: We consider five label poisoning attacks : Badnets, Blend, TrojanNet, Dynamic, and

Original: BPPA.
Revised: BPPA.

Original: For TorjanNet, we consider two different variations based on label-mapping criteria:
Revised: For TorjanNet, we consider two different variations based on label-mapping criteria:

Original: Troj-one and Troj-all.
Revised: Troj-one and Troj-all.

Original: Regardless the complexity of the label-mapping type, our proposed method outperforms all other methods both in terms of ASR and ACC.
Revised: Regardless the complexity of the label-mapping type, our proposed method outperforms all other methods both in terms of ASR and ACC.

Original: We also create two variations for Dynamic attack:
Revised: We also create two variations for Dynamic attack:

Original: Dyn-one and Dyn-all.
Revised: Dyn-one and Dyn-all.

Original: Dynamic attack optimizes for input-aware triggers that are capable of fooling the model; making it more challenging than the static trigger based attacks (Badnets, Blend and
Revised: Dynamic attack optimizes for input-aware triggers that are capable of fooling the model; making it more challenging than the static trigger based attacks (Badnets, Blend and

Original: Trojan).
Revised: Trojan).

Original: However, NGF outperforms other methods by a satisfactory margin.
Revised: However, NGF outperforms other methods by a satisfactory margin.

Original: We also consider attacks that does not change the label during trigger insertion, i.e. , clean label attack .
Revised: We also consider attacks that does not change the label during trigger insertion, i.e. , clean label attack .

Original: Two such attacks are
Revised: Two such attacks are

Original: CLB and SIG.
Revised: CLB and SIG.

Original: For further validation of our proposed method, we use deep feature based attacks ,
Revised: For further validation of our proposed method, we use deep feature based attacks ,

Original: CBA and FBA.
Revised: CBA and FBA.

Original: Both of these attacks manipulates deep features for backdoor insertion.
Revised: Both of these attacks manipulates deep features for backdoor insertion.

Original: Compared to other defenses, NGF shows better effectiveness against these diverse set of attacks achieving an average drop of 94 .
Revised: Compared to other defenses, NGF shows better effectiveness against these diverse set of attacks achieving an average drop of 95 .

Original: 85% in ASR while sacrificing an ACC of 3 .
Revised: 01% in ASR while sacrificing an ACC of 3 .

Original: 46% for that.
Revised: 33% for that.

Original: Table 2 also shows the performance of baseline methods such as NAD and ANP.
Revised: Table 2 also shows the performance of baseline methods such as I-BAU and AWM.

Original: While these methods work well for mild attacks with low poison rates, the performance deteriorates for stronger attacks we consider here.
Revised: AWM performs similarly as ANP and often struggles to remove the backdoor.

Original: GTSRB:
Revised: GTSRB:

Original: In case of GTSRB, almost all defenses performs similarly for Badnets and Trojan.
Revised: In case of GTSRB, almost all defenses performs similarly for Badnets and Trojan.

Original: This, however, does not hold for blend as we achieve an 2 .
Revised: This, however, does not hold for blend as we achieve an 2 .

Original: 17% ASR improvement over the next best method.
Revised: 17% ASR improvement over the next best method.

Original: The performance is consistent for other attacks as well.
Revised: The performance is consistent for other attacks as well.

Original: Overall, we record an average 97 .
Revised: Overall, we record an average 97 .

Original: 39% ASR drop with only an 2 .
Revised: 39% ASR drop with only an 2 .

Original: 79% drop in ACC.
Revised: 79% drop in ACC.

Revised: In some cases, ACC for I-BAU are slightly better as it uses a much larger validation size (5%) for purification than other defense techniques.

Original: ImageNet: For scalability test of NGF, we consider two large and widely used datasets, TinyImageNet and ImageNet.
Revised: ImageNet: For scalability test of NGF, we consider two large and widely used datasets, TinyImageNet and ImageNet.

Original: In consistence with other datasets, NGF obtains SOTA performance in these diverse datasets too.
Revised: In consistence with other datasets, NGF obtains SOTA performance in these diverse datasets too.

Original: The effectiveness of ANP reduces significantly for this dataset.
Revised: The effectiveness of ANP reduces significantly for this dataset.

Original: In case of large models and datasets, the task of identifying and pruning vulnerable neurons gets more complicated and may result in wrong neurons pruning.
Revised: In case of large models and datasets, the task of identifying and pruning vulnerable neurons gets more complicated and may result in wrong neurons pruning.

Original: 5. A BLATION S TUDIES 5.3. S MOOTHNESS A NALYSIS OF D IFFERENT A TTACKS
Revised: 5. A BLATION S TUDIES 5.3. S MOOTHNESS A NALYSIS OF D IFFERENT A TTACKS

Original: We show the relationship between loss surface smoothness and backdoor insertion process in
Revised: We show the relationship between loss surface smoothness and backdoor insertion process in

Original: Fig.
Revised: Fig.

Original: 2a-2b.
Revised: 2a-2b.

Original: During backdoor insertion, the model is optimized for 2 different data distributions: clean and poison.
Revised: During backdoor insertion, the model is optimized for 2 different data distributions: clean and poison.

Original: Compared to a benign model, the loss surface of a backdoor becomes much sharper as the model becomes well optimized for both distributions , i.e. , model has both high ASR and high ACC.
Revised: Compared to a benign model, the loss surface of a backdoor becomes much sharper as the model becomes well optimized for both distributions , i.e. , model has both high ASR and high ACC.

Original: At the beginning of training, both backdoor and benign models are far from being well optimized.
Revised: At the beginning of training, both backdoor and benign models are far from being well optimized.

Original: The difference between these models are prominent once the model reaches closer to the final optimization point.
Revised: The difference between these models are prominent once the model reaches closer to the final optimization point.

Original: As shown in Fig.
Revised: As shown in Fig.

Original: 2b, the training becomes reasonably stable after 100 epochs with ASR and ACC near saturation level.
Revised: 2b, the training becomes reasonably stable after 100 epochs with ASR and ACC near saturation level.

Original: Comparing λ max of benign and all backdoor models after 100 epochs, we notice a sharp contrast in Fig.
Revised: Comparing λ max of benign and all backdoor models after 100 epochs, we notice a sharp contrast in Fig.

Original: 2a.
Revised: 2a.

Original: This validates our previous claim on loss surface smoothness of benign and backdoor models.
Revised: This validates our previous claim on loss surface smoothness of benign and backdoor models.

Original: [Table]
Revised: [Table]

Original: During purification period as shown in 2c-2d [Table] the model is being optimized to a smoother minima.
Revised: During purification period as shown in 2c-2d, the model is being optimized to a smoother minima.

Original: As a result,
Revised: As a result,

Original: ASR becomes close to 0 while retaining good clean test performance.
Revised: ASR becomes close to 0 while retaining good clean test performance.

Original: Note that, we calculate loss Hessian and λ max using all DNN parameters.
Revised: Note that, we calculate loss Hessian and λ max using all DNN parameters.

Original: This indicates that changing the parameters of only one layer impacts the loss landscape of whole network.
Revised: This indicates that changing the parameters of only one layer impacts the loss landscape of whole network.

Original: Even though the CNN-backbone parameters are frozen, NGF changes the last layer in a way such that whole backdoor network behaves differently,
Revised: Even though the CNN-backbone parameters are frozen, NGF changes the last layer in a way such that whole backdoor network behaves differently,

Original: i
Revised: i

Original: [Table]
Revised: [Table]

Original: e. , like a benign model.
Revised: e. , like a benign model.

Original: 5.3. E VALUATION OF D IFFERENT O PTIMIZERS
Revised: 5.3. E VALUATION OF D IFFERENT O PTIMIZERS

Original: We compare the performance of NGF with different variants of first-order optimizer:
Revised: We compare the performance of NGF with different variants of first-order optimizer:

Original: [Table]
Revised: [Table]

Original: (i) AdaGrad adaptively updates the step size of each parameter inversely proportional to the square root of the sum of all observed squared values ( L 2 norm) of that component of gradient (Duchi et al., 2011), (ii)
Revised: (i) AdaGrad adaptively updates the step size of each parameter inversely proportional to the square root of the sum of all observed squared values ( L 2 norm) of that component of gradient (Duchi et al., 2011), (ii)

Original: RMSProp divides the learning rate for a parameter by a running average of gradient of the parameter (Hinton et al.), (iii) Adam combines AdaGrad and RMSProp by taking a running average of gradient and L 2 norm of gradient (Kingma & Ba, 2014), (iv) Sharpness-Aware
Revised: RMSProp divides the learning rate for a parameter by a running average of gradient of the parameter (Hinton et al.), (iii) Adam combines AdaGrad and RMSProp by taking a running average of gradient and L 2 norm of gradient (Kingma & Ba, 2014), (iv) Sharpness-Aware

Original: Minimization ( SAM ) (Foret et al., 2020) is a recently proposed SGD-based optimizer that explicitly penalizes the abrupt changes of loss surface by bounding the search space within a small region.
Revised: Minimization ( SAM ) (Foret et al., 2020) is a recently proposed SGD-based optimizer that explicitly penalizes the abrupt changes of loss surface by bounding the search space within a small region.

Original: This forces the changes of model parameters in a way such that the optimization achieve smoother loss surface.
Revised: This forces the changes of model parameters in a way such that the optimization achieve smoother loss surface.

Original: Table 3 shows that NGF outperforms all of these variants of first-order optimizer by a huge margin.
Revised: Table 3 shows that NGF outperforms all of these variants of first-order optimizer by a huge margin.

Original: At the same time, proposed method achieves comparable clean test performance.
Revised: At the same time, proposed method achieves comparable clean test performance.

Original: The poor performance of all SGD-based optimizers (including SAM) can be attributed to shallow-network optimization problem .
Revised: The poor performance of all SGD-based optimizers (including SAM) can be attributed to shallow-network optimization problem .

Original: Thus, the issue of bad local minima (Choromanska et al., 2015) persists, which results in poor removal performance.
Revised: Thus, the issue of bad local minima (Choromanska et al., 2015) persists, which results in poor removal performance.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 5.3. R UNTIME A NALYSIS
Revised: 5.3. R UNTIME A NALYSIS

Original: In Table 4, we show the average runtime for different defenses.
Revised: In Table 4, we show the average runtime for different defenses.

Original: Similar to purification performance, purification time is also an important indicator to measure the success of a defense technique.
Revised: Similar to purification performance, purification time is also an important indicator to measure the success of a defense technique.

Original: In
Revised: In

Original: Section 5.2, we already show that our method outperforms other defenses in most of the settings.
Revised: Section 5.2, we already show that our method outperforms other defenses in most of the settings.

Original: As for the run time, our method completes the purification (for CIFAR10) in just 38 .
Revised: As for the run time, our method completes the purification (for CIFAR10) in just 38 .

Original: 3 seconds; which is almost half as compared to FT.
Revised: 3 seconds; which is almost half as compared to FT.

Original: The time-advantage of our method also holds for large datasets and models, e.g. , ImageNet and ResNet50.
Revised: The time-advantage of our method also holds for large datasets and models, e.g. , ImageNet and ResNet50.

Original: Comparison with other methods is in the Appendix H .
Revised: Comparison with other methods is in the Appendix H .

Original: . E FFECT OF R EGULARIZER
Revised: 5.3. E FFECT OF R EGULARIZER

Original: In this section, we analyze the effect of regularizer and long training with SGD.
Revised: In this section, we analyze the effect of regularizer and long training with SGD.

Original: The effect of our clean distribution-aware regularizer can be observed in Table 5.
Revised: The effect of our clean distribution-aware regularizer can be observed in Table 5.

Original: NGF with the proposed regularizer achieves an 1% clean test performance improvement over vanilla NGF.
Revised: NGF with the proposed regularizer achieves an 1% clean test performance improvement over vanilla NGF.

Original: For long training with SGD (SGD-Long), we fine-tune the last layer for 2500 epochs.
Revised: For long training with SGD (SGD-Long), we fine-tune the last layer for 2500 epochs.

Original: Table 5 shows the evaluations of SGD-Long on 7 different attacks.
Revised: Table 5 shows the evaluations of SGD-Long on 7 different attacks.

Original: Even though the ASR performance improves significantly for CLB and SIG attacks, SGD-based FT still severely underperforms for other attacks.
Revised: Even though the ASR performance improves significantly for CLB and SIG attacks, SGD-based FT still severely underperforms for other attacks.

Original: Moreover, the computational time increases significantly over NGF.
Revised: Moreover, the computational time increases significantly over NGF.

Original: Thus, our choice of NGD-based FT as a fast and effective backdoor purification technique is well justified
Revised: Thus, our choice of NGD-based FT as a fast and effective backdoor purification technique is well justified

Original: . 5.3. S TRONG B ACKDOOR A TTACKS
Revised: . 5.3. S TRONG B ACKDOOR A TTACKS

Original: By increasing the poison rates, we create stronger version of different attacks against which most defense techniques fail quite often.
Revised: By increasing the poison rates, we create stronger version of different attacks against which most defense techniques fail quite often.

Original: We use 3 different poison rates, { 25% , 35% , 50% } .
Revised: We use 3 different poison rates, { 25% , 35% , 50% } .

Original: We show in Table 6 that NGF is capable of defending very well even with a poison rate of 50% , achieving a significant ASR improvement over FT.
Revised: We show in Table 6 that NGF is capable of defending very well even with a poison rate of 50% , achieving a significant ASR improvement over FT.

Original: Furthermore, there is a sharp difference in classification accuracy between NGF and other defenses.
Revised: Furthermore, there is a sharp difference in classification accuracy between NGF and other defenses.

Original: For 25% Blend attack, however, ANP offers a slightly better performance than our method.
Revised: For 25% Blend attack, however, ANP offers a slightly better performance than our method.

Original: However, ANP performs poorly in terms of removing backdoor as it obtains an ASR of 29 .
Revised: However, ANP performs poorly in terms of removing backdoor as it obtains an ASR of 29 .

Original: 96% as compared to 0 .
Revised: 96% as compared to 0 .

Original: 83% for NGF.
Revised: 83% for NGF.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We propose a novel backdoor purification technique based on natural gradient descent fine-tuning.
Revised: We propose a novel backdoor purification technique based on natural gradient descent fine-tuning.

Original: The proposed method is motivated by our analysis of loss surface smoothness and its strong correlation with the backdoor insertion and purification processes.
Revised: The proposed method is motivated by our analysis of loss surface smoothness and its strong correlation with the backdoor insertion and purification processes.

Original: As a backdoor model has to learn an additional data distribution, it tends to be optimized to a bad local minima or sharper minima compared to a benign model.
Revised: As a backdoor model has to learn an additional data distribution, it tends to be optimized to a bad local minima or sharper minima compared to a benign model.

Original: We argue that backdoor can be removed by re-optimizing the model to a smoother minima.
Revised: We argue that backdoor can be removed by re-optimizing the model to a smoother minima.

Original: We further argue that fine-tuning a single layer is enough to remove the backdoor.
Revised: We further argue that fine-tuning a single layer is enough to remove the backdoor.

Original: Therefore, in order to achieve a smooth minima in a single-layer fine-tuning scenario, we propose to use an
Revised: Therefore, in order to achieve a smooth minima in a single-layer fine-tuning scenario, we propose to use an

Original: FIM based DNN objective function and minimize it using a curvature-aware NGD optimizer.
Revised: FIM based DNN objective function and minimize it using a curvature-aware NGD optimizer.

Original: Our proposed method achieves SOTA performance in a wide range of benchmarks.
Revised: Our proposed method achieves SOTA performance in a wide range of benchmarks.

Original: Since we fine-tune only one layer the training time overhead reduces significantly, making our method one of the fastest among SOTA defenses.
Revised: Since we fine-tune only one layer the training time overhead reduces significantly, making our method one of the fastest among SOTA defenses.

Original: In the future, we aim to extend our smoothness analysis to 3D point-cloud attacks as well as attacks on contrastive learning.
Revised: In the future, we aim to extend our smoothness analysis to 3D point-cloud attacks as well as attacks on contrastive learning.

Original: A A PPENDIX
Revised: A A PPENDIX

Original: Section B describes our proposed algorithm.
Revised: Section B describes our proposed algorithm.

Original: Section C discusses the intuitions behind the uses of clean data distribution for smoothness analysis.
Revised: Section C.1 discusses the intuitions behind the uses of clean data distribution for smoothness analysis.

Original: Section D contains the experimental details of different attacks and defenses.
Revised: Section D contains the experimental details of different attacks and defenses.

Original: Section E contain comparison with another recent defense technique.
Revised: Section E contain comparison with another recent defense technique.

Original: We present smoothness analysis with different datasets and architectures in Section F. Section G shows the Label Correction Rates for different defense techniques.
Revised: We present smoothness analysis with different datasets and architectures in Section F. Section G shows the Label Correction Rates for different defense techniques.

Original: Section H
Revised: Section H

Original: and I contain additional runtime analysis.
Revised: and I contain additional runtime analysis.

Original: Section K contains more ablation studies purification with last layer re-initialization.
Revised: Section K contains more ablation studies purification with last layer re-initialization.

Original: Section L and M discuss more attacks, all2all and combined attacks.
Revised: Section L and M discuss more attacks, all2all and combined attacks.

Original: Our code is available at anonymous GitHub link 3 .
Revised: Our code is available at anonymous GitHub link 3 .

Original: B N ATURAL G RADIENT F INE - TUNING
Revised: B N ATURAL G RADIENT F INE - TUNING

Original: In our proposed method, we aim to remove backdoor by fine-tuning only the last layer.
Revised: In our proposed method, we aim to remove backdoor by fine-tuning only the last layer.

Original: The manner in which we perform that fine-tuning is described in Algorithm 1.
Revised: The manner in which we perform that fine-tuning is described in Algorithm 1.

Original: After purification, the model should behave like a benign/clean model producing same prediction irrespective of the presence of trigger.
Revised: After purification, the model should behave like a benign/clean model producing same prediction irrespective of the presence of trigger.

Original: Note that Kirkpatrick et al.
Revised: Note that Kirkpatrick et al.

Original: (2017) proposed a similar regularizer, known as elastic weight consolidation (EWC) used in continual learning.
Revised: (2017) proposed a similar regularizer, known as elastic weight consolidation (EWC) used in continual learning.

Original: EWC helps a model to learn a new task while keeping the knowledge of previously learned tasks.
Revised: EWC helps a model to learn a new task while keeping the knowledge of previously learned tasks.

Original: Our clean data distribution aware regularization, instead, only helps to preserve the knowledge of previously learned task corresponding to clean data distribution (not task corresponding to poison samples) through computing ¯ F using clean validation set.
Revised: Our clean data distribution aware regularization, instead, only helps to preserve the knowledge of previously learned task corresponding to clean data distribution (not task corresponding to poison samples) through computing ¯ F using clean validation set.

Original: Thus, the design of our regularizer is backdoor specific and needs careful attention as it is crucial for clean test performance. 
Revised: Thus, the design of our regularizer is backdoor specific and needs careful attention as it is crucial for clean test performance. Input:

Original: [Table]
Revised: [Table]

Original: [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation] [Table] [Equation] [Table]
Revised: Purification

Original: [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original: // ¯ 
Revised: // ¯ θ

Original: [Equation]
Revised: [Equation]

Original: is the last layer’s parameter of initial backdoor model.
Revised: is the last layer’s parameter of initial backdoor model.

Original: for i = 1 to N do
Revised: for i = 1 to N do

Original: Calculate 
Revised: Calculate loss, L = L

Original: [Equation] [Table]
Revised: [Equation] [Equation]

Original: // θiL is the last layer’s parameter at i th iterations
Revised: , f θ i ( X )) + η 2 (cid:80) j

Original: [Table]
Revised: ( diag ( ¯ F )) j · ( θ iL,j − ¯ θ L,j ) F ← 1 | D val | (cid:80) x ∈X ,y ∈Y (cid:20) ∇ θ iL y log f θ i ( x ) · (cid:16) ∇ θ iL y log

Original:  //α is the learning rate
Revised: f θ i ( x ) (cid:17) T (cid:21) //

Original: [Table]
Revised: θ iL is the last layer’s parameter at i th iterations θ i +1 L ← θ iL − α · F − 1 ∇ θ iL ( L ) // α is the learning rate θ i +1 ← { W 0 , 1 , W 1 , 2 , · · · , W L − 2 ,L − 1 ,

Original:  //W i,i [Table]
Revised: θ i +1 L } //

Original:  ’s are frozen parameters [Table] // θ p is the purified model’s parameter
Revised: W i,i +1 ’s are frozen parameters θ p ← { W 0 , 1 , W 1 , 2 , · · · , W L − 2 ,L − 1 , θ N L } // θ p is the purified model’s parameter

Original: Output: Purified Model, f 
Revised: Output: Purified Model, f θ p

Original: [Table] p C  W HY S MOOTHNESS A NALYSIS W . R . T C LEAN D ISTRIBUTION ?
Revised: C M ORE EXPLANATIONS ON S MOOTHNESS AND B ACKDOOR C. W HY S MOOTHNESS A NALYSIS W . R . T C LEAN D ISTRIBUTION ?

Original: In general, a backdoor model is usually well optimized w.r.t clean and poison data distribution.
Revised: In general, a backdoor model is usually well optimized w.r.t clean and poison data distribution.

Original: Therefore, it is designed to perform well on both distributions.
Revised: Therefore, it is designed to perform well on both distributions.

Original: If we look at the smoothness analysis of backdoor models w.r.t.
Revised: If we look at the smoothness analysis of backdoor models w.r.t.

Original: original poisoned training data (both data distributions), the loss surface will be smoother.
Revised: original poisoned training data (both data distributions), the loss surface will be smoother.

Original: However, looking from only clean distribution point of view the loss surface is sharper as we have described in the paper.
Revised: However, looking from only clean distribution point of view the loss surface is sharper as we have described in the paper.

Original: Backdoor purification implies that the model will only be sensitive to clean data distribution and completely ignore any type of backdoor manipulations.
Revised: Backdoor purification implies that the model will only be sensitive to clean data distribution and completely ignore any type of backdoor manipulations.

Original: Since the model’s behavior w.r.t.
Revised: Since the model’s behavior w.r.t.

Original: clean distribution is of our particular interest, we perform the smoothness analysis w.r.t.
Revised: clean distribution is of our particular interest, we perform the smoothness analysis w.r.t.

Original: clean distribution in all cases.
Revised: clean distribution in all cases.

Original: If we put it another way, making the loss surface smooth w.r.t.
Revised: If we put it another way, making the loss surface smooth w.r.t.

Original: clean distribution ensures that the model will automatically forget the poison distribution, i.e. , backdoor purification.
Revised: clean distribution ensures that the model will automatically forget the poison distribution, i.e. , backdoor purification.

Original: Another minor reason is that, we are able to distinguish the behavior of benign and backdoor models because we consider clean distribution.
Revised: Another minor reason is that, we are able to distinguish the behavior of benign and backdoor models because we consider clean distribution.

Original: This is the only common distribution between these models, and one has to perform smoothness analysis w.r.t.
Revised: This is the only common distribution between these models, and one has to perform smoothness analysis w.r.t.

Original: a common distribution to distinguish them.
Revised: a common distribution to distinguish them.

Original: D E XPERIMENTAL D ETAILS
Revised: C. W HY SMOOTHNESS IS THE KEY TO REMOVING THE BACKDOOR ?

Revised: One key observation from the smoothness study is that: there exists a key difference between weightloss surface smoothness (estimated by loss hessian ) of a backdoor and a benign model w.r.t. clean distribution—the weight-loss surface of a backdoor model is less smooth compared to a benign model. To further elaborate, let us consider feeding a clean sample to a backdoor model.

Revised: By definition, it will predict the correct ground truth label.

Revised: Now, consider feeding a sample with a backdoor trigger on it.

Revised: The model will predict the adversary-set target label implying significant changes in prediction distribution.

Revised: This significant change can be explained by the surface smoothness.

Revised: In order to accommodate this significant change in prediction, the model must adjust itself accordingly.

Revised: Such adjustment leads to non-smoothness in the weight-loss surface.

Revised: A non-smooth surface causes significant changes in loss gradient for specific inputs.

Revised: In our case, these specific inputs are backdoortriggered samples.

Revised: As the magnitude of a trigger is usually very small compared to the total input magnitude, the model has to experience quite a significant change in its weight space to cause large loss changes.

Revised: We characterize this change in terms of smoothness.

Revised: In summary, for a model to show certain backdoor behavior, there are some specific changes that take place in the weight space.

Revised: In this work, we try to explain these changes in terms of weight-loss surface smoothness.

Revised: Our intuition is well supported by our comprehensive empirical evaluations.

Revised: C. W HY U SE F ISHER I NFORMATION M ATRIX FOR A CHIEVING S MOOTHNESS ?

Revised: In Fisher Information Matrix (FIM) based optimization, the natural gradient is defined as F − 1 ∇ L (ref.

Revised: Eq. 5).

Revised: From the perspective of information geometry, natural gradient defines the direction in parameter space which gives largest change in objective per unit of change in model ( p ( y | x, θ ) ) .

Revised: Per unit of change in model is measured by KL-divergence.

Revised: Note that KL-divergence is well connected with FIM as it can be used as a local quadrature approximation of KL-divergence of model change .

Revised: Eqn. 2 suggests that one requires the knowledge of the original parameter ( θ ) space to estimate it.

Revised: Therefore, FIM can be thought of as a mechanism to translate between the geometry of the model ( p ( y | x, θ ) ) and the current parameters ( θ ) of the model.

Revised: The way natural gradient defined the direction in parameter space is contrastive to the stochastic gradient.

Revised: Stochastic gradient defines the direction in parameter space for largest change in objective per unit of change in parameter ( θ ) measured by Eucludian distance.

Revised: That is, the gradient direction is solely calculated based on the changes of parameters, without any knowledge of model geometry.

Revised: As FIM-based optimization minimizes the changes in model , the model itself cannot significantly change at each iteration.

Revised: So, the overall optimization process goes through comparatively smoother transition and finally reaches smoother minima in comparison with SGD-based optimization 4 .

Revised: C. W HY SAM U NDERPERFORMS ?

Revised: One-layer optimization becomes a shallow network optimization problem for which there can exist many bad local minima.

Revised: For such an optimization problem, typically first-order optimizers perform poorly mainly for the unawareness of loss surface curvature geometry.

Revised: In the case of SAM, it uses

Revised: SGD as the optimizer.

Revised: Informally, the working principle of SAM is: at each iteration, SAM tries to minimize the maximum loss within a certain area in the loss weight space.

Revised: Note that the formulation of finding the maximum loss in a certain area is based on ‘Euclidean distance’ metric which does not capture the curvature information of the plane.

Revised: Although SAM performs better than vanilla SGD in deep network 5 in terms of smoother optimization point, SAM’s performance in shallow network (our case) is almost similar to vanilla SGD.

Revised: Two potential reasons behind this poor performance are (i) using a predefined local area to search for maximum loss, and (ii) using ‘Euclidean distance’ metric instead of geometric distance metric.

Revised: In contrast, NGD with curvature geometry aware Fisher

Revised: Information Matrix can successfully avoid such bad minima and optimizes to a global minima.

Revised: D E XPERIMENTAL D ETAILS

Original: For creating backdoor models with CIFAR10 (Krizhevsky et al., 2009), we train a PreActResNet
Revised: For creating backdoor models with CIFAR10 (Krizhevsky et al., 2009), we train a PreActResNet

Original: (He et al., 2016) model using an SGD optimizer with an initial learning rate of 0.01, learning rate decay of 0.1/100 epochs for 250 epochs.
Revised: (He et al., 2016) model using an SGD optimizer with an initial learning rate of 0.01, learning rate decay of 0.1/100 epochs for 250 epochs.

Original: We also use a weight decay of 5 e − 4 with momentum of 0.9.
Revised: We also use a weight decay of 5 e − 4 with momentum of 0.9.

Original: We use a longer backdoor training to ensure a satisfactory attack success rate.
Revised: We use a longer backdoor training to ensure a satisfactory attack success rate.

Original: We use a batch size of 128.
Revised: We use a batch size of 128.

Original: For GTSRB (Stallkamp et al., 2011), we train a WideResNet-16-1 (Zagoruyko & Komodakis, 2016) model for 200 epochs with a learning rate of 0.01 and momentum of 0.9.
Revised: For GTSRB (Stallkamp et al., 2011), we train a WideResNet-16-1 (Zagoruyko & Komodakis, 2016) model for 200 epochs with a learning rate of 0.01 and momentum of 0.9.

Original: We also regularize the weights with a weight-decay of 5 e − 4 We rescale each training image to 32 × 32 before feeding them to the model.
Revised: We also regularize the weights with a weight-decay of 5 e − 4 We rescale each training image to 32 × 32 before feeding them to the model.

Original: The training batch size is 128 and an SGD optimizer is used for all training.
Revised: The training batch size is 128 and an SGD optimizer is used for all training.

Original: We further created backdoor models trained on the Tiny-ImageNet and ImageNet datasets.
Revised: We further created backdoor models trained on the Tiny-ImageNet and ImageNet datasets.

Original: For Tiny-ImageNet, we train the model for 150 epochs with a learning rate of 0.005, a decay rate of 0.1/60 epochs, and a weight decay of 1e-4.
Revised: For Tiny-ImageNet, we train the model for 150 epochs with a learning rate of 0.005, a decay rate of 0.1/60 epochs, and a weight decay of 1e-4.

Original: For ImageNet, we train the model for 200 epochs with a learning rate of 0.
Revised: For ImageNet, we train the model for 200 epochs with a learning rate of 0.

Original: with a decay rate of 0.1/75 epochs.
Revised: with a decay rate of 0.1/75 epochs.

Original: We also employ 0.9 and 1e-4 for momentum and weight decay, respectively.
Revised: We also employ 0.9 and 1e-4 for momentum and weight decay, respectively.

Original: The details of these four datasets are presented in Table 7.
Revised: The details of these four datasets are presented in Table 7.

Original: D. D ETAILS OF A TTACKS
Revised: D. D ETAILS OF A TTACKS

Original: We use 11 different attacks for CIFAR10.
Revised: We use 11 different attacks for CIFAR10.

Original: Each of them differs from each other in terms of either label mapping type or trigger properties.
Revised: Each of them differs from each other in terms of either label mapping type or trigger properties.

Original: For label poisoning attack, we use a fixed poison rate of 10%.
Revised: For label poisoning attack, we use a fixed poison rate of 10%.

Original: However, we need to increase this rate to 80% for CLB and SIG.
Revised: However, we need to increase this rate to 80% for CLB and SIG.

Original: For Blend and SIG attacks, we use a image-trigger mixup ratio of 0.2.
Revised: For Blend and SIG attacks, we use a image-trigger mixup ratio of 0.2.

Revised: WaNet adopts a universal wrapping augmentation as the backdoor trigger.

Revised: Note that WaNet can be considered as an non-additive attack since it works like a augmentation technique with direct information insertion or addition like Badnets or TrojanNet.

Revised: ISSBA adds specific trigger to each input that is of low magnitude and imperceptible.

Revised: Both of these methods are capable of evading some existing defenses.

Original: For BPPA attack, we follow the PyTorch implementation 4 .
Revised: For BPPA attack, we follow the PyTorch implementation 6 .

Original: For Feature attack, we create backdoor model based on this implementation 5 .
Revised: For Feature attack, we create backdoor model based on this implementation 7 .

Original: Apart from clean-label attacks, we use a poison rate of 10% for creating backdoor attacks.
Revised: Apart from clean-label attacks, we use a poison rate of 10% for creating backdoor attacks.

Original: The details of these attacks are presented in Table 8.
Revised: The details of these attacks are presented in Table 8.

Original: In addition to theses attacks, we also consider ’All2All’ attacks (Troj-all, Dyn-all) where we have more than one target label.
Revised: In addition to theses attacks, we also consider ’All2All’ attacks (Troj-all, Dyn-all) where we have more than one target label.

Original: To implement this attack, we change the given label i to the target label i + 1 .
Revised: To implement this attack, we change the given label i to the target label i + 1 .

Original: For class 9, the target label is 0.
Revised: For class 9, the target label is 0.

Original: [Table]
Revised: [Table]

Original: D. NGF AND O THER O PTIMIZER I MPLEMENTATION D ETAILS
Revised: D. NGF AND O THER O PTIMIZER I MPLEMENTATION D ETAILS

Original: To implement our proposed algorithm, we freeze the CNN backbone of the model and only fine-tune the linear or classification layer parameters.
Revised: To implement our proposed algorithm, we freeze the CNN backbone of the model and only fine-tune the linear or classification layer parameters.

Original: We perform the fine-tuning for 100 epochs with a learning rate of 0.01, weight decay of 1 e − 4 , momentum of 0.9, and a batch size of 128.
Revised: We perform the fine-tuning for 100 epochs with a learning rate of 0.01, weight decay of 1 e − 4 , momentum of 0.9, and a batch size of 128.

Original: For studies with different optimizers (Adam, RMSProp, etc. ), we use similar training settings as NGF.
Revised: For studies with different optimizers (Adam, RMSProp, etc. ), we use similar training settings as NGF.

Original: For sharpness-aware minimization, we restrict the search region for the SGD optimizer.
Revised: For sharpness-aware minimization, we restrict the search region for the SGD optimizer.

Original: We follow
Revised: We follow

Original: Pytorch implementation described here 6 .
Revised: Pytorch implementation described here 8 .

Original: We use a batch size of 128 and a learning rate of 0.01 for
Revised: We use a batch size of 128 and a learning rate of 0.01 for

Original: SAM.
Revised: SAM.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: D. D ETAILS OF O THER D EFENSES
Revised: D. D ETAILS OF O THER D EFENSES

Original: For experimental results with ANP (Wu & Wang, 2021), we follow the source code implementation 7 .
Revised: For experimental results with ANP (Wu & Wang, 2021), we follow the source code implementation 9 .

Original: After creating each of the above mentioned attacks, we apply adversarial neural pruning on the backdoor model for 500 epochs with a learning rate of 0.02.
Revised: After creating each of the above mentioned attacks, we apply adversarial neural pruning on the backdoor model for 500 epochs with a learning rate of 0.02.

Original: We use the default settings for all attacks.
Revised: We use the default settings for all attacks.

Original: For vanilla FT, we perform simple DNN fine-tuning with a learning rate of 0.01 for 125 epochs.
Revised: For vanilla FT, we perform simple DNN fine-tuning with a learning rate of 0.01 for 125 epochs.

Original: We higher number of epochs for FT due to its poor clean test performance.
Revised: We higher number of epochs for FT due to its poor clean test performance.

Original: The clean validation size is 1% for both of these methods.
Revised: The clean validation size is 1% for both of these methods.

Original: For NAD (Li et al., 2021b), we increase the  validation data size to 5% and use teacher model to guide the attacked student model.
Revised: For I-BAU (Zeng et al., 2021), we follow their PyTorch Implementationand purify the model for 10 epochs. We use 5% validation data for I-BAU.

Original: We perform the training with distillation loss proposed in NAD 8 . For MCR (Zhao et al., 2020a), the training goes on forepochs according to the provided implementation 9 .
Revised: For AWM (Chai & Chen, 2022), we train the model for 100 epochs and use Adam optimizer with a learning rate of 0.01 and a wight decay of 0.001. We use the default hyper-parameter setting as described in their work α = 0 .

Revised: 9 , β = 0 .

Original:  Above settings is for CIFAR10 and GTSRB only.
Revised: 1 , γ = 108 , η = 1000 . Above settings is for CIFAR10 and GTSRB only.

Original: For Tiny-ImageNet, we keep most of the training settings similar except reducing the number of epochs significantly.
Revised: For Tiny-ImageNet, we keep most of the training settings similar except reducing the number of epochs significantly.

Original: We also increase the validation size to 5% for vanilla FT and ANP.
Revised: We also increase the validation size to 5% for vanilla FT, ANP, and AWM.

Original: For NAD, we use a higher valiadtion size of 8%.
Revised: For I-BAU, we use a higher valiadtion size of 10%.

Original: For purification, we apply ANP, NAD and MCR for 30  epochs and Vanilla FT for 25 epochs.
Revised: For purification, we apply ANP and AWM for 30 epochs, I-BAU for 5 epochs and Vanilla FT for 25 epochs.

Original: For ImageNet, we use a 3% validation size for all defenses  and use different number of purification epochs for different methods.
Revised: For ImageNet, we use a 3% validation size for all defenses (except for I-BAU, we use 5% validation data) and use different number of purification epochs for different methods.

Original: We apply MCR and NAD for 2 epochs.
Revised: We apply I-BAU for 2 epochs.

Original: On the other hand, ANP and vanilla FT trains the model for 3 epochs.
Revised: On the other hand, we train the model for 3 epochs for ANP, AWM and vanilla FT. [Table] [Table]

Original: E C OMPARISON WITH A DDITIONAL D EFENSE
Revised: E C OMPARISON WITH A DDITIONAL D EFENSE

Original: In Table 9, we show the comparison of NGF with a recently proposed defense technique based on channel Lipschitzness Pruning (CLP) (Zheng et al., 2022) that works without any data.
Revised: In Table [Table] we show the comparison of NGF with a recently proposed defense technique based on channel Lipschitzness Pruning (CLP) (Zheng et al., 2022) that works without any data.

Original: We follow the
Revised: We follow the

Original: [Table]

Original: [Table]

Original: Github link 10 .
Revised: Github link 11 .

Original: Based on the trigger-activated change on channel activation, CLP prunes channel.
Revised: Based on the trigger-activated change on channel activation, CLP prunes channel.

Original: One disadvantage of pruning based method is that in case of challenging scenarios, e.g. ,, strong attacks, large datasets and models etc. , it prunes neurons abruptly.
Revised: One disadvantage of pruning based method is that in case of challenging scenarios, e [Table] g. ,, strong attacks, large datasets and models etc. , it prunes neurons abruptly.

Original: This creates high possibility of pruning neurons sensible to clean data distribution.
Revised: This creates high possibility of pruning neurons sensible to clean data distribution.

Original: In turn, the clean test accuracy may decrease significantly in some scenario.
Revised: In turn, the clean test accuracy may decrease significantly in some scenario.

Original: As shown in Table 9, clean accuracies (ACCs) for Blend, Trojan and CLB attacks are much lower compared to NGF.
Revised: As shown in Table 9, clean accuracies (ACCs) for Blend, Trojan and CLB attacks are much lower compared to NGF.

Original: Even though CLP performs reasonably well at removing backdoor,
Revised: Even though CLP performs reasonably well at removing backdoor,

Original: NGF still outperforms in that area.
Revised: NGF still outperforms in that area.

Original: F M ORE ON S MOOTHNESS A NALYSIS
Revised: F M ORE ON S MOOTHNESS A NALYSIS

Original: For smoothness analysis, we follow the PyHessian implementation 11 and modify it according to our needs.
Revised: For smoothness analysis, we follow the PyHessian implementation 12 and modify it according to our needs.

Original: We use a single batch with size 200 to calculate the loss Hessian for all attacks with CIFAR and GTSRB datasets.
Revised: We use a single batch with size 200 to calculate the loss Hessian for all attacks with CIFAR and GTSRB datasets.

Original: We conduct further smoothness analysis for ImageNet dataset and different architectures.
Revised: We conduct further smoothness analysis for ImageNet dataset and different architectures.

Original: In Fig.
Revised: In Fig.

Original: 5, we show the Eigen density plots for different 5 different attacks.
Revised: 5, we show the Eigen density plots for different 5 different attacks.

Original: We used
Revised: We used

Original: A40 GPUs with 96GB system memory.
Revised: A40 GPUs with 96GB system memory.

Original: However, it was not enough to calculate the loss hessian if we consider all 1000 classes of ImageNet.
Revised: However, it was not enough to calculate the loss hessian if we consider all 1000 classes of ImageNet.

Original: Due to GPU memory constraint, we consider ImageNet subset with 12 classes.
Revised: Due to GPU memory constraint, we consider ImageNet subset with 12 classes.

Original: We train a ResNet34 architecture with 5 different attacks.
Revised: We train a ResNet34 architecture with 5 different attacks.

Original: To calculate the loss hessian, we use a batch size of 50.
Revised: To calculate the loss hessian, we use a batch size of 50.

Original: Density plots before and after purification further confirms our proposed hypothesis.
Revised: Density plots before and after purification further confirms our proposed hypothesis.

Original: To test our hypothesis for larger architectures, we consider 5 different architectures for CIFAR10, i.e. , VGG19 (Simonyan & Zisserman, 2014), MobileNetV2 (Sandler et al., 2018), DenseNet121 (Huang et al., 2017), GoogleNet (Szegedy et al., 2014), Inception-V3 (Szegedy et al., 2016).
Revised: To test our hypothesis for larger architectures, we consider 5 different architectures for CIFAR10, i.e. , VGG19 (Simonyan & Zisserman, 2014), MobileNetV2 (Sandler et al., 2018), DenseNet121 (Huang et al., 2017), GoogleNet (Szegedy et al., 2014), Inception-V3 (Szegedy et al., 2016).

Original: Each of the architectures is deeper compared to the ResNet18 architecture we consider for CIFAR10.
Revised: Each of the architectures is deeper compared to the ResNet18 architecture we consider for CIFAR10.

Original: Due to their large size, showing the effectiveness of NGF in case of these architecture will strengthen our claim— one layer NGF based fine-tuning is enough for backdoor purification.
Revised: Due to their large size, showing the effectiveness of NGF in case of these architecture will strengthen our claim— one layer NGF based fine-tuning is enough for backdoor purification.

Original: In
Revised: In

Original: Fig.
Revised: Fig.

Original: 6, we show the performance of NGF when backdoor models are created using these architectures.
Revised: 6, we show the performance of NGF when backdoor models are created using these architectures.

Original: Our proposed one layer fine-tuning successfully removes the backdoor in all of these scenarios.
Revised: Our proposed one layer fine-tuning successfully removes the backdoor in all of these scenarios.

Original: G L ABEL C ORRECTION R ATE OF D IFFERENT D EFENSES
Revised: G L ABEL C ORRECTION R ATE OF D IFFERENT D EFENSES

Original: In standard removal measurement, it is sufficient for backdoored images to be classified as a non-target class.
Revised: In standard removal measurement, it is sufficient for backdoored images to be classified as a nontarget class.

Original: As we calculate ASR after removal, our evaluation follows standard measurement.
Revised: As we calculate ASR after removal, our evaluation follows standard measurement.

Original: However, we also consider the reviewer’s second point.

Original: We define the correction rate (CR) as the percentage of poisonous samples correctly classified to their original classes.
Revised: We define the correction rate (CR) as the percentage of poisonous samples correctly classified to their original classes.

Original: We define the method with the highest value of CR as the best performing or SOTA method.
Revised: We define the method with the highest value of CR as the best performing or SOTA [Table] [Table] [Table]

Original:  We use the CIFAR10 dataset anddifferent attacks for demonstration.
Revised: method. We use the CIFAR10 dataset and 4 different attacks for demonstration.

Original: It can be observed from Table 10 that our method obtains SOTA correction performance for most of these attacks.[Table] [Table] [Table]
Revised: It can be observed from Table 10 that our method obtains SOTA correction performance for most of these attacks.

Original: H R UNTIME A NALYSIS OF O THER D EFENSES
Revised: H R UNTIME A NALYSIS OF O THER D EFENSES

Original: In Table [Table] we show the average runtime of other defenses.
Revised: In Table 11, we show the average runtime of other defenses.

Original: It can be observed that ANP is almost 6 x slower than NGF.
Revised: It can be observed that ANP is almost 6 x slower than NGF.

Original: Other defenses, NAD and MCR are also much slower than NGF.
Revised: Other defenses, NAD and MCR are also much slower than NGF.

Original: NAD uses transfer learning based distillation using a teacher-student framework.
Revised: NAD uses transfer learning based distillation using a teacher-student framework.

Original: However, the complexity of this method results in computational overhead.
Revised: However, the complexity of this method results in computational overhead.

Original: Instead, NGF revisits much simpler fine-tuning approach from one-layer optimization point of view.
Revised: Instead, NGF revisits much simpler fine-tuning approach from one-layer optimization point of view.

Original: Our simple and effective method leads to one of the fastest purification.
Revised: Our simple and effective method leads to one of the fastest purification.

Original: We take the average of all run times against 11 attacks on CIFAR10.
Revised: We take the average of all run times against 11 attacks on CIFAR10.

Original: Note that, for each epoch in NGF, we have to feed-forward all validation data.
Revised: Note that, for each epoch in NGF, we have to feed-forward all validation data.

Original: However, we only update the parameters of last layer through back-propagation.
Revised: However, we only update the parameters of last layer through back-propagation.

Original: The reason behind this is that we use different data augmentations while fine-tuning.
Revised: The reason behind this is that we use different data augmentations while fine-tuning.

Original: This does not allow us to save the CNN features one time and re-use it for upcoming all epochs.
Revised: This does not allow us to save the CNN features one time and re-use it for upcoming all epochs.

Original: I F INE - TUNING A LL L AYERS
Revised: I F INE - TUNING A LL L AYERS

Original: We have considered fine-tuning all layers fusing NGF and SGD.
Revised: We have considered fine-tuning all layers fusing NGF and SGD.

Original: Note that vanilla FT does fine-tune all layers.
Revised: Note that vanilla FT does fine-tune all layers.

Original: We report the performance of NGF for all layers in Table 12.
Revised: We report the performance of NGF for all layers in Table 12.

Original: While fine-tuning all layers seems to improve the performance, it takes almost 6 × more computational time than NGF on last layer.
Revised: While fine-tuning all layers seems to improve the performance, it takes almost 6 × more computational time than NGF on last layer.

Original: We perform NGF with the regularizer here.
Revised: We perform NGF with the regularizer here.

Original: [Table]
Revised: [Table]

Original: J E FFECT OF C LEAN V ALIDATION D ATA S IZE
Revised: J E FFECT OF C LEAN V ALIDATION D ATA S IZE

Original: We also present how the total number of clean validation data can impact the purification performance.
Revised: We also present how the total number of clean validation data can impact the purification performance.

Original: In Table 14, we see the change in performance while gradually reducing the validation size from 1% to 0.1%.
Revised: In Table [Table] we see the change in performance while gradually reducing the validation size from 1% to 0.1%.

Original: We consider Badnets attack on CIFAR10 dataset for this evaluation.
Revised: We consider Badnets attack on CIFAR10 dataset for this evaluation.

Original: Even with only(0.1%) data points, NGF can successfully remove the backdoor by bringing down the attack success rate (ASR) to 6.91%.
Revised: Even with only [Table] [Table] (0.1%) data points, NGF can successfully remove the backdoor by bringing down the attack success rate (ASR) to 6.91%.

Original: We also consider adversarial weight masking for this comparison.
Revised: We also consider adversarial weight masking for this comparison.

Original: For both
Revised: For both

Original: ANP and AWM, reducing the validation size has severe impact on the test accuracy (ACC).[Table] [Table]
Revised: ANP and AWM, reducing the validation size has severe impact on the test accuracy (ACC).

Original: K P URIFICATION U SING L AST L AYER R E -I NITIALIZATION
Revised: K P URIFICATION U SING L AST L AYER R E -I NITIALIZATION

Original: We also conduct studies on the behavioral difference of SGD and NGD while we re-initialize the last layer.
Revised: We also conduct studies on the behavioral difference of SGD and NGD while we re-initialize the last layer.

Original: Even though we re-initialize the last layer, one still has to properly fine-tune the backdoor model to remove the backdoor.
Revised: Even though we re-initialize the last layer, one still has to properly fine-tune the backdoor model to remove the backdoor.

Original: However, we see throughout our evaluations that SGD-based onelayer fine-tuning is not a proper fine-tuning method and unable to remove backdoor.
Revised: However, we see throughout our evaluations that SGD-based onelayer fine-tuning is not a proper fine-tuning method and unable to remove backdoor.

Original: In case of re-initialization, the shallow network optimization problem still stands as wells as the issue of bad local minima.
Revised: In case of re-initialization, the shallow network optimization problem still stands as wells as the issue of bad local minima.

Original: Therefore, SGD shows similar behavior in this scenario too.
Revised: Therefore, SGD shows similar behavior in this scenario too.

Original: Table 13 shows the performance of SGD and NGF in case one decides to re-initialize the layer than fine-tunes.
Revised: Table 13 shows the performance of SGD and NGF in case one decides to re-initialize the layer than fine-tunes.

Original: As usual,
Revised: As usual,

Original: NGF is able to reach smooth minima due to its ability to properly fine-tune the model.
Revised: NGF is able to reach smooth minima due to its ability to properly fine-tune the model.

Original: L M ORE A LL 2A LL A TTACKS
Revised: L M ORE A LL 2A LL A TTACKS

Original: Most of the defenses evaluate their methods on only All2One attack where we consider only one target label.
Revised: Most of the defenses evaluate their methods on only All2One attack where we consider only one target label.

Original: However, there can be multiple target classes in a practical attack scenario.
Revised: However, there can be multiple target classes in a practical attack scenario.

Original: We consider one such case: All2All attack where target classes are uniformly distributed among all available classes.
Revised: We consider one such case: All2All attack where target classes are uniformly distributed among all available classes.

Original: In Table 15, we show the performance under such settings for 3 different attacks with a poison rate of 10% .
Revised: In Table 15, we show the performance under such settings for 3 different attacks with a poison rate of 10% .

Original: It shows that All2All attack is more challenging to defend against as compared to All2One attack.
Revised: It shows that All2All attack is more challenging to defend against as compared to All2One attack.

Original: However, the performance of NGF seems to be consistently better than other defenses for both of these attack variations.
Revised: However, the performance of NGF seems to be consistently better than other defenses for both of these attack variations.

Original: For reference, we achieve an ASR improvement of 3 .
Revised: For reference, we achieve an ASR improvement of 3 .

Original: 12% over ANP while maintaining a lead in classification accuracy too.
Revised: 12% over ANP while maintaining a lead in classification accuracy too.

Original: M C OMBINING D IFFERENT B ACKDOOR A TTACKS
Revised: M C OMBINING D IFFERENT B ACKDOOR A TTACKS

Original: We also perform experiments with combined backdoor attacks.
Revised: We also perform experiments with combined backdoor attacks.

Original: To create such attacks, we poison some portion of the training data using 3 different attacks; Badnets, Blend, and Trojan.
Revised: To create such attacks, we poison some portion of the training data using 3 different attacks; Badnets, Blend, and Trojan.

Original: Each of these attacks have an equal share in the poison data.
Revised: Each of these attacks have an equal share in the poison data.

Original: As shown in Table 16, we use 4 different poison rates: 10% ∼ 50% .
Revised: As shown in Table 16, we use 4 different poison rates: 10% ∼ 50% .

Original: NGF outperforms other baseline methods (MCR and ANP) by a satisfactory margin. 
Revised: NGF outperforms other baseline methods (MCR and ANP) by a satisfactory margin. [Figure]

Original: N D ECISION H EATMAP
Revised: N D ECISION H EATMAPS : H OW NGF REMOVES B ACKDOOR ?

Revised: While inserting the backdoor behavior, the model, especially the linear classification layer, memorizes the poison data distribution. By memorization, we mean it memorizes the simpler trigger pattern. Whenever the model sees that pattern in the input, it prioritizes the trigger-specific feature instead of image-specific (clean part) feature and predicts the adversary-set target label.

Revised: When we re-train or fine-tune the classifier with clean validation data, the classifier forgets the poison distribution as finetuning reinforces the dominance of clean features in model prediction.

Revised: After fine-tuning, the model looks for image-specific features for prediction as it has almost no memory of the trigger-specific features.

Original: We illustrate the decision heat-maps for clean, backdoor and purified model in Figure 4.
Revised: We illustrate the decision heat-maps for clean, backdoor and purified model in Figure 4.

Original: We show the decision heatmaps for clean an poison data.
Revised: We show the decision heatmaps for clean an poison data.

Original: As clean model is only trained on clean data, it is not sensitive to the trigger.
Revised: As clean model is only trained on clean data, it is not sensitive to the trigger.

Original: Our defense objective says that, a purified model should behave like a benign model, i.e. , the decision making process (for clean and poison data) should resemble a clean model.[Figure]
Revised: Our defense objective says that, a purified model should behave like a benign model, i.e. , the decision making process (for clean and poison data) should resemble a clean model.

Original: As we can see for the poison data, NGF successfully removes the effect of the trigger.
Revised: As we can see for the poison data, NGF successfully removes the effect of the trigger.

Original: The purified model ignores the trigger while making decisions.
Revised: The purified model ignores the trigger while making decisions.

Original: [Figure]
Revised: [Figure]

Original: [Table] 
Revised: [Table] [Figure] [Table] [Figure]

Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table] [Figure] 
Revised: [Table] [Figure] [Table]

Original: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]

Original: [Figure][Table] [Figure] [Figure]
Revised: [Figure]