Scaffolding Networks: Incremental Learning and Teaching Through Questioning

TL;DR

The paper presents a novel incremental learning paradigm using a teacher-student neural network architecture that improves reasoning and understanding through sequential questioning and reinforcement learning.

Contribution

It introduces the scaffolding network framework that enables machines to learn reasoning incrementally via interactive questioning and reinforcement learning, outperforming existing methods.

Findings

Outperforms state-of-the-art methods on synthetic and real datasets

Learns reasoning in a scalable way with minimal human input

Demonstrates effective incremental learning through question-answer interactions

Abstract

We introduce a new paradigm of learning for reasoning, understanding, and prediction, as well as the scaffolding network to implement this paradigm. The scaffolding network embodies an incremental learning approach that is formulated as a teacher-student network architecture to teach machines how to understand text and do reasoning. The key to our computational scaffolding approach is the interactions between the teacher and the student through sequential questioning. The student observes each sentence in the text incrementally, and it uses an attention-based neural net to discover and register the key information in relation to its current memory. Meanwhile, the teacher asks questions about the observed text, and the student network gets rewarded by correctly answering these questions. The entire network is updated continually using reinforcement learning. Our experimental results on synthetic and real datasets show that the scaffolding network not only outperforms state-of-the-art methods but also learns to do reasoning in a scalable way even with little human generated input.

Tables

Table 1. Table 1: Error Rates on Travel Log test data. Larger number of attractions implies harder tasks.

Attractions	#Action	LSTM	MemN2N	Ent-Net	SN	SN-no-imp	SN-no-att
5	9	41.1	15.6	16.6	18.8	20.1	35.0
10	14	63.6	41.4	40.7	40.0	41.1	59.2
15	19	88.5	59.4	58.4	56.3	58.6	78.3
20	24	90.8	70.4	69.3	67.2	68.5	83.9
25	29	95.5	79.4	78.5	75.1	76.2	89.5

Table 2. Table 2: A sample output from scaffolding network inference on travel log. The numbers in parenthesis indicate which sentences the teacher used to generate the questions. The bolded question (20) is corpus provided question.

Sentences in Travel Log	Importance	Teacher’s Question	Student Action	Reward
1: i am at the museum	0.009
2: the school on my east	0.015	(2) what is on my east ?	school	1
3: i am heading to south	0.019	(1) where am i at ?	museum	1
4: the coffee-shop on the south of museum	0.22	(4) what is on the south of the museum ?	coffee-shop	1
5: the parliament is on my north	0.028	(1) where am i at ?	museum	1
6: i am heading south towards train-station	0.24	(6) where am i heading south towards ?	train-station	1
7: after leaving the museum, i reached train-station	0.47	(7) where did i reach ?	train-station	1
8: i am heading east	0.47	(2) what is the school on ?	east	1
9: school is on my north	0.48	(2,9) what is on my east ? what is on my north ?	school	1
10: the coffee-shop on my east	0.53	(4,10) what is on the south of the museum ? what is on my east ?	school	-1
11: the coffee-shop on my east	0.55	(10) what is on my east ?	coffee-shop	1
12: the park is on my east	0.28	(1,4) where am i at ? what is the coffee-shop south of ?	parliament	-1
13: the park is on my east	0.57	(2,13) what does the school on ? what does the park on ?	east	1
14: i am heading to east again	0.58	(2) what is th school on ?	east	1
15: the school on my north	0.64	(5,15) what is parliament on ? what is school on ?	north	1
16: i just arrived to the park	0.68	(4,7) what is the coffee-shop south of ? where did i leave ?	museum	1
17: i see a restaurant on my south	0.29	(2,9) what is on my east ? what is on my north ?	school	1
18: coffee shop is on my west	0.62	(4,18) what is on the south of the museum? what is on my west?	coffee-shop	1
19: i am walking towards the restaurant	0.75	(17,19) what do i see on my south ? what i am walking towards ?	restaurant	1
20: what is west of the park ?			coffee-shop	9

Table 3. Table 3: Error Rates on Babi Dialog and DSTC2 dialog datasets Bordes & Weston, ( 2017 ) with and without match features.

	#Action	No-Match Features				With Match Features
Task	$\left|𝒞\right|$	N2N	QRN	GMemN2N	SN	N2N	QRN	GMemN2N	SN
1: Issuing API Calls	309	0.1	0.0	0.0	0.0	0.0	0.0	0.0	0.0
2: Updating API Calls	307	0.0	0.0	0.0	0.0	1.7	0.0	0.0	0.0
3: Displaying Options	333	25.1	12.6	25.1	12.0	25.1	7.6	25.1	5.6
4: Providing Extra Information	1036	40.5	14.3	42.8	14.2	0.0	0.0	0.0	0.0
5: Conducting Full Dialogs	1257	3.9	0.7	3.7	3.4	6.6	0.0	2.0	1.0
Average Error Rates (%)		13.9	5.5	14.3	5.9	6.7	1.5	5.4	1.3
1: (OOV) Issuing API Calls	309	27.7	6.6	17.6	5.6	3.5	0.0	0.0	1.2
2: (OOV) Updating API Calls	307	21.1	8.4	21.1	10.8	5.5	0.0	5.8	0.8
3: (OOV) Displaying Options	333	25.6	12.4	24.7	10.2	24.8	7.7	24.9	6.0
4: (OOV) Providing Extra Inform.	1036	42.4	14.4	43.0	23.3	0.0	0.0	0.0	0.0
5: (OOV) Conducting Full Dialogs	1257	34.5	13.7	33.3	14.6	22.3	4.0	20.6	2.6
Average Error Rates		30.3	11.1	26.9	12.9	11.2	2.3	10.3	2.1
DSTC-2 Real Dialogs	1257	58.9	48.9	52.6	47.6	59.0	49.3	51.3	48.7

Equations

$${\mathbf{m}}_t\leftarrow \varphi (W^x{\mathbf{H}}_t+W^h{\mathcal{M}}_t\otimes {\mathbf{I}}_n),$$

$$g_t$$

$${\mathcal{M}}_{t+1}$$

$${\tilde{\mathbf{h}}}_{t,0}\leftarrow f({\mathcal{M}}_t,{\mathbf{h}}_t^q);{\tilde{\mathbf{h}}}_{t,i}\leftarrow f({\mathbf{h}}_{t,i}+{\mathbf{h}}_t^q);{\mathbf{o}}_t\leftarrow \mathrm{LSTM}({\tilde{\mathbf{h}}}_{t,0},{\tilde{\mathbf{h}}}_t)$$

$$I(x_t)$$

Full text

1 Introduction

Today’s machines are mostly designed to understand human language from written or spoken text. Most related work has used fixed training data of labeled text focusing on learning lower-level semantics in sentences (such as semantic tagging or parsing), later to be expanded to higher-level semantics in documents or dialogs (such as sentiment detection, question-answering, machine translation or task completion dialogs). Nevertheless, real human learning is incremental, repetitive, compositional, and is enhanced through interaction with a teacher or other humans. New and exciting work has recently started to emerge that use human-like learning, e.g., dialog-based language understanding Weston, (2016), interactive language learning Wang et al., (2016), compositional learning Andreas et al., (2016); Yu et al., (2017), to name a few.

In this work, we explore teaching machines to learn concepts as conveyed in text with a new architecture that uses an incremental learning framework. We draw inspiration from real-life instructional scaffolding teaching Kim, (2010); Hogan & Pressley, (1997), a process through which a teacher adds support for students to enhance learning. A common method in scaffolding teaching is to repeatedly question students to check for understanding, which systematically builds on students’ experiences and knowledge. We present a neural network architecture that imitates scaffolding teaching for understanding text and do reasoning.

The Scaffolding Network (SN) is comprised of a teacher and a student sharing the same environment, and combines several features into a single, effective network. The student observes text one sentence at a time, which contains limited or partial information about the state of the world; no prior information of entities, slots or relations between them is provided. Its goal is to perform sentence-level interpretation, using a recurrent memory structure and attention mechanism to track the changes of facts over the course of story or dialog, and identify new ones that has not been observed before. Meanwhile, the teacher, being a companion, generates question-answer pairs related to the text observed so far and poses these questions to the student. Observing a sentence and a question, the student consequently learns to encode and answer the question based on the reward signal it receives from the environment. We adopt a reinforcement learning (RL) framework which provides an ideal setting for step by step teaching of semantic understanding. The student aims to maximize its rewards that it obtains upon answering generated questions. Our contributions are:

• •

We present a neural network model, which introduces a teacher-student framework to incrementally learn and reason about the state of the world by extracting and registering the facts that are partially observable. Our models are scalable due to incremental encoding of each sentence.

• •

We introduce a teacher that can generate scaffolding question-answer pairs and guides the student to accurately estimate the relations between facts and their changing states.

• •

We evaluate the usefulness of our approach against baseline supervised learning models on story-based reasoning and dialog tasks. We show promising improvements on reasoning about objects and their relations, especially when we reduce the human generated input.

2 Related Work

We draw particular inspiration for scaffolding networks from Weston’s dialog-based language learning approach, which gets feedback from a teacher and various other signals while the student imitates such feedback in order to learn to answer questions Weston, (2016). Li et al. presents a conversational agent that gets feedback from a human teacher based on its response to improve question answering skills Li et al., (2017). Another recent work Guo et al., (2017) uses dialog-based interactive learning in which an agent iteratively asks questions about relevant missing facts, so it learns to correctly answer a target question. Several memory networks expansions have also shown promising improvements on dialog datasets Bordes & Weston, (2017); Seo et al., (2017); Perez & Liu, (2016). Unlike these work, which mainly search for clues about a particular question, our goal is to learn to encode the entire text incrementally to do reasoning and learn to answer as many questions as possible. Also, the key to our approach is that the teacher helps student focus on the state changes of entities and register into the episode memory, which was not fully explored in these work.

Another inspiration of this work is from the incremental learning framework in which the input text is received in sequences of sentences and encoded separately. While Shen et al., (2016) uses an Markov Decision Process (MDP) framework to learn when to stop reading to answer a focused question, Boyd-Graber et al., (2015) builds an incremental classifier for a trivia game to decide whether additional features are needed. The closest to our work is the Recurrent Entity Networks Henaff et al., (2017), in which the authors try to learn an internal state representation of each sentence in a sequential order and store in memory by parallel recurrent units with tied weights using gating functions. Although our network’s structure has similarities, they use supervised objective while we view the task as an MDP Zubek & Dietterich, (2002), in which our agent choses its actions to maximize its rewards towards learning to encode text by answering teacher’s questions.

3 The Scaffolding Networks

The scaffolding networks (Figure 1) comprise of a teacher and a student sharing an environment. The environment provides the student and the teacher the sentences from input text one at a time. The teacher component generates scaffolding question-answer pairs about the input text observed so far. Contrary to the teacher-student framework literature Suay & Chernova, (2011); Zimmer et al., (2014), our teacher is not a RL agent that directly influences student in taking actions. Our teacher guides the student to focus on parts of the text which might be harder for the student to extract information.

The student observes a sentence from the environment and a question from the teacher at time $t$. It starts in an initial state (no memory), encodes the sentence together with its current memory using attention network, thereby enabling reasoning over entailments of pairs of memory cells. This way the student identifies new information to register into memory. Meanwhile, it processes the sentence together with the posed question to capture similarities. It aims to maximize the sum of all rewards until the end of the document is reached by correctly answering as many questions as possible in an episode through trial and error via RL algorithm. Depending on student’s answer (the action), the environment moves on to provide the next sentence (if the answer is correct), or stays on providing the same sentence until the student learns to answer one question correctly (or until maximum trials are exhausted), while the teacher generates a new question each time. We denote the episode as a sequence of time steps from an initial state (the first sentence in text) to a terminal state (the end of document is reached or as set by the environment). The input to the scaffolding network is an input text, $\mathcal{X}$, of a sequence of sentences: $\mathcal{X}=(x_{1},\ldots,x_{T})$ denoting the environment from which the student receives sentences incrementally during the course of the episode. Each sentence at time $t$ is a sequence of $n$ words, $x_{t}=(w_{t,1},\ldots,w_{t,n})$.

3.1 The Student

The memory attention encoder of the student in Figure 1 serves to (i) identify whether there is new information in the current sentence in relation to its episode memory using soft attention, and (ii) control how much of its episode memory should be updated with this new information. The question-sentence encoder serves to search for clues in the current sentence and the episode memory about the facts in the question, and the answer selection module learns a policy to answer questions posed by the teacher. The student observes a sentence $x_{t}$ at each time step of the episode. Each token $w_{t,i}$ in sentence $x_{t}$ is represented with embedding vector, which are then processed through a long short-term memory (LSTM) Hochreiter & Schmidhuber, (1997) model layer to obtain hidden states of each token $\mathbf{H}_{t}=(h_{t,1},\ldots,h_{t,n})$.

3.1.1 Memory Attention Encoder

Soft Attention. Rocktaschel et al. learns an entailment relation between two sentences (a premise and a hypothesis text) by word-by-word soft attention to encourage reasoning over entailment of pairs of words Rocktaschel et al., (2016). We learn a similar entailment between the observed sentence and the current memory at $t$, to determine if there is a new information in the observed sentence. Weaker entailment (attention) indicates that the information in the current sentence compared to the memory is different (e.g., a new entity present in the current sentence but not in the memory). With the soft attention in Figure 3, we produce intermediate attention representations $\mathbf{m}_{t}$ as a non-linear combination of the episode memory $\mathcal{M}_{t}$ and the unrolled hidden states of the encoded sentence $h_{t,i}$ $\in$ $\mathbf{H}_{t}$:

[TABLE]

$W^{x}$ and $W^{h}$ are weight matrices to be learned, and the output product ($W^{h}\mathcal{M}_{t}\otimes\mathbf{I}_{n}$) repeats the memory representation $\mathcal{M}_{t}$ $n$ times. $\phi$ is the activation function; in our experiments, we used the sigmoid activation function. Each column $m_{t,i}$ of the output attention matrix $\mathbf{m}_{t}$ is the un-normalized attention of the $i$th word of sentence $x_{t}$. We concatenate each column to generate one soft attention vector $\mathbf{m}_{t}$ (overusing the notation), which partially forms the current state representation.

Episode Memory Update.

The student determines how much of the episode memory should be updated with the information provided in the new sentence using a gating function (see Figure 3):

[TABLE]

$W^{C}$ and $W^{P}$ are weight matrices to be learned. They represent the weights associated with the current sentence and the episode memory at time $t$. $\mathbf{h}_{t}$ is the last hidden state of the current sentence $x_{t}$ LSTM. We choose hyperbolic tangent for the activation $\phi$. The way we look at the gating function $g_{t}$ is that, it allows some cells in the memory $\mathcal{M}_{t}$ to be forgotten and be replaced with the new ones $h_{t}$, as the information flows through time - as the dialog progresses or stories evolve.

3.1.2 Question-Sentence Encoder

At each time $t$, the teacher generates one or more questions which are concatenated into a single question $q_{t}$. Student maps the question $q_{t}$ into a vector form to generate its fixed length semantic representation. Each word $a_{i}$ in the question $q_{t}=(a_{1}\cdots a_{n})$ is encoded by mapping onto embedding layer and then processed through another LSTM layer to obtain the last hidden state vector $\mathbf{h}^{q}_{t}$. Given the fixed length representation of the sentence at time $t$ in semantic space $\mathbf{h_{t}}$, and the $\mathbf{h_{t}^{q}}$, the student applies a linear combination followed by another LSTM layer (Figure 3) as follows:

[TABLE]

An interaction function $f(\cdot)$ is used to approximate the similarity between the question $\mathbf{h_{t}^{q}}$ and the memory $\mathcal{M}_{t}$ that gives the initial state $\mathbf{\tilde{h}}_{t,0}$ for the question-sentence LSTM. We merge the question $\mathbf{h_{t}^{q}}$ with the encoded sentence word vectors h_{t,i}$$\in$$\mathbf{h}_{t} using the same interaction function to obtain \tilde{h}_{t,i}$$\in$$\mathbf{\tilde{h}}_{t} approximating similarity between the current sentence and the question. The interaction function could be an inner product, or a nonlinear function such as a deep neural network. In our experiments, both gave similar results. For simplicity, in our experiments we mostly use the inner product interaction function. The last hidden state, $\mathbf{o}_{t}$, is used as part of the state representation.

3.1.3 Answer Selection

State. At each time step $t$, the student agent concatenates the soft attention vector ($\mathbf{m}_{t}$), the output of the question-sentence encoder ($\mathbf{o}_{t}$) as well as the question representation ($\mathbf{h}_{t}^{q}$) to form the current state representation: $s_{t}=\left[\mathbf{o}_{t};\mathbf{m}_{t};\mathbf{h}_{t}^{q}\right]$.

Action. An action corresponds to an answer, which is an entity from a task-specific entity set. The agent selects an action $a_{t}$ at time $t$ from a finite set of actions $\mathcal{A}$=$\{1,\ldots,\mathcal{K}\}$, then collects a reward from the environment. The agent’s action affects the next operations of the whole network, including whether the next sentence from input text is to be read, and how the teacher samples question-answer pairs (see $\S$ 3.2); this affects the next state, $s_{t+1}$, observed by the student. The teacher’s strategy helps student explore different question-sentence pairs, yielding exploration of "novel" states.

Reward. We consider the case when the return is partially received at the intermediate steps in the form of rewards $r_{t}\in${+1,-1} depending on answering questions correct or wrong. If the answer is wrong, the student does not observe a new sentence, but rather the teacher generates a new question, and the student encodes the same sentence with the new question to form a new state. The student runs its policy and produces an answer and collects a new reward. This process continues until the student gets a correct answer or a maximum of trials are exhausted. The reward at terminal is a larger positive number which is proportional to the number of correctly answered questions given the episode length. The environment decides to terminate the episode if the student fails to provide correct answers to more than an empirically defined threshold.

Policy. We learn the optimal policy $\pi^{*}$ through a Deep Q-Network (DQN) Mnih et al., (2015). The Q-function for the policy $\pi$ measures the expected cumulative discounted reward for each state-action pair $(s,a)$ if the agent chooses $a$ in state $s$ and then follows $\pi$ thereafter: $Q^{\pi}(s,a)=\mathbb{E}_{\pi}[\sum_{i=0}^{T}\gamma^{i}r_{t+i}|s_{t}=s,a_{t}=a]$, where $\gamma$ is the discount factor. During learning the optimal policy, $\epsilon$-greedy exploration is used with $\epsilon=0.1$ which decays over time. We approximate the Q-function by a 2-layer neural network $Q(s,a;\theta)$, where $\theta$ are parameters to be learned. As commonly done, we represent experiences as tuples of transitions, ($(s_{t},a_{t},r_{t},s_{t+1})\in\mathcal{D}_{e}$). We use experience reply Mnih et al., (2015) by maintaining a buffer of experiences and training on randomly selected mini-batches.

3.2 The Teacher

The teacher, early in the training, serves to generate rather simple questions by sampling a sentence from so far observed sentences $\mathcal{X}_{1:t}$. When the student performance on a held-out set reaches a plateau, the teacher starts sampling multiple sentences from $\mathcal{X}_{1:t}$ to generate multiple questions having the same answer. The motivation is to ask questions that explicitly conveys spatially distant facts related to the answer and remind the student about such long distance dependencies (see Table 2).

Every-time the student observes a sentence, it should not only track new facts, but also possible state changes about the facts. For example, if the student observes a new sentence ’the park is on my east’, it should easily track that the ’park’ is a new entity if it has not been observed before. However, if student have already observed the sentence ’the museum is on the east of the park’, then what it tracks should be the state change rather than the new fact because the new sentence indicates a location change. This may not be equally easy for the student to track with the entailment based memory attention encoder. We design the teacher to help student focus on such cases by introducing a strategy called Importance Measure $I(x_{t})$ extending Zimmer et al., (2014). The teacher first evaluates whether there is a state change in a given sentence as follows: At each time $t$, the student does forward pass and calculates the current sentence attention vector $\mathbf{\bar{m}}_{t}$ by taking the average of each of its word attention vectors $m_{t,i}$ : $\mathbf{\bar{m}}_{t}$=$\sum_{i}^{n}m_{t,i}$ from $i$=$1\cdots n$. It also tracks the episode attention by measuring a moving average of average sentence attentions $\mathbf{\bar{m}}_{1:t}$=$(\mathbf{\bar{m}}_{1:t-1}$+$\mathbf{\bar{m}}_{t})$/2 over the episode. The teacher then measures the importance based on the similarity between the sentence $\mathbf{\bar{m}}_{t}$ and episode $\mathbf{\bar{m}}_{1:t}$ attentions:

[TABLE]

We use linear kernel (cosine similarity) although any non-linear kernel can be used. When the average attention of the current sentence is similar to the episode’s attention, it indicates that the current sentence may contain facts similar to so far observed sentences in the episode, hence a possible state change. The student should be questioned to verify that it captures this information correctly.

To generate question-answer pairs, our teacher uses the Question Generator (QG) in Heilman & Smith, (2010)111Code available in http://www.cs.cmu.edu/~ark/mheilman/questions/, a rule-base system. Identifying various constructions such as conjunctions, subordinate clauses, and appositives, it generates multiple questions from a single sentence that conveys multiple pieces of information. QG uses Stanford ParserKlein & Manning, (2003) to find sentence boundaries, tokenize, and parse the sentence and TregexLevy & Andrew, (2006), tree searching language, to identify various constructions (e.g., non-restrictive appositives). After identifying the key nodes with Tregex, QG manipulates trees using the Stanford Parser, which allows for inserting and deleting children, changing tree node labels, etc. to generate questions (see Table 2).

The teacher generates questions at each time $t$ using QG as follows: If the importance $I(x_{t})$ of current sentence is greater than a given (empirically optimized) threshold, the teacher decides that the state of an entity might have changed. Using QG, it generates a set of question-answer pairs from current $x_{t}$. Additionally, it may also choose to select zero or more sentences from $\mathcal{X}_{1:t}$ to generate sets of question-answer pairs. Then it chooses one question from each set that has the same answer and forms question $q_{t}$ by concatenating each question. If the importance is low, then it randomly chooses one or more sentences from $\mathcal{X}_{1:t}$ and uses QG to generate a question as explained above.

4 Experimental Setup

4.1 Training the Scaffolding Network

If no validation data is provided, we withhold 10% of the data for hyper-parameter tuning. We use hidden size of 128 for all experiments. The weights in the input and output units were initialized with zero mean and standard deviation of 1/$\sqrt{d}$. L2 weight decay of 0.001 is used for all weights. All models are trained with ADAM Kingma & Ba, (2015) with initial learning rates set by a grid search over $\{$0.1, 0.01$\}$. We assign a reward of $\mp$1 depending on the answer being wrong or right when the question is posed by the teacher; or $\mp$(k/T)*10 when the questions are corpus provided (at the end of the text) where k is the correct answer count and T is the episode length. Following Sukhbaatar et al., (2015), we repeat each training 10 times with different random initializations and choose the best model based on validation performance and report test results of the best model.

Our benchmark models use multi-hop/multi-layer memory networks and show promising improvements compared to single hop/layer counterparts; thus, we use 3-layer LSTMs for the question-sentence encoder for all experiments. For all scaffolding models, an episode is terminated and deemed unsuccessful when student fails to answer number of questions exceeding more than 50% of sentences in the input text.

4.2 Datasets

Travel Log datasets. This dataset is a collection of documents about travel narratives. Our goal in creating these datasets is to measure the ability of our scaffolding network in reasoning tasks which require learning relations between multiple facts and tracking their changing states. Each text is constructed by placing a traveler agent in a town defined by a 9$\times$9 grid, which is full of attractions. The agent starts randomly in one location and wanders around the town by randomly choosing a direction to the next move (i.e., north, west, south, east) and logs each move. As agent moves to a new direction, logs any attraction nearby with respect to the current location (e.g. there is a museum on my left.) End of each log, a question is asked about the location of a randomly chosen attraction, (e.g.,what is north of the museum?). The task is to find the correct answer, which can only be inferred from the text by tracing the traveler’s steps. The complexity of the task increases as the number of attractions is increased. Five different datasets are generated by varying the number of attractions, i.e., complexity of the reasoning task. Each dataset contains 1000 training and test logs. (see Appendix-A)

bAbI Dialog datasets. Our goal in using the dialog data is to test the capacity of the scaffolding networks to provide the correct response while tracking changing user goals. The dialog dataset Bordes & Weston, (2017) is organized as set of 5 tasks (T1,..,T5) each focusing on a specific objective: issuing API calls, updating API calls, displaying options, providing extra-information, conducting full dialogs (the aggregation of the first 4 tasks). These data are synthetically generated based on a knowledge base consisting of facts which define all the restaurants with 7 different features (e.g., location and price range). The texts are in the form of conversation between a user and a bot, in a restaurant reservation scenario. These tasks test the capacity of end-to-end dialog systems with various goals (e.g., request phone-number, address, etc.). Another set of test data, named out-of-vocabulary (OOV), are also used to test the capability of a system to deal with entities not appearing in training data.

DSTC-2 Dialog datasets. This restaurant domain dataset Bordes & Weston, (2017) is similar to bAbI Dialog data in format and goal but contains real human-bot conversations and is derived from second Dialog State Tracking Challenge Henderson et al., (2014). This task draws on human-computer dialog data, where crowd-workers interacted with several variants of a spoken dialog system Henderson et al., (2014). Sample dialog is provided in appendix.

5 Experimental Results

5.1 Travel-Log Results

We evaluate our model’s reasoning capability on 5 different travel log datasets with increased number of attractions. The action space is composed of the list of attractions and 4 directions. As a baseline we use LSTM, End-to-End Memory Networks (MemN2N)222Code : github.com/facebook/MemNN & github.com/facebook/MemNN/tree/master/EntNet-babi Sukhbaatar et al., (2015) and Recurrent Entity Networks Ent-Net2 Henaff et al., (2017) as summarized in the related work. We compare these baselines against our full Scaffolding Networks model (SN). The importance threshold $I(x_{t})$ is empirically chosen to be 0.30. To evaluate the impact of the teacher’s importance strategy, we trained our model without the importance strategy, where the teacher only uses random sampling to generate questions, (SN-no-imp). To evaluate the importance of our memory attention encoder, we train another SN model without the attention component (SN-no-att). Since teacher’s importance strategy depends on the attention, the teacher uses random sampling to generate questions in SN-no-att. Table 1 shows benchmark results. Table 2 demonstrates the output of our full SN model on a single log text data. We observed the following results:

• •

Our full SN models outperform nearly all benchmark models, except for the simplest task.

• •

The LSTMs perform poorly. Both MemN2N and Ent-Net performances are similar to our full SN model for simpler tasks (when #attractions $\leq$10).

• •

When no attention is used in SN-no-att, the scaffolding model performance suffers the most. Since only with attention the SN model is able to capture the relations between the previous memory and observed sentence, without attention it’s decisions become myopic.

• •

With no importance strategy, SN-no-imp performs slightly worse than our full model SN, indicating that teacher’s intelligence influences the student’s actions.

• •

Although the performance of all models drop as the complexity increase, our SN is both more accurate and more robust on harder tasks.

• •

The SN model can infer locations that doesn’t exist in the training data (e.g., north-east) and correctly reason about them (step-17 in Table 2).

• •

The student demonstrates that it can track the state changes and positional relations of the objects based on the guidance it gets from the teacher (Table 2). For instance, even though it has not observed the fact about ’west of the park’, it learns to reason about the answer based on its memory and the scaffolding questions it receives from the teacher in step-16 and step-18, and can successfully answer the corpus provided question at step-20.

5.2 Dialog Results on bAbI and DSTC-2 Datasets

The input text in both dialog data is defined as a series of utterances $c^{u}_{1},c^{s}_{1},c^{u}_{2},c^{s}_{2},..,c^{u}_{t-1},c^{s}_{t-1}$ (alternating between the user utterance $c^{u}_{i}$ and agent’s response $c^{s}_{i}$), while the $c^{u}_{t}$ is the question and the goal is to predict agent’s response $c^{s}_{t}$. In this task the $c^{s}_{t}$ is a sequence of words, while our model predicts word tokens as actions. Therefore, we map each response $c^{s}_{t}$ to a unique category following Bordes & Weston, (2017). Specifically, we collect all possible agent responses into a candidate set $\mathcal{C}$ and define an action $a_{i}$ as the ith response in the candidate set $\mathcal{C}$ such that $a_{i}\in\mathcal{C}$. The set of candidate responses includes all possible bot utterances and API calls. We benchmark our approach against: End-to-End Goal Oriented Dialog Model (N2N) Bordes & Weston, (2017), Query Reduction Networks (QRN) Seo et al., (2017), and Gated Memory Networks (GMemN2N) Perez & Liu, (2016), all presented state-of-the art in this dataset. We show the results of our full SNs with teacher’s importance strategy. Performance results are summarized in Table 3 comparing models when no-match and 7 different restaurant specific match features are used, e.g., location, price range, etc., indicating if there is an exact match between words occurring in the current utterance and those in the question or memory. We observed the following results:

• •

For Tasks 1-5, when no features used, our SN model follows the state-of-the-art closely.

• •

Especially when match features are used, on average SN outperforms all models.

• •

The OOV experiments in Table 3 demonstrate how the models handle actions with "unseen" entities in conversational dialogs. All models have slightly higher error rates with OOV words. SNs immediately follow the best model when no match features (plain) are used, while outperforms all others when match features are used.

• •

The efficacy of our SN models are more pronounced with and without the match features with the real dialog scenarios in DSTC-2.

**Scaffolding Teacher versus the Human as a Teacher. **

We investigate how much improvement we gain from the teacher generated questions by gradually replacing the human provided questions with

the teacher’s questions at training time. We benchmark SN against QRN Seo et al., (2017) (best performing benchmark). Specifically, for SN models, we only use m% of the human generated questions and replace the rest with the teacher generated ones and re-train. For QRN models, we use self-training by first removing m% of the training data, and training with the rest (100-m)% human labeled data. Then we predict the answers for the removed m% text, add them back to the training data, re-train and repeat the process. We repeat the experiments for increasing values of $m$ and demonstrate the results on DSTC-2 real dialog dataset.

As shown in in Figure 4, reducing the human provided input does not affect the SNs performance as much as QRN models (e.g., 5% reduction in error with the SN models when 50% of the labels are removed). Even with reduced human input, the SNs can learn to do reasoning well and track the state of the world, reducing the dependence on humans as teachers.

6 Conclusion and Outlook

We take a step towards teaching machines to reason by introducing an RL framework that simulates instructional scaffolding teaching. We found that by integrating the strengths of neural attention models and incremental teacher-student learning we can repeatably check and update the student about the information it encodes in sequential order. We additionally show that with a simple importance strategy the teacher can guide the student into learning a policy for identifying not only new aspects but also track their state changes throughout the text. Our future work will investigate a teacher acting as another agent to influence the student into taking actions.

Appendix

Appendix-A : Details of the Travel Log Experiments

The traveler is placed on a 9$\times$9 grid town of 81 distinct locations with a list of attractions in randomly chosen locations. At each time step, the traveler’s next direction is chosen at random among 4 possible actions, e.g., north, south, east, west. If the selection puts the traveler off the grid, a new legal direction is chosen at random.

We use the following rules to generate the log data. The traveler visits each attraction only once. If the randomly chosen next direction takes the traveler to an attraction previously visited, a new random direction is chosen. If all the 4 directions contain attractions that are visited before, the log terminates. Once the traveler is in a new location, she looks at 4 immediate directions to log attractions. If there is no attraction, she continues on the next direction. Otherwise randomly chooses one attraction to log. We randomly generate different town layouts by varying the number of attractions, e.g., $\{$5,10,15,20,25$\}$ and evaluate the performance of the models in the experiments. The teacher only uses the sentences that contain the location of the attractions to generate questions.

We use all the words in the vocabulary except a list of stop words. The list of attractions and 4 different directions are used as the output space. If the attraction is a multi-word expression, we combine all the words.

Appendix-B : Example Dialog from the DSTC-2 Dataset

[TABLE]