暗恋学妹的黑框眼镜 · 原生js给一个元素绑定click事件(三种实 ...· 5 月前 · |
完美的硬盘 · R预言错误: ...· 6 月前 · |
坚强的煎鸡蛋 · python将dataframe转换为lis ...· 1 年前 · |
心软的蘑菇 · 云原生面经分享:精心整理的 K8s / ...· 1 年前 · |
酷酷的仙人球 · oracle ...· 1 年前 · |
玉树临风的山羊
1 年前 |
Research on analyzing ML applications in adversarial settings can be studied in three main groups: 1) literature reviews , 2) analytical taxonomies , and 3) best practices . The first group provides a valuable set of knowledge about the state-of-the-art security threats to ML applications and possible solutions, but does not go further than reviewing and discussing the current research [ 38 ]–[ 47 ]. The second type of research provides taxonomies for in-depth analysis and evaluation of the security issues in ML applications [ 20 ], [ 48 ]. The early research by Barreno et al. [ 49 ] provides a taxonomy of attacks and defenses in adversarial ML. In their research, the effects of attacks and defenses on the integrity and availability of the target system are studied. However, the mentioned work leaves more detailed analysis of the arms race between attacks and defenses as future research. Some recent research on adversarial ML covers the arms race [ 11 ], [ 12 ], [ 41 ], [ 48 ], [ 50 ]–[ 62 ]. These works can be studied under three main subcategories: a) data-driven [ 41 ], [ 63 ]–[ 65 ], b) algorithm-driven [ 60 ], [ 62 ], [ 66 ], and c) application-driven [ 52 ], [ 53 ], [ 58 ], [ 61 ], [ 67 ], [ 68 ] taxonomies. As an example of data-driven research, Liu et al. [ 41 ] categorize attacks and defenses based on the data type (i.e. training or testing). In algorithm-driven approach, Ling et al. [ 62 ] develop a taxonomy by providing a platform, which implements several state-of-the-art attacks and defenses. The platform enables testing and evaluating deep learning applications under attacks and the effectiveness of available defenses. As an example of application-driven taxonomies, Laskov et al. [ 53 ] propose a taxonomy that focuses on the effect of adversary’s knowledge on the attack success rate and possible defense solutions in an on-line PDF malware detector (i.e. PDFRATE [ 69 ]). Although these works provide in-depth analysis of the arms race, they are highly dependent on specific data types, algorithms, or applications. In this case, they may not efficiently adapt to cover a wide range of applications or potential future threats. Our research proposes a system-driven taxonomy that surveys the state-of-the-art research based on the system models of its adversary, the ML application, and the defense mechanism to derive a comprehensive model of their interactions. The developed model, is independent from a specific data type, algorithm, or application, that not only covers existing works, but also reveals potential vulnerabilities that have not yet been addressed by the current research. It can also be used to identify specific defense strategies that can be added to an existing ML application to manage its vulnerabilities to attacks. Finally, the third group contains best practices, which provide some intuitive suggestions on the potential research gaps and high level guidelines for filling them [ 37 ]. Our work provides a framework to evaluate recent research in terms of the guidelines proposed in visionary research [ 37 ] and similar works. As an example, the works by Biggio et al. (2015) [ 70 ] and Zhang et al. (2016) [ 71 ] implement the same attack exploiting the same adversary model (Biggio et al. (2013) [ 17 ]), but achieve different success rates. However, a close look at Biggio et al. (2015) [ 70 ] suggests that a defense already exists. Since Zhang et al. (2016) [ 71 ] is a later work, to maintain the arms race, it is expected that the work should have considered the defense proposed in Biggio et al. (2015) [ 70 ] as a part of the ML application. However, our taxonomy shows otherwise. Although Zhang et al. (2016) [ 71 ] adds great value by improving the success rate of the attack, it however destructs the arms race, since there have been no other works that continue from where they left off.
Fig. 3 shows a generic process model in ML-based applications utilizing supervised learning (in the rest of the paper, ML refers to supervised learning for classification). A ML application operates in two phases: 1) training and 2) testing . In the training phase, labeled raw data (i.e. training raw data ) is used to set the machine parameters in a way to match a significant amount of the raw data samples to their corresponding labels. In the testing phase, labels are assigned to unlabeled raw data by passing through the trained machine. The input data can have different types, such as text [ 72 ], signal [ 73 ], 2D image [ 74 ], 3D image [ 75 ], or video [ 76 ]. Fig. 7 provides a taxonomy of the state-of-the-art research based on their dataset and ML algorithm. The figure shows most of the works focus on image and CNN, while signal, text, video, and classic ML draw less attention. Table III summarizes the specifications of the state-of-the-art target systems under perturbation attack. The accuracy (Acc.) is defined as the number of correct classification of the test data samples, out of the total number of samples. Any data other than training and testing raw data (a.k.a. original data ), but with the same type is called surrogate raw data , such as traffic signs images of another country for a ML applications that have been trained by US traffic signs. Surrogate data may have the same distribution as the original data.
After receiving the input raw data, some preprocessing algorithms such as normalization or filtering are applied on the data for noise reduction. In the next step, a feature extractor derives a feature vector from the input raw data by mapping the samples in the raw data domain to samples in the feature domain. The feature extractor is often intended to reduce the data dimensionality that assists in classifying the data [ 87 ]. It is noteworthy that some recent ML algorithms, such as CNN do not need a separate feature extractor component and features are extracted as a part of the training process, which still follow the model in Fig. 3 . Derived features from training, testing, and surrogate raw data, are respectively called, training , testing , and surrogate features .
Fig. 4 categorizes ML algorithms in two main groups: 1) classic ML , which consists of traditional classification algorithms with typically low computational cost, and 2) deep learning , which is computationally intensive. The ML algorithm receives data features as input and computes cost or loss values , which indicate the likelihood of the input to belong to each class [ 88 ]. Typically higher value of cost or lower value of loss are interpreted as higher likelihood of belonging to the class. The parameters of the ML algorithm are set in a way to minimize the loss for features in their corresponding class. After obtaining the loss vector for a given input feature, the label for a class with the lowest loss is assigned to the input. The most likely class may be the correct class or it can be misclassified affecting the machine accuracy. Typically ML algorithms cannot provide a perfect classification, and may never reach 100% accuracy. A classifier can be trained off-line or on-line ; in off-line mode, the classifier is only trained one time at the beginning before the system usage, while in on-line training, in addition to the initial training, the trained machine parameters can be updated through the usage of the system with new collected data. Although on-line training (a.k.a. active learning ) can enhance the ML accuracy, it can also increase the application vulnerability against attacks, since there is a more chance of infecting the training data [ 89 ]. Perturbation attacks as a subset of presentation attacks are only launched at the test time, hence in this paper we only focus on off-line ML algorithms. There are various approaches for classification, which are one-class, binary, and multi-class classifications. In all these approaches, the data domain is divided into two parts: 1) source , which contains malicious data and 2) target , which includes the classes of legitimate data. An adversary manipulates the source data to be recognized as a target data sample by the classifier.
The attack model can be developed based on the four main attributes of an adversary [ 17 ]: 1) knowledge , 2) capability , 3) goal , and 4) strategy . The attack system specifications columns in Table III evaluates state-of-the-art perturbation attacks. The adversaries Success Rate (SR) is defined as the percentage of non-target data samples, which are misclassified as the target class out of the total number of attacks.
As seen in Fig. 5 , two main types of knowledge may be available for an adversary: 1) data and 2) algorithm . In each type, the adversary’s knowledge can be limited or full . For instance, a neural network architecture can be specified by the number of layers, number of nodes in each layer, and type of transition functions, while an adversary with limited knowledge only knows about some of these entities. Table I evaluates the attacks in various works, based on the available knowledge at the beginning of the attacks. It is noteworthy that the adversary may infer more knowledge while designing the attack. For example, with knowledge about the classifier architecture and parameters, the adversary can obtain losses in further steps. This is not indicated in the table and is further discussed in Sec. IV-D (adversary’s strategy).
Reference | Data | Algorithm | Overall | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Raw (Unlabeled) | Loss/Cost | Class Label | Feature Extractor | Classifier | |||||||
Surrogate | Testing | Training | Arch. | Parameters | |||||||
Goodfellow et al. (2014) [ 12 ] | — | ● | — | — | ● | — | ● | ● | ● | ||
Biggio et al. (2015a,c) [ 70 ] | — | ● | — | — | ● | ● | ○ | — | ○ | ||
Biggio et al. (2015b,d) [ 70 ] | — | ● | — | — | ● | ● | ● | ● | ● | ||
Graese et al. (2016a:f) [ 77 ] | — | ● | — | ● | ● | — | — | — | ○ | ||
Papernot et al. (2016) [ 78 ] | — | ● | — | — | ● | — | ● | ● | ● | ||
Zhang et al. (2016a,c) [ 71 ] | — | ● | — | — | ● | ● | ○ | — | ○ | ||
Zhang et al. (2016b,d) [ 71 ] | — | ● | — | — | ● | ● | ● | ● | ● | ||
Bulò et al. (2017a:c) [ 79 ] | — | ● | — | — | ● | ● | ● | ● | ● | ||
Cao et al. (2017a:h) [ 80 ] | — | ● | — | — | ● | — | ● | ● | ● | ||
Carlini et al. (2017a:c) [ 81 ] | — | ● | — | — | ● | — | ● | ● | ● | ||
Demontis et al. (2017a,c) [ 82 ] | ● | — | — | — | ● | ● | ○ | — | ○ | ||
Demontis et al. (2017b,d) [ 82 ] | ● | — | — | — | ● | ● | ● | ● | ● | ||
Osadchy et al. (2017a:d) [ 83 ] | — | ● | — | — | ● | — | ● | ● | ● | ||
Papernot et al. (2017a:d) [ 84 ] | — | ● | — | — | ● | — | — | — | ○ | ||
Xu et al. (2017a:m) [ 85 ] | — | ● | — | — | ● | ● | ● | ● | ● | ||
Zhang et al. (2017) [ 73 ] | — | ● | — | — | ● | ● | — | — | ○ | ||
Baluja et al. (2018a:b) [ 86 ] | ● | — | — | — | ● | — | ● | ● | ● |
Lowercase letters distinguish among various settings in the experiments (“a:d” indicates all the alphabets between ‘a’ and ‘d’ including both).
According to the target system model in Sec. III , an adversary may have knowledge about four types of data in the system: 1) raw data, 2) data feature, 3) loss/cost, or 4) class label (each type can appear in different forms of surrogate, testing, or training).
Raw data domain usually has high dimension, which makes it challenging for an adversary to find an attack point in an affordable time interval. Access to data features with lower dimensionality facilitates searching in reduced search domain for more successful attacks [ 90 ].
By access to loss/cost values of the input test data, an adversary can pick a data point, and reproduce its corresponding input through reverse engineering [ 91 ]. Also, loss/cost values indicate the likelihood of acceptance the attack point by the target class [ 23 ].
With access to labels, an adversary can present unlabeled surrogate data and observe the outputs to obtain a labeled surrogate dataset for training a surrogate classifier (or substitute classifier ), which resembles the target classifier [ 92 ]–[ 94 ]. Full knowledge about the surrogate classifier is exploited to generate more successful adversarial samples.
An adversary may also know the algorithms, which the target system applies on data.
Many attacks manipulate the data in the feature domain [ 17 ], [ 73 ], [ 95 ]–[ 97 ]. Here, the knowledge about the feature extractor and subsequently the feature domain is available. The adversary crafts an attack feature point and finds its corresponding point in raw data domain, which is only feasible for invertible feature extractors.
An adversary’s amount of knowledge about the classifier depends on the ML attributes: 1) architecture , including type (e.g. Neural Networks (NNs)) and structure (e.g. number of layers in NNs) and 2) parameters , such as weights of edges between nodes in NNs, which are set during training. By knowing the ML type, the adversary can train an accurate substitute classifier to initiate more effective attacks (i.e. spending lower time with higher success rate) [ 84 ]. In Table I , limited knowledge about the architecture, such as solely the ML type is indicated by an empty circle (○). Knowing the structure in addition to its type leads to more accurate reconstruction of the classifier. Also, knowing the ML parameters means full access to the classifier that also enables testing large number of samples on the replica (e.g. by brute-forcing) until finding 100% successful adversarial samples.
In addition to the provided taxonomy, there are some high level qualitative measures to determine the amount of available knowledge for an adversary: black-box (i.e. no knowledge), gray-box (i.e. limited knowledge), and white-box (i.e. full knowledge) [ 55 ]. The white-box scenario is unlikely to happen in practice, but as an example, compressing and deploying trained ML models on data centers for smart-phones may allow white-box access, where the initial models can be derived through reverse engineering [ 98 ].
In practical scenarios, an adversary can only alter a portion of the data (surrogate, testing, or training) or has limited access to the target system. The portion size or the number of possible accesses have key roles in adversary’s success rate [ 99 ]. For example, in attacks on traffic sign recognition application in autonomous vehicles, in the presence of an external observer (e.g. a passenger), the adversary is not free to make any changes in signs due to the chance of the detection of abnormal changes by the observer [ 100 ]. As another example, in many adversarial ML research, full knowledge of class labels is assumed for the adversary ( Table I ), which is obtained either through stealing labeled data or oracle access to the ML application. Although by assuming full knowledge for an adversary, the system security is tested under the worst case scenario (from the target system viewpoint), this assumption does not always hold [ 101 ]. For instance, in biometric authentication systems, the application can terminate the oracle access if it detects few illegitimate inputs. At last, since the focus of the paper is on perturbation attacks, it is assumed the adversary cannot directly inject altered data features, losses/costs, or class labels, or change the feature extraction or classification algorithms (i.e. mostly related to network or system security). In this case, the adversary can only alter the input raw data.
One of the most common way of attacking the ML algorithm is known as poisoning attack , where an adversary alters the training raw data (either the raw data itself, or its labels) to alter the classifier’s parameters in its favor. In general, any attempts for illegitimate changes in the classifier settings is called causative attack , which is a subset of active attacks ( Fig. 2 ). Considering the amount of possible alteration at the training time (i.e. limited [ 52 ] or full [ 102 ]), the classifier boundaries can be moved toward the source data class, which leads to misclassification of source data as the target class [ 54 ].
An adversary can alter the available surrogate or testing source raw data to craft adversarial samples to be classified in the target class at the test time. Perturbing the data may trick the system, but too much perturbations can raise suspicion [ 116 ].
Due to low dimensionality of the feature domain, finding attack points in this domain is more time efficient. Raw adversarial samples can be retrieved by applying an inverse feature extraction on the attack points in the feature domain [ 174 ].
To the best of our knowledge, there is no attack that applies reverse engineering on these data types.
The adversary’s goals can be categorized in three main groups based on violating three high level security aspects [ 55 ]: 1) confidentiality , 2) integrity , or 3) availability , also known as CIA triad. These goals can be either: 1) indiscriminate , where any class’s data or any components of the ML application are prone to attack or 2) targeted , which attacks a specific class or component. In an indiscriminate perturbation attack, the source data is misclassified in any target classes, while in the targeted version, it should be mis-recognized as data in a specific target class [ 54 ].
Confidentiality violation happens when information of the application users or components is disclosed. Finding out whether a dataset belongs to ML training dataset [ 93 ], extracting training data [ 175 ], stealing the ML model [ 176 ], or predicting users critical information [ 177 ] are some examples of violating confidentiality. These type of attacks can be indiscriminate when information from random users or components of the application is stolen, or targeted when victims are some specific users or components.
Penetrating an ML application using illegitimate data leads to unauthorized access to information and subsequently integrity violation. For instance, acceptance of malware samples in malware detection systems [ 82 ], impersonation of another user in facial biometric systems [ 6 ], or detecting an unknown object (e.g. a fire hydrant) as a traffic sign in autonomous vehicles [ 100 ]. Integrity violation can be indiscriminate when a malicious sample can be recognized as any legitimate data. In contrast, in targeted attacks, a malicious sample should be recognized as a specific legitimate sample.
Availability is disrupted when the application does not accept legitimate data samples. For instance, recognizing legitimate data as malware in malware detectors [ 82 ], rejecting login attempts from legitimate users in biometric systems [ 178 ], or ignoring traffic signs by autonomous vehicles [ 100 ]. In indiscriminate availability violation, any legitimate samples are recognized as malicious data, while in targeted attack, specific legitimate samples are rejected.
Attack strategies can be studied in two main groups ( Fig. 2 ):
Their aim is to derive information about the application or its users [ 179 ]. Two common approaches for passive or exploratory attacks are: 1) probing [ 93 ] and 2) Reverse Engineering (RE) [ 180 ].
In this attack, an adversary submits some queries to the system and observes the responses. For instance, the adversary may provide input data to the system and observe the outputs (e.g. class labels), also known as oracle access , to gain some information about the training dataset [ 49 ]. Probing can determine whether a raw data sample belongs to the training dataset [ 93 ]. In addition, finding the relationship between changes in the inputs and outputs enables testing randomly guessed input data to reach an input data in the target class. Finally, the adversary can prepare synthetic training data by performing several tests on the oracle and plan for more advanced attacks [ 54 ]. Synthetic data is a type of surrogate data, which is close to the original data distribution.
Based on some information about the distribution of the data (possibly through eavesdropping or probing), an adversary may guess the class boundaries or develop a substitute model of the classifier [ 180 ]. As an example, the functionality of a black-box classifier can be stolen by labeling some surrogate data through oracle access and training a deep learning based substitute model [ 181 ].
These attacks disrupt the application’s normal operation. Active attacks can be launched either through: 1) presentation or 2) causative attacks ( Fig. 2 ).
In this approach, an adversary is only capable of altering the input raw data (cannot change any data or algorithm inside the application). Presentation attacks are the most popular type of active attacks, where the adversary presents falsifying raw data at the test time to be misclassified as the target class data. These attacks can be categorized in three main groups based on the origin of the data, which is exploited for attack: 1) zero-effort , 2) replay , and 3) perturbation attacks. In the simplest case, Zero-Effort (ZE) attack, the adversary chooses an attack sample among the source data without making any changes in it [ 182 ]–[ 184 ]. Due to imperfect classification by the ML algorithm, the sample might be misclassified as the target class. Unlike the ZE attack, in Replay Attack (RA), the adversarial sample is picked among the stolen [ 185 ] or artificially crafted (i.e. artefact [ 186 ]) target class data to mimic the target data features [ 73 ]. There are various strategies to launch a replay attack. Stealing the data (e.g. an image of a traffic sign) or its origin (i.e. the real traffic sign) are the most common one. In practice, small changes (e.g. white noise) are applied to the stolen data to pass some defenses, such as similarity check ( Sec. V-B ) [ 187 ]. Reverse engineering on features [ 73 ] or creating different representations of the same target data using generative models [ 188 ] are common methods for crafting artefacts. In presence of an external observer (e.g. passengers in autonomous vehicles), there is a high chance of detecting zero-effort and replay attacks. As a more advanced strategy, in perturbation attack [ 54 ], the adversary obtains an adversarial sample by altering a source data sample (e.g. by adding carefully crafted perturbations, a.k.a. adversarial noise ), to be accepted as the target class data, while remains hidden from the observer [ 189 ], [ 190 ]; for example, spraying some paint on a stop sign to be recognized as a speed limit sign by the object recognition system in autonomous vehicles [ 100 ]. For obtaining adversarial samples, the adversary faces a search problem, which may be solved through two main approaches ( Fig. 6 ): 1) non-guided search , where an adversary has no clue about the classifier function and 2) guided search , where the adversary knows the function. Grid search [ 191 ] or random search [ 192 ] are examples of non-guided search techniques. The second approach, which has drawn more attention, suggests two strategies: 1) optimization [ 11 ], where due to non-linearity of the classifier function in most cases, is narrowed down to non-linear programming or 2) game theory , where a game is defined between the ML application and the adversary, to find effective adversarial samples [ 26 ], [ 193 ], [ 194 ]. In game theoretical strategies, on one hand, the adversary attempts to generate an adversarial sample to be classified as the target class data, and on the other hand, the ML application attempts to recognize the sample and reject it [ 42 ], [ 195 ], [ 196 ]. Generative Adversarial Nets (GAN) [ 142 ], [ 143 ] is a popular example of game theoretical strategies for generating adversarial samples. Specially, applying deep learning to develop GAN can lead to crafting samples with a high chance of success [ 144 ]. A GAN is composed of a generator and a discriminator [ 142 ]. The generator produces adversarial samples, which the discriminator attempts to recognize them. Indeed, there is a co-evolution between these two modules, which optimizes the functionality of both of them. The game between the generator and the discriminator can roughly be interpreted as a set of coupled optimization problems (i.e. minimax game [ 142 ]), where both opponents (i.e. the adversary and ML application) do their best to maximize the success rate and classification accuracy, respectively [ 197 ]. The game theoretic methods can also be used for defense by reinforcing the classifier in the ML application, to block the adversarial samples [ 198 ]. In general, game-theoretic methods use losses in both attack and target systems to design attack and defense strategies.
With knowledge about the ML algorithm, the adversary can derive the loss function and exploit it as the objective function of the problem. The objective is to find an adversarial sample, which minimizes the loss. There are various methods to obtain the objective function, such as deriving it from a substitute classifier ( Sec. IV-A2 ). An input crafted to break the substitute classifier can be effective on the original one, due to transferability properties of ML algorithms [ 92 ]. The derived objective function from commonly used ML techniques are non-linear and non-convex, which means the optimal solution is likely to be a local optimum, however still can be used for attack [ 78 ]. Based on the properties of the derived loss function, the optimization-based techniques are categorized in three main groups ( Fig. 6 ): 1) non-differentiable when derivatives of the loss function are not defined on the search domain, 2) differentiable when derivatives of the function can be calculated, and 3) twice differentiable when the second order derivatives of the function on the search domain are available. Table II lists state-of-the-art perturbation attack strategies. The adversarial sample manufacturing problem can also be defined as a game between attack and target systems, where on one hand, the adversary attempts to generate adversarial samples to be classified as the target class, and on the other hand, the ML application attempts to recognize and reject the samples [ 42 ]. For example, in Generative Adversarial Networks (GANs) , the game between the generator and the discriminator can be interpreted as a set of coupled optimization problems, where both opponents (i.e. the adversary and ML application) attempt to maximize the success rate and classification accuracy, respectively [ 142 ], [ 197 ], [ 259 ].
Attack Strategies | |||
---|---|---|---|
Type | Method | Description | |
Non-Differentiable | Evolutionary Algorithms (EA) [ 23 ], [ 103 ] | In each generation, the features that reduce the loss values are kept, while the rest are replaced by mutants. | |
Generative Models [ 104 ] | Generating adversarial samples by developing generative models using machine learning algorithms. | ||
Gradient Estimation Attacks [ 105 ], [ 106 ] | Estimating the loss function’s gradient using the finite differences method [ 107 ] to calculate the amount of perturbation. | ||
Zeroth Order Optimization (ZOO) [ 108 ] | Using zero order optimization to estimate the gradients of DNN toward generating the adversarial samples. | ||
Local Search Optimization [ 109 ] | Running the local search algorithm using the loss values to find a perturbed data, which minimizes the loss. | ||
Hill-Climbing (HC) [ 23 ], [ 110 ]–[ 114 ] | A source data sample is iteratively modified until reaching a sample, which reduces the loss function. | ||
Differentiable | Adam Optimizer [ 81 ], [ 115 ] | Minimizing the amount of distortions required to generate adversarial samples using Adam optimization algorithm. | |
Deepfool [ 116 ] | Minimizing the amount of required perturbations to change the source data class using gradient-based optimization. | ||
Elastic-net Attacks to DNNs (EAD) [ 117 ] | Minimizing the linear combination of the loss function, and L 1 and L 2 norms of the amount of perturbation. | ||
Gradient Descent (GD) [ 118 ], [ 119 ] | The loss function’s gradient is derived to find the direction of changes in a source data sample to reach the target class. | ||
Dense Adversary Generation (DAG) [ 120 ] | The losses of belonging to both source and target classes form the optimization problem, which is solved by GD method. | ||
Jacobian-based Saliency Map Attack (JSMA) [ 54 ], [ 121 ] | Reducing the search space dimensionality using adversarial saliency map [ 122 ] for Jacobian-based objective functions. | ||
JSMA-Z [ 78 ] | A version of JSMA, which uses the second to the last layer (Z) outputs in deep neural networks. | ||
Carlini and Wagner’s (C&W) Attack [ 81 ], [ 123 ] | JSMA using the softmax layer output, as a modification on JSMA-Z, to be resilient to defensively distilled networks [ 78 ]. | ||
RP 2 Algorithm [ 124 ], [ 125 ] | Adding physical constraints (e.g. samples printability) to JSMA to find robust physical world adversarial samples. | ||
Fast Gradient Sign (FGS) [ 12 ], [ 54 ], [ 76 ], [ 126 ], [ 127 ] | Perturbing the source data toward reaching a neighbor class by applying the sign function on gradients. | ||
Least Likely Class (LLC) [ 128 ] | A version of FGS method for targeted attacks, where the adversarial samples fall in a specific target class. | ||
Iterative Fast Gradient Sign (IFGS) [ 74 ], [ 129 ] | Limiting the amount of alteration in each point of the source data samples, which leads to multiple runs of FGS. | ||
Projected Gradient Descent (PGD) [ 129 ] | Another name for IFGS, which is used in adversarial ML literatures. | ||
Iterative Least Likely Class (ILLC) [ 74 ] | A version of IFGS method for targeted attacks, where the adversarial samples fall in a specific target class. | ||
Random Perturbation with FGS [ 130 ] | Adding a small random perturbation to the initial point before applying FGS to avoid its non-smooth vicinity. | ||
Random Perturbation with LLC [ 130 ] | Adding a small random perturbation to the initial point before applying LLC to avoid its non-smooth vicinity. | ||
Robust IFGS [ 83 ] | Filtering the adversarial samples before inputing to the objective function in FGS to be resilient to filtering defenses. | ||
Momentum IFGS [ 131 ] | Integrating the momentum method [ 132 ] with IFGS to stabilize changes directions and avoid local optima. | ||
Universal Adversarial Sample [ 133 ] | A version of deepfool that generates a perturbation to escape most of the classes of data with the same distribution. | ||
Quasi-Newton’s Methods (e.g. BFGS) [ 134 ], [ 135 ] | Approximating the second order derivatives in the process of generating the adversarial samples. | ||
Limited-memory BFGS (L-BFGS) [ 11 ] | A version of BFGS algorithm, which has been designed to use limited amount of computer memory. | ||
L-BFGS-B [ 136 ]–[ 138 ] | An extension of L-BFGS, which has been designed for handling box constraints on the perturbations. | ||
Spatial Transformation [ 139 ] | Finding the minimum displacement of the source data in generating adversarial samples using gradient-based optimization. | ||
Wasserstein Adversarial Samples [ 140 ] | Minimizing the amount of distortions required to generate adversarial samples using Wasserstein distance metric. | ||
Twice Differentiable | Newton’s Method [ 141 ] | Obtaining the Newton’s direction using the first and second order derivatives to calculate the perturbations. | |
Game Theory | Generative Adversarial Network (GAN) [ 142 ]–[ 145 ] | Generating adversarial samples using the generator component in GAN. | |
Adversarial Transformation Network (ATN) [ 91 ] | A version of GAN, which trains a generator receiving source data to generate minimally perturbed adversarial samples. | ||
Universal Adversarial Network (UAN) [ 104 ] | Generating adversarial noise using generative models developed by reverse engineering of the target classifier. | ||
Two-Person Game [ 146 ], [ 147 ] | Developing a two-person constant sum game, where adversary perturbs the input and recognizer should detect distortions. |
This approach targets the classifier itself, including its parameters or architecture [ 260 ]. Poisoning [ 261 ] is the most common causative attack strategy, which is categorized as: 1) label contamination [ 262 ] and 2) red herring [ 102 ]. In label contamination, the training data labels are altered to change the classifier’s boundaries [ 263 ]. Label contamination can be applied on training data with both hard class labels (e.g. 0–9 digits as labels for handwritten digits dataset [ 148 ]) or soft class labels (e.g. losses derived from the ML algorithm as labels to train another machine [ 98 ]). Label flipping is a special case of label contamination, which deals with hard class labels. For instance, in the absence of an external observer, an adversary can flip the labels of the source class training data to expand the target class boundaries toward the source data. Selecting the most influential labels on altering the class boundaries can be formalized as an optimization problem [ 262 ]. In this strategy, after training, a source data sample can be accepted as the target class data without perturbing it [ 54 ]. In presence of an external observer, flipping the labels raises suspicion, where an adversary should poison the data itself, also known as red herring. The adversary perturbs the unlabeled training data to shift the target class boundaries toward the source data. At the same time, the amount of changes in the data should be low enough to be hidden from the observer. This problem can be formalized as an optimization problem, where knowledge about the target class data or ML algorithm can elevate the attack success rate [ 264 ].
Defense methods are designed based on two main approaches [ 265 ]: 1) proactive when a target system is prepared for potential threats before attack [ 266 ] and 2) reactive when defense strategies are applied after occurrence of an attack, such as machine unlearning after poisoning attacks [ 267 ]. Most defenses take the first approach to prevent the damage as much as possible [ 39 ]. Fig. 8 categorizes the proactive defense methods against perturbation attacks in two main groups: 1) modifying the classifier and 2) adding a specialized detector. Table IV provides brief descriptions of state-of-the-art defense strategies in the taxonomy. The specifications of applications using these defenses are summarized in the defense system specifications in Table III . In the table, the third column shows the accuracy of the target ML after applying the defense method. The defense gain indicates the amount of reduction in adversary’s success rate after applying a defense. Various defense strategies can also be combined (a.k.a ensemble defenses ) for higher defense gain; however, this approach does not guarantee an improvement [ 268 ].
Defense Strategies | |||
---|---|---|---|
Type | Method | Description | |
Adversarial Sample Thwarting (MC) | Data Transformation [ 77 ], [ 199 ]–[ 204 ] | Transforming the input data (e.g. scanning an image, scaling, or averaging) to reduce the adversarial noise. | |
Ensemble Data Transformation [ 205 ] | Combining various data transformation methods (e.g. image cropping and quilting). | ||
Random Data Transformation [ 206 ] | Applying random data transformation methods (e.g. scaling an image data to a random size). | ||
Magnet [ 207 ] | Reducing the adversarial noise by passing the input data through an auto-encoder before classification. | ||
Pixeldefend [ 208 ] | Reverting input data samples to their corresponding training data distribution before classification. | ||
Noise Filtering [ 83 ] | Reducing the adversarial noise by applying filters, such as median filter. | ||
Training Process Modification (MC) | Adversarial Training [ 129 ], [ 145 ], [ 198 ], [ 209 ]–[ 215 ] | Adding an adversary class to the training dataset containing adversarial samples for training. | |
Constrained Adversarial Training [ 33 ] | Generating adversarial samples for adversarial training by adding Gaussian noise to the target data samples. | ||
Adversarial Boosting [ 210 ] | Augmenting the training dataset to train boosted classifiers (e.g. boosted DT) in each boosting round. | ||
Batch Adjusted Network Gradients [ 216 ] | Scaling the gradients during training to reduce the effect of outliers in the training data on the CNN weights. | ||
Ensemble Adversarial Training [ 130 ], [ 217 ] | Using adversarial samples generated for other ML models to train the target model. | ||
Curriculum Adversarial Training [ 218 ] | Generating adversarial samples for wide range of adversaries with various attack models for training. | ||
Adversarial Polytope [ 219 ], [ 220 ] | Training the ML considering adversarial classes formed by convex outer of norm-bounded perturbations. | ||
Convex Relaxation [ 221 ] | Applying convex relaxation in DNN training to find more accurate approximation of minimal loss values. | ||
Defensive Distillation [ 78 ] | Reducing the gradient of the loss function using soft class labels (e.g. loss values) for training. | ||
Feature Masking [ 71 ], [ 222 ], [ 223 ] | Selecting specific features for classification, which are less sensitive to adversarial noise. | ||
Foveation-Based Classification [ 224 ] | Applying the classifier on different regions of an input data (e.g. an image). | ||
Gradient Inhibition [ 225 ] | Linear enlargement of DNN’s weights to reduce the sensitivity of the loss values to adversarial noise. | ||
Gradient Masking [ 98 ] | Reducing the gradient of the loss function to reduce the ML sensitivity to distortions in input data. | ||
High-Level Guided Denoiser (HGD) [ 226 ] | Including the changes in the activation values of DNNs hidden layers in the loss function for training. | ||
Input Gradient Regularization [ 227 ] | Applying double-back propagation [ 228 ] in training DNNs to minimize their sensitivity to small perturbations. | ||
Randomized Smoothing [ 32 ]–[ 34 ] | Adding random noise to DNN’s weights in each layer to reduce the loss’s sensitivity to distortions. | ||
Reject-On-Negative-Impact (RONI) [ 99 ] | Eliminating the samples with the highest impact on classes boundaries from the training dataset. | ||
Stability Training [ 229 ] | ML training using sets of perturbed training samples to reduce the ML sensitivity to perturbations. | ||
Quantized Activation Function [ 230 ] | Quantizing the activation functions output in DNNs during training and testing to avoid adversarial samples. | ||
Machine Learning Modification (MC) | Classifiers Randomization [ 180 ] | Randomly choosing a classifier from a set, for each test query, to avoid classifier’s functionality theft. | |
Enclosing the Target Class [ 231 ] | Surrounding the target class area to avoid blind spots, by applying more complex classifiers. | ||
Competitive Overcomplete Output Layer [ 232 ] | Combining multiple nodes results in output layer of DNNs for deciding the test data class. | ||
Convex Learning [ 233 ] | Applying a convex optimization approach for more accurate training of classifiers. | ||
Deep Contractive Network (DCN) [ 234 ] | Training a deep neural network using the constant features of the training data. | ||
Infinity-Norm SVM [ 235 ] | Modifying the SVM training, to involve more number of features in determining the class boundaries. | ||
Low-Sensitive ML [ 236 ]–[ 239 ] | Putting constraints on the ML parameters during training, to reduce its sensitivity to adversarial noise. | ||
Multiple Classifier System [ 16 ], [ 70 ], [ 159 ] | Aggregating multiple classifiers outputs using ensemble methods (e.g. bagging or random subspace methods). | ||
Non-Linear ML [ 12 ], [ 240 ] | Using highly non-linear classifiers, such as Radial Basis Function (RBF) neural networks or RBF SVMs. | ||
Cross-Lipschitz Regularization [ 241 ] | Minimizing the sensitivity of NNs output to perturbations, using cross-Lipschitz regularization during training. | ||
Parseval Regularization [ 242 ] | Reducing the sensitivity of ML output to adversarial noise, by regularizing the ML parameters. | ||
Stochastic Activation Pruning [ 243 ] | Defining a minimax zero-sum game between the ML and adversary to optimize the ML parameters. | ||
Multi-Model-Based Defense [ 244 ] | Constructing a family of classifiers from the target classifier to be chosen randomly at the test time. | ||
Randomized Classifier [ 180 ] | Random selection among a distribution of trained classifiers for testing each input sample. | ||
Hybrid Classifier [ 245 ] | Combining kNN and DNN classifiers, where kNN is applied on the learned parameters in each layer of DNN. | ||
Region-Based Classification [ 80 ] | Labeling a test sample based on the intersection volume of its surrounding area with a given class area. | ||
Adversarial Sample Detection by Specialized Detectors (SD) | Feature Extraction [ 73 ], [ 246 ]–[ 251 ] | Detection by extracting new data features, which are more sensitive to adversarial noise. | |
Feature Extraction [ 252 ]–[ 254 ] | Analyzing the data representations in the middle layers of deep learning algorithms to detect attacks. | ||
Feature Squeezing [ 85 ], [ 255 ] | Rejecting samples with different classification results before and after transformation (e.g. spatial smoothing). | ||
Characterizing Adversarial Subspaces [ 250 ] | Extracting spatial features (i.e. local intrinsic dimensionality) from samples to detect adversarial samples. | ||
Multiple Detectors [ 256 ] | Analyzing various data features, such as soft-max distributions or manifold analysis, by consecutive detectors. | ||
Surrogate Classifier [ 28 ], [ 257 ], [ 258 ] | Applying a separate add-on classifier (e.g. polynomial kernel-based SVM) to detect the adversarial samples. |
Adversarial samples tend to be inside the target class boundary, which typically covers a vast area containing blind spots [ 11 ] (parts of the target class, where there is no training data). A classifier can prevent access to the blind spots by utilizing adversarial sample thwarting or eliminate the spots by modifying its training process or ML algorithm.
This approach is based on neutralizing the perturbations in adversarial samples before classification. Several methods reduce the possible adversarial noise in the test data, such as data transformation [ 199 ], noise filtering [ 83 ], or mapping to normal samples [ 207 ].
These defenses revise the type and arrangement of the training data or modify the training process, to avoid misclassification of the adversarial samples in the target class [ 214 ], such as adversarial training [ 129 ] or modifying the training process [ 78 ].
Modifying the classifier by refining its ML algorithm for drawing more accurate boundaries around each class training data to avoid falsifying test data is another defensive approach [ 235 ]. Applying non-linear ML algorithms [ 240 ] and designing robust ML algorithms [ 233 ] are common modification approaches.
In other type of defense strategies, a specialized detector is added as a separate component to the target system. With an add-on attack detector, adversarial samples may be blocked (based on the detector accuracy) before classification [ 246 ], [ 252 ], [ 257 ]. Many detectors extract new data features, which are more sensitive to adversarial noise for accurate detection [ 249 ]–[ 251 ]. Feature squeezing [ 85 ] and applying consecutive detectors [ 256 ] are examples in this category.
In this section, a unified system-driven taxonomy is developed to compare state-of-the-art research works in adversarial ML. The arms race between attack and target systems in AMLC are modeled and analyzed by merging all the provided models and taxonomies throughout the paper ( Table VI ).
In AMLC, each cycle can be studied as a generation , where the arms race lead to the emergence of new types of target, attack, or defense systems due to contributions of research works through years ( Table III ). There are various ways of arranging these systems in a sequence. In this research, a heuristic metric, called research impact , is defined to rank the research works in adversarial machine learning:
Given an adversarial machine learning cycle, research impact is a heuristic metric that facilitates ranking the research works based on the differences in the specifications of their systems under study.
As seen in Table V , zero and one RIs are assigned to each AMLC model based on its target, attack, and defense systems specifications in the proposed taxonomies ( Fig. 2 , ,4, 4 , ,5, 5 , ,6, 6 , & 8 ). The RI of the defense strategy for defenseless ML applications is considered as zero. For ease of analysis, the RI can be represented as bits. Target, attack, and defense models impacts are then combined as a bit string to represent a generation number for each research work. As seen in Table VI , the generation number is calculated by converting its binary representation to the corresponding integer value. In each generation with a greater number, progress is seen at least in one of the models. In the second step, the works are sorted in ascending order of the generation numbers ( Table VI ). The two vertical dots in some rows in Table VI show the gap between the works indicating open research problems. It is noteworthy that the choice of research impact for analyzing the arms race, the particular arrangement of the impacts in a bit string, and the way of calculating the generation numbers can be changed based on the analysis purposes. Hence the generation number does not represent the quality of works, but merely is an indicator to explore the field. For example, Table VI gives higher priority to the RI of ML applications (left columns), then the adversaries (middle columns), and at last the defense systems (right columns). This can be useful for researchers pursuing the most recent system under the most successful attack strategy. The taxonomy can also suggest the most relevant adversarial model to a researcher who wants to analyze and improve a given ML application. In addition, vector operations, such as dot product, can be applied on the bit strings to evaluate the similarity between competing research works and extract the trends in these works.
Zero Impact (○) | One Impact (●) | |||
---|---|---|---|---|
Target | Data | One-Dimensional (e.g. signal) | Multidimensional (e.g. image) | |
Architecture | Classic ML | Deep Learning | ||
Accuracy (Acc.) | ≤ 50 | > 50 | ||
Attack | Knowledge | Limited | Full | |
Capability | Limited | Full | ||
Strategy | Reverse Engineering & Optimization | Game-Theory | ||
Goal | Indiscriminate | Targeted | ||
Success Rate | ≤ 50 | > 50 | ||
Defense | Strategy | Modified Classifier (MC) | Specialized Detector (SD) | |
Acc. after Defense | ≤ 50 | > 50 | ||
Defense Gain | ≤ 50 | > 50 |
The arms race between the attack and target systems in Table VI , indicates the focus of the state-of-the-art research. New research can also be added to the taxonomy based on its rank calculated by the research impacts of its specifications.
Ideally, it is expected that the ranks in Table VI match the chronological order of publishing each research, which does not completely apply in practice. This reveals the potential open problems in the field. For instance, the gap between the works by Demontis et al. [ 82 ] (generation #395) and Zhang et al. [ 73 ] (generation #815) indicates the need of testing classic machine learning algorithms applied on low dimensional data under more complex attacks (e.g. with unlimited capabilities and advanced attack strategies). Also, the gap between the works by Bulò et al. [ 79 ] (generation #1410) and Grease et al. [ 77 ] (generation #1862) shows the lack of work on testing advanced targeted attacks on classic ML algorithms. As another example, the work by Baluja et al. [ 86 ] (generation #2042) shows still there is no effective defense strategy against advanced attacks using ATN on CNN-based applications ( Table III ).
The taxonomy in Table VI can also facilitate choosing an optimal configuration for the target application (e.g. type of dataset, feature extraction algorithm, or ML algorithm) or the defense strategy by ML designers. In this case, designers can find the most robust ML algorithm against a specific type of attack. For instance, the work by Zhang et al. [ 73 ] (generation #815) suggests adding a SVM-based detector to the ML application as an effective defense against a successful gray-box targeted attack on the DNN algorithm applied in Siri for analyzing audio data ( Table III ). As another example, the work by Bulò et al. [ 79 ] (generation #1410) shows SVM classifier with linear kernel has high robustness against white-box attack using gradient descent strategy ( Table III ).
Based on the provided system models and taxonomies, the following challenges towards securing ML applications against perturbation attacks are extracted:
The emergence of wide variety of ML algorithms and attack strategies requires extra effort in handling security issues in CI field. Table VI shows the research gaps, which are needed to be addressed by future research toward securing ML applications.
A set of standard metrics for precise evaluation of ML algorithms under attack are required [ 269 ], [ 270 ]. The metrics ensure a certain amount of robustness for ML algorithms facing various attacks, which is vital in deployment for real-world application. The proposed metric (research impact) in this work can be an initial step to coin quantitative standard metrics. For example, the processing time of generating adversarial samples is just as important as the attack success rate, which is often ignored in research.
Most defenses focus on ML algorithms, while rethinking a formal method for extracting new data features for mitigating the attacks is usually ignored. For instance, considering the distance constraints on adversarial samples, finding features that maximize the gap between the source and target classes can lead to an immunity against perturbation attacks. Classification based on new types of features may also defeat the attacks. For example, in facial recognition systems, by extracting features inspired by human visual perception (e.g. simile [ 271 ]), vulnerability to pixel level perturbations can be diminished.
Typically defense methods degrade the ML accuracy. A possible future trend is to find an analytical solution for modeling the trade-off between the classification accuracy and effectiveness of the defense strategies [ 192 ], [ 272 ].
There are some works that quantitatively analyze the security of ML algorithms from geometrical viewpoint [ 50 ], [ 56 ], [ 57 ], [ 273 ]. However, these studies are limited to low dimensional input data, which are not applicable in higher dimensions (e.g. image data). By knowing the position of each class and class boundaries within the data domain, the constraints on amount of changes in data samples can be set in a way to distance from the target class. Also, analyzing the volume of each class indicates the quality of the classifier in drawing class boundaries and eliminating blind spots. Although these types of geometrical analysis can assist ML designers to extract new features or refine algorithms for robust classification, applying the analysis on high dimensional domains is still intractable.
One of the reasons for choosing supervised ML algorithms for analysis in this research was the significant amount of attention to them; while, other types of algorithms, such as unsupervised and reinforcement learning , require extensive analysis as well [ 61 ], [ 274 ], [ 275 ]. The proposed approach in this work can also be used to analyze other types of ML algorithms.
There are few works that go beyond theoretical analysis to test practical conditions [ 118 ], [ 276 ], [ 277 ]. For instance, in practical ML-based authentication systems, an adversary may apply different methods to launch a replay attack, such as coercion or using artefact (e.g. gummy finger) [ 186 ]. For mitigating coercion, applying stress or fear detectors (e.g. analyzing facial muscle movement [ 278 ]) and for detecting artefact, liveness detection methods (e.g. perspiration in fingerprinting [ 279 ]) are some defensive strategies. Modeling the adversary’s capability considering these breaches is a hot research topic.
Predicting all possible attacks during the ML design is not feasible. System recovery after encountering attacks is also an important topic that needs to be addressed. Machine unlearning [ 267 ] as a recovery method after poisoning attacks, in order to reduce its effects on a trained model, is an example of post-attack solutions.
Certified defenses, such as randomized smoothing [ 32 ], [ 34 ], differential privacy [ 31 ], or constrained adversarial training [ 33 ], determine certain levels of robustness facing attacks, which have constraints on the amount of alteration on the source data. Using such defenses, the adversary has to make more alteration that increases the chance to be spotted by an external observer. However, in many ML applications, such physiological signal based authentication systems [ 5 ], since the detection of the alteration by the observer is not very likely, there is no constraints in generating adversarial samples and certified defenses cannot block the attack.
This research analyzes perturbation attacks on ML applications by developing system-driven models and taxonomies of the applications, adversary’s strategies, defense mechanisms, and their interactions. The provided models and taxonomies can be used to rank and compare the research works to reveal potential vulnerabilities that have not yet been addressed by the current studies. The taxonomies are independent from a specific type of data, algorithm, or application, which can also be generalized to evaluate and organize the future research. The main aims of creating the set of system-driven taxonomies are twofold: 1) enabling the extension of recent research and 2) discovering open problems and research gaps. This research outcome can benefit: 1) new researchers in the field, to choose appropriate ML applications, attack strategies, or defense mechanisms to address, 2) experienced researchers, for relative comparison of contributions in recent and future research, 3) ML designers, to ensure that the selected ML application to be used has state-of-the-art defense strategies, and 4) standardization organizations [ 186 ], by utilizing the provided systematic terminologies, models, and taxonomies.
This work has been partly funded by CNS grant #1218505, IIS grant #1116385, and NIH grant #EB019202.
Koosha Sadeghi is a Ph.D. candidate in Computer Engineering at the School of Computing, Informatics, and Decision Systems Engineering, Arizona State University, Tempe, AZ. He is also working as a digital signal processing and machine learning algorithms engineer at Ciye.co, Albany, California. His current research interests are focused around machine learning, mathematical optimization, and pervasive computing. More details about his research are available at http://kooshasadeghi.weebly.com .
Ayan Banerjee is an Assistant Research Professor in the School of Computing, Informatics, and Decision Systems Engineering, Arizona State University, Tempe, AZ. He received his PhD degree in Computer Science from Arizona State University and his B.E. degree in Electronics and Telecommunication Engineering from Jadavpur University, Kolkata, India. His research interests include safety and sustainability of cyber-physical systems. He is a member of the IEEE. His publications are available at http://impact.asu.edu/ayan/index.html .
Sandeep K. S. Gupta is the Director of the School of Computing, Informatics, and Decision Systems Engineering (SCIDSE) and a Professor of Computer Science and Engineering, Arizona State University, Tempe, AZ. He is a member of several Graduate Faculties at ASU including Computer Science, Computer Engineering, Electrical Engineering, and Mechanical Engineering. He received the BTech degree in Computer Science and Engineering (CSE) from the Institute of Technology, Banaras Hindu University, Varanasi, India, the M.Tech. degree in CSE from the Indian Institute of Technology, Kanpur, and the MS and PhD degrees in Computer and Information Science from Ohio State University, Columbus, OH. He has served at Duke University, Durham, NC, as a postdoctoral researcher; at Ohio University, Athens, OH, as a Visiting Assistant Professor; and at Colorado State University, Ft. Collins, CO, as an Assistant Professor. His current research is focused on safe, secure and sustainable cyber-physical systems with focus on AI-enabled systems such as Artificial Pancreas and Autonomous Transportation. His research has been funded by the US National Science Foundation (NSF), The National Institute of Health (NIH), Science Foundation of Arizona (SFAz), the Consortium for Embedded Systems (CES), the Intel Corp., Raytheon, Northrop Grumman, and Mediserve Information Systems. Dr. Gupta has published over 150 peer reviewed conference and journal articles (Google Scholar h-index 54) and has advised over 15 PhD and over 25 MS students. He has co-authored two books: Fundamentals of Mobile and Pervasive Computing, McGraw Hill, and Body Sensor Networks: Safety, Security and Sustainability, Cambridge University Press. He currently is or has served on the editorial board of Elsevier Sustainable Computing, IEEE Transactions on Parallel & Distributed System, IEEE Communications Letters and Wireless Networks. Dr. Gupta is a Senior Sustainability Scientist, in the Global Institute of Sustainability, ASU. His awards include a Best 2009 SCIDSE Senior Researcher, a Best Paper Award for Security for Pervasive Health Monitoring Application, and two best paper award nominations. His research has been highlighted on various research news, sites and blogs from various sources including NSF, ACM, ASU, and the Discovery channel. He was TPC Chair of BodyNets 2008 conference and TPC co-chair for Greencom 2013 conference and SI co-editor for IEEE Pervasive, IEEE Transactions on Computers, IEEE Transactions on Knowledge and Data Engineering, and IEEE Proceedings. Dr. Gupta heads the IMPACT Lab ( http://impact.asu.edu ) at Arizona State University.
1 In this paper, the term “ML application” refers to ML-based CI application.