Explaining Queries over Web Tables to Non-Experts

08/14/2018 ∙ by Jonathan Berant, et al. ∙ Tel Aviv University 4

Designing a reliable natural language (NL) interface for querying tables has been a longtime goal of researchers in both the data management and natural language processing (NLP) communities. Such an interface receives as input an NL question, translates it into a formal query, executes the query and returns the results. Errors in the translation process are not uncommon, and users typically struggle to understand whether their query has been mapped correctly. We address this problem by explaining the obtained formal queries to non-expert users. Two methods for query explanations are presented: the first translates queries into NL, while the second method provides a graphic representation of the query cell-based provenance (in its execution on a given table). Our solution augments a state-of-the-art NL interface over web tables, enhancing it in both its training and deployment phase. Experiments, including a user study conducted on Amazon Mechanical Turk, show our solution to improve both the correctness and reliability of an NL interface.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 14

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Natural language interfaces have been gaining significant popularity, enabling ordinary users to write and execute complex queries. One of the prominent paradigms for developing NL interfaces is semantic parsing

, which is the mapping of NL phrases into a formal language. As Machine Learning techniques are standardly used in semantic parsing, a training set of question-answer pairs is provided alongside a target database

[4, 30, 22]. The parser is a parameterized function that is trained by updating its parameters such that questions from the training set are translated into queries that yield the correct answers.

A crucial challenge for using semantic parsers is their reliability. Flawless translation from NL to formal language is an open problem, and even state-of-the-art parsers are not always right. With no explanation of the executed query, users are left wondering if the result is actually correct. Consider the example in Figure 1, displaying a table of Olympic games and the question ”Greece held its last Olympics in what year?”. A semantic parser parsing the question generates multiple candidate queries and returns the evaluation result of its top ranked query. The user is only presented with the evaluation result, 2004. Although the end result is correct, she has no clear indication whether the question was correctly parsed. In fact, the interface might have chosen any candidate query yielding 2004. Ensuring the system has executed a correct query (rather than simply returning a correct answer in a particular instance) is essential, as it enables reusing the query as the data evolves over time. For example, a user might wish for a query such as ”The average price of the top 5 stocks on Wall Street” to be run on a daily basis. Only its correct translation into SQL will consistently return accurate results.

Our approach is to design provenance-based [10, 12] query explanations that are extensible, domain-independent and immediately understandable by non-expert users. We devise a cell-based provenance model for explaining formal queries over web tables and implement it with our query explanations, (see Figure 1). We enhance an existing NL interface for querying tables [37] by introducing a novel component featuring our query explanations. Following the parsing of an input NL question, our component explains the candidate queries to users, allowing non-experts to choose the one that best fits their intention. The immediate application is to improve the quality of obtained queries at deployment time over simply choosing the parser’s top query (without user feedback). Furthermore, we show how query explanations can be used to obtain user feedback which is used to retrain the Machine Learning system, thereby improving its performance.

: ”Greece held its last Olympics in what year?”
: {2004}

MAX(Year) Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro

: maximum value in column Year where Country is Greece.
Figure 1: Querying a table of Olympic games. Above, the user is only shown the final result, . Below, a candidate query is explained by utterance, and provenance-based highlights.

Setting

We focus on the task of explaining complex queries over web tables to non-expert users. Our solution employs explanations of formal queries to augment an existing state-of-the-art semantic parser [37]. The parser is used as the NL interface, mapping complex NL questions into queries over web tables. We test our solution on real-world data using the WikiTableQuestions benchmark dataset [30] which includes over 20,000 complex NL questions formulated by actual users on thousands of extracted web tables.

As our formal query language over tables we use lambda DCS, a standard query language in the NLP community [27, 4, 30]. We note that lambda DCS is geared towards queries one would write in a search engine – such as those in [4, 30] – rather than database ones, and as such, its queries receive a single table as their input. However, lambda DCS enables us to formulate highly complex queries supporting operations such as sorting, aggregation and intersection (see Tables 1 and 8 that contain complex NL questions that can be expressed as lambda DCS formulas).

Contributions

We first sought to provide a data provenance model for the lambda DCS query language. In order to align this model with previous works on data provenance we produced a mapping from lambda DCS to SQL. This enabled us to introduce a novel multilevel cell-based provenance model for lambda DCS. Our model was implemented through the use of provenance-based highlights. The table highlights serve as query explanations by providing a visual explanation for the underlying query execution (the table in Figure 1 shows the highlights for our example query). These provenance-based highlights are combined with a more conventional form of query explanation via NL utterances. Drawing on previous work [35], we design an extensible, domain independent context-free grammar that derives NL utterances describing lambda DCS queries. One of our key contributions is showing empirically that combining NL utterances with our provenance-based highlights greatly accelerates user understanding of complex queries.

We demonstrate the effectiveness of our query explanations by further enhancing a semantic parser for querying tables [37] and testing it against a benchmark dataset of thousands of complex NL questions [30]. At deployment, users are able to make an informed choice of the query, based on our explanation mechanism. We further leverage the use of explaining queries to users in order to retrain the semantic parser on procured user feedback. Feedback being pairs of NL questions and their correct query. This approach is in line with the human in the loop paradigm of users enhancing machine learning systems [21, 22].

User studies conducted via Amazon Mechanical Turk (AMT) clearly show our query explanations to be applicable to non-experts. Furthermore, user feedback was beneficial for improving the correctness of generated queries, when used both in deployment and in training time. During deployment, the correctness of obtained queries improved by over 30% compared to the fully automated process of outputting the top query computed by the baseline parser.

To summarize, the key contributions of our solution are:

  • Provenance Model. We present a novel provenance model for lambda DCS, an expressive query language which has been used in the context of Natural Language Processing question answering.

  • Query Explanations. We introduce novel provenance-based highlights for explaining queries over web tables.

  • Human in the loop. Our query explanations enable users to impact the parser choices and output. User feedback is crucial in improving the baseline parser when deployed and also for retraining it offline.

  • User Study. We show that our query explanations significantly improve the NL interface, while requiring minimal effort from non-expert users.

After reviewing our system (Section 2) and providing the necessary preliminaries in Section 3, we describe our multilevel provenance model in Section 4. Our query explanation methods are presented in Section 5. We discuss the concrete applications of our methods in Section 6 and measure their contribution via experiments and a user study in Section 7. We discuss related work in Section 8. In Section 9 we conclude and point to future work.

Question Table Attributes
What was the difference in engine size between Luigi Arcangeli and Louis Chiron? No., Driver, Entrant, Constructor, Chassis, Engine
The US and China are tied in total medal count. Which country has more silver medals, the US or China? Rank, Nation, Gold, Silver, Bronze, Total
How long did it take Jeff Lastennet to finish? Rank, Name, Nationality, Time, Notes, Points
What’s the total number of festivals that occurred in October? Date, Festival, Location, Awards
In what position did team Penske finish the first year a Honda engine was used? Year, Chassis, Engine, Start, Finish, Team
How many championships were in the $150,000 category? Result, Date, Category, Tournament, Surface, Partnering, Opponents, Score
Which position was recorded the most? Year, Competition, Venue, Position, Event, Notes
Which was the only episode to gain a 7 or higher rating? No., Episode, Air date, Rating, Share, 18-49 (Rating/Share), Viewers (m), Rank (night), Rank (timesolt), Rank (overall)
Table 1: WikiTableQuestions Examples

2 System Overview

We review our system architecture from Figure 2 and describe its general workflow.

Semantic Parser

Given an NL question and corresponding table, we use the state-of-the-art parser in [37] to parse the question into a set of candidate lambda DCS queries. The parser is trained for the task of querying web tables using the WikiTableQuestions dataset [30].

Query Explanations

Following the mapping of a question to a set of candidate queries, our interface will generate the relevant query explanations for each query, displaying a detailed NL utterance (Section 5.1) and highlighting the provenance data using Algorithm 1 (Section 5.2).

Deployment

Query explanations are presented to non-technical users to assist in selecting the correct formal-query representing the question.

Training on Feedback

User feedback in the form of question-query pairs is used offline in order to retrain the semantic parser.

Figure 2: System Architecture.

3 Preliminaries

We begin by formally defining our task of querying tables. Afterwards, we discuss the formal query language and show how lambda DCS queries can be translated directly into SQL.

3.1 Data Model

An NL interface for querying tables receives a question on a table and outputs a set of values as the answer (where each value is either the content of a cell, or the result of an aggregate function on cells). As discussed in the introduction, we make the assumption that a query concerns a single table.

Following the model presented in [30], all table records are ordered from top to bottom with each record possessing a unique (0, 1, 2, …). In addition, every record has a pointer to the record above it. The values of table cells can be either strings, numbers or dates. While we view the table as a relation, it is common [30, 37] to describe it as a knowledge base (KB) where is a set of entities and a set of binary properties. The entity set, is comprised of all table cells (e.g., Greece) and all table records, while contains all column headers, serving as binary relations from an entity to the table records it appears in. In the example of Figure 1, column Country is a binary relation such that Country.Greece returns all table records where the value of column Country is Greece (see definition of composition operators below). If the table in Figure 1 has records, the returned records indices will be .

3.2 Query Language

Following the definition of our data model we introduce our formal query language, lambda dependency-based compositional semantics (lambda DCS) [27, 4], which is a language inspired by lambda calculus, that revolves around sets. Lambda DCS was originally designed for building an NL interface over Freebase [5].

Language Operators

Lambda DCS is a highly expressive language, designed to represent complex NL questions involving sorting, aggregation intersection and more. It has been considered a standard language for performing semantic parsing over knowledge bases [27, 4, 30, 37]. A lambda DCS formula is executed against a target table and returns either a set of values (string, number or date) or a set of table records. We describe here a simplified version of lambda DCS that will be sufficient for understanding the examples presented in this paper. For a full description of lambda DCS, the reader should refer to [27]. The basic constructs of lambda DCS are as follows:

  • Unary: a set of values. The simplest type of unary in a table is a table cell, e.g., Greece, which denotes the set of cells containing the entity ’Greece’.

  • Binary: A binary relation describes a relation between sets of objects. The simplest type of a binary relation is a table column , mapping table entities to the records where they appear, e.g., Country.

  • Join: For a binary relation and unary relation , operates as a selection and projection. Country.Greece denotes all table records where the value of column Country is Greece.

  • Prev: Given records the operator will return the set of preceding table records, .

  • Reverse: Given a binary relation from to , there is a reversed binary relation R[] from to . E.g., for a column binary relation from table values to their records, R[] is a relation from records to values. R[Year].Country.Greece takes all the record indices of Country.Greece and returns the values of column Year in these records. Similarly, R[Prev] denotes a relation from a set of records, to the set of following (reverse of previous) table records.

  • Intersection: Intersection of sets. E.g., the set of records where Country is Greece and also where Year is 2004, Country.Greece Year.2004.

  • Union: Union of sets. E.g., records where the value of column Country is Greece or China, Country.Greece Country.China.

  • Aggregation: Aggregate functions min, max, avg, sum, count that take a unary and return a unary with one number. E.g., count(City.Athens) returns the number of records where the value of City is Athens.

  • Superlatives: argmax, argmin. For unary and binary , argmax(u,b) is the set of all values .

Compositional Operators

In this paper we use a group of predefined operators specifically designed for the task of querying tables [30]. The language operators are compositional in nature, allowing the semantic parser to compose several sub-formulas into a single formula representing complex query operations.

Example 3.1

Consider the following lambda DCS query on the table from Figure 1,

R[City].argmin(Record, Year)

it returns values of column City (binary) appearing in records (Record unary) that have the lowest value in column Year.

Mapping to SQL

To position our work in the context of relational queries we show lambda DCS to be an expressive fragment of SQL. The translation into SQL proves useful when introducing our provenance model by aligning our model with previous work [17, 12]. Table 10 (presented at the end of the paper) describes all lambda DCS operators with their corresponding translation into SQL.

Example 3.2

Returning to the lambda DCS query from the previous example, it can be easily translated to SQL as,
   SELECT City FROM T
   WHERE Index IN (
           SELECT Index FROM T
           WHERE Year = ( SELECT MIN(Year) FROM T ) );

where Index denotes the attribute of record indices in table . The query first computes the set of record indices containing the minimum value in column Year, which in our running example table is
{0}. It then returns the values of column City in these records, which is Athens as it is the value of column City at record 0.

Operator Query (lambda DCS) Example Translation Provenance
Column Values R[C].records R[Year].City.Athens ”value of column Year where City is Athens”

Aggregation on Values aggr(vals)
aggr {count, max, min, sum, avg}
sum(R[Year].City.Athens) ”the sum of values in column Year where City is Athens”

Difference of Values sub(R[C1].C2.v, R[C1].C2.u) sub(R[Year].City.London, R[Year].City.Beijing) ”the difference in column Year between London and Beijing”

Intersection of Records records1 records2 City.London Country.UK ”rows where value of City is London and also where value of Country is UK”

Table 2: Example provenance for several query operators

4 Provenance

The tracking and presentation of provenance data has been extensively studied in the context of relational queries [17, 12]. In addition to explaining query results [12], we can use provenance information for explaining the query execution on a given web table. We design a model for multilevel cell-based provenance over tables, with three levels of granularity. The model enables us to distinguish between different types of table cells involved in the execution process. This categorization of provenance cells serves as a form of query explanation that is later implemented in our provenance-based highlights (Section 5.2).

4.1 Model Definitions

Given query and table , the execution result, denoted by , is either a collection of table cells, or a numeric result of an aggregate or arithmetic operation.

We define to be the infinite domain of possible queries over , to be the set of table records, to be the set of table cells and denote by the set of aggregate functions, {min, max, avg, count, sum}.

Our cell-based provenance takes as input a query and its corresponding table and returns the set of cells and aggregate functions involved in the query execution. The model distinguishes between three types of provenance cells. There are the cells returned as the query output , cells that are examined during the execution, and also the cells in columns that are projected or aggregated on by the query. We formally define the following three cell-based provenance functions.

Definition 4.1

Let be a formal query and its corresponding table. We define three cell-based provenance functions, . Given the functions output a set of table cells and aggregate functions.

We use to denote an aggregate function or arithmetic operation on tables cells. Given the compositional nature of the lambda DCS query language, we define as the set of all sub-queries composing . We have used to denote the table columns that are either projected by the query, or that are aggregated on by it.

(1)
(2)
(3)

Function returns all cells output by or, if is the result of an arithmetic or aggregate operation, returns all table cells involved in that operation in addition to the aggregate function itself. returns cells and aggregate functions used during the query execution. returns all table cells in columns that are either projected or aggregated on by . These cell-based provenance functions have a hierarchical relation, where the cells output by each function are a subset of those output by the following function. Therefore, the three provenance sets constitute an ordered chain, where .

Having described our three levels of cell-based provenance, we combine them into a single multilevel cell-based model for querying tables.

Definition 4.2

Given formal query and table , the multilevel cell-based provenance of executed on is a function,

Returning the provenance chain,

4.2 Query Operators

Using our model, we describe the multilevel cell-based provenance of several lambda DCS operator in Table 2. Provenance descriptions of all lambda DCS operators are provided in Table 10 (at the end of the paper). For simplicity, we omit the table parameter from provenance expressions, writing instead of . We also denote both cells and aggregate functions as belonging to the same set.

We use to denote a table cell with value , while denoting specific cell values by . Each cell belongs to a table record, with a unique index, (Section 3.1). We distinguish between two types of lambda DCS formulas: formulas returning values are denoted by while those returning table records by .

Example 4.3

We explain the provenance of the following lambda DCS query,

R[Year].City.Athens

It returns the values of column Year in records where column City is Athens, thus will return all cells containing these values.

The cells involved in the execution of include the output cells in addition to the provenance of the sub-formula City.Athens, defined as all cells of column City with value Athens.

Where,

The provenance of the columns of is simply all cells appearing in columns Year and City.

The provenance rules used in the examples regard the lambda DCS operators of ”column records” and of ”column values”. The definition of the relevant provenance rules are described in the first two rows of Table 10.

5 Explaining Queries

To allow users to understand formal queries we must provide them with effective explanations. We describe the two methods of our system for explaining its generated queries to non-experts. Our first method translates formal queries into NL, deriving a detailed utterance representing the query. The second method implements the multilevel provenance model introduced in Section 4. For each provenance function () we uniquely highlight its cells, creating a visual explanation of the query execution.

5.1 Query to Utterance

Given a formal query in lambda DCS we provide a domain independent method for converting it into a detailed NL utterance. Drawing on the work in [35] we use a similar technique of deriving an NL utterance alongside the formal query. We introduce new NL templates describing complex lambda DCS operations for querying tables.

Example 5.1

The lambda DCS query,

R[Year].Country.Greece

is mapped to the utterance, ”value in column Year where column Country is Greece”. If we compose it with an aggregate function,

max(R[Year].Country.Greece)

its respective utterance will be composed as well, being ”maximum of values in column Year where column Country is Greece”. The full derivation trees are presented in Figure 3, where the original query parse tree is shown on the left, while our derived NL explanation is presented on the right.

We implement query to utterance as part of the semantic parser of our interface (Section 6.2). The actual parsing of questions into formal queries is achieved using a context-free grammar (CFG). As shown in Figure 3, formal queries are derived recursively by repeatedly applying the grammar deduction rules. Using the CYK [23] algorithm, the semantic parser returns derivation trees that maximize its objective (Section 6.2). To generate an NL utterance for any formal query, we change the right-hand-side of each grammar rule to be a sequence of both non-terminals and NL phrases. For example, grammar rule: (”maximum of” Values Entity) where Values, Entity and ”maximum of” are its non-terminals and NL phrase respectively. Table 3 describes the rules of the CFG augmented with our NL utterances. At the end of the derivation, the full query utterance can be read as the yield of the parse tree.

To utilize utterances as query explanations, we design them to be as clear and understandable as possible, albeit having a somewhat clumsy syntax. The references to table columns, rows as part of the NL utterance helps to clarify the actual semantics of the query to the non-expert users.

As the utterances are descriptions of formal queries, reading the utterance of each candidate query to determine its correctness might take some time. As user work-time is expensive, explanation methods that allow to quickly target correct results are necessary. We enhance utterances by employing provenance-based explanations, used for quickly identifying correct queries.

Figure 3: (a) The parser’s derivation tree of the formal query. (b) Our derived NL utterance explaining the query. Derivations are composed bottom-up.
Rule Example Utterance
Entity Values Athens.
”is at most” Entity Values is at most 17.
”rows where value in column” Binary ”is” Values Records rows where value in column City is Athens or London.
”values in column” Binary ”in rows” Records Values values of column Year in rows where value of column City is Athens.
”right above” Records Records right above rows where value of column City is Athens.
”the number of” Records Entity the number of rows where value of column City is Athens.
”maximum of” Values Entity maximum of values in column Year in rows where value of column City is Athens.
”difference in value of column” ValueFunc Values ”and” Values Values
Binary ”between rows where” Binary ”is” ValueFunc
difference in values of column Year between rows where values of column City is London and Beijing.
”in column” Binary ”what is the difference between rows with value” Entity ”and rows with value” Entity Values in column City, what is the difference between rows with value Athens and rows with value London.
Entity ”or” Entity Values China or Greece.
Records ”and also” Records Records rows where value of column City is London and also where value of column Country is UK.
Records ”that have the highest value in column” Binary Records rows that have the highest value in column Year.
”where it is the last row” Records Records where it is the last row in rows where value of column City is Athens.
”the value of” Values ”that appears the most in column” Binary Values the value of Athens or London that appears the most in column City.
”between” Values ”who has the highest value of column” Binary Values between London or Beijing who has the highest value of column Year.
Table 3: Parser grammar combined with utterances

5.2 Provenance to Highlights

The understanding of a table query can be achieved by examining the cells on which it is executed. We explain a query by highlighting its multilevel cell-based provenance (Section 4).

Using our provenance model, we define a procedure that takes a query as input and returns all cells involved in its execution on the corresponding table. These cells are then highlighted in the table, illustrating the query execution. Given a query and table , the procedure divides cells into four types, based on their multilevel provenance functions. To help illustrate the query, each type of its provenance cells is highlighted differently: Colored cells are equivalent to and are the cells returned by as output, or used to compute the final output. Framed cells are equivalent to and are the cells and aggregate functions used during query execution. Lit cells are equivalent to , and are the cells of columns projected by the query. All other cells are unrelated to the query, hence no highlights are applied to them.

Example 5.2

Consider the lambda DCS query,

The utterance of this query is, ”difference in column Total between rows where Nation is Fiji and Tonga”. Figure 6 displays the highlights generated for this query, lighting all of the query’s columns, framing its provenance cells and coloring the cells that comprise its output. In this example, all cells in columns Nation and Total are lit. The cells Fiji and Tonga are part of and are therefore framed. The cells in , containing 130 and 20, are colored as they contain the values used to compute the final result.

To highlight a query over the input table we call the procedure with . We describe our implementation in Algorithm 1. It is a recursive procedure which leverages the compositional nature of lambda DCS formulas. It decomposes the query into its set of sub-formulas , recursively computing the multilevel provenance. When reaching an atomic formula the algorithm will execute it and return its output. Cells returned by a sub-formula are both lit and framed, being part of and . Finally, all of the cells in (Equation 1) are colored.

Examples of provenance-based highlights are provided for several lambda DCS operators in Figures 6-6. We display highlight examples for all lambda DCS operators in Figures 22 - 22 (at the end of the paper).

1:procedure Highlight(, , )
2:      provenance sets
3:     
4:     if  then aggregate function
5:                
6:     if  is atomic then
7:          
8:     else
9:          
10:          for  do
11:               
12:                               
13:     for  do
14:          for  do
15:                               
16:     if  then
17:          ;
18:                
19:     return
Algorithm 1 Highlighting query cell-based provenance

We note that different queries may possess identical provenance-based highlights. Consider Figure 6 and the following query utterances,

  1. ”values in column Games that are more than 4.”

  2. ”values in column Games that are at least 5 and also less than 17.”

The highlights displayed on Figure 6 will be the same for both of the above queries. In such cases the user should refer to the NL utterances of the queries in order to distinguish between them. Thus our query explanation methods are complementary, with the provenance-based highlights providing quick visual feedback while the NL utterances serve as detailed descriptions.

Name Position Games Erich Burgener GK 3 Charly In-Albon DF 4 Andy Egli DF 6 Marcel Koller DF 2 Heinz Hermann MF 6 Lucien Favre MF 5
Figure 4: Comparison

rows where values of column Games are more than 4.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Figure 5: Superlative (values)

between London or Beijing who has the highest value of column Year.

Rank Nation Gold Total 1 New Caledonia 120 288 2 Tahiti 60 144 3 Papua New Guinea 48 121 4 Fiji 33 130 5 Samoa 22 73 6 Tonga 4 20
Figure 6: Difference (values)

difference in column Total between Fiji and Tonga.

5.3 Scaling to Large Tables

We elaborate on how our query explanations can be easily extended to tables with numerous records. Given the nature of the NL utterances, this form of explanation is independent of a table’s given size. The utterance will still provide an informed explanation of the query regardless of the table size or its present relations.

When employing our provenance-based highlights to large tables it might seem intractable to display them to the user. However, the highlights are meant to explain the candidate query itself, and not the final answer returned by it. Thus we can precisely indicate to the user what are the semantics of the query by employing highlights to a subsample of the table.

An intuitive solution can be used to achieve a succinct sample. First we use Algorithm 1 to compute the cell-based provenance sets and to mark the aggregation operators on relevant table headers. We can then map each provenance cell to its relevant record (table row), enabling us to build corresponding record sets, . To illustrate the query highlights we sample one record from each of the three sets: , and . In the special case of a query containing arithmetic difference (Figure 6), we select two records from , one for each subtracted value. Sampled records are ordered according to their order in the original table. The example in Figure 7 contains three table rows selected from a large web table [18].

”What was the highest growth rate of Madagascar in the 1980s?”

Row Country Year MAX(Growth Rate) 14266 Madagascar 1986 2.945 14270 Madagascar 1983 2.877 14454 Burkina Faso 2011 3.085
Figure 7: Scaling highlights to a large table by selecting three table rows.

6 Concrete Applications

So far we have described our methods for query explanations (Sections 5.1, 5.2) and we now harness these methods to enhance an existing NL interface for querying tables.

Deployment

When deployed, our interface is given a table and a corresponding user question. It parses the question, generating a set of candidate queries ranked by their likelihood of being correct. We display the top-k candidates to users using our explanations (utterances and highlights). The choice of is discussed in Section 7.2. Through the query explanations users can identify which queries are correct translations of the question, and which should be discarded. If no correct query was generated among the parser’s top-k candidates, the user should mark None. This allows users to choose which queries are to be executed, substituting the system-selected query when necessary and thereby improving its overall correctness.

Training on Feedback

User feedback is also used to enhance the system correctness through training. The mapping from NL to formal queries is learned by the semantic parser of [37], trained on a large scale dataset for querying web tables [30]. We improve the semantic parser by retraining it on pairs of questions and formal queries, marked as correct translations by users. While it is known that training a semantic parser on question-query pairs improves its performance [3], up until now the only way to achieve this was by relying on expert annotators. We are the first to illicit such annotations without any reliance on experts [3, 36, 22].

6.1 Implementation

We return to our system architecture from Figure 2. Presented with an NL question and corresponding table, our interface parses the question into lambda DCS queries using the state-of-the-art parser in [37]. The parser is trained for the task of querying web tables using the WikiTableQuestions dataset [30].

Following the mapping of a question to a set of candidate queries, our interface will generate relevant query explanations for each of the queries, displaying a detailed NL utterance and highlighting the provenance data. The explanations are presented to non-technical users to assist in selecting the correct formal-query representing the question.

User feedback in the form of question-query pairs is also used offline in order to retrain the semantic parser.

We briefly describe the benchmark dataset used in our framework and its relation to the task of querying web tables.

WikiTableQuestions Dataset

WikiTableQuestions [30] is a question answering dataset over semi-structured tables. It is comprised of question-answer pairs on HTML tables, and was constructed by selecting data tables from Wikipedia that contained at least 8 rows and 5 columns. Amazon Mechanical Turk workers were then tasked with writing trivia questions about each table. In contrast to common NLIDB benchmarks [22, 4, 26], WikiTableQuestions

contains 22,033 questions and is an order of magnitude larger than previous state-of-the-art datasets. Its questions were not designed by predefined templates but were hand crafted by users, demonstrating high linguistic variance. Compared to previous datasets on knowledge bases it covers nearly 4,000 unique column headers, containing far more relations than closed domain datasets

[26, 22] and datasets for querying knowledge bases [7]. Its questions cover a wide range of domains, requiring operations such as table lookup, aggregation, superlatives (argmax, argmin), arithmetic operations, joins and unions. The complexity of its questions can be shown in Tables 1 and 8.

The complete dataset contains 22,033 examples on 2,108 tables. As the test set, 20% of the tables and their associated questions were set aside, while the remaining tables and questions serve as the training set. The separation between tables in the training and test sets forces the question answering system to handle new tables with previously unseen relations and entities.

6.2 Training on Feedback

The goal of the semantic parser is to translate natural language questions into equivalent formal queries. Thus, in order to ideally train the parser, we should train it on questions annotated with their respective queries. However, annotating NL questions with formal queries is a costly operation, hence recent works have trained semantic parsers on examples labeled solely with their answer [9, 28, 4, 30]. This weak supervision facilitates the training process at the cost of learning from incorrect queries. Figure 8 presents two candidate queries for the question ”What was the last year the team was a part of the USL A-league?”. Note that both queries output the correct answer to the question, which is 2004. However, the second query is clearly incorrect given its utterance is ”minimum value in column Year in rows that have the highest value in column Open Cup”.

The WikiTableQuestions dataset, on which the parser is trained, is comprised of question-answer pairs. Thus by retraining the parser on question-query pairs, that are provided as feedback, we can improve its overall correctness. We address this in our work by explaining queries to non-experts, enabling them to select the correct candidate query or mark None when all are incorrect.

These annotations are then used to retrain the semantic parser. Given a question, its annotations are the queries marked as correct by users. We note that a question may have more than one correct annotation.

Semantic Parsing

Semantic Parsing is the task of mapping natural language questions to formal language queries (SQL, lambda DCS, etc.) that are executed against a target database. The semantic parser is a parameterized function, trained by updating its parameter vector such that questions from the training set are translated to formal queries yielding the correct answer.

We denote the table by and the NL question by . The semantic parser aims to generate a query which executes to the correct answer of on , denoted by . In our running example from Figure 1, the parser tries to generate queries which execute to the value 2004. We define as the set of candidate queries generated by parsing . For each we extract a feature vector and define a log-linear distribution over candidates:

(4)

where is the parameter vector. We formally define the parser distribution of yielding the correct answer,

(5)

where is 1 when and zero otherwise.

The parser is trained using examples , optimizing the parameter vector using AdaGrad [14] in order to maximize the following objective [30],

(6)

where

is a hyperparameter vector obtained from cross-validation. To train a semantic parser that is unconstrained to any specific domain we deploy the parser in

[37], trained end-to-end on the WikiTableQuestions dataset [30].

Semantic Parsing on Annotations

We modify the original parser so that annotated questions are trained using question-query pairs while all other questions are trained as before. The set of annotated examples is denoted by . Given annotated example , its set of valid queries is . We define the distribution for an annotated example to yield the correct answer by,

(7)

Where is 1 when and zero otherwise. Our new objective for retraining the semantic parser,

(8)

the first sum denoting the set of annotated examples, while the second sum denotes all other examples.

This enables the parser to update its parameters so that questions are translated into correct queries, rather than merely into queries that yield the correct answer.

Question: What was the last year the team was a part of the USL A-League?

Utterance: ”maximum value in column Year in rows where value of column League is USL A-League”

MAX(Year) League Attendance Open Cup 2002 USL A-League 6,260 Did not qualify 2003 USL A-League 5,871 Did not qualify 2004 USL A-League 5,628 4th Round 2005 USL First Division 6,028 4th Round 2006 USL First Division 5,575 3rd Round


Utterance: ”minimum value in column Year in rows that have the highest value in column Open Cup”

MIN(Year) League Attendance Open Cup 2002 USL A-League 6,260 Did not qualify 2003 USL A-League 5,871 Did not qualify 2004 USL A-League 5,628 4th Round 2005 USL First Division 6,028 4th Round 2006 USL First Division 5,575 3rd Round
Figure 8: Correct & incorrect query both returning the same answer

6.3 Deployment

At deployment, user interaction is used to ensure that the system returns formal-queries that are correct.

We have constructed a web interface allowing users to pose NL questions on tables and by using our query explanations, to choose the correct query from the top-k generated candidates. Normally, a semantic parser receives an NL question as input and displays to the user only the result of its top ranked query. The user receives no explanation as to why was she returned this specific result or whether the parser had managed to correctly parse her question into formal language. In contrast to the baseline parser, our system displays to users its top-k candidates, allowing them to modify the parser’s top query.

Example 6.1

Figure 9 shows an example from the WikitableQuestions test set with the question ”How many more ships were wrecked in lake Huron than in Erie”. Note that the original table contains many more records than those displayed in the figure. Given the explanations of the parser’s top candidates, our provenance-based highlights make it clear that the first query is correct as it compares the table occurrences of lakes Huron and Erie. The second result is incorrect, comparing lakes Huron and Superior, while the third query does not compare occurrences.

Question: How many more ships were wrecked in lake Huron than in Erie?

Utterance: ”in column Lake, what is the difference between rows with value Lake Huron and rows with value Lake Erie”

Ship Vessel Lake Lives lost Argus Steamer Lake Huron 25 lost Hydrus Steamer Lake Huron 28 lost Plymouth Barge Lake Michigan 7 lost Issac M. Scott Steamer Lake Huron 28 lost Henry B. Smith Steamer Lake Superior all hands Lightship No. 82 Lightship Lake Erie 6 lost


Utterance: ”in column Lake, what is the difference between rows with value Lake Huron and rows with value Lake Superior”

Ship Vessel Lake Lives lost Argus Steamer Lake Huron 25 lost Hydrus Steamer Lake Huron 28 lost Plymouth Barge Lake Michigan 7 lost Issac M. Scott Steamer Lake Huron 28 lost Henry B. Smith Steamer Lake Superior all hands Lightship No. 82 Lightship Lake Erie 6 lost


Utterance: ”the number of rows where value of column Lake is Lake Huron that have the highest value in column Lives lost”

Ship Vessel COUNT(Lake) Lives lost Argus Steamer Lake Huron 25 lost Hydrus Steamer Lake Huron 28 lost Plymouth Barge Lake Michigan 7 lost Issac M. Scott Steamer Lake Huron 28 lost Henry B. Smith Steamer Lake Superior all hands Lightship No. 82 Lightship Lake Erie 6 lost
Figure 9: Identifying the correct query through provenance-based highlights

7 Experiments

Following the presentation of concrete applications for our methods we have designed an experimental study to measure the effect of our query explanation mechanism. We conducted experiments to evaluate both the quality of our explanations, as well as their contribution to the baseline parser. This section is comprised of two main parts:

  • Interactive Parsing: We have deployed our NL interface online, explaining to users the top candidate queries generated for over 400 distinct questions. Our user study measured the impact of query explanations on choosing correct queries while also comparing the average work-time of users with and without our provenance-based highlights.

  • Training on Feedback: We stored user feedback as question-query pairs, and used it to retrain the system’s semantic parser. Experiments show an increase in parser correctness when trained on user feedback.

The experimental results show our query explanations to be effective, allowing non-experts to easily understand generated queries and to disqualify incorrect ones. Training on user feedback further improves the system correctness, allowing it to learn from user experience.

7.1 Evaluation Metrics

We begin by defining the system correctness

, used as our main evaluation metric. Recall that the semantic parser is given an NL question

and table and generates a set of candidate queries. Each query is then executed against the table, yielding result . We define the parser correctness as the percentage of questions where the top-ranked query is a correct translation of from NL to lambda DCS. In addition to correctness, we also measured the mean reciprocal rank (MRR), used for evaluating the average correctness of all candidate queries generated, rather than only that of the top-1.

Example 7.1

To illustrate the difference between correct answers and correct queries let us consider the example in Figure 8. The parser generates the following candidate queries (we present only their utterances):

  • maximum value in column Year in rows where value of column League is USL A-League.

  • minimum value in column Year in rows that have the highest value in column Open Cup.

Both return the correct answer 2004, however only the first query conveys the correct translation of the NL question.

7.2 Interactive Parsing at Deployment

We use query explanations to improve the real-time performance of the semantic parser. Given any NL question on a (never before seen) table, the parser will generate a set of candidate queries. Using our explanations, the user will interactively select the correct query (when generated) from the parser’s top-k results. We compare the correctness scores of our interactive method with that of the baseline parser.

User Study

Our user study was conducted using anonymous workers recruited through the the Amazon Mechanical Turk (AMT) crowdsourcing platform. Focusing on non-experts, our only requirements were that participants be over 18 years old and reside in a native English speaking country. Our study included 35 distinct workers, a significant number of participants compared to previous works on NL interfaces [12, 26, 24]. Rather than relying on a small set of NL test questions [12, 26] we presented each worker with 20 distinct questions that were randomly selected from the WikiTableQuestions benchmark dataset (Section 6.1). A total of 405 distinct questions were presented (as described in Table 4). For each question, workers were shown explanations (utterances, highlights) of the top-7 candidate queries generated. Candidates were randomly ordered, rather than ranked by the parser scores, so that users will not be biased towards the parser’s top query. Given a question, participants were asked to mark the correct candidate query, or None if no correct query was generated.

Displaying the top-k results allowed workers to improve the baseline parser in cases where the correct query was generated, but not ranked at the top. After examining different values of , we chose to display top-k queries with . We made sure to validate that our choice of was sufficiently large, so that it included the correct query (when generated). We randomly selected 100 examples where no correct query was generated in the top-7 and examined whether one was generated within the top-14 queries. Results had shown that for only 5% of the examples contained a correct query, a minor improvement at the cost of doubling user effort. Thus a choice of appears to be reasonable.

User Success

To verify that our query explanations were understandable to non-experts we measured each worker’s success. Results in Table 4 show that in 78.4% of the cases, workers had succeeded in identifying the correct query or identifying that no candidate query was correct. The average success rate for all 35 workers being 15.7/20 questions. When comparing our explanation approach (utterances + highlights) to a baseline of no explanations, non-expert users failed to identify correct queries when shown only lambda DCS queries. This demonstrates that utterances and provenance-based highlights serve as effective explanations of formal queries to the layperson. We now show that using them jointly is superior to using only utterances.

distinct questions explanations avg. success
405 2,835 78.4%


The number of distinct questions and candidate query explanations presented to users. Users successfully identified 78.4% of the explanations as being correct or incorrect.

Table 4: User Study - Success Rates

Work-time Results

When introducing our two explanation methods, we noted their complementary nature. NL utterances serve as highly detailed phrases describing the query, while highlighting provenance cells allows to quickly single out the correct queries. We put this claim to the test by measuring the impact our novel provenance-based highlights had on the average work-time of users. We measured the work-time of 20 distinct AMT workers, divided into two separate groups, each containing half of the participants. Workers from both groups were presented with 20 questions from WikiTableQuestions. The first group of workers were presented both with highlights and utterances as their query explanations, while the second group had to rely solely on NL utterances. Though both groups achieved identical correctness results, the group employing table highlights performed significantly faster. Results in Table 5 show our provenance-based explanations cut the average and median work-time by 34% and 20% respectively. Since user work-time is valuable, the introduction of visual explanations such as table highlights may lead to significant savings in worker costs.

method avg median min max
Utterances + Highlights 16.2m 16.6m 6.45m 22.5m
Utterances 24.7m 20.7m 17.5m 35.4m
Table 5: User Work-Time (minutes) on 20 questions

Correctness Results

We have examined the effect to which our query explanations can help users improve the correctness of a baseline NL interface. Our user study compares the correctness of three scenarios:

  • Parser correctness - our baseline is the percentage of examples where the top query returned by the semantic parser was correct.

  • User correctness - the percentage of examples where the user selected a correct query from the top-7 generated by the parser.

  • Hybrid correctness - correctness of queries returned by a combination of the previous two scenarios. The system returns the query marked by the user as correct; if the user marks all queries as incorrect it will return the parser’s top candidate.

Results in Table 6 show the correctness rates of these scenarios. User correctness score is superior to that of the baseline parser by 7.5% (from 37.1% to 44.6%), while the hybrid approach outscores both with a correctness of 48.7% improving the baseline by 11.6%. For the user and hybrid correctness we used a test to measure significance. Random queries and tables included in the experiment are presented in Table 8. We also include a comparison of the top ranked query of the baseline parser compared to that of the user.

We define the correctness bound as the percentage of examples where the top-k candidate queries actually contain a correct result. This bound serves as the optimal correctness score that workers can achieve. The 56% correctness-bound of the baseline parser stems from the sheer complexity of the WikiTableQuestions benchmark. Given the training and test tables are disjoint, the parser is tested on relations and entities unobserved during its training. This task of generalizing to unseen domains is an established challenge in semantic parsing [30, 38]. Using the correctness-bound as an upper bound on our results shows the hybrid approach achieves 87% of its full potential. Though there is some room for improvement, it seems reasonable given that our non-expert workers possess no prior experience of their given task.

Execution Times

We describe the execution times for generating our query explanations in Table 7. We trained the semantic parser using the SMEPRE toolkit [4] on a machine with Xeon 2.20GHz CPU and 256GB RAM running Linux Ubuntu 14.04 LTS. We report the average generation times of candidate queries, utterances and highlights over the entire WikiTableQuestions test set, numbering 4,344 questions.

correct examples correctness
Parser 260/700 37.1%
Users 312/700 44.6%
Hybrid 341/700 48.7%
Bound 392/700 56%


The sign indicates statistical significance compared to the Parser baseline at the 0.01 level using the

test (with 1 degree of freedom).

Table 6: User Study - Correctness Results
Questions Cand. Gen. Utter. Gen. Highlights Gen.
4,344 1.22 0.22 1.36
Table 7: Avg. Execution Time (seconds) on WikiTableQuestions
Question Table Attributes User explanation choice Parser baseline
What is the difference in number of defensive player of the year awards received by Gabriel Gervais and Mauricio Vincello? Year, MVP, Defensive Player of the Year, Unsung Hero, Newcomer of the Year in column Defensive Player of the Year, what is the difference between rows with value Mauricio Vincello and rows with value Gabriel Gervais in column Defensive Player of the Year, what is the difference between rows with value Mauricio Vincello and rows with value Mauricio Vincello
The next European team Haiti played after Spain on June 8, 2013 was which team? Date, Location, Opponent, Result, Competition values in column Opponent in rows right below rows where value of column Date is June 8 2013 values in column Opponent in rows right below rows where value of column Opponent is June 8 2013 or Spain
Who superseded lord high steward? Position, Officer, Current Officers, Superseded By, Royal Household values in column Superseded By in rows where value of column Officer is lord high steward values in column Royal Household in rows where value of column Officer is lord high steward
Who has won the least amount of medals? Rank, Nation, Gold, Silver, Bronze, Total values in column Nation in rows that have the lowest value in column Total between values in column Nation in rows, who has the lowest value of column Bronze out of the values in Nation
Who is older, Tatiana Abramenko or Myriam Asfry? Represent, Candidate, in Russian, Age, Height, Hometown between Myriam Asfry or Tatiana Abramenko, who has the highest value of column Age out of the values in Candidate between Myriam Asfry or Tatiana Abramenko, who has the lowest value of column Age out of the values in Candidate
The title of the last show was? No., Episode, Air date, Rating, Share, Viewers between values in column Episode in rows, who has the highest value of column Air date out of the values in Episode between values in column No. in rows, who has the highest value of column Air date out of the values in No.
Table 8: User Study - Questions and Answers

7.3 Training on User Feedback

We measure our system’s ability to learn from user feedback in the form of question-query pairs. Given a question, the user is shown explanations of the parser’s top-7 queries, using them to annotate the question, i.e. assign to it correct formal queries (e.g., the first query in Figure 8). Annotations were collected by displaying users with questions from the WikiTableQuestions training set along with query explanations of the parser results. To enhance the annotation quality, each question was presented to three distinct users, taking only the annotations marked by at least two of them as correct. Data collection was done using AMT and in total, 2,068 annotated questions were collected. Following a standard methodology, we split the annotated data into train and development sets. Out of our 2,068 annotated examples, 418 were selected as the development set, and 1,650 as the training set. The annotated development examples were used to evaluate the effect of our annotations on the parser correctness.

We experiment on two scenarios: (1) training the parser solely on 1,650 annotated examples; (2) integrating our training examples into the entire WikiTableQuestions training set of 11K examples. For each scenario we trained two parsers, one trained using annotations and the other without any use of annotations. To gain more robust results we ran our experiments on three different train/dev splits of our data, averaging the results. Table 9 displays the results of our experiments. When training solely on the annotated examples, parser correctness on development examples increased by 8% (41.8% to 49.8%). The spike in correctness shows that feedback acquired using our explanations is high-quality input for the semantic parser, hence the parser achieves better correctness when trained on it compared to training on the original WikiTableQuestions benchmark.

When training on all 11K train examples using our 1,650 annotations we also saw an increase (of 2.1%), albeit being more modest due to the percentage of annotated examples. We witnessed an increase in both correctness and MRR (mean reciprocal rank) that grows in the number of annotated train examples. This further asserts the significance of annotated training data [31, 36] and shows that our system can learn from quality feedback collected by non-experts.

train ex. annotations correctness MRR
1650 1650 49.8% 0.586
1650 0 41.8% 0.499
11000 1650 51.6% 0.60
11000 0 49.5% 0.570
Table 9: Effect of user feedback on correctness

8 Related Work

NL interfaces

Building a natural language interface (NLIDB) for querying databases has been extensively studied in the literature [25, 2, 32, 16, 26, 22]. Notably, NaLIR [26] is an NLIDB where users are presented explanations of candidate queries in the form of an intermediate representation, termed the query tree. Since we are geared towards non-experts, instead of a query tree representation, we explain parsed queries by highlighting their cell-based provenance while also providing detailed NL utterances.

Explaining formal queries in NL has been studied both on relational database schemas [24, 13] and KB systems [35]. Our domain independent utterances are comparable to the generic template of [24], however when challenged with complex queries, both methods are forced to return utterances which are quite long. The paper authors solve this by having users manually devise schema specific templates. We are able to leverage our adherence to single tables by providing provenance-based highlights to visually explain complex queries to non-experts. The evaluation of our query explanations was focused on the comprehension of non-experts, in contrast to the expert driven evaluation presented in [24]. Our user study empirically showed a joint approach of NL utterances and table highlights facilitates user understanding compared to explaining only through utterances [13].

NL utterances have also been used in the context of data exploration systems [33, 13]. The work in [33] compresses user query results and describes the resulting clusters in NL. We focus on an orthogonal task of explaining formal queries, in order improve a state-of-the-art semantic parser.

Machine learning systems for querying knowledge bases have long been the standard in NLP research. From systems for question answering over Freebase [4, 36], to NL interfaces mapping directly to SQL [22, 38]. The work in [37] presents a state-of-the-art semantic parser over the NLP community benchmark of WikiTableQuestions [30]. We further improve the correctness of the parser by integrating our query explanations into an NL interface over this dataset. The usage of procured user feedback to train semantic parsers was also pursued in recent works [36, 22]. However, both works rely on additional labeling by expert users (familiar in SQL, SPARQL), while our parser is trained solely from the feedback of its non-expert users. Our approach of utilizing user feedback to enhance the interface both at deployment and also in retraining the parser is a joint implementation of both database and NLP common practices [26, 22, 36].

Provenance

Provenance models have long been studied in the context of relational queries [6, 8, 11, 17, 19, 20]. The complexity of provenance expressions resulted in multiple approaches to represent provenance that is user-understandable. These include provenance in a graph form [1, 11, 15, 29, 34] and methods that present different ways of provenance visualization [20]. The work in [12] presents NLProv, an interface built on top of NaLIR complete with a provenance model for NL queries. Their solution however, is limited to handling Conjunctive Queries. The cell-based provenance we present supports further NL constructs such as union, aggregation, arithmetic difference and more. Our model is able to explain NL questions that show high diversity in structure and linguistic compositionality, tested on a benchmark NLP dataset for question answering over tables [30].

9 Conclusion and Future Work

We have studied in this paper the problem of explaining complex NL queries to non expert users. We introduced visual query explanations in the form of table highlights, based on a novel cell-based provenance model tested on web tables from hundreds of distinct domains. Table highlights provide immediate visual feedback for identifying correct candidate queries. We combine table highlights with utterance based query explanations, significantly improving their effectiveness. Using our query explanations we enhanced an NL interface for querying tables by providing it with feedback at both deployment and training time. Feedback is procured through query explanations, allowing users with no technical background to query tables with confidence, while simultaneously providing feedback to enhance the interface itself. We implement a human in the loop paradigm, where our users both exploit the underlying Machine Learning algorithm while providing it with further data to train on.

We have put our methods to the test, having conducted an extensive user study to determine the clarity of our explanations. Experimenting with explanations for hundreds of formal queries, users proved to be successful in interactively choosing correct queries, easily topping the baseline parser correctness. The addition of provenance-based highlights helps boost the efficacy of user feedback, cutting average work-time by a third compared to the utterances baseline.

Future Work

In our implementation, the retraining of the parser on user annotations is performed offline. In future work we aim to enable the parser to learn from users at run-time, via online learning techniques. Instead of asking the user to choose a query from the top-k results, or mark all of them as incorrect, an online parser may query the user until the correct query is generated. Such a system should be expected to learn interactively whether to return its top-ranked query, or seek further clarifications from the user.

Additional work might explore the impact of user understandable query explanations on semantic parsing tasks lacking strong supervision. As we described in Section 6.2 annotating questions with formal queries is a costly operation, hence recent works have trained parsers on questions labeled solely with their answer [9, 28, 4, 30]. By explaining the candidate queries of a baseline semantic parser non experts workers were able to annotate thousands of examples from the WikiTableQuestions dataset without any knowledge of the formal language in use. Explaining semantic parser candidate queries can be employed on other datasets, allowing non-experts to easily annotate significant amounts of the data. The positive impact of query annotations has been established in [36], hence by annotating weakly supervised datasets we will produce quality training data used to improve the accuracy of state-of-the-art parsers on a myriad of tasks.

Another direction worth exploring is attempting to significantly improve the WikiTableQuestions benchmark through use of our collected annotations and the introduction of new neural sequence-to-sequence models replacing the parser of [37] that we used. Neural models have shown great promise in semantic parsing tasks when trained on question-query pairs [22, 38]. We hope to improve benchmark results by using our approach to annotate most of WikiTableQuestions then a training state-of-the-art neural sequence-to-sequence on the collected data.

Operator Query (lambda DCS) Example Semantics (SQL) Provenance
Column Records C.v City.Athens SELECT * FROM T
WHERE C = ’v’;


Column Values R[C].records R[Year].City.Athens SELECT C FROM (records);

Values in Preceding Records R[C].Prev.records R[Year].Prev.City.
Athens
SELECT C FROM T
WHERE Index IN (
          SELECT Index-1
          FROM (records));


Values in Following Records R[C].R[Prev].
records
R[Year].R[Prev].City.
Athens
SELECT C FROM T
WHERE Index IN (
          SELECT Index+1
          FROM (records));


Aggregation on Values aggr(vals)
aggr {count, max, min, sum, avg}
sum(R[Year].City.
Athens)
SELECT AGGR(C) FROM (vals);

Difference of Values sub(R[C1].C2.v, R[C1].C2.u) sub(
R[Year].City.London, R[Year].City.Beijing)
(
SELECT C1 FROM T
WHERE Index IN(
          SELECT Index FROM T
          WHERE C2 = ’v’))
- (
SELECT C1 FROM T
WHERE Index IN(
          SELECT Index FROM T
          WHERE C2 = ’u’));


Difference of Value Occurrences sub(count(C.v), count(C.u)) sub(
count(City.Athens), count(City.London))
(
SELECT COUNT(Index) FROM T
WHERE C = ’v’)
- (
SELECT COUNT(Index) FROM T
WHERE C = ’u’);


Union of Values vals1 vals2 Country.China Country.Greece SELECT C FROM (vals1)
UNION
SELECT C FROM (vals2);


Intersection of Records records1 records2 City.London Country.UK SELECT * FROM T
WHERE Index IN (
          (SELECT Index FROM records1)
AND Index IN
          (SELECT Index FROM records2));


Records with Highest Value argmax(Record, x[C.x]) argmax(Record, x[Year.x]) SELECT * FROM T
WHERE C = (
          SELECT MAX(C) FROM T );


Value in Record with Highest Index R[C].argmax(
records, Index)
R[Year].argmax(City.
Athens, Index)
SELECT C FROM T
WHERE Index = (
          SELECT MAX(Index)
          FROM (records));


Value with Most Appearances argmax(vals, R[x.count(C.x)]) argmax(Athens London, R[x.count(City.x)]) SELECT C FROM T
WHERE Index = (
          SELECT COUNT(Index)
          FROM T
          WHERE C IN (vals)
          GROUP BY C
          ORDER BY COUNT(Index) DESC
          LIMIT 1);


Comparing Values argmax(vals, R[x.R[C1].C2.x]) argmax(London Beijing, R[x.R[Year].City.x]) SELECT DISTINCT C2 FROM T
WHERE C1 = (
          SELECT MAX(C1) FROM T
          WHERE C2 IN (vals));


Table 10: Lambda DCS Operators, SQL Translation and Provenance
Name Type Owner Sally Yacht Lyman Caprice Yacht Robinson Eleanor Yacht Clapp USS Lawrence Yacht U.S. Navy USS Macdonough Yacht U.S. Navy Jule Yacht J. Arthur lightship LV-72 Lightvessel U.S Lighthouse Board
Table 11: Simple Join

rows where value of column Name is Jule.

Name Position Games Club Erich Burgener GK 3 Servette Roger Berbig GK 3 Grasshoppers Charly In-Albon DF 4 Grasshopers Beat Rietmann DF 2 FC St. Gallen Andy Egli DF 6 Grasshoppers Marcel Koller DF 2 Grasshoppers Rene Botteron MF 1 FC Nuremburg Heinz Hermann MF 6 Grasshoppers Roger Wehrli MF 6 Grasshoppers Lucien Favre MF 5 Toulouse Servette
Table 12: Comparison

rows where values of column Games are more than 4.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 13: Reverse Join

values of column Year in rows where value of column City is Athens.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 14: Previous

values of column City right above rows where values of column City is London.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 15: Next

values of column City right below rows where values of column City is Athens.

Year Country COUNT(City) 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 16: Aggregation

the number of rows where value of column City is Athens.

Rank Nation Gold Silver Bronze Total 1 New Caledonia 120 107 61 288 2 Tahiti 60 42 42 144 3 Papua New Guinea 48 25 48 121 4 Fiji 33 44 53 130 5 Samoa 22 17 34 73 6 Nauru 8 10 10 28 7 Tonga 4 6 10 20
Table 17: Difference (values)

difference in column Total between Fiji and Tonga.

Temple Town Prefecture Iwaya-ji Kumakogen Ehime Prefecture Yakushi Nyorai Matsuyama Ehime Prefecture Amida Nyorai Matsuyama Ehime Prefecture Shaka Nyorai Matsuyama Ehime Prefecture Yakushi Nyorai Matsuyama Ehime Prefecture Yokomine-ji Saijo Ehime Prefecture Fudo Myoo Imabari Ehime Prefecture Jizo Bosatsu Imabari Ehime Prefecture
Table 18: Difference (occurrences)

in column Town, what is the difference between rows with value Matsuyama and rows with value Imabari.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 19: Union

values of column City where value of column Country is China or Greece.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 20: Intersection

values of column City where value of column Country is UK and also where value of column Year is 2012.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 21: Superlative (values)

between London or Beijing who has the highest value of column Year.

Year Country City 1896 Greece Athens 1900 France Paris 2004 Greece Athens 2008 China Beijing 2012 UK London 2016 Brazil Rio de Janeiro
Table 22: Superlative (occurrences)

the value that appears the most in column City.

References

  • [1] A. Ailamaki, Y. E. Ioannidis, and M. Livny. Scientific workflow management by database management. In SSDBM, 1998.
  • [2] I. Androutsopoulos, G. D. Ritchie, and P. Thanisch. Natural language interfaces to databases–an introduction. In Natural language engineering. Cambridge University Press, 1995.
  • [3] Y. Artzi and L. Zettlemoyer.

    Weakly supervised learning of semantic parsers for mapping instructions to actions.

    In TACL, 2013.
  • [4] J. Berant, A. Chou, R. Frostig, and P. Liang. Semantic parsing on Freebase from question-answer pairs. In EMNLP, 2013.
  • [5] K. Bollacker, C. Evans, P. Paritosh, T. Sturge, and J. Taylor. Freebase: a collaboratively created graph database for structuring human knowledge. In SIGMOD, 2008.
  • [6] P. Buneman, S. Khanna, and T. Wang-Chiew. Why and where: A characterization of data provenance. In ICDT, 2001.
  • [7] Q. Cai and A. Yates.

    Large-scale semantic parsing via schema matching and lexicon extension.

    In ACL, 2013.
  • [8] J. Cheney, L. Chiticariu, and W. C. Tan. Provenance in databases: Why, how, and where. In Foundations and Trends in Databases, 2009.
  • [9] J. Clarke, D. Goldwasser, M. Chang, and D. Roth. Driving semantic parsing from the world’s response. In CoNLL, 2010.
  • [10] S. B. Davidson, S. C. Boulakia, A. Eyal, B. Ludäscher, T. M. McPhillips, S. Bowers, M. K. Anand, and J. Freire. Provenance in scientific workflow systems. In IEEE Data Eng. Bull., 2007.
  • [11] S. B. Davidson and J. Freire. Provenance and scientific workflows: challenges and opportunities. In SIGMOD, 2008.
  • [12] D. Deutch, N. Frost, and A. Gilad. Provenance for natural language queries. In VLDB. VLDB Endowment, 2017.
  • [13] K. Dhamdhere, K. S. McCurley, R. Nahmias, M. Sundararajan, and Q. Yan. Analyza: Exploring data with conversation. In IUI, 2017.
  • [14] J. Duchi, E. Hazan, and Y. Singer. Adaptive subgradient methods for online learning and stochastic optimization. In Journal of Machine Learning Research, 2011.
  • [15] I. Foster, J. Vockler, M. Wilde, and Y. Zhao. Chimera: A virtual data system for representing, querying, and automating data derivation. In SSDBM, 2002.
  • [16] A. Giordani and A. Moschitti. Translating questions to SQL queries with generative parsers discriminatively reranked. In COLING, 2012.
  • [17] B. Glavic, R. J. Miller, and G. Alonso. Using sql for efficient generation and querying of provenance information. In In search of elegance in the theory and practice of computation. Springer, 2013.
  • [18] Google. Google bigquery public datasets. https://cloud.google.com/bigquery/public-data/.
  • [19] T. J. Green. Containment of conjunctive queries on annotated relations. In Theory of Computing Systems. Springer, 2011.
  • [20] M. Herschel and M. Hlawatsch. Provenance: On and behind the screens. In SIGMOD, 2016.
  • [21] A. Holzinger. Interactive machine learning for health informatics: when do we need the human-in-the-loop? Brain Informatics, 2016.
  • [22] S. Iyer, I. Konstas, A. Cheung, J. Krishnamurthy, and L. Zettlemoyer. Learning a neural semantic parser from user feedback. In ACL, 2017.
  • [23] T. Kasami. An efficient recognition and syntax-analysis algorithm for context-free languages. Coordinated Science Laboratory Report no. R-257, 1966.
  • [24] G. Koutrika, A. Simitsis, and Y. E. Ioannidis. Explaining structured queries in natural language. In ICDE, 2010.
  • [25] D. Kuepper, M. Storbel, and D. Roesner. Nauda: A cooperative natural language interface to relational databases. In SIGMOD, 1993.
  • [26] F. Li and H. Jagadish. Constructing an interactive natural language interface for relational databases. In VLDB. VLDB Endowment, 2014.
  • [27] P. Liang. Lambda dependency-based compositional semantics. 2013.
  • [28] P. Liang, M. Jordan, and D. Klein. Learning dependency-based compositional semantics. In ACL, 2011.
  • [29] T. Oinn, M. Addis, J. Ferris, D. Marvin, M. Senger, M. Greenwood, T. Carver, K. Glover, M. R. Pocock, A. Wipat, et al. Taverna: a tool for the composition and enactment of bioinformatics workflows. In Bioinformatics. Oxford University Press, 2004.
  • [30] P. Pasupat and P. Liang. Compositional semantic parsing on semi-structured tables. In ACL, 2015.
  • [31] H. Poon. Grounded unsupervised semantic parsing. In ACL, 2013.
  • [32] A. M. Popescu, O. Etzioni, and H. Kautz. Towards a theory of natural language interfaces to databases. In Proceedings of the 8th international conference on Intelligent user interfaces. ACM, 2003.
  • [33] T. Sellam and M. Kersten. Have a chat with clustine, conversational engine to query large tables. In HILDA, 2016.
  • [34] Y. L. Simmhan, B. Plale, and D. Gannon. Karma2: Provenance management for data-driven workflows. In Int. J. Web Service Res., 2008.
  • [35] Y. Wang, J. Berant, P. Liang, et al. Building a semantic parser overnight. In ACL, 2015.
  • [36] W. T. Yih, M. Richardson, C. Meek, M. W. Chang, and J. Suh. The value of semantic parse labeling for knowledge base question answering. In ACL, 2016.
  • [37] Y. Zhang, P. Pasupat, and P. Liang. Macro grammars and holistic triggering for efficient semantic parsing. In EMNLP, 2017.
  • [38] V. Zhong, C. Xiong, and R. Socher.

    Seq2sql: Generating structured queries from natural language using reinforcement learning.

    2017.