Incremental Bounded Model Checking of Artificial Neural Networks in CUDA

TL;DR

This paper introduces a novel CUDA-based symbolic verification framework for artificial neural networks, enabling the detection of adversarial cases and safety property violations in safety-critical applications.

Contribution

It develops the first symbolic verification framework for CUDA-implemented ANNs using incremental bounded model checking, enhancing safety analysis capabilities.

Findings

Successfully verified safety properties in ANNs

Generated 28 adversarial cases in MLPs

Demonstrated effectiveness of the framework in CUDA environments

Abstract

Artificial Neural networks (ANNs) are powerful computing systems employed for various applications due to their versatility to generalize and to respond to unexpected inputs/patterns. However, implementations of ANNs for safety-critical systems might lead to failures, which are hardly predicted in the design phase since ANNs are highly parallel and their parameters are hardly interpretable. Here we develop and evaluate a novel symbolic software verification framework based on incremental bounded model checking (BMC) to check for adversarial cases and coverage methods in multi-layer perceptron (MLP). In particular, we further develop the efficient SMT-based Context-Bounded Model Checker for Graphical Processing Units (ESBMC-GPU) in order to ensure the reliability of certain safety properties in which safety-critical systems can fail and make incorrect decisions, thereby leading to unwanted material damage or even put lives in danger. This paper marks the first symbolic verification framework to reason over ANNs implemented in CUDA. Our experimental results show that our approach implemented in ESBMC-GPU can successfully verify safety properties and covering methods in ANNs and correctly generate 28 adversarial cases in MLPs.

Tables

Table 1. TABLE I : ANN instantiated examples and covering methods.

Ex	Input	$n_{1,1}$	$n_{2,1}$	$n_{3,1}$	$n_{1,2}$	$n_{2,2}$	$n_{1,3}$
Ex1	(1, -3)	-1,3	-1,80	-0,50	-0,79	-1,370	-1,417
Ex2	(1, -1)	-0,3	-0,40	0,10	0,51	0,090	0,353
Ex3	(1, -1.2)	-0,4	-0,54	0,04	0,38	-0,056	0,176
Ex4	(1, -7)	-3,3	-4,60	-1,70s	-3,39	-4,290	-4,957

Table 2. TABLE II : ANN instances of two inputs.

Neuron	Image ”U”	Noise ”U”
$n_{1,1}$	-1.885322	4.619613
$n_{2,1}$	8.775419	9.796190
$n_{3,1}$	2.959348	5.743809
$n_{4,1}$	10.424796	4.046428
$n_{5,1}$	8.172012	14.466885
$n_{1,2}$	-3.863095	-9.308636
$n_{2,2}$	5.328067	5.263461
$n_{3,2}$	-3.770385	-5.705760
$n_{4,2}$	0.574238	-2.029373
$n_{1,3}$	-6.707186	-7.149290
$n_{2,3}$	-15.815082	-17.246468
$n_{3,3}$	-10.060704	-13.074245
$n_{4,3}$	-9.688183	-4.868999
$n_{5,3}$	-0.555885	3.355738

Table 3. TABLE III : Verification time and proximity parameter relation.

Benchmark	Image	$\gamma$	Verification Time (hours)
Ex1	Vocalic O	0.5	1
Ex2	Vocalic O	1.5	4
Ex3	Vocalic O	2.5	8
Ex4	Vocalic O	3.5	6
Ex5	Vocalic E	0.5	25
Ex6	Vocalic E	0.7	25
Ex7	Vocalic E	1.5	14
Ex8	Vocalic E	3.0	12
Ex9	Vocalic U	0.3	6
Ex10	Vocalic U	0.5	5
Ex11	Vocalic U	1.0	20
Ex12	Vocalic U	1.5	19
Ex13	Vocalic A	1.0	63
Ex14	Vocalic A	1.5	63

Equations

$$u=\sum _{j=0}^n{w}_j\times i_j+b.$$

$$\mathcal{N}(u)=\frac{1}{1+e^{-u}}.$$

$$sign(i)=\{\begin{array}{ll}\text{1,}& \text{if i}\ge 0,\\ \text{0,}& \text{otherwise.}\end{array}$$

$$l_{covered\_neuron}\iff (\frac{\sum _{i,j}\mathrm{ss}(n_{k,l},x_1,x_2)}{N}\ge P).$$

$$l_{covered\_neuron}\iff (\frac{\sum _{i,j}\mathrm{ds}(n_{k,l},x_1,x_2,h)}{N}\ge P).$$

$$l_{covered\_neuron}\iff (\frac{\sum _{i,j}\mathrm{sv}(n_{k,l},x_1,x_2,g)}{N}\ge P).$$

$$l_{covered\_neuron}\iff (\frac{\sum _{i,j}\mathrm{ss}(n_{k,l},x_1,x_2,g,h)}{N}\ge P).$$

$$\delta (P,Q)=\sqrt{\sum _{i=0}^n(p_i-q_i{)}^2}.$$

$$I^d\in {\mathcal{D}}^{\text{m}\times \text{n}}$$

$$R=I\in {\mathbb{M}}^{mn}\mid \delta (I^d,\mathcal{I})\le b\}.$$

$${\mathcal{Y}}^d$$

$$l_{image\_misclassified}\iff (n_{D,3}<V)\wedge (n_{i,3}>V).$$

Full text

I Introduction

Artificial Neural Networks (ANNs) have been used to perform various tasks in a safety-critical domain (e.g., medical diagnosis [1] and self-driving autonomous cars [2]), where failures such as misclassifications can put lives in danger. In particular, small noises and adversarial perturbations can lead ANNs to misclassify simple patterns and cause serious damage in safety-critical systems, e.g., a red traffic light misclassified as green. If these systems are formally verified w.r.t. safety properties, then guarantees could be provided to ensure reliability and avoid errors in safety-critical ANNs. Given the current literature, there exists a gap between implementations of ANNs and safety guarantees. The application of formal methods to ensure these safety properties are not properly consolidated yet, e.g., the application of symbolic (software) model checking is still its infancy to solve this problem [3].

There exist various attempts to apply verification and validation techniques to ensure safety in ANNs. In recent days, testing [4], training [5], and validation [6] have achieved impressive results. Sun et al. [4] show that concolic testing provides reasonable results for generating adversarial cases; the authors describe how unsafe can ANNs be but they do not address actual implementations of ANN to provide formal safety guarantees. Zheng et al. [5] show how training techniques can bring noise robustness to the trained ANN, but no formal guarantees from a safety perspective are provided. Krogh and Vedelsby [6] describe validations techniques during the training phase and how the training phase can be optimized by exploring the dataset and improving generalization capability. These studies, however, do not provide safety guarantees for the implementation of ANNs. Despite positive recent results obtained from these techniques, symbolic software model checking can be seen as an alternative to ensure the safety of actual implementations of ANN.

In recent years, researchers proposed the verification of ANNs using formal methods [7, 4, 8]. Huang et al. [7] describe a formal verification framework based on Satisfiability Modulo Theories (SMT); they focus on verifying safety classification of images with real cases perturbations such as scratches, changes in camera angle, or lighting conditions. Sun et al. [4] describe and evaluate concolic testing for ANNs; their test criteria measure how adversarial an input is w.r.t. other images. These test criteria are used by an algorithm based on linear programming, which generates test cases by perturbing a given system until adversarial cases are obtained. Katz et al. [8] describe a formal verification technique for checking properties of deep neural networks (DNNs); their technique extended the simplex method to handle ReLU (Rectified Linear Unit) activation function, which is evaluated on the airborne collision avoidance system for unmanned aircraft (ACAS Xu). However, for image classification, the number of layers and neurons is still a problem for formal verification approaches mainly due to a large number of mathematical computations required by the underlying ANN.

Here we describe and evaluate a novel symbolic software verification framework based on incremental bounded model checking (BMC) to check covering methods and adversarial cases in ANNs using the efficient SMT-based Context-Bounded Model Checker for Graphical Processing Units (ESBMC-GPU) [9, 10]. Our approach, implemented on top of ESBMC-GPU, verifies the actual implementation of ANNs using CUDA and its deep learning primitives cuDNN [11] and cuBLAS [12]. Our work makes two major contributions. First, we formally verify covering methods, as described by Sun et al. [4], to measure how adversarial are two images w.r.t. the ANN neurons using incremental BMC. Second, we formally check adversarial cases using instances of ANNs, where only weights and bias descriptions are needed for our verification process. In both checks, we use incremental BMC to iteratively verify the implementation of ANNs for each unwind bound indefinitely (i.e., until it exhausts the time or memory limits). Intuitively, we aim to either find a counterexample with up to k loop unwinding or to fully unwind all loops in the actual implementations of ANNs so we can provide a correct result. Our incremental verification algorithm relies on a symbolic execution engine to increasingly unwind the loop after each iteration of the algorithm.

II Preliminaries

II-A Artificial Neural Networks (ANNs)

Artificial Neural Networks (ANNs) are efficient models for statistical pattern recognition, which makes them a suitable paradigm for learning tasks [13]. Learning in ANNs is based on modifying the synaptic weights of their interconnected units, which will fit their values according to a given set of labeled examples or tasks, during the training phase. A training algorithm uses each input example to converge these weights to specific results. In most applications areas of ANNs, this may solve classification problems and some specific generalization for adversarial situations [14].

There exist various algorithms to train ANNs; backpropagation is a commonly used algorithm [14]. ANNs architectures vary in the type of layers, activation functions, number of layers, and neurons. Perceptron multi-layer [15] is a classic and commonly used ANN. In the safety verification of ANNs, some notations are important to logically represent operations. Hagan et al. [14] describe how Multi-layer Perceptrons (MLPs) calculate a neuron output. The neuron activation potential of an input i = {$i_{0},i_{1},i_{2}...,i_{n}$} will be denoted as u, which is obtained from

[TABLE]

$\mathcal{N}$(i) or Y represents neuron output, that is, $\mathcal{N}$ is the activation function of the activation potential u. Suppose that the activation function is sigmoid, $\mathcal{N}$ would be described by

[TABLE]

ReLU [16], Sigmoid [17], and Gaussian [17] are activation functions commonly used in MLP. All our experimental results are obtained from MLPs with sigmoid activation function.

However, adversarial perturbation or small noises may lead to misclassification. In some cases, this may happen because the network tends to not recognize the data entered due to convergence problems, e.g., the vanishing gradient in back-propagation [13]. Although some techniques can be used to avoid such problems (e.g., gradient regularization [18]), safety-critical systems usually deal with a huge volume of complex data, which may be coded into big numbers and functions such as sigmoid squish. Thus, a large change in the input of the sigmoid function will cause a small change in the output; therefore, the derivative becomes small. For safety-critical applications, detecting where such problems may happen in a complex network is a task that the formal verification community has been seeking to solve (e.g., [7]); our work aims to contribute to the solution of this research problem.

II-B Incremental Bounded Model Checking (BMC)

We have used the ESBMC-GPU tool [9, 10], which is an extension of the Efficient SMT-Based Context-Bounded Model Checker (ESBMC) [19], aimed at verifying Graphics Processing Unit (GPU) programs written for the Compute Unified Device Architecture (CUDA) platform. ESBMC-GPU uses an operational model (OM), i.e., an abstract representation of the standard CUDA libraries, which conservatively approximates their semantics, to verify CUDA-based programs.

Our incremental BMC approach in ESMBC-GPU uses an iterative technique and verifies the implementation of ANNs for each unwind bound indefinitely or until it exhausts the time or memory limits. We aim to either find a counterexample with up to k loop unwinding or to fully unwind all loops. The algorithm relies on ESBMC’s symbolic execution engine to increasingly unwind the loop after each algorithm iteration.

The approach is divided into two steps: one that tries to find property violations and one that checks if all the loops were fully unwound. When searching for property violation, ESBMC-GPU replaces all unwinding assertions (i.e., assertions to check if a loop was completely unrolled) by unwinding assumptions. Normally, this would lead to unsound behavior, however, the first step can only find property violations, thus reporting that an unwinding assertion failure is not a real bug. The next step is to check if all loops in the program were fully unrolled. This is done by checking whether all the unwinding assertions are unsatisfiable. No assertion is checked in the second step because they were already checked in the first step for the current k loop unwinding.

The algorithm also offers the option to change the granularity of the increment; the default value is $1$. Note that changing the value of the increment can lead to slower verification time and might not present the shortest counterexample possible for the property violation. ESBMC-GPU also explicitly explores the possible interleavings of CUDA programs (up to the given context bound), while treats each interleaving itself symbolically. Additionally, ESBMC-GPU employs monotonic partial order reduction [20] and the two-thread analysis [21] to efficiently prune the state-space exploration. ESBMC-GPU verifies properties such as user-specified assertions, deadlocks, memory leaks, invalid pointer dereference, array out-of-bounds, and division by zero in CUDA programs.

III Incremental BMC of ANNs in CUDA

Our goal is to detect adversarial cases that lead ANNs to wrong results. We have developed two verification strategies for ANNs described using weights and bias vectors. First, we check the coverage criteria of ANNs w.r.t. a set of images. Second, we verify safety aspects by checking adversarial cases of a given image known by an ANN.

III-A SMT-based Safety Verification for ANNs

Our incremental verification method is based on two phases: (1) obtain the required models from real ANN programs written in CUDA and (2) design safety properties that ensure reliability of ANN implementations. All models are collected from actual implementations of ANNs written in CUDA. There exist two APIs in CUDA to support neural networks and mathematical operations: cuBLAS [12] and cuDNN [11]. cuBLAS provides mathematical operations such as matrix multiplication and sums; these operations are typically used on feed-forward process of neural networks [14]. cuDNN provides deep neural networks (DNN) primitives such as tensors operations, convolution functions, activation functions, and backward operations [14].

Here we have developed operational models (cf. Section II-B) for the cuBLAS and cuDNN libraries and integrated them into ESBMC-GPU.111The full implementation of our OMs are available at https://github.com/LuizHenriqueSena/ESBMC-GPU/tree/master/cpp/library Any ANN written in CUDA using these APIs can be verified by our method. Additionally, any user-specified assertion can be provided and then verified by ESBMC-GPU. Our operational models aim to perform the same steps that the execution of the original library does but ignoring irrelevant calls (e.g., screen-printing methods), where there exists no safety property to be checked. For the cuBLAS and cuDNN libraries, we ensure that their operational models return the same results as the original APIs. All developed modules were manually verified and exhaustively compared with the original ones to ensure the same behavior via conformance testing [22]. As an example, we can see a pseudo-code of the cublasSgem operational model illustrated in Algorithm 1, which consists of multiplying matrices $A$ and $B$ and store its result in matrix $C$.

III-B Verification of Covering Methods

Covering methods [4] are based on Modified Condition/Decision Coverage (MC/DC) [23], which is a method applied to ensure adequate testing for safety-critical software; in our symbolic verification framework, MC/DC represents conditions and decisions of ANNs. Conditions are neurons in the previously layer and decisions are neurons of the following layer. Covering methods are used to measure how adversarial are two images w.r.t. the ANN neurons. There exist four covering methods available in the literature [4]: Sign-Sign Cover (SS Cover), Distance-Sign Cover (DS Cover), Sign-Value Cover (SV Cover), Distance-Value Cover (DV Cover). Each covering method is represented as a property (assertion) within our verification framework. In particular, each property specifies that an image set must cause that all the neurons present in the ANN are covered by the covering method. Our algorithm uses each covering method to evaluate whether the adversarial behavior of a set of pair of images reaches a certain percentage of all containing neurons on the ANN.

In covering methods, neurons are indexed as $n_{kl}$, where $k$ represents its sort on the layer $l$, inputs are defined as $x_{1}$ and $x_{2}$. A signal-change denoted as sc occurs when the activation potential of a certain neuron has its sign function changed by two different inputs. Sign function can be described by the equation below:

[TABLE]

Covering methods consist of some logical expressions: sc(nk,l, x1, x2) is denoted if the activation potential $u$ of neuron nk,l has its signals changed, this is, sign($u(x_{1}$)) $\neq$ sign($u(x_{2}$)). A value-change or vc occurs when the activation potential of a determined neuron represents a certain value change w.r.t. some metric $h$ and no signal change has occurred, i.e., $h(u(x1),u(x2))=true$ and $\neg$sc(nk,l, x1, x2), where $h$ can be a rate function, e.g., $\mathrm{h}(a,b)$= $\frac{a}{b}\geq d$, ($d$ represents a real number that limits the change value by $h$); a distance-change or dc occurs when all containing neurons in a certain layer have no signal-change and its values represent some value change. We denote dc(h,k,$x_{1}$,$x_{2}$) if $\neg$sc(nk,l, x1, x2) for all neurons in layer $k$ and h(k,$x_{1}$, $x_{2}$) $\geq$ d. As defined in value-change, function $h$ can be instantiated as any norm-based distance function and $d$ can be any real number that limits the distance function. A neuron pair is denoted as $\alpha$ =(nk,l, nk+1,j) and two inputs are denoted as x1 and x2. The covering methods are formally described as follows:

Sign Sign Cover (SS-Cover):

\neg\mathrm{sc(\textit{n{}{k,l}},\textit{x{}{1}},\textit{x{}_{2}}}) $\forall$ p${}_{k},l$ $\in$ Pk$\backslash$ {i};

\neg\mathrm{sc(\textit{n{}{k,l}},\textit{x{}{1}},\textit{x{}_{2}}}) $\forall$ p${}_{k},l$ $\in$ Pk$\backslash$ {i};

\mathrm{sc(\textit{n{}{k+1,l}},\textit{x{}{1}},\textit{x{}_{2}}});

Distance Sign Cover (DS-Cover):

\mathrm{dc(\textit{h},\textit{k},\textit{x{}{1}},\textit{x{}{2}}});

\mathrm{sc(\textit{n{}{k+1,l}},\textit{x{}{1}},\textit{x{}_{2}}});

Sign Value Cover (SV-Cover):

\mathrm{sc(\textit{n{}{k,i}},\textit{x{}{1}},\textit{x{}_{2}}});

\neg\mathrm{sc(\textit{n{}{k,l}},\textit{x{}{1}},\textit{x{}_{2}}}) $\forall$ p${}_{k},l$ $\in$ Pk$\backslash$ {i};

\mathrm{vc(\textit{g},\textit{n{}{k+1,l}},\textit{x{}{1}},\textit{x{}_{2}}});

Distance Value Cover (DV-Cover):

\mathrm{dc(\textit{h},\textit{k},\textit{x{}{1}},\textit{x{}{2}}});

\mathrm{vc(\textit{g},\textit{n{}{k+1,l}},\textit{x{}{1}},\textit{x{}_{2}}});

Some examples of covering methods can be seen in Table I w.r.t. the ANN illustrated in Fig. 1.

In Table I, Ex1 and Ex2 instances have the pair $\alpha=\{n_{13},n_{21}\}$ covered by SS-Cover. Here only neuron $n_{13}$ has its signal changed in layer 1. This means that sc(n1,3, x1, x2) and $\neg$sc(n1,k, x1, x2) $\forall$ p${}_{k},l$ $\in$ Pk$\backslash$ {1} are true. Since only one neuron has its signal changed in layer $1$, any neuron in layer $2$ with its signal changed will make a pair covered by SS-Cover. In this case, if the first neuron of layer 2 ($n_{1,2}$) has its value changed, then the pair $\alpha=\{n_{3,1},n_{1,2}\}$ is SS-Covered.

Ex2 and Ex3 are examples of DS-Cover. In Table I, there exist no change values in layer $1$; it means that for some metric h (euclidian distance, gaussian), the two instances of layer $1$ have a distance change and it makes dc(h,1, x1, x2) true. The distance change in layer $1$ implies a signal change of neuron $n_{2,2}$; it makes the neuron pair $\alpha=\{n_{i,1},n_{1,2}\}$ formed by any neuron in layer $1$ covered by DS-Cover.

Ex2 and Ex3 contain a pair covered by SV-Cover. Similar to SS-Cover, there exists only one neuron with signal change in layer $2$; it implies a value change on neuron $n_{1,3}$, which means that the neuron pair $\alpha=\{n_{2,2},n_{1,3}\}$ is SV-Covered. Finally, Ex1 and Ex 4 are examples of DV-Cover. In this case, there exists no signal change in any layer of the ANN instances. However, if there exists a metric that makes a distance change true in layer $1$ or $2$ and if there exists another metric, which makes a value change true in any neuron of layer $2$ or $3$, then we have a DV-Covered pair.

The ANN properties to be checked by ESBMC-GPU generate the same literal to all four covering methods. The neuron covered by one of all four covering methods must be equal or greater than a percentage $P$ of all containing neurons in the ANN. In particular, these properties generate literals $l_{covered\_neuron}$ with the goal of representing the validity of the covering method w.r.t. the ANN, according to four constraints:

For SS-Cover:

[TABLE]

For DS-Cover:

[TABLE]

For SV-Cover:

[TABLE]

For DV-Cover:

[TABLE]

III-C Verification of Adversarial Case

Our verification algorithm to check adversarial cases is called checkNN, which is implemented in CUDA; this verification algorithm does not check the ANN code but an instance of the ANN. This means that only weights and bias descriptions are needed for our verification process. Let us assume an image input is represented by $I$, and m and n represent its size. The dataset will be denoted as $D$; $M$ is the universe of all possible images with size m$\times$n. Let $\delta:\mathcal{M}^{\textit{m}\times\textit{n}}\times\mathcal{M}^{\textit{m}\times\textit{n}}\rightarrow\mathbb{R}$ be an euclidian distance operator defined as follows:

[TABLE]

Suppose that any image can be casted to a vector and its values are normalized. $P$ = ($p_{1},p_{2},p_{3},\ldots,p_{n}$) and $Q=(q_{1},q_{2},q_{3},\ldots,q_{n})\in\mathcal{R}^{N}$. Suppose that $P$ and $Q$ are 5$\times$5 images, i.e., both vectors length are 25 and they are represented by the images “A” and “O”, respectively, as illustrated below:

If we apply these two images in Fig. 2 to the euclidian distance equation described by Eq. (7), $\delta$ will return $2.449$. Denoting ${I}^{d}$ as an image that belongs to the dataset, all sets can be represented as follows:

[TABLE]

Our verification algorithm checkNN requires three inputs: the first input is an ANN with its weights and bias descriptions; the second one is the image to be checked; and the third one is a parameter that limits the proximity of the adversarial cases. Our safety property is specified using two intrinsic operators supported by ESBMC-GPU: assume and assert. ESBMC-GPU assumes that a function call assume(expression) has the following meaning: if “expression” is evaluated to “0”, then the function loops forever; otherwise the function returns (no side effects). In particular, the desired image to be checked can be represented by an assume, which is formally described as the restriction $R$:

[TABLE]

Eq. (9) denotes that $\mathcal{I}^{d}\in\mathcal{M}^{mn}$, which will be compared with a non-deterministic image $\mathcal{I}$ until the euclidian distance $\delta(\mathcal{I}^{d},\mathcal{I})$ described by Eq. (7) is less than or equal to the parameter $b$. After a non-deterministic image $\mathcal{I}$ is obtained, a safety property is checked by ESBMC-GPU, which is represented by an assert statement formally described as

[TABLE]

In Eq. (10), $\mathcal{Y}^{d}$ represents any ANN’s output mapped by the input $\mathcal{I}^{d}$ on the given dataset. The function $N$ represents the ANN function $\mathcal{R}^{m}\rightarrow\mathcal{R}^{n}$. The property is taken as the negative of Eq. (10). If the output obtained by function $N$ and the non-deterministic image is different from the mapped output, then the property is violated and a counterexample is produced. The property described by Eq. (10) generates the literal $l_{image\_misclassified}$. A classification is obtained from the output values represented by the neurons of the last layer. A reference value is denoted by the variable $V$, a desired classification is denoted by variable $D$, which represents the neuron position of the output layer and i represents any other neuron position different than $D$. The literal $l_{image\_misclassified}$ represents the validity of the original image classification, according to the constraint:

[TABLE]

IV Experimental Evaluation

IV-A Description of the Benchmarks

Our evaluation employs a new character pattern recognition benchmark, which was developed by our research group with the goal of performing conformance testing [22] over our cuBLAS and cuDNN operational models (cf. Section III-A)222Available at https://github.com/LuizHenriqueSena/ESBMC-GPU/tree/master/cpp/library In particular, each experiment uses an ANN that solves the problem of vocalic pattern recognition in $5x5$ images as input. The ANN was trained by the back-propagation algorithm [13]. Our dataset is composed by $100$ correct vocalics with noise images and $100$ non vocalic images. All vocalics are illustrated in Fig. 3.

We conducted the experimental evaluation on a 8-core 3.40 GHz Intel Core i7 with 24 GB of RAM and Linux OS. We use CUDA v9.0, cuDNN v5.0, cuBLAS v10.1, and ESBMC-GPU v2.0.333Available at http://gpu.esbmc.org/ All presented execution times are actually CPU times, i.e., only the elapsed time periods spent in the allocated CPUs, which was measured with the times system call (POSIX system). All adversarial cases were obtained by executing the following command, which is wrapped in a shell script to iteratively unwind the program: esbmc-gpu verifynn.c -I <path-to-OM> --force-malloc-success --no-div-by-zero-check --no-pointer-check --no-bounds-check --incremental-bmc.

IV-A1 Availability of Data and Tools

All benchmarks, tools, and results associated with the current evaluation, are available for downloading at https://github.com/ssvlab/ssvlab.github.io/tree/master/gpu/benchmarks.

IV-B Objectives

Using the benchmarks given in Section IV-A, our evaluation has the following two experimental goals:

1. EG1

(Covering Methods) Evaluate the performance and correctness of our symbolic verification algorithms to check all four covering methods (cf. Section III-B). 2. EG2

(Adversarial Cases) Evaluate the performance and correctness of our verification algorithm checkNN (cf. Section III-C) to verify adversarial cases obtained from changing input images and parameter proximity.

IV-C Results

IV-C1 Covering Methods

in covering methods experiments, ESBMC-GPU was able to correctly verify all four methods: SS-Cover, DS-Cover, SV-Cover, and DV-Cover. The verification time of all four covering methods did not take longer than a few seconds for checking how adversarial are two images w.r.t. the ANN neurons as described by Equations (3), (4), (5), and (6) in Section III-B. The fast verification was expected since all covering methods have only deterministic inputs. These results successfully answer EG1: ESBMC-GPU achieves reasonable performance to correctly verify all covering methods.

The verified properties imply that $80$% of all neurons on the ANN must be covered by the set of images. In particular, the set of images employed was the dataset used during the training phase; the tool output of all benchmarks correctly returned that covered neurons were not greater than $80$%. As a result, the dataset was unable to provide $80$% of neuron coverage by any covering method. With respect to this property, the average execution time of all four covering methods, when applied to a set of $200$ images, is around $20$ minutes; additionally, ESBMC-GPU does not generate test cases based on covering methods yet, which we leave for future work.

The two generated ANN instances of the two inputs “U” and noise “U” illustrated in Fig. 4 can be seen in Table II.

According to the SS-Cover equation described in Section III and the literal described by Eq. (3), we have two pairs of neuron: $\alpha 1=\{n_{1,1},n_{4,2}\}$ and $\alpha 2=\{n_{4,2},n_{5,3}\}$ SS-Covered by the two images. Only $3$ of $14$ neurons are SS-Covered, that is, only $21$% of the neurons are covered by the covering method. The literal described by Eq. (3) specifies that the neuron coverage must be greater than a percentage $P$. All benchmarks were run with the value of $P$ set to $80$%, which means that for these two inputs the property fails.

IV-C2 Adversarial Cases

in adversarial cases, we executed $14$ experiments, where the average verification time was approx. $19$ hours. Table III shows the verification time and parameter values of our experiments. Here, benchmark is the experiment identifier, image represents the desired image, where we intend to have the classification verified, $\gamma$ represents a limit of proximity for each benchmark, and verification time is the execution time taken by ESBMC-GPU measured in hours using times system call (POSIX system).

Incremental BMC approach has not been so efficient w.r.t. verification time since we verify the actual implementation of ANNs in CUDA using the logics QF_AUFBV from the SMT standard [24], The QF_AUFBV logic represents quantifier-free formulae that are built over bit-vectors and arrays with free sort and function symbols, but with the restriction that all array terms have the following structure (array (bit-vector $i$[$w_{1}$]) (bit-vector $v$[$w_{2}$])), where $i$ is the index with bit-width $w_{1}$ and $v$ is the value with bit-width $w_{2}$.

Although our ANN benchmarks contain $3$ layers, ESBMC-GPU took longer than other existing tools, which have previously reported experimental results with larger ANNs [7]. In particular, DLV (Deep Learning Verification) [7] has obtained adversarial cases of ANNs with $12$ layers, ranging from a few seconds to $20$ minutes. In order to check refinement by layer, DLV uses the theory of linear real arithmetic with existential and universal quantifiers, and for verification within a layer (0-variation), DLV uses the same theory but without universal quantification.

In prior work, Cordeiro et al. [25] reported that, although verification conditions are solved faster using the theory of linear real arithmetic (since the result of the analysis is independent from the actual binary representation), the theory of bit-vector allows the encoding of bit-level operators more accurately, which is inherently present in the implementation of ANNs. These results partially answer EG2: ESBMC-GPU is able to correctly produce adversarial cases, which are confirmed by graphical inspection in MATLAB, but our verification time is high due to the bit-accurate precision of our verification model. Some of the adversarial cases produced by ESBMC-GPU are shown in Fig. 6.

Unfortunately, a direct performance comparison using the same ANN with DLV was not possible due to some compatibility issues. Note that DeepConcolic [4] and DLV [7] perform verification and testing only on ANNs trained by classics dataset as MNIST; both tools do not support the verification and testing on general ANNs. For future work, we will adapt our tool to support the same models as the ones handled by DeepConcolic and DLV.

IV-D Threats to validity

Although all adversarial cases obtained from the benchmarks are real, which we confirmed by executing our validation scripts in MATLAB, our algorithm uses a lookup table to compute the sigmoid activation function; even with a good resolution, a lookup table will always contain more value errors than a computed function, which could potentially produce a false adversarial case. Additionally, our new character pattern recognition benchmark is probably an easy ANN to find adversarial cases, since the ANN training was performed by a small dataset, which contains only $200$ images. This kind of training probably generates ANN with a low-level of safety classification. Another identified threat is that our verification framework is not flexible enough; any change to ANN layer number might not be an easy task since our verification algorithms based on incremental BMC were developed using cuBLAS and cuDNN primitives; these primitives are not so flexible to perform such changes.

V Related work

Our ultimate goal is to formally ensure safety for applications that are based on Artificial Intelligence (AI), as described by Amodei et al. [26]. In particular, the potential impact of intelligent systems performing tasks in society and how safety guarantees are necessary to prevent damages are the main problem of safety in ANNs.

Sun et al. [4] and Huang et al. [7] have shown how weak ANNs can be if small noises are present in their inputs. They described and evaluated testing and verification approaches based on covering methods and images proximity [4] and how adversarial cases are obtained [7]. In particular, our study resembles that of Huang et al. and Su et al. [7, 4] to obtain adversarial cases. Here, if any property is violated, then a counterexample is provided; in cases of safety properties, adversarial examples will be generated via counterexample using ESBMC-GPU. In contrast to Huang et al. [7], we do not focus on generating noise in specific regions, but in every image pixel. Our approach in images proximity is influenced by Sun et al. [4] but we use incremental BMC instead of concolic testing as our verification engine. Our symbolic verification method checks safety properties on non-deterministic images with a certain distance of a given image; both image and distance are determined by the user. Gopinath et al. [3] also describe an approach to validate ANNs using symbolic execution by translating a NN into an imperative program. By contrast, we consider the actual implementation of ANN in CUDA and apply incremental BMC using off-the-shelf SMT solvers.

Gopinath et al. [27] presented formal techniques to extract invariants from the decision logic of ANNs. These invariants represent pre- and post-conditions, which hold when transformations of a certain type are applied to ANNs. The authors have proposed two techniques. The first one is called iterative relaxation of decision patterns, which uses Reluplex as the decision procedures [8]. The second one is called decision-tree based invariant generation, which resembles covering methods [4]. Robustness and explainability are the core properties of this study. Applying those properties to ANNs have shown impressive experimental results. Explainability showed an important property to evaluate safety in ANNs; the core idea is to obtain explanations of why the adversarial case happened by observing the pattern activation behavior of a subset of neurons described by the given invariant.

Gopinath et al. [28] also proposed a novel approach for automatically identifying safe regions of inputs w.r.t. some labels. The core idea is to identify safe regions w.r.t. labeled targets, i.e., providing a specific safety guarantee that a robust region is robust enough against adversarial perturbations w.r.t. to a target label. As the notion of safety robustness in ANNs is a strong term for many ANNs, the target robustness is the main property. The technique works with clustering and verification. Clustering technique is used to split the dataset into a subset of inputs with the same labels, then each cluster is verified by Reluplex [8] to provide the safety region w.r.t. the target label. The tool proposed is called DeepSafe, which is evaluated on trained ANNs by the dataset MNIST and ACAS XU.

In addition to ESBMC-GPU, there exist other tools able to verify CUDA programs and each one of them uses its approach and targets specific property violations. However, given the current knowledge in software verification, ESBMC-GPU is the first verifier to check for adversarial cases and coverage methods in ANNs implemented in CUDA. For instance, GPUVerify [21] is based on synchronous, delayed visibility semantics, which focuses on detecting data race and barrier divergence, while reducing kernel verification procedures for the analysis of sequential programs. GPU+KLEE (GKLEE) [29], in turn, is a concrete and symbolic execution tool, which considers both kernels and main functions, while checking deadlocks, memory coalescing, data race, warp divergence, and compilation level issues. Also, Concurrency Intermediate Verification Language (CIVL) [30], a framework for static analysis and concurrent program verification, uses abstract syntax tree and partial order reduction to detect user-specified assertions, deadlocks, memory leaks, invalid pointer dereference, array out-of-bounds, and division by zero.

Our approach implemented on top of ESBMC-GPU has some similarities with other techniques described here, e.g., covering methods proposed by Sun et al. [4], model checking to solve adversarial cases proposed by Huang et al.[7]. However, the main contribution is our requirements and how we handle the actual implementations of ANNs. To run our proposed safety verification, only the ANNs with weights and bias descriptors and the desired input of the dataset is required. For tools such as DeepConcolic [4] and DLV [7], obtaining adversarial cases or safety guarantees for different ANNs is not an easy task due to the focus given to the famous datasets as MNIST [31] or CIFAR-10 [32] during the tool development. In our proposed approach, there exists no need for providing specific datasets, but only the desired dataset sample to be verified. Besides these requirements, it is necessary for the user to know how cuDNN [11] deals with ANNs.

VI Conclusions

We have described and evaluated two approaches for verifying ANNs: one to check for adversarial cases and another one to check for coverage methods in MLP. In particular, our verification method was able to find adversarial cases for different input images and proximity parameter values. Despite a high verification time in some benchmarks due to bit-accurate verification, the average time is reasonable since our approach exhaustively verifies all possible adversarial cases. In other approaches, obtaining adversarial cases of even bigger ANNs tend to be faster, but noises are not fully explored.

Our verification of covering methods was able to correctly verify our dataset and has shown to be effective during our experiments. All OMs developed here are integrated into ESBMC-GPU and can be used to verify other programs that use the cuBLAS and cuDNN APIs, while other existing approaches (e.g., DeepConcolic and DLV) perform verification and testing only on ANNs trained by classics dataset as MNIST, i.e., they do not offer much flexibility to perform verification and testing on general ANNs.

Future work aims to implement further techniques (e.g., invariant inference [33]) to prune the state space exploration, by taking into account design aspects of ANNs. We will also improve our training dataset by considering the counterexample produced by our verification framework. Lastly, we will investigate fault localization and repair techniques [34] to make the ANN implementation robust against small noises that are present in the ANN inputs.