Testing DNN Image Classifiers for Confusion & Bias Errors

TL;DR

This paper introduces DeepInspect, a testing approach for DNN image classifiers that detects class confusion and bias errors, revealing numerous issues in popular models and emphasizing the need for rigorous testing before deployment.

Contribution

The paper presents a novel technique for automatically detecting class-level confusion and bias errors in DNN image classifiers, addressing limitations of existing per-image testing methods.

Findings

DeepInspect achieved up to 100% precision in detecting confusion errors.

It found hundreds of classification mistakes in popular models.

Many errors indicated significant confusion or bias issues.

Abstract

Image classifiers are an important component of today's software, from consumer and business applications to safety-critical domains. The advent of Deep Neural Networks (DNNs) is the key catalyst behind such wide-spread success. However, wide adoption comes with serious concerns about the robustness of software systems dependent on DNNs for image classification, as several severe erroneous behaviors have been reported under sensitive and critical circumstances. We argue that developers need to rigorously test their software's image classifiers and delay deployment until acceptable. We present an approach to testing image classifier robustness based on class property violations. We found that many of the reported erroneous cases in popular DNN image classifiers occur because the trained models confuse one class with another or show biases towards some classes over others. These bugs usually violate some class properties of one or more of those classes. Most DNN testing techniques focus on per-image violations, so fail to detect class-level confusions or biases. We developed a testing technique to automatically detect class-based confusion and bias errors in DNN-driven image classification software. We evaluated our implementation, DeepInspect, on several popular image classifiers with precision up to 100% (avg.~72.6%) for confusion errors, and up to 84.3% (avg.~66.8%) for bias errors. DeepInspect found hundreds of classification mistakes in widely-used models, many exposing errors indicating confusion or bias.

Tables

Table 1. Table 1 . Examples of real-world bugs reported in neural image classifiers

Bug Type	Name	Report Date	Outcome
	Gorilla Tag (Grush, 2015)	Jul 1, 2015	Black people were tagged as gorillas by Google photo app.
Confusion	Elephant is detected	Aug 9, 2018	Image Transplantation (replacing a sub-region of an image by
	in a room (Rosenfeld et al., 2018)		another image containing a trained object) leads to mis-classification.
	Google Photo (MalletsDarker, 2018)	Dec 10, 2018	Google Photo confuses skier and mountain.
	Nikon Camera (Rose, 2010)	Jan 22, 2010	Camera shows bias toward Caucasian faces when detecting people’s blinks.
	Men Like Shopping (Zhao et al., 2017)	July 29, 2017	Multi-label object classification models show bias towards women on
Bias			activities like shopping, cooking, washing, etc.
	Gender Shades(Buolamwini and Gebru, 2018)	2018	Open-source face recognition services provided by IBM, Microsoft, and Face++
			have higher error rates on darker-skin females for gender classification.

Table 2. Table 2 . Study Subjects

Dataset			Model
Classification			CNN			Reported
Task	Name	#classes	Models	#Neurons	#Layers	Accuracy
	COCO (Lin et al., 2014)	80	ResNet-50(Zhao et al., 2017)	26,560	53 Conv	0.73*
Multi-label	COCO gender(Zhao et al., 2017)	81	ResNet-50(He et al., 2016)	26,560	53 Conv	0.71*
classification	imSitu(Yatskar et al., 2016)	205,095	ResNet-34(Yatskar et al., 2016)	8,448	36 Conv	0.37†
	CIFAR-100(Krizhevsky, 2012)	100	CNN(cif, 2017)	2,916	26	0.74
	Robust	10	Small CNN(Wong et al., 2018)	158	8	0.69
Single-label	CIFAR-10(Krizhevsky, 2012)		Large CNN(Wong et al., 2018)	1,226	14	0.73
classification			ResNet(Wong et al., 2018)	1,410	34	0.70
	ImageNet(Russakovsky et al., 2015)	1000	ResNet-50(Simonyan and Zisserman, 2015)	26,560	53 Conv	0.75

Table 3. Table 3 . DeepInspect performance on detecting confusion errors

		napvd < mean-1std				Top 1%
		TP	FP	Precision	Recall	TP	FP	Precision	Recall
COCO	DeepInspect	138	256	0.350	0.775	31	0	1	0.174
	MODE	126	382	0.248	0.708	26	5	0.839	0.146
	random	22	372	0.056	0.124	1	30	0.032	0.006
COCO gender	DeepInspect	139	286	0.327	0.827	32	0	1	0.190
	MODE	125	379	0.248	0.744	30	2	0.938	0.179
	random	22	403	0.052	0.131	1	31	0.031	0.006
CIFAR-100	DeepInspect	206	584	0.261	0.718	39	10	0.796	0.136
	MODE	111	605	0.155	0.387	22	27	0.449	0.077
	random	45	745	0.057	0.157	2	47	0.041	0.007
R CIFAR-10 S	DeepInspect	4	6	0.400	0.800	-	-	-	-
	MODE	3	4	0.429	0.600	-	-	-	-
	random	1	9	0.100	0.200	-	-	-	-
R CIFAR-10 L	DeepInspect	3	4	0.430	0.600	-	-	-	-
	MODE	3	5	0.375	0.600	-	-	-	-
	random	0	7	0	0	-	-	-	-
R CIFAR-10 R	DeepInspect	5	3	0.625	1	-	-	-	-
	MODE	1	3	0.250	0.200	-	-	-	-
	random	0	8	0	0	-	-	-	-
ImageNet	DeepInspect	4014	69957	0.054	0.617	1073	3922	0.215	0.165
	MODE	3428	66987	0.049	0.527	1591	3404	0.319	0.245
	random	962	73009	0.013	0.148	65	4930	0.013	0.010
imSitu	DeepInspect	48	58	0.453	0.165	31	19	0.620	0.107
	random	6	100	0.057	0.020	2	48	0.040	0.007

Table 4. Table 4 . DeepInspect performance on detecting bias errors

		avg_bias > mean+1std				Top 1%
		TP	FP	Precision	Recall	TP	FP	Precision	Recall
COCO	DeepInspect	249	278	0.472	0.759	24	8	0.75	0.073
	MODE	145	324	0.309	0.442	12	20	0.375	0.037
	random	54	472	0.103	0.167	3	28	0.103	0.010
COCO gender	DeepInspect	218	325	0.401	0.568	17	16	0.515	0.044
	MODE	151	328	0.315	0.393	13	20	0.394	0.034
	random	64	478	0.118	0.168	3	28	0.118	0.010
CIFAR-100	DeepInspect	310	543	0.363	0.380	29	21	0.580	0.036
	MODE	69	315	0.180	0.085	5	45	0.100	0.001
	random	140	711	0.165	0.172	8	41	0.165	0.010
R CIFAR-10 S	DeepInspect	7	4	0.636	0.778	-	-	-	-
	MODE	3	10	0.231	0.333	-	-	-	-
	random	2	8	0.200	0.222	-	-	-	-
R CIFAR-10 L	DeepInspect	6	7	0.462	0.667	-	-	-	-
	MODE	8	14	0.364	0.889	-	-	-	-
	random	2	9	0.200	0.267	-	-	-	-
R CIFAR-10 R	DeepInspect	6	3	0.667	0.667	-	-	-	-
	MODE	8	14	0.364	0.889	-	-	-	-
	random	1	7	0.200	0.200	-	-	-	-
ImageNet	DeepInspect	26704	48913	0.353	0.330	3253	1742	0.651	0.040
	MODE	23881	47503	0.335	0.295	2355	2640	0.471	0.029
	random	12234	63381	0.162	0.151	808	4186	0.162	0.010
imSitu	DeepInspect	408	311	0.567	0.718	43	8	0.843	0.076
	random	80	638	0.112	0.142	5	44	0.112	0.010

Table 5. Table 5 . DeepInspect impact of neuron coverage threshold on detecting confusion errors for COCO

NC threshold	napvd < mean-1std				Top 1%
	TP	FP	Precision	Recall	TP	FP	Precision	Recall
0.25	36	18	0.67	0.20	23	8	0.74	0.13
0.40	150	215	0.41	0.84	31	0	1	0.17
0.50	138	256	0.35	0.78	31	0	1	0.17
0.60	137	264	0.34	0.77	30	1	0.97	0.17
0.75	135	271	0.33	0.76	29	2	0.94	0.16

Table 6. Table 6 . DeepInspect impact of neuron coverage threshold on detecting confusion errors for CIFAR-100

NC threshold	napvd < mean-1std				Top 1%
	TP	FP	Precision	Recall	TP	FP	Precision	Recall
0.25	188	629	0.23	0.66	34	15	0.69	0.12
0.40	197	550	0.26	0.69	39	10	0.80	0.14
0.50	206	584	0.26	0.72	39	10	0.80	0.14
0.60	211	596	0.26	0.74	37	12	0.76	0.13
0.75	195	604	0.24	0.68	37	12	0.76	0.13

Table 7. Table 7 . DeepInspect impact of neuron coverage threshold on detecting bias errors for COCO

NC threshold	avg_bias > mean+1std				Top 1%
	TP	FP	Precision	Recall	TP	FP	Precision	Recall
0.25	218	280	0.438	0.665	26	6	0.812	0.079
0.40	260	275	0.486	0.793	20	12	0.625	0.061
0.50	249	278	0.472	0.759	24	8	0.75	0.073
0.60	190	273	0.410	0.579	24	8	0.75	0.073
0.75	197	54	0.785	0.601	32	0	1	0.098
0.90	201	102	0.663	0.592	32	0	1	0.094

Table 8. Table 8 . DeepInspect impact of neuron coverage threshold on detecting bias errors for CIFAR-100

NC threshold	avg_bias > mean+1std				Top 1%
	TP	FP	Precision	Recall	TP	FP	Precision	Recall
0.25	289	569	0.337	0.355	18	32	0.36	0.022
0.40	272	545	0.333	0.334	27	23	0.54	0.033
0.50	310	543	0.363	0.380	29	21	0.58	0.036
0.60	279	473	0.371	0.342	26	24	0.54	0.032
0.75	276	455	0.378	0.339	29	21	0.58	0.036
0.90	179	587	0.234	0.220	12	38	0.24	0.015

Equations

$$\scriptstyle\rho=\blockarray{cccccc}&C_{1}...C_{i}...C_{m}\\ \block{c(ccccc)}N_{1}p_{11}p_{1m}\\ ......\\ N_{j}p_{j1}...p_{jm}\\ ......\\ N_{n}p_{n1}p_{nm}\\$$

$$\begin{array}{r}\text{textsc}napvd(a,b)=\Delta (a,b)=||{\rho }_{\alpha a}-{\rho }_{\alpha b}|{|}_2=\sqrt{\sum _{i=1}^n{\left(P(N_i|a)-P(N_i|b)\right)}^2}\end{array}$$

$$bias(a,b,c):=\frac{|\Delta (c,a)-\Delta (c,b)|}{\Delta (c,a)+\Delta (c,b)}$$

$$avg\_bias(a,b):=\frac{1}{|O|-2}\sum _{c\in O,c\ne a,b}bias(a,b,c)$$

$$\text{avg\_cd}(x,y):=\frac{1}{|O|-2}\sum _{z\in O,z\ne x,y}\text{cd}(x,y,z).$$

Full text

We found that many of the reported erroneous cases in popular DNN image classifiers occur because the trained models confuse one class with another or show biases towards some classes over others. These bugs usually violate some class properties of one or more of those classes. Most DNN testing techniques focus on per-image violations, so fail to detect class-level confusions or biases.

We developed a testing technique to automatically detect class-based confusion and bias errors in DNN-driven image classification software. We evaluated our implementation, DeepInspect, on several popular image classifiers with precision up to 100% (avg. 72.6%) for confusion errors, and up to 84.3% (avg. 66.8%) for bias errors. DeepInspect found hundreds of classification mistakes in widely-used models, many exposing errors indicating confusion or bias.

whitebox testing, deep learning, DNNs, image classifiers, bias

††journalyear: 2020††copyright: acmcopyright††conference: 42nd International Conference on Software Engineering; May 23–29, 2020; Seoul, Republic of Korea††booktitle: 42nd International Conference on Software Engineering (ICSE ’20), May 23–29, 2020, Seoul, Republic of Korea††price: 15.00††doi: 10.1145/3377811.3380400††isbn: 978-1-4503-7121-6/20/05††ccs: Software and its engineering Software testing and debugging††ccs: Computing methodologies Neural networks

1. Introduction

Image classification has a plethora of applications in software for safety-critical domains such as self-driving cars, medical diagnosis, etc. Even day-to-day consumer software includes image classifiers, such as Google Photo search and Facebook image tagging. Image classification is a well-studied problem in computer vision, where a model is trained to classify an image into single or multiple predefined categories (Kamavisdar et al., 2013). Deep Neural Networks (DNNs) have enabled major breakthroughs in image classification tasks over the past few years, sometimes even matching human-level accuracy under some conditions (He et al., 2016), which has led to their ubiquity in modern software.

However, in spite of such spectacular success, DNN-based image classification models, like traditional software, are known to have serious bugs. For example, Google faced backlash in 2015 due to a notorious error in its photo-tagging app, which tagged pictures of dark-skinned people as “gorillas” (Grush, 2015). Analogous to traditional software bugs, the Software Engineering (SE) literature denotes these classification errors as model bugs (Ma et al., 2018b), which can arise due to either imperfect model structure or inadequate training data.

At a high-level, these bugs can affect either an individual image, where a particular image is mis-classified (e.g., a particular skier is mistaken as a part of a mountain), or an image class, where a class of images is more likely to be mis-classified (e.g., dark-skinned people are more likely to be misclassified), as shown in Table 1. The latter bugs are specific to a whole class of images rather than individual images, implying systematic bugs rather than the DNN equivalent of off-by-one errors. While much effort from the SE literature on Neural Network testing has focused on identifying individual-level violations—using white-box (Pei et al., 2017a; Ma et al., 2018a; Kim et al., 2019; Wang et al., 2019), grey-box (Tian et al., 2018; Ma et al., 2018b), or concolic testing (Sun et al., 2018b), detection of class-level violations remains relatively less explored. This paper focuses on automatically detecting such class-level bugs, so they can be fixed.

After manual investigation of some public reports describing the class-level violations listed in Table 1, we determined two root causes: (i) Confusion: The model cannot differentiate one class from another. For example, Google Photos confuses skier and mountain (MalletsDarker, 2018). (ii) Bias: The model shows disparate outcomes between two related groups. For example, Zhao et al. in their paper “Men also like shopping” (Zhao et al., 2017), find classification bias in favor of women on activities like shopping, cooking, washing, etc. We further notice that some class-level properties are violated in both kinds of cases. For example, in the case of confusion errors, the classification error-rate between the objects of two classes, say, skier and mountain, is significantly higher than the overall classification error rate of the model. Similarly, in the bias scenario reported by Zhao et al., a DNN model should not have different error rates while classifying the gender of a person in the shopping category. Unlike individual image properties, this is a class property affecting all the shopping images with men or women. Any violation of such a property by definition affects the whole class although not necessarily every image in that class, e.g., a man is more prone to be predicted as a woman when he is shopping, even though some individual images of a man shopping may still be predicted correctly. Thus, we need a class-level approach to testing image classifier software for confusion and bias errors.

The bugs in a DNN model occur due to sub-optimal interactions between the model structure and the training data (Ma et al., 2018b). To capture such interactions, the literature has proposed various metrics primarily based on either neuron activations (Pei et al., 2017a; Ma et al., 2018a; Kim et al., 2019) or feature vectors (Ma et al., 2018b; Odena et al., 2019). However, these techniques are primarily targeted at the individual image level. To detect class-level violations, we abstract away such model-data interactions at the class level and analyze the inter-class interactions using that new abstraction. To this end, we propose a metric using neuron activations and a baseline metric using weight vectors of the feature embedding to capture the class abstraction.

For a set of test input images, we compute the probability of activation of a neuron per predicted class. Thus, for each class, we create a vector of neuron activations where each vector element corresponds to a neuron activation probability. If the distance between the two vectors for two different classes is too close, compared to other class-vector pairs, that means the DNN under test may not effectively distinguish between those two classes. Motivated by MODE’s technique (Ma et al., 2018b), we further create a baseline where each class is represented by the corresponding weight vector of the last linear layer of the model under test.

We evaluate our methodology for both single- and multi-label classification models in eight different settings. Our experiments demonstrate that DeepInspect can efficiently detect both Bias and Confusion errors in popular neural image classifiers. We further check whether DeepInspect can detect such classification errors in state-of-the-art models designed to be robust against norm-bounded adversarial attacks (Wong et al., 2018); DeepInspect finds hundreds of errors proving the need for orthogonal testing strategies to detect such class-level mispredictions. Unlike some other DNN testing techniques (Tian et al., 2018; Pei et al., 2017a; Odena et al., 2019; Sun et al., 2018b), DeepInspect does not need to generate additional transformed (synthetic) images to find these errors. The primary contributions of this paper are:

• •

We propose a novel neuron-coverage metric to automatically detect class-level violations (confusion and bias errors) in DNN-based visual recognition models for image classification.

• •

We implemented our metric and underlying techniques in DeepInspect.

• •

We evaluated DeepInspect and found many errors in widely-used DNN models with precision up to 100% (avg. 72.6%) for confusion errors and up to 84.3% (avg. 66.8%) for bias errors.

Our code is available at https://github.com/ARiSE-Lab/DeepInspect. The errors reported by DeepInspect are available at: https://www.ariselab.info/deepinspect.

2. DNN Background

Deep Neural Networks (DNNs) are a popular type of machine learning model loosely inspired by the neural networks of human brains. A DNN model learns the logic to perform a software task from a large set of training examples. For example, an image recognition model learns to recognize cows through being shown (trained with) many sample images of cows.

A typical "feed-forward" DNN consists of a set of connected computational units, referred as neurons, that are arranged sequentially in a series of layers. The neurons in sequential layers are connected to each other through edges. Each edge has a corresponding weight. Each neuron applies $\displaystyle\sigma$, a nonlinear activation function (e.g., ReLU (Nair and Hinton, 2010), Sigmoid (Mitchell, 1997)), to the incoming values on its input edges and sends the results on its output edges to the next layer of connected neurons. For image classification, convolutional neural networks (CNNs) (LeCun et al., 1998), a specific type of DNN, are typically used. CNNs consist of layers with local spatial connectivity and sets of neurons with shared parameters.

When implementing a DNN application, developers typically start with a set of annotated experimental data and divide it into three sets: (i) training: to construct the DNN model in a supervised setting, meaning the training data is labeled (e.g., using stochastic gradient descent with gradients computed using back-propagation (Rumelhart et al., 1988)); (ii) validation: to tune the model’s hyper-parameters, basically configuration parameters that can be modified to better fit the expected application workload; and (iii) evaluation: to evaluate the accuracy of the trained model w.r.t. to its predictions on other annotated data, to determine whether or not it predicts correctly. Typically, training, validation, and testing data are drawn from the same initial dataset.

For image classification, a DNN can be trained in either of the following two settings:

(i) Single-label Classification. In a traditional single-label classification problem, each datum is associated with a single label l from a set of disjoint labels $\displaystyle L$ where $\displaystyle|L|>1$. If $\displaystyle|L|=2$, the classification problem is called a binary classification problem; if $\displaystyle|L|>2$, it is a multi-class classification problem (Tsoumakas and Katakis, 2007). Among some popular image classification datasets, MNIST, CIFAR-10/CIFAR-100 (Krizhevsky, 2012) and ImageNet (Russakovsky et al., 2015) are all single-label, where each image can be categorized into only one class or outside that class.

(ii) Multi-label Classification. In a multi-label classification problem, each datum is associated with a set of labels Y where $\displaystyle Y\subseteq L$. COCO(Lin et al., 2014) and imSitu(Yatskar et al., 2016) are popular datasets for multi-label classification. For example, an image from the COCO dataset can be labeled as car, person, traffic light and bicycle. A multi-label classification model is supposed to predict all of car, person, traffic light and bicycle from a single image that shows all of these kinds of objects.

Given any single- or multi-label classification task, DNN classifier software tries to learn the decision boundary between the classes—all members of a class, say $\displaystyle C_{i}$, should be categorized identically irrespective of their individual features, and members of another class, say $\displaystyle C_{j}$, should not be categorized to $\displaystyle C_{i}$ (Bengio et al., 2013). The DNN represents the input image in an embedded space with the feature vector at a certain intermediate layer and uses the layers after as a classifier to classify these representations. The class separation between two classes estimates how well the DNN has learned to separate each class from the other. If the embedded distance between two classes is too small compared to other classes, or lower than some pre-defined threshold, we assume that the DNN could not separate them from each other.

3. Methodology

We give a detailed technical description of DeepInspect. We describe a typical scenario where we envision our tool might be used in the following and design the methodology accordingly.

Usage Scenario. Similar to customer testing of post-release software, DeepInspect works in a real-world setting where a customer gets a pre-trained model and tests its performance in a sample production scenario before deployment. The customer has white-box access to the model to profile, although all the data in the production system can be unlabeled. In the absence of ground truth labels, the classes are defined by the predicted labels. These predicted labels are used as class references as DeepInspect tries to detect confusion and bias errors among the classes. DeepInspect tracks the activated neurons per class and reports a potential class-level violation if the class-level activation-patterns are too similar between two classes. Such reported errors will help customers evaluate how much they can trust the model’s results related to the affected classes. As elaborated in Section 7, once these errors are reported back to the developers, they can focus their debugging and fixing effort on these classes. Figure 1 shows the DeepInspect workflow.

3.1. Definitions

Before we describe DeepInspect’s methodology in detail, we introduce definitions that we use in the rest of the paper. The following table shows our notation.

[TABLE]

Neural-Path ($\displaystyle NP$). For an input image $\displaystyle c$, we define neural-path as a sequence of neurons that are activated by $\displaystyle c$.

Neural-Path per Class ($\displaystyle NP_{C}$). For a class $\displaystyle C_{i}$, this metric represents a set consisting of the union of neural-paths activated by all the inputs in $\displaystyle C_{i}$.

For example, consider a class cow containing two images: a brown cow and a black cow. Let’s assume they activate two neural-paths: $\displaystyle[N_{1},N_{2},N_{3}]$ and $\displaystyle[N_{4},N_{5},N_{3}]$. Thus, the neural-paths for class cow would be $\displaystyle NP_{cow}=\{[N_{1},N_{2},N_{3}],[N_{4},N_{5},N_{3}]\}$. $\displaystyle NP_{cow}$ is further represented by a vector $\displaystyle(N_{1}^{1},N_{2}^{1},N_{3}^{2},N_{4}^{1},N_{5}^{1})$, where the superscripts represent the number of times each neuron is activated by $\displaystyle C_{cow}$. Thus, each class $\displaystyle C_{i}$ in a dataset can be expressed with a neuron activation frequency vector, which captures how the model interacts with $\displaystyle C_{i}$.

Neuron Activation Probability: Leveraging how frequently a neuron $\displaystyle N_{j}$ is activated by all the members from a class $\displaystyle C_{i}$, this metric estimates the probability of a neuron $\displaystyle N_{j}$ to be activated by $\displaystyle C_{i}$. Thus, we define: $\displaystyle\displaystyle P(N_{j}~{}|~{}C_{i})=\frac{|\{c_{ik}~{}|~{}\forall{c_{ik}}\in C_{i},out(N_{j},c_{ik})>Th\}|}{|C_{i}|}$

We then construct a $\displaystyle n\times m$ dimensional neuron activation probability matrix, $\displaystyle\rho$, ($\displaystyle n$ is the number of neurons and $\displaystyle m$ is the number of classes) with its ij-th entry being $\displaystyle P(N_{j}~{}|~{}C_{i})$.

[TABLE]

This matrix captures how a model interacts with a set of input data. The column vectors ($\displaystyle\rho_{\alpha m}$) represent the interaction of a class $\displaystyle C_{m}$ with the model. Note that, in our setting, $\displaystyle C$s are predicted labels.

Since Neuron Activation Probability Matrix ($\displaystyle\rho$) is designed to represent each class, it should be able to distinguish between different $\displaystyle C$s. Next, we use this metric to find two different classes of errors often found in DNN systems: confusion and bias (see Table 1).

3.2. Finding Confusion Errors

In an object classification task, when the model cannot distinguish one object class from another, confusion occurs. For example, as shown in Table 1, a Google photo app model confuses a skier with the mountain. Thus, finding confusion errors means checking how well the model can distinguish between objects of different classes. An error happens when the model under test classifies an object with a wrong class, or for multi-label classification task, predicts two classes but only one of them is present in the test image.

We argue that the model makes these errors because during the training process the model has not learned to distinguish well between the two classes, say $\displaystyle a$ and $\displaystyle b$. Therefore, the neurons activated by these objects are similar and the column vectors corresponding to these classes: $\displaystyle\rho_{\alpha a}$ and $\displaystyle\rho_{\alpha b}$ will be very close to each other. Thus, we compute the confusion score between two classes as the euclidean distance between their two probability vectors:

[TABLE]

If the $\displaystyle\Delta$ value is less than some pre-defined threshold (conf_th) for two pairs of classes, the model will potentially make mistakes in distinguishing one from another, which results in confusion errors. This $\displaystyle\Delta$ is called napvd (Neuron Activation Probabiliy Vector Distance).

3.3. Finding Bias Errors

In an object classification task, bias occurs if the model under test shows disparate outcomes between two related classes. For example, we find that ResNet-34 pretrained by imSitu dataset, often mis-classifies a man with a baby as woman. We observe that in the embedded matrix $\displaystyle\rho$, $\displaystyle\Delta(baby,woman)$ is much smaller than $\displaystyle\Delta(baby,man)$. Therefore, during testing, whenever the model finds an image with a baby, it is biased towards associating the baby image with a woman. Based on this observation, we propose an inter-class distance based metric to calculate the bias learned by the model. We define the bias between two classes $\displaystyle a$ and $\displaystyle b$ over a third class $\displaystyle c$ as follows:

[TABLE]

If a model treats objects of classes $\displaystyle a$ and $\displaystyle b$ similarly under the presence of a third object class $\displaystyle c$, $\displaystyle a$ and $\displaystyle b$ should have similar distance w.r.t. $\displaystyle c$ in the embedded space $\displaystyle\rho$; thus, the numerator of the above equation will be small. Intuitively, the model’s output can be more influenced by the nearer object classes, i.e. if $\displaystyle a$ and $\displaystyle b$ are closer to $\displaystyle c$. Thus, we normalize the disparity between the two distances to increase the influence of closer classes.

This bias score is used to measure how differently the given model treats two classes in the presence of a third object class. An average bias (abbreviated as avg_bias) between two objects $\displaystyle a$ and $\displaystyle b$ for all class objects $\displaystyle O$ is defined as:

[TABLE]

The above score captures the overall bias of the model between two classes. If the bias score is larger than some pre-defined threshold, we report potential bias errors.

Note that, even when the two classes $\displaystyle a$ and $\displaystyle b$ are not confused by the model, i.e. $\displaystyle\Delta(a,b)>conf\_th$, they can still show bias w.r.t. another class, say $\displaystyle c$, if $\displaystyle\Delta(a,c)$ is very different from $\displaystyle\Delta(b,c)$. Thus, bias and confusion are two separate types of class-level errors that we intend to study in this work.

Using these above equations we develop a novel testing tool, DeepInspect, to inspect a DNN implementing image classification tasks and look for potential confusion and bias errors. We implemented DeepInspect in the Pytorch deep learning framework and Python 2.7. All our experiments were run on Ubuntu 18.04.2 with two TITAN Xp GPUs. For all of our experiments, we set the activation threshold $\displaystyle Th$ to be 0.5 for all datasets and models. We discuss why we choose 0.5 as neuron activation threshold and how different thresholds affect our performance in the section 7.

4. Experimental Design

4.1. Study Subjects

We apply DeepInspect for both multi-label and single-label DNN-based classifications. Under different settings, DeepInspect automatically inspects 8 DNN models for 6 datasets. Table 2 summarizes our study subjects. All the models we used are standard, widely-used models for each dataset. We used pre-trained models as shown in the Table for all settings except for COCO with gender. For COCO with gender model, we used the gender labels from (Zhao et al., 2017) and trained the model in the same way as (Zhao et al., 2017). imSitu model is a pre-trained ResNet-34 model (Yatskar et al., 2016). There are in total 11,538 entities and 1,788 roles in the imSitu dataset. When inspecting a model trained using imSitu, we only considered the top 100 frequent entities or roles in the test dataset.

Among the 8 DNN models, three are pre-trained relatively more robust models that are trained using adversarial images along with regular images. These models are pre-trained by provably robust training approach proposed by (Wong et al., 2018). Three models with different network structures are trained using the CIFAR10 dataset (Wong et al., 2018).

4.2. Constructing Ground Truth (GT) Errors

To collect the ground truth for evaluating DeepInspect, we refer to the test images misclassified by a given model. We then aggregate these misclassified image instances by their real and predicted class-labels and estimate pair-wise confusion/bias.

4.2.1. GT of Confusion Errors

Confusion occurs when a DNN often makes mistakes in disambiguating members of two different classes. In particular, if a DNN is confused between two classes, the classification error rate is higher between those two classes than between the rest of the class-pairs. Based on this, we define two types of confusion errors for single-label classification and multi-label classification separately:

Type1 confusions: In single-label classification, Type1 confusion occurs when an object of class $\displaystyle x$ (*e.g.,*violin) is misclassified to another class $\displaystyle y$ (*e.g.,*cello). For all the objects of class $\displaystyle x$ and $\displaystyle y$, it can be quantified as: $\displaystyle\operatorname{type1conf}(x,y)=\operatorname{mean}(\operatorname{P}(x|y),\operatorname{P}(y|x))$ —DNN’s probability to misclassify class $\displaystyle y$ as $\displaystyle x$ and vice-versa, and takes the average value between the two. For example, given two classes cello and violin, $\displaystyle\operatorname{type1conf}$ estimates the mean probability of violin misclassified to cello and vice versa. Note that, this is a bi-directional score, i.e. misclassification of $\displaystyle y$ as $\displaystyle x$ is the same as misclassification of $\displaystyle x$ as $\displaystyle y$.

Type2 confusions: In multi-label classification, Type2 confusion occurs when an input image contains an object of class $\displaystyle x$ (*e.g.,*mouse) and no object of class $\displaystyle y$ (*e.g.,*keyboard), but the model predicts both classes (see Figure 7. For a pair of classes, this can be quantified as: $\displaystyle\operatorname{type2conf}(x,y)=\operatorname{mean}(\operatorname{P}((x,y)|x),\operatorname{P}((x,y)|y))$ to compute the probability to detect two objects in the presence of only one. For example, given two classes keyboard and mouse, $\displaystyle\operatorname{type2conf}$ estimates the mean probability of mouse being predicted while predicting keyboard and vice versa. This is also a bi-directional score.

We measure $\displaystyle\operatorname{type1conf}$ and $\displaystyle\operatorname{type2conf}$ by using a DNN’s true classification error measured on a set of test images. They create the DNN’s true confusion characteristics between all possible class-pairs. We then draw the distributions of $\displaystyle\operatorname{type1conf}$ and $\displaystyle\operatorname{type2conf}$. For example,  Figure 2(a) shows $\displaystyle\operatorname{type2conf}$ distribution for COCO . The class-pairs with confusion scores greater than $\displaystyle 1$ standard deviation from the mean-value are marked as pairs truly confused by the model and form our ground truth for confusion errors. For example, in the COCO dataset, there are 80 classes and thus 3160 class pairs (80*79/2); 178 class-pairs are ground-truth confusion errors.

Note that, unlike how a bug/error is defined in traditional software engineering, our suspicious confusion pairs have an inherent probabilistic nature. For example, even if $\displaystyle a$ and $\displaystyle b$ represent a confusion pair, it does not mean that all the images containing $\displaystyle a$ or $\displaystyle b$ will be misclassified by the model. Rather, it means that compared with other pairs, images containing $\displaystyle a$ or $\displaystyle b$ tend to have a higher chance to be misclassified by the model.

4.2.2. GT of Bias Errors

A DNN model is biased if it treats two classes differently. For example, consider three classes: man, woman, and surfboard. An unbiased model should not have different error rates while classifying man or woman in the presence of surfboard. To measure such bias formally, we define confusion disparity (cd) to measure differences in error rate between classes $\displaystyle x$ and $\displaystyle z$ and between $\displaystyle y$ and $\displaystyle z$: $\displaystyle\textrm{cd}(x,y,z)=|error(x,z)-error(y,z)|$, where the error measure can be either $\displaystyle\operatorname{type1conf}$ or $\displaystyle\operatorname{type2conf}$ as defined earlier. cd essentially estimates the disparity of the model’s error between classes $\displaystyle x$, $\displaystyle y$ (e.g., man, woman) w.r.t. a third class $\displaystyle z$ (e.g., surfboard).

We also define an aggregated measure average confusion disparity (avg_cd) between two classes $\displaystyle x$ and $\displaystyle y$ by summing up the bias between them over all third classes and taking the average:

[TABLE]

Depending on the error types we used to estimate avg_cd, we refer to $\displaystyle Type1$_avg_cd and $\displaystyle Type2$_avg_cd. We measure avg_cd using the true classification error rate reported for the test images. Similar to confusion errors, we draw the distribution of avg_cd for all possible class pairs and then consider the pairs as truly biased if their avg_cd score is higher than one standard deviation from the mean value. Such truly biased pairs form our ground truth for bias errors.

4.3. Evaluating DeepInspect

We evaluate DeepInspect using a set of test images.

Error Reporting. DeepInspect reports confusion errors based on NAPVD (see Equation 2) scores—lower NAPVD indicates errors. We draw the distributions of NAPVDs for all possible class pairs, as shown in Figure 2(b). Class pairs having NAPVD scores lower than $\displaystyle 1$ standard deviation from the mean score are marked as potential confusion errors.

As discussed in Section 3.3, DeepInspect reports bias errors based on avg_bias score (see Equation 4), where higher avg_bias means class pairs are more prone to bias errors. Similar to above, from the distribution of avg_bias scores, DeepInspect predicts pairs with avg_bias greater than $\displaystyle 1$ standard deviation from the mean score to be erroneous. Note that, while calculating error disparity between classes $\displaystyle a$, $\displaystyle b$ w.r.t. $\displaystyle c$ (see Equation 3), if both $\displaystyle a$ and $\displaystyle b$ are far from $\displaystyle c$ in the embedded space $\displaystyle\rho$, disparity of their distances ($\displaystyle\Delta$) should not reflect true bias. Thus, while calculating $\displaystyle\textrm{avg\_bias}(a,b)$ we further filter out the triplets where $\displaystyle\Delta(c,a)>th\land\Delta(c,b)>th$, where $\displaystyle th$ is some pre-defined threshold. In our experiment, we remove all the class-pairs having $\displaystyle\Delta$ larger than $\displaystyle 1$ standard deviation (i.e. $\displaystyle th$) from the mean value of all $\displaystyle Delta$s across all the class-pairs.

Evaluation Metric. We evaluate DeepInspect in two ways:

Precision & Recall. We use precision and recall to measure DeepInspect’s accuracy. For each error type t, suppose that E is the number of errors detected by DeepInspect and A is the the number of true errors in the ground truth set. Then the precision and recall of DeepInspect are $\displaystyle\frac{|A\cap E|}{|E|}$ and $\displaystyle\frac{|A\cap E|}{|A|}$ respectively.

Area Under Cost Effective Curve (AUCEC). Similarly to how static analysis warnings are ranked based on their priority levels (Rahman and Devanbu, 2013), we also rank the erroneous class-pairs identified by DeepInspect based on the decreasing order of error proneness, i.e. most error-prone pairs will be at the top. To evaluate the ranking we use a cost-effectiveness measure (Arisholm et al., 2010), AUCEC (Area Under the Cost-Effectiveness Curve), which has become standard to evaluate rank-based bug-prediction systems (Rahman et al., 2013; Kamei et al., 2010; Rahman et al., 2011; Rahman and Devanbu, 2013; Ray et al., 2016).

Cost-effectiveness evaluates when we inspect/test top n% class-pairs in the ranked list (i.e. inspection cost), how many true errors are found (i.e. effectiveness). Both cost and effectiveness are normalized to 100%.  Figure 6 shows cost on the x-axis, and effectiveness on the y-axis, indicating the portion of the ground truth errors found. AUCEC is the area under this curve.

Baseline.

We compare DeepInspect w.r.t. two baselines:

(i) MODE-inspired: A popular way to inspect each image is to inspect a feature vector, which is an output of an intermediate layer  (Ma et al., 2018b; Zhang et al., 2018). However, abstracting a feature vector per image to the class level is non-trivial. Instead, for a given layer, one could inspect the weight vector ($\displaystyle w_{l}=[w^{0}_{l},w^{1}_{l},...,w^{n}_{l}]$) of a class, say $\displaystyle l$, where the superscripts represent a feature. Similar weight-vectors are used in MODE (Ma et al., 2018b) to compare the difference in feature importance between two image groups. In particular, from the last linear layer before the output layer we extract such per-class weight vectors and compute the pairwise distances between the weight vectors. Using these pairwise distances we calculate confusion and bias metrics as described in Section 3.

(ii) Random: We also build a random model that picks random class-pairs for inspection (Witten and Frank, 2005) as a baseline.

For AUCEC evaluation, we further show the performance of an optimal model that ranks the class-pairs perfectly—if $\displaystyle n$% of all the class-pairs are truly erroneous, the optimal model would rank them at the top such that with lower inspection budget most of the errors will be detected. The optimal curve gives the lower upper bound of the ranking scheme.

Research Questions. With this experimental setting, we investigate the following three research questions to evaluate DeepInspect for DNN image classifiers:

• •

RQ1. Can DeepInspect distinguish between different classes?

• •

RQ2. Can DeepInspect identify the confusion errors?

• •

RQ3. Can DeepInspect identify the bias errors?

5. Results

We begin our investigation by checking whether de-facto neuron coverage-based metrics can capture class separation.

**RQ1. Can DeepInspect distinguish between different classes? **

Motivation. The heart of DeepInspect’s error detection technique lies in the fact that the underlying Neuron Activation Probability metric ($\displaystyle\rho$) captures each class abstraction reasonably well and thus distinguishes between classes that do not suffer from class-level violations. In this RQ we check whether this is indeed true. We also check whether a new metric $\displaystyle\rho$ is necessary, i.e., whether existing neuron-coverage metrics could capture such class separations.

Approach. We evaluate this RQ w.r.t. the training data since the DNN behaviors are not tainted with inaccuracies associated with the test images. Thus, all the class-pairs are benign. We evaluate this RQ in three settings: (i) using DeepInspect’s metrics, (ii) neuron-coverage proposed by Pei et al. (Pei et al., 2017a), and (iii) other neuron-activation related metrics proposed by DeepGauge (Ma et al., 2018a).

Setting-1. DeepInspect. Our metric, Neuron Activation Probability Matrix ($\displaystyle\rho$), by construction is designed per class. Hence it would be unfair to directly measure its capability to distinguish between different classes. Thus, we pose this question in slightly a different way, as described below. For multi-label classification, each image contains multiple class-labels. For example, an image might have labels for both mouse and keyboard. Such coincidence of labels may create confusion—if two labels always appear together in the ground truth set, no classifier can distinguish between them. To check how many times two labels coincide, we define a coincidence score between two labels $\displaystyle L_{a}$ and $\displaystyle L_{b}$ as: $\displaystyle\displaystyle coincidence\left(L_{a},L_{b}\right)=mean(P\left(L_{a},L_{b}|L_{a}\right),P\left(L_{a},L_{b}|L_{b}\right))$.

The above formula computes the minimum probability of labels $\displaystyle L_{a}$ and $\displaystyle L_{b}$ occurring together in an image given that one of them is present. Note that this is a bi-directional score, i.e. we treat the two labels similarly. The $\displaystyle mean$ operation ensures we detect the least coincidence in either direction. A low value of coincidence score indicates two class-labels are easy to separate and vice versa.

Now, to check DeepInspect’s capability to capture class separation, we simply check the correlation between coincidence score and confusion score (napvd) from Equation 2 for all possible class-label pairs. Since only multi-label objects can have label coincidences, we perform this experiment for a pre-trained ResNet-50 model on the COCO multi-label classification task.

A Spearman correlation coefficient between the confusion and coincidence scores reaches a value as high as 0.96, showing strong statistical significance. The result indicates that DeepInspect can disambiguate most of the classes that have a low confusion scores.

Interestingly, we found some pairs where coincidence score is high, but DeepInspect was able to isolate them. For example, (cup,chair), (toilet,sink), etc.. Manually investigating such cases reveals that although these pairs often appear together in the input images, there are also enough instances when they appear by themselves. Thus, DeepInspect disambiguates between these classes and puts them apart in the embedded space $\displaystyle\rho$. These results indicate DeepInspect can also learn some hidden patterns from the context and, thus, can go beyond inspecting the training data coincidence for evaluating model bias/confusion, which is the de facto technique among machine learning researchers (Zhao et al., 2017).

Next, we investigate whether popular white-box metrics can distinguish between different classes.

Setting-2. Neuron Coverage ($\displaystyle NC$) (Pei et al., 2017a) computes the ratio of the union of neurons activated by an input set and the total number of neurons in a DNN. Here we compute $\displaystyle NC$ per class-label, i.e. for a given class-label, we measure the number of neurons activated by the images tagged with that label w.r.t. to the total neurons. The activation threshold we use is 0.5. We perform this experiment on COCO and CIFAR-100 to study multi- and single-label classifications. Figure 3 shows results for COCO . We observe similar results for CIFAR-100 .

Each boxplot in the figure shows the distribution of neuron coverage per class-label across all the relevant images. These boxplots visually show that different labels have very similar $\displaystyle NC$ distribution. We further compare these distributions using Kruskal Test (Kruskal and Wallis, 1952), which is a non-parametric way of comparing more than two groups. Note that we choose a non-parametric measure as $\displaystyle NC$s may not follow normal distributions. (Kruskal Test is a parametric equivalent of the one-way analysis of variance (ANOVA).) The result reports a $\displaystyle p-value<<0.05$, i.e. some differences exist across these distributions. However, a pairwise Cohend’s effect size for each class-label pair, as shown in the following table, shows more than 56% and 78% class-pairs for CIFAR-100 and COCO have small to negligible effect size. This means neuron coverage cannot reliably distinguish a majority of the class-labels.

[TABLE]

Setting-3. DeepGauge (Ma et al., 2018a). Ma et al. (Ma et al., 2018a) argue that each neuron has a primary region of operation; they identify this region by using a boundary condition $\displaystyle[{low},{high}]$ on its output during training time; outputs outside this region ($\displaystyle(-\infty,{low})\cup({high},+\infty)$) are marked as corner cases. They therefore introduce multi-granular neuron and layer-level coverage criteria. For neuron coverage they propose: (i) k-multisection coverage to evaluate how thoroughly the primary region of a neuron is covered, (ii) boundary coverage to compute how many corner cases are covered, and (iii) strong neuron activation coverage to measure how many corner case regions are covered in ($\displaystyle{high},+\infty$) region. For layer-level coverage, they define (iv) top-k neuron coverage to identify the most active k-neurons for each layer, and (v) top-k neuron pattern for each test-case to find a sequence of neurons from the top-k most active neurons across each layer.

We investigate whether each of these metrics can distinguish between different classes by measuring the above metrics for individual input classes following Ma et al.’s methodology. We first profiled every neuron upper- and lower-bound for each class using the training images containing that class-label. Next, we computed per-class neuron coverage using test images containing that class; for k-multisection coverage we chose $\displaystyle k=100$ to scale up the analysis. It should be noted that we also tried $\displaystyle k=1000$ (which is used in the original DeepGauge paper) and observed similar results (not shown here).

For layer-level coverage, we directly used the input images containing each class, where we select $\displaystyle k=1$.

Figure 4 shows the results as a histogram of the above five coverage criteria for the COCO dataset. For all five coverage criteria, there are many class-labels that share similar coverage. For example, in COCO , there are $\displaystyle 52$ labels with k-multisection neuron coverage with values between $\displaystyle 0.31$ and $\displaystyle 0.32$. Similarly, there are $\displaystyle 40$ labels with 0 neuron boundary coverage. Therefore, none of the five coverage criteria are an effective way to distinguish between different equivalence classes. The same conclusion was drawn for the CIFAR-100 dataset.

Result 5: DeepInspect can disambiguate classes better than previous coverage-based metrics for the image classification task.

We now investigate DeepInspect’s capability in detecting confusion and bias errors in DNN models.

**RQ2. Can DeepInspect identify the confusion errors? **

Motivation. To evaluate how well DeepInspect can detect class-level violations, in this RQ, we report DeepInspect’s ability to detect the first type of violation, i.e., Type1/Type2 confusions w.r.t. to ground truth confusion errors, as described in Section 4.2.1.

We first explore the correlation between napvd and ground truth Type1/Type2 confusion score. Strong correlation has been found for all 8 experimental settings.  Figure 5 gives examples on COCO and CIFAR-10. These results indicate that napvd can be used to detect confusion errors—lower napvd means more confusion.

Approach. By default, DeepInspect reports all the class-pairs with napvd scores one standard deviation less than the mean napvd score as error-prone (See Figure 2(b)). In this setting, as the result shown on  Table 3, DeepInspect reports errors at high recall under most settings. Specifically, on CIFAR-100 and robust CIFAR-10 ResNet, DeepInspect can report errors as high as 71.8%, and 100%, respectively. DeepInspect has identified thousands of confusion errors.

If higher precision is wanted, a user can choose to inspect only a small set of confused pairs based on napvd. As also shown in Table 3, when only the top1% confusion errors are reported, a much higher precision is achieved for all the datasets. In particular, DeepInspect identifies 31 and 39 confusion errors for the COCO model and the CIFAR-100 model with 100% and 79.6% precision, respectively. The trade-off between precision and recall can be found on the cost-effective curves shown on  Figure 6, which show overall performance of DeepInspect at different inspection cutoffs. Overall, w.r.t. a random baseline mode, DeepInspect is gaining AUCEC performance from $\displaystyle 61.6\%$ to $\displaystyle 85.7\%$; w.r.t. a MODE baseline mode, DeepInspect is gaining AUCEC performance from $\displaystyle 10.2\%$ to $\displaystyle 28.2\%$.

Figure 7 and Figure 8 give some specific confusion errors found by DeepInspect in the COCO and the ImageNet settings. In particular, as shown in Figure 7(a), when there is only a keyboard but no mouse in the image, the COCO model reports both. Similarly, Figure 8(a) shows confusion errors on (cello, violin). There are several cellos in this image, but the model predicts it to show a violin.

Across all three relatively more robust CIFAR-10 models DeepInspect identifies (cat, dog), (bird, deer) and (automobile, truck) as buggy pairs, where one class is very likely to be mistakenly classified as the other class of the pair. This indicates that these confusion errors are to be tied to the training data, so all the models trained on this dataset including the robust models may have these errors. These results further show that the confusion errors are orthogonal to the norm-based adversarial perturbations and we need a different technique to address them.

We also note that the performance of all methods degrades quite a bit on ImageNet. ImageNet is known to have a complex structure, and all the tasks, including image classification and robust image classification (Xie et al., 2019) usually have inferior performance compared with simpler datasets like CIFAR-10 or CIFAR-100. Due to such inherent complexity, the class representation in the embedded space is less accurate, and thus the relative distance between two classes may not correctly reflect a model’s confusion level between two classes.

Result 5: DeepInspect can successfully find confusion errors with precision 21% to 100% at top1% for both single- and multi-object classification tasks. DeepInspect also finds confusion errors in robust models.

**RQ3. Can DeepInspect identify the bias errors? **

Motivation. To assess DeepInspect’s ability to detect class-level violations, in this RQ, we report DeepInspect’s performance in detecting the second type of violation, i.e., Bias errors as described in Section 4.2.2.

Approach. We evaluate this RQ by estimating a model’s bias (avg_bias) using Equation 4 w.r.t. the ground truth (avg_cd), computed as in Section 4.2.2. We first explore the correlation between pairwise avg_cd and our proposed pairwise avg_bias;  Figure 9 shows the results for COCO and CIFAR-10. Similar trends were found in the other datasets we studied. The results show that a strong correlation exists between avg_cd and avg_bias. In other words, our proposed avg_bias is a good proxy for detecting confusion errors.

As in RQ2, we also do a precision-recall analysis w.r.t. finding the bias errors across all the datasets. We analyze the precision and recall of DeepInspect when reporting bias errors at the cutoff Top1$\displaystyle\%$(avg_bias) and mean(avg_bias)+standard deviation(avg_bias), respectively. The results are shown in Table 4. At cutoff Top1$\displaystyle\%$(avg_bias), DeepInspect detects suspicious pairs with precision as high as 75% and 84% for COCO and imSitu, respectively. At cutoff mean(avg_bias)+standard deviation(avg_bias), DeepInspect has high recall but lower precision: DeepInspect detects ground truth suspicious pairs with recall at 75.9% and 71.8% for COCO and imSitu. DeepInspect can report 657(=249+408) total true bias bugs across the two models. DeepInspect outperforms the random baseline by a large margin at both cutoffs. As in the case of detecting confusion errors, there is a significant trade-off between precision and recall. This can be customized based on user needs. The cost-effectiveness analysis in  Figure 10 shows the entire spectrum.

As shown in Figure 10, DeepInspect outperforms the baseline by a large margin. The AUCEC gains of DeepInspect are from $\displaystyle 37.1\%$ to $\displaystyle 76.1\%$ w.r.t. the random baseline and from $\displaystyle 6.0\%$ to $\displaystyle 41.9\%$ w.r.t. the MODE baseline across the 8 settings. DeepInspect’s performance is close to the optimal curve under some settings, specifically the AUCEC gains of the optimal over DeepInspect are only 7.11% and 7.95% under the COCO and ImSitu settings, respectively.

Inspired by (Zhao et al., 2017), which shows bias exists between men and women in COCO for the gender image captioning task, we analyze the most biased third class $\displaystyle c$ for $\displaystyle a$ and $\displaystyle b$ being men and women. As shown in Figure 11, we found that sports like skiing, snowboarding, and surfboarding are more closely associated with men and thus misleads the model to predict the women in the images as men. Figure 12 shows results on imSitu, where we found that the model tends to associate the class “inside” with women while associating the class “outside” with men.

We generalize the idea by choosing classes $\displaystyle a$ and $\displaystyle b$ to be any class-pair. We found that similar bias also exists in the single-label classification settings. For example, in ImageNet, one of the highest biases is between Eskimo_dog and rapeseed w.r.t. Siberian_husky. The model tends to confuse the two dogs but not Eskimo_dog and rapeseed. This makes sense since Eskimo_dog and Siberian_husk are both dogs so more easily misclassified by the model.

One of the fairness violations of a DNN system can be drastic differences in accuracy across groups divided according to some sensitive feature(s). In black-box testing, the tester can get a number indicating the degree of fairness has been violated by feeding into the model a validation set. In contrast, DeepInspect provides a new angle to the fairness violations. The neuron distance difference between two classes $\displaystyle a$ and $\displaystyle b$ w.r.t. a third class $\displaystyle c$ sheds light on why the model tends to be more likely to confuse between one of them and $\displaystyle c$ than the other. We leave a more comprehensive examination on interpreting bias/fairness violations for future work.

Result 5: DeepInspect can successfully find bias errors for both single- and multi-label classification tasks, and even for the robust models, from 52% to 84% precision at top1%.

6. Related Work

Software Testing & Verification of DNNs. Prior research proposed different white-box testing criteria based on neuron coverage (Pei et al., 2017a; Ma et al., 2018a; Tian et al., 2018) and neuron-pair coverage (Sun et al., 2018a). Sun et al. (Sun et al., 2018b) presented a concolic testing approach for DNNs called DeepConcolic. They showed that their concolic testing approach can effectively increase coverage and find adversarial examples. Odena and Goodfellow proposed TensorFuzz(Odena et al., 2019), which is a general tool that combines coverage-guided fuzzing with property-based testing to generate cases that violate a user-specified objective. It has applications like finding numerical errors in trained neural networks, exposing disagreements between neural networks and their quantized versions, surfacing broken loss functions in popular GitHub repositories, and making performance improvements to TensorFlow. There are also efforts to verify DNNs (Pei et al., 2017b; Katz et al., 2017; Huang et al., 2017a; Wang et al., 2018) against adversarial attacks. However, most of the verification efforts are limited to small DNNs and pixel-level properties. It is not obvious how to directly apply these techniques to detect class-level violations.

Adversarial Deep Learning. DNNs are known to be vulnerable to well-crafted inputs called adversarial examples, where the discrepancies are imperceptible to a human but can easily make DNNs fail (Yuan et al., 2019; Lu et al., 2017; Raghunathan et al., 2018; Papernot et al., 2016a; Evtimov et al., 2017; Goodfellow et al., 2015; Kos et al., 2017; Narodytska and Kasiviswanathan, 2016; Nguyen et al., 2015; Papernot et al., 2017, 2016b; Szegedy et al., 2014; Huang et al., 2017b; Kurakin et al., 2017). Much work has been done to defend against adversarial attacks (Bastani et al., 2016; Carlini and Wagner, 2017; Feinman et al., 2017; Grosse et al., 2017; Gu and Rigazio, 2015; Metzen et al., 2017; Papernot and McDaniel, 2017; Papernot et al., 2016c; Shaham et al., 2015; Xu et al., 2017; Zheng et al., 2016; He et al., 2017; Mao et al., 2019). Our methods have potential to identify adversarial inputs. Moreover, adversarial examples are usually out of distribution data and not realistic, while we can find both out-distribution and in-distribution corner cases. Further, we can identify a general weakness or bug rather than focusing on crafted attacks that often require a strong attacker model (e.g., the attacker adds noise to a stop sign image).

Interpreting DNNs. There has been much research on model interpretability and visualization (Lipton, 2016; Zhang and Zhu, 2018; Selvaraju et al., 2017; Montavon et al., 2017; Bau et al., 2017; Dong et al., 2017). A comprehensive study is presented by Lipton  (Lipton, 2016). Dong et al. (Dong et al., 2017) observed that instead of learning the semantic features of whole objects, neurons tend to react to different parts of the objects in a recurrent manner. Our probabilistic way of looking at neuron activation per class aims to capture holistic behavior of an entire class instead of an individual object so diverse features of class members can be captured. Closest to ours is by Papernot et al. (Papernot and McDaniel, 2018), who used nearest training points to explain adversarial attacks. In comparison, we analyze the DNN’s dependencies on the entire training/testing data and represent it in Neuron Activation Probability Matrix. We can explain the DNN’s bias and weaknesses by inspecting this matrix.

Evaluating Models’ Bias/Fairness. Evaluating the bias and fairness of a system is important both from a theoretical and a practical perspective (Luong et al., 2011; Zemel et al., 2013; Zafar et al., 2017b; Brun and Meliou, 2018). Related studies first define a fairness criteria and then try to optimize the original objective while satisfying the fairness criteria  (Dwork et al., 2012; Hardt et al., 2016; Barocas et al., 2018; Menon and Williamson, 2018; Donini et al., 2018; Lamy et al., 2019). These properties are defined either at individual (Dwork et al., 2012; Kusner et al., 2017; Kim et al., 2018) or group levels (Calders et al., 2009; Hardt et al., 2016; Zafar et al., 2017a). In this work, we propose a definition of a bias error for image classification closely related to fairness notions at group-level. Class membership can be regarded as the sensitive feature and the equality that we want to achieve is for the confusion levels of two groups w.r.t. any third group. We showed the potential of DeepInspect to detect such violations.

Galhotra et al. (Galhotra et al., 2017) first applied the notion of software testing to evaluating software fairness. They mutate the sensitive features of the inputs and check whether the output changes. One major problem with their proposed method, Themis, is that it assumes the model takes into account sensitive attribute(s) during training and inference. This assumption is not realistic since most existing fairness-aware models drop input-sensitive feature(s). Besides, Themis will not work on image classification, where the sensitive attribute (e.g.,, gender, race) is a visual concept that cannot be flipped easily. In our work, we use a white-box approach to measure the bias learned by the model during training. Our testing method does not require the model to take into account any sensitive feature(s). We propose a new fairness notion for the setting of multi-object classification, average confusion disparity, and a proxy, average bias, to measure for any deep learning model even when only unlabeled testing data is provided. In addition, our method tries to provide an explanation behind the discrimination. A complementary approach by Papernot et al. (Papernot and McDaniel, 2018) shows such explainability behind model bias in a single classification setting.

7. Discussion & Threats to Validity

Discussion. In the literature, bug detection, debugging, and repair are usually three distinct tasks, and there is a large body of work investigating each separately. In this work, we focus on bug detection for image classifier software. A natural follow-up of our work will be debugging and repair leveraging DeepInspect’s bug detection. We present some preliminary results and thoughts.

A commonly used approach to improving (i.e. fixing) image classifiers is active learning, which consists of adding more labeled data by smartly choosing what to label next. In our case, we can use napvd to identify the most confusing class pairs, and then target those pairs by collecting additional examples that contain individual objects from the confusing pairs. We download 105 sample images from Google Images that contain isolated examples of these categories so that the model learns to disambiguate them. We retrain the model from scratch using the original training data and these additional examples. Using this approach, we have some preliminary results on the COCO dataset. After retraining, we find that the $\displaystyle\operatorname{type2conf}$ of the top confused pairs reduces. For example, the $\displaystyle\operatorname{type2conf}$(baseball bat, baseball glove) is reduced from 0.23 to 0.16, and $\displaystyle\operatorname{type2conf}$(refrigerator, oven) is reduced from 0.14 to 0.10. Unlike traditional active learning approaches that encourage labeling additional examples near the current decision boundary of the classifier, our approach encourages the labeling of problematic examples based on confusion bugs.

Another potential direction to explore is to use DeepInspect in tandem with debugging & repair tools for DNN models like MODE (Ma et al., 2018b). DeepInspect enables the user to focus debugging effort on the vulnerable classes even in the absence of labeled data. For instance, once DeepInspect identifies the vulnerable class-pairs, one can use the GAN-based approach proposed in MODE to generate more training data from these class-pairs, apply MODE to identify the most vulnerable features in these pairs to select for retraining.

We have also explored how the neuron coverage threshold($\displaystyle th$) used in computing $\displaystyle NAPVD$ affects our performance in detecting confusion and bias errors. We studied one multi-label classification task COCO  and one single-label classification task CIFAR-100. Table 5, 6, 7, 8 show how our precision and recall change when using different neuron coverage thresholds ($\displaystyle th$). We observed that for CIFAR-100 and COCO  that DeepInspect’s accuracies are overall stable at $\displaystyle 0.4\leq th\leq 0.75$. With smaller th($\displaystyle<0.25$), too many neurons are activated pulling the per-class activation-probability-vectors closer to each other. In contrast, with higher th($\displaystyle>0.75$), important activation information gets lost. Thus, we select $\displaystyle th=0.5$ for all the other experiments to avoid either issue.

Threats to Validity. We only test DeepInspect on 6 datasets under 8 settings. We include both single-class and multi-class as well as regular and robust models to address these threats as much as possible.

Another limitation is that DeepInspect needs to decide thresholds for both confusion errors and bias errors, and a threshold for discarding low-confusion triplets in the estimation of avg_bias. Instead of choosing fixed threshold, we mitigate this threat by choosing thresholds that are one standard deviation from the corresponding mean values and, also, reporting performance at top1%.

The task of accurately classifying any image is notoriously difficult. We simplify the problem by testing the DNN model only for the classes that it has seen during training. For example, while training, if a DNN does not learn to differentiate between black vs. brown cows (i.e., all the cow images only have label cow and they are treated as belonging to the same class by the DNN), DeepInspect will not be able to test these sub-groups.

8. Conclusion

Our testing tool for DNN image classifiers, DeepInspect, automatically detects confusion and bias errors in classification models. We applied DeepInspect to six different popular image classification datasets and eight pretrained DNN models, including three so-called relatively more robust models. We show that DeepInspect can successfully detect class-level violations for both single- and multi-label classification models with high precision.

Acknowledgements.

This work is supported in part by NSF CNS-1563555, CCF-1815494, CNS-1842456, CCF-1845893, and CCF-1822965. Any opinions, findings, conclusions, or recommendations expressed herein are those of the authors, and do not necessarily reflect those of the US Government or NSF.