Learning Language Games through Interaction

Introduction

Wittgenstein (1953) famously said that language derives its meaning from use, and introduced the concept of language games to illustrate the fluidity and purpose-orientedness of language. He described how a builder B and an assistant A can use a primitive language consisting of four words—‘block’, ‘pillar’, ‘slab’, ‘beam’—to successfully communicate what block to pass from A to B. This is only one such language; many others would also work for accomplishing the cooperative goal.

This paper operationalizes and explores the idea of language games in a learning setting, which we call interactive learning through language games (ILLG). In the ILLG setting, the two parties do not initially speak a common language, but nonetheless need to collaboratively accomplish a goal. Specifically, we created a game called SHRDLURN,Demo: http://shrdlurn.sidaw.xyz in homage to the seminal work of Winograd (1972). As shown in Figure 1, the objective is to transform a start state into a goal state, but the only action the human can take is entering an utterance. The computer parses the utterance and produces a ranked list of possible interpretations according to its current model. The human scrolls through the list and chooses the intended one, simultaneously advancing the state of the blocks and providing feedback to the computer. Both the human and the computer wish to reach the goal state (only known to the human) with as little scrolling as possible. For the computer to be successful, it has to learn the human’s language quickly over the course of the game, so that the human can accomplish the goal more efficiently. Conversely, the human must also accommodate the computer, at least partially understanding what it can and cannot do.

We model the computer in the ILLG as a semantic parser (Section 3), which maps natural language utterances (e.g., ‘remove red’) into logical forms (e.g., $\texttt{remove}(\texttt{with}(\texttt{red}))$). The semantic parser has no seed lexicon and no annotated logical forms, so it just generates many candidate logical forms. Based on the human’s feedback, it performs online gradient updates on the parameters corresponding to simple lexical features.

During development, it became evident that while the computer was eventually able to learn the language, it was learning less quickly than one might hope. For example, after learning that ‘remove red’ maps to remove(with(red)), it would think that ‘remove cyan’ also mapped to remove(with(red)), whereas a human would likely use mutual exclusivity to rule out that hypothesis (Markman and Wachtel, 1988). We therefore introduce a pragmatics model in which the computer explicitly reasons about the human, in the spirit of previous work on pragmatics (Golland et al., 2010; Frank and Goodman, 2012; Smith et al., 2013). To make the model suitable for our ILLG setting, we introduce a new online learning algorithm. Empirically, we show that our pragmatic model improves the online accuracy by 8% compared to our best non-pragmatic model on the 10 most successful players (Section 5.3).

What is special about the ILLG setting is the real-time nature of learning, in which the human also learns and adapts to the computer. While the human can teach the computer any language—English, Arabic, Polish, a custom programming language—a good human player will choose to use utterances that the computer is more likely to learn quickly. In the parlance of communication theory, the human accommodates the computer (Giles, 2008; Ireland et al., 2011). Using Amazon Mechanical Turk, we collected and analyzed around 10k utterances from 100 games of SHRDLURN. We show that successful players tend to use compositional utterances with a consistent vocabulary and syntax, which matches the inductive biases of the computer (Section 5.2). In addition, through this interaction, many players adapt to the computer by becoming more consistent, more precise, and more concise.

On the practical side, natural language systems are often trained once and deployed, and users must live with their imperfections. We believe that studying the ILLG setting will be integral for creating adaptive and customizable systems, especially for resource-poor languages and new domains where starting from close to scratch is unavoidable.

Setting

We now describe the interactive learning of language games (ILLG) setting formally. There are two players, the human and the computer. The game proceeds through a fixed number of levels. In each level, both players are presented with a starting state $s\in\mathcal{Y}$, but only the human sees the goal state $t\in\mathcal{Y}$. (e.g. in SHRDLURN, $\mathcal{Y}$ is the set of all configurations of blocks). The human transmits an utterance $x$ (e.g., ‘remove red’) to the computer. The computer then constructs a ranked list of candidate actions $Z=[z_{1},\dots,z_{K}]\subseteq\mathcal{Z}$ (e.g., remove(with(red)), add(with(orange)), etc.), where $\mathcal{Z}$ is all possible actions. For each $z_{i}\in Z$, it computes $y_{i}=\llbracket z_{i}\rrbracket_{s}$, the successor state from executing action $z_{i}$ on state $s$. The computer returns to the human the ordered list $Y=[y_{1},\dots,y_{K}]$ of successor states. The human then chooses $y_{i}$ from the list $Y$ (we say the computer is correct if $i=1$). The state then updates to $s=y_{i}$. The level ends when $s=t$, and the players advance to the next level.

Since only the human knows the goal state $t$ and only the computer can perform actions, the only way for the two to play the game successfully is for the human to somehow encode the desired action in the utterance $x$. However, we assume the two players do not have a shared language, so the human needs to pick a language and teach it to the computer. As an additional twist, the human does not know the exact set of actions $\mathcal{Z}$ (although they might have some preconception of the computer’s capabilities).This is often the case when we try to interact with a new software system or service before reading the manual. Finally, the human only sees the outcomes of the computer’s actions, not the actual logical actions themselves.

We expect the game to proceed as follows: In the beginning, the computer does not understand what the human is saying and performs arbitrary actions. As the computer obtains feedback and learns, the two should become more proficient at communicating and thus playing the game. Herein lies our key design principle: language learning should be necessary for the players to achieve good game performance.

Let us now describe the details of our specific game, SHRDLURN. Each state $s\in\mathcal{Y}$ consists of stacks of colored blocks arranged in a line (Figure 1), where each stack is a vertical column of blocks. The actions $\mathcal{Z}$ are defined compositionally via the grammar in Table 1. Each action either adds to or removes from a set of stacks, and a set of stacks is computed via various set operations and selecting by color. For example, the action $\texttt{remove}(\texttt{leftmost}(\texttt{with}(\texttt{red})))$ removes the top block from the leftmost stack whose topmost block is red. The compositionality of the actions gives the computer non-trivial capabilities. Of course, the human must teach a language to harness those capabilities, while not quite knowing the exact extent of the capabilities. The actual game proceeds according to a curriculum, where the earlier levels only need simpler actions with fewer predicates.

We designed SHRDLURN in this way for several reasons. First, visual block manipulations are intuitive and can be easily crowdsourced, and it can be fun as an actual game that people would play. Second, the action space is designed to be compositional, mirroring the structure of natural language. Third, many actions $z$ lead to the same successor state $y=\llbracket z\rrbracket_{s}$; e.g., the ‘leftmost stack’ might coincide with the ‘stack with red blocks’ for some state $s$ and therefore an action involving either one would result in the same outcome. Since the human only points out the correct $y$, the computer must grapple with this indirect supervision, a reflection of real language learning.

Semantic parsing model

Following Zettlemoyer and Collins (2005) and most recent work on semantic parsing, we use a log-linear model over logical forms (actions) $z\in\mathcal{Z}$ given an utterance $x$:

Our features are $n$-grams (including skip-grams) conjoined with tree-grams on the logical form side. Specifically, on the utterance side (e.g., ‘stack red on orange’), we use unigrams ($\textit{`stack'},*,*$), bigrams ($\textit{`red'},\textit{`on'},*$), trigrams ($\textit{`red'},\textit{`on'},\textit{`orange'}$), and skip-trigrams ($\textit{`stack'},*,\textit{`on'}$). On the logical form side, features corresponds to the predicates in the logical forms and their arguments. For each predicate $h$, let $h.i$ be the $i$-th argument of $h$. Then, we define tree-gram features $\psi(h,d)$ for predicate $h$ and depth $d=0,1,2,3$ recursively as follows:

The set of all features is just the cross product of utterance features and logical form features. For example, if $x=\textit{`enlever tout'}$ and $z=\texttt{remove(all())}$, then features include:

Note that we do not model an explicit alignment or derivation compositionally connecting the utterance and the logical form, in contrast to most traditional work in semantic parsing (Zettlemoyer and Collins, 2005; Wong and Mooney, 2007; Liang et al., 2011; Kwiatkowski et al., 2010; Berant et al., 2013), instead following a looser model of semantics similar to (Pasupat and Liang, 2015). Modeling explicit alignments or derivations is only computationally feasible when we are learning from annotated logical forms or have a seed lexicon, since the number of derivations is much larger than the number of logical forms. In the ILLG setting, neither are available.

Generation/parsing.

We generate logical forms from smallest to largest using beam search. Specifically, for each size $n=1,\dots,8$, we construct a set of logical forms of size $n$ (with exactly $n$ predicates) by combining logical forms of smaller sizes according to the grammar rules in Table 1. For each $n$, we keep the $100$ logical forms $z$ with the highest score $\theta^{\mathsf{T}}\phi(x,z)$ according to the current model $\theta$. Let $Z$ be the set of logical forms on the final beam, which contains logical forms of all sizes $n$. During training, due to pruning at intermediate sizes, $Z$ is not guaranteed to contain the logical form that obtains the observed state $y$. To mitigate this effect, we use a curriculum so that only simple actions are needed in the initial levels, giving the human an opportunity to teach the computer about basic terms such as colors first before moving to larger composite actions.

The system executes all of the logical forms on the final beam $Z$, and orders the resulting denotations $y$ by the maximum probability of any logical form that produced it. We tried ordering based on the sum of the probabilities (which corresponds to marginalizing out the logical form), but this had the degenerate effect of assigning too much probability mass to $y$ being the set of empty stacks, which can result from many actions.

Learning.

When the human provides feedback in the form of a particular $y$, the system forms the following loss function:

Then it makes a single gradient update using AdaGrad (Duchi et al., 2010), which maintains a per-feature step size.

Modeling pragmatics

In our initial experience with the semantic parsing model described in Section 3, we found that it was able to learn reasonably well, but lacked a reasoning ability that one finds in human learners. To illustrate the point, consider the beginning of a game when $\theta=0$ in the log-linear model $p_{\theta}(z\mid x)$. Suppose that human utters ‘remove red’ and then identifies $z_{\texttt{rm-red}}=\texttt{remove}(\texttt{with}(\texttt{red}))$ as the correct logical form. The computer then performs a gradient update on the loss function (2), upweighting features such as $(\textit{`remove'},\texttt{remove})$ and $(\textit{`remove'},\texttt{red})$.

Next, suppose the human utters ‘remove cyan’. Note that $z_{\texttt{rm-red}}$ will score higher than all other formulas since the $(\textit{`remove'},\texttt{red})$ feature will fire again. While statistically justified, this behavior fails to meet our intuitive expectations for a smart language learner. Moreover, this behavior is not specific to our model, but applies to any statistical model that simply tries to fit the data without additional prior knowledge about the specific language. While we would not expect the computer to magically guess $\textit{`remove cyan'}\mapsto\texttt{remove}(\texttt{with}(\texttt{cyan}))$, it should at least push down the probability of $z_{\texttt{rm-red}}$ because $z_{\texttt{rm-red}}$ intuitively is already well-explained by another utterance ‘remove red’.

This phenomenon, mutual exclusivity, was studied by Markman and Wachtel (1988). They found that children, during their language acquisition process, reject a second label for an object and treat it instead as a label for a novel object.

To model mutual exclusivity formally, we turn to probabilistic models of pragmatics (Golland et al., 2010; Frank and Goodman, 2012; Smith et al., 2013; Goodman and Lassiter, 2015), which operationalize the ideas of Grice (1975). The central idea in these models is to treat language as a cooperative game between a speaker (human) and a listener (computer) as we are doing, but where the listener has an explicit model of the speaker’s strategy, which in turn models the listener. Formally, let $S(x\ |\ z)$ be the speaker’s strategy and $L(z\ |\ x)$ be the listener’s strategy. The speaker takes into account the literal semantic parsing model $p_{\theta}(z\mid x)$ as well as a prior over utterances $p(x)$, while the listener considers the speaker $S(x\mid z)$ and a prior $p(z)$:

where $\beta\geq 1$ is a hyperparameter that sharpens the distribution (Smith et al., 2013). The computer would then use $L(z\ |\ x)$ to rank candidates rather than $p_{\theta}$. Note that our pragmatic model only affects the ranking of actions returned to the human and does not affect the gradient updates of the model $p_{\theta}$.

Let us walk through a simple example to see the effect of modeling pragmatics. Table 2 shows that the literal listener $p_{\theta}(z\ |\ x)$ assigns high probability to $z_{\texttt{rm-red}}$ for both ‘remove red’ and ‘remove cyan’. Assuming a uniform $p(x)$ and $\beta=1$, the pragmatic speaker $S(x\ |\ z)$ corresponds to normalizing each column of $p_{\theta}$. Note that if the pragmatic speaker wanted to convey $z_{\texttt{rm-cyan}}$, there is a decent chance that they would favor ‘remove cyan’. Next, assuming a uniform $p(z)$, the pragmatic listener $L(z\ |\ x)$ corresponds to normalizing each row of $S(x\ |\ z)$. The result is that conditioned on ‘remove cyan’, $z_{\texttt{rm-cyan}}$ is now more likely than $z_{\texttt{rm-red}}$, which is the desired effect.

The pragmatic listener models the speaker as a cooperative agent who behaves in a way to maximize communicative success. Certain speaker behaviors such as avoiding synonyms (e.g., not ‘delete cardinal’) and using a consistent word ordering (e.g, not ‘red remove’) fall out of the game theory. Of course, synonyms and variable word order occur in real language. We would need a more complex game compared to SHRDLURN to capture this effect. For speakers that do not follow this strategy, our pragmatic model is incorrect, but as we get more data through game play, the literal listener $p_{\theta}(z\ |\ x)$ will sharpen, so that the literal listener and the pragmatic listener will coincide in the limit.

Online learning with pragmatics.

To implement the pragmatic listener as defined in (5), we need to compute the speaker’s normalization constant $\sum_{x}p_{\theta}(z\mid x)p(x)$ in order to compute $S(x\mid z)$ in (4). This requires parsing all utterances $x$ based on $p_{\theta}(z\ |\ x)$. To avoid this heavy computation in an online setting, we propose Algorithm 1, where some approximations are used for the sake of efficiency. First, to approximate the intractable sum over all utterances $x$, we only use the examples that are seen to compute the normalization constant $\sum_{x}p_{\theta}(z\mid x)p(x)\approx\sum_{i}p_{\theta}(z\mid x_{i})$. Then, in order to avoid parsing all previous examples again using the current parameters for each new example, we store $Q(z)=\sum_{i}p_{\theta_{i}}(z\mid x_{i})^{\beta}$, where $\theta_{i}$ is the parameter after the model updates on the $i^{th}$ example $x_{i}$. While $\theta_{i}$ is different from the current parameter $\theta$, $p_{\theta}(z\ |\ x_{i})\approx p_{\theta_{i}}(z\ |\ x_{i})$ for the relevant example $x_{i}$, which is accounted for by both $\theta_{i}$ and $\theta$.

In Algorithm 1, the pragmatic listener $L(z\mid x)$ can be interpreted as an importance-weighted version of the sharpened literal listener $p_{\theta}^{\beta}$, where it is downweighted by $Q(z)$, which reflects which $z$’s the literal listener prefers, and upweighted by $P(z)$, which is just a smoothed estimate of the actual distribution over logical forms $p(z)$. By construction, Algorithm 1 is the same as (4) except that it uses the normalization constant $Q$ based on stale parameters $\theta_{i}$ after seeing example, and it uses samples to compute the sum over $x$. Following (5), we also need $p(z)$, which is estimated by $P(z)$ using add-$\alpha$ smoothing on the counts $C(z)$. Note that $Q(z)$ and $C(z)$ are updated after the model parameters are updated for the current example.

Lastly, there is a small complication due to only observing the denotation $y$ and not the logical form $z$. We simply give each consistent logical form $\{z\mid\llbracket z\rrbracket_{s}=y\}$ a pseudocount based on the model: $C(z)\leftarrow C(z)+p_{\theta}(z\mid x,\llbracket z\rrbracket_{s}=y)$ where $p_{\theta}(z\mid x,\llbracket z\rrbracket_{s}=y)\propto\exp(\theta^{\mathsf{T}}\phi(x,z))$ for $\llbracket z\rrbracket_{s}=y$ (0 otherwise).

Compared to prior work where the setting is specifically designed to require pragmatic inference, pragmatics arises naturally in ILLG. We think that this form of pragmatics is the most important during learning, and becomes less important if we had more data. Indeed, if we have a lot of data and a small number of possible $z$s, then $L(z|x)\approx p_{\theta}(z|x)$ as $\sum_{x}p_{\theta}(z|x)p(x)\rightarrow p(z)$ when $\beta=1$.Technically, we also need $p_{\theta}$ to be well-specified. However, for semantic parsing, we would not be in this regime even if we have a large amount of training data. In particular, we are nowhere near that regime in SHRDLURN, and most of our utterances / logical forms are seen only once, and the importance of modeling pragmatics remains.

Experiments

Using Amazon Mechanical Turk (AMT), we paid 100 workers 3 dollars each to play SHRDLURN. In total, we have 10223 utterances along with their starting states $s$. Of these, 8874 utterances are labeled with their denotations $y$; the rest are unlabeled, since the player can try any utterance without accepting an action. 100 players completed the entire game under identical settings. We deliberately chose to start from scratch for every worker, so that we can study the diversity of strategies that different people used in a controlled setting.

Each game consists of 50 blocks tasks divided into 5 levels of 10 tasks each, in increasing complexity. Each level aims to reach an end goal given a start state. Each game took on average 89 utterances to complete. This number is not 50 because some block tasks need multiple steps and players are also allowed to explore without reaching the goal. It only took 6 hours to complete these 100 games on AMT and each game took around an hour on average according to AMT’s work time tracker (which does not account for multi-tasking players). The players were provided minimal instructions on the game controls. Importantly, we gave no example utterances in order to avoid biasing their language use. Around 20 players were confused and told us that the instructions were not clear and gave us mostly spam utterances. Fortunately, most players understood the setting and some even enjoyed SHRDLURN as reflected by their optional comments:

That was probably the most fun thing I have ever done on mTurk.

Wow this was one mind bending games [sic].

Metrics.

We use the number of scrolls as a measure of game performance for each player. For each example, the number of scrolls is the position in the list $Y$ of the action selected by the player. It was possible to complete this version of SHRDLURN by scrolling (all actions can be found in the first 125 of $Y$)—22 of the 100 players failed to teach an actual language, and instead finished the game mostly by scrolling. Let us call them spam players, who usually typed single letters, random words, digits, or random phrases (e.g. ‘how are you’). Overall, spam players had to scroll a lot: 21.6 scrolls per utterance versus only 7.4 for the non-spam players.

2 Human strategies

Some example utterances can be found in Table 3. Most of the players used English, but vary in their adherence to conventions such as use of determiners, plurals, and proper word ordering. 5 players invented their own language, which are more precise, more consistent than general English. One player used Polish, and another used Polish notation (bottom of Table 3).

Overall, we find that many players adapt in ILLG by becoming more consistent, less verbose, and more precise, even if they used standard English at the beginning. For example, some players became more consistent over time (e.g. from using both ‘remove’ and ‘discard’ to only using ‘remove’). In terms of verbosity, removing function words like determiners as the game progresses is a common adaptation. In each of the following examples from different players, we compare an utterance that appeared early in the game to a similar utterance that appeared later: ‘Remove the red ones’ became ‘Remove red.’; ‘add brown on top of red’ became ‘add orange on red’; ‘add red blocks to all red blocks’ became ‘add red to red’; ‘dark red’ became ‘red’; one player used ‘the’ in all of the first 20 utterances, and then never used ‘the’ in the last 75 utterances.

Players also vary in precision, ranging from overspecified (e.g. ‘remove the orange cube at the left’, ‘remove red blocks from top row’) to underspecified or requiring context (e.g. ‘change colors’, ‘add one blue’, ‘Build more blocus’, ‘Move the blocks fool’,‘Add two red cubes’). We found that some players became more precise over time, as they gain a better understanding of ILLG.

Most players use utterances that actually do not match our logical language in Table 1, even the successful players. In particular, numbers are often used. While some concepts always have the same effect in our blocks world (e.g. ‘first block’ means leftmost), most are different. More concretely, of the top 10 players, 7 used numbers of some form and only 3 players matched our logical language. Some players who did not match the logical language performed quite well nevertheless. One possible explanation is because the action required is somewhat constrained by the logical language and some tokens can have unintended interpretations. For example, the computer can correctly interpret numerical positional references, as long as the player only refers to the leftmost and rightmost positions. So if the player says ‘rem blk pos 4’ and ‘rem blk pos 1’, the computer can interpret ‘pos’ as rightmost and interpret the bigram $(\textit{`pos'},\textit{`1'})$ as leftmost. On the other hand, players who deviated significantly by describing the desired state declaratively (e.g. ‘red orange red’, ‘246’) rather than using actions, or a coordinate system (e.g. ‘row two column two’) performed poorly. Although players do not have to match our logical language exactly to perform well, being similar is definitely helpful.

As far as we can tell, all players used a compositional language; no one invented unrelated words for each action. Interestingly, 3 players did not put spaces between words. Since we assume monomorphemic words separated by spaces, they had to do a lot of scrolling as a result (e.g., 14.15 with utterances like ‘orangeonorangerightmost’).

3 Computer strategies

We now present quantitative results on how quickly the computer can learn, where our goal is to achieve high accuracy on new utterances as we make just a single pass over the data. The number of scrolls used to evaluate player is sensitive to outliers and not as intuitive as accuracy. Instead, we consider online accuracy, described as follows. Formally, if a player produced $T$ utterances $x^{(j)}$ and labeled them $y^{(j)}$, then

where $z^{(j)}=\arg\max_{z}p_{\theta^{(j-1)}}(z|x^{(j)})$ is the model prediction based on the previous parameter $\theta^{(j-1)}$. Note that the online accuracy is defined with respect to the player-reported labels, which only corresponds to the actual accuracy if the player is precise and honest. This is not true for most spam players.

To study the importance of compositionality, we consider two baselines. First, consider a non-compositional model (memorize) that just remembers pairs of complete utterance and logical forms. We implement this using indicator features on features $(x,z)$, e.g., $(\textit{`remove all the red blocks'},z_{\texttt{rm-red}})$, and use a large learning rate. Second, we consider a model (half) that treats utterances compositionally with unigrams, bigrams, and skip-trigrams features, but the logical forms are regarded as non-compositional, so we have features such as $(\textit{`remove'},z_{\texttt{rm-red}})$, $(\textit{`red'},z_{\texttt{rm-red}})$, etc.

Table 4 shows that the full model (Section 3) significantly outperforms both the memorize and half baselines. The learning rate $\eta=0.1$ is selected via cross validation, and we used $\alpha=1$ and $\beta=3$ following Smith et al. (2013).

Pragmatics.

Next, we study the effect of pragmatics on online accuracy. Figure 2 shows that modeling pragmatics helps successful players (e.g., top 10 by number of scrolls) who use precise and consistent languages. Interestingly, our pragmatics model did not help and can even hurt the less successful players who are less precise and consistent. This is expected behavior: the pragmatics model assumes that the human is cooperative and behaving rationally. For the bottom half of the players, this assumption is not true, in which case the pragmatics model is not useful.

Related Work and Discussion

Our work connects with a broad body of work on grounded language, in which language is used in some environment as a means towards some goal. Examples include playing games (Branavan et al., 2009, 2010; Reckman et al., 2010) interacting with robotics (Tellex et al., 2011, 2014), and following instructions (Vogel and Jurafsky, 2010; Chen and Mooney, 2011; Artzi and Zettlemoyer, 2013) Semantic parsing utterances to logical forms, which we leverage, plays an important role in these settings (Kollar et al., 2010; Matuszek et al., 2012; Artzi and Zettlemoyer, 2013).

What makes this work unique is our new interactive learning of language games (ILLG) setting, in which a model has to learn a language from scratch through interaction. While online gradient descent is frequently used, for example in semantic parsing (Zettlemoyer and Collins, 2007; Chen, 2012), we using it in a truly online setting, taking one pass over the data and measuring online accuracy (Cesa-Bianchi and Lugosi, 2006).

To speed up learning, we leverage computational models of pragmatics (Jäger, 2008; Golland et al., 2010; Frank and Goodman, 2012; Smith et al., 2013; Vogel et al., 2013). The main difference is these previous works use pragmatics with a trained base model, whereas we learn the model online. Monroe and Potts (2015) uses learning to improve the pragmatics model. In contrast, we use pragmatics to speed up the learning process by capturing phenomena like mutual exclusivity (Markman and Wachtel, 1988). We also differ from prior work in several details. First, we model pragmatics in the online learning setting where we use an online update for the pragmatics model. Second, unlikely the reference games where pragmatic effects plays an important role by design, SHRDLURN is not specifically designed to require pragmatics. The improvement we get is mainly due to players trying to be consistent in their language use. Finaly, we treat both the utterance and the logical forms as featurized compositional objects. Smith et al. (2013) treats utterances (i.e. words) and logical forms (i.e. objects) as categories; Monroe and Potts (2015) used features, but also over flat categories.

Looking forward, we believe that the ILLG setting is worth studying and has important implications for natural language interfaces. Today, these systems are trained once and deployed. If these systems could quickly adapt to user feedback in real-time as in this work, then we might be able to more readily create systems for resource-poor languages and new domains, that are customizable and improve through use.

Acknowledgments

DARPA Communicating with Computers (CwC) program under ARO prime contract no. W911NF-15-1-0462. The first author is supported by a NSERC PGS-D fellowship. In addition, we thank Will Monroe, and Chris Potts for their insightful comments and discussions on pragmatics.

Reproducibility

All code, data, and experiments for this paper are available on the CodaLab platform: https://worksheets.codalab.org/worksheets/0x9fe4d080bac944e9a6bd58478cb05e5e The client side code is here: https://github.com/sidaw/shrdlurn/tree/acl16-demo and a demo: http://shrdlurn.sidaw.xyz

Literatura