Robust Adversarial Immune-Inspired Learning System

Abstract

The lack of robustness of Deep Neural Networks (DNNs) against different types of attacks is problematic in adversarial environments. The long-standing and arguably most powerful natural defense system is the mammalian immune system, which has successfully defended the species against attacks by novel pathogens for millions of years. This disclosure proposes a Robust Adversarial Immune-inspired Learning System (RAILS) inspired by the mammalian immune system. The RAILS approach is demonstrated using adaptive immune system emulation to harden Deep k-Nearest Neighbor (DkNN) architectures against evasion attacks. Using evolutionary programming to simulate new B-cell generation that occurs in natural immune systems, e.g., B-cell flocking, clonal expansion, and affinity maturation, it is shown that the RAILS learning curve exhibits similar learning behavior as observed in in-vitro experiments on B-cell affinity maturation. The life-long learning mechanism allows RAILS to evolve and defend against diverse attacks.

Description

FIELD

The present disclosure relates to techniques for emulating immune system defense mechanisms to thwart adversarial attacks on deep learning systems.

BACKGROUND

State of the art in supervised learning, especially deep learning, has dramatically improved over the past decades. Many techniques are widely used as effective tools aiding human tasks, e.g., face recognition, object detection, natural language processing. Despite effectiveness, deep learning techniques have all been demonstrated vulnerable to imperceptibly examples intentionally designed by evasion attack (aka. adversarial attack). The vulnerability of deep neural networks (DNN) restricts its application scenarios and motivates researchers to develop various defense techniques.

The current defense methods can be broadly divided into three categories: (1) adversarial example detection, (2) robust training, and (3) robust deep architectures. The first category of methods intends to protect the model by distinguishing the adversarial examples. However, it was shown that adversarial detection methods are not perfect and can be easily defeated. Different from detecting the outliers in the first category, robust training aims to harden the model to deactivate the evasion attack. Known robust training methods are tailored to a certain level of attack strength in the context of l_p-perturbation. Moreover, the trade-off between accuracy and robustness becomes an obstruction to enhance the robustness. Recent works are also exploring another possibility designing robust deep architectures that are naturally resilient to evasion attacks. Nevertheless, relying on the architecture alone cannot provide enough robustness, either the prediction confidence.

Facing the artificial design system's vulnerability to attacks, a natural question to ask is: can we find a robust biological system for our reference? The immune system may be the answer. Recent studies have shown that the immune system takes advantages of the three categories of defense mechanisms and incorporates life-long learning, permitting continuous hardening of the system. The immune system has the detector to distinguish the non-self contents from the self components, and is embedded with robust natural architecture. Even more surprising, the immune system continuously increases its robustness by adaptively learning from attacks.

Motivated by the immune system's powerful defense ability, this disclosure aims to develop a Robust Adversarial Immune-Inspired Learning System (RAILS) that can effectively defend against evasion attacks on deep learning systems.

This section provides background information related to the present disclosure which is not necessarily prior art.

SUMMARY

This section provides a general summary of the disclosure, and is not a comprehensive disclosure of its full scope or all of its features.

A computer-implemented method is presented for classifying an input using a deep learning system. The method includes: receiving an input for a deep learning system, where the deep learning system was trained with a training dataset and the training dataset includes data for a plurality of classes; for each class in the training dataset, identifying a set of data points in the training dataset, where the data points in the set of data points are similar to the input; for each set of data points, generating additional data points from data points in the set of data points using genetic operators (such as selection, mutation, and crossover); for each of the data points, calculating a similarity score in relation to the input; selecting a subset of data points with the highest similarity scores amongst the data points; and predicting a class label for the input from the plurality of classes, where the prediction of a class label for the input is determined by consensus of the data points in the subset of data points with the highest similarity scores.

In some embodiments, the input is identified as an outlier prior to the step of identifying a set of data points, and remaining steps of the method are performed only when the input is identified as an outlier.

The method may further include: selecting a first subset of data points and selecting a second subset of data points, where the data points in the first subset of data points have an average similarity score higher than the average similarity score of the data points in the second subset of data points, and the data points in the second subset of data points has an average similarity score higher than the average similarity score for all of the data points. Furthermore, the input is classified to a predicted class in the plurality of classes, where the predicted class has the most similar data points to the input in the first subset of data points; and the training dataset is updated by appending the data points in the second subset to the training dataset.

Further areas of applicability will become apparent from the description provided herein. The description and specific examples in this summary are intended for purposes of illustration only and are not intended to limit the scope of the present disclosure.

DRAWINGS

The drawings described herein are for illustrative purposes only of selected embodiments and not all possible implementations, and are not intended to limit the scope of the present disclosure.

FIG. 1 is a diagram illustrating a simplified immune system.

FIG. 2 is a block diagram showing the computational workflow of the proposed RAILS system.

FIGS. 3A and 3B are graphs showing the learning curves for an in-vitro analog immune system and the RAILS system, respectively.

FIG. 4 is a diagram showing adaptive immune system emulation integrated with a deep n-nearest neighbor method.

FIG. 5 is a diagram providing an overview of the classification method implemented by the RAILS system.

FIGS. 6A and 6B are confusion matrices comparing results for adversarial inputs to the RAILS system and to a k-nearest neighbor method for a first convolutional layer and a second convolutional layer, respectively.

FIGS. 7A and 7B are confusion matrices comparing results for clean inputs to the RAILS system and to a k-nearest neighbor method for a first convolutional layer and a second convolutional layer, respectively.

FIGS. 8A and 8B are graphs showing the proportion of the true class population in each generation changes when the generation number increases.

FIGS. 9A and 9B are graphs showing the affinity score of the true class population in each generation change when the generation number increases.

FIG. 10 shows the plasma data and memory data generated by the RAILS system.

FIGS. 11A and 11B are confusion matrices showing prediction results for adversarial inputs and clean inputs, respectively.

Corresponding reference numerals indicate corresponding parts throughout the several views of the drawings.

DETAILED DESCRIPTION

Example embodiments will now be described more fully with reference to the accompanying drawings.

Robustness in systems comes from architecture, and one of the greatest examples of this is within the mammalian adaptive immune system. With reference to FIG. 1, the architecture of the adaptive immune system ensures a robust response to foreign antigens, splitting the work between active sensing and competitive growth to produce an effective antibody. Sensing of a foreign attack leads to antigen-specific B cells flocking to lymph nodes, and forming temporary structures called germinal centers. Here a diverse initial set of B cells bearing antigen-specific immunoglobulins divide symmetrically in the expansion phase to populate the germinal center in preparation for affinity maturation. During affinity maturation, or the selection phase, B cells with the highest affinity to the antigen are repeatedly selected to asymmetrically divide and mutate for affinity optimization. Within this step, memory B cells are created which can be used to defend against similar attacks in the future. B cells that reach consensus, or achieve a threshold affinity against the foreign antigen, undergo terminal differentiation into plasma B cells, which represent the actuators of the humoral adaptive immune response. The adaptive immune system is incredibly complex, but one can simplify its robust learning process into these five steps: sensing, flocking, expansion, optimization, and consensus.

The immune system has formed an effective self renewal defense system through millions of years of evolution. Motivated by the recent understanding of the immune system, this disclosure proposes a new defense system—Robust Adversarial Immune-Inspired Learning System (RAILS). This computational system has a one-to-one mapping to the simplified immune system. FIG. 2 illustrates the computational workflow for the RAILS system 20. For example, the RAILS system 20 emulates the clonal expansion in the immune system, which enlarges the population of the candidates (B-cell). Similar to the plasma B-cell and memory B-cell generated in the immune system, the RAILS system generates plasma data 21 and memory data 22. Plasma B-cell data 21 is used to predict the present inputs, while memory B-cell data 22 is used to generate the antibody of the present antigen. They are all used to defend against the current attacks. Memory data and memory B-cell also have the same function in that they all contribute to the defense of future attacks.

To demonstrate that the computational system indeed captures some exclusive properties of the immune system, the learning curves for an immune system and the RAILS system 20 are shown in FIGS. 3A and 3B, respectively. The green and red lines depict the affinity change between the population and the antigen (test data). The activated naive B-cell (nearest data points) come from antigen 1 (test data 1) in all tests. The immune system's learning curves have a small affinity decrease at the beginning. This phenomenon demonstrates a two-phase learning process—expansion and optimization. Expansion corresponds to B-cell diversity, while optimization corresponds to B-cell selection. Surprisingly, one observes the same phenomenon in the learning curve for the RAILS system 20. This suggests that the computational system is aligned with the immune system.

Adaptive Immune System Emulation (AISE) is designed and implemented with a bionic process inspiring by the mammalian immune system. Concretely, AISE generates plasma data (plasma B-cells) and memory data (memory B-cells) through multiple generations of evolutionary programming that includes three operations, namely, selection, mutation, and cross-over. The plasma data and memory data are selected in different ways, thus contributing to different model robustifying levels. The plasma data contributes to the robust predictions of the present inputs, and the memory data helps to adjust the classifiers to effectively defend future attacks. From the perspective of classifier adjustment, AISE's learning process can be divided into static learning and adaptive learning.

Static learning helps to correct the predictions of the present inputs. For illustration purposes, adaptive immune system emulation is shown integrated with a deep k-nearest neighbor (DkNN) algorithm as seen in FIG. 4. While reference is made herein to k-nearest neighbor algorithms, it is readily understood that the adaptive immune system emulation techniques can be integrated with other types of classification method, including but not limited to decision trees, neural networks and support vector machines.

Recall that DkNN algorithms integrate predicted k nearest neighbors of layers in the deep neural network, and the final prediction y_DkNN can be obtained by the following formula.

y _DkNN=arg max_cΣ_l=1^Lp_l^c(x) subject to c ∈ [C]  (1)

where l is the l-th layer of a DNN with L layers in total. p_l^c(x) is the probability predicted by kNN of class c in layer l of input x. There is a finite set of classes and the total number is C. [C] denotes the set [1, 2, . . . , C]. Note that p_l^c (x) could be small for poisoned data, e.g., adversarial example, even c is the true class y_true. The purpose of the static learning is to increase p_l^ytrue (x) (even to one) of the present input x. The key idea is to generate new examples via clonal expansion and optimization, and only select the examples with high affinity (plasma data) to the input. The hypothesis is that examples inherited from parents of class y_true have higher chance of reaching the high affinity and, therefore, survival. After the process, a majority vote is enough to make the correct prediction.

Different from static learning, adaptive learning tries to harden the classifiers to defend the potential attacks in the future. The hardening is done by leveraging another set of data—memory data generated after clonal expansion. Unlike plasma data, memory data is selected from examples with moderate-affinity to the input, which can rapidly adapt to new variants of the current adversarial examples. This approach permits the continuous hardening of the model during the inference stage, which is life-long learning accompanied by increasing defensive ability. The adaptive learning will provide a naturally high p_l^ytrue (x) even if using the DkNN alone. This disclosure will mainly focus on static learning and single-stage adaptive learning that only hardens the classifier once. It is envisioned that the concepts herein can be extended to multi-stage adaptive learning as well.

With continued reference to FIGS. 2 and 4, an example implementation for the proposed RAILS system 20 is described. Given a mapping ^d→^d, and two vectors x₁, x₂ ∈ ^d, first define the affinity score between x₁, x₂ as A(F; x₁, x₂)=−∥F(x₁)−F(x₂) ∥2, where A is the affinity function using a negative Euclidean distance. In the DNN context, F denotes the feature mapping from input to a feature representation, and A measures the similarity between two inputs. In this context, the affinity score is understood to be a distance score or a similarity score, where higher affinity scores indicate higher similarity.

Sensing is the first step of the process as indicated at 23. This step is to conduct the initial identification of the adversarial inputs and the clean inputs. The identification is an outlier detection process and can be done using different methods. In one example, DkNN provides a metric called credibility that can measure the consistency of k-nearest neighbors in each layer. The higher the credibility, the higher the confidence that the input is clean (i.e., not an outlier). Other suitable outlier detection methods include those described by L. Zhou, Y. Wei and A. Hero in “Second-Order Asymptotically Optimal Universal Outlying Sequence Detection with Reject Option,” arxiv:2009.03505, September 2019; by E. Hou, K. Sricharan, A. O. Hero in “Latent Laplacian Maximum Entropy Discrimination for Detection of High-Utility Anomalies” IEEE Transactions on Information Forensics and Security, Vol. 13, No. 6, pp. 1446-1459, June 2018; and by K. Sricharan and AO Hero in “Efficient anomaly detection using bipartite k-NN graphs,” Proc. of Neural Information Processing Systems (NIPS), Grenada Spain, December 2011 which are incorporated by reference herein. These example are merely illustrative and other outlier detection methods are also contemplated by this disclosure.

The sensing stage provides a confidence score of the DkNN architecture. In some embodiments, the remaining steps of the classification are executed only when the input is identified as an outlier. That is, the confidence score is below a predetermined threshold. In other embodiments, the sensing stage can be skipped or omitted from the classification process implemented by the RAILS system 20.

Flocking 24 is the start point for clonal expansion. For each class and each layer, find the k-nearest neighbors that have the highest initial affinity score to the input data. Mathematically, select

$\begin{array}{cc}{N}_l^c=\{\left(\hat{x},y_c|R_c\left(\hat{x}\right)\le k,\left(\hat{x},y_c\right)\in D_c\right\}\mathrm{Given}A\left(f_l;x_i^c,x\right)\le A\left(f_l;x_i^c,x\right)\Leftarrow R_c\left(i\right)>R_c\left(j\right)\forall c\in \left[C\right],l\in \left[L\right],\forall i,j\in \left[n_c\right],& \left(2\right)\end{array}$

where x is the input, Dc is the training dataset from class c and the size |D_c|=n_c.R_c: [n_c]→[n_c] is a ranking function that sorts the indices based on the affinity score. If memory data exists, the nearest neighbors method uses both the training data and the existing memory data.

Next, expansion 25 generates new examples (offspring) from the existing examples (parents). The ancestors are nearest neighbors found by the flocking step. The process can be viewed as creating new nodes linked to the existing nodes, and can be characterized by Preferential Attachment as described by Barabasi and Albery in “Emergence of Scaling in Random Networks” Science, 286(5439): 509-512. The probability of a new node linking to node i is

$\begin{array}{cc}\mathrm{II}\left(k_i\right)=\frac{k_i}{\sum _j{k}_j},& \left(3\right)\end{array}$

where k_i is the degree of node i. New nodes prefer to attach to existing nodes having a high degree. In the RAILS system 20, the degree is the exponential of affinity measurement, and the offspring is generated by parents having high probability in the network and subnetworks. In the example embodiment, the diversities in expansion are provided by genetic operators of selection, mutation and cross-over. Other types of genetic operators are also contemplated by this disclosure. After new examples are generated, the RAILS system calculates each new example's affinity score to the input. The new examples are associated with labels that are inherited from their parents.

Optimization (affinity maturation) step 26 selects generated examples with high affinity scores to be plasma data 21, and examples with moderate-affinity scores are saved as memory data 22. The selection is based on a ranking function.

S _opt={({tilde over (x)}, {tilde over (y)})|R_g({tilde over (x)})≤|P^(G)|, ({tilde over (x)}, {tilde over (y)}) ∈ P^(G)}  (4)

where R_g: [|P^(G)|]→[|P^(G)|] is the same ranking function as R_c except that the domain is the set of cardinality of the final population P^(G). In one example, is a percentage parameter and is selected as 0.05 and 0.25 percent for plasma data and memory data, respectively. Note that the memory data can be selected in each generation and in a nonlinear way. In the example embodiment, memory data is selected only in last generation. Memory data will be saved in a secondary database of the system and used for model hardening.

Consensus 27 is preferably used to predicting a class label for the input. That is, the prediction of the class label for the input is determined by consensus of the data points with the highest similarity scores. In one example embodiment, the prediction for the input is determined by majority vote although other consensus methods also fall within the scope of this disclosure. Note that all the examples are associated with labels.

Algorithm 1 below further describes the five step workflow for the RAILS system 20.

Algorithm 1 Robust Adversarial Immune-inspired Learning
System (RAILS)
Require: Test data point x; Training dataset tr =
   {1, 2, . . . , C}; Number of Classes C; Model M
   with feature mapping fl (·), l ∈  ; Affinity function A.
   First Step: Sensing
1: Check the threat score given by an outlier detection
   strategy to detect the threat of x.
   Second Step: Flocking
2: for c = 1, 2, . . . , C do
3: In each layer l ∈  , find the k-nearest neigh-
   bors     of x in c by ranking the affiinty score
   A(fl; xj, x), xj ∈ c
4: end for
   Third and Fourth Steps: Expansion and Optimiza-
   tion
5. Return plasma data Sp and memory data Sm by using
   subroutine: Algorithm 2
   Fifth Step: Consensus
6: Obtain the prediction y of x using the majority vote of
   the plasma data
7: Output: y, the memory data
indicates data missing or illegible when filed

It is to be understood that only the relevant steps of the algorithm are shown, but that other software-implemented instructions may be needed to control and manage the overall operation of the system.

Clonal expansion and affinity maturation (optimization) are the two main steps after flocking. Algorithm 2 below sets for an example implementation for these two steps.

Algorithm 2 Clonal Expansion & Optimization
Require: x; k-nearest neighbors in each layer lc, c ∈
[C], l ∈  ; Population size T; Maximum generation
number G; Mutation probability ρ; Mutation range parameters
δmin, δmax; Sampling temperature τ
1:  For each layer l ∈  , do
2:  c              (0) ← Mutation(x′) for TCK⁢⁢times,
    ∀x′ ∈ lc, ∀c ∈ [C].
3:  for g = 1, 2, . . . , G do
4:  for i = 1, 2, . . . , T/C do
5:  Pc(g-1) = Softmax(A(fi;  c(g−1), x)/τ)
6:  (xc, yc) = Selection(Pc(g−1), c(g−1))
7:  (xc′, yc) = Selection(Pc(g−1),  c(g−1))
8:  xos′ = Crossover(xc, xc′)
9:  xos = Mutation(xos′)
10: c(g) ← (xos, yc)
11: end for
12: end for
13: Calculate the affinity score A(fl;  (C), x), ∀c ∈ [C]
    given  (G) =  1(G) ∪ . . . ∪ C(G).
14: end For
15: Select the top 5% as plasma data Spl and the top 25% as
    memory data Sml based on the affinity scores. ∀l ∈
16: end For
17: Output: Sp = {Sp1, Sp2, . . . ,  } and
    Sm = {Sm1, Sm2, . . . ,  }

The goal is to promote diversity and explore the best solutions in a broader searching space.

The selection operation aims to decide which candidates in the generation will be chosen to generate the offspring. In one example, the probability for each candidate is calculated through a softmax function as follows.

$\begin{array}{cc}P\left(x_i\right)=\frac{\mathrm{Softmax}\left(A\left(f_l;x_{i}x\right)/\tau \right)\exp \left(A\left(f_l;x_i,x\right)/\tau \right)}{=\sum _{\mathrm{xj}\in s}\exp \left(A\left(f_l;x_j,x\right)/\tau \right)}& \left(5\right)\end{array}$

where S is the set containing data points and x_i ∈ S. τ>0 is the sampling temperature that controls the distance after softmax operation. Given the probability P of a candidates set S, the selection operation is to randomly pick one example pair (x_i, y_i) from S according to its probability.

(x_i, y_i)=Selections(S, P)   (6)

In the example embodiment, two parents are selected for each offspring, and the second parent is selected from the same class of the first parent. The parents selection process appears in line 5—line 7 in Algorithm 2.

Next, the crossover operator combines different candidates (parents) for generating new examples (offspring). Given two parents x_p and x_p^l, the new offspring is generated by selecting each entry (e.g., pixel) from either x_p or x_p^l via calculating the corresponding probability. Mathematically,

$\begin{array}{cc}{x}_{os}^l=\mathrm{Crossover}\left(x_p,x_p^l\right)=\{\begin{array}{c}{x}_p^{\left(l\right)}\mathrm{with}\mathrm{prob}\frac{A\left(f_l;x_p,x\right)}{A\left(f_l;x_p,x\right)+A\left(f_l;x_p^l,x\right)}\\ x_p^{l\left(i\right)}\mathrm{with}\mathrm{prob}\frac{A\left(f_l;x_p^l,x\right)}{A\left(f_l;x_p,x\right)+A\left(f_l;x_p^l,x\right)}\end{array}\forall i\in \left[d\right]& \left(7\right)\end{array}$

where i represents the i-th entry of the example and d is the dimension of the example. The cross-over operator appears in line 8 in Algorithm 2.

This operation mutates each entry with probability ρ by adding uniformly distributed noises in the range [−δ_max,−δ_min]∪[δ_min,δ_max]. The resulting perturbation vector is subsequently clipped to satisfy the domain constraints.

x _OS=Mutation(x_OS^l)=Clip_[0,1](x_OS^l+1_{[Bernoulli(p)]}u([−δ_max,−δ_min]∪[δ_min,δ_max]))   (8)

where 1_{[Bernoulli(p)]} takes value 1 with probability ρ and value 0 with probability 1−ρ. u([−δ_max,−δ_min]∪[δ_min,δ_max]) is the vector that each entry is i.i.d. chosen from the uniform distribution U([−δ_max,−δ_min]∪[δ_min,δ_max]). Clip_[0,1](x) is equivalent to max(0, min(x,1)). The mutation operation appears in line 2 and line 9 in Algorithm 2.

An overview of this classification method is described in relation to FIG. 5. As a starting point, an input to a deep learning system is received as indicated at 51. In one example, the deep learning system is a convolutional neural network with a plurality of hidden layers. The adversarial learning techniques described herein can be applied to other types of deep learning systems as well. It is understood that the deep learning system was trained with a training dataset having data from different classes.

A determination is made at 52 as to whether the input is an outlier. When the input is identified as an outlier, the process continues with the adversarial learning steps as indicated at 53. When the input is identified as a valid input, the input can be classified by the deep learning system without the adversarial learning steps. In some embodiments, detection of outliers can be skipped.

Next, training data similar to the input is identified at step 53. For each class in the training dataset, a set of data points is identified in the training dataset, where the data points in the set of data points are similar to the input. In one example, the set of data points is identified in one or at least one hidden layer of the neural network. In other examples, sets of data points are identified in more than one hidden layer or in each hidden layer of the neural network.

The set (or sets) of identified data points are then expanded using genetic operators. That is, for each set of identified data points, additional data points are generated at 54 from data points in the set of data points using genetic operators. Genetic operators may include but are not limited to selection, mutation and crossover as described above. The identified data points and the additional data points collectively form a pool of data points. For each of the data points in the pool of data points, a similarity score is also calculated in relation to the input.

Memory data is selected at 55 and plasma data is selected at 56. That is, a first subset of data points is selected and a second subset of data points is selected, where the data points in the first subset have an average similarity score higher than the average similarity score of the data points in the second subset of data points, and the data points in the second subset of data points has an average similarity score higher than the average similarity score for all of the data points. In one example, data points in the first subset of data points have a similarity score in top x percent of data points (e.g., top 5%) while the data points in the second subset of data points have a similarity score in top y percent of data points (e.g., top 20%). In another example, data points in the first subset of data points have a similarity score in top x percent of data points (e.g., top 5%) while the data points in the second subset of data points have a similarity score outside the top x percent but within the top y percent of data points (i.e., between 5% and 20%). In any case, the first subset of data points serves as the plasma data and the second subset of data points serves as memory data.

Finally, a prediction of the class label for the input is made at 57 using the plasma data. More specifically, the prediction of a class label for the input is determined by consensus of the data points in the subset of data points with the highest similarity scores. The memory data may be appended to the training data and used to classify subsequent inputs.

For the sake of simplicity, experiments are conducted in the perspective of image classification. The RAILS system 20 is compared to standard Convolutional Neural Network Classification (CNN) and Deep k-Nearest Neighbors Classification (DkNN) using the MNIST dataset. The MNIST dataset is a 10-class handwritten digit database consisting of 60,000 training examples and 10,000 test examples. The RAILS system is tested using a four-convolutional-layer neural network. The performance will be measured by standard accuracy (SA) evaluated using benign (unperturbed) test examples and robust accuracy (RA) evaluated using the adversarial (perturbed) test examples.

In addition to the clean test examples, 10,000 adversarial examples were generated using a 20-step PGD attack with attack strength E=40=60. By default, number of population T=1000, mutation probability ρ=0:15, mutation range parameters δ _min=0:05(12:75=255); δ max=0:15(38:25=255), and maximum generation number G=50. To speed up the algorithm, the running stops when the newly generated examples are all from the same class. The sampling temperature τ in each layer is set to 3, 18, 18, 72.

First, results were obtained from a single layer of the CNN model in the RAILS system and compared with the results from DkNN. Table 1 below shows the comparison results in the input layer, the first convolutional layer (Conv1), and the second convolutional layer (Conv2).

TABLE 1
SA/RA Performance of RAILS versus DkNN in
single layer
		Input	Conv1	Conv2
SA	RAILS	97.53%	97.7%	97.78%
	DkNN	96.88%	97.4%	97.42%
RA	RAILS	93.78%	92.56%	89.29%
(∈ = 40)	DkNN	91.81%	90.84%	88.26%
RA	RAILS	88.83%	84.18%	73.42%
(∈ = 60)	DkNN	85.54%	81.01%	69.18%

One can see that for both standard accuracy and robust accuracy, RAILS can improve DkNN in the hidden layers and reach better results in the input layer. The input layer results indicate that RAILS can also outperform the performance of supervised learning methods like kNN. Referring to FIGS. 6A, 6B, 7A and 7B, the confusion matrices show that RAILS has less wrong predictions for those data that DkNN gets wrong. Each value in matrices represents the percentage of intersections of RAILS (correct or wrong) and DkNN (correct or wrong).

Clonal expansion of RAILS system creates new examples in each generation. To better understand the capability of the RAILS system, one can visualize the changing of some key indices during the algorithm running. After the expansion and optimization, the plasma data and memory data can be compared to the nearest neighbors DkNN found.

FIGS. 8A and 8B shows how the population of the true class examples in each generation change when the generation number increases; whereas, FIGS. 9A and 9B shows how the population of the true class examples in each generation change when the generation number increases. Two examples are shown. DkNN only makes a correct prediction to the first one and obtains low confidence for all two examples. The data proportion of true class in each generation's population is shown in the first curve row. Data from the true class occupies the majority of population when the generation number increases, which indicates that the RAILS system can obtain correct prediction and the high confidence score, simultaneously. At the same time, clonal expansion over multiple generations produces increased affinity within the true class, as shown in the second curve row. Another observation is that RAILS system requires less generation number when DkNN gets correct, suggests that affinity maturation occurs in fewer generations when test data is easy to classify.

FIG. 10 shows the plasma data and memory data generated by the RAILS system. For the first example—digit 9, DkNN gets 9 in four out of five nearest neighbors. For the other two examples—digit 2 and digit 1, the nearest neighbors only contain a small amount of data from the true class. In contrast, the plasma data generated by the RAILS system are all from the true class, which provides correct prediction with confidence value 1. The memory data captures the information of the adversarial variants and is associated with the true label. They can be used to defend future adversarial inputs.

RAILS performance is compare to CNN and DkNN in terms of SA and RA. DkNN use 750 calibration data and 59250 training data. RAILS leverages the static learning to make the predictions. The results are shown in Table 2 below.

TABLE 2
SA/RA Performance of RAILS versus CNN
and DkNN (∈ = 60)
		SA	RA
	RAILS	97.75%	76.67%
	CNN	99.16%	1.01%
	DkNN	97.99%	71.05%

CNN has a poor performance on adversarial examples. One can see that RAILS delivers an additional 5.62% improvement in RA without appreciable loss of SA as compare to applying DkNN alone. The confusion matrices in FIGS. 11A and 11B indicate that the correct predictions of the RAILS system cover a majority of DkNN's correct predictions and overlap with DkNN's wrong predictions.

The techniques described herein may be implemented by one or more computer programs executed by one or more processors. The computer programs include processor-executable instructions that are stored on a non-transitory tangible computer readable medium. The computer programs may also include stored data. Non-limiting examples of the non-transitory tangible computer readable medium are nonvolatile memory, magnetic storage, and optical storage.

Some portions of the above description present the techniques described herein in terms of algorithms and symbolic representations of operations on information. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. These operations, while described functionally or logically, are understood to be implemented by computer programs. Furthermore, it has also proven convenient at times to refer to these arrangements of operations as modules or by functional names, without loss of generality.

Unless specifically stated otherwise as apparent from the above discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system memories or registers or other such information storage, transmission or display devices.

Certain aspects of the described techniques include process steps and instructions described herein in the form of an algorithm. It should be noted that the described process steps and instructions could be embodied in software, firmware or hardware, and when embodied in software, could be downloaded to reside on and be operated from different platforms used by real time network operating systems.

The present disclosure also relates to an apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may comprise a computer selectively activated or reconfigured by a computer program stored on a computer readable medium that can be accessed by the computer. Such a computer program may be stored in a tangible computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, application specific integrated circuits (ASICs), or any type of media suitable for storing electronic instructions, and each coupled to a computer system bus. Furthermore, the computers referred to in the specification may include a single processor or may be architectures employing multiple processor designs for increased computing capability.

The algorithms and operations presented herein are not inherently related to any particular computer or other apparatus. Various systems may also be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatuses to perform the required method steps. The required structure for a variety of these systems will be apparent to those of skill in the art, along with equivalent variations. In addition, the present disclosure is not described with reference to any particular programming language. It is appreciated that a variety of programming languages may be used to implement the teachings of the present disclosure as described herein.

The foregoing description of the embodiments has been provided for purposes of illustration and description. It is not intended to be exhaustive or to limit the disclosure. Individual elements or features of a particular embodiment are generally not limited to that particular embodiment, but, where applicable, are interchangeable and can be used in a selected embodiment, even if not specifically shown or described. The same may also be varied in many ways. Such variations are not to be regarded as a departure from the disclosure, and all such modifications are intended to be included within the scope of the disclosure.

Claims

1. A computer-implemented method of classifying an input using a deep learning system, comprising: receiving, by a computer processor, an input for a deep learning system, where the deep learning system was trained with a training dataset and the training dataset includes data for a plurality of classes;for each class in the training dataset, identifying, by the computer processor, a set of data points in the training dataset, where the data points in the set of data points are similar to the input;for each set of data points, generating, by the computer processor, additional data points from data points in the set of data points using genetic operators;for each of the data points, calculating, by the computer processor, a similarity score in relation to the input;selecting, by the computer processor, a subset of data points with the highest similarity scores amongst the data points; andpredicting, by the computer processor, a class label for the input from the plurality of classes, where the prediction of a class label for the input is determined by consensus of the data points in the subset of data points with the highest similarity scores.

2. The method of claim 1 further comprises identifying the input as an outlier prior to the step of identifying a set of data points, and continuing with remaining steps of the method only when the input is identified as an outlier.

3. The method of claim 1 further comprises identifying a set of data points in the training dataset by computing a distance measure between the input and each data point in the training dataset

4. The method of claim 1 further comprises identifying a set of data points in the training dataset using a k-nearest neighbor method.

5. The method of claim 1 wherein the deep learning system is a neural network with a plurality of hidden layers and further comprises, for one or more of the hidden layers, identifying the set of data points in the training dataset that are similar to the input for each class in the training data set.

6. The method of claim 1 wherein the genetic operators are selected from a group consisting of selection, mutation, and crossover.

7. The method of claim 1 wherein selecting a subset of data points further comprises selecting a first subset of data points and selecting a second subset of data points, where the data points in the first subset of data points have an average similarity score higher than the average similarity score of the data points in the second subset of data points, and the data points in the second subset of data points has an average similarity score higher than the average similarity score for all of the data points.

8. The method of claim 7 further comprises classifying the input to a predicted class in the plurality of classes, where the predicted class has the most similar data points to the input in the first subset of data points; and updating the training dataset by appending the data points in the second subset to the training dataset.

9. A computer-implemented method of classifying an input using a deep learning system, comprising: receiving, by a computer processor, a first input for a deep learning system, where the deep learning system was trained with a training dataset and the training dataset includes data for a plurality of classes;for each class in the training dataset, identifying, by the computer processor, a set of data points in the training dataset, where the data points in the set of data points are similar to the first input;for each set of identified data points, generating, by the computer processor, additional data points from data points in the set of identified data points using genetic operators, where the identified data points and the additional data points collectively form a pool of data points;for each of the data points in the pool of data points, calculating, by the computer processor, a similarity score in relation to the first input;selecting, by the computer processor, a subset of data points with the highest similarity scores amongst the data points in the pool of data points;appending, by the computer processor, the data points in the subset of data points to the training dataset;receiving, by the computer processor, a second input for the deep learning system;for each class in the training dataset, identifying, by the computer processor, a second set of data points in the training dataset, where the data points in the second set of data points are similar to the second input;for each second set of data points, generating, by the computer processor, additional data points from data points in the second set of data points using genetic operators, where the identified data points and the additional data points collectively form a second pool of data points;for each of the data points in the second pool of data points, calculating, by the computer processor, a similarity score in relation to the second input;selecting, by the computer processor, a subset of data points with the highest similarity scores amongst the data points in the second pool of data points; andpredicting, by the computer processor, a class label for the second input from the plurality of classes, where the prediction of a class label for the second input is determined by consensus of the data points in the second pool of data points with the highest similarity scores.

10. The method of claim 9 further comprises predicting a class label for the first input from the plurality of classes, where the prediction of a class label for the first input is determined by consensus of the data points in the first pool of data points with the highest similarity scores.

11. The method of claim 9 further comprises identifying a set of data points in the training dataset using a k-nearest neighbor method.

12. The method of claim 9 wherein the deep learning system is a neural network with a plurality of hidden layers and further comprises, for one or more of the hidden layers in the deep learning system, identifying the set of data points in the training dataset that are similar to the first input for each class in the training data set.

13. The method of claim 9 wherein the genetic operators are selected from a group consisting of selection, mutation, and crossover.

14. A deep learning system, comprising: a training data set having data from a set of classes;a flocking module configured to receive an input for a deep learning system and operates to identify a set of data points in the training dataset for each class in the set of classes, where the data points in the set of data points are similar to the input;for each set of data points, an expansion module generates additional data points from the data points in a given set of data points using genetic operators, where each additional data point is tagged with class inherited from its parents;for each of the data points, an optimizer module calculates a similarity score in relation to the input and selects a subset of data points with the highest similarity scores amongst the data points; anda predictor module predicts a class label for the input from the plurality of classes, where the prediction of a class label for the input is determined by consensus of the data points in the subset of data points with the highest similarity scores.

15. The deep learning system of claim 14 wherein the set of data points in the training dataset is identified by computing a distance measure between the input and each data point in the training dataset

16. The deep learning system of claim 14 wherein the set of data points in the training dataset is identified using a k-nearest neighbor method.

17. The deep learning system of claim 14 includes a neural network with a plurality of hidden layers.

18. The deep learning system of claim 14 wherein the genetic operators are selected from a group consisting of selection, mutation, and crossover.

19. The deep learning system of claim 14 wherein selecting a subset of data points further comprises selecting a first subset of data points and selecting a second subset of data points, where the data points in the first subset of data points have an average similarity score higher than the average similarity score of the data points in the second subset of data points, and the data points in the second subset of data points has an average similarity score higher than the average similarity score for all of the data points.

20. The deep learning system of claim 14 further comprises classifying the input to a predicted class in the plurality of classes, where the predicted class has the most similar data points to the input in the first subset of data points; and updating the training dataset by appending the data points in the second subset to the training dataset.