| { |
| "paper_id": "P17-1015", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T08:18:56.790075Z" |
| }, |
| "title": "Program Induction by Rationale Generation: Learning to Solve and Explain Algebraic Word Problems", |
| "authors": [ |
| { |
| "first": "Wang", |
| "middle": [], |
| "last": "Ling", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "University of Oxford", |
| "location": {} |
| }, |
| "email": "lingwang@google.com" |
| }, |
| { |
| "first": "Dani", |
| "middle": [], |
| "last": "Yogatama", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "University of Oxford", |
| "location": {} |
| }, |
| "email": "dyogatama@google.com" |
| }, |
| { |
| "first": "Chris", |
| "middle": [], |
| "last": "Dyer", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "University of Oxford", |
| "location": {} |
| }, |
| "email": "cdyer@google.com" |
| }, |
| { |
| "first": "Phil", |
| "middle": [], |
| "last": "Blunsom", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "University of Oxford", |
| "location": {} |
| }, |
| "email": "pblunsom@google.com" |
| }, |
| { |
| "first": "\u2666", |
| "middle": [ |
| "\u2660" |
| ], |
| "last": "Deepmind", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "University of Oxford", |
| "location": {} |
| }, |
| "email": "" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "Solving algebraic word problems requires executing a series of arithmetic operations-a program-to obtain a final answer. However, since programs can be arbitrarily complicated, inducing them directly from question-answer pairs is a formidable challenge. To make this task more feasible, we solve these problems by generating answer rationales, sequences of natural language and human-readable mathematical expressions that derive the final answer through a series of small steps. Although rationales do not explicitly specify programs, they provide a scaffolding for their structure via intermediate milestones. To evaluate our approach, we have created a new 100,000-sample dataset of questions, answers and rationales. Experimental results show that indirect supervision of program learning via answer rationales is a promising strategy for inducing arithmetic programs.", |
| "pdf_parse": { |
| "paper_id": "P17-1015", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "Solving algebraic word problems requires executing a series of arithmetic operations-a program-to obtain a final answer. However, since programs can be arbitrarily complicated, inducing them directly from question-answer pairs is a formidable challenge. To make this task more feasible, we solve these problems by generating answer rationales, sequences of natural language and human-readable mathematical expressions that derive the final answer through a series of small steps. Although rationales do not explicitly specify programs, they provide a scaffolding for their structure via intermediate milestones. To evaluate our approach, we have created a new 100,000-sample dataset of questions, answers and rationales. Experimental results show that indirect supervision of program learning via answer rationales is a promising strategy for inducing arithmetic programs.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "Behaving intelligently often requires mathematical reasoning. Shopkeepers calculate change, tax, and sale prices; agriculturists calculate the proper amounts of fertilizers, pesticides, and water for their crops; and managers analyze productivity. Even determining whether you have enough money to pay for a list of items requires applying addition, multiplication, and comparison. Solving these tasks is challenging as it involves recognizing how goals, entities, and quantities in the real-world map onto a mathematical formalization, computing the solution, and mapping the solution back onto the world. As a proxy for the richness of the real world, a series of papers have used natural language specifications of algebraic word problems, and solved these by either learning to fill in templates that can be solved with equation solvers (Hosseini et al., 2014; or inferring and modeling operation sequences (programs) that lead to the final answer (Roy and Roth, 2015) .", |
| "cite_spans": [ |
| { |
| "start": 841, |
| "end": 864, |
| "text": "(Hosseini et al., 2014;", |
| "ref_id": "BIBREF6" |
| }, |
| { |
| "start": 952, |
| "end": 972, |
| "text": "(Roy and Roth, 2015)", |
| "ref_id": "BIBREF18" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "In this paper, we learn to solve algebraic word problems by inducing and modeling programs that generate not only the answer, but an answer rationale, a natural language explanation interspersed with algebraic expressions justifying the overall solution. Such rationales are what examiners require from students in order to demonstrate understanding of the problem solution; they play the very same role in our task. Not only do natural language rationales enhance model interpretability, but they provide a coarse guide to the structure of the arithmetic programs that must be executed. In fact the learner we propose (which relies on a heuristic search; \u00a74) fails to solve this task without modeling the rationales-the search space is too unconstrained.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "This work is thus related to models that can explain or rationalize their decisions (Hendricks et al., 2016; Harrison et al., 2017) . However, the use of rationales in this work is quite different from the role they play in most prior work, where interpretation models are trained to generate plausible sounding (but not necessarily accurate) posthoc descriptions of the decision making process they used. In this work, the rationale is generated as a latent variable that gives rise to the answer-it is thus a more faithful representation of the steps used in computing the answer.", |
| "cite_spans": [ |
| { |
| "start": 84, |
| "end": 108, |
| "text": "(Hendricks et al., 2016;", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 109, |
| "end": 131, |
| "text": "Harrison et al., 2017)", |
| "ref_id": "BIBREF4" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "This paper makes three contributions. First, we have created a new dataset with more than 100,000 algebraic word problems that includes both answers and natural language answer rationales ( \u00a72).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Problem 1: Question: Two trains running in opposite directions cross a man standing on the platform in 27 seconds and 17 seconds respectively and they cross each other in 23 seconds. The ratio of their speeds is: Options: A) 3/7 B) 3/2 C) 3/88 D) 3/8 E) 2/2 Rationale: Let the speeds of the two trains be x m/sec and y m/sec respectively. Then, length of the first train = 27x meters, and length of the second train = 17 y meters. (27x + 17y) / (x + y) = 23 \u2192 27x + 17y = 23x + 23y \u2192 4x = 6y \u2192 x/y = 3/2. Correct Option: B Problem 2: Question: From a pack of 52 cards, two cards are drawn together at random. What is the probability of both the cards being kings? Options: A) 2/1223 B) 1/122 C) 1/221 D) 3/1253 E) 2/153 Rationale: Let s be the sample space. Then n(s) = 52C2 = 1326 E = event of getting 2 kings out of 4 n(E) = 4C2 = 6 P(E) = 6/1326 = 1/221 Answer is C Correct Option: C Problem 3: Question: For which of the following does p(a)\u2212p(b) = p(ab) for all values of a and b? Options:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Figure 1 illustrates three representative instances", |
| "sec_num": null |
| }, |
| { |
| "text": "A) p(x) = x 2 , B) p(x) = x/2, C) p(x) = x + 5, D) p(x) = 2x1, E) p(x) = |x|", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Figure 1 illustrates three representative instances", |
| "sec_num": null |
| }, |
| { |
| "text": "Rationale: To solve this easiest way is just put the value and see that if it equals or not. with option A. p(a) = a 2 and p(b from the dataset. Second, we propose a sequence to sequence model that generates a sequence of instructions that, when executed, generates the rationale; only after this is the answer chosen ( \u00a73). Since the target program is not given in the training data (most obviously, its specific form will depend on the operations that are supported by the program interpreter); the third contribution is thus a technique for inferring programs that generate a rationale and, ultimately, the answer. Even constrained by a text rationale, the search space of possible programs is quite large, and we employ a heuristic search to find plausible next steps to guide the search for programs ( \u00a74). Empirically, we are able to show that state-of-the-art sequence to sequence models are unable to perform above chance on this task, but that our model doubles the accuracy of the baseline ( \u00a76).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Figure 1 illustrates three representative instances", |
| "sec_num": null |
| }, |
| { |
| "text": ") = b 2 so L.H.S = a 2 \u2212 b 2 and R.H.S = (a \u2212 b) 2 \u2192 a 2 + b 2 \u2212 2ab. so L.H.S not equal to R.H.S with option B. p(a) = a/2 and p(b) = b/2 L.H.S = a/2 \u2212 b/2 \u2192 1/2(a \u2212 b) R.H.S = (a \u2212 b)/2 so L", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Figure 1 illustrates three representative instances", |
| "sec_num": null |
| }, |
| { |
| "text": "We built a dataset with 100,000 problems with the annotations shown in Figure 1 . Each question is decomposed in four parts, two inputs and two outputs: the description of the problem, which we will denote as the question, and the possible (multiple choice) answer options, denoted as options. Our goal is to generate the description of the rationale used to reach the correct answer, denoted as rationale and the correct option label. Problem 1 illustrates an example of an algebra problem, which must be translated into an expression (i.e., (27x + 17y)/(x + y) = 23) and then the desired quantity (x/y) solved for. Problem 2 is an example that could be solved by multi-step arithmetic operations proposed in (Roy and Roth, 2015) . Finally, Problem 3 describes a problem that is solved by testing each of the options, which has not been addressed in the past.", |
| "cite_spans": [ |
| { |
| "start": 710, |
| "end": 730, |
| "text": "(Roy and Roth, 2015)", |
| "ref_id": "BIBREF18" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 71, |
| "end": 79, |
| "text": "Figure 1", |
| "ref_id": "FIGREF0" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Dataset", |
| "sec_num": "2" |
| }, |
| { |
| "text": "We first collect a set of 34,202 seed problems that consist of multiple option math questions covering a broad range of topics and difficulty levels. Examples of exams with such problems include the GMAT (Graduate Management Admission Test) and GRE (General Test). Many websites contain example math questions in such exams, where the answer is supported by a rationale.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Construction", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "Next, we turned to crowdsourcing to generate new questions. We create a task where users are presented with a set of 5 questions from our seed dataset. Then, we ask the Turker to choose one of the questions and write a similar question. We also force the answers and rationale to differ from the original question in order to avoid paraphrases of the original question. Once again, we manually check a subset of the jobs for each Turker for quality control. The type of questions generated using this method vary. Some turkers propose small changes in the values of the questions (e.g., changing the equality p(a)p(b) = p(ab) in Problem 3 to a different equality is a valid question, as long as the rationale and options are rewritten to reflect the change). We designate these as replica problems as the natural language used in the question and rationales tend to be only minimally unaltered. Others propose new problems in the same topic where the generated questions tend to differ more radically from existing ones. Some Turkers also copy math problems available on the web, and we define in the instructions that this is not allowed, as it will generate multiple copies of the same problem in the dataset if two or more Turkers copy from the same resource. These Turkers can be detected by checking the nearest neighbours within the collected datasets as problems obtained from online resources are frequently submitted by more than one Turker. Using this method, we obtained 70,318 additional questions.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Construction", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "Descriptive statistics of the dataset is shown in Figure 1 . In total, we collected 104,519 problems (34,202 seed problems and 70,318 crowdsourced problems). We removed 500 problems as heldout set (250 for development and 250 for testing). As replicas of the heldout problems may be present in the training set, these were removed manually by listing for each heldout instance the closest problems in the training set in terms of character-based Levenstein distance. After filtering, 100,949 problems remained in the training set. We also show the average number of tokens (total number of tokens in the question, options and rationale) and the vocabulary size of the questions and rationales. Finally, we provide the same statistics exclusively for tokens that are numeric values and tokens that are not. Figure 2 shows the distribution of examples based on the total number of tokens. We can see that most examples consist of 30 to 500 tokens, but there are also extremely long examples with more than 1000 tokens in our dataset.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 50, |
| "end": 58, |
| "text": "Figure 1", |
| "ref_id": "FIGREF0" |
| }, |
| { |
| "start": 806, |
| "end": 814, |
| "text": "Figure 2", |
| "ref_id": "FIGREF1" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Statistics", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "Generating rationales for math problems is challenging as it requires models that learn to perform math operations at a finer granularity as each step within the solution must be explained. 17y)/(x + y) = 23 must be solved to obtain the answer. In previous work , this could be done by feeding the equation into an expression solver to obtain x/y = 3/2. However, this would skip the intermediate steps 27x + 17y = 23x + 23y and 4x = 6y, which must also be generated in our problem. We propose a model that jointly learns to generate the text in the rationale, and to perform the math operations required to solve the problem. This is done by generating a program, containing both instructions that generate output and instructions that simply generate intermediate values used by following instructions.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Model", |
| "sec_num": "3" |
| }, |
| { |
| "text": "In traditional sequence to sequence models (Sutskever et al., 2014; Bahdanau et al., 2014) , the goal is to predict the output sequence y = y 1 , . . . , y |y| from the input sequence x = x 1 , . . . , x |x| , with lengths |y| and |x|.", |
| "cite_spans": [ |
| { |
| "start": 43, |
| "end": 67, |
| "text": "(Sutskever et al., 2014;", |
| "ref_id": "BIBREF20" |
| }, |
| { |
| "start": 68, |
| "end": 90, |
| "text": "Bahdanau et al., 2014)", |
| "ref_id": "BIBREF1" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "In our particular problem, we are given the problem and the set of options, and wish to predict the rationale and the correct option. We set x as the sequence of words in the problem, concatenated with words in each of the options separated by a special tag. Note that knowledge about the possible options is required as some problems are solved by the process of elimination or by testing each of the options (e.g. Problem 3). We wish to generate y, which is the sequence of words in the rationale. We also append the correct option as the last word in y, which is interpreted as the chosen option. For example, y in Problem 1 is \"Let the . . . = 3/2 . EOR B EOS \", whereas in Problem 2 it is \"Let s be . . . Answer is C EOR C EOS \", where \" EOS \" is the end of sentence symbol and \" EOR \" is the end of rationale symbol.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "i x z v r From Id(\"Let\") Let y1 a Id(\"s\") s y2 pack", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Id(\"be\") be y3 of Id(\"the\") the y4 52", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Id(\"sample\") sample y5 cards Id(\"space\") space y6 , Id(\".\") . y7 two Id(\"\\n\") \\n y8 cards Id(\"Then\") Then y9 are", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Id(\"n\") n y10 drawn Id(\"(\") ( y11 together Id(\"s\") s y12 at Id(\")\") ) y13 random Id(\"=\") = y14 . Str to Float(x5) 52 m1 What", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Float to Str(m1) 52 y15 is Id(\"C\") C y16 the Id(\"2\") 2 y17 probability Id(\"=\") = y18 of Str to Float(y17) 2 m2 both Choose(m1,m2) 1326 m3 cards", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Float to Str(m3) 1326 y19 being Id(\"E\") E y20 kings Id(\"=\") = y21 ?", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Id(\"event\") event ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "y22 <O> Id(\"of\") of y23 A) Id(\"getting\") getting y24 2/1223 Id(\"2\") 2 y25 <O> Id(\"kings\") kings y26 B) Id(\"out\") out y27 1/122 Id(\"of\") of y28 . . . . . . . . . . . . . . . |z| Id(\" EOS \") EOS y |y|", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Problem Definition", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "We wish to generate a latent sequence of program instructions, z = z 1 , . . . , z |z| , with length |z|, that will generate y when executed. We express z as a program that can access x, y, and the memory buffer m. Upon finishing execution we expect that the sequence of output tokens to be placed in the output vector y. Table 2 illustrates an example of a sequence of instructions that would generate an excerpt from Problem 2, where columns x, z, v, and r denote the input sequence, the instruction sequence (program), the values of executing the instruction, and where each value v i is written (i.e., either to the output or to the memory). In this example, instructions from indexes 1 to 14 simply fill each position with the observed output y 1 , . . . , y 14 with a string, where the Id operation simply returns its parame-ter without applying any operation. As such, running this operation is analogous to generating a word by sampling from a softmax over a vocabulary. However, instruction z 15 reads the input word x 5 , 52, and applies the operation Str to Float, which converts the word 52 into a floating point number, and the same is done for instruction z 20 , which reads a previously generated output word y 17 . Unlike, instructions z 1 , . . . , z 14 , these operations write to the external memory m, which stores intermediate values. A more sophisticated instruction-which shows some of the power of our model-is z 21 = Choose(m 1 , m 2 ) \u2192 m 3 which evaluates m 1 m 2 and stores the result in m 3 . This process repeats until the model generates the end-of-sentence symbol. The last token of the program as said previously must generate the correct option value, from \"A\" to \"E\". By training a model to generate instructions that can manipulate existing tokens, the model benefits from the additional expressiveness needed to solve math problems within the generation process. In total we define 22 different operations, 13 of which are frequently used operations when solving math problems. These are: Id, Add, Subtract, Multiply, Divide, Power, Log, Sqrt, Sine, Cosine, Tangent, Factorial, and Choose (number of combinations). We also provide 2 operations to convert between Radians and Degrees, as these are needed for the sine, cosine and tangent operations. There are 6 operations that convert floating point numbers into strings and vice-versa. These include the Str to Float and Float to Str operations described previously, as well as operations which convert between floating point numbers and fractions, since in many math problems the answers are in the form \"3/4\". For the same reason, an operation to convert between a floating point number and number grouped in thousands is also used (e.g. 1000000 to \"1,000,000\" or \"1.000.000\"). Finally, we define an operation (Check) that given the input string, searches through the list of options and returns a string with the option index in {\"A\", \"B\", \"C\", \"D\", \"E\"}. If the input value does not match any of the options, or more than one option contains that value, it cannot be applied. For instance, in Problem 2, once the correct probability \"1/221\" is generated, by applying the check operation to this number we can obtain correct option \"C\". Figure 3 : Illustration of the generation process of a single instruction tuple at timestamp i.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 322, |
| "end": 329, |
| "text": "Table 2", |
| "ref_id": "TABREF2" |
| }, |
| { |
| "start": 3228, |
| "end": 3236, |
| "text": "Figure 3", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Generating Programs to Generate Rationales", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "h i softmax o i r i softmax r i q i,j=1 softmax q ij softmax copy input a ij q i,j+1 copy output h i+1 j < argc(o i )? v i execute", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating Programs to Generate Rationales", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "In our model, programs consist of sequences of instructions, z. We turn now to how we model each z i , conditional on the text program specification, and the program's history. The instruction z i is a tuple consisting of an operation (o i ), an ordered sequence of its arguments (a i ), and a decision about where its results will be placed (r i ) (is it appended in the output y or in a memory buffer m?), and the result of applying the operation to its arguments (", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "v i ). That is, z i = (o i , r i , a i , v i ).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Formally, o i is an element of the pre-specified set of operations O, which contains, for example add, div, Str to Float, etc. The number of arguments required by o i is given by argc(o i ), e.g., argc(add) = 2 and argc(log) = 1. The arguments are a i = a i,1 , . . . , a i,argc(o i ) . An instruction will generate a return value v i upon execution, which will either be placed in the output y or hidden. This decision is controlled by r i . We define the instruction probability as:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "p(o i , a i , r i ,v i | z <i , x, y, m) = p(o i | z <i , x) \u00d7 p(r i | z <i , x, o i )\u00d7 argc(o i ) j=1 p(a i,j | z <i , x, o i , m, y)\u00d7 [v i = apply(o i , a)],", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "where [p] evaluates to 1 if p is true and 0 otherwise, and apply(f, x) evaluates the operation f with arguments x. Note that the apply function is not learned, but pre-defined.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "The network used to generate an instruction at a given timestamp i is illustrated in Figure 3 . We first use the recurrent state In order to predict r i , we generate a new hidden state r i , which is a function of the current program context h i , and an embedding of the current predicted operation, o i . As the output can either be placed in the memory m or the output y, we compute the probability p(r", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 85, |
| "end": 93, |
| "text": "Figure 3", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "h i to generate p(o i | z <i , x) = softmax o i \u2208O (h i ),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "i = OUTPUT | z <i , x, o i ) = \u03c3(r i \u2022 w r + b r ),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "where \u03c3 is the logistic sigmoid function. If r i = OUTPUT, v i is appended to the output y; otherwise it is appended to the memory m.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Once we generate r i , we must predict a i , the argc(o i )-length sequence of arguments that operation o i requires. The jth argument a i,j can be either generated from a softmax over the vocabulary, copied from the input vector x, or copied from previously generated values in the output y or memory m. This decision is modeled using a latent predictor network (Ling et al., 2016) , where the control over which method used to generate a i,j is governed by a latent variable q i,j \u2208 {SOFTMAX, COPY-INPUT, COPY-OUTPUT}. Similar to when predicting r i , in order to make this choice, we also generate a new hidden state for each argument slot j, denoted by q i,j with an LSTM, feeding the previous argument in at each time step, and initializing it with r i and by reading the predicted value of the output r i .", |
| "cite_spans": [ |
| { |
| "start": 363, |
| "end": 382, |
| "text": "(Ling et al., 2016)", |
| "ref_id": "BIBREF12" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "\u2022 If q i,j = SOFTMAX, a i,j is generated by sampling from a softmax over the vocabulary Y,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "p(a i,j | q i,j = SOFTMAX) = softmax a i,j \u2208Y (q i,j ).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "This corresponds to a case where a string is used as argument (e.g. y 1 =\"Let\").", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "\u2022 If q i,j = COPY-INPUT, a i,j is obtained by copying an element from the input vector with a pointer network (Vinyals et al., 2015) over input words x 1 , . . . , x |x| , represented by their encoder LSTM state u 1 , . . . , u |x| . As such, we compute the probability distribution over input words as:", |
| "cite_spans": [ |
| { |
| "start": 110, |
| "end": 132, |
| "text": "(Vinyals et al., 2015)", |
| "ref_id": "BIBREF21" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "p(a i,j | q i,j =COPY-INPUT) = (1) softmax a i,j \u2208x 1 ,...,x |x| f (u a i,j , q i,j )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Function f computes the affinity of each token x a i,j and the current output context q i,j . A common implementation of f , which we follow, is to apply a linear projection from [u a i,j ; q i,j ] into a fixed size vector (where [u; v] is vector concatenation), followed by a tanh and a linear projection into a single value.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "\u2022 If q i,j = COPY-OUTPUT, the model copies from either the output y or the memory m. This is equivalent to finding the instruction z i , where the value was generated. Once again, we define a pointer network that points to the output instructions and define the distribution over previously generated instructions as:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "p(a i,j | q i,j =COPY-OUTPUT) = softmax a i,j \u2208z 1 ,...,z i\u22121 f (h a i,j , q i,j )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Here, the affinity is computed using the decoder state h a i,j and the current state q i,j .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Finally, we embed the argument a i,j 1 and the state q i,j to generate the next state q i,j+1 . Once all arguments for o i are generated, the operation is executed to obtain v i . Then, the embedding of v i , the final state of the instruction q i,|a i | and the previous state h i are used to generate the state at the next timestamp h i+1 .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generating and Executing Instructions", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "The set of instructions z that will generate y is unobserved. Thus, given x we optimize the marginal probability function:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "p(y | x) = z\u2208Z p(y | z)p(z | x) = z\u2208Z(y) p(z | x),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "where p(y | z) is the Kronecker delta function \u03b4 e(z),y , which is 1 if the execution of z, denoted as e(z), generates y and 0 otherwise. Thus, we can redefine p(y|x), the marginal over all programs Z, as a marginal over programs that would generate y, defined as Z(y). As marginalizing over z \u2208 Z(y) is intractable, we approximate the marginal by generating samples from our model. Denote the set of samples that are generated by\u1e90(y). We maximize z \u2208\u1e90(y)p(z|x).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "However, generating programs that generate y is not trivial, as randomly sampling from the RNN distribution over instructions at each timestamp is unlikely to generate a sequence z \u2208 Z(y).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "This is analogous to the question answering work in Liang et al. (2016) , where the query that generates the correct answer must be found during inference, and training proved to be difficult without supervision. In Roy and Roth (2015) this problem is also addressed by adding prior knowledge to constrain the exponential space.", |
| "cite_spans": [ |
| { |
| "start": 52, |
| "end": 71, |
| "text": "Liang et al. (2016)", |
| "ref_id": "BIBREF11" |
| }, |
| { |
| "start": 216, |
| "end": 235, |
| "text": "Roy and Roth (2015)", |
| "ref_id": "BIBREF18" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "In our work, we leverage the fact that we are generating rationales, where there is a sense of progression within the rationale. That is, we assume that the rationale solves the problem step by step. For instance, in Problem 2, the rationale first describes the number of combinations of two cards in a deck of 52 cards, then describes the number of combinations of two kings, and finally computes the probability of drawing two kings. Thus, while generating the final answer without the rationale requires a long sequence of latent instructions, generating each of the tokens of the rationale requires far less operations.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "More formally, given the sequence z 1 , . . . , z i\u22121 generated so far, and the possible values for z i given by the network, denoted Z i , we wish to filter Z i to Z i (y k ), which denotes a set of possible options that contain at least one path capable of generating the next token at index k. Finding the set Z i (y k ) is achieved by testing all combinations of instructions that are possible with at most one level of indirection, and keeping those that can generate y k . This means that the model can only generate one intermediate value in memory (not including the operations that convert strings into floating point values and vice-versa).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "Decoding. During decoding we find the most likely sequence of instructions z given x, which can be performed with a stack-based decoder. However, it is important to refer that each generated instruction", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "z i = (o i , r i , a i,1 , . . . , a i,|a i | , v i )", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "must be executed to obtain v i . To avoid generating unexecutable code-e.g., log(0)-each hypothesis instruction is executed and removed if an error occurs. Finally, once the \" EOR \" tag is generated, we only allow instructions that would generate one of the option \"A\" to \"E\" to be generated, which guarantees that one of the options is chosen.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "for each instruction z i , the model needs to compute the probability distribution between all the attendable units c conditioned on the previous state h i\u22121 . For the attention model and input copy mechanisms, c = x 0,i\u22121 and for the output copy mechanism c = z. These operations generally involve an exponential number of matrix multiplications as the size of c and z grows. For instance, during the computation of the probabilities for the input copy mechanism in Equation 1, the affinity function f between the current context q and a given input u k is generally implemented by projecting u and q into a single vector followed by a non-linearity, which is projected into a single affinity value. Thus, for each possible input u, 3 matrix multiplications must be performed. Furthermore, for RNN unrolling, parameters and intermediate outputs for these operations must be replicated for each timestamp. Thus, as z becomes larger the attention and copy mechanisms quickly become a memory bottleneck as the computation graph becomes too large to fit on the GPU. In contrast, the sequence-to-sequence model proposed in (Sutskever et al., 2014) , does not suffer from these issues as each timestamp is dependent only on the previous state h i\u22121 .", |
| "cite_spans": [ |
| { |
| "start": 1119, |
| "end": 1143, |
| "text": "(Sutskever et al., 2014)", |
| "ref_id": "BIBREF20" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "To deal with this, we use a training method we call staged back-propagation which saves memory by considering slices of K tokens in z, rather than the full sequence. That is, to train on a minibatch where |z| = 300 with K = 100, we would actually train on 3 mini-batches, where the first batch would optimize for the first z 1:100 , the second for z 101:200 and the third for z 201:300 . The advantage of this method is that memory intensive operations, such as attention and the copy mechanism, only need to be unrolled for K steps, and K can be adjusted so that the computation graph fits in memory.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "However, unlike truncated back-propagation for language modeling, where context outside the scope of K is ignored, sequence-to-sequence models require global context. Thus, the sequence of states h is still built for the whole sequence z. Afterwards, we obtain a slice h j:j+K , and compute the attention vector. 2 Finally, the prediction of the instruction is conditioned on the LSTM state and the attention vector.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Inducing Programs while Learning", |
| "sec_num": "4" |
| }, |
| { |
| "text": "We apply our model to the task of generating rationales for solutions to math problems, evaluating it on both the quality of the rationale and the ability of the model to obtain correct answers.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Experiments", |
| "sec_num": "6" |
| }, |
| { |
| "text": "As the baseline we use the attention-based sequence to sequence model proposed by Bahdanau et al. (2014) , and proposed augmentations, allowing it to copy from the input (Ling et al., 2016) and from the output (Merity et al., 2016) .", |
| "cite_spans": [ |
| { |
| "start": 82, |
| "end": 104, |
| "text": "Bahdanau et al. (2014)", |
| "ref_id": "BIBREF1" |
| }, |
| { |
| "start": 170, |
| "end": 189, |
| "text": "(Ling et al., 2016)", |
| "ref_id": "BIBREF12" |
| }, |
| { |
| "start": 210, |
| "end": 231, |
| "text": "(Merity et al., 2016)", |
| "ref_id": "BIBREF13" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Baselines", |
| "sec_num": "6.1" |
| }, |
| { |
| "text": "We used a two-layer LSTM with a hidden size of H = 200, and word embeddings with size 200. The number of levels that the graph G is expanded during sampling D is set to 5. Decoding is performed with a beam of 200. As for the vocabulary of the softmax and embeddings, we keep the most frequent 20,000 word types, and replace the rest of the words with an unknown token. During training, the model only learns to predict a word as an unknown token, when there is no other alternative to generate the word.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Hyperparameters", |
| "sec_num": "6.2" |
| }, |
| { |
| "text": "The evaluation of the rationales is performed with average sentence level perplexity and BLEU-4 (Papineni et al., 2002) . When a model cannot generate a token for perplexity computation, we predict unknown token. This benefits the baselines as they are less expressive. As the perplexity of our model is dependent on the latent program that is generated, we force decode our model to generate the rationale, while maximizing the probability of the program. This is analogous to the method used to obtain sample programs described in Section 4, but we choose the most likely instructions at each timestamp instead of sampling. Finally, the correctness of the answer is evaluated by computing the percentage of the questions, where the chosen option matches the correct one.", |
| "cite_spans": [ |
| { |
| "start": 96, |
| "end": 119, |
| "text": "(Papineni et al., 2002)", |
| "ref_id": "BIBREF15" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation Metrics", |
| "sec_num": "6.3" |
| }, |
| { |
| "text": "The test set results, evaluated on perplexity, BLEU, and accuracy, are presented in Table 3 .", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 84, |
| "end": 91, |
| "text": "Table 3", |
| "ref_id": "TABREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "Perplexity. In terms of perplexity, we observe that the regular sequence to sequence model fares poorly on this dataset, as the model requires the generation of many values that tend to be sparse. Adding an input copy mechanism greatly improves the perplexity as it allows the generation process to use values that were mentioned in the question. The output copying mechanism improves perplexity slightly over the input copy mechanism, as many values are repeated after their first occurrence. For instance, in Problem 2, the value \"1326\" is used twice, so even though the model cannot generate it easily in the first occurrence, the second one can simply be generated by copying the first one. We can observe that our model yields significant improvements over the baselines, demonstrating that the ability to generate new values by algebraic manipulation is essential in this task. An example of a program that is inferred is shown in Figure 4 . The graph was generated by finding the most likely program z that generates y. Each node isolates a value in x, m, or y, where arrows indicate an operation executed with the outgoing nodes as arguments and incoming node as the return of the operation. For simplicity, operations that copy or convert values (e.g. from string to float) were not included, but nodes that were copied/converted share the same color. Examples of tokens where our model can obtain the perplexity reduction are the values \"0.025\", \"0.023\", \"0.002\" and finally the answer \"E\" , as these cannot be copied from the input or output.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 937, |
| "end": 945, |
| "text": "Figure 4", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "BLEU. We observe that the regular sequence to sequence model achieves a low BLEU score. In fact, due to the high perplexities the model generates very short rationales, which frequently consist of segments similar to \"Answer should be D\", as most rationales end with similar statements. By applying the copy mechanism the BLEU score improves substantially, as the model can define the variables that are used in the rationale. Interestingly, the output copy mechanism adds no further improvement in the perplexity evaluation. This is because during decoding all values that can be copied from the output are values that could have been generated by the model either from the softmax or the input copy mechanism. As such, adding an output copying mechanism adds little to the expressiveness of the model during decoding. Finally, our model can achieve the highest BLEU score as it has the mechanism to generate the intermediate and final values in the rationale.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "Accuracy. In terms of accuracy, we see that all baseline models obtain values close to chance (20%), indicating that they are completely unable to solve the problem. In contrast, we see that our model can solve problems at a rate that is significantly higher than chance, demonstrating the value of our program-driven approach, and its ability to learn to generate programs.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "In general, the problems we solve correctly correspond to simple problems that can be solved in one or two operations. Examples include questions such as \"Billy cut up each cake into 10 slices, and ended up with 120 slices altogether. How many cakes did she cut up? A) 9 B) 7 C) 12 D) 14 E) 16\", which can be solved in a single step. In this case, our model predicts \"120 / 10 = 12 cakes. Answer is C\" as the rationale, which is reasonable.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Results", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "While we show that our model can outperform the models built up to date, generating complex rationales as those shown in Figure 1 correctly is still an unsolved problem, as each additional step adds complexity to the problem both during inference and decoding. Yet, this is the first result showing that it is possible to solve math problems in such a manner, and we believe this modeling approach and dataset will drive work on this problem.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 121, |
| "end": 129, |
| "text": "Figure 1", |
| "ref_id": "FIGREF0" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Discussion.", |
| "sec_num": "6.5" |
| }, |
| { |
| "text": "Extensive efforts have been made in the domain of math problem solving (Hosseini et al., 2014; Roy and Roth, 2015) , which aim at obtaining the correct answer to a given math problem. Other work has focused on learning to map math expressions into formal languages (Roy et al., 2016) . We aim to generate natural language rationales, where the bindings between variables and the problem solving approach are mixed into a single generative model that attempts to solve the problem while explaining the approach taken.", |
| "cite_spans": [ |
| { |
| "start": 71, |
| "end": 94, |
| "text": "(Hosseini et al., 2014;", |
| "ref_id": "BIBREF6" |
| }, |
| { |
| "start": 95, |
| "end": 114, |
| "text": "Roy and Roth, 2015)", |
| "ref_id": "BIBREF18" |
| }, |
| { |
| "start": 265, |
| "end": 283, |
| "text": "(Roy et al., 2016)", |
| "ref_id": "BIBREF19" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Related Work", |
| "sec_num": "7" |
| }, |
| { |
| "text": "Our approach is strongly tied with the work on sequence to sequence transduction using the encoder-decoder paradigm (Sutskever et al., 2014; Bottle R contains 250 capsules and costs $ 6.25 . Bottle T contains 130 capsules and costs $ 2.99 . What is the difference between the cost per capsule for bottle R and the cost per capsule for bottle T ?", |
| "cite_spans": [ |
| { |
| "start": 116, |
| "end": 140, |
| "text": "(Sutskever et al., 2014;", |
| "ref_id": "BIBREF20" |
| }, |
| { |
| "start": 141, |
| "end": 141, |
| "text": "", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Related Work", |
| "sec_num": "7" |
| }, |
| { |
| "text": "(A) $ 0. Figure 4 : Illustration of the most likely latent program inferred by our algorithm to explain a held-out question-rationale pair. Bahdanau et al., 2014; Kalchbrenner and Blunsom, 2013) , and inherits ideas from the extensive literature on semantic parsing (Jones et al., 2012; Berant et al., 2013; Andreas et al., 2013; Quirk et al., 2015; Liang et al., 2016; Neelakantan et al., 2016) and program generation (Reed and de Freitas, 2016; Graves et al., 2016) , namely, the usage of an external memory, the application of different operators over values in the memory and the copying of stored values into the output sequence.", |
| "cite_spans": [ |
| { |
| "start": 140, |
| "end": 162, |
| "text": "Bahdanau et al., 2014;", |
| "ref_id": "BIBREF1" |
| }, |
| { |
| "start": 163, |
| "end": 194, |
| "text": "Kalchbrenner and Blunsom, 2013)", |
| "ref_id": "BIBREF8" |
| }, |
| { |
| "start": 266, |
| "end": 286, |
| "text": "(Jones et al., 2012;", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 287, |
| "end": 307, |
| "text": "Berant et al., 2013;", |
| "ref_id": "BIBREF2" |
| }, |
| { |
| "start": 308, |
| "end": 329, |
| "text": "Andreas et al., 2013;", |
| "ref_id": "BIBREF0" |
| }, |
| { |
| "start": 330, |
| "end": 349, |
| "text": "Quirk et al., 2015;", |
| "ref_id": "BIBREF16" |
| }, |
| { |
| "start": 350, |
| "end": 369, |
| "text": "Liang et al., 2016;", |
| "ref_id": "BIBREF11" |
| }, |
| { |
| "start": 370, |
| "end": 395, |
| "text": "Neelakantan et al., 2016)", |
| "ref_id": "BIBREF14" |
| }, |
| { |
| "start": 447, |
| "end": 467, |
| "text": "Graves et al., 2016)", |
| "ref_id": "BIBREF3" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 9, |
| "end": 17, |
| "text": "Figure 4", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Related Work", |
| "sec_num": "7" |
| }, |
| { |
| "text": "Providing textual explanations for classification decisions has begun to receive attention, as part of increased interest in creating models whose decisions can be interpreted. Lei et al. (2016) , jointly modeled both a classification decision, and the selection of the most relevant subsection of a document for making the classification decision. Hendricks et al. (2016) generate textual explanations for visual classification problems, but in contrast to our model, they first generate an answer, and then, conditional on the answer, generate an explanation. This effectively creates a post-hoc justification for a classification decision rather than a program for deducing an answer. These papers, like ours, have jointly modeled rationales and answer predictions; however, we are the first to use rationales to guide program induction.", |
| "cite_spans": [ |
| { |
| "start": 177, |
| "end": 194, |
| "text": "Lei et al. (2016)", |
| "ref_id": "BIBREF10" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Related Work", |
| "sec_num": "7" |
| }, |
| { |
| "text": "In this work, we addressed the problem of generating rationales for math problems, where the task is to not only obtain the correct answer of the problem, but also generate a description of the method used to solve the problem. To this end, we collect 100,000 question and rationale pairs, and propose a model that can generate natural language and perform arithmetic operations in the same decoding process. Experiments show that our method outperforms existing neural models, in both the fluency of the rationales that are generated and the ability to solve the problem.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "8" |
| }, |
| { |
| "text": "The embeddings of a given argument ai,j and the return value vi are obtained with a lookup table embedding and two flags indicating whether it is a string and whether it is a float. Furthermore, if the the value is a float we also add its numeric value as a feature.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "Staged Back-propagationAs it is shown inFigure 2, math rationales with more than 200 tokens are not uncommon, and with additional intermediate instructions, the size z can easily exceed 400. This poses a practical challenge for training the model. For both the attention and copy mechanisms,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "This modeling strategy is sometimes known as late fusion, as the attention vector is not used for state propagation, it is incorporated \"later\".", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| } |
| ], |
| "back_matter": [], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "Semantic parsing as machine translation", |
| "authors": [ |
| { |
| "first": "Jacob", |
| "middle": [], |
| "last": "Andreas", |
| "suffix": "" |
| }, |
| { |
| "first": "Andreas", |
| "middle": [], |
| "last": "Vlachos", |
| "suffix": "" |
| }, |
| { |
| "first": "Stephen", |
| "middle": [], |
| "last": "Clark", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "Proc. of ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Jacob Andreas, Andreas Vlachos, and Stephen Clark. 2013. Semantic parsing as machine translation. In Proc. of ACL.", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "Neural machine translation by jointly learning to align and translate", |
| "authors": [ |
| { |
| "first": "Dzmitry", |
| "middle": [], |
| "last": "Bahdanau", |
| "suffix": "" |
| }, |
| { |
| "first": "Kyunghyun", |
| "middle": [], |
| "last": "Cho", |
| "suffix": "" |
| }, |
| { |
| "first": "Yoshua", |
| "middle": [], |
| "last": "Bengio", |
| "suffix": "" |
| } |
| ], |
| "year": 2014, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Ben- gio. 2014. Neural machine translation by jointly learning to align and translate. arXiv 1409.0473.", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "Semantic parsing on freebase from question-answer pairs", |
| "authors": [ |
| { |
| "first": "Jonathan", |
| "middle": [], |
| "last": "Berant", |
| "suffix": "" |
| }, |
| { |
| "first": "Andrew", |
| "middle": [], |
| "last": "Chou", |
| "suffix": "" |
| }, |
| { |
| "first": "Roy", |
| "middle": [], |
| "last": "Frostig", |
| "suffix": "" |
| }, |
| { |
| "first": "Percy", |
| "middle": [], |
| "last": "Liang", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "Proc. of EMNLP", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. 2013. Semantic parsing on freebase from question-answer pairs. In Proc. of EMNLP.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "Hybrid computing using a neural network with dynamic external memory", |
| "authors": [ |
| { |
| "first": "Alex", |
| "middle": [], |
| "last": "Graves", |
| "suffix": "" |
| }, |
| { |
| "first": "Greg", |
| "middle": [], |
| "last": "Wayne", |
| "suffix": "" |
| }, |
| { |
| "first": "Malcolm", |
| "middle": [], |
| "last": "Reynolds", |
| "suffix": "" |
| }, |
| { |
| "first": "Tim", |
| "middle": [], |
| "last": "Harley", |
| "suffix": "" |
| }, |
| { |
| "first": "Ivo", |
| "middle": [], |
| "last": "Danihelka", |
| "suffix": "" |
| }, |
| { |
| "first": "Agnieszka", |
| "middle": [], |
| "last": "Grabska-Barwiska", |
| "suffix": "" |
| }, |
| { |
| "first": "Sergio", |
| "middle": [ |
| "Gmez" |
| ], |
| "last": "Colmenarejo", |
| "suffix": "" |
| }, |
| { |
| "first": "Edward", |
| "middle": [], |
| "last": "Grefenstette", |
| "suffix": "" |
| }, |
| { |
| "first": "Tiago", |
| "middle": [], |
| "last": "Ramalho", |
| "suffix": "" |
| }, |
| { |
| "first": "John", |
| "middle": [], |
| "last": "Agapiou", |
| "suffix": "" |
| }, |
| { |
| "first": "Adri", |
| "middle": [ |
| "Puigdomnech" |
| ], |
| "last": "Badia", |
| "suffix": "" |
| }, |
| { |
| "first": "Karl", |
| "middle": [ |
| "Moritz" |
| ], |
| "last": "Hermann", |
| "suffix": "" |
| }, |
| { |
| "first": "Yori", |
| "middle": [], |
| "last": "Zwols", |
| "suffix": "" |
| }, |
| { |
| "first": "Georg", |
| "middle": [], |
| "last": "Ostrovski", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Koray Kavukcuoglu, and Demis Hassabis", |
| "volume": "538", |
| "issue": "", |
| "pages": "471--476", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka Grabska- Barwiska, Sergio Gmez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, Adri Puigdomnech Badia, Karl Moritz Hermann, Yori Zwols, Georg Ostrovski, Adam Cain, Helen King, Christopher Summerfield, Phil Blunsom, Koray Kavukcuoglu, and Demis Hassabis. 2016. Hybrid computing using a neural network with dynamic external memory. Nature 538(7626):471- 476.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Rationalization: A neural machine translation approach to generating natural language explanations", |
| "authors": [ |
| { |
| "first": "Brent", |
| "middle": [], |
| "last": "Harrison", |
| "suffix": "" |
| }, |
| { |
| "first": "Upol", |
| "middle": [], |
| "last": "Ehsan", |
| "suffix": "" |
| }, |
| { |
| "first": "Mark", |
| "middle": [ |
| "O" |
| ], |
| "last": "Riedl", |
| "suffix": "" |
| } |
| ], |
| "year": 2017, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Brent Harrison, Upol Ehsan, and Mark O. Riedl. 2017. Rationalization: A neural machine translation ap- proach to generating natural language explanations. CoRR abs/1702.07826.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "Generating visual explanations", |
| "authors": [ |
| { |
| "first": "Lisa", |
| "middle": [ |
| "Anne" |
| ], |
| "last": "Hendricks", |
| "suffix": "" |
| }, |
| { |
| "first": "Zeynep", |
| "middle": [], |
| "last": "Akata", |
| "suffix": "" |
| }, |
| { |
| "first": "Marcus", |
| "middle": [], |
| "last": "Rohrbach", |
| "suffix": "" |
| }, |
| { |
| "first": "Jeff", |
| "middle": [], |
| "last": "Donahue", |
| "suffix": "" |
| }, |
| { |
| "first": "Bernt", |
| "middle": [], |
| "last": "Schiele", |
| "suffix": "" |
| }, |
| { |
| "first": "Trevor", |
| "middle": [], |
| "last": "Darrell", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Proc. ECCV", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Lisa Anne Hendricks, Zeynep Akata, Marcus Rohrbach, Jeff Donahue, Bernt Schiele, and Trevor Darrell. 2016. Generating visual explanations. In Proc. ECCV.", |
| "links": null |
| }, |
| "BIBREF6": { |
| "ref_id": "b6", |
| "title": "Learning to solve arithmetic word problems with verb categorization", |
| "authors": [ |
| { |
| "first": "Mohammad Javad", |
| "middle": [], |
| "last": "Hosseini", |
| "suffix": "" |
| }, |
| { |
| "first": "Hannaneh", |
| "middle": [], |
| "last": "Hajishirzi", |
| "suffix": "" |
| }, |
| { |
| "first": "Oren", |
| "middle": [], |
| "last": "Etzioni", |
| "suffix": "" |
| }, |
| { |
| "first": "Nate", |
| "middle": [], |
| "last": "Kushman", |
| "suffix": "" |
| } |
| ], |
| "year": 2014, |
| "venue": "Proc. of EMNLP", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Mohammad Javad Hosseini, Hannaneh Hajishirzi, Oren Etzioni, and Nate Kushman. 2014. Learning to solve arithmetic word problems with verb catego- rization. In Proc. of EMNLP.", |
| "links": null |
| }, |
| "BIBREF7": { |
| "ref_id": "b7", |
| "title": "Semantic parsing with bayesian tree transducers", |
| "authors": [ |
| { |
| "first": "Keeley", |
| "middle": [], |
| "last": "Bevan", |
| "suffix": "" |
| }, |
| { |
| "first": "Mark", |
| "middle": [], |
| "last": "Jones", |
| "suffix": "" |
| }, |
| { |
| "first": "Sharon", |
| "middle": [], |
| "last": "Johnson", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Goldwater", |
| "suffix": "" |
| } |
| ], |
| "year": 2012, |
| "venue": "Proc. of ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Bevan Keeley Jones, Mark Johnson, and Sharon Gold- water. 2012. Semantic parsing with bayesian tree transducers. In Proc. of ACL.", |
| "links": null |
| }, |
| "BIBREF8": { |
| "ref_id": "b8", |
| "title": "Recurrent continuous translation models", |
| "authors": [ |
| { |
| "first": "Nal", |
| "middle": [], |
| "last": "Kalchbrenner", |
| "suffix": "" |
| }, |
| { |
| "first": "Phil", |
| "middle": [], |
| "last": "Blunsom", |
| "suffix": "" |
| } |
| ], |
| "year": 2013, |
| "venue": "Proc. of EMNLP", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Nal Kalchbrenner and Phil Blunsom. 2013. Recurrent continuous translation models. In Proc. of EMNLP.", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "Learning to automatically solve algebra word problems", |
| "authors": [ |
| { |
| "first": "Nate", |
| "middle": [], |
| "last": "Kushman", |
| "suffix": "" |
| }, |
| { |
| "first": "Yoav", |
| "middle": [], |
| "last": "Artzi", |
| "suffix": "" |
| }, |
| { |
| "first": "Luke", |
| "middle": [], |
| "last": "Zettlemoyer", |
| "suffix": "" |
| }, |
| { |
| "first": "Regina", |
| "middle": [], |
| "last": "Barzilay", |
| "suffix": "" |
| } |
| ], |
| "year": 2014, |
| "venue": "Proc. of ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Nate Kushman, Yoav Artzi, Luke Zettlemoyer, and Regina Barzilay. 2014. Learning to automatically solve algebra word problems. In Proc. of ACL.", |
| "links": null |
| }, |
| "BIBREF10": { |
| "ref_id": "b10", |
| "title": "Rationalizing neural predictions", |
| "authors": [ |
| { |
| "first": "Tao", |
| "middle": [], |
| "last": "Lei", |
| "suffix": "" |
| }, |
| { |
| "first": "Regina", |
| "middle": [], |
| "last": "Barzilay", |
| "suffix": "" |
| }, |
| { |
| "first": "Tommi", |
| "middle": [], |
| "last": "Jaakkola", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Proc. of EMNLP", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Tao Lei, Regina Barzilay, and Tommi Jaakkola. 2016. Rationalizing neural predictions. In Proc. of EMNLP.", |
| "links": null |
| }, |
| "BIBREF11": { |
| "ref_id": "b11", |
| "title": "Neural symbolic machines: Learning semantic parsers on freebase with weak supervision", |
| "authors": [ |
| { |
| "first": "Chen", |
| "middle": [], |
| "last": "Liang", |
| "suffix": "" |
| }, |
| { |
| "first": "Jonathan", |
| "middle": [], |
| "last": "Berant", |
| "suffix": "" |
| }, |
| { |
| "first": "Quoc", |
| "middle": [], |
| "last": "Le", |
| "suffix": "" |
| }, |
| { |
| "first": "Kenneth", |
| "middle": [ |
| "D" |
| ], |
| "last": "Forbus", |
| "suffix": "" |
| }, |
| { |
| "first": "Ni", |
| "middle": [], |
| "last": "Lao", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Chen Liang, Jonathan Berant, Quoc Le, Kenneth D. Forbus, and Ni Lao. 2016. Neural symbolic ma- chines: Learning semantic parsers on freebase with weak supervision. arXiv 1611.00020.", |
| "links": null |
| }, |
| "BIBREF12": { |
| "ref_id": "b12", |
| "title": "Latent predictor networks for code generation", |
| "authors": [ |
| { |
| "first": "Wang", |
| "middle": [], |
| "last": "Ling", |
| "suffix": "" |
| }, |
| { |
| "first": "Edward", |
| "middle": [], |
| "last": "Grefenstette", |
| "suffix": "" |
| }, |
| { |
| "first": "Karl", |
| "middle": [ |
| "Moritz" |
| ], |
| "last": "Hermann", |
| "suffix": "" |
| }, |
| { |
| "first": "Tom\u00e1s", |
| "middle": [], |
| "last": "Kocisk\u00fd", |
| "suffix": "" |
| }, |
| { |
| "first": "Andrew", |
| "middle": [], |
| "last": "Senior", |
| "suffix": "" |
| }, |
| { |
| "first": "Fumin", |
| "middle": [], |
| "last": "Wang", |
| "suffix": "" |
| }, |
| { |
| "first": "Phil", |
| "middle": [], |
| "last": "Blunsom", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Proc. of ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Wang Ling, Edward Grefenstette, Karl Moritz Her- mann, Tom\u00e1s Kocisk\u00fd, Andrew Senior, Fumin Wang, and Phil Blunsom. 2016. Latent predictor networks for code generation. In Proc. of ACL.", |
| "links": null |
| }, |
| "BIBREF13": { |
| "ref_id": "b13", |
| "title": "Pointer sentinel mixture models", |
| "authors": [ |
| { |
| "first": "Stephen", |
| "middle": [], |
| "last": "Merity", |
| "suffix": "" |
| }, |
| { |
| "first": "Caiming", |
| "middle": [], |
| "last": "Xiong", |
| "suffix": "" |
| }, |
| { |
| "first": "James", |
| "middle": [], |
| "last": "Bradbury", |
| "suffix": "" |
| }, |
| { |
| "first": "Richard", |
| "middle": [], |
| "last": "Socher", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. 2016. Pointer sentinel mixture models. arXiv 1609.07843.", |
| "links": null |
| }, |
| "BIBREF14": { |
| "ref_id": "b14", |
| "title": "Neural programmer: Inducing latent programs with gradient descent", |
| "authors": [ |
| { |
| "first": "Arvind", |
| "middle": [], |
| "last": "Neelakantan", |
| "suffix": "" |
| }, |
| { |
| "first": "V", |
| "middle": [], |
| "last": "Quoc", |
| "suffix": "" |
| }, |
| { |
| "first": "Ilya", |
| "middle": [], |
| "last": "Le", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Sutskever", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Proc. ICLR", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Arvind Neelakantan, Quoc V. Le, and Ilya Sutskever. 2016. Neural programmer: Inducing latent pro- grams with gradient descent. In Proc. ICLR.", |
| "links": null |
| }, |
| "BIBREF15": { |
| "ref_id": "b15", |
| "title": "Bleu: A method for automatic evaluation of machine translation", |
| "authors": [ |
| { |
| "first": "Kishore", |
| "middle": [], |
| "last": "Papineni", |
| "suffix": "" |
| }, |
| { |
| "first": "Salim", |
| "middle": [], |
| "last": "Roukos", |
| "suffix": "" |
| }, |
| { |
| "first": "Todd", |
| "middle": [], |
| "last": "Ward", |
| "suffix": "" |
| }, |
| { |
| "first": "Wei-Jing", |
| "middle": [], |
| "last": "Zhu", |
| "suffix": "" |
| } |
| ], |
| "year": 2002, |
| "venue": "Proc. of ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Kishore Papineni, Salim Roukos, Todd Ward, and Wei- Jing Zhu. 2002. Bleu: A method for automatic eval- uation of machine translation. In Proc. of ACL.", |
| "links": null |
| }, |
| "BIBREF16": { |
| "ref_id": "b16", |
| "title": "Language to code: Learning semantic parsers for if-this-then-that recipes", |
| "authors": [ |
| { |
| "first": "Chris", |
| "middle": [], |
| "last": "Quirk", |
| "suffix": "" |
| }, |
| { |
| "first": "Raymond", |
| "middle": [], |
| "last": "Mooney", |
| "suffix": "" |
| }, |
| { |
| "first": "Michel", |
| "middle": [], |
| "last": "Galley", |
| "suffix": "" |
| } |
| ], |
| "year": 2015, |
| "venue": "Proc. of ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Chris Quirk, Raymond Mooney, and Michel Galley. 2015. Language to code: Learning semantic parsers for if-this-then-that recipes. In Proc. of ACL.", |
| "links": null |
| }, |
| "BIBREF17": { |
| "ref_id": "b17", |
| "title": "Neural programmer-interpreters", |
| "authors": [ |
| { |
| "first": "E", |
| "middle": [], |
| "last": "Scott", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Proc. of ICLR", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Scott E. Reed and Nando de Freitas. 2016. Neural programmer-interpreters. In Proc. of ICLR.", |
| "links": null |
| }, |
| "BIBREF18": { |
| "ref_id": "b18", |
| "title": "Solving general arithmetic word problems", |
| "authors": [ |
| { |
| "first": "Subhro", |
| "middle": [], |
| "last": "Roy", |
| "suffix": "" |
| }, |
| { |
| "first": "Dan", |
| "middle": [], |
| "last": "Roth", |
| "suffix": "" |
| } |
| ], |
| "year": 2015, |
| "venue": "Proc. of EMNLP", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Subhro Roy and Dan Roth. 2015. Solving general arithmetic word problems. In Proc. of EMNLP.", |
| "links": null |
| }, |
| "BIBREF19": { |
| "ref_id": "b19", |
| "title": "Equation parsing: Mapping sentences to grounded equations", |
| "authors": [ |
| { |
| "first": "Subhro", |
| "middle": [], |
| "last": "Roy", |
| "suffix": "" |
| }, |
| { |
| "first": "Shyam", |
| "middle": [], |
| "last": "Upadhyay", |
| "suffix": "" |
| }, |
| { |
| "first": "Dan", |
| "middle": [], |
| "last": "Roth", |
| "suffix": "" |
| } |
| ], |
| "year": 2016, |
| "venue": "Proc. of EMNLP", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Subhro Roy, Shyam Upadhyay, and Dan Roth. 2016. Equation parsing: Mapping sentences to grounded equations. In Proc. of EMNLP.", |
| "links": null |
| }, |
| "BIBREF20": { |
| "ref_id": "b20", |
| "title": "Sequence to sequence learning with neural networks. arXiv 1409", |
| "authors": [ |
| { |
| "first": "Ilya", |
| "middle": [], |
| "last": "Sutskever", |
| "suffix": "" |
| }, |
| { |
| "first": "Oriol", |
| "middle": [], |
| "last": "Vinyals", |
| "suffix": "" |
| }, |
| { |
| "first": "V", |
| "middle": [], |
| "last": "Quoc", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Le", |
| "suffix": "" |
| } |
| ], |
| "year": 2014, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. 2014. Sequence to sequence learning with neural net- works. arXiv 1409.3215.", |
| "links": null |
| }, |
| "BIBREF21": { |
| "ref_id": "b21", |
| "title": "Pointer networks", |
| "authors": [ |
| { |
| "first": "Oriol", |
| "middle": [], |
| "last": "Vinyals", |
| "suffix": "" |
| }, |
| { |
| "first": "Meire", |
| "middle": [], |
| "last": "Fortunato", |
| "suffix": "" |
| }, |
| { |
| "first": "Navdeep", |
| "middle": [], |
| "last": "Jaitly", |
| "suffix": "" |
| } |
| ], |
| "year": 2015, |
| "venue": "Proc. of NIPS", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. 2015. Pointer networks. In Proc. of NIPS.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "num": null, |
| "text": ".H.S = R.H.S which is the correct answer. answer:B Correct Option: B Examples of solved math problems.", |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF1": { |
| "num": null, |
| "text": "For instance, in Problem 1, the equation (27x + Distribution of examples per length.", |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF2": { |
| "num": null, |
| "text": "using a softmax over the set of available operations O.", |
| "type_str": "figure", |
| "uris": null |
| }, |
| "TABREF1": { |
| "num": null, |
| "text": "Descriptive statistics of our dataset.", |
| "content": "<table/>", |
| "type_str": "table", |
| "html": null |
| }, |
| "TABREF2": { |
| "num": null, |
| "text": "Example of a program z that would generate the output y. In v, italics indicates string types; bold indicates float types. Refer to \u00a73.3 for description of variable names.", |
| "content": "<table/>", |
| "type_str": "table", |
| "html": null |
| }, |
| "TABREF4": { |
| "num": null, |
| "text": "Results over the test set measured in Perplexity, BLEU and Accuracy.", |
| "content": "<table/>", |
| "type_str": "table", |
| "html": null |
| } |
| } |
| } |
| } |
