Grammar Based Directed Testing of Machine Learning Systems

TL;DR

This paper introduces OGMA, a systematic, grammar-based testing framework for machine learning systems that efficiently discovers errors and improves model robustness, demonstrated on NLP classifiers with significantly better results than random testing.

Contribution

The paper presents OGMA, the first scalable, grammar-based testing approach for ML systems that automatically finds errors and enhances model robustness.

Findings

Discovered thousands of errors in NLP classifiers

OGMA outperforms random testing by up to 489%

Demonstrated effectiveness on real-world NLP systems

Abstract

The massive progress of machine learning has seen its application over a variety of domains in the past decade. But how do we develop a systematic, scalable and modular strategy to validate machine-learning systems? We present, to the best of our knowledge, the first approach, which provides a systematic test framework for machine-learning systems that accepts grammar-based inputs. Our OGMA approach automatically discovers erroneous behaviours in classifiers and leverages these erroneous behaviours to improve the respective models. OGMA leverages inherent robustness properties present in any well trained machine-learning model to direct test generation and thus, implementing a scalable test generation methodology. To evaluate our OGMA approach, we have tested it on three real world natural language processing (NLP) classifiers. We have found thousands of erroneous behaviours in these systems. We also compare OGMA with a random test generation approach and observe that OGMA is more effective than such random test generation by up to 489%.

Tables

Table 1. TABLE I : Notations used in Ogma approach

$G$	A grammar used to generate test inputs
${𝕀}_G$	All inputs described by a grammar $G$
${𝕋}_G$	The derivation trees of any input $I\in {𝕀}_G$
$f_1,f_2$	Classifiers under test.
$J$	A pre-determined Jaccard Threshold
${\tau }_G$	A function ${𝕀}_G\to {𝕋}_G$ which outputs the derivation tree of an input $I\in {𝕀}_G$
$S$	The initial input to the directed search. $S$ conforms to grammar $G$

Table 2. TABLE II : Notations used in Evaluation

#inputs	Total number of unique generated test inputs
#err	Total number of unique erroneous inputs
$er{r}_r$	$\frac{\#err}{\#inputs}$
Imp%	Improvement of $er{r}_r$ of Ogma with respect to the $er{r}_r$ of random test

Table 3. TABLE III : Key Results (the initial input is not erroneous)

	Ogma			Ogma- No Backtrack			Random			%impr
	#inputs	#errs	$er{r}_r$	#inputs	#errs	$er{r}_r$	#inputs	#errs	$er{r}_r$
$ℝ$-$𝔸$	1948.33	1757.50	0.90	1953.17	1126.17	0.58	1798.33	1276.67	0.71	27.06
$𝕌$-$𝔸$	1920.33	1686.67	0.88	1947.67	983.67	0.51	1778.67	1305.17	0.73	19.70
$ℝ$-$𝕌$	1917.17	1312.17	0.68	1954.67	741.50	0.38	1798.00	797.50	0.44	54.31

Table 4. TABLE IV : Jaccard Thresholds

Grammars	A	B	C	D	E	F
$ℝ$-$𝔸$	0.15	0.15	0.1	0.15	0.15	0.15
$𝕌$-$𝔸$	0.15	0.15	0.1	0.15	0.1	0.1
$ℝ$-$𝕌$	0.3	0.15	0.15	0.3	0.15	0.15

Table 5. TABLE V : Sensitivity of Ogma w.r.t. the threshold J 𝐽 J for checking Jaccard Index

	Ogma			Random
	#inputs	#err	$er{r}_r$	#inputs	#err	$er{r}_r$	Imp%
0.05	172	41	0.23	198	8	0.04	489.97
0.15	189	100	0.53	196	47	0.24	120.65
0.3	196	148	0.76	200	124	0.62	21.79
0.4	195	168	0.86	195	134	0.69	25.37
0.45	196	184	0.93	193	187	0.96	-3.11
0.5	193	189	0.98	197	184	0.93	4.85
0.6	195	184	0.94	197	184	0.93	1.0
0.75	197	197	1	195	194	0.99	0.51

Table 6. TABLE VI : Sensitivity of Ogma w.r.t. Grammars

	Grammar A - F		$G_{bad}$
	%unique inps	%error inps	%unique inps	%error inps
$ℝ$-$𝔸$	97%	88%	52%	22%
$𝕌$-$𝔸$	96%	84%	49%	34%
$ℝ$-$𝕌$	96%	66%	51%	28%

Table 7. TABLE VIII : Number of error inducing inputs after retraining. The number of error inputs added is shown as a percentage of the size of original training set.

% added	#Errors	Accuracy% SGDClassifier	Accuracy% Multinomial NB
0%	553	99.76	99.76
2%	477	99.76	99.76
5%	439	99.76	99.76
7%	370	99.76	99.76
10%	409	99.76	99.76
12%	351	99.76	99.76
15%	293	99.76	99.76
17%	387	99.74	99.74
20%	454	99.74	99.74
22%	449	99.74	99.74
25%	417	99.73	99.73

Equations

$$JI(A,B)=\frac{|A\cap B|}{|A\cup B|}$$

$$0\le JI(A,B)\le 1$$

$$JI(f_1(I),f_2(I))<J$$

$$themonkeyshotBob$$

$$IshotJohnwithMary$$

Full text

1 Introduction

In recent years, the application of machine-learning models has escalated to several application domains, including sensitive and safety-critical application domains such as the automotive industry [14], human resources[12] and education[13]. One of the key insight behind the usage of such models is to automate mundane and typically error-prone tasks of decision making. On the flip side, these machine-learning models are susceptible to erroneous behaviour, which may induce unpredictable scenarios, even costing human lives and causing financial damage. As an example, consider the following sentence that might be processed by an automated emergency response service:

“My house is on fire. Please send help in Sebastopol, CA. There is a huge forest fire approaching the town.”

While processing this text using a well trained text classifier model [8], it provides the following classification classes for the text:

’Hobbies and Interests’, ’Science’, ’Arts and Entertainment’, ’Home and Garden’, ’Religion and Spirituality’

It is needless to mention that the respective text classifier is unsuitable for categorising the emergency aspect underneath the text and therefore, is broken for the usage in emergency text classification. In short, systematic validation of machine-learning models is of critical importance before deploying them in any sensitive application domain.

In this paper, we broadly consider the problem of systematically testing the erroneous behaviours of arbitrary machine learning based natural language processing models. Moreover, we consider these models are amenable only to text inputs conforming to certain grammars – a common feature across a variety of systems including models used in text classification. While the nature of erroneous behaviours in a machine-learning model depends on its input features, it is often challenging to formally characterise such behaviours. This is due to the inherent complexity of real world machine-learning models. To deal with such complexity, we leverage differential testing. Thus, instead of checking whether the output of a classifier is correct for a given input, we compare the output with the respective output of a different classifier realising the same problem. If the outputs from two classifiers are vastly dissimilar, then we call the respective input to be erroneous. The primary objective of this paper is to facilitate discovery of erroneous inputs. Specifically, given a pair of machine-learning models and a grammar encoding their inputs, our Ogma 111God of language from Irish mythology and Scottish mythology approach systematically searches the input space of the models and discovers inputs that highlight the erroneous behaviours.

As an example, consider the behaviours of $\mathit{Classifier}\ A$ and $\mathit{Classifier}\ B$, which are targeted for the same classification job over an input domain conforming to grammar $G$ (i.e. $\mathbb{I}_{G}$), in Figure 1. Despite being targeted for the same classification task, $\mathit{Classifier}\ A$ and $\mathit{Classifier}\ B$ generate largely dissimilar classification classes $O_{1}$ and $O_{2}$ for the same input $I$. The dissimilarity in outputs is indicative of one or both of the outputs being incorrect. Such erroneous behaviours in the classifiers might appear due to the outdated or inappropriate training data. We use our Ogma approach to automatically discover erroneous inputs such as $I$. Moreover, we can use these inputs to retrain and reduce the erroneous behaviours of the classifiers.

The directed strategy embodied within Ogma forms the crux of its scalability and effectiveness. Concretely, Ogma leverages the robustness property of common machine-learning models. According to the robustness property [18], the classification classes of two similar inputs do not vary substantially for well trained machine-learning models. As an example, consider the input $I^{\prime}$ in Figure 1, to be similar to input $I$. The classification classes for input $I^{\prime}$ will be similar to $O_{1}$ and $O_{2}$ for $\mathit{Classifier}\ A$ and $\mathit{Classifier}\ B$, respectively. In other words, if input $I$ is an erroneous input, then input $I^{\prime}$ is likely to be erroneous too. To realise this robustness property for test generation, Ogma designs a perturbation function to continuously derive similar inputs to $I$ and $I^{\prime}$ and thus, exploring the neighbourhood of erroneous inputs for a given classifier. Such a perturbation cannot simply be obtained by mutating a raw input, as the mutated input may not conform to the grammar. To this end, Ogma perturbs the derivation tree to explore the erroneous input subspace.

The grammar-based test input generation and the directed strategy make our Ogma approach generic in terms of testing arbitrary erroneous behaviours of machine learning based natural language processing classifiers. In contrast to existing works that use concrete inputs from the training dataset to test machine-learning models [44, 36], our Ogma approach does not require training data for testing the models. Instead, we abstract the input space of the model via a grammar, which is a common strategy to encode an arbitrarily-large space of structured inputs. Thus, the tests generated by Ogma can explore these large input space, potentially discovering more errors when compared to limiting the test generation via the training data. In contrast to previous works, Ogma is not limited to test specific applications [29] or properties [19, 41]. Ogma works completely blackbox and can be easily adapted to test real-world classification systems for a variety of different applications. Finally, we show that the erroneous inputs generated by Ogma are useful and can be used for retraining the model under test and reducing erroneous behaviours.

The remainder of the paper is organised as follows. After providing the relevant background and an overview of Ogma approach in Section 3, we make the following contributions:

We present Ogma, a novel approach for systematically testing erroneous behaviours of arbitrary machine learning based natural language processing models. The Ogma approach is based on a directed strategy to discover and explore the erroneous input subspace. Since the directed strategy embodied in Ogma is based on the fundamental robustness property of well-trained machine-learning models, we believe that Ogma can be adopted for testing arbitrary machine-learning models exhibiting robustness (Section 4). 2. 2.

We provide an implementation of Ogma in python. Our implementation and all experimental data are publicly available (Section 5). 3. 3.

We evaluate Ogma on three real-world text classifier service providers, namely Rosette [8], uClassify [9] and Aylien [2]. We show that our Ogma approach discovers up to 90% error inducing inputs (with respect to the total number of inputs generated) across a variety of grammars. We also show that the directed strategy in Ogma substantially outperforms (up to 489%) a strategy that randomly generates inputs conforming to the given grammar (Section 5). 4. 4.

We design and evaluate an experiment to show how the error inducing inputs generated by Ogma can be utilised to repair the test classifiers. We show that by retraining the test classifiers with the generated error inducing inputs, the erroneous behaviour can be reduced as much as 24%.

After discussing the related work (Section 6) and threats to validity (Section 7), we conclude and reflect in Section 8.

2 Background

In this section, we introduce the relevant background and the key concepts based on which we design our Ogma approach.

Systems based on machine learning

In this paper, we are concerned about a machine learning based natural language processing model that accepts an input $I$ and classifies it into one of the $n$ classes from the set $\{C_{1},C_{2},C_{3},\cdots,C_{n}\}$. Moreover, such an input $I$ conforms to a grammar $G$, which encodes the set of all valid inputs for the model. Some classic examples of such models include deep-learning-based systems to categorise news items and systems that analyse the sentiments from Twitter feeds, among others. As of today, most machine-learning models are tested on their accuracy for well-defined sets of data. Such a strategy only validates a model on the available datasets. However, it lacks capability to systematically and automatically explore the input space accepted by the model and not captured by the available datasets. This is crucial, as inputs not captured by the available datasets may be presented to the model in a production setting and lead to catastrophic error, potentially costing human lives [10], [11]. In summary, a systematic validation of machine-learning model demands the machinery of automated software testing, a field that is largely unexplored in the light of testing machine-learning models.

Challenges in validating machine-learning-based systems

There exist multitudes of challenges in systematically validating machine-learning models. Consider an arbitrary machine-learning model $M$ that accepts input $I$ conforming to grammar $G$ and classifies $I$ in one of the category $\{C_{1},C_{2},C_{3},\cdots,C_{n}\}$. Firstly, without precisely knowing the correct categorisation of input $I$, it is not possible to validate the model $M$. In other words, validation of machine-learning models faces the oracle problem [15] in software testing. Secondly, there has been significant effort in the software engineering research community to design directed test input generation strategies. The insight behind such directed strategies is to uncover bugs faster. For instance, to check the presence of crashes in C programs, a directed strategy may steer the test execution towards statements accessing pointers. Such directed strategies are well studied for deterministic software and their correctness properties. However, systematically steering the execution of a machine-learning model, in order to make its prediction dramatically wrong, is still immature. Finally, the error inducing inputs for a machine-learning model may not necessarily highlight a bug in the respective code (unlike classic software debugging process). Instead error inputs may highlight flaws in the data on which the respective machine-learning algorithm was trained to obtain the model under test. Therefore, the systematic usage of the error inducing inputs, to debug the machine-learning model, is also of critical importance.

Differential testing

To solve the oracle problem in testing machine-learning models, we leverage differential testing. Specifically, consider two models $M_{1}$ and $M_{2}$ that expect valid inputs conforming to the same grammar $G$ and classifies each input from the same set of categories $\{C_{1},C_{2},C_{3},\cdots,C_{n}\}$. For an input $I$ conforming to $G$, if the prediction of $M_{1}$ and $M_{2}$ are drastically different, then we conclude that $I$ is an error inducing input for at least one of $M_{1}$ and $M_{2}$. In Section 4, we formally define the criteria for identifying such an error inducing input. Although our testing strategy requires two models from the same problem domain, we believe this is practical, given the presence of a large class of machine-learning models targeting real-world problems. Moreover, our proposed strategy can also be useful to discover regression bugs via comparing the outputs from two different versions (e.g. a stable version and a developing version) of the same machine-learning model. It is worthwhile to note that differential testing has also been successfully used for testing ML models in other domains [36] (e.g. computer vision).

Robustness in machine learning

The insight behind the directed testing in Ogma is based on the robustness of common machine-learning models. Conceptually, robustness in machine-learning captures a phenomenon stating that a slight change in the input does not change the output dramatically in well-trained machine-learning models [18]. This means that error inducing inputs are likely to be clustered together in the input space of well-trained models. Technically, assume a model $f$, and let $I$ be an input to $f$ and $\delta$ be a small value. If $f$ is robust, then $f(I)\approx f(I\boxtimes\delta)$, where $I\boxtimes\delta$ captures an input obtained via small $\delta$ perturbation of input $I$. In such case, we say that input $I\boxtimes\delta$ is in the neighbourhood of input $I$. Since $f(I)\approx f(I\boxtimes\delta)$, we hypothesise that if an input $I$ causes an error, then it is likely that input $I\boxtimes\delta$ will cause an error too. This hypothesis forms the crux of our directed testing methodology.

State-of-the-art in testing machine-learning-based systems

Adversarial testing [16, 31] techniques have the objective to fool a machine-learning model with minute perturbation on inputs and guiding the model towards a dramatically wrong prediction. However, such testing strategies are only limited to minimal and unobservable input perturbations and require a set of seed inputs. Therefore, adversarial techniques are neither sufficient nor general enough to check the erroneous behaviour of machine-learning models. Besides, adversarial testing does not solve the test design problem in the broadest sense due to their dependency on a set of seed inputs and due to their incapability to discover faults that may only appear with observable differences across inputs. Finally, if the processed data by the machine-learning model requires security clearance (e.g. healthcare data, finance data), then we need a systematic process to generate these inputs during the automated validation stage of the model.

In recent years, the software engineering research community have stepped up to develop testing methodologies for deep-learning systems [29, 36, 40, 19]. These works, however are, limited either to specific applications  [29] or rely on the presence of sample inputs [44, 36]. Moreover, none of the prior works are applicable to generate grammar-based inputs in a fashion that such inputs steer the execution of machine-learning models to erroneous behaviour. In the subsequent sections, we will discuss the key ingredients of our Ogma approach that accomplishes this objective.

3 Overview of Ogma

In this section, we will outline the working principle of Ogma via simple examples.

Consider a context free grammar as shown in Figure 3. We assume that the sentences generated from this grammar are used as inputs to machine-learning-based systems, such as classifiers. These classifiers may be used to identify a sentence into a specific category, such as hobby, sports and so on.

Differential Testing

Our Ogma approach starts with an initial input $I$. Such an initial input is randomly generated from the grammar. Let us assume that the initial input is “Mary saw my dog”. To check whether this input leads to any classification error, we feed it into two text classifiers. Usually the real-world text classifiers, as used in our evaluation, return a set of classification classes. Let us assume $\mathbb{C}_{1}$ and $\mathbb{C}_{2}$ are the set of classification classes returned by the two classifiers $M_{1}$ and $M_{2}$, respectively. To check whether the initial input lead to a classification error, we evaluate the Jaccard Index $\frac{\left|\mathbb{C}_{1}\cap\mathbb{C}_{2}\right|}{\left|\mathbb{C}_{1}\cup\mathbb{C}_{2}\right|}$. If the Jaccard Index between $\mathbb{C}_{1}$ and $\mathbb{C}_{2}$ is below a user-defined threshold $J$, then we conclude that either $M_{1}$ or $M_{2}$ exhibits a classification error. We note that the threshold $J$ controls the error condition. For instance, a very low value for $J$ will enforce a strong condition on identifying a classification error.

Directed Testing

One of the key challenge for testing machine-learning models is to systematically direct the test generation process. This is to discover erroneous behaviours as fast as possible. While directed test generation is well studied for deterministic software systems, a similar development is limited in the case of machine-learning systems. In this paper, we leverage the robustness of well trained machine learning models to design a directed test generation method. According to robustness, similar inputs and similar outputs are clustered together for such machine-learning models [18]. Thus, we hypothesise that error inducing inputs are also clustered together. However, as our Ogma approach targets inputs conforming to certain grammars, it is not straight-forward to define the neighbourhood of an input that are likely to be classified in a similar fashion. Specifically, we need to explore the following for a directed test generation:

The grammar under test: We should be able to generate a substantial number of inputs that are derived similarly (e.g. by applying similar sequence of production rules) from the grammar. This is to facilitate exploring the neighbourhood of an input conforming to the grammar and thus, exploiting the robustness property of the machine-learning model under test. As observed from the grammar introduced earlier in this section, it does encode several inputs that are derived via similar sequence of production rules. 2. 2.

The distance between inputs conforming to a given grammar: We need an artifact to formally define and explore the neighbourhood of an arbitrary input conforming to a grammar. To this end, we chose the derivation tree of an input generated from the grammar. We consider two different inputs $I$ and $I^{\prime}$ (both conforming to the grammar) in the same neighbourhood if $I$ and $I^{\prime}$ have the same derivation tree, but the exception of a terminal symbol. For instance, the input sentences Mary saw my dog and Bob saw my dog are in the same neighbourhood, as they differ only in the production rules $\mathit{NP}\rightarrow\mathit{Mary}$ and $\mathit{NP}\rightarrow\mathit{Bob}$ (see Figure 2(a) and Figure 2(d)), respectively.

Ogma in Action

Figure 2 captures an excerpt of Ogma actions when initiated with an input sentence $I\equiv$ Mary saw my dog. For the sake of illustration, let us assume that the initial sentence led to a classification error. Thus, Ogma aims to explore the neighbourhood of input $I$ and targets to discover more error inducing inputs. Figure 2(a) captures the derivation tree of the input $I$. We wish to find an input $I^{\prime}$ that has the same derivation tree as $I$ except for one lead node. To this end, we randomly chose a terminal symbol appearing in $I$. As shown in Figure 2(b), Ogma randomly chooses the terminal symbol Mary. Subsequently, we discover the production rule generating the randomly chosen terminal symbol. In Figure 2, Ogma identifies this production rule to be $\mathit{NP}\rightarrow\mathit{Mary}$. Finally, Ogma generates $I^{\prime}$ by randomly choosing a production rule other than $\mathit{NP}\rightarrow\mathit{Mary}$. As observed in Figure 2(d), Ogma identifies the production rule $\mathit{NP}\rightarrow\mathit{Bob}$, leading to the new test input $I^{\prime}\equiv$ Bob saw my dog.

The test input $I^{\prime}\equiv$ Bob saw my dog might not lead to a classification error, as reflected in Figure 2(d). Intuitively, this can be viewed as Ogma moving outside the neighbourhood of error inducing inputs with $I^{\prime}\equiv$ Bob saw my dog. Thus, Ogma stops performing any more modifications to input $I^{\prime}$ and backtracks. To realise this backtracking, Ogma sets the input $I^{\prime}$ to the original input Mary saw my dog. Ogma, then chooses another terminal symbol randomly, as observed in Figure 2(e). A terminal symbol “dog” (cf. Figure 2(e)) is chosen. Subsequently, Ogma finds the production rule resulting the terminal “dog” in a similar manner. Once Ogma finds this rule, a random terminal other than “dog” is chosen from this rule. This new terminal symbol will replace “dog” in $I^{\prime}$. As seen in Figure 2(f), $I^{\prime}\equiv$ Mary saw my cat. Now, input $I^{\prime}$ leads to a classification error, as indicated by ✓. Thus, Ogma follows the same steps, as explained in the preceding paragraphs, to perturb $I^{\prime}$ and generate more error inducing inputs.

In the case where the initial input $I\equiv$ Mary saw my dog was not error inducing, we continue to perturb the input until an error inducing input is discovered. In our experiments, we observed that such a strategy discovers an error inducing input quickly even though the initial input is not error inducing. Once an error inducing input is discovered, the test effectiveness of Ogma accelerates due to the presence of more error inducing inputs in the neighbourhood. Thus, the initial input could be randomly generated and it has negligible impact on the effectiveness of Ogma.

Choice of grammar-based equivalence

Ogma abstracts the input space via a grammar and explores the input space with the objective of generating erroneous inputs. While generating the inputs, Ogma does not aim to preserve the semantic similarity, instead it guarantees that all generated inputs conform to the grammar and thus valid. We choose this approach for multiple reasons. Firstly, Ogma aims to explore a larger input space abstracted by the grammar, instead of restricting the exploration to the semantically equivalent inputs. Thus, as long as the semantically equivalent inputs conform to the grammar, they can potentially be explored by Ogma. To this end, our approach is unaffected even if there exists antonym in the production rule. Secondly, if the semantic similarity is the key factor affecting the classifier results and a perturbation involves an antonym, then Ogma backtracks to the previous (erroneous) sentence. Then, it chooses another terminal symbol for perturbation that may preserve the semantic similarity. As shown by our empirical evaluation, that the backtracking is crucial in the design of Ogma and it leads to $\approx 85\%$ erroneous inputs. Finally, although we evaluated Ogma for natural language processing tools, the central idea behind Ogma is applicable to any machine-learning model whose valid inputs can be captured by a grammar. Such ML models may span across a wide range of applications including detection of malicious http and javascript traffic [42] and malicious powershell commands [24]. However, the notion of semantic equivalence varies across various application domains. For example, the notion of program semantic equivalence (e.g. for an ML-based malware detector) is completely different as compared to the notion of semantic equivalence in natural language (e.g. for an ML-based natural language processing tool). Thus, to keep the idea behind Ogma applicable to a variety of ML application domains, we focus on grammar-based equivalence instead of semantic equivalence.

Handling non-robust input subspace

It is well known in existing [31] literature that there are certain inputs that violate the robustness property of ML systems. However, such adversarial inputs generally cover only a small fraction of the entire input space. This is evident by the fact that adversarial inputs need to be crafted using very specialized techniques. Additionally, Ogma is designed to avoid these adversarial input regions by systematically directing the test generator (e.g. via backtracking). Intuitively, Ogma achieves this by backtracking from a non-error-inducing input subspace (see Algorithm 1 for details). Consequently, if adversarial or non-robust input regions do not exhibit erroneous inputs, such regions will eventually be explored less frequently by Ogma.

4 Detailed Methodology

In this section we discuss our Ogma approach in detail. Our approach revolves around discovering erroneous behaviours by systematically perturbing the derivation tree of an input that conforms to a grammar $G$. First, we introduce the notion of Jaccard index, erroneous inputs, tree similarities and input perturbation before delving into the algorithmic details of our approach. We capture the notations used henceforth in Table I.

Definition 1**.**

**(Jaccard Index)

For any two sets $A$ and $B$ the Jaccard Index $JI$ is defined as follows [39]**

[TABLE]

[TABLE]

If A and B are both empty, we define $JI(A,B)=1$.

Within our Ogma approach, $JI$ is used to compare the output classification classes of two test classifiers. It is worthwhile to mention that we choose the Jaccard Index due to the choice of subject classifiers in our empirical evaluation. The choice of such a metric is modular and can be fine tuned. This means that Ogma is extensible for not only other set similarity metrics, but also for regressors.

In our experiments, the output of the classifiers are finite sets. The Jaccard index satisfies the properties of metric [30]. Other common set similarity indices such as Sørensen-Dice coefficient and the Tversky index are related to the Jaccard Index and may not be metric [20] [27]. As a result, for finite sets, the Jaccard Index is our preferred set similarity index.

Definition 2**.**

**(Erroneous input)

We say that input $I\in\mathbb{I}_{G}$ is an erroneous input if the output sets of the classifiers $f_{1},f_{2}$ satisfy the following condition**

[TABLE]

The threshold $J$ is a user-defined threshold. A lower value of $J$ indicates a stricter condition for finding erroneous inputs.

Definition 3**.**

**(Tree Similarity)

We say two trees $T_{1}$ and $T_{2}$ are similar if we can construct a tree $T$ by replacing exactly one leaf node in $T_{1}$ (respectively, $T_{2}$) such that $T$ is identical to $T_{2}$ (respectively, $T_{1}$).**

Definition 4**.**

**(Input perturbation)

Let $\tau_{G}:\mathbb{I}_{G}\rightarrow\mathbb{T}_{G}$ be a function such that for an arbitrary input $I\in\mathbb{I}_{G}$, $\tau_{G}(I)$ is the derivation tree for $I$. We define $\mathit{Perturb}$ as a function $\mathit{Perturb}:\mathbb{I}_{G}\rightarrow\mathbb{I}_{G}$ such that for an input $I\in\mathbb{I}_{G}$, if $I^{\prime}=\mathit{Perturb}(I)$, then $\tau_{G}(I)$ and $\tau_{G}(I^{\prime})$ are similar trees.**

An overview of our overall approach can be found in Figure 4. The main contribution of this paper is an automated directed test generator for grammar-based inputs. Our applications under test (AUTs) are machine-learning models that accept inputs conforming to certain grammars. The initial input to Ogma (Figure 4) is randomly generated from the grammar. Subsequently, Ogma involves two major steps: 1) Directed Search (directed_search) in the input domain $\mathbb{I}_{G}$ and 2) Input perturbation (Perturb). In the following, we describe these two procedures in detail.

4.1 Directed Search in Ogma

The motivation behind our directed search (cf. procedure directed_search) is to contain the search in the subset of the input space $\mathbb{I}_{G}$ where the errors are localised. Conceptually, robustness in machine-learning captures a phenomenon stating that a slight change in the input does not change the output dramatically in well-trained machine-learning models [18]. This means that error inducing inputs are likely to cluster together in certain input subspace of well-trained models. The goal of Ogma is to discover these subspace(s) and the instances of erroneous behaviours that are present in these subspace(s).

The directed search requires the two classifiers under test ($f_{1},f_{2}$), a grammar ($G$), a randomly generated initial input conforming to the grammar $G$ and a Jaccard Threshold ($J$). The search algorithm evaluates the input $S$ initially. It finds the Jaccard Index (cf. Definition 1) of the output sets $f_{1}(S)$ and $f_{2}(S)$. If $\mathit{JI}\left(f_{1}(S),f_{2}(S)\right)$ is lower than the threshold $J$, then the input $S$ is added to the set $error\_inps$ and $S$ is assigned to $I_{cur}$ for the first iteration. Intuitively, this means $S$ falls in the region of error inducing input subspace and thus, it is likely to lead to more error inducing inputs via perturbation.

At any point, the directed search process keeps track of two crucial inputs, namely $I_{cur}$ (Current input) and $I_{cand}$ (Candidate input), respectively. $I_{cur}$ is the input that was discovered in the latest iteration of the directed search. $I_{cur}$ can be an error or non error input (cf. Definition 2). $I_{cand}$ is the perturbed input resulting from $I_{cur}$ (cf. procedure Perturb), i.e., $I_{cand}=\mathit{Perturb}(I_{cur})$ according to Definition 4. The goal of Ogma with the perturbation is to either discover more error inputs (if $I_{cur}$ is already an error input) or to discover a subspace of $\mathbb{I}_{G}$ which contains error inputs (if $I_{cur}$ is a non-error input).

It is crucial for Ogma to keep track of the transition sequence between error and non-error inducing inputs during the test generation process. Specifically, Ogma prevents the test generation process from entering an input subspace containing non-error inducing inputs from the subspace containing an error inducing inputs. The rationale behind such a strategy is backed by the robustness property of machine-learning models, as perturbing error inducing inputs is certainly more effective than perturbing non-error inducing inputs. As an example, let $I_{cur}$ be “Mary saw my dog”, which is an input that causes erroneous behaviour (cf. Definition 2) in the classifiers $f_{1}$ and/or $f_{2}$. It is part of a subset of $\mathbb{I}_{G}$ in these classifiers which causes these classifiers to exhibit erroneous behaviours. Let the perturbation of $I_{cur}$ result in “Bob saw my dog”, which is assigned to $I_{cand}$. Let us assume $I_{cand}$ does not show erroneous behaviours and thus, is located in an input subspace that is unlikely to exhibit erroneous behaviours. In this case, therefore, we discard $I_{cand}$ (line 21 in Algorithm 1) and backtracks the test generation process to induce a different perturbation to $I_{cur}$.

In the case where $I_{cand}$ does induce an erroneous behaviour, the test generation process is focused to search in the vicinity of $I_{cand}$ to find more such inputs. In this case, we update $I_{cur}$ to the value in $I_{cand}$ and proceed to the subsequent iterations to repeat the perturbation steps.

It is worthwhile to note that there are four possible transitions between inputs in each iteration. These are namely, Non-error inducing input $\rightarrow$ Error inducing input, Error inducing input $\rightarrow$ Error inducing input, Non-error inducing input $\rightarrow$ Non-error inducing input and Error inducing input $\rightarrow$ Non-error inducing input. We only move out of a subspace of interest of $\mathbb{I}_{G}$ in the last case. This is to avoid getting stuck in a region that does not contain error inducing inputs.

4.2 Perturbation in Ogma

The perturbation function has two responsibilities. The first responsibility of this function is to discover the input subspace $\mathbb{I}_{G}$ that contains erroneous inputs. The second responsibility is to explore this subspace to find instances of error inducing inputs in the same. The first responsibility is captured when the initial seed input $S$ is non-error inducing. As we can see in Figure 8, in some cases Ogma produces several non-error inputs in the initial stages of the test generation process. This is because the initial input to Ogma is in some part of the input subspace of $\mathbb{I}_{G}$ where the inputs show non erroneous behaviour. Thus, we need to perturb the input to get the process out of this subspace and find a subspace which shows erroneous behaviour. Ogma continuously perturbs the input to find such a subspace. As we can see in Figure 8(a), eventually after $\approx$ 200 iterations, Ogma finds the subspace of $\mathbb{I}_{G}$ where the inputs do indeed show erroneous behaviours.

The function Perturb chooses a random terminal $i$ from an input $I\in\mathbb{I}_{G}$. Then, we obtain the derivation tree $T=\tau_{G}(I)$. In this derivation tree, we find the leaf node that contains $i$ and discover the parent of this node. This, in turn, gives the production rule $P$ that produced the terminal symbol $i$. In the next step we construct a set $K$, which includes all the terminal symbols we have found in the production rule $P$, except for the terminal symbol $i$. If we reconsider the example in Figure 2(b), the set of such terminal symbols would be $K=${“John”, “Bob”}. We choose a random terminal symbol $i^{\prime}\in K$. We will use this terminal symbol to replace $i\in I$ to create a new input $I^{\prime}$. In the example, if we choose “John”, and replace “Mary”, the new sentence $I^{\prime}\in\mathbb{I}_{G}$ will be “John saw my dog”.

As a result of the design of the perturbation function, the choice of grammar plays an important role in the success of Ogma. The idea of the perturbation is to generate a substantial number of inputs with similar derivation trees.

4.3 Similar Sentences and Perturbation

It is important to note that sentences that might appear similar, may not be considered similar (cf. Definition 3) in Ogma. This difference is best brought out with the help of an example. Concretely, consider the grammar seen in Figure 5 and the derivation tree of the sentence “Frank saw my dog” generated from this grammar.

Two sentences that conform to this grammar are $I_{1}=$ “Mary saw my dog” and $I_{2}=$ “Frank saw my dog”. The derivation tree for $I_{1}$ can be seen in Figure 2(a). As we can clearly see the structures of the derivation trees for $I_{1}$ and $I_{2}$ are different and as a result, these similar sentences are not considered similar inputs in Ogma (cf. Definition 3). In other words, Ogma considers inputs to be similar only if they are derived similarly from the candidate grammar. This is a stricter condition over the similarity of the actual sentences. The similar sentences (cf. Definition 3) for $I_{1}$ would be “Bob saw my dog” and “John saw my dog” according to Ogma. Likewise, the similar sentences for $I_{2}$ would be “Thomas saw my dog” and “Alex saw my dog”.

5 Results

Experimental Setup

We evaluate Ogma across three industrial text classification models provided by uClassify [9], Aylien [2] and Rosette [8] text analytics. We have chosen these classifiers for two reasons. Firstly, these service providers are used in industry scale, such as in Amazon, Airbnb, Microsoft and Oracle among others. Secondly, our chosen service providers use text classifiers that categorise input text into a standard text classification taxonomy called the IAB content taxonomy [7]. At a broader perspective, such a classification taxonomy acts as a guideline on the types of classes that a text can be categorised to. In other words, this ensures a standardisation of classes across a variety of text classifiers. A sample classification via the IAB (Interactive Advertising Bureau) Content Taxonomy can be found in Figure 7. “Automotive” is the broadest level of classification (Tier 1). Underneath this classification, there exists increasingly specific categories. For instance, Tier 2 under the category ”Automotive” includes “Auto Body Styles”, “Auto Type” and “Auto Technology”. Tier 3 is the most specific classification. Examples under “Auto Type” include “Budget Cars”, “Classic Cars”, “Concept Cars” etc. For our evaluation, we have only considered the top tier classification. This is because we expect the classifier to at least have similar classification at the broadest category (i.e. Tier 1).

As we leverage differential testing, we aim to validate whether the output classes from two different text classifiers are similar. Since all our classifiers implement the IAB content taxonomy, we can compare their outputs coherently. Subsequently, we guide our test generation methodology to discover inputs that lead to vastly dissimilar classifier outputs (according to the IAB content taxonomy). We access the services of uClassify, Aylien and Rosette via client-side APIs. We engineer each API call to classify a sentence (as automatically generated via Ogma) and to return a set of at most the five most likely results. For each test environment, we consider a pair of classifiers from different service providers to facilitate differential testing. To check the similarity between classifier outputs, we compute the Jaccard Index of outputs from two classifiers. If the computed Jaccard Index is below a certain threshold $J$ (c.f. Definition 2), then we consider the input, leading to the respective Jaccard Index, as erroneous for at least one of the text classifier. The threshold $J$ is user defined and we evaluate Ogma to check its sensitivity with respect to the threshold $J$. The threshold $J$ that we use for our evaluations can be found in Table IV.

Although Google [5], Baidu [3], Facebook [4] and Amazon [1] do have certain NLP solutions, they do not offer a standard solution. Ogma requires classifiers that are trained to provide a standard set of classification outputs or on a standard taxonomy. This is to have a reasonable expectation that the classifiers should have the same kind of outputs. As the training and testing data are proprietary for classifiers provided by Google [5], Baidu [3], Facebook [4] and Amazon [1], we cannot expect to have their outputs to be similar. In contrast, all our subject classifiers are expected to classify according to the IAB Taxonomy [7]. Thus, we can compare the outputs of our subject classifiers to locate erroneous inputs.

For the sake of brevity, we refer to Aylien as $\mathbb{A}$, Rosette as $\mathbb{R}$ and uClassify as $\mathbb{U}$ for the rest of this section. We also use the notations in Table II to describe the evaluation results.

Choice of Input Grammars

We validate Ogma using six different grammars (see Appendix for all the grammars used). As explained in Section 4, Ogma essentially perturbs the derivation trees for an input generated from a grammar. Such a perturbation forms the crux of our systematic test generation while searching the neighbourhood of an erroneous input. We consider two inputs to be in the same neighbourhood if their derivation tree have the same structure (cf. Definition 2). Thus, to continue test generation via Ogma, the chosen grammar must encode a substantial number of inputs with the same derivation tree structure (see Figure 2). To this end, we chose grammars that support production rules with multiple possible terminal symbols. For example, consider the grammar used in Section 3. In this grammar, production rules from each non-terminal $V$, $NP$, $Det$, $N$ and $P$ lead to multiple possible terminal symbols.

Key Results

We construct three possible pairs of classifiers from the three text classifiers under test. Each pair of classifiers were validated with the six subject grammars chosen for evaluation. Table III outlines our key findings averaging over all such evaluation scenarios. The average is calculated over a varying threshold $[0.1,0.3]$ (cf. Definition 2) to check the (dis)similarity of classifier outputs.

In our evaluation, we intend to check whether our directed strategy indeed improves the state-of-the-art test generation methodologies for arbitrary machine-learning models. However, to the best of our knowledge, there does not exist any directed strategy for grammar-based test input generation with the objective to uncover errors in such models. Thus, to evaluate the effectiveness of Ogma, we compare it with a strategy that randomly generates sentences (Random) conforming to the input grammar and employs differential testing as embodied within Ogma. We aim to show that if Ogma generates more error inducing inputs than Random, then it is a step forward in designing directed, yet scalable methods for grammar-based test input generation targeting arbitrary machine-learning models.

As observed in Table III, Ogma outperforms Random by a significant margin (up to 54%). We attribute this improvement to the directed test strategy integrated within Ogma. Specifically, Ogma discovers more erroneous inputs than Random by exploiting the robustness property of common machine-learning models and realising this via a focused search in the neighbourhood of already discovered erroneous inputs. To evaluate the effectiveness of Ogma in detail, we have answered the following research questions (RQs).

RQ1: Can the robustness property be leveraged for systematically testing real-world text classifiers?

Intuitively, robustness is a concept in machine learning which states that changing the input to any well trained machine learning model by some small value $\delta$ should not change the respective output dramatically. This means that similar inputs with similar outputs are likely to be clustered together. Thus, inputs similar to an error inducing input are also likely to lead to classification errors.

We present two cases (cf. Figure 8) where we have discovered clear indications of robustness playing a role in error discovery. In both Figure 8(a) and Figure 8(b), the graphs demonstrate whether a given test iteration leads to an error (output True) or not (output False). We have the following crucial observations from Figure 8. Firstly, we observe that once Ogma finds an error inducing input (e.g. around iteration 200 in Figure 8(a)), it continues to discover more error inducing inputs (e.g. approximately until iteration 300). This is because Ogma by design ensures to explore the neighbourhood of an input, whereas the robustness property of machine-learning models ensure that the neighbourhood of an error inducing inputs are likely to be error inducing too. Thus, Ogma discovers a stretch of error inducing inputs, as observed between iterations 200 to 300 in Figure 8(a). Secondly, we observe from Figure 8 that the directed search embodied in Ogma is useful in terms of steering the execution to errors. For example, even though Ogma discovers non-error inducing inputs, it can quickly revert to find error inducing inputs (e.g. approximately between iterations 300 and 350 in Figure 8(a)). Similar characteristics can also be observed in Figure 8(b). Due to the aforementioned characteristics, Ogma significantly outperforms the random test generation. This validates our hypothesis that robustness of well trained machine learning model can indeed be leveraged to design systematic and scalable test generation methodologies.

RQ2: How effective is Ogma in terms of generating error inducing inputs for a variety of real-world text classifiers?

We measure the effectiveness of Ogma as the ratio of the number of errors found with respect to the number of unique inputs generated (cf. Table III). On average the random approach discovers errors with a ratio of 0.7, 0.73 and 0.44 for the pairs of classifiers $\mathbb{R}$-$\mathbb{A}$, $\mathbb{U}$-$\mathbb{A}$, $\mathbb{R}$-$\mathbb{U}$, respectively. In comparison, the ratio of errors discovered via Ogma are 0.9, 0.87 and 0.68 respectively. Thus, on average, we observe that the directed search strategy embodied in Ogma improves the effectiveness of test generation by 33.68%.

RQ3: Does the effectiveness of Ogma depend on initial test input?

We validated whether the initial input plays a major role in the effectiveness of Ogma. To this end, we conducted two sets of experiments – one where the initial input induced an error (i.e. two classifiers under test had dissimilar outputs) and another where the initial input was not an error inducing input (i.e. two classifiers under the test had similar outputs). We discovered that the initial input does not play a major role in the effectiveness of Ogma. Figure 9 outlines our finding. Specifically, Figure 9 captures the average ratio of error inducing inputs discovered over all grammars and text classifiers.

In Figure 9, the effectiveness of random test generation (in terms of discovering error inducing inputs) improves marginally by 1.57% when initiated with an error inducing input. In general, the effectiveness of random test generation should be unaffected by the initial input, as each test input is generated independently. Concurrently, the effectiveness of Ogma also improves by a negligible 4.94% when the initial input is error inducing. Thus, we conclude that the initial input does not influence the effectiveness of our test generation methodologies significantly. However, as also seen in Figure 9, the relative improvement due to the directed strategy in Ogma, over the random test generation strategy, remains over 33% regardless of the category of initial input.

The effectiveness of OGMA depends on the number of iterations it takes to reach the first non-error-inducing input. Subsequently, OGMA employs a backtracking strategy to prevent the exploration of non-error-inducing input space. When OGMA starts exploration with a non-error inducing input, it takes some iterations to reach the first input that induces error (e.g. see the flat portion of the OGMA curve until iteration 100 in Figure 8). However, when starting with a non-error-inducing input, we note that OGMA randomly samples the input space to reach an error-inducing input. From the Law of Large Number (LLN) in probability theory and as observed in the previous work [41], we can find the error inducing input with high probability within a few sampling instances. The number of such sampling instances are usually negligible when compared with the substantial number of test inputs (e.g. 2000 test iterations) generated by OGMA. In our evaluation, it takes an average of only 25.22 iterations to get to the first error inducing input. As a result, even though OGMA takes a few test iterations initially to reach the error-inducing input (when started with a non-error-inducing input), the effectiveness of OGMA is essentially unaffected by the type of initial test input.

**RQ4: How sensitive is Ogma w.r.t. the threshold $J$ (cf. Definition 2) to check the similarity of classifier outputs? **

To answer this research question, we varied the threshold $J$ (cf. Definition 2) for grammar A (see Appendix). The initial input for the test generation led to a Jaccard Index $>0.15$, but $<0.3$. Thus, for threshold values $[0.05,0.15]$, the initial input was not error inducing, whereas for threshold $\geq 0.3$, the initial input was error inducing. Finally, the reported values in this experiments were averaged over all possible pairs of classifiers (i.e. $\mathbb{R}$-$\mathbb{A}$, $\mathbb{U}$-$\mathbb{A}$ and $\mathbb{R}$-$\mathbb{U}$).

A small Jaccard index threshold captures very low overlap between two classifier outputs. Thus, for Jaccard Index threshold 0.1, an error inducing input exhibits vastly dissimilar outputs between two classifiers. We recommend to set such low Jaccard Index threshold when the two classifier outputs are expected to have some dissimilarity. Thus, an error inducing input will capture scenarios where the dissimilarity is substantial. We recommend to set high Jaccard Index threshold when the level of tolerance in a classifier output is low (for example, in safety-critical domains). In such cases, even a small deviation in classifier outputs can be classified as errors. We leave the choice of Jaccard Index threshold to the user, as it might depend on the type of applications being targeted.

We observe a direct correlation between the chosen threshold $J$ and the effectiveness of Ogma (cf. Table V). In particular, a low threshold value for $J$ (cf. Definition 2) indicates that the tested classifier outputs have vastly dissimilar content. Thus, the lower the threshold $J$, the lower is also the probability to discover erroneous inputs. In other words, if we keep the threshold $J$ low, it is difficult for a random test generation strategy to discover error inducing inputs. As a result, for such scenarios, the directed test strategy in Ogma outperforms random test generation by a significant margin (up to 489%). In contrast, for a higher threshold $J$, even a slightly dissimilar classifier outputs might be categorized as errors. As such, for higher threshold (e.g. between 0.45 and 0.75), the effectiveness of Ogma and the random test generation strategy is similar.

Figure 10 provides the trend of discovered error inputs with respect to the threshold $J$. The number of errors found by Ogma is consistently higher than the random approach except for threshold value 0.45. For threshold value 0.45, random strategy is marginally better due to the ease of finding error inputs with high probability. The observations in Table V and in Figure 10 reveal that Ogma should be used for finding error inducing inputs where the error condition is strict (i.e. low threshold $J$ for the computed Jaccard Index). This is because such error inducing inputs are unlikely to be discovered via a random search, while Ogma can discover these inputs effectively by leveraging the robustness property of machine-learning models.

**RQ5: How sensitive is Ogma w.r.t. the chosen grammar? **

As discussed earlier in this section, we employ a directed search in the neighbourhood of an error inducing input. This is accomplished by only perturbing a leaf node of the derivation tree, yet keeping the structure of the derivation tree similar. As such, we have chosen grammars (see Appendix) to generate a substantial number of test inputs by perturbing only leaf nodes of the derivation tree for a given input.

We evaluate the effectiveness of Ogma for six different grammars chosen for our evaluation and our findings are demonstrated via Figure 11. For each set of experiments, we measure the ratio of error inducing inputs (with respect to the total number of generated inputs) discovered for both random testing and Ogma. As observed from Figure 11, our Ogma approach is consistently more effective than random test generation and its effectiveness is not compromised across a variety of grammars. Specifically, we obtain a maximum improvement of up to 94% (for classifiers $\mathbb{R}$-$\mathbb{U}$ and with Grammar C) and an average improvement of up to 33% across all grammars and classifiers.

Sensitivity to Grammars with a few terminal symbols:

Additionally, we have also evaluated the three pairs of classifiers on a input grammar with a few terminal symbols. This grammar, as seen in Figure 12 has very few terminal symbols. This grammar is used with our Ogma approach for 100 iterations. We aim to fine the number of unique inputs and the number of unique errors we can generate using this grammar. Intuitively, we do not expect the grammar with a few terminal symbols to be able to generate a lot of unique sentences because it has very few options for perturbations and it is likely that Ogma won’t be able to generate a lot of unique inputs.

We measure the unique inputs and unique errors generated as a percentage of the total number of inputs generated by Ogma. The data, as seen in Table VI shows that the grammar with a few terminal symbols produces on an average only 52% unique inputs, in contrast to an average of 96% for the other grammars (Grammars A - F) and 28% unique error inputs in comparison to the average of 79% unique error inputs of the “good” grammars (Grammars A - F).

RQ6: Does Ogma find errors for different use cases and classifiers?

To evaluate RQ6, we have evaluated the sentiment analysis tool provided by Google’s Natural Language API [5]. We have employed differential testing with Rosette’s sentiment analysis service [8]. The outputs of the Rosette API are [“POSITIVE”, “NEGATIVE”, “NEUTRAL”]. The Google API returns a score, $sc\in(-1,1)$ and magnitude, $mg\in(0,\infty)$. Using the Interpreting sentiment analysis values as a guide [6], we classify the output as [“NEGATIVE”], [“NEUTRAL”] and [“POSITIVE”] when $sc\in(-1,-0.25]$, $~{}sc\in(-0.25,0.25)$ and $sc\in[0.25,1)$, respectively. An input is considered an error if the outputs of the Google sentiment analysis API and Rosette sentiment analysis API are different.

We use this experiment to check OGMA’s differential testing capability. We present the result in Table VII. We run OGMA for 200 iterations and we evaluate three error discovery strategies as seen before, i.e., OGMA, random and OGMA with backtracking disabled. From Table VII, we observe that the results are in line with our findings in IAB classification use cases. Specifically, OGMA discovers the most number of errors, averaging an error ratio of 0.81 across the six grammars. The random and OGMA- No Backtrack strategies have an error ratio average of 0.29 and 0.37, respectively.

$\bm{\mu}$**RQ: Can we use the error inducing inputs generated by Ogma to improve the accuracy of classifiers? **

As part of this research question, we intend to check the usage of error inducing inputs generated by Ogma. A natural usage of these inputs is to retrain the classifier under test. Such a retraining can be accomplished by augmenting the training sets with the generated error inducing inputs. However, as we only had usage-level access to the text classifiers from Rosette, Aylien and uClassify, we were unable to retrain these classifiers. Thus, for this research question, we evaluated two classifiers from scikit-learn implementations of a regularized linear model with stochastic gradient descent and the multinomial Naive Bayes classifier. The objective of these classifiers is to classify a given sentence based on which grammar they were generated from. We used the following grammars seen in Figure 13 and Figure 14 in the evaluation:

Initially, the classification accuracy was 99.75% for the classifiers. Subsequently, we used Ogma to generate inputs such that the outputs of the chosen two classifiers are different. We add a sample of the generated erroneous test inputs into the training set and retrain the classifier. To generate the correct labels for the erroneous test inputs, we considered one classifier to be the oracle and assign the output generated by the oracle as the label. Subsequently, we train the other classifier with the augmented training set. It is important to note that there may be other ways (e.g. Transduction[21]) to find the ground truth labels, but investigating such methodologies is beyond the scope of this work.

Although in certain cases it might be possible to repair the machine-learning (ML) model with few representative inputs, we believe it is necessary to generate a significant number of erroneous inputs (when possible). This is because of two reasons. Firstly, the erroneous inputs generated by Ogma can be used to retrain the underlying ML algorithm and reduce its erroneous behaviour. The exact percentage of inputs that need to be added may depend on the application and the ML algorithm. In our evaluation, for example, augmenting the training set by 15% with the error inducing inputs led to the largest reduction in errors. Secondly, even though the repair might be achieved by a few representative error inputs, it is crucial to test the repaired model with a substantial number of error inducing inputs generated by Ogma. This is to check whether the repaired model indeed reduced the error rate. In the absence of a substantial number of error inducing inputs, the designer will not be able to validate a repaired model.

We generated 1000 test inputs via Ogma to discover the number of error inducing inputs before and after retraining. Since Ogma has randomness involved in its core, we repeated the test generation 50 times and take the average over all 50 iterations. Our findings are summarized in Table VIII. On average, Ogma generated 553 error inducing inputs (out of 1000) before retraining, whereas the number of error inducing inputs reduced to as low as 294 (i.e. 47.01% decrease) after the retraining. This experiment clearly shows that the test inputs generated by Ogma can be utilized to reduce the erroneous behaviours in classifiers.

Examples of Error Inducing Inputs

In this section, we introduce some of the interesting error inducing inputs automatically discovered by Ogma. For instance, consider the following sentence generated from one of our subject grammars:

[TABLE]

The text classifier $\mathbb{U}$ returns the following result (top three categories) where the first element in the pair captures the classification class (according IAB content Taxonomy Tier 1) and the second element captures the weight (i.e. a score reflecting how likely is the respective category):

’HOBBIES AND INTERESTS’, 0.371043 2. 2.

’SOCIETY’, 0.167253 3. 3.

’SPORTS’, 0.118665

Another classification for the example sentence

[TABLE]

leads to the following classification classes:

’SOCIETY’, 0.840454 2. 2.

’ARTS AND ENTERTAINMENT’, 0.159546 3. 3.

’SPORTS’, 6.65587$e^{-11}$

As observed from the preceding examples, the computed categories were clearly erroneous.

We contacted the developers of the service providers of text classifiers and pinpointed them to the erroneous inputs. Developers confirm that these are indeed erroneous behaviours of the classifiers. They also confirmed that the primary reason for such erroneous behaviours is that the respective classifiers were inadequately trained for the type of text inputs generated by Ogma. Thus, for these texts, the classifiers failed to provide a reasonable classification class. This experience clearly indicates the utility of Ogma, as the directed test strategy embodied within Ogma can rapidly discover such erroneous behaviours due to inappropriate training. Moreover, as observed in our $\bm{\mu}$RQ, Ogma can also augment the training set with the generated erroneous inputs. This, in turn, helps to improve the accuracy of classifiers, as observed in our experiments.

6 Related Work

In this section, we review the related literature and position our work on testing machine-learning systems.

Testing of machine-learning models: DeepXplore [36] is a whitebox differential testing algorithm for systematically finding inputs that can trigger inconsistencies between multiple deep neural networks (DNNs). The neuron coverage was used as a systematic metric for measuring how much of the internal logic of a DNNs had been tested. More recently, DeepTest [40] leverages metamorphic relations to identify erroneous behaviors in a DNN. The usage of metamorphic relations somewhat solves the limitation of differential testing, especially to lift the requirement of having multiple DNNs implementing the same functionality. A feature-guided black-box approach is proposed recently to validate the safety of deep neural networks [44]. This work uses their proposed method to evaluate the robustness of neural networks in safety-critical applications such as traffic sign recognition. DeepGauge [32] formalizes a set of testing criteria based on multi level and -granularity coverage for testing DNNs and measures the testing quality. Aequitas [41] aims to uncover fairness violations in machine learning models. DeepConcolic [38] designs a coherent framework to perform concolic testing for discovering violations of robustness. DeepHunter [45] and TensorFuzz [35] propose coverage guided fuzzing for Neural Networks.

Unlike adversarial text generation [31], the goal of Ogma is completely different. Ogma abstracts the input space via a grammar and explores the input space with the objective of generating erroneous inputs. As a result, the erroneous inputs generated by Ogma is not limited to only adversarial texts and they do not need to focus on semantic similarities. Nevertheless, it is possible for Ogma to explore semantically equivalent sentences, as long as they conform to the input grammar. Indeed, the set of sentences generated by Ogma captures a variety of texts and they are not restricted to unobservable input perturbations. Moreover, Ogma guarantees that the input perturbations still lead to valid input sentences (according to the grammar). Adversarial perturbations, e.g. TextBugger [31], might not guarantee the conformance with a grammar. Finally, Ogma does not need any seed input to commence test generation. Thus, in contrast to most adversarial testing, Ogma can work without seed inputs and also for models where the training data is sensitive.

The aforementioned works are either not applicable for structured inputs [41] or they require a set of concrete seed inputs to initiate the test generation process [36, 40, 44]. On the contrary, Ogma encodes input domain via grammars and systematically generates inputs conforming to the grammar by exploiting the robustness property. Due to the grammar-based input generation, Ogma can explore an input subspace that could be beyond the capability of techniques relying on concrete seed inputs. Presence of an input grammar is also common for several machine learning models, especially for models in the domain of text classification. Moreover, the objective of the works, as explained in the preceding paragraph, is largely to evaluate salient properties, e.g., fairness and robustness, of a given machine-learning model. In contrast, our Ogma approach is targeted to discover classification errors in machine-learning models in a generic fashion, while leveraging the robustness property of these well trained models.

Verification of Machine Learning models: AI2 [22] uses abstract interpretation to verify the robustness of a given input against adversarial perturbations. AI2 leverages zonotopes to approximate ReLU outputs. The authors guarantee soundness, but not precision. ReluVal [43] uses interval arithmetic [34] to estimate a neural network’s decision boundary by computing tight bounds on the output of a network for a given input range. The authors leverage this to verify security properties of a Deep Neural Network. Similarly, Reluplex [28] uses SMT solvers to verify these security properties. They present an SMT solver and encode properties of interest into this SMT solver. Dvijotham et al. [17] transform the verification problem into an unconstrained dual formulation using Lagrange relaxation and use gradient-descent to solve the respective optimization problem.

In contrast to these works, our Ogma approach has the flavor of testing. Specifically, our Ogma approach does not generate false positives, i.e., all witnesses generated by Ogma indeed capture erroneous behaviours in test classifier(s). Moreover, these witnesses generated by Ogma can be used to retrain the test classifiers and thus reducing the number of erroneous classifications.

Search based testing: Search-based testing has a long standing history in the domain of software engineering. Common techniques for search-based software testing are hill climbing, simulated annealing and genetic algorithms [33]. These have been applied extensively to test applications that largely fall in the class of deterministic software systems. With this work we aim to uncover ways to adapt these techniques to statistical software in general.

Choice of grammar-based equivalence: Grammar-based testing is applicable to a wide-range of real-world software, as observed in several existing works in the software engineering research community [23, 25]. These works, however, target traditional software (i.e. not ML-based applications). The objective of our work is a novel grammar-based testing that exploits the intrinsic properties in machine-learning systems. For several real-world software (e.g. malware detectors for Javascript), the grammars are already available. Moreover, for several real-world systems, existing works show that such grammars can be constructed with little manual effort [37] or they can even be mined automatically [26]. Thus, we believe that it is justifiable to rely on the presence of a grammar (encoding the input space) or to construct them with reasonable manual effort. In our evaluation, we can easily construct several grammars according to a template and they facilitate in discovering numerous errors in the NLP classifiers. In the future, such a grammar can be mined automatically, yet we believe that is orthogonal to the objective of our paper.

7 Threats to Validity

Choice of Grammar: Ogma implements a perturbation algorithm which perturbs the structure of the derivation tree of an input. The key requirement of Ogma is that there should be many inputs which have the same structure for their derivation trees. This is not possible with grammars that have only one terminal symbols in their production rules. A derivation tree constructed from such a grammar will not be perturbed by Ogma, and would lead to very restricted testing. However, the rationale behind perturbation in Ogma is to exploit the robustness property in machine-learning models for scalable testing. Specifically, we postulated that inputs having similar derivation tree structure are likely to be classified similarly and our empirical results validated this.

Robustness: Ogma is based on the hypothesis that the machine-learning models under test exhibit robustness. This is a reasonable assumption, as we expect the models under test to be deployed in real-world settings. As evidenced by our evaluation, Ogma approach, which is based on the aforementioned hypothesis, was effective to localize the search in the neighbourhood of regions exhibiting erroneous behaviours.

Complex Inputs:

Currently, Ogma only works on input domain encoded by context free grammars. This includes natural language processing tools (as evaluated in our work) and malware detectors targeting certain programming and scripting languages [42, 24], among others. The grammar helps us to encode a large number of inputs and explore the input space beyond the training set in a systematic fashion. In our evaluation, we can easily construct several grammars according to a template and they facilitate in discovering numerous errors in the NLP classifiers.

Ogma is not evaluated on more complex input structures such as images and videos. To adapt our Ogma approach for such complex inputs, a model that encodes these inputs is needed. This can be accomplished in a future extension of Ogma.

Size of Input Text: We have tested classifiers that are claimed to not perform well for short text. It was brought to our notice that the classifier models need more context for the task of classification. We cannot conclude the effectiveness of Ogma for longer texts. However, the open architecture of Ogma allows for extensive evaluation of grammars generating longer texts.

Incompleteness:

In our evaluation, we have tested Ogma for only up to 2000 iterations. It is possible that we have not captured all the test cases which induce errors. By design Ogma is not complete in terms of generating erroneous inputs.

8 Conclusion

In this paper, we present Ogma, a fully automated technique to generate grammar-based inputs which exhibit erroneous behaviours in machine learning based natural language processing models. At the core of Ogma lies a novel directed search technique. The key insight behind Ogma is to exploit the robustness property inherent in any well trained machine-learning model. Ogma provides comprehensive empirical proof for errors in text classifiers. To the best of our knowledge, Ogma is the only grammar-based machine learning testing solution to date. We provide a generic and modular framework to any user of our tool to extend the application of Ogma beyond classifiers. We also try and retrain a toy classifier models to show the potential use cases of these discovered erroneous behaviours.

Ogma directs the search process in the input space to maximise the number of errors found. These errors may not necessarily be due to the same defect of the model. Thus, we believe that Ogma is a powerful tool to discover erroneous inputs that may be caused due to a variety of defects embodied within the model. In other words, Ogma should be used as a testing tool for NLP models to discover errors. In its current state, Ogma is not capable to pin down the root cause in the model for a given erroneous input. This requires further development in the fault localisation research. In future, we plan to extend the capability of Ogma to automatically localise the cause of errors discovered in these machine learning based natural language processing models. It would also be desirable to integrate Ogma with a system that can determine the ground truth label of the discovered inputs (e.g. Transduction [21]) to effectively retrain the classifiers to alleviate the errors we have discovered.

Ogma lifts the state of the art by introducing a novel approach to testing for machine-learning models. We envision to extend Ogma beyond just text classifier testing and we hope it can be used to test any machine-learning model whose input domain can be formalised not only via grammars, but also via other techniques such as via leveraging logic based on satisfiability modulo theory (SMT). We would also like to extend Ogma to video and image inputs. We hope that the central idea behind our Ogma approach would influence the rigorous software engineering principles and help validate machine-learning applications. For reproducibility and advancing the state of research, we have made our tool and all experimental data publicly available:

https://github.com/sakshiudeshi/Ogma-Data https://github.com/sakshiudeshi/Ogma

Appendix A Grammars and Additional Graphs

In the appendix below we provide all the grammars that we used for testing and the additional experimental results that we obtained.