diff --git "a/parse/train/SJTQLdqlg/SJTQLdqlg_middle.json" "b/parse/train/SJTQLdqlg/SJTQLdqlg_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/SJTQLdqlg/SJTQLdqlg_middle.json" @@ -0,0 +1,28695 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 412, + 96 + ], + "lines": [ + { + "bbox": [ + 104, + 77, + 414, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 77, + 414, + 97 + ], + "score": 1.0, + "content": "LEARNING TO REMEMBER RARE EVENTS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 113, + 115, + 252, + 148 + ], + "lines": [ + { + "bbox": [ + 111, + 114, + 181, + 127 + ], + "spans": [ + { + "bbox": [ + 111, + 114, + 181, + 127 + ], + "score": 1.0, + "content": "Łukasz Kaiser∗", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 111, + 125, + 169, + 138 + ], + "spans": [ + { + "bbox": [ + 111, + 125, + 169, + 138 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 112, + 136, + 253, + 149 + ], + "spans": [ + { + "bbox": [ + 112, + 136, + 253, + 149 + ], + "score": 1.0, + "content": "lukaszkaiser@google.com", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 371, + 115, + 498, + 148 + ], + "lines": [ + { + "bbox": [ + 369, + 114, + 438, + 126 + ], + "spans": [ + { + "bbox": [ + 369, + 114, + 438, + 126 + ], + "score": 1.0, + "content": "Ofir Nachum∗†", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 371, + 126, + 428, + 137 + ], + "spans": [ + { + "bbox": [ + 371, + 126, + 428, + 137 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 371, + 137, + 499, + 149 + ], + "spans": [ + { + "bbox": [ + 371, + 137, + 499, + 149 + ], + "score": 1.0, + "content": "ofirnachum@google.com", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 113, + 165, + 210, + 198 + ], + "lines": [ + { + "bbox": [ + 111, + 163, + 166, + 177 + ], + "spans": [ + { + "bbox": [ + 111, + 163, + 166, + 177 + ], + "score": 1.0, + "content": "Aurko Roy‡", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 111, + 176, + 169, + 187 + ], + "spans": [ + { + "bbox": [ + 111, + 176, + 169, + 187 + ], + "score": 1.0, + "content": "Georgia Tech", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 111, + 187, + 210, + 199 + ], + "spans": [ + { + "bbox": [ + 111, + 187, + 210, + 199 + ], + "score": 1.0, + "content": "aurko@gatech.edu", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 369, + 165, + 473, + 199 + ], + "lines": [ + { + "bbox": [ + 368, + 164, + 428, + 178 + ], + "spans": [ + { + "bbox": [ + 368, + 164, + 428, + 178 + ], + "score": 1.0, + "content": "Samy Bengio", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 368, + 176, + 426, + 188 + ], + "spans": [ + { + "bbox": [ + 368, + 176, + 426, + 188 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 368, + 187, + 474, + 200 + ], + "spans": [ + { + "bbox": [ + 368, + 187, + 474, + 200 + ], + "score": 1.0, + "content": "bengio@google.com", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 278, + 227, + 333, + 239 + ], + "lines": [ + { + "bbox": [ + 276, + 226, + 336, + 241 + ], + "spans": [ + { + "bbox": [ + 276, + 226, + 336, + 241 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 143, + 253, + 468, + 330 + ], + "lines": [ + { + "bbox": [ + 141, + 253, + 470, + 267 + ], + "spans": [ + { + "bbox": [ + 141, + 253, + 470, + 267 + ], + "score": 1.0, + "content": "Despite recent advances, memory-augmented deep neural networks are still lim-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 264, + 469, + 277 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 469, + 277 + ], + "score": 1.0, + "content": "ited when it comes to life-long and one-shot learning, especially in remembering", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 140, + 275, + 470, + 289 + ], + "spans": [ + { + "bbox": [ + 140, + 275, + 470, + 289 + ], + "score": 1.0, + "content": "rare events. We present a large-scale life-long memory module for use in deep", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "learning. The module exploits fast nearest-neighbor algorithms for efficiency and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 298, + 469, + 309 + ], + "spans": [ + { + "bbox": [ + 141, + 298, + 469, + 309 + ], + "score": 1.0, + "content": "thus scales to large memory sizes. Except for the nearest-neighbor query, the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "score": 1.0, + "content": "module is fully differentiable and trained end-to-end with no extra supervision. It", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 318, + 457, + 333 + ], + "spans": [ + { + "bbox": [ + 141, + 318, + 457, + 333 + ], + "score": 1.0, + "content": "operates in a life-long manner, i.e., without the need to reset it during training.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 143, + 333, + 468, + 431 + ], + "lines": [ + { + "bbox": [ + 142, + 333, + 469, + 345 + ], + "spans": [ + { + "bbox": [ + 142, + 333, + 469, + 345 + ], + "score": 1.0, + "content": "Our memory module can be easily added to any part of a supervised neural net-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "spans": [ + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "score": 1.0, + "content": "work. To show its versatility we add it to a number of networks, from simple", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 354, + 470, + 367 + ], + "spans": [ + { + "bbox": [ + 141, + 354, + 470, + 367 + ], + "score": 1.0, + "content": "convolutional ones tested on image classification to deep sequence-to-sequence", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 365, + 470, + 378 + ], + "spans": [ + { + "bbox": [ + 141, + 365, + 470, + 378 + ], + "score": 1.0, + "content": "and recurrent-convolutional models. In all cases, the enhanced network gains the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 376, + 470, + 389 + ], + "spans": [ + { + "bbox": [ + 141, + 376, + 470, + 389 + ], + "score": 1.0, + "content": "ability to remember and do life-long one-shot learning. Our module remembers", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 388, + 469, + 400 + ], + "spans": [ + { + "bbox": [ + 141, + 388, + 469, + 400 + ], + "score": 1.0, + "content": "training examples shown many thousands of steps in the past and it can success-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 398, + 470, + 411 + ], + "spans": [ + { + "bbox": [ + 141, + 398, + 470, + 411 + ], + "score": 1.0, + "content": "fully generalize from them. We set new state-of-the-art for one-shot learning on", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 141, + 410, + 469, + 422 + ], + "spans": [ + { + "bbox": [ + 141, + 410, + 469, + 422 + ], + "score": 1.0, + "content": "the Omniglot dataset and demonstrate, for the first time, life-long one-shot learn-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 420, + 439, + 432 + ], + "spans": [ + { + "bbox": [ + 141, + 420, + 439, + 432 + ], + "score": 1.0, + "content": "ing in recurrent neural networks on a large-scale machine translation task.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 205, + 467 + ], + "lines": [ + { + "bbox": [ + 105, + 453, + 208, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 208, + 470 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 480, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "Machine learning systems have been successful in many domains, from computer vision", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 492, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 505, + 503 + ], + "score": 1.0, + "content": "(Krizhevsky et al., 2012) to speech recognition (Hinton et al., 2012) and machine translation", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "(Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). Neural machine translation (NMT)", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 513, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 104, + 513, + 506, + 526 + ], + "score": 1.0, + "content": "is so successful that for some language pairs it approaches, on average, the quality of human trans-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 523, + 506, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 537 + ], + "score": 1.0, + "content": "lators (Wu et al., 2016). The words on average are crucial though. When a sentence resembles one", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "score": 1.0, + "content": "from the abundant training data, the translation will be accurate. However, when encountering a", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "rare word such as Dostoevsky (in German, Dostojewski), many models will fail. The correct Ger-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 557, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 506, + 570 + ], + "score": 1.0, + "content": "man translation of Dostoevsky does not appear enough times in the training data for the model to", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 568, + 234, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 234, + 581 + ], + "score": 1.0, + "content": "sufficiently learn its translation.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 585, + 505, + 640 + ], + "lines": [ + { + "bbox": [ + 107, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 107, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "While more example sentences concerning the famous Russian author might eventually be added to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 596, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 506, + 608 + ], + "score": 1.0, + "content": "the training data, there are many other rare words or rare events of other kinds. This illustrates a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 606, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 506, + 620 + ], + "score": 1.0, + "content": "general problem with current deep learning models: it is necessary to extend the training data and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 617, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 632 + ], + "score": 1.0, + "content": "re-train them to handle such rare or new events. Humans, on the other hand, learn in a life-long", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 629, + 254, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 254, + 641 + ], + "score": 1.0, + "content": "fashion, often from single examples.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 108, + 646, + 502, + 690 + ], + "lines": [ + { + "bbox": [ + 107, + 646, + 504, + 658 + ], + "spans": [ + { + "bbox": [ + 107, + 646, + 504, + 658 + ], + "score": 1.0, + "content": "We present a life-long memory module that enables one-shot learning in a variety of neural networks.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 656, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 505, + 669 + ], + "score": 1.0, + "content": "Our memory module consists of key-value pairs. Keys are activations of a chosen layer of a neural", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "network, and values are the ground-truth targets for the given example. This way, as the network", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 679, + 504, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 504, + 691 + ], + "score": 1.0, + "content": "is trained, its memory increases and becomes more useful. Eventually it can give predictions that", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 699, + 469, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 698, + 258, + 712 + ], + "spans": [ + { + "bbox": [ + 118, + 698, + 258, + 712 + ], + "score": 1.0, + "content": "∗First two authors contributed equally.", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 708, + 470, + 723 + ], + "spans": [ + { + "bbox": [ + 118, + 708, + 470, + 723 + ], + "score": 1.0, + "content": "†Work done as a member of the Google Brain Residency program (g.co/brainresidency).", + "type": "text" + } + ] + }, + { + "bbox": [ + 117, + 718, + 290, + 734 + ], + "spans": [ + { + "bbox": [ + 117, + 718, + 290, + 734 + ], + "score": 1.0, + "content": "‡Work done during internship at Google Brain.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 412, + 96 + ], + "lines": [ + { + "bbox": [ + 104, + 77, + 414, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 77, + 414, + 97 + ], + "score": 1.0, + "content": "LEARNING TO REMEMBER RARE EVENTS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "list", + "bbox": [ + 113, + 115, + 252, + 148 + ], + "lines": [ + { + "bbox": [ + 111, + 114, + 181, + 127 + ], + "spans": [ + { + "bbox": [ + 111, + 114, + 181, + 127 + ], + "score": 1.0, + "content": "Łukasz Kaiser∗", + "type": "text" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 125, + 169, + 138 + ], + "spans": [ + { + "bbox": [ + 111, + 125, + 169, + 138 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 136, + 253, + 149 + ], + "spans": [ + { + "bbox": [ + 112, + 136, + 253, + 149 + ], + "score": 1.0, + "content": "lukaszkaiser@google.com", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 369, + 114, + 438, + 126 + ], + "spans": [ + { + "bbox": [ + 369, + 114, + 438, + 126 + ], + "score": 1.0, + "content": "Ofir Nachum∗†", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 371, + 126, + 428, + 137 + ], + "spans": [ + { + "bbox": [ + 371, + 126, + 428, + 137 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 371, + 137, + 499, + 149 + ], + "spans": [ + { + "bbox": [ + 371, + 137, + 499, + 149 + ], + "score": 1.0, + "content": "ofirnachum@google.com", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 163, + 166, + 177 + ], + "spans": [ + { + "bbox": [ + 111, + 163, + 166, + 177 + ], + "score": 1.0, + "content": "Aurko Roy‡", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 176, + 169, + 187 + ], + "spans": [ + { + "bbox": [ + 111, + 176, + 169, + 187 + ], + "score": 1.0, + "content": "Georgia Tech", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 187, + 210, + 199 + ], + "spans": [ + { + "bbox": [ + 111, + 187, + 210, + 199 + ], + "score": 1.0, + "content": "aurko@gatech.edu", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 368, + 164, + 428, + 178 + ], + "spans": [ + { + "bbox": [ + 368, + 164, + 428, + 178 + ], + "score": 1.0, + "content": "Samy Bengio", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 368, + 176, + 426, + 188 + ], + "spans": [ + { + "bbox": [ + 368, + 176, + 426, + 188 + ], + "score": 1.0, + "content": "Google Brain", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 368, + 187, + 474, + 200 + ], + "spans": [ + { + "bbox": [ + 368, + 187, + 474, + 200 + ], + "score": 1.0, + "content": "bengio@google.com", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + } + ], + "index": 3, + "bbox_fs": [ + 111, + 114, + 253, + 149 + ] + }, + { + "type": "list", + "bbox": [ + 371, + 115, + 498, + 148 + ], + "lines": [], + "index": 4, + "bbox_fs": [ + 369, + 114, + 499, + 149 + ], + "lines_deleted": true + }, + { + "type": "list", + "bbox": [ + 113, + 165, + 210, + 198 + ], + "lines": [], + "index": 9, + "bbox_fs": [ + 111, + 163, + 210, + 199 + ], + "lines_deleted": true + }, + { + "type": "list", + "bbox": [ + 369, + 165, + 473, + 199 + ], + "lines": [], + "index": 10, + "bbox_fs": [ + 368, + 164, + 474, + 200 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 278, + 227, + 333, + 239 + ], + "lines": [ + { + "bbox": [ + 276, + 226, + 336, + 241 + ], + "spans": [ + { + "bbox": [ + 276, + 226, + 336, + 241 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 143, + 253, + 468, + 330 + ], + "lines": [ + { + "bbox": [ + 141, + 253, + 470, + 267 + ], + "spans": [ + { + "bbox": [ + 141, + 253, + 470, + 267 + ], + "score": 1.0, + "content": "Despite recent advances, memory-augmented deep neural networks are still lim-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 264, + 469, + 277 + ], + "spans": [ + { + "bbox": [ + 141, + 264, + 469, + 277 + ], + "score": 1.0, + "content": "ited when it comes to life-long and one-shot learning, especially in remembering", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 140, + 275, + 470, + 289 + ], + "spans": [ + { + "bbox": [ + 140, + 275, + 470, + 289 + ], + "score": 1.0, + "content": "rare events. We present a large-scale life-long memory module for use in deep", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "spans": [ + { + "bbox": [ + 141, + 286, + 470, + 299 + ], + "score": 1.0, + "content": "learning. The module exploits fast nearest-neighbor algorithms for efficiency and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 298, + 469, + 309 + ], + "spans": [ + { + "bbox": [ + 141, + 298, + 469, + 309 + ], + "score": 1.0, + "content": "thus scales to large memory sizes. Except for the nearest-neighbor query, the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "spans": [ + { + "bbox": [ + 141, + 308, + 470, + 321 + ], + "score": 1.0, + "content": "module is fully differentiable and trained end-to-end with no extra supervision. It", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 318, + 457, + 333 + ], + "spans": [ + { + "bbox": [ + 141, + 318, + 457, + 333 + ], + "score": 1.0, + "content": "operates in a life-long manner, i.e., without the need to reset it during training.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 140, + 253, + 470, + 333 + ] + }, + { + "type": "text", + "bbox": [ + 143, + 333, + 468, + 431 + ], + "lines": [ + { + "bbox": [ + 142, + 333, + 469, + 345 + ], + "spans": [ + { + "bbox": [ + 142, + 333, + 469, + 345 + ], + "score": 1.0, + "content": "Our memory module can be easily added to any part of a supervised neural net-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "spans": [ + { + "bbox": [ + 141, + 343, + 469, + 356 + ], + "score": 1.0, + "content": "work. To show its versatility we add it to a number of networks, from simple", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 354, + 470, + 367 + ], + "spans": [ + { + "bbox": [ + 141, + 354, + 470, + 367 + ], + "score": 1.0, + "content": "convolutional ones tested on image classification to deep sequence-to-sequence", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 365, + 470, + 378 + ], + "spans": [ + { + "bbox": [ + 141, + 365, + 470, + 378 + ], + "score": 1.0, + "content": "and recurrent-convolutional models. In all cases, the enhanced network gains the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 376, + 470, + 389 + ], + "spans": [ + { + "bbox": [ + 141, + 376, + 470, + 389 + ], + "score": 1.0, + "content": "ability to remember and do life-long one-shot learning. Our module remembers", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 388, + 469, + 400 + ], + "spans": [ + { + "bbox": [ + 141, + 388, + 469, + 400 + ], + "score": 1.0, + "content": "training examples shown many thousands of steps in the past and it can success-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 398, + 470, + 411 + ], + "spans": [ + { + "bbox": [ + 141, + 398, + 470, + 411 + ], + "score": 1.0, + "content": "fully generalize from them. We set new state-of-the-art for one-shot learning on", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 141, + 410, + 469, + 422 + ], + "spans": [ + { + "bbox": [ + 141, + 410, + 469, + 422 + ], + "score": 1.0, + "content": "the Omniglot dataset and demonstrate, for the first time, life-long one-shot learn-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 141, + 420, + 439, + 432 + ], + "spans": [ + { + "bbox": [ + 141, + 420, + 439, + 432 + ], + "score": 1.0, + "content": "ing in recurrent neural networks on a large-scale machine translation task.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 25, + "bbox_fs": [ + 141, + 333, + 470, + 432 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 205, + 467 + ], + "lines": [ + { + "bbox": [ + 105, + 453, + 208, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 208, + 470 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 480, + 505, + 579 + ], + "lines": [ + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "Machine learning systems have been successful in many domains, from computer vision", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 492, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 505, + 503 + ], + "score": 1.0, + "content": "(Krizhevsky et al., 2012) to speech recognition (Hinton et al., 2012) and machine translation", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 505, + 515 + ], + "score": 1.0, + "content": "(Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). Neural machine translation (NMT)", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 513, + 506, + 526 + ], + "spans": [ + { + "bbox": [ + 104, + 513, + 506, + 526 + ], + "score": 1.0, + "content": "is so successful that for some language pairs it approaches, on average, the quality of human trans-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 523, + 506, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 537 + ], + "score": 1.0, + "content": "lators (Wu et al., 2016). The words on average are crucial though. When a sentence resembles one", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "score": 1.0, + "content": "from the abundant training data, the translation will be accurate. However, when encountering a", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "rare word such as Dostoevsky (in German, Dostojewski), many models will fail. The correct Ger-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 557, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 506, + 570 + ], + "score": 1.0, + "content": "man translation of Dostoevsky does not appear enough times in the training data for the model to", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 568, + 234, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 234, + 581 + ], + "score": 1.0, + "content": "sufficiently learn its translation.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 35, + "bbox_fs": [ + 104, + 480, + 506, + 581 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 585, + 505, + 640 + ], + "lines": [ + { + "bbox": [ + 107, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 107, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "While more example sentences concerning the famous Russian author might eventually be added to", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 596, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 506, + 608 + ], + "score": 1.0, + "content": "the training data, there are many other rare words or rare events of other kinds. This illustrates a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 606, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 506, + 620 + ], + "score": 1.0, + "content": "general problem with current deep learning models: it is necessary to extend the training data and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 617, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 632 + ], + "score": 1.0, + "content": "re-train them to handle such rare or new events. Humans, on the other hand, learn in a life-long", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 629, + 254, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 254, + 641 + ], + "score": 1.0, + "content": "fashion, often from single examples.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 585, + 506, + 641 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 646, + 502, + 690 + ], + "lines": [ + { + "bbox": [ + 107, + 646, + 504, + 658 + ], + "spans": [ + { + "bbox": [ + 107, + 646, + 504, + 658 + ], + "score": 1.0, + "content": "We present a life-long memory module that enables one-shot learning in a variety of neural networks.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 656, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 505, + 669 + ], + "score": 1.0, + "content": "Our memory module consists of key-value pairs. Keys are activations of a chosen layer of a neural", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "network, and values are the ground-truth targets for the given example. This way, as the network", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 679, + 504, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 504, + 691 + ], + "score": 1.0, + "content": "is trained, its memory increases and becomes more useful. Eventually it can give predictions that", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "leverage on knowledge from past data with similar activations. Given a new example, the network", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 493, + 107 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 493, + 107 + ], + "score": 1.0, + "content": "writes it to memory and is able to use it afterwards, even if the example was presented just once.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 646, + 505, + 691 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "leverage on knowledge from past data with similar activations. Given a new example, the network", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 493, + 107 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 493, + 107 + ], + "score": 1.0, + "content": "writes it to memory and is able to use it afterwards, even if the example was presented just once.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 504, + 166 + ], + "lines": [ + { + "bbox": [ + 105, + 109, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 109, + 505, + 124 + ], + "score": 1.0, + "content": "There are many advantages of having a long-term memory. One-shot learning is a desirable property", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "in its own right, and some tasks, as we will show below, are simply not solvable without it. Even", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "real-world tasks where we have large training sets, such as translation, can benefit from long-term", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "memory. Finally, since the memory can be traced back to training examples, it might help explain", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 460, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 460, + 167 + ], + "score": 1.0, + "content": "the decisions that the model is making and thus improve understandability of the model.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 171, + 505, + 204 + ], + "lines": [ + { + "bbox": [ + 105, + 171, + 505, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 171, + 505, + 184 + ], + "score": 1.0, + "content": "It is not immediately clear how to measure the performance of a life-long one-shot learning model,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "since most deep learning evaluations focus on the average performance and do not have a one-shot", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 499, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 499, + 206 + ], + "score": 1.0, + "content": "component. We therefore evaluate in a few ways, to show that our memory module indeed works:", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 213, + 506, + 343 + ], + "lines": [ + { + "bbox": [ + 107, + 214, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 107, + 214, + 505, + 226 + ], + "score": 1.0, + "content": "(1) We evaluate on the well-known one-shot learning task Omniglot, which is the only dataset with", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 122, + 223, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 122, + 223, + 506, + 239 + ], + "score": 1.0, + "content": "explicit one-shot learning evaluation. This dataset is small and does not benefit from life-long", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 122, + 236, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 122, + 236, + 505, + 249 + ], + "score": 1.0, + "content": "learning capability of our module, but we still exceed the best previous results and set new", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 123, + 247, + 187, + 259 + ], + "spans": [ + { + "bbox": [ + 123, + 247, + 187, + 259 + ], + "score": 1.0, + "content": "state-of-the-art.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 261, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 107, + 261, + 505, + 274 + ], + "score": 1.0, + "content": "(2) We devise a synthetic task that requires life-long one-shot learning. On this task, standard", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 122, + 272, + 450, + 286 + ], + "spans": [ + { + "bbox": [ + 122, + 272, + 450, + 286 + ], + "score": 1.0, + "content": "models fare poorly while our model can solve it well, demonstrating its strengths.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 107, + 286, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 107, + 286, + 505, + 301 + ], + "score": 1.0, + "content": "(3) Finally, we train an English-German translation model that has our life-long one-shot learning", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 121, + 297, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 121, + 297, + 505, + 313 + ], + "score": 1.0, + "content": "module. It retains very good performance on average and is also capable of one-shot learning.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 122, + 309, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 122, + 309, + 505, + 323 + ], + "score": 1.0, + "content": "On the qualitative side, we find that it can translate rarely-occurring words like Dostoevsky.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 122, + 320, + 506, + 333 + ], + "spans": [ + { + "bbox": [ + 122, + 320, + 506, + 333 + ], + "score": 1.0, + "content": "On the quantitative side, we see that the BLEU score for the generated translations can be", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 123, + 331, + 423, + 344 + ], + "spans": [ + { + "bbox": [ + 123, + 331, + 423, + 344 + ], + "score": 1.0, + "content": "significantly increased by showing it related translations before evaluating.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 108, + 359, + 224, + 372 + ], + "lines": [ + { + "bbox": [ + 104, + 357, + 226, + 374 + ], + "spans": [ + { + "bbox": [ + 104, + 357, + 226, + 374 + ], + "score": 1.0, + "content": "2 MEMORY MODULE", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 383, + 505, + 428 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 244, + 396 + ], + "score": 1.0, + "content": "Our memory consists of a matrix", + "type": "text" + }, + { + "bbox": [ + 244, + 384, + 254, + 394 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 383, + 362, + 396 + ], + "score": 1.0, + "content": "of memory keys, a vector", + "type": "text" + }, + { + "bbox": [ + 363, + 384, + 372, + 394 + ], + "score": 0.78, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "of memory values, and an addi-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 159, + 408 + ], + "score": 1.0, + "content": "tional vector", + "type": "text" + }, + { + "bbox": [ + 160, + 396, + 168, + 405 + ], + "score": 0.79, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 394, + 505, + 408 + ], + "score": 1.0, + "content": "that tracks the age of items stored in memory. Keys can be arbitrary vectors of size", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 406, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 107, + 407, + 155, + 417 + ], + "score": 0.54, + "content": "{ \\mathrm { k e y } } - s { \\mathrm { i } } z { \\mathrm { e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 406, + 505, + 418 + ], + "score": 1.0, + "content": ", and we assume that the memory values are single integers representing a class or token", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 416, + 348, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 348, + 429 + ], + "score": 1.0, + "content": "ID. We define a memory of size memory-size as a triple:", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "interline_equation", + "bbox": [ + 179, + 433, + 431, + 447 + ], + "lines": [ + { + "bbox": [ + 179, + 433, + 431, + 447 + ], + "spans": [ + { + "bbox": [ + 179, + 433, + 431, + 447 + ], + "score": 0.88, + "content": "\\mathcal { M } = ( K _ { \\mathrm { m e m o r y - s i z e } \\times \\mathrm { k e y - s i z e } } , ~ V _ { \\mathrm { m e m o r y - s i z e } } , ~ A _ { \\mathrm { m e m o r y - s i z e } } ) .", + "type": "interline_equation", + "image_path": "4d094333e0364c1022d04cb764b0856863c3efe2bc3daec41d71b71044517129.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 179, + 433, + 431, + 447 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 458, + 504, + 491 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 466, + 471 + ], + "score": 1.0, + "content": "A memory query is a vector of size key-size which we assume to be normalized, i.e.,", + "type": "text" + }, + { + "bbox": [ + 466, + 458, + 501, + 470 + ], + "score": 0.93, + "content": "\\| q \\| = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 457, + 505, + 471 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 165, + 482 + ], + "score": 1.0, + "content": "Given a query", + "type": "text" + }, + { + "bbox": [ + 165, + 471, + 171, + 480 + ], + "score": 0.79, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 468, + 310, + 482 + ], + "score": 1.0, + "content": ", we define the nearest neighbor of", + "type": "text" + }, + { + "bbox": [ + 310, + 471, + 316, + 481 + ], + "score": 0.82, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 468, + 328, + 482 + ], + "score": 1.0, + "content": "in", + "type": "text" + }, + { + "bbox": [ + 328, + 470, + 341, + 479 + ], + "score": 0.83, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 341, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "as any of the keys that maximize the dot", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 480, + 170, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 159, + 493 + ], + "score": 1.0, + "content": "product with", + "type": "text" + }, + { + "bbox": [ + 160, + 482, + 166, + 492 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 480, + 170, + 493 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "interline_equation", + "bbox": [ + 240, + 490, + 371, + 504 + ], + "lines": [ + { + "bbox": [ + 240, + 490, + 371, + 504 + ], + "spans": [ + { + "bbox": [ + 240, + 490, + 371, + 504 + ], + "score": 0.91, + "content": "\\operatorname { N N } ( q , \\mathcal { M } ) = \\operatorname { a r g m a x } _ { i } q \\cdot K [ i ] .", + "type": "interline_equation", + "image_path": "9d429d010560f5484bdf780ca6e9411504c7461104f9b6f874434c579802e267.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 240, + 490, + 371, + 504 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 506, + 505, + 540 + ], + "lines": [ + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "Since the keys are normalized, the above notion corresponds to the nearest neighbor with respect", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 378, + 529 + ], + "score": 1.0, + "content": "to cosine similarity. We will also use the natural extension of it to", + "type": "text" + }, + { + "bbox": [ + 379, + 517, + 385, + 527 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "nearest neighbors, which we", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 527, + 482, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 135, + 541 + ], + "score": 1.0, + "content": "denote", + "type": "text" + }, + { + "bbox": [ + 136, + 528, + 185, + 540 + ], + "score": 0.92, + "content": "\\mathrm { N N } _ { k } ( q , \\mathcal { M } )", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 527, + 371, + 541 + ], + "score": 1.0, + "content": ". In our experiments we always used the set of", + "type": "text" + }, + { + "bbox": [ + 371, + 528, + 406, + 538 + ], + "score": 0.89, + "content": "k = 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 527, + 482, + 541 + ], + "score": 1.0, + "content": "nearest neighbors.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 544, + 504, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 191, + 558 + ], + "score": 1.0, + "content": "When given a query", + "type": "text" + }, + { + "bbox": [ + 192, + 547, + 198, + 556 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 543, + 254, + 558 + ], + "score": 1.0, + "content": ", the memory", + "type": "text" + }, + { + "bbox": [ + 254, + 544, + 321, + 557 + ], + "score": 0.93, + "content": "\\mathcal { M } = ( K , V , A )", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 543, + 379, + 558 + ], + "score": 1.0, + "content": "will compute", + "type": "text" + }, + { + "bbox": [ + 379, + 545, + 386, + 555 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 543, + 505, + 558 + ], + "score": 1.0, + "content": "nearest neighbors (sorted by", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 556, + 226, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 226, + 568 + ], + "score": 1.0, + "content": "decreasing cosine similarity):", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "interline_equation", + "bbox": [ + 248, + 565, + 363, + 579 + ], + "lines": [ + { + "bbox": [ + 248, + 565, + 363, + 579 + ], + "spans": [ + { + "bbox": [ + 248, + 565, + 363, + 579 + ], + "score": 0.92, + "content": "( n _ { 1 } , \\dots , n _ { k } ) = \\Nu \\Nu _ { k } ( q , { \\mathcal { M } } )", + "type": "interline_equation", + "image_path": "40ce1960e7101f9b3d4fbc83b8ab1967ce2f34b96b6a44956a361874e8718032.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 248, + 565, + 363, + 579 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 581, + 505, + 637 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 264, + 594 + ], + "score": 1.0, + "content": "and return, as the main result, the value", + "type": "text" + }, + { + "bbox": [ + 264, + 581, + 289, + 593 + ], + "score": 0.89, + "content": "V [ n _ { 1 } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 582, + 505, + 594 + ], + "score": 1.0, + "content": ". Additionally, we will compute the cosine similarities", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 107, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 107, + 592, + 165, + 604 + ], + "score": 0.93, + "content": "d _ { i } = \\boldsymbol { q } \\cdot \\boldsymbol { K } [ n _ { i } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 592, + 242, + 605 + ], + "score": 1.0, + "content": "and return softmax", + "type": "text" + }, + { + "bbox": [ + 242, + 593, + 312, + 604 + ], + "score": 0.72, + "content": "( d _ { 1 } \\cdot t , \\ldots , d _ { k } \\cdot t )", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 592, + 375, + 605 + ], + "score": 1.0, + "content": ". The parameter", + "type": "text" + }, + { + "bbox": [ + 376, + 594, + 381, + 602 + ], + "score": 0.7, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "denotes the inverse of softmax", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 603, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 218, + 617 + ], + "score": 1.0, + "content": "temperature and we set it to", + "type": "text" + }, + { + "bbox": [ + 218, + 604, + 246, + 614 + ], + "score": 0.9, + "content": "t = 4 0", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 603, + 505, + 617 + ], + "score": 1.0, + "content": "in our experiments. In models where the memory output is again", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "score": 1.0, + "content": "embedded into a dense vector, we multiply the embedded output by the corresponding softmax", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 625, + 385, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 385, + 639 + ], + "score": 1.0, + "content": "component so as to provide a signal about confidence of the memory.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 642, + 504, + 675 + ], + "lines": [ + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "score": 1.0, + "content": "The forward computation of the memory module is thus very simple, the only interesting part being", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 653, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 506, + 666 + ], + "score": 1.0, + "content": "how to compute nearest neighbors efficiently, which we discuss below. But we must also answer the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 664, + 254, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 254, + 676 + ], + "score": 1.0, + "content": "question how the memory is trained.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 344, + 700 + ], + "score": 1.0, + "content": "Memory Loss. Assume now that in addition to a query", + "type": "text" + }, + { + "bbox": [ + 344, + 690, + 351, + 699 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "we are also given the correct desired", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 183, + 711 + ], + "score": 1.0, + "content": "(supervised) value", + "type": "text" + }, + { + "bbox": [ + 183, + 701, + 190, + 709 + ], + "score": 0.72, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 699, + 330, + 711 + ], + "score": 1.0, + "content": ". In the case of classification, this", + "type": "text" + }, + { + "bbox": [ + 330, + 701, + 336, + 709 + ], + "score": 0.77, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 337, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "would be the class label. In a sequence-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 179, + 723 + ], + "score": 1.0, + "content": "to-sequence task,", + "type": "text" + }, + { + "bbox": [ + 180, + 712, + 186, + 720 + ], + "score": 0.65, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "would be the desired output token of the current time step. After computing", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 121, + 733 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 721, + 128, + 730 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 720, + 203, + 733 + ], + "score": 1.0, + "content": "nearest neighbors", + "type": "text" + }, + { + "bbox": [ + 203, + 721, + 255, + 732 + ], + "score": 0.92, + "content": "( n _ { 1 } , \\ldots , n _ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 720, + 308, + 733 + ], + "score": 1.0, + "content": "as above, let", + "type": "text" + }, + { + "bbox": [ + 309, + 722, + 315, + 732 + ], + "score": 0.81, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 720, + 442, + 733 + ], + "score": 1.0, + "content": "be the smallest index such that", + "type": "text" + }, + { + "bbox": [ + 442, + 720, + 487, + 733 + ], + "score": 0.94, + "content": "V [ n _ { p } ] = { \\bar { v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 106, + 82, + 505, + 107 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 504, + 166 + ], + "lines": [ + { + "bbox": [ + 105, + 109, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 109, + 505, + 124 + ], + "score": 1.0, + "content": "There are many advantages of having a long-term memory. One-shot learning is a desirable property", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "in its own right, and some tasks, as we will show below, are simply not solvable without it. Even", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 506, + 145 + ], + "score": 1.0, + "content": "real-world tasks where we have large training sets, such as translation, can benefit from long-term", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "memory. Finally, since the memory can be traced back to training examples, it might help explain", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 460, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 460, + 167 + ], + "score": 1.0, + "content": "the decisions that the model is making and thus improve understandability of the model.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 109, + 506, + 167 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 171, + 505, + 204 + ], + "lines": [ + { + "bbox": [ + 105, + 171, + 505, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 171, + 505, + 184 + ], + "score": 1.0, + "content": "It is not immediately clear how to measure the performance of a life-long one-shot learning model,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "since most deep learning evaluations focus on the average performance and do not have a one-shot", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 499, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 499, + 206 + ], + "score": 1.0, + "content": "component. We therefore evaluate in a few ways, to show that our memory module indeed works:", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 171, + 505, + 206 + ] + }, + { + "type": "list", + "bbox": [ + 106, + 213, + 506, + 343 + ], + "lines": [ + { + "bbox": [ + 107, + 214, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 107, + 214, + 505, + 226 + ], + "score": 1.0, + "content": "(1) We evaluate on the well-known one-shot learning task Omniglot, which is the only dataset with", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 122, + 223, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 122, + 223, + 506, + 239 + ], + "score": 1.0, + "content": "explicit one-shot learning evaluation. This dataset is small and does not benefit from life-long", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 122, + 236, + 505, + 249 + ], + "spans": [ + { + "bbox": [ + 122, + 236, + 505, + 249 + ], + "score": 1.0, + "content": "learning capability of our module, but we still exceed the best previous results and set new", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 123, + 247, + 187, + 259 + ], + "spans": [ + { + "bbox": [ + 123, + 247, + 187, + 259 + ], + "score": 1.0, + "content": "state-of-the-art.", + "type": "text" + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 261, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 107, + 261, + 505, + 274 + ], + "score": 1.0, + "content": "(2) We devise a synthetic task that requires life-long one-shot learning. On this task, standard", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 122, + 272, + 450, + 286 + ], + "spans": [ + { + "bbox": [ + 122, + 272, + 450, + 286 + ], + "score": 1.0, + "content": "models fare poorly while our model can solve it well, demonstrating its strengths.", + "type": "text" + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 286, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 107, + 286, + 505, + 301 + ], + "score": 1.0, + "content": "(3) Finally, we train an English-German translation model that has our life-long one-shot learning", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 121, + 297, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 121, + 297, + 505, + 313 + ], + "score": 1.0, + "content": "module. It retains very good performance on average and is also capable of one-shot learning.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 122, + 309, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 122, + 309, + 505, + 323 + ], + "score": 1.0, + "content": "On the qualitative side, we find that it can translate rarely-occurring words like Dostoevsky.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 122, + 320, + 506, + 333 + ], + "spans": [ + { + "bbox": [ + 122, + 320, + 506, + 333 + ], + "score": 1.0, + "content": "On the quantitative side, we see that the BLEU score for the generated translations can be", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 123, + 331, + 423, + 344 + ], + "spans": [ + { + "bbox": [ + 123, + 331, + 423, + 344 + ], + "score": 1.0, + "content": "significantly increased by showing it related translations before evaluating.", + "type": "text" + } + ], + "index": 20, + "is_list_end_line": true + } + ], + "index": 15, + "bbox_fs": [ + 107, + 214, + 506, + 344 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 359, + 224, + 372 + ], + "lines": [ + { + "bbox": [ + 104, + 357, + 226, + 374 + ], + "spans": [ + { + "bbox": [ + 104, + 357, + 226, + 374 + ], + "score": 1.0, + "content": "2 MEMORY MODULE", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 383, + 505, + 428 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 244, + 396 + ], + "score": 1.0, + "content": "Our memory consists of a matrix", + "type": "text" + }, + { + "bbox": [ + 244, + 384, + 254, + 394 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 383, + 362, + 396 + ], + "score": 1.0, + "content": "of memory keys, a vector", + "type": "text" + }, + { + "bbox": [ + 363, + 384, + 372, + 394 + ], + "score": 0.78, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 383, + 505, + 396 + ], + "score": 1.0, + "content": "of memory values, and an addi-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 159, + 408 + ], + "score": 1.0, + "content": "tional vector", + "type": "text" + }, + { + "bbox": [ + 160, + 396, + 168, + 405 + ], + "score": 0.79, + "content": "A", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 394, + 505, + 408 + ], + "score": 1.0, + "content": "that tracks the age of items stored in memory. Keys can be arbitrary vectors of size", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 107, + 406, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 107, + 407, + 155, + 417 + ], + "score": 0.54, + "content": "{ \\mathrm { k e y } } - s { \\mathrm { i } } z { \\mathrm { e } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 406, + 505, + 418 + ], + "score": 1.0, + "content": ", and we assume that the memory values are single integers representing a class or token", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 416, + 348, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 348, + 429 + ], + "score": 1.0, + "content": "ID. We define a memory of size memory-size as a triple:", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 383, + 505, + 429 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 179, + 433, + 431, + 447 + ], + "lines": [ + { + "bbox": [ + 179, + 433, + 431, + 447 + ], + "spans": [ + { + "bbox": [ + 179, + 433, + 431, + 447 + ], + "score": 0.88, + "content": "\\mathcal { M } = ( K _ { \\mathrm { m e m o r y - s i z e } \\times \\mathrm { k e y - s i z e } } , ~ V _ { \\mathrm { m e m o r y - s i z e } } , ~ A _ { \\mathrm { m e m o r y - s i z e } } ) .", + "type": "interline_equation", + "image_path": "4d094333e0364c1022d04cb764b0856863c3efe2bc3daec41d71b71044517129.jpg" + } + ] + } + ], + "index": 26, + "virtual_lines": [ + { + "bbox": [ + 179, + 433, + 431, + 447 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 458, + 504, + 491 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 466, + 471 + ], + "score": 1.0, + "content": "A memory query is a vector of size key-size which we assume to be normalized, i.e.,", + "type": "text" + }, + { + "bbox": [ + 466, + 458, + 501, + 470 + ], + "score": 0.93, + "content": "\\| q \\| = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 457, + 505, + 471 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 468, + 165, + 482 + ], + "score": 1.0, + "content": "Given a query", + "type": "text" + }, + { + "bbox": [ + 165, + 471, + 171, + 480 + ], + "score": 0.79, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 468, + 310, + 482 + ], + "score": 1.0, + "content": ", we define the nearest neighbor of", + "type": "text" + }, + { + "bbox": [ + 310, + 471, + 316, + 481 + ], + "score": 0.82, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 468, + 328, + 482 + ], + "score": 1.0, + "content": "in", + "type": "text" + }, + { + "bbox": [ + 328, + 470, + 341, + 479 + ], + "score": 0.83, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 341, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "as any of the keys that maximize the dot", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 480, + 170, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 159, + 493 + ], + "score": 1.0, + "content": "product with", + "type": "text" + }, + { + "bbox": [ + 160, + 482, + 166, + 492 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 480, + 170, + 493 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 457, + 506, + 493 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 240, + 490, + 371, + 504 + ], + "lines": [ + { + "bbox": [ + 240, + 490, + 371, + 504 + ], + "spans": [ + { + "bbox": [ + 240, + 490, + 371, + 504 + ], + "score": 0.91, + "content": "\\operatorname { N N } ( q , \\mathcal { M } ) = \\operatorname { a r g m a x } _ { i } q \\cdot K [ i ] .", + "type": "interline_equation", + "image_path": "9d429d010560f5484bdf780ca6e9411504c7461104f9b6f874434c579802e267.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 240, + 490, + 371, + 504 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 506, + 505, + 540 + ], + "lines": [ + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 506, + 505, + 518 + ], + "score": 1.0, + "content": "Since the keys are normalized, the above notion corresponds to the nearest neighbor with respect", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 516, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 378, + 529 + ], + "score": 1.0, + "content": "to cosine similarity. We will also use the natural extension of it to", + "type": "text" + }, + { + "bbox": [ + 379, + 517, + 385, + 527 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 516, + 506, + 529 + ], + "score": 1.0, + "content": "nearest neighbors, which we", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 527, + 482, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 135, + 541 + ], + "score": 1.0, + "content": "denote", + "type": "text" + }, + { + "bbox": [ + 136, + 528, + 185, + 540 + ], + "score": 0.92, + "content": "\\mathrm { N N } _ { k } ( q , \\mathcal { M } )", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 527, + 371, + 541 + ], + "score": 1.0, + "content": ". In our experiments we always used the set of", + "type": "text" + }, + { + "bbox": [ + 371, + 528, + 406, + 538 + ], + "score": 0.89, + "content": "k = 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 527, + 482, + 541 + ], + "score": 1.0, + "content": "nearest neighbors.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 506, + 506, + 541 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 544, + 504, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 191, + 558 + ], + "score": 1.0, + "content": "When given a query", + "type": "text" + }, + { + "bbox": [ + 192, + 547, + 198, + 556 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 543, + 254, + 558 + ], + "score": 1.0, + "content": ", the memory", + "type": "text" + }, + { + "bbox": [ + 254, + 544, + 321, + 557 + ], + "score": 0.93, + "content": "\\mathcal { M } = ( K , V , A )", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 543, + 379, + 558 + ], + "score": 1.0, + "content": "will compute", + "type": "text" + }, + { + "bbox": [ + 379, + 545, + 386, + 555 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 543, + 505, + 558 + ], + "score": 1.0, + "content": "nearest neighbors (sorted by", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 556, + 226, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 226, + 568 + ], + "score": 1.0, + "content": "decreasing cosine similarity):", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 543, + 505, + 568 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 248, + 565, + 363, + 579 + ], + "lines": [ + { + "bbox": [ + 248, + 565, + 363, + 579 + ], + "spans": [ + { + "bbox": [ + 248, + 565, + 363, + 579 + ], + "score": 0.92, + "content": "( n _ { 1 } , \\dots , n _ { k } ) = \\Nu \\Nu _ { k } ( q , { \\mathcal { M } } )", + "type": "interline_equation", + "image_path": "40ce1960e7101f9b3d4fbc83b8ab1967ce2f34b96b6a44956a361874e8718032.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 248, + 565, + 363, + 579 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 581, + 505, + 637 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 264, + 594 + ], + "score": 1.0, + "content": "and return, as the main result, the value", + "type": "text" + }, + { + "bbox": [ + 264, + 581, + 289, + 593 + ], + "score": 0.89, + "content": "V [ n _ { 1 } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 582, + 505, + 594 + ], + "score": 1.0, + "content": ". Additionally, we will compute the cosine similarities", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 107, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 107, + 592, + 165, + 604 + ], + "score": 0.93, + "content": "d _ { i } = \\boldsymbol { q } \\cdot \\boldsymbol { K } [ n _ { i } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 592, + 242, + 605 + ], + "score": 1.0, + "content": "and return softmax", + "type": "text" + }, + { + "bbox": [ + 242, + 593, + 312, + 604 + ], + "score": 0.72, + "content": "( d _ { 1 } \\cdot t , \\ldots , d _ { k } \\cdot t )", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 592, + 375, + 605 + ], + "score": 1.0, + "content": ". The parameter", + "type": "text" + }, + { + "bbox": [ + 376, + 594, + 381, + 602 + ], + "score": 0.7, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "denotes the inverse of softmax", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 603, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 218, + 617 + ], + "score": 1.0, + "content": "temperature and we set it to", + "type": "text" + }, + { + "bbox": [ + 218, + 604, + 246, + 614 + ], + "score": 0.9, + "content": "t = 4 0", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 603, + 505, + 617 + ], + "score": 1.0, + "content": "in our experiments. In models where the memory output is again", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "score": 1.0, + "content": "embedded into a dense vector, we multiply the embedded output by the corresponding softmax", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 625, + 385, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 385, + 639 + ], + "score": 1.0, + "content": "component so as to provide a signal about confidence of the memory.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 581, + 505, + 639 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 642, + 504, + 675 + ], + "lines": [ + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "score": 1.0, + "content": "The forward computation of the memory module is thus very simple, the only interesting part being", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 653, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 506, + 666 + ], + "score": 1.0, + "content": "how to compute nearest neighbors efficiently, which we discuss below. But we must also answer the", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 664, + 254, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 254, + 676 + ], + "score": 1.0, + "content": "question how the memory is trained.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 641, + 506, + 676 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 344, + 700 + ], + "score": 1.0, + "content": "Memory Loss. Assume now that in addition to a query", + "type": "text" + }, + { + "bbox": [ + 344, + 690, + 351, + 699 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "we are also given the correct desired", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 183, + 711 + ], + "score": 1.0, + "content": "(supervised) value", + "type": "text" + }, + { + "bbox": [ + 183, + 701, + 190, + 709 + ], + "score": 0.72, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 699, + 330, + 711 + ], + "score": 1.0, + "content": ". In the case of classification, this", + "type": "text" + }, + { + "bbox": [ + 330, + 701, + 336, + 709 + ], + "score": 0.77, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 337, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "would be the class label. In a sequence-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 179, + 723 + ], + "score": 1.0, + "content": "to-sequence task,", + "type": "text" + }, + { + "bbox": [ + 180, + 712, + 186, + 720 + ], + "score": 0.65, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "would be the desired output token of the current time step. After computing", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 121, + 733 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 721, + 128, + 730 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 720, + 203, + 733 + ], + "score": 1.0, + "content": "nearest neighbors", + "type": "text" + }, + { + "bbox": [ + 203, + 721, + 255, + 732 + ], + "score": 0.92, + "content": "( n _ { 1 } , \\ldots , n _ { k } )", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 720, + 308, + 733 + ], + "score": 1.0, + "content": "as above, let", + "type": "text" + }, + { + "bbox": [ + 309, + 722, + 315, + 732 + ], + "score": 0.81, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 720, + 442, + 733 + ], + "score": 1.0, + "content": "be the smallest index such that", + "type": "text" + }, + { + "bbox": [ + 442, + 720, + 487, + 733 + ], + "score": 0.94, + "content": "V [ n _ { p } ] = { \\bar { v } }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 687, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 109, + 83, + 302, + 112 + ], + "lines": [ + { + "bbox": [ + 108, + 81, + 302, + 97 + ], + "spans": [ + { + "bbox": [ + 108, + 81, + 131, + 97 + ], + "score": 1.0, + "content": "Case", + "type": "text" + }, + { + "bbox": [ + 132, + 83, + 302, + 96 + ], + "score": 0.72, + "content": "1 \\colon V [ n _ { 1 } ] = v ; \\quad \\operatorname { L o s s } = [ q \\cdot k _ { b } - q \\cdot k _ { 1 } + \\alpha ] _ { + }", + "type": "inline_equation" + } + ], + "index": 0 + }, + { + "bbox": [ + 118, + 96, + 269, + 112 + ], + "spans": [ + { + "bbox": [ + 118, + 96, + 150, + 112 + ], + "score": 1.0, + "content": "Update:", + "type": "text" + }, + { + "bbox": [ + 150, + 97, + 269, + 112 + ], + "score": 0.63, + "content": "\\begin{array} { r l } { K [ n _ { 1 } ] \\gets \\frac { q + k _ { 1 } } { \\| q + k _ { 1 } \\| } } & { { } A [ n _ { 1 } ] \\gets 0 } \\end{array}", + "type": "inline_equation" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 318, + 83, + 514, + 111 + ], + "lines": [ + { + "bbox": [ + 318, + 83, + 514, + 96 + ], + "spans": [ + { + "bbox": [ + 318, + 83, + 514, + 96 + ], + "score": 0.52, + "content": "{ \\mathrm { C a s e ~ } } 2 \\colon V [ n _ { 1 } ] \\neq v ; \\quad { \\mathrm { L o s s } } = [ q \\cdot k _ { 1 } - q \\cdot k _ { p } + \\alpha ] _ { + }", + "type": "inline_equation", + "image_path": "547fd45890bcca9766874b0ee533f043055fea5cfb54837b05da3ea0d3e33b0c.jpg" + } + ], + "index": 2 + }, + { + "bbox": [ + 331, + 98, + 506, + 111 + ], + "spans": [ + { + "bbox": [ + 331, + 98, + 362, + 111 + ], + "score": 1.0, + "content": "Update:", + "type": "text" + }, + { + "bbox": [ + 362, + 98, + 405, + 110 + ], + "score": 0.39, + "content": "K [ n ^ { \\prime } ] \\gets q", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 99, + 506, + 110 + ], + "score": 0.31, + "content": "\\mid q \\quad V [ n ^ { \\prime } ] v \\quad A [ n ^ { \\prime } ] 0", + "type": "inline_equation" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "image", + "bbox": [ + 111, + 125, + 284, + 237 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 125, + 284, + 237 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 125, + 284, + 237 + ], + "spans": [ + { + "bbox": [ + 111, + 125, + 284, + 237 + ], + "score": 0.914, + "type": "image", + "image_path": "9a0e9979f224838b6739ede56f86aa3a60d5f2bde94e10bf2bf90a017be31af0.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 111, + 125, + 284, + 139.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 111, + 139.0, + 284, + 153.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 111, + 153.0, + 284, + 167.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 111, + 167.0, + 284, + 181.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 111, + 181.0, + 284, + 195.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 111, + 195.0, + 284, + 209.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 111, + 209.0, + 284, + 223.0 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 111, + 223.0, + 284, + 237.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 255, + 503, + 267 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 338, + 268 + ], + "score": 1.0, + "content": "Figure 1: The operation of the memory module on a query", + "type": "text" + }, + { + "bbox": [ + 338, + 257, + 344, + 267 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 253, + 418, + 268 + ], + "score": 1.0, + "content": "with correct value", + "type": "text" + }, + { + "bbox": [ + 419, + 257, + 425, + 265 + ], + "score": 0.71, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 253, + 505, + 268 + ], + "score": 1.0, + "content": "; see text for details.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + } + ], + "index": 13.75 + }, + { + "type": "image", + "bbox": [ + 322, + 125, + 496, + 237 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 322, + 125, + 496, + 237 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 322, + 125, + 496, + 237 + ], + "spans": [ + { + "bbox": [ + 322, + 125, + 496, + 237 + ], + "score": 0.877, + "type": "image", + "image_path": "439659069ba27ddf6723d23d463db67cb813a1033d57af231b411cfaded4e734.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 322, + 125, + 496, + 139.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 322, + 139.0, + 496, + 153.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 322, + 153.0, + 496, + 167.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 322, + 167.0, + 496, + 181.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 322, + 181.0, + 496, + 195.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 322, + 195.0, + 496, + 209.0 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 322, + 209.0, + 496, + 223.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 322, + 223.0, + 496, + 237.0 + ], + "spans": [], + "index": 19 + } + ] + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 106, + 286, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 286, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 113, + 297 + ], + "score": 0.55, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 286, + 231, + 300 + ], + "score": 1.0, + "content": "the smallest index such that", + "type": "text" + }, + { + "bbox": [ + 231, + 287, + 278, + 299 + ], + "score": 0.93, + "content": "V [ n _ { b } ] \\ne v", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 286, + 318, + 300 + ], + "score": 1.0, + "content": ". We call", + "type": "text" + }, + { + "bbox": [ + 319, + 289, + 331, + 299 + ], + "score": 0.87, + "content": "n _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 286, + 440, + 300 + ], + "score": 1.0, + "content": "the positive neighbor and", + "type": "text" + }, + { + "bbox": [ + 440, + 289, + 451, + 298 + ], + "score": 0.85, + "content": "n _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 286, + 505, + 300 + ], + "score": 1.0, + "content": "the negative", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 334, + 311 + ], + "score": 1.0, + "content": "neighbor. When no positive neighbor is among the top-", + "type": "text" + }, + { + "bbox": [ + 335, + 299, + 341, + 308 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 341, + 298, + 505, + 311 + ], + "score": 1.0, + "content": ", we pick any vector from memory with", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 309, + 335, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 130, + 321 + ], + "score": 1.0, + "content": "value", + "type": "text" + }, + { + "bbox": [ + 131, + 311, + 137, + 319 + ], + "score": 0.75, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 309, + 180, + 321 + ], + "score": 1.0, + "content": "instead of", + "type": "text" + }, + { + "bbox": [ + 180, + 309, + 206, + 321 + ], + "score": 0.93, + "content": "K [ n _ { p } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 309, + 335, + 321 + ], + "score": 1.0, + "content": ". We define the memory loss as:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22 + }, + { + "type": "interline_equation", + "bbox": [ + 209, + 325, + 401, + 341 + ], + "lines": [ + { + "bbox": [ + 209, + 325, + 401, + 341 + ], + "spans": [ + { + "bbox": [ + 209, + 325, + 401, + 341 + ], + "score": 0.91, + "content": "\\mathrm { l o s s } ( q , v , { \\cal M } ) = \\left[ q \\cdot K [ n _ { b } ] - q \\cdot K [ n _ { p } ] + \\alpha \\right] _ { + } .", + "type": "interline_equation", + "image_path": "5e66fbc0762a10a6278bd0d001ce44f3d279547f91ceee348b92a7a76deeec8b.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 209, + 325, + 401, + 341 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 351, + 505, + 429 + ], + "lines": [ + { + "bbox": [ + 105, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 173, + 364 + ], + "score": 1.0, + "content": "Recall that both", + "type": "text" + }, + { + "bbox": [ + 174, + 354, + 180, + 363 + ], + "score": 0.82, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "and the keys in memory are normalized, so the products in the above loss term", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 363, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 278, + 375 + ], + "score": 1.0, + "content": "correspond to cosine similarities between", + "type": "text" + }, + { + "bbox": [ + 279, + 365, + 285, + 374 + ], + "score": 0.76, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 363, + 505, + 375 + ], + "score": 1.0, + "content": ", the positive key, and the negative key. Since cosine", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "similarity is maximal for equal terms, we want to maximize the similarity to the positive key and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 493, + 398 + ], + "score": 1.0, + "content": "minimize the similarity to the negative one. But once they are far enough apart (by the margin", + "type": "text" + }, + { + "bbox": [ + 494, + 388, + 501, + 394 + ], + "score": 0.72, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 384, + 505, + 398 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "score": 1.0, + "content": "0.1 in all our experiments), we do not propagate any loss. This definition and reasoning behind it are", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "almost identical to the one in Schroff et al. (2015) and similar to many other distance metric learning", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 417, + 328, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 328, + 430 + ], + "score": 1.0, + "content": "works (Weinberger & Saul, 2009; Weston et al., 2011).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 441, + 505, + 486 + ], + "lines": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 448, + 453 + ], + "score": 1.0, + "content": "Memory Update. In addition to computing the loss, we will also update the memory", + "type": "text" + }, + { + "bbox": [ + 448, + 442, + 461, + 451 + ], + "score": 0.82, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "to account", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 451, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 276, + 465 + ], + "score": 1.0, + "content": "for the fact that the newly presented query", + "type": "text" + }, + { + "bbox": [ + 276, + 454, + 283, + 464 + ], + "score": 0.76, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 451, + 344, + 465 + ], + "score": 1.0, + "content": "corresponds to", + "type": "text" + }, + { + "bbox": [ + 344, + 454, + 351, + 462 + ], + "score": 0.68, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 451, + 505, + 465 + ], + "score": 1.0, + "content": ". The update is done in a different way", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 464, + 504, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 497, + 475 + ], + "score": 1.0, + "content": "depending on whether the main value returned by the memory module already is the correct value", + "type": "text" + }, + { + "bbox": [ + 497, + 465, + 504, + 473 + ], + "score": 0.71, + "content": "v", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 473, + 377, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 192, + 488 + ], + "score": 1.0, + "content": "or not. As before, let", + "type": "text" + }, + { + "bbox": [ + 192, + 474, + 260, + 486 + ], + "score": 0.93, + "content": "n _ { 1 } = \\mathrm { N N } ( q , { \\mathcal { M } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 473, + 367, + 488 + ], + "score": 1.0, + "content": "be the nearest neighbor to", + "type": "text" + }, + { + "bbox": [ + 367, + 476, + 373, + 486 + ], + "score": 0.76, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 473, + 377, + 488 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 490, + 504, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 327, + 504 + ], + "score": 1.0, + "content": "If the memory already returns the correct value, i.e., if", + "type": "text" + }, + { + "bbox": [ + 327, + 490, + 371, + 503 + ], + "score": 0.93, + "content": "V [ n _ { 1 } ] = v", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 489, + 505, + 504 + ], + "score": 1.0, + "content": ", then we only update the key for", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 107, + 502, + 383, + 515 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 118, + 513 + ], + "score": 0.83, + "content": "n _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 502, + 297, + 515 + ], + "score": 1.0, + "content": "by taking the average of the current key and", + "type": "text" + }, + { + "bbox": [ + 297, + 504, + 303, + 514 + ], + "score": 0.81, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 502, + 383, + 515 + ], + "score": 1.0, + "content": "and normalizing it:", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "interline_equation", + "bbox": [ + 255, + 518, + 356, + 546 + ], + "lines": [ + { + "bbox": [ + 255, + 518, + 356, + 546 + ], + "spans": [ + { + "bbox": [ + 255, + 518, + 356, + 546 + ], + "score": 0.94, + "content": "K [ n _ { 1 } ] \\gets \\frac { q + K [ n _ { 1 } ] } { \\lVert q + K [ n _ { 1 } ] \\rVert } .", + "type": "interline_equation", + "image_path": "3fa7aa1f9cda9c5a5982ec2c4a5782e58eabac60bb96dea28f0da76a72647b1c.jpg" + } + ] + } + ], + "index": 38.5, + "virtual_lines": [ + { + "bbox": [ + 255, + 518, + 356, + 532.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 255, + 532.0, + 356, + 546.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 550, + 317, + 563 + ], + "lines": [ + { + "bbox": [ + 106, + 549, + 318, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 269, + 564 + ], + "score": 1.0, + "content": "When doing this, we also re-set the age:", + "type": "text" + }, + { + "bbox": [ + 269, + 550, + 314, + 563 + ], + "score": 0.93, + "content": "A [ n _ { 1 } ] 0", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 549, + 318, + 564 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 106, + 567, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 178, + 581 + ], + "score": 1.0, + "content": "Otherwise, when", + "type": "text" + }, + { + "bbox": [ + 178, + 567, + 225, + 580 + ], + "score": 0.93, + "content": "V [ n _ { 1 } ] \\neq v", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 566, + 455, + 581 + ], + "score": 1.0, + "content": ", we find a new place in the memory and write the pair", + "type": "text" + }, + { + "bbox": [ + 455, + 568, + 478, + 580 + ], + "score": 0.92, + "content": "( q , v )", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 566, + 506, + 581 + ], + "score": 1.0, + "content": "there.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "score": 1.0, + "content": "Which place should we choose? We find memory items with maximum age, and write to one of", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 589, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 314, + 602 + ], + "score": 1.0, + "content": "those (randomly chosen). More formally, we pick", + "type": "text" + }, + { + "bbox": [ + 314, + 589, + 414, + 601 + ], + "score": 0.91, + "content": "n ^ { \\prime } = \\mathrm { a r g m a x } _ { i } A [ i ] + r _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 590, + 443, + 602 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 444, + 589, + 494, + 601 + ], + "score": 0.92, + "content": "| r _ { i } | \\ll | \\mathcal { M } |", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 590, + 505, + 602 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "a random number that introduces some randomness in the choice so as to avoid race conditions in", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 611, + 306, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 306, + 624 + ], + "score": 1.0, + "content": "asynchronous multi-replica training. We then set:", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43 + }, + { + "type": "interline_equation", + "bbox": [ + 223, + 627, + 387, + 642 + ], + "lines": [ + { + "bbox": [ + 223, + 627, + 387, + 642 + ], + "spans": [ + { + "bbox": [ + 223, + 627, + 387, + 642 + ], + "score": 0.92, + "content": "K [ n ^ { \\prime } ] q , \\quad V [ n ^ { \\prime } ] v , \\quad A [ n ^ { \\prime } ] 0 .", + "type": "interline_equation", + "image_path": "9a5e7f44b6243f2c40fd82bf4fa870633978ae523232ca81e6765dd8dbd03591.jpg" + } + ] + } + ], + "index": 46, + "virtual_lines": [ + { + "bbox": [ + 223, + 627, + 387, + 642 + ], + "spans": [], + "index": 46 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 646, + 505, + 670 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 505, + 660 + ], + "score": 1.0, + "content": "With every memory update we also increment the age of all non-updated indices by 1. The full", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 658, + 335, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 335, + 671 + ], + "score": 1.0, + "content": "operation of the memory module is depicted in Figure 1.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5 + }, + { + "type": "text", + "bbox": [ + 106, + 681, + 503, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "Efficient nearest neighbor computation. The most expensive operation in our memory module", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 692, + 484, + 706 + ], + "spans": [ + { + "bbox": [ + 105, + 692, + 193, + 706 + ], + "score": 1.0, + "content": "is the computation of", + "type": "text" + }, + { + "bbox": [ + 194, + 693, + 200, + 703 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 692, + 484, + 706 + ], + "score": 1.0, + "content": "nearest neighbors. This can be done exactly or in an approximate way.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 49.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 350, + 723 + ], + "score": 1.0, + "content": "In the exact mode, to calculate the nearest neighbors in", + "type": "text" + }, + { + "bbox": [ + 351, + 710, + 361, + 720 + ], + "score": 0.84, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 708, + 479, + 723 + ], + "score": 1.0, + "content": "to a mini-batch of queries", + "type": "text" + }, + { + "bbox": [ + 480, + 709, + 504, + 721 + ], + "score": 0.88, + "content": "Q \\ =", + "type": "inline_equation" + } + ], + "index": 51 + }, + { + "bbox": [ + 107, + 719, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 107, + 721, + 154, + 733 + ], + "score": 0.91, + "content": "( q _ { 1 } , \\dots , q _ { b } )", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 719, + 329, + 734 + ], + "score": 1.0, + "content": ", we perform a single matrix multiplication:", + "type": "text" + }, + { + "bbox": [ + 329, + 721, + 362, + 732 + ], + "score": 0.92, + "content": "Q \\times K ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 719, + 505, + 734 + ], + "score": 1.0, + "content": ". This multiplies the batch-size", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 109, + 83, + 302, + 112 + ], + "lines": [ + { + "bbox": [ + 108, + 81, + 302, + 97 + ], + "spans": [ + { + "bbox": [ + 108, + 81, + 131, + 97 + ], + "score": 1.0, + "content": "Case", + "type": "text" + }, + { + "bbox": [ + 132, + 83, + 302, + 96 + ], + "score": 0.72, + "content": "1 \\colon V [ n _ { 1 } ] = v ; \\quad \\operatorname { L o s s } = [ q \\cdot k _ { b } - q \\cdot k _ { 1 } + \\alpha ] _ { + }", + "type": "inline_equation" + } + ], + "index": 0 + }, + { + "bbox": [ + 118, + 96, + 269, + 112 + ], + "spans": [ + { + "bbox": [ + 118, + 96, + 150, + 112 + ], + "score": 1.0, + "content": "Update:", + "type": "text" + }, + { + "bbox": [ + 150, + 97, + 269, + 112 + ], + "score": 0.63, + "content": "\\begin{array} { r l } { K [ n _ { 1 } ] \\gets \\frac { q + k _ { 1 } } { \\| q + k _ { 1 } \\| } } & { { } A [ n _ { 1 } ] \\gets 0 } \\end{array}", + "type": "inline_equation" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 108, + 81, + 302, + 112 + ] + }, + { + "type": "text", + "bbox": [ + 318, + 83, + 514, + 111 + ], + "lines": [ + { + "bbox": [ + 318, + 83, + 514, + 96 + ], + "spans": [ + { + "bbox": [ + 318, + 83, + 514, + 96 + ], + "score": 0.52, + "content": "{ \\mathrm { C a s e ~ } } 2 \\colon V [ n _ { 1 } ] \\neq v ; \\quad { \\mathrm { L o s s } } = [ q \\cdot k _ { 1 } - q \\cdot k _ { p } + \\alpha ] _ { + }", + "type": "inline_equation", + "image_path": "547fd45890bcca9766874b0ee533f043055fea5cfb54837b05da3ea0d3e33b0c.jpg" + } + ], + "index": 2 + }, + { + "bbox": [ + 331, + 98, + 506, + 111 + ], + "spans": [ + { + "bbox": [ + 331, + 98, + 362, + 111 + ], + "score": 1.0, + "content": "Update:", + "type": "text" + }, + { + "bbox": [ + 362, + 98, + 405, + 110 + ], + "score": 0.39, + "content": "K [ n ^ { \\prime } ] \\gets q", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 99, + 506, + 110 + ], + "score": 0.31, + "content": "\\mid q \\quad V [ n ^ { \\prime } ] v \\quad A [ n ^ { \\prime } ] 0", + "type": "inline_equation" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 318, + 83, + 514, + 111 + ] + }, + { + "type": "image", + "bbox": [ + 111, + 125, + 284, + 237 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 125, + 284, + 237 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 125, + 284, + 237 + ], + "spans": [ + { + "bbox": [ + 111, + 125, + 284, + 237 + ], + "score": 0.914, + "type": "image", + "image_path": "9a0e9979f224838b6739ede56f86aa3a60d5f2bde94e10bf2bf90a017be31af0.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 111, + 125, + 284, + 139.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 111, + 139.0, + 284, + 153.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 111, + 153.0, + 284, + 167.0 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 111, + 167.0, + 284, + 181.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 111, + 181.0, + 284, + 195.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 111, + 195.0, + 284, + 209.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 111, + 209.0, + 284, + 223.0 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 111, + 223.0, + 284, + 237.0 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 255, + 503, + 267 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 253, + 505, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 338, + 268 + ], + "score": 1.0, + "content": "Figure 1: The operation of the memory module on a query", + "type": "text" + }, + { + "bbox": [ + 338, + 257, + 344, + 267 + ], + "score": 0.78, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 253, + 418, + 268 + ], + "score": 1.0, + "content": "with correct value", + "type": "text" + }, + { + "bbox": [ + 419, + 257, + 425, + 265 + ], + "score": 0.71, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 425, + 253, + 505, + 268 + ], + "score": 1.0, + "content": "; see text for details.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + } + ], + "index": 13.75 + }, + { + "type": "image", + "bbox": [ + 322, + 125, + 496, + 237 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 322, + 125, + 496, + 237 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 322, + 125, + 496, + 237 + ], + "spans": [ + { + "bbox": [ + 322, + 125, + 496, + 237 + ], + "score": 0.877, + "type": "image", + "image_path": "439659069ba27ddf6723d23d463db67cb813a1033d57af231b411cfaded4e734.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 322, + 125, + 496, + 139.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 322, + 139.0, + 496, + 153.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 322, + 153.0, + 496, + 167.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 322, + 167.0, + 496, + 181.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 322, + 181.0, + 496, + 195.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 322, + 195.0, + 496, + 209.0 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 322, + 209.0, + 496, + 223.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 322, + 223.0, + 496, + 237.0 + ], + "spans": [], + "index": 19 + } + ] + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 106, + 286, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 286, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 113, + 297 + ], + "score": 0.55, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 286, + 231, + 300 + ], + "score": 1.0, + "content": "the smallest index such that", + "type": "text" + }, + { + "bbox": [ + 231, + 287, + 278, + 299 + ], + "score": 0.93, + "content": "V [ n _ { b } ] \\ne v", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 286, + 318, + 300 + ], + "score": 1.0, + "content": ". We call", + "type": "text" + }, + { + "bbox": [ + 319, + 289, + 331, + 299 + ], + "score": 0.87, + "content": "n _ { p }", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 286, + 440, + 300 + ], + "score": 1.0, + "content": "the positive neighbor and", + "type": "text" + }, + { + "bbox": [ + 440, + 289, + 451, + 298 + ], + "score": 0.85, + "content": "n _ { b }", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 286, + 505, + 300 + ], + "score": 1.0, + "content": "the negative", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 298, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 334, + 311 + ], + "score": 1.0, + "content": "neighbor. When no positive neighbor is among the top-", + "type": "text" + }, + { + "bbox": [ + 335, + 299, + 341, + 308 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 341, + 298, + 505, + 311 + ], + "score": 1.0, + "content": ", we pick any vector from memory with", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 309, + 335, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 130, + 321 + ], + "score": 1.0, + "content": "value", + "type": "text" + }, + { + "bbox": [ + 131, + 311, + 137, + 319 + ], + "score": 0.75, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 309, + 180, + 321 + ], + "score": 1.0, + "content": "instead of", + "type": "text" + }, + { + "bbox": [ + 180, + 309, + 206, + 321 + ], + "score": 0.93, + "content": "K [ n _ { p } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 206, + 309, + 335, + 321 + ], + "score": 1.0, + "content": ". We define the memory loss as:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 286, + 505, + 321 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 209, + 325, + 401, + 341 + ], + "lines": [ + { + "bbox": [ + 209, + 325, + 401, + 341 + ], + "spans": [ + { + "bbox": [ + 209, + 325, + 401, + 341 + ], + "score": 0.91, + "content": "\\mathrm { l o s s } ( q , v , { \\cal M } ) = \\left[ q \\cdot K [ n _ { b } ] - q \\cdot K [ n _ { p } ] + \\alpha \\right] _ { + } .", + "type": "interline_equation", + "image_path": "5e66fbc0762a10a6278bd0d001ce44f3d279547f91ceee348b92a7a76deeec8b.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 209, + 325, + 401, + 341 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 351, + 505, + 429 + ], + "lines": [ + { + "bbox": [ + 105, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 173, + 364 + ], + "score": 1.0, + "content": "Recall that both", + "type": "text" + }, + { + "bbox": [ + 174, + 354, + 180, + 363 + ], + "score": 0.82, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "and the keys in memory are normalized, so the products in the above loss term", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 363, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 278, + 375 + ], + "score": 1.0, + "content": "correspond to cosine similarities between", + "type": "text" + }, + { + "bbox": [ + 279, + 365, + 285, + 374 + ], + "score": 0.76, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 363, + 505, + 375 + ], + "score": 1.0, + "content": ", the positive key, and the negative key. Since cosine", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "similarity is maximal for equal terms, we want to maximize the similarity to the positive key and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 384, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 493, + 398 + ], + "score": 1.0, + "content": "minimize the similarity to the negative one. But once they are far enough apart (by the margin", + "type": "text" + }, + { + "bbox": [ + 494, + 388, + 501, + 394 + ], + "score": 0.72, + "content": "\\alpha", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 384, + 505, + 398 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 505, + 408 + ], + "score": 1.0, + "content": "0.1 in all our experiments), we do not propagate any loss. This definition and reasoning behind it are", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 505, + 420 + ], + "score": 1.0, + "content": "almost identical to the one in Schroff et al. (2015) and similar to many other distance metric learning", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 417, + 328, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 328, + 430 + ], + "score": 1.0, + "content": "works (Weinberger & Saul, 2009; Weston et al., 2011).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 351, + 505, + 430 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 441, + 505, + 486 + ], + "lines": [ + { + "bbox": [ + 105, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 448, + 453 + ], + "score": 1.0, + "content": "Memory Update. In addition to computing the loss, we will also update the memory", + "type": "text" + }, + { + "bbox": [ + 448, + 442, + 461, + 451 + ], + "score": 0.82, + "content": "\\mathcal { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "to account", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 451, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 276, + 465 + ], + "score": 1.0, + "content": "for the fact that the newly presented query", + "type": "text" + }, + { + "bbox": [ + 276, + 454, + 283, + 464 + ], + "score": 0.76, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 283, + 451, + 344, + 465 + ], + "score": 1.0, + "content": "corresponds to", + "type": "text" + }, + { + "bbox": [ + 344, + 454, + 351, + 462 + ], + "score": 0.68, + "content": "v", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 451, + 505, + 465 + ], + "score": 1.0, + "content": ". The update is done in a different way", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 464, + 504, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 497, + 475 + ], + "score": 1.0, + "content": "depending on whether the main value returned by the memory module already is the correct value", + "type": "text" + }, + { + "bbox": [ + 497, + 465, + 504, + 473 + ], + "score": 0.71, + "content": "v", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 473, + 377, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 192, + 488 + ], + "score": 1.0, + "content": "or not. As before, let", + "type": "text" + }, + { + "bbox": [ + 192, + 474, + 260, + 486 + ], + "score": 0.93, + "content": "n _ { 1 } = \\mathrm { N N } ( q , { \\mathcal { M } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 473, + 367, + 488 + ], + "score": 1.0, + "content": "be the nearest neighbor to", + "type": "text" + }, + { + "bbox": [ + 367, + 476, + 373, + 486 + ], + "score": 0.76, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 473, + 377, + 488 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 441, + 505, + 488 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 490, + 504, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 327, + 504 + ], + "score": 1.0, + "content": "If the memory already returns the correct value, i.e., if", + "type": "text" + }, + { + "bbox": [ + 327, + 490, + 371, + 503 + ], + "score": 0.93, + "content": "V [ n _ { 1 } ] = v", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 489, + 505, + 504 + ], + "score": 1.0, + "content": ", then we only update the key for", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 107, + 502, + 383, + 515 + ], + "spans": [ + { + "bbox": [ + 107, + 503, + 118, + 513 + ], + "score": 0.83, + "content": "n _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 118, + 502, + 297, + 515 + ], + "score": 1.0, + "content": "by taking the average of the current key and", + "type": "text" + }, + { + "bbox": [ + 297, + 504, + 303, + 514 + ], + "score": 0.81, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 502, + 383, + 515 + ], + "score": 1.0, + "content": "and normalizing it:", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 489, + 505, + 515 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 255, + 518, + 356, + 546 + ], + "lines": [ + { + "bbox": [ + 255, + 518, + 356, + 546 + ], + "spans": [ + { + "bbox": [ + 255, + 518, + 356, + 546 + ], + "score": 0.94, + "content": "K [ n _ { 1 } ] \\gets \\frac { q + K [ n _ { 1 } ] } { \\lVert q + K [ n _ { 1 } ] \\rVert } .", + "type": "interline_equation", + "image_path": "3fa7aa1f9cda9c5a5982ec2c4a5782e58eabac60bb96dea28f0da76a72647b1c.jpg" + } + ] + } + ], + "index": 38.5, + "virtual_lines": [ + { + "bbox": [ + 255, + 518, + 356, + 532.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 255, + 532.0, + 356, + 546.0 + ], + "spans": [], + "index": 39 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 550, + 317, + 563 + ], + "lines": [ + { + "bbox": [ + 106, + 549, + 318, + 564 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 269, + 564 + ], + "score": 1.0, + "content": "When doing this, we also re-set the age:", + "type": "text" + }, + { + "bbox": [ + 269, + 550, + 314, + 563 + ], + "score": 0.93, + "content": "A [ n _ { 1 } ] 0", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 549, + 318, + 564 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40, + "bbox_fs": [ + 106, + 549, + 318, + 564 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 567, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 178, + 581 + ], + "score": 1.0, + "content": "Otherwise, when", + "type": "text" + }, + { + "bbox": [ + 178, + 567, + 225, + 580 + ], + "score": 0.93, + "content": "V [ n _ { 1 } ] \\neq v", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 566, + 455, + 581 + ], + "score": 1.0, + "content": ", we find a new place in the memory and write the pair", + "type": "text" + }, + { + "bbox": [ + 455, + 568, + 478, + 580 + ], + "score": 0.92, + "content": "( q , v )", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 566, + 506, + 581 + ], + "score": 1.0, + "content": "there.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "score": 1.0, + "content": "Which place should we choose? We find memory items with maximum age, and write to one of", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 589, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 314, + 602 + ], + "score": 1.0, + "content": "those (randomly chosen). More formally, we pick", + "type": "text" + }, + { + "bbox": [ + 314, + 589, + 414, + 601 + ], + "score": 0.91, + "content": "n ^ { \\prime } = \\mathrm { a r g m a x } _ { i } A [ i ] + r _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 590, + 443, + 602 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 444, + 589, + 494, + 601 + ], + "score": 0.92, + "content": "| r _ { i } | \\ll | \\mathcal { M } |", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 590, + 505, + 602 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 505, + 613 + ], + "score": 1.0, + "content": "a random number that introduces some randomness in the choice so as to avoid race conditions in", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 611, + 306, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 306, + 624 + ], + "score": 1.0, + "content": "asynchronous multi-replica training. We then set:", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 566, + 506, + 624 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 223, + 627, + 387, + 642 + ], + "lines": [ + { + "bbox": [ + 223, + 627, + 387, + 642 + ], + "spans": [ + { + "bbox": [ + 223, + 627, + 387, + 642 + ], + "score": 0.92, + "content": "K [ n ^ { \\prime } ] q , \\quad V [ n ^ { \\prime } ] v , \\quad A [ n ^ { \\prime } ] 0 .", + "type": "interline_equation", + "image_path": "9a5e7f44b6243f2c40fd82bf4fa870633978ae523232ca81e6765dd8dbd03591.jpg" + } + ] + } + ], + "index": 46, + "virtual_lines": [ + { + "bbox": [ + 223, + 627, + 387, + 642 + ], + "spans": [], + "index": 46 + } + ] + }, + { + "type": "text", + "bbox": [ + 105, + 646, + 505, + 670 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 505, + 660 + ], + "score": 1.0, + "content": "With every memory update we also increment the age of all non-updated indices by 1. The full", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 658, + 335, + 671 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 335, + 671 + ], + "score": 1.0, + "content": "operation of the memory module is depicted in Figure 1.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47.5, + "bbox_fs": [ + 105, + 646, + 505, + 671 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 681, + 503, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "Efficient nearest neighbor computation. The most expensive operation in our memory module", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 692, + 484, + 706 + ], + "spans": [ + { + "bbox": [ + 105, + 692, + 193, + 706 + ], + "score": 1.0, + "content": "is the computation of", + "type": "text" + }, + { + "bbox": [ + 194, + 693, + 200, + 703 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 692, + 484, + 706 + ], + "score": 1.0, + "content": "nearest neighbors. This can be done exactly or in an approximate way.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 49.5, + "bbox_fs": [ + 105, + 681, + 505, + 706 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 504, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 350, + 723 + ], + "score": 1.0, + "content": "In the exact mode, to calculate the nearest neighbors in", + "type": "text" + }, + { + "bbox": [ + 351, + 710, + 361, + 720 + ], + "score": 0.84, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 708, + 479, + 723 + ], + "score": 1.0, + "content": "to a mini-batch of queries", + "type": "text" + }, + { + "bbox": [ + 480, + 709, + 504, + 721 + ], + "score": 0.88, + "content": "Q \\ =", + "type": "inline_equation" + } + ], + "index": 51 + }, + { + "bbox": [ + 107, + 719, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 107, + 721, + 154, + 733 + ], + "score": 0.91, + "content": "( q _ { 1 } , \\dots , q _ { b } )", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 719, + 329, + 734 + ], + "score": 1.0, + "content": ", we perform a single matrix multiplication:", + "type": "text" + }, + { + "bbox": [ + 329, + 721, + 362, + 732 + ], + "score": 0.92, + "content": "Q \\times K ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 719, + 505, + 734 + ], + "score": 1.0, + "content": ". This multiplies the batch-size", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 299, + 506, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 300, + 167, + 311 + ], + "score": 0.28, + "content": "\\times \\mathrm { \\ k e y - s i z e }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 167, + 299, + 198, + 312 + ], + "score": 1.0, + "content": "matrix", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 198, + 300, + 208, + 312 + ], + "score": 0.83, + "content": "Q", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 208, + 299, + 238, + 312 + ], + "score": 1.0, + "content": "by the", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 239, + 301, + 368, + 311 + ], + "score": 0.56, + "content": "{ \\bf k e y - s i z e } \\times { \\bf m e m o r y - s i z e }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 368, + 299, + 399, + 312 + ], + "score": 1.0, + "content": "matrix", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 400, + 299, + 416, + 310 + ], + "score": 0.89, + "content": "K ^ { T }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 416, + 299, + 506, + 312 + ], + "score": 1.0, + "content": ", and the result is the", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 165, + 323 + ], + "score": 1.0, + "content": "batch-size", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 165, + 312, + 191, + 322 + ], + "score": 0.35, + "content": "\\div \\times \\mathrm { ~ m } \\in", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 191, + 310, + 495, + 323 + ], + "score": 1.0, + "content": "emory-size matrix of all distances, from which we can choose the top-", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 495, + 312, + 501, + 321 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 501, + 310, + 505, + 323 + ], + "score": 1.0, + "content": ".", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "score": 1.0, + "content": "This procedure is linear in memory-size, so it can be expensive for very large memory sizes. But", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "score": 1.0, + "content": "matrix multiplication is very heavily optimized, so in our experiments on GPUs we find that this", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 344, + 375, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 375, + 357 + ], + "score": 1.0, + "content": "operation is not a bottleneck for memory sizes up to half a million.", + "type": "text", + "cross_page": true + } + ], + "index": 17 + } + ], + "index": 51.5, + "bbox_fs": [ + 105, + 708, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 181, + 84, + 425, + 217 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 181, + 84, + 425, + 217 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 181, + 84, + 425, + 217 + ], + "spans": [ + { + "bbox": [ + 181, + 84, + 425, + 217 + ], + "score": 0.969, + "type": "image", + "image_path": "b8f9c043a8b0838456ee094f0909ad7a399d67f149e328b2e34a7d07e1152410.jpg" + } + ] + } + ], + "index": 4.5, + "virtual_lines": [ + { + "bbox": [ + 181, + 84, + 425, + 97.3 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 181, + 97.3, + 425, + 110.6 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 181, + 110.6, + 425, + 123.89999999999999 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 181, + 123.89999999999999, + 425, + 137.2 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 181, + 137.2, + 425, + 150.5 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 181, + 150.5, + 425, + 163.8 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 181, + 163.8, + 425, + 177.10000000000002 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 181, + 177.10000000000002, + 425, + 190.40000000000003 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 181, + 190.40000000000003, + 425, + 203.70000000000005 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 181, + 203.70000000000005, + 425, + 217.00000000000006 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 240, + 503, + 274 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 240, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 444, + 252 + ], + "score": 1.0, + "content": "Figure 2: The GNMT model with added memory module. On each decoding step", + "type": "text" + }, + { + "bbox": [ + 444, + 241, + 449, + 250 + ], + "score": 0.65, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 240, + 505, + 252 + ], + "score": 1.0, + "content": ", the result of", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 252, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 252, + 158, + 264 + ], + "score": 1.0, + "content": "the attention", + "type": "text" + }, + { + "bbox": [ + 158, + 253, + 168, + 262 + ], + "score": 0.85, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 252, + 505, + 264 + ], + "score": 1.0, + "content": "is used to query the memory. The resulting value is combined with the output of the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 262, + 425, + 274 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 301, + 274 + ], + "score": 1.0, + "content": "final LSTM layer to produce the predicted logits", + "type": "text" + }, + { + "bbox": [ + 302, + 263, + 311, + 273 + ], + "score": 0.87, + "content": "\\hat { y } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 262, + 425, + 274 + ], + "score": 1.0, + "content": ". See text for further details.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + } + ], + "index": 7.75 + }, + { + "type": "text", + "bbox": [ + 107, + 299, + 504, + 355 + ], + "lines": [ + { + "bbox": [ + 106, + 299, + 506, + 312 + ], + "spans": [ + { + "bbox": [ + 106, + 300, + 167, + 311 + ], + "score": 0.28, + "content": "\\times \\mathrm { \\ k e y - s i z e }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 299, + 198, + 312 + ], + "score": 1.0, + "content": "matrix", + "type": "text" + }, + { + "bbox": [ + 198, + 300, + 208, + 312 + ], + "score": 0.83, + "content": "Q", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 299, + 238, + 312 + ], + "score": 1.0, + "content": "by the", + "type": "text" + }, + { + "bbox": [ + 239, + 301, + 368, + 311 + ], + "score": 0.56, + "content": "{ \\bf k e y - s i z e } \\times { \\bf m e m o r y - s i z e }", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 299, + 399, + 312 + ], + "score": 1.0, + "content": "matrix", + "type": "text" + }, + { + "bbox": [ + 400, + 299, + 416, + 310 + ], + "score": 0.89, + "content": "K ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 299, + 506, + 312 + ], + "score": 1.0, + "content": ", and the result is the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 310, + 505, + 323 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 165, + 323 + ], + "score": 1.0, + "content": "batch-size", + "type": "text" + }, + { + "bbox": [ + 165, + 312, + 191, + 322 + ], + "score": 0.35, + "content": "\\div \\times \\mathrm { ~ m } \\in", + "type": "inline_equation" + }, + { + "bbox": [ + 191, + 310, + 495, + 323 + ], + "score": 1.0, + "content": "emory-size matrix of all distances, from which we can choose the top-", + "type": "text" + }, + { + "bbox": [ + 495, + 312, + 501, + 321 + ], + "score": 0.77, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 310, + 505, + 323 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "score": 1.0, + "content": "This procedure is linear in memory-size, so it can be expensive for very large memory sizes. But", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "score": 1.0, + "content": "matrix multiplication is very heavily optimized, so in our experiments on GPUs we find that this", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 344, + 375, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 344, + 375, + 357 + ], + "score": 1.0, + "content": "operation is not a bottleneck for memory sizes up to half a million.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 361, + 505, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 239, + 373 + ], + "score": 1.0, + "content": "If the exact mode is too slow, the", + "type": "text" + }, + { + "bbox": [ + 239, + 361, + 246, + 371 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 361, + 505, + 373 + ], + "score": 1.0, + "content": "nearest neighbors can be computed approximately using locality", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "sensitive hashing (LSH). LSH is a hashing scheme so that near neighbors get similar hashes (Indyk", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 383, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 218, + 395 + ], + "score": 1.0, + "content": "& Motwani, 1998; Andoni", + "type": "text" + }, + { + "bbox": [ + 219, + 383, + 228, + 393 + ], + "score": 0.34, + "content": "\\&", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 383, + 505, + 395 + ], + "score": 1.0, + "content": "Indyk, 2006). For cosine similarity, the computation of an LSH is", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 393, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 376, + 407 + ], + "score": 1.0, + "content": "very simple. We pick a number of random normalized hash vectors", + "type": "text" + }, + { + "bbox": [ + 377, + 394, + 419, + 405 + ], + "score": 0.92, + "content": "h _ { 1 } , \\ldots , h _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 393, + 505, + 407 + ], + "score": 1.0, + "content": ". The hash of a query", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 404, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 113, + 416 + ], + "score": 0.73, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 404, + 183, + 419 + ], + "score": 1.0, + "content": "is a sequence of", + "type": "text" + }, + { + "bbox": [ + 183, + 405, + 188, + 415 + ], + "score": 0.68, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 404, + 210, + 419 + ], + "score": 1.0, + "content": "bits,", + "type": "text" + }, + { + "bbox": [ + 210, + 405, + 249, + 416 + ], + "score": 0.91, + "content": "b _ { 1 } , \\ldots , b _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 404, + 293, + 419 + ], + "score": 1.0, + "content": ", such that", + "type": "text" + }, + { + "bbox": [ + 294, + 405, + 324, + 416 + ], + "score": 0.91, + "content": "b _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 404, + 388, + 419 + ], + "score": 1.0, + "content": "if, and only if,", + "type": "text" + }, + { + "bbox": [ + 388, + 405, + 433, + 416 + ], + "score": 0.91, + "content": "q \\cdot h _ { i } > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 404, + 506, + 419 + ], + "score": 1.0, + "content": ". It turns out that", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "score": 1.0, + "content": "near neighbors will, with high probability, have a large number of identical bits in their hash. To", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "score": 1.0, + "content": "compute the nearest neighbors it is therefore sufficient to only look into parts of the memory with", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "score": 1.0, + "content": "similar hashes. This makes the nearest neighbor computation work in approximately constant time", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 449, + 490, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 490, + 461 + ], + "score": 1.0, + "content": "– we only need to multiply the query by the hash vectors, and then only use the nearest buckets.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22 + }, + { + "type": "title", + "bbox": [ + 108, + 480, + 263, + 491 + ], + "lines": [ + { + "bbox": [ + 105, + 479, + 265, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 265, + 492 + ], + "score": 1.0, + "content": "2.1 USING THE MEMORY MODULE", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 502, + 504, + 525 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "The memory module presented above can be added to any classification network. There are two", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 514, + 486, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 486, + 527 + ], + "score": 1.0, + "content": "main choices: which layer to use to generate queries, and how to use the output of the module.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 531, + 505, + 564 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "In the simplest case, we use the final layer of a network as query and the output of the module is", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "directly used for classification. This simplest case is similar to matching networks (Oriol Vinyals,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 552, + 454, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 454, + 566 + ], + "score": 1.0, + "content": "2016b) and our memory module yields good results already in this setting (see below).", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "Instead of using the output of the module directly, it is possible to embed it again into a dense", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "representation and mix it with other predictions made by the network. To study this setting, we", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "add the memory module to sequence-to-sequence recurrent neural networks. As described in detail", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "score": 1.0, + "content": "below, a query to memory is made in every step of the decoder network. Memory output is embedded", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 613, + 479, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 479, + 626 + ], + "score": 1.0, + "content": "again into a dense representation and combined with inputs from other layers of the network.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "Convolutional Network with Memory. To test our memory module in a simple setting, we first", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "score": 1.0, + "content": "add it to a basic convolutional network network for image classification. Our network consists of", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "two convolutional layers with ReLU non-linearity, followed by a max-pooling layer, another two", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "convolutional-ReLU layers, another max-pooling, and two fully connected layers. All convolutions", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 122, + 700 + ], + "score": 1.0, + "content": "use", + "type": "text" + }, + { + "bbox": [ + 122, + 688, + 145, + 698 + ], + "score": 0.89, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "filters with 64 channels in the first pair, and 128 in the second. The fully connected layers", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "have dimension 256 and dropout applied between them. The output of the final layer is used as query", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "to our memory module and the nearest neighbor returned by the memory is used as the final network", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "prediction. Even this basic architecture yields good results in one-shot learning, as discussed below.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 181, + 84, + 425, + 217 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 181, + 84, + 425, + 217 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 181, + 84, + 425, + 217 + ], + "spans": [ + { + "bbox": [ + 181, + 84, + 425, + 217 + ], + "score": 0.969, + "type": "image", + "image_path": "b8f9c043a8b0838456ee094f0909ad7a399d67f149e328b2e34a7d07e1152410.jpg" + } + ] + } + ], + "index": 4.5, + "virtual_lines": [ + { + "bbox": [ + 181, + 84, + 425, + 97.3 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 181, + 97.3, + 425, + 110.6 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 181, + 110.6, + 425, + 123.89999999999999 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 181, + 123.89999999999999, + 425, + 137.2 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 181, + 137.2, + 425, + 150.5 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 181, + 150.5, + 425, + 163.8 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 181, + 163.8, + 425, + 177.10000000000002 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 181, + 177.10000000000002, + 425, + 190.40000000000003 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 181, + 190.40000000000003, + 425, + 203.70000000000005 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 181, + 203.70000000000005, + 425, + 217.00000000000006 + ], + "spans": [], + "index": 9 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 240, + 503, + 274 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 240, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 444, + 252 + ], + "score": 1.0, + "content": "Figure 2: The GNMT model with added memory module. On each decoding step", + "type": "text" + }, + { + "bbox": [ + 444, + 241, + 449, + 250 + ], + "score": 0.65, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 240, + 505, + 252 + ], + "score": 1.0, + "content": ", the result of", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 252, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 252, + 158, + 264 + ], + "score": 1.0, + "content": "the attention", + "type": "text" + }, + { + "bbox": [ + 158, + 253, + 168, + 262 + ], + "score": 0.85, + "content": "a _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 169, + 252, + 505, + 264 + ], + "score": 1.0, + "content": "is used to query the memory. The resulting value is combined with the output of the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 262, + 425, + 274 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 301, + 274 + ], + "score": 1.0, + "content": "final LSTM layer to produce the predicted logits", + "type": "text" + }, + { + "bbox": [ + 302, + 263, + 311, + 273 + ], + "score": 0.87, + "content": "\\hat { y } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 262, + 425, + 274 + ], + "score": 1.0, + "content": ". See text for further details.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + } + ], + "index": 7.75 + }, + { + "type": "text", + "bbox": [ + 107, + 299, + 504, + 355 + ], + "lines": [], + "index": 15, + "bbox_fs": [ + 105, + 299, + 506, + 357 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 361, + 505, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 239, + 373 + ], + "score": 1.0, + "content": "If the exact mode is too slow, the", + "type": "text" + }, + { + "bbox": [ + 239, + 361, + 246, + 371 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 361, + 505, + 373 + ], + "score": 1.0, + "content": "nearest neighbors can be computed approximately using locality", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "sensitive hashing (LSH). LSH is a hashing scheme so that near neighbors get similar hashes (Indyk", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 383, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 383, + 218, + 395 + ], + "score": 1.0, + "content": "& Motwani, 1998; Andoni", + "type": "text" + }, + { + "bbox": [ + 219, + 383, + 228, + 393 + ], + "score": 0.34, + "content": "\\&", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 383, + 505, + 395 + ], + "score": 1.0, + "content": "Indyk, 2006). For cosine similarity, the computation of an LSH is", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 393, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 376, + 407 + ], + "score": 1.0, + "content": "very simple. We pick a number of random normalized hash vectors", + "type": "text" + }, + { + "bbox": [ + 377, + 394, + 419, + 405 + ], + "score": 0.92, + "content": "h _ { 1 } , \\ldots , h _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 393, + 505, + 407 + ], + "score": 1.0, + "content": ". The hash of a query", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 404, + 506, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 113, + 416 + ], + "score": 0.73, + "content": "q", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 404, + 183, + 419 + ], + "score": 1.0, + "content": "is a sequence of", + "type": "text" + }, + { + "bbox": [ + 183, + 405, + 188, + 415 + ], + "score": 0.68, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 404, + 210, + 419 + ], + "score": 1.0, + "content": "bits,", + "type": "text" + }, + { + "bbox": [ + 210, + 405, + 249, + 416 + ], + "score": 0.91, + "content": "b _ { 1 } , \\ldots , b _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 404, + 293, + 419 + ], + "score": 1.0, + "content": ", such that", + "type": "text" + }, + { + "bbox": [ + 294, + 405, + 324, + 416 + ], + "score": 0.91, + "content": "b _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 324, + 404, + 388, + 419 + ], + "score": 1.0, + "content": "if, and only if,", + "type": "text" + }, + { + "bbox": [ + 388, + 405, + 433, + 416 + ], + "score": 0.91, + "content": "q \\cdot h _ { i } > 0", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 404, + 506, + 419 + ], + "score": 1.0, + "content": ". It turns out that", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 506, + 428 + ], + "score": 1.0, + "content": "near neighbors will, with high probability, have a large number of identical bits in their hash. To", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 505, + 439 + ], + "score": 1.0, + "content": "compute the nearest neighbors it is therefore sufficient to only look into parts of the memory with", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "score": 1.0, + "content": "similar hashes. This makes the nearest neighbor computation work in approximately constant time", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 449, + 490, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 449, + 490, + 461 + ], + "score": 1.0, + "content": "– we only need to multiply the query by the hash vectors, and then only use the nearest buckets.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 361, + 506, + 461 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 480, + 263, + 491 + ], + "lines": [ + { + "bbox": [ + 105, + 479, + 265, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 265, + 492 + ], + "score": 1.0, + "content": "2.1 USING THE MEMORY MODULE", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 502, + 504, + 525 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 505, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 505, + 515 + ], + "score": 1.0, + "content": "The memory module presented above can be added to any classification network. There are two", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 514, + 486, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 486, + 527 + ], + "score": 1.0, + "content": "main choices: which layer to use to generate queries, and how to use the output of the module.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28.5, + "bbox_fs": [ + 106, + 502, + 505, + 527 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 531, + 505, + 564 + ], + "lines": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "In the simplest case, we use the final layer of a network as query and the output of the module is", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "directly used for classification. This simplest case is similar to matching networks (Oriol Vinyals,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 552, + 454, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 454, + 566 + ], + "score": 1.0, + "content": "2016b) and our memory module yields good results already in this setting (see below).", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 531, + 505, + 566 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 625 + ], + "lines": [ + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "Instead of using the output of the module directly, it is possible to embed it again into a dense", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 594 + ], + "score": 1.0, + "content": "representation and mix it with other predictions made by the network. To study this setting, we", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 505, + 605 + ], + "score": 1.0, + "content": "add the memory module to sequence-to-sequence recurrent neural networks. As described in detail", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 505, + 616 + ], + "score": 1.0, + "content": "below, a query to memory is made in every step of the decoder network. Memory output is embedded", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 613, + 479, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 479, + 626 + ], + "score": 1.0, + "content": "again into a dense representation and combined with inputs from other layers of the network.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 570, + 505, + 626 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 643, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "Convolutional Network with Memory. To test our memory module in a simple setting, we first", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 666 + ], + "score": 1.0, + "content": "add it to a basic convolutional network network for image classification. Our network consists of", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "two convolutional layers with ReLU non-linearity, followed by a max-pooling layer, another two", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "convolutional-ReLU layers, another max-pooling, and two fully connected layers. All convolutions", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 122, + 700 + ], + "score": 1.0, + "content": "use", + "type": "text" + }, + { + "bbox": [ + 122, + 688, + 145, + 698 + ], + "score": 0.89, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "filters with 64 channels in the first pair, and 128 in the second. The fully connected layers", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 713 + ], + "score": 1.0, + "content": "have dimension 256 and dropout applied between them. The output of the final layer is used as query", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "to our memory module and the nearest neighbor returned by the memory is used as the final network", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "prediction. Even this basic architecture yields good results in one-shot learning, as discussed below.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 644, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 127, + 78, + 488, + 216 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 127, + 78, + 488, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 127, + 78, + 488, + 216 + ], + "spans": [ + { + "bbox": [ + 127, + 78, + 488, + 216 + ], + "score": 0.972, + "type": "image", + "image_path": "7d63c9c6459cd8c2b28898bc12351be72bca2ac04e812c6be2789ac05c86e989.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 127, + 78, + 488, + 124.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 127, + 124.0, + 488, + 170.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 127, + 170.0, + 488, + 216.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 233, + 505, + 267 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 233, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 505, + 246 + ], + "score": 1.0, + "content": "Figure 3: Extended Neural GPU with memory module. Memory query is read from the position one", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "score": 1.0, + "content": "below the current output logit, and the embedded memory value is put at the same position of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 254, + 474, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 153, + 268 + ], + "score": 1.0, + "content": "output tape", + "type": "text" + }, + { + "bbox": [ + 153, + 257, + 160, + 266 + ], + "score": 0.75, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 254, + 474, + 268 + ], + "score": 1.0, + "content": ". The network learns to use these values to produce the output in the next step.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 287, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 106, + 288, + 504, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 504, + 299 + ], + "score": 1.0, + "content": "Sequence-to-sequence with Memory. For large-scale experiments, we add the memory mod-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 299, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 505, + 310 + ], + "score": 1.0, + "content": "ule into a large sequence-to-sequence model. Such sequence-to-sequence recurrent neural networks", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 308, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 506, + 322 + ], + "score": 1.0, + "content": "(RNNs) with long short-term memory (LSTM) cells (Hochreiter & Schmidhuber, 1997) have proven", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 320, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 333 + ], + "score": 1.0, + "content": "especially successful at natural language processing (NLP) tasks, including machine translation", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "(Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). We add the memory module to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "the Google Neural Machine Translation (GNMT) model (Wu et al., 2016). This model consists of", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "score": 1.0, + "content": "an encoder RNN, which creates a representation of the source language sentence, and a decoder", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 363, + 504, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 504, + 377 + ], + "score": 1.0, + "content": "RNN that outputs the target language sentence. We left the encoder RNN unmodified. In the de-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "coder RNN, we use the vector retrieved by the attention mechanism as query to the memory module.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "In the GNMT model, the attention vector is used in all LSTM layers beyond the second one, so the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "computation of the other layers and the memory can happen in parallel. Before the final softmax", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "layer, we combine the embedded memory output with the output of the final LSTM layer using an", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 419, + 294, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 294, + 431 + ], + "score": 1.0, + "content": "additional linear layer, as depicted in Figure 2.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 442, + 505, + 552 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 455 + ], + "score": 1.0, + "content": "Extended Neural GPU with Memory. To test versatility of our memory module, we also add it to", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "the Extended Neural GPU, a convolutional-recurrent model introduced by Kaiser & Bengio (2016).", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 463, + 506, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 478 + ], + "score": 1.0, + "content": "The Extended Neural GPU is a sequence-to-sequence model too, but its decoder is convolutional", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "and the size of its state changes depending on the size of the input. Again, we leave the encoder", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 486, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 104, + 486, + 506, + 499 + ], + "score": 1.0, + "content": "part of the model intact, and extend the decoder part by a memory query. This time, we use the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 496, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 104, + 496, + 506, + 511 + ], + "score": 1.0, + "content": "position one step ahead to query memory, and we put the embedded result to the output tape, as", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "score": 1.0, + "content": "shown in Figure 3. Note that in this model the result of the memory will be processed by two", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "recurrent-convolutional cells before the corresponding output is produced. The fact that this model", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "score": 1.0, + "content": "still does one-shot learning confirms that the output of our memory module can be used deep inside", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 541, + 270, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 270, + 554 + ], + "score": 1.0, + "content": "a network, not just near the output layer.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23.5 + }, + { + "type": "title", + "bbox": [ + 108, + 569, + 211, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 568, + 213, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 213, + 583 + ], + "score": 1.0, + "content": "3 RELATED WORK", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 594, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "Memory in Neural Networks. Augmenting neural networks with memory has been heavily stud-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "ied recently. Many of these approaches design a memory component that is intended as a general-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "score": 1.0, + "content": "ization of the memory in standard recurrent neural networks. In recurrent networks, the state passed", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "from one time step to the next can be interpreted as the network’s memory representation of the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "current example. Moving away from this fixed-length vector representation of memory to a larger", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 649, + 329, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 329, + 660 + ], + "score": 1.0, + "content": "and more versatile form is at the core of these methods.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Augmenting recurrent neural networks with attention (Bahdanau et al., 2014) can be interpreted as", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "creating a large memory component that allows content-based addressing. More generally, Graves", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "et al. (2014) augmented a recurrent neural network with a computing-inspired memory component", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "that can be addressed via both content- and address-based queries. Sukhbaatar et al. (2015) present", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "a similar augmentation and show the importance of allowing multiple reads and writes to memory", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "between inputs. These approaches excel at tasks where it is necessary to store large parts of a se-", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 38.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 127, + 78, + 488, + 216 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 127, + 78, + 488, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 127, + 78, + 488, + 216 + ], + "spans": [ + { + "bbox": [ + 127, + 78, + 488, + 216 + ], + "score": 0.972, + "type": "image", + "image_path": "7d63c9c6459cd8c2b28898bc12351be72bca2ac04e812c6be2789ac05c86e989.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 127, + 78, + 488, + 124.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 127, + 124.0, + 488, + 170.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 127, + 170.0, + 488, + 216.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 233, + 505, + 267 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 233, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 505, + 246 + ], + "score": 1.0, + "content": "Figure 3: Extended Neural GPU with memory module. Memory query is read from the position one", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "score": 1.0, + "content": "below the current output logit, and the embedded memory value is put at the same position of the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 254, + 474, + 268 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 153, + 268 + ], + "score": 1.0, + "content": "output tape", + "type": "text" + }, + { + "bbox": [ + 153, + 257, + 160, + 266 + ], + "score": 0.75, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 254, + 474, + 268 + ], + "score": 1.0, + "content": ". The network learns to use these values to produce the output in the next step.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 287, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 106, + 288, + 504, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 288, + 504, + 299 + ], + "score": 1.0, + "content": "Sequence-to-sequence with Memory. For large-scale experiments, we add the memory mod-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 299, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 299, + 505, + 310 + ], + "score": 1.0, + "content": "ule into a large sequence-to-sequence model. Such sequence-to-sequence recurrent neural networks", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 308, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 506, + 322 + ], + "score": 1.0, + "content": "(RNNs) with long short-term memory (LSTM) cells (Hochreiter & Schmidhuber, 1997) have proven", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 320, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 333 + ], + "score": 1.0, + "content": "especially successful at natural language processing (NLP) tasks, including machine translation", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "(Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). We add the memory module to", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "the Google Neural Machine Translation (GNMT) model (Wu et al., 2016). This model consists of", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 365 + ], + "score": 1.0, + "content": "an encoder RNN, which creates a representation of the source language sentence, and a decoder", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 363, + 504, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 504, + 377 + ], + "score": 1.0, + "content": "RNN that outputs the target language sentence. We left the encoder RNN unmodified. In the de-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "coder RNN, we use the vector retrieved by the attention mechanism as query to the memory module.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 398 + ], + "score": 1.0, + "content": "In the GNMT model, the attention vector is used in all LSTM layers beyond the second one, so the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "computation of the other layers and the memory can happen in parallel. Before the final softmax", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "layer, we combine the embedded memory output with the output of the final LSTM layer using an", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 419, + 294, + 431 + ], + "spans": [ + { + "bbox": [ + 106, + 419, + 294, + 431 + ], + "score": 1.0, + "content": "additional linear layer, as depicted in Figure 2.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 288, + 506, + 431 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 442, + 505, + 552 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 455 + ], + "score": 1.0, + "content": "Extended Neural GPU with Memory. To test versatility of our memory module, we also add it to", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 466 + ], + "score": 1.0, + "content": "the Extended Neural GPU, a convolutional-recurrent model introduced by Kaiser & Bengio (2016).", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 463, + 506, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 478 + ], + "score": 1.0, + "content": "The Extended Neural GPU is a sequence-to-sequence model too, but its decoder is convolutional", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 488 + ], + "score": 1.0, + "content": "and the size of its state changes depending on the size of the input. Again, we leave the encoder", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 486, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 104, + 486, + 506, + 499 + ], + "score": 1.0, + "content": "part of the model intact, and extend the decoder part by a memory query. This time, we use the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 496, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 104, + 496, + 506, + 511 + ], + "score": 1.0, + "content": "position one step ahead to query memory, and we put the embedded result to the output tape, as", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "score": 1.0, + "content": "shown in Figure 3. Note that in this model the result of the memory will be processed by two", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 519, + 506, + 531 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 506, + 531 + ], + "score": 1.0, + "content": "recurrent-convolutional cells before the corresponding output is produced. The fact that this model", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 505, + 543 + ], + "score": 1.0, + "content": "still does one-shot learning confirms that the output of our memory module can be used deep inside", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 541, + 270, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 270, + 554 + ], + "score": 1.0, + "content": "a network, not just near the output layer.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23.5, + "bbox_fs": [ + 104, + 442, + 506, + 554 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 569, + 211, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 568, + 213, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 213, + 583 + ], + "score": 1.0, + "content": "3 RELATED WORK", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 594, + 504, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "Memory in Neural Networks. Augmenting neural networks with memory has been heavily stud-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "ied recently. Many of these approaches design a memory component that is intended as a general-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "score": 1.0, + "content": "ization of the memory in standard recurrent neural networks. In recurrent networks, the state passed", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "from one time step to the next can be interpreted as the network’s memory representation of the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 506, + 651 + ], + "score": 1.0, + "content": "current example. Moving away from this fixed-length vector representation of memory to a larger", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 649, + 329, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 329, + 660 + ], + "score": 1.0, + "content": "and more versatile form is at the core of these methods.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 594, + 506, + 660 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Augmenting recurrent neural networks with attention (Bahdanau et al., 2014) can be interpreted as", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "creating a large memory component that allows content-based addressing. More generally, Graves", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "et al. (2014) augmented a recurrent neural network with a computing-inspired memory component", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "that can be addressed via both content- and address-based queries. Sukhbaatar et al. (2015) present", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "a similar augmentation and show the importance of allowing multiple reads and writes to memory", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "between inputs. These approaches excel at tasks where it is necessary to store large parts of a se-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "quential input in a representation that can later be precisely queried. Such tasks include algorithmic", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 461, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 461, + 106 + ], + "score": 1.0, + "content": "sequence manipulation tasks, natural language modelling, and question-answering tasks.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 38.5, + "bbox_fs": [ + 104, + 665, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 503, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "quential input in a representation that can later be precisely queried. Such tasks include algorithmic", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 461, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 461, + 106 + ], + "score": 1.0, + "content": "sequence manipulation tasks, natural language modelling, and question-answering tasks.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 505, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 506, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 506, + 124 + ], + "score": 1.0, + "content": "The success of these approaches hinges on making the memory component fully differentiable and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "backpropagating signal through every access of memory. In this setting, computational requirements", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "necessitate that the memory be small. Some attempts have been made at making hard access queries", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "to memory (Zaremba & Sutskever, 2015; Xu et al., 2015), but it was usually challenging to match", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "the soft version. Recently, more successful training for hard queries was reported (Gulc¸ehre et al. ¨ ,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "2016) that makes use of a curriculum strategy that mixes soft and hard queries at training time. Our", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 190 + ], + "score": 1.0, + "content": "approach applies hard access as well, but we encourage the model to make good queries via a special", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 163, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 163, + 200 + ], + "score": 1.0, + "content": "memory loss.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 107, + 204, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "Modifications to allow for large-scale memory in neural networks have been proposed. The original", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 215, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 506, + 228 + ], + "score": 1.0, + "content": "implementation of memory networks (Weston et al., 2014) and later work on scaling it (Bordes", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "score": 1.0, + "content": "et al., 2015; Chandar et al., 2016) used memory with size in the millions. The cost of doing so is", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "that the memory must be fixed prior to training. Moreover, since during the beginning of training the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "score": 1.0, + "content": "model is unlikely to query the memory correctly, strong supervision is used to encourage the model", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 258, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 272 + ], + "score": 1.0, + "content": "to query memory locations that are useful. These hints are either given as additional supervising", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 270, + 404, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 404, + 282 + ], + "score": 1.0, + "content": "information by the task or determined heuristically as in Hill et al. (2015).", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 505, + 375 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "score": 1.0, + "content": "All the work discussed so far has either used a memory that is fixed before training or used a memory", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 297, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 311 + ], + "score": 1.0, + "content": "that is not persistent between different examples. For one-shot and lifelong learning, a memory must", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 308, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 322 + ], + "score": 1.0, + "content": "necessarily be both volatile during training and persistent between examples. To bridge this gap,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "score": 1.0, + "content": "Santoro et al. (2016) propose to partition training into distinct episodes consisting of a sequence", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 330, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 195, + 345 + ], + "score": 1.0, + "content": "of labelled examples", + "type": "text" + }, + { + "bbox": [ + 195, + 330, + 248, + 343 + ], + "score": 0.93, + "content": "\\bar { \\{ ( x _ { i } , y _ { i } ) \\} } _ { i = 1 } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 330, + 506, + 345 + ], + "score": 1.0, + "content": ". A network augmented with a fully-differentiable memory is", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 177, + 355 + ], + "score": 1.0, + "content": "trained to predict", + "type": "text" + }, + { + "bbox": [ + 178, + 343, + 187, + 353 + ], + "score": 0.84, + "content": "y _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 342, + 305, + 355 + ], + "score": 1.0, + "content": "given the previous sequence", + "type": "text" + }, + { + "bbox": [ + 305, + 342, + 379, + 354 + ], + "score": 0.9, + "content": "( x _ { 1 } , y _ { 1 } , \\dotsc , x _ { i - 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 342, + 506, + 355 + ], + "score": 1.0, + "content": ". This way, the model learns to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "store important examples with their corresponding labels in memory and later re-use this information", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 364, + 504, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 504, + 376 + ], + "score": 1.0, + "content": "to correctly classify new examples. This model successfully exhibits one-shot learning on Omniglot.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 380, + 504, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 392 + ], + "score": 1.0, + "content": "However, this approach again requires fully-differentiable memory access and thus limits the size of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 392, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 506, + 403 + ], + "score": 1.0, + "content": "the memory as well as the length of an episode. This restriction has recently been alleviated by Rae", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "et al. (2016). Their model can utilize large memories, but unlike our work does not have an explicit", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 413, + 285, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 285, + 426 + ], + "score": 1.0, + "content": "cost to guide the formation of memory keys.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 107, + 430, + 505, + 486 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "For classification tasks like Omniglot, it is easy to construct short episodes so that they include a few", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "examples from each of several classes. However, this becomes harder as the output becomes richer.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "For example, in the difficult sequence-to-sequence tasks which we consider, it is hard to determine", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 462, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 505, + 476 + ], + "score": 1.0, + "content": "which examples would be helpful for correctly predicting others a priori, and so constructing short", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 474, + 484, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 484, + 486 + ], + "score": 1.0, + "content": "episodes each containing examples that are similar and act as hints to each other is intractable.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 533, + 505, + 566 + ], + "lines": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "One-shot Learning. While the recent work of Santoro et al. (2016) succeeded in bridging the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 544, + 507, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 507, + 558 + ], + "score": 1.0, + "content": "gap between memory-based models and one-shot learning, the field of one-shot learning has seen a", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 555, + 273, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 273, + 568 + ], + "score": 1.0, + "content": "variety of different approaches over time.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 572, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "score": 1.0, + "content": "Early work utilized Bayesian methods to model data generatively (Fei-Fei et al., 2006; Lake et al.,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "score": 1.0, + "content": "2011). The paper that introduced the Omniglot dataset (Lake et al., 2011) approached the task with a", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "score": 1.0, + "content": "generative model for strokes. This way, given a single character image, the probability of a different", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "image being of the same character may be approximated via standard techniques. One early neural", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "score": 1.0, + "content": "network approach to one-shot learning was given by Siamese networks (Koch, 2015). When our", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "approach is applied to the Omniglot image classification dataset, the resulting training algorithm is", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "actually similar to that of Siamese networks. The only difference is in the loss function: Siamese", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 649, + 442, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 442, + 661 + ], + "score": 1.0, + "content": "networks utilize a cross-entropy loss whereas our method uses a margin triplet loss.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "A more sophisticated neural network approach is given by Vinyals et al. (2016). The strengths of", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "score": 1.0, + "content": "this approach are (1) the model architecture utilizes recent advances in attention-augmented neural", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "networks for set-to-set learning (Oriol Vinyals, 2016a), and (2) the training algorithm is designed to", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 264, + 712 + ], + "score": 1.0, + "content": "exactly match the testing phase (given", + "type": "text" + }, + { + "bbox": [ + 264, + 699, + 271, + 709 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "distinct images and an additional image, the model must", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 189, + 722 + ], + "score": 1.0, + "content": "predict which of the", + "type": "text" + }, + { + "bbox": [ + 189, + 710, + 196, + 720 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "images is of the same class as the additional image). This approach may also", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 388, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 388, + 734 + ], + "score": 1.0, + "content": "be considered as a generalization of previous work on metric learning.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 503, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 106 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 110, + 505, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 506, + 124 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 506, + 124 + ], + "score": 1.0, + "content": "The success of these approaches hinges on making the memory component fully differentiable and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 134 + ], + "score": 1.0, + "content": "backpropagating signal through every access of memory. In this setting, computational requirements", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "necessitate that the memory be small. Some attempts have been made at making hard access queries", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "to memory (Zaremba & Sutskever, 2015; Xu et al., 2015), but it was usually challenging to match", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 505, + 167 + ], + "score": 1.0, + "content": "the soft version. Recently, more successful training for hard queries was reported (Gulc¸ehre et al. ¨ ,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "2016) that makes use of a curriculum strategy that mixes soft and hard queries at training time. Our", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 506, + 190 + ], + "score": 1.0, + "content": "approach applies hard access as well, but we encourage the model to make good queries via a special", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 163, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 163, + 200 + ], + "score": 1.0, + "content": "memory loss.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 110, + 506, + 200 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 204, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "Modifications to allow for large-scale memory in neural networks have been proposed. The original", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 215, + 506, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 506, + 228 + ], + "score": 1.0, + "content": "implementation of memory networks (Weston et al., 2014) and later work on scaling it (Bordes", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 506, + 239 + ], + "score": 1.0, + "content": "et al., 2015; Chandar et al., 2016) used memory with size in the millions. The cost of doing so is", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "that the memory must be fixed prior to training. Moreover, since during the beginning of training the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "score": 1.0, + "content": "model is unlikely to query the memory correctly, strong supervision is used to encourage the model", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 258, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 272 + ], + "score": 1.0, + "content": "to query memory locations that are useful. These hints are either given as additional supervising", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 270, + 404, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 404, + 282 + ], + "score": 1.0, + "content": "information by the task or determined heuristically as in Hill et al. (2015).", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 204, + 506, + 282 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 286, + 505, + 375 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 300 + ], + "score": 1.0, + "content": "All the work discussed so far has either used a memory that is fixed before training or used a memory", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 297, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 311 + ], + "score": 1.0, + "content": "that is not persistent between different examples. For one-shot and lifelong learning, a memory must", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 308, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 322 + ], + "score": 1.0, + "content": "necessarily be both volatile during training and persistent between examples. To bridge this gap,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 505, + 332 + ], + "score": 1.0, + "content": "Santoro et al. (2016) propose to partition training into distinct episodes consisting of a sequence", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 330, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 195, + 345 + ], + "score": 1.0, + "content": "of labelled examples", + "type": "text" + }, + { + "bbox": [ + 195, + 330, + 248, + 343 + ], + "score": 0.93, + "content": "\\bar { \\{ ( x _ { i } , y _ { i } ) \\} } _ { i = 1 } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 330, + 506, + 345 + ], + "score": 1.0, + "content": ". A network augmented with a fully-differentiable memory is", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 177, + 355 + ], + "score": 1.0, + "content": "trained to predict", + "type": "text" + }, + { + "bbox": [ + 178, + 343, + 187, + 353 + ], + "score": 0.84, + "content": "y _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 342, + 305, + 355 + ], + "score": 1.0, + "content": "given the previous sequence", + "type": "text" + }, + { + "bbox": [ + 305, + 342, + 379, + 354 + ], + "score": 0.9, + "content": "( x _ { 1 } , y _ { 1 } , \\dotsc , x _ { i - 1 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 342, + 506, + 355 + ], + "score": 1.0, + "content": ". This way, the model learns to", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "store important examples with their corresponding labels in memory and later re-use this information", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 364, + 504, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 504, + 376 + ], + "score": 1.0, + "content": "to correctly classify new examples. This model successfully exhibits one-shot learning on Omniglot.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 285, + 506, + 376 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 380, + 504, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 380, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 392 + ], + "score": 1.0, + "content": "However, this approach again requires fully-differentiable memory access and thus limits the size of", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 392, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 392, + 506, + 403 + ], + "score": 1.0, + "content": "the memory as well as the length of an episode. This restriction has recently been alleviated by Rae", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "et al. (2016). Their model can utilize large memories, but unlike our work does not have an explicit", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 413, + 285, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 285, + 426 + ], + "score": 1.0, + "content": "cost to guide the formation of memory keys.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 380, + 506, + 426 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 430, + 505, + 486 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "For classification tasks like Omniglot, it is easy to construct short episodes so that they include a few", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "examples from each of several classes. However, this becomes harder as the output becomes richer.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "For example, in the difficult sequence-to-sequence tasks which we consider, it is hard to determine", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 462, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 505, + 476 + ], + "score": 1.0, + "content": "which examples would be helpful for correctly predicting others a priori, and so constructing short", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 474, + 484, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 484, + 486 + ], + "score": 1.0, + "content": "episodes each containing examples that are similar and act as hints to each other is intractable.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 430, + 505, + 486 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 533, + 505, + 566 + ], + "lines": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "One-shot Learning. While the recent work of Santoro et al. (2016) succeeded in bridging the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 544, + 507, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 507, + 558 + ], + "score": 1.0, + "content": "gap between memory-based models and one-shot learning, the field of one-shot learning has seen a", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 555, + 273, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 273, + 568 + ], + "score": 1.0, + "content": "variety of different approaches over time.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 532, + 507, + 568 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 572, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 505, + 584 + ], + "score": 1.0, + "content": "Early work utilized Bayesian methods to model data generatively (Fei-Fei et al., 2006; Lake et al.,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 595 + ], + "score": 1.0, + "content": "2011). The paper that introduced the Omniglot dataset (Lake et al., 2011) approached the task with a", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 506, + 607 + ], + "score": 1.0, + "content": "generative model for strokes. This way, given a single character image, the probability of a different", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "image being of the same character may be approximated via standard techniques. One early neural", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 506, + 629 + ], + "score": 1.0, + "content": "network approach to one-shot learning was given by Siamese networks (Koch, 2015). When our", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "approach is applied to the Omniglot image classification dataset, the resulting training algorithm is", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "actually similar to that of Siamese networks. The only difference is in the loss function: Siamese", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 649, + 442, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 442, + 661 + ], + "score": 1.0, + "content": "networks utilize a cross-entropy loss whereas our method uses a margin triplet loss.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 572, + 506, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "A more sophisticated neural network approach is given by Vinyals et al. (2016). The strengths of", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "score": 1.0, + "content": "this approach are (1) the model architecture utilizes recent advances in attention-augmented neural", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "networks for set-to-set learning (Oriol Vinyals, 2016a), and (2) the training algorithm is designed to", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 264, + 712 + ], + "score": 1.0, + "content": "exactly match the testing phase (given", + "type": "text" + }, + { + "bbox": [ + 264, + 699, + 271, + 709 + ], + "score": 0.79, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 272, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "distinct images and an additional image, the model must", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 189, + 722 + ], + "score": 1.0, + "content": "predict which of the", + "type": "text" + }, + { + "bbox": [ + 189, + 710, + 196, + 720 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "images is of the same class as the additional image). This approach may also", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 388, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 388, + 734 + ], + "score": 1.0, + "content": "be considered as a generalization of previous work on metric learning.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47.5, + "bbox_fs": [ + 105, + 665, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 136, + 514, + 205 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 505, + 123 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Table 1: Results on the Omniglot dataset. Although our model uses only a simple convolutional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "score": 1.0, + "content": "neural network, the addition of our memory module allows it to approach much more complex", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 111, + 298, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 298, + 123 + ], + "score": 1.0, + "content": "models on 1-shot and multi-shot learning tasks.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 106, + 136, + 514, + 205 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 136, + 514, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 136, + 514, + 205 + ], + "score": 0.979, + "html": "
Model5-way 1-shot5-way 5-shot20-way 1-shot20-way 5-shot
Pixels Nearest Neighbor41.7%63.2%26.7%42.6%
MANN (no convolutions)82.8%94.9%11
Convolutional Siamese Net96.7%98.4%88.0%96.5%
Matching Network98.1%98.9%93.8%98.5%
ConvNet with Memory Module98.4%99.6%95.0%98.6%
", + "type": "table", + "image_path": "3e84788e380c6c8f31c00e5fa93f09a01f2fb8880153858877a44dfe07b512aa.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 106, + 136, + 514, + 159.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 106, + 159.0, + 514, + 182.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 106, + 182.0, + 514, + 205.0 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 108, + 229, + 200, + 241 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 201, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 201, + 243 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "We perform experiments using all three architectures described above. We experiment both on real-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 264, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 506, + 277 + ], + "score": 1.0, + "content": "world data and on synthetic tasks that give us some insight into the performance and limitations of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "the memory module. In all our experiments we use the Adam optimizer (Kingma & Ba, 2014) and", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 344, + 299 + ], + "score": 1.0, + "content": "the parameters for the memory module remain unchanged", + "type": "text" + }, + { + "bbox": [ + 344, + 286, + 421, + 298 + ], + "score": 0.33, + "content": "( k = 2 5 6 , \\alpha = 0 . 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 286, + 505, + 299 + ], + "score": 1.0, + "content": ". Good performance", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 297, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 310 + ], + "score": 1.0, + "content": "with a single set of parameters shows the versatility of our memory module. The source code for the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 308, + 432, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 432, + 321 + ], + "score": 1.0, + "content": "memory module, together with our settings for Omniglot, is available on github1.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 431 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 505, + 343 + ], + "score": 1.0, + "content": "Omniglot. The Omniglot dataset (Lake et al., 2011) consists of 1623 characters from 50 different", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 343, + 505, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 355 + ], + "score": 1.0, + "content": "alphabets, each hand-drawn by 20 different people. The large number of classes (characters) with", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 354, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 505, + 366 + ], + "score": 1.0, + "content": "relatively few data per class (20), makes this an ideal data set for testing one-shot classification. In", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 121, + 377 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 122, + 365, + 132, + 375 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 365, + 271, + 377 + ], + "score": 1.0, + "content": "-way Omniglot task setup we pick", + "type": "text" + }, + { + "bbox": [ + 271, + 365, + 282, + 375 + ], + "score": 0.74, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "unseen character classes, independent of alphabet. We", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 375, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 436, + 389 + ], + "score": 1.0, + "content": "provide the model with one drawing of each character and measure its accuracy the", + "type": "text" + }, + { + "bbox": [ + 436, + 376, + 446, + 385 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 375, + 506, + 389 + ], + "score": 1.0, + "content": "-th time it sees", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 387, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 505, + 399 + ], + "score": 1.0, + "content": "the character class. Our setup is identical to Oriol Vinyals (2016b), so we also augmented the data", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 398, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 505, + 410 + ], + "score": 1.0, + "content": "set with random rotations by multiples of 90 degrees and use 1200 characters for training, and the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "remaining character classes for evaluation. We present the results from Oriol Vinyals (2016b) and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 419, + 496, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 496, + 432 + ], + "score": 1.0, + "content": "ours in Table 1. Even with a simpler network without batch normalization, we get similar results.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 477 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "Synthetic task. To better understand the memory module operation and to test what it can remem-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 453, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 467 + ], + "score": 1.0, + "content": "ber, we devise a synthetic task and train the Extended Neural GPU with and without memory (we", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 465, + 458, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 458, + 478 + ], + "score": 1.0, + "content": "use a small Extended Neural GPU with 32 channels and memory of size half a million).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 482, + 505, + 515 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 480, + 494 + ], + "score": 1.0, + "content": "To create training and test data for our synthetic task, we use symbols from the set", + "type": "text" + }, + { + "bbox": [ + 480, + 482, + 505, + 493 + ], + "score": 0.87, + "content": "S \\_ =", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 107, + 492, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 107, + 493, + 170, + 505 + ], + "score": 0.91, + "content": "\\{ 2 , \\ldots , 1 6 0 0 0 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 492, + 294, + 506 + ], + "score": 1.0, + "content": "and first fix a random function", + "type": "text" + }, + { + "bbox": [ + 295, + 493, + 339, + 504 + ], + "score": 0.92, + "content": "f : S S", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 492, + 397, + 506 + ], + "score": 1.0, + "content": ". The function", + "type": "text" + }, + { + "bbox": [ + 397, + 493, + 405, + 504 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 492, + 506, + 506 + ], + "score": 1.0, + "content": "is chosen at random, but", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 503, + 466, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 466, + 516 + ], + "score": 1.0, + "content": "fixed and the same for all training and testing examples (we used 40K training examples).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 505, + 587 + ], + "lines": [ + { + "bbox": [ + 104, + 519, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 506, + 534 + ], + "score": 1.0, + "content": "In our synthetic task, the input is a sequence consisting of As and Bs with one continuous substring", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 530, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 203, + 546 + ], + "score": 1.0, + "content": "of 7 digits from the set", + "type": "text" + }, + { + "bbox": [ + 204, + 532, + 238, + 543 + ], + "score": 0.85, + "content": "0 , 1 , 2 , 3", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 530, + 506, + 546 + ], + "score": 1.0, + "content": ". The substring is interpreted as a number written in base-4, e.g.,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 542, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 178, + 554 + ], + "score": 0.91, + "content": "1 9 8 2 = 1 3 2 3 3 2 _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 542, + 506, + 555 + ], + "score": 1.0, + "content": ", so the string 132332 would be interpreted as 1982. The corresponding output", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 554, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 476, + 566 + ], + "score": 1.0, + "content": "is created by copying all As and Bs, but mapping the number through the random function", + "type": "text" + }, + { + "bbox": [ + 476, + 554, + 483, + 565 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 554, + 506, + 566 + ], + "score": 1.0, + "content": ". For", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 564, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 187, + 577 + ], + "score": 1.0, + "content": "instance, assuming", + "type": "text" + }, + { + "bbox": [ + 188, + 564, + 261, + 577 + ], + "score": 0.91, + "content": "{ \\bar { f } } ( 1 9 8 2 ) = 3 7 2 6", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 564, + 506, + 577 + ], + "score": 1.0, + "content": ", the output corresponding to 132332 would be 322032 as", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 576, + 354, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 175, + 587 + ], + "score": 0.91, + "content": "3 7 2 6 = 3 2 2 0 3 2 _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 576, + 354, + 588 + ], + "score": 1.0, + "content": ". Here is an example of an input-output pair:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30.5 + }, + { + "type": "table", + "bbox": [ + 167, + 597, + 445, + 622 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 167, + 597, + 445, + 622 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 167, + 597, + 445, + 622 + ], + "spans": [ + { + "bbox": [ + 167, + 597, + 445, + 622 + ], + "score": 0.961, + "html": "
InputA0132332BABAB
OutputA0322032BABAB
", + "type": "table", + "image_path": "3c51d635a68755ef96260617b0c660691d11e3d7759a893cee9f1d7f22ce0f03.jpg" + } + ] + } + ], + "index": 34, + "virtual_lines": [ + { + "bbox": [ + 167, + 597, + 445, + 622 + ], + "spans": [], + "index": 34 + } + ] + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 631, + 505, + 676 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "score": 1.0, + "content": "This task clearly requires memory to store the fixed random function. Since there are 16K elements", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 642, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 505, + 654 + ], + "score": 1.0, + "content": "to learn, it is hard to memorize, and each single instance occurs quite rarely. The raw Extended", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "score": 1.0, + "content": "Neural GPU (or any other sequence-to-sequence model) are limited by their size. With long training,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 664, + 445, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 445, + 676 + ], + "score": 1.0, + "content": "the small model can memorize some of the sequences, but it is only a small fraction.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 106, + 681, + 502, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 680, + 504, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 504, + 694 + ], + "score": 1.0, + "content": "Additionally, there is no direct indication in the data what part of the input should trigger the pro-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 691, + 504, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 504, + 705 + ], + "score": 1.0, + "content": "duction of each output symbol. For example, to produce the first 3 output in the above example, the", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 105, + 712, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 117, + 708, + 505, + 725 + ], + "spans": [ + { + "bbox": [ + 117, + 708, + 505, + 725 + ], + "score": 1.0, + "content": "1 https://github.com/tensorflow/models/tree/master/learning_to_remember_", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 722, + 169, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 722, + 169, + 732 + ], + "score": 1.0, + "content": "rare_events", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 136, + 514, + 205 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 505, + 123 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Table 1: Results on the Omniglot dataset. Although our model uses only a simple convolutional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 505, + 113 + ], + "score": 1.0, + "content": "neural network, the addition of our memory module allows it to approach much more complex", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 111, + 298, + 123 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 298, + 123 + ], + "score": 1.0, + "content": "models on 1-shot and multi-shot learning tasks.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 106, + 136, + 514, + 205 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 136, + 514, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 136, + 514, + 205 + ], + "score": 0.979, + "html": "
Model5-way 1-shot5-way 5-shot20-way 1-shot20-way 5-shot
Pixels Nearest Neighbor41.7%63.2%26.7%42.6%
MANN (no convolutions)82.8%94.9%11
Convolutional Siamese Net96.7%98.4%88.0%96.5%
Matching Network98.1%98.9%93.8%98.5%
ConvNet with Memory Module98.4%99.6%95.0%98.6%
", + "type": "table", + "image_path": "3e84788e380c6c8f31c00e5fa93f09a01f2fb8880153858877a44dfe07b512aa.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 106, + 136, + 514, + 159.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 106, + 159.0, + 514, + 182.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 106, + 182.0, + 514, + 205.0 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 108, + 229, + 200, + 241 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 201, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 201, + 243 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 505, + 266 + ], + "score": 1.0, + "content": "We perform experiments using all three architectures described above. We experiment both on real-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 264, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 506, + 277 + ], + "score": 1.0, + "content": "world data and on synthetic tasks that give us some insight into the performance and limitations of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "the memory module. In all our experiments we use the Adam optimizer (Kingma & Ba, 2014) and", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 286, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 344, + 299 + ], + "score": 1.0, + "content": "the parameters for the memory module remain unchanged", + "type": "text" + }, + { + "bbox": [ + 344, + 286, + 421, + 298 + ], + "score": 0.33, + "content": "( k = 2 5 6 , \\alpha = 0 . 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 286, + 505, + 299 + ], + "score": 1.0, + "content": ". Good performance", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 297, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 297, + 506, + 310 + ], + "score": 1.0, + "content": "with a single set of parameters shows the versatility of our memory module. The source code for the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 308, + 432, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 432, + 321 + ], + "score": 1.0, + "content": "memory module, together with our settings for Omniglot, is available on github1.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 253, + 506, + 321 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 431 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 505, + 343 + ], + "score": 1.0, + "content": "Omniglot. The Omniglot dataset (Lake et al., 2011) consists of 1623 characters from 50 different", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 343, + 505, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 355 + ], + "score": 1.0, + "content": "alphabets, each hand-drawn by 20 different people. The large number of classes (characters) with", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 354, + 505, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 354, + 505, + 366 + ], + "score": 1.0, + "content": "relatively few data per class (20), makes this an ideal data set for testing one-shot classification. In", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 365, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 365, + 121, + 377 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 122, + 365, + 132, + 375 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 365, + 271, + 377 + ], + "score": 1.0, + "content": "-way Omniglot task setup we pick", + "type": "text" + }, + { + "bbox": [ + 271, + 365, + 282, + 375 + ], + "score": 0.74, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 365, + 505, + 377 + ], + "score": 1.0, + "content": "unseen character classes, independent of alphabet. We", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 375, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 436, + 389 + ], + "score": 1.0, + "content": "provide the model with one drawing of each character and measure its accuracy the", + "type": "text" + }, + { + "bbox": [ + 436, + 376, + 446, + 385 + ], + "score": 0.82, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 447, + 375, + 506, + 389 + ], + "score": 1.0, + "content": "-th time it sees", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 387, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 505, + 399 + ], + "score": 1.0, + "content": "the character class. Our setup is identical to Oriol Vinyals (2016b), so we also augmented the data", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 398, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 505, + 410 + ], + "score": 1.0, + "content": "set with random rotations by multiples of 90 degrees and use 1200 characters for training, and the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "remaining character classes for evaluation. We present the results from Oriol Vinyals (2016b) and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 419, + 496, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 496, + 432 + ], + "score": 1.0, + "content": "ours in Table 1. Even with a simpler network without batch normalization, we get similar results.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 333, + 506, + 432 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 477 + ], + "lines": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "Synthetic task. To better understand the memory module operation and to test what it can remem-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 453, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 467 + ], + "score": 1.0, + "content": "ber, we devise a synthetic task and train the Extended Neural GPU with and without memory (we", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 465, + 458, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 458, + 478 + ], + "score": 1.0, + "content": "use a small Extended Neural GPU with 32 channels and memory of size half a million).", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 442, + 505, + 478 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 482, + 505, + 515 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 480, + 494 + ], + "score": 1.0, + "content": "To create training and test data for our synthetic task, we use symbols from the set", + "type": "text" + }, + { + "bbox": [ + 480, + 482, + 505, + 493 + ], + "score": 0.87, + "content": "S \\_ =", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 107, + 492, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 107, + 493, + 170, + 505 + ], + "score": 0.91, + "content": "\\{ 2 , \\ldots , 1 6 0 0 0 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 492, + 294, + 506 + ], + "score": 1.0, + "content": "and first fix a random function", + "type": "text" + }, + { + "bbox": [ + 295, + 493, + 339, + 504 + ], + "score": 0.92, + "content": "f : S S", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 492, + 397, + 506 + ], + "score": 1.0, + "content": ". The function", + "type": "text" + }, + { + "bbox": [ + 397, + 493, + 405, + 504 + ], + "score": 0.86, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 492, + 506, + 506 + ], + "score": 1.0, + "content": "is chosen at random, but", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 503, + 466, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 466, + 516 + ], + "score": 1.0, + "content": "fixed and the same for all training and testing examples (we used 40K training examples).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 482, + 506, + 516 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 520, + 505, + 587 + ], + "lines": [ + { + "bbox": [ + 104, + 519, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 104, + 519, + 506, + 534 + ], + "score": 1.0, + "content": "In our synthetic task, the input is a sequence consisting of As and Bs with one continuous substring", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 530, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 203, + 546 + ], + "score": 1.0, + "content": "of 7 digits from the set", + "type": "text" + }, + { + "bbox": [ + 204, + 532, + 238, + 543 + ], + "score": 0.85, + "content": "0 , 1 , 2 , 3", + "type": "inline_equation" + }, + { + "bbox": [ + 238, + 530, + 506, + 546 + ], + "score": 1.0, + "content": ". The substring is interpreted as a number written in base-4, e.g.,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 542, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 178, + 554 + ], + "score": 0.91, + "content": "1 9 8 2 = 1 3 2 3 3 2 _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 542, + 506, + 555 + ], + "score": 1.0, + "content": ", so the string 132332 would be interpreted as 1982. The corresponding output", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 554, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 476, + 566 + ], + "score": 1.0, + "content": "is created by copying all As and Bs, but mapping the number through the random function", + "type": "text" + }, + { + "bbox": [ + 476, + 554, + 483, + 565 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 554, + 506, + 566 + ], + "score": 1.0, + "content": ". For", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 564, + 506, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 187, + 577 + ], + "score": 1.0, + "content": "instance, assuming", + "type": "text" + }, + { + "bbox": [ + 188, + 564, + 261, + 577 + ], + "score": 0.91, + "content": "{ \\bar { f } } ( 1 9 8 2 ) = 3 7 2 6", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 564, + 506, + 577 + ], + "score": 1.0, + "content": ", the output corresponding to 132332 would be 322032 as", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 576, + 354, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 175, + 587 + ], + "score": 0.91, + "content": "3 7 2 6 = 3 2 2 0 3 2 _ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 576, + 354, + 588 + ], + "score": 1.0, + "content": ". Here is an example of an input-output pair:", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30.5, + "bbox_fs": [ + 104, + 519, + 506, + 588 + ] + }, + { + "type": "table", + "bbox": [ + 167, + 597, + 445, + 622 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 167, + 597, + 445, + 622 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 167, + 597, + 445, + 622 + ], + "spans": [ + { + "bbox": [ + 167, + 597, + 445, + 622 + ], + "score": 0.961, + "html": "
InputA0132332BABAB
OutputA0322032BABAB
", + "type": "table", + "image_path": "3c51d635a68755ef96260617b0c660691d11e3d7759a893cee9f1d7f22ce0f03.jpg" + } + ] + } + ], + "index": 34, + "virtual_lines": [ + { + "bbox": [ + 167, + 597, + 445, + 622 + ], + "spans": [], + "index": 34 + } + ] + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 631, + 505, + 676 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 644 + ], + "score": 1.0, + "content": "This task clearly requires memory to store the fixed random function. Since there are 16K elements", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 642, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 106, + 642, + 505, + 654 + ], + "score": 1.0, + "content": "to learn, it is hard to memorize, and each single instance occurs quite rarely. The raw Extended", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "score": 1.0, + "content": "Neural GPU (or any other sequence-to-sequence model) are limited by their size. With long training,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 664, + 445, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 445, + 676 + ], + "score": 1.0, + "content": "the small model can memorize some of the sequences, but it is only a small fraction.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 630, + 505, + 676 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 681, + 502, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 680, + 504, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 504, + 694 + ], + "score": 1.0, + "content": "Additionally, there is no direct indication in the data what part of the input should trigger the pro-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 691, + 504, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 504, + 705 + ], + "score": 1.0, + "content": "duction of each output symbol. For example, to produce the first 3 output in the above example, the", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5, + "bbox_fs": [ + 106, + 680, + 504, + 705 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 169, + 115, + 441, + 186 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 503, + 112 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Table 2: Results on the synthetic task. We report the percentage of fully correct sequences from the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 384, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 384, + 112 + ], + "score": 1.0, + "content": "test set, which contains 10000 random examples. See text for details.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 169, + 115, + 441, + 186 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 169, + 115, + 441, + 186 + ], + "spans": [ + { + "bbox": [ + 169, + 115, + 441, + 186 + ], + "score": 0.98, + "html": "
ModelAccuracy
HammingNearestNeighborBaseline Sequence-to-Sequence with AttentionBaseline Extended Neural GPU0.1%0.9%12.2%
Sequence-to-Sequence with Attention and MemoryExtended Neural GPU with Memory Module35.2%71.3%
", + "type": "table", + "image_path": "18a08bfd3c22f4560cc91e2fa7269939fec5786838ff6eb450649973f936c0e8.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 169, + 115, + 441, + 138.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 169, + 138.66666666666666, + 441, + 162.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 169, + 162.33333333333331, + 441, + 185.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 107, + 211, + 505, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 210, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 224 + ], + "score": 1.0, + "content": "Table 3: Results on the WMT En-De task. As described in the text, we split the test set in two", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 223, + 504, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 504, + 235 + ], + "score": 1.0, + "content": "(odd lines and even lines) to evaluate the model on one-shot learning. Given the even test set, the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 234, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 505, + 245 + ], + "score": 1.0, + "content": "model can perform better on the odd test set. We also see a dramatic improvement when the model", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 245, + 484, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 484, + 257 + ], + "score": 1.0, + "content": "is provided with the whole test set, validating that the memory module is working as intended.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6.5 + }, + { + "type": "table", + "bbox": [ + 141, + 261, + 469, + 320 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 141, + 261, + 469, + 320 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 141, + 261, + 469, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 261, + 469, + 320 + ], + "score": 0.977, + "html": "
ModelFull TestOdd Test
GNMT23.2523.17
GNMT withMemoryModule23.2923.16
GNMTwithMemoryModule andEven Testcontext123.60
GNMT with Memory Module and Whole Test context31.11*1
", + "type": "table", + "image_path": "079f9dac90fea47a116c7b9245994f9ad491792a80f2179ec00f5037178d0b4f.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 141, + 261, + 469, + 280.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 141, + 280.6666666666667, + 469, + 300.33333333333337 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 141, + 300.33333333333337, + 469, + 320.00000000000006 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 348, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 348, + 505, + 360 + ], + "score": 1.0, + "content": "memory key needs to encode all base-4 symbols from the input. Not just one or two aligned sym-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 358, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 506, + 371 + ], + "score": 1.0, + "content": "bols, but a number of them. Moreover, it should not encode more symbols or it will not generalize", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 370, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 382 + ], + "score": 1.0, + "content": "to the test set. Similarly, a basic nearest neighbor classifier fails on this task. We use sequences of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 379, + 506, + 394 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 506, + 394 + ], + "score": 1.0, + "content": "length up to 40 during training, but there are only 7 relevant symbols. The simple nearest neighbor", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 390, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 104, + 390, + 506, + 404 + ], + "score": 1.0, + "content": "by Hamming distance will most probably select some sequence with similar prefix or suffix of As", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "and Bs, and not the one with the corresponding base-4 part. We also trained a large sequence-to-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "sequence model with attention on this task (a 2-layer LSTM model with 256 units in each layer).", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "This model can memorize the whole training set, but it suffers from a similar problem as the Ham-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 486, + 447 + ], + "score": 1.0, + "content": "ming nearest neighbor – it almost doesn’t generalize, its accuracy on the test set is only about", + "type": "text" + }, + { + "bbox": [ + 487, + 435, + 501, + 446 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 435, + 505, + 447 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 446, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 426, + 459 + ], + "score": 1.0, + "content": "The same model with a memory module generalizes much better, reaching over", + "type": "text" + }, + { + "bbox": [ + 426, + 446, + 446, + 457 + ], + "score": 0.89, + "content": "3 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 446, + 505, + 459 + ], + "score": 1.0, + "content": "accuracy. The", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 456, + 456, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 456, + 469 + ], + "score": 1.0, + "content": "Extended Neural GPU with our memory module yields even better results, see Table 2.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 108, + 483, + 505, + 516 + ], + "lines": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "Translation. To evaluate the memory module in a large-scale setting we use the GNMT", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "model (Wu et al., 2016) extended with our memory module on the WMT14 English-to-German", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 505, + 413, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 413, + 518 + ], + "score": 1.0, + "content": "translation task. We evaluate the model both qualitatively and quantitatively.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 108, + 523, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "score": 1.0, + "content": "On the qualitative side, we note that our memory-augmented model can successfully translate rare", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "words like Dostoevsky, unlike the baseline model which predicts an identity-mapped Dostoevsky for", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 544, + 262, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 262, + 557 + ], + "score": 1.0, + "content": "the German translation of Dostoevsky.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 108, + 561, + 503, + 583 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 575 + ], + "score": 1.0, + "content": "On the quantitative side, we use the WMT test set. We find that in terms of BLEU score, an aggregate", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 572, + 465, + 584 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 465, + 584 + ], + "score": 1.0, + "content": "measure, the memory-augmented GNMT is on par with the baseline GNMT, see Table 3.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 589, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "To evaluate our memory-augmented model for one-shot capabilities we split the test set in two. We", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "score": 1.0, + "content": "take the even lines of the test set (index starting at 0) as a context set and the odd lines of the test set", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 609, + 507, + 626 + ], + "spans": [ + { + "bbox": [ + 104, + 609, + 507, + 626 + ], + "score": 1.0, + "content": "as the one-shot evaluation set. While showing the context set to the model, no additional training", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "occurs, only memory updates are allowed. So the weights of the model do not change, but the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "memory does. Since the sentences in the test set are highly-correlated to each other (they come from", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "paragraphs with preserved order), we expect that if we allow a one-shot capable model to use the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 104, + 653, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 104, + 653, + 505, + 669 + ], + "score": 1.0, + "content": "context set to update its memory and then evaluate it on the other half of the test set, its accuracy", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 664, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 680 + ], + "score": 1.0, + "content": "will increase. For our GNMT with memory model, we passed the context set through the memory", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "update operations 3 times. As seen in Table 3, the context set indeed helps when evaluating on the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "odd lines, increasing the BLEU score by almost 0.5. As further indication that our memory module", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "works properly, we also evaluate the model after showing the whole test set as a context set. Note", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "that this is essentially an oracle: the memory module gets to see all the correct answers, we do this", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 720, + 484, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 484, + 734 + ], + "score": 1.0, + "content": "only to test and debug. As expected, this increases BLEU score dramatically, by over 8 points.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 37 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 169, + 115, + 441, + 186 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 503, + 112 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Table 2: Results on the synthetic task. We report the percentage of fully correct sequences from the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 384, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 384, + 112 + ], + "score": 1.0, + "content": "test set, which contains 10000 random examples. See text for details.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 169, + 115, + 441, + 186 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 169, + 115, + 441, + 186 + ], + "spans": [ + { + "bbox": [ + 169, + 115, + 441, + 186 + ], + "score": 0.98, + "html": "
ModelAccuracy
HammingNearestNeighborBaseline Sequence-to-Sequence with AttentionBaseline Extended Neural GPU0.1%0.9%12.2%
Sequence-to-Sequence with Attention and MemoryExtended Neural GPU with Memory Module35.2%71.3%
", + "type": "table", + "image_path": "18a08bfd3c22f4560cc91e2fa7269939fec5786838ff6eb450649973f936c0e8.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 169, + 115, + 441, + 138.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 169, + 138.66666666666666, + 441, + 162.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 169, + 162.33333333333331, + 441, + 185.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 107, + 211, + 505, + 257 + ], + "lines": [ + { + "bbox": [ + 105, + 210, + 505, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 224 + ], + "score": 1.0, + "content": "Table 3: Results on the WMT En-De task. As described in the text, we split the test set in two", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 223, + 504, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 504, + 235 + ], + "score": 1.0, + "content": "(odd lines and even lines) to evaluate the model on one-shot learning. Given the even test set, the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 234, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 505, + 245 + ], + "score": 1.0, + "content": "model can perform better on the odd test set. We also see a dramatic improvement when the model", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 245, + 484, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 484, + 257 + ], + "score": 1.0, + "content": "is provided with the whole test set, validating that the memory module is working as intended.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 210, + 505, + 257 + ] + }, + { + "type": "table", + "bbox": [ + 141, + 261, + 469, + 320 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 141, + 261, + 469, + 320 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 141, + 261, + 469, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 261, + 469, + 320 + ], + "score": 0.977, + "html": "
ModelFull TestOdd Test
GNMT23.2523.17
GNMT withMemoryModule23.2923.16
GNMTwithMemoryModule andEven Testcontext123.60
GNMT with Memory Module and Whole Test context31.11*1
", + "type": "table", + "image_path": "079f9dac90fea47a116c7b9245994f9ad491792a80f2179ec00f5037178d0b4f.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 141, + 261, + 469, + 280.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 141, + 280.6666666666667, + 469, + 300.33333333333337 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 141, + 300.33333333333337, + 469, + 320.00000000000006 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 106, + 347, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 348, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 348, + 505, + 360 + ], + "score": 1.0, + "content": "memory key needs to encode all base-4 symbols from the input. Not just one or two aligned sym-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 358, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 506, + 371 + ], + "score": 1.0, + "content": "bols, but a number of them. Moreover, it should not encode more symbols or it will not generalize", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 370, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 506, + 382 + ], + "score": 1.0, + "content": "to the test set. Similarly, a basic nearest neighbor classifier fails on this task. We use sequences of", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 379, + 506, + 394 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 506, + 394 + ], + "score": 1.0, + "content": "length up to 40 during training, but there are only 7 relevant symbols. The simple nearest neighbor", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 390, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 104, + 390, + 506, + 404 + ], + "score": 1.0, + "content": "by Hamming distance will most probably select some sequence with similar prefix or suffix of As", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "and Bs, and not the one with the corresponding base-4 part. We also trained a large sequence-to-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 505, + 426 + ], + "score": 1.0, + "content": "sequence model with attention on this task (a 2-layer LSTM model with 256 units in each layer).", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "This model can memorize the whole training set, but it suffers from a similar problem as the Ham-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 435, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 486, + 447 + ], + "score": 1.0, + "content": "ming nearest neighbor – it almost doesn’t generalize, its accuracy on the test set is only about", + "type": "text" + }, + { + "bbox": [ + 487, + 435, + 501, + 446 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 435, + 505, + 447 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 446, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 426, + 459 + ], + "score": 1.0, + "content": "The same model with a memory module generalizes much better, reaching over", + "type": "text" + }, + { + "bbox": [ + 426, + 446, + 446, + 457 + ], + "score": 0.89, + "content": "3 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 446, + 505, + 459 + ], + "score": 1.0, + "content": "accuracy. The", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 456, + 456, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 456, + 469 + ], + "score": 1.0, + "content": "Extended Neural GPU with our memory module yields even better results, see Table 2.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 17, + "bbox_fs": [ + 104, + 348, + 506, + 469 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 483, + 505, + 516 + ], + "lines": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "Translation. To evaluate the memory module in a large-scale setting we use the GNMT", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 507 + ], + "score": 1.0, + "content": "model (Wu et al., 2016) extended with our memory module on the WMT14 English-to-German", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 505, + 413, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 413, + 518 + ], + "score": 1.0, + "content": "translation task. We evaluate the model both qualitatively and quantitatively.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 483, + 505, + 518 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 523, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 536 + ], + "score": 1.0, + "content": "On the qualitative side, we note that our memory-augmented model can successfully translate rare", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "words like Dostoevsky, unlike the baseline model which predicts an identity-mapped Dostoevsky for", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 544, + 262, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 262, + 557 + ], + "score": 1.0, + "content": "the German translation of Dostoevsky.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 522, + 505, + 557 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 561, + 503, + 583 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 575 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 575 + ], + "score": 1.0, + "content": "On the quantitative side, we use the WMT test set. We find that in terms of BLEU score, an aggregate", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 572, + 465, + 584 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 465, + 584 + ], + "score": 1.0, + "content": "measure, the memory-augmented GNMT is on par with the baseline GNMT, see Table 3.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 106, + 560, + 505, + 584 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 589, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "To evaluate our memory-augmented model for one-shot capabilities we split the test set in two. We", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 506, + 613 + ], + "score": 1.0, + "content": "take the even lines of the test set (index starting at 0) as a context set and the odd lines of the test set", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 609, + 507, + 626 + ], + "spans": [ + { + "bbox": [ + 104, + 609, + 507, + 626 + ], + "score": 1.0, + "content": "as the one-shot evaluation set. While showing the context set to the model, no additional training", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "occurs, only memory updates are allowed. So the weights of the model do not change, but the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "memory does. Since the sentences in the test set are highly-correlated to each other (they come from", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 644, + 505, + 656 + ], + "score": 1.0, + "content": "paragraphs with preserved order), we expect that if we allow a one-shot capable model to use the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 104, + 653, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 104, + 653, + 505, + 669 + ], + "score": 1.0, + "content": "context set to update its memory and then evaluate it on the other half of the test set, its accuracy", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 664, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 680 + ], + "score": 1.0, + "content": "will increase. For our GNMT with memory model, we passed the context set through the memory", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "update operations 3 times. As seen in Table 3, the context set indeed helps when evaluating on the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "odd lines, increasing the BLEU score by almost 0.5. As further indication that our memory module", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "works properly, we also evaluate the model after showing the whole test set as a context set. Note", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "that this is essentially an oracle: the memory module gets to see all the correct answers, we do this", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 720, + 484, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 484, + 734 + ], + "score": 1.0, + "content": "only to test and debug. As expected, this increases BLEU score dramatically, by over 8 points.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 37, + "bbox_fs": [ + 104, + 588, + 507, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 190, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 192, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 192, + 96 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 105, + 505, + 172 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "We presented a long-term memory module that can be used for life-long learning. It is versatile, so it", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 506, + 129 + ], + "score": 1.0, + "content": "can be added to different deep learning models and at different layers to give the networks one-shot", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 140 + ], + "score": 1.0, + "content": "learning capability. Several parts of the presented memory module could be tuned and studied in", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 138, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 505, + 151 + ], + "score": 1.0, + "content": "more detail. The update rule that averages the query with the correct key could be parametrized.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 161 + ], + "score": 1.0, + "content": "Instead of returning only the single nearest neighbor we could also return a number of them to be", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 453, + 173 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 453, + 173 + ], + "score": 1.0, + "content": "processed by other layers of the network. We leave these questions for future research.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 177, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "The main issue we encountered, though, is that evaluating one-shot learning is difficult, as standard", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "score": 1.0, + "content": "metrics do not focus on this scenario. In this work, we adapted the standard metrics to investigate", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "our approach. For example, in the translation task we used half of the test set as context for the other", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 211, + 504, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 504, + 222 + ], + "score": 1.0, + "content": "half, and we still report the standard BLEU score. This allows us to show that our module works,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "but it is only a temporary solution. Better metrics are needed to accelerate progress of one-shot and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 231, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 104, + 231, + 505, + 246 + ], + "score": 1.0, + "content": "life-long learning. Thus, we consider the present work as just a first step on the way to making deep", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 244, + 349, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 349, + 255 + ], + "score": 1.0, + "content": "models learn to remember rare events through their lifetime.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 107, + 271, + 175, + 283 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 176, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 176, + 285 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 105, + 282, + 506, + 738 + ], + "lines": [ + { + "bbox": [ + 105, + 289, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 303 + ], + "score": 1.0, + "content": "A. Andoni and P. Indyk. Near-optimal hashing algorithms for approximate nearest neighbor in", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 300, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 115, + 300, + 505, + 313 + ], + "score": 1.0, + "content": "high dimensions. In 2006 47th Annual IEEE Symposium on Foundations of Computer Science", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 312, + 382, + 324 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 382, + 324 + ], + "score": 1.0, + "content": "(FOCS’06), pp. 459–468, Oct 2006. doi: 10.1109/FOCS.2006.49.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 329, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 104, + 329, + 505, + 344 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 340, + 504, + 354 + ], + "spans": [ + { + "bbox": [ + 114, + 340, + 504, + 354 + ], + "score": 1.0, + "content": "learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 117, + 353, + 199, + 364 + ], + "spans": [ + { + "bbox": [ + 117, + 353, + 199, + 364 + ], + "score": 1.0, + "content": "abs/1409.0473.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 369, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 104, + 369, + 505, + 384 + ], + "score": 1.0, + "content": "Antoine Bordes, Nicolas Usunier, Sumit Chopra, and Jason Weston. Large-scale simple question", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 114, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 114, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "answering with memory networks. CoRR, abs/1506.02075, 2015. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 117, + 393, + 205, + 404 + ], + "spans": [ + { + "bbox": [ + 117, + 393, + 205, + 404 + ], + "score": 1.0, + "content": "abs/1506.02075.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 410, + 504, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 504, + 423 + ], + "score": 1.0, + "content": "Sarath Chandar, Sungjin Ahn, Hugo Larochelle, Pascal Vincent, Gerald Tesauro, and Yoshua Ben-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 421, + 428, + 434 + ], + "spans": [ + { + "bbox": [ + 115, + 421, + 428, + 434 + ], + "score": 1.0, + "content": "gio. Hierarchical memory networks. arXiv preprint arXiv:1605.07427, 2016.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "score": 1.0, + "content": "Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Fethi Bougares, Holger Schwenk, and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 449, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 115, + 449, + 505, + 464 + ], + "score": 1.0, + "content": "Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical ma-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 460, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 114, + 460, + 505, + 475 + ], + "score": 1.0, + "content": "chine translation. CoRR, abs/1406.1078, 2014. URL http://arxiv.org/abs/1406.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 473, + 146, + 484 + ], + "spans": [ + { + "bbox": [ + 115, + 473, + 146, + 484 + ], + "score": 1.0, + "content": "1078.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 489, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 104, + 489, + 505, + 505 + ], + "score": 1.0, + "content": "Li Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE Trans.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 115, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "Pattern Anal. Mach. Intell., 28(4):594–611, April 2006. ISSN 0162-8828. doi: 10.1109/TPAMI.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 513, + 416, + 525 + ], + "spans": [ + { + "bbox": [ + 116, + 513, + 416, + 525 + ], + "score": 1.0, + "content": "2006.79. URL http://dx.doi.org/10.1109/TPAMI.2006.79.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 530, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 545 + ], + "score": 1.0, + "content": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 541, + 349, + 555 + ], + "spans": [ + { + "bbox": [ + 115, + 541, + 349, + 555 + ], + "score": 1.0, + "content": "2014. URL http://arxiv.org/abs/1410.5401.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 559, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 505, + 574 + ], + "score": 1.0, + "content": "C¸ aglar Gulc¸ehre, Sarath Chandar, Kyunghyun Cho, and Yoshua Bengio. Dynamic neural turing ¨", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 571, + 434, + 584 + ], + "spans": [ + { + "bbox": [ + 115, + 571, + 434, + 584 + ], + "score": 1.0, + "content": "machine with soft and hard addressing schemes. CoRR, abs/1607.00036, 2016.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 103, + 587, + 506, + 604 + ], + "spans": [ + { + "bbox": [ + 103, + 587, + 506, + 604 + ], + "score": 1.0, + "content": "Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 599, + 462, + 614 + ], + "spans": [ + { + "bbox": [ + 114, + 599, + 462, + 614 + ], + "score": 1.0, + "content": "children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 617, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 632 + ], + "score": 1.0, + "content": "Geoffrey Hinton, Li Deng, Dong Yu, George Dahl, Abdelrahman Mohamed, Navdeep Jaitly, An-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 628, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 114, + 628, + 505, + 644 + ], + "score": 1.0, + "content": "drew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara Sainath, and Brian Kingsbury. Deep", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 114, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 114, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "neural networks for acoustic modeling in speech recognition: The shared views of four research", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 651, + 372, + 665 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 372, + 665 + ], + "score": 1.0, + "content": "groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 669, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 684 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 680, + 191, + 693 + ], + "spans": [ + { + "bbox": [ + 116, + 680, + 191, + 693 + ], + "score": 1.0, + "content": "1735–1780, 1997.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "Piotr Indyk and Rajeev Motwani. Approximate nearest neighbors: towards removing the curse of", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 114, + 708, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 114, + 708, + 505, + 724 + ], + "score": 1.0, + "content": "dimensionality. In Proceedings of the thirtieth annual ACM symposium on Theory of computing,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 115, + 721, + 223, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 223, + 732 + ], + "score": 1.0, + "content": "pp. 604–613. ACM, 1998.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 31 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 293, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 190, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 192, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 192, + 96 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 105, + 505, + 172 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "We presented a long-term memory module that can be used for life-long learning. It is versatile, so it", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 506, + 129 + ], + "score": 1.0, + "content": "can be added to different deep learning models and at different layers to give the networks one-shot", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 140 + ], + "score": 1.0, + "content": "learning capability. Several parts of the presented memory module could be tuned and studied in", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 138, + 505, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 505, + 151 + ], + "score": 1.0, + "content": "more detail. The update rule that averages the query with the correct key could be parametrized.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 161 + ], + "score": 1.0, + "content": "Instead of returning only the single nearest neighbor we could also return a number of them to be", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 453, + 173 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 453, + 173 + ], + "score": 1.0, + "content": "processed by other layers of the network. We leave these questions for future research.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 106, + 506, + 173 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 177, + 505, + 255 + ], + "lines": [ + { + "bbox": [ + 106, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 106, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "The main issue we encountered, though, is that evaluating one-shot learning is difficult, as standard", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "score": 1.0, + "content": "metrics do not focus on this scenario. In this work, we adapted the standard metrics to investigate", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "our approach. For example, in the translation task we used half of the test set as context for the other", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 211, + 504, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 504, + 222 + ], + "score": 1.0, + "content": "half, and we still report the standard BLEU score. This allows us to show that our module works,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 234 + ], + "score": 1.0, + "content": "but it is only a temporary solution. Better metrics are needed to accelerate progress of one-shot and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 231, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 104, + 231, + 505, + 246 + ], + "score": 1.0, + "content": "life-long learning. Thus, we consider the present work as just a first step on the way to making deep", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 244, + 349, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 349, + 255 + ], + "score": 1.0, + "content": "models learn to remember rare events through their lifetime.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10, + "bbox_fs": [ + 104, + 177, + 505, + 255 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 271, + 175, + 283 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 176, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 176, + 285 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "list", + "bbox": [ + 105, + 282, + 506, + 738 + ], + "lines": [ + { + "bbox": [ + 105, + 289, + 505, + 303 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 303 + ], + "score": 1.0, + "content": "A. Andoni and P. Indyk. Near-optimal hashing algorithms for approximate nearest neighbor in", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 300, + 505, + 313 + ], + "spans": [ + { + "bbox": [ + 115, + 300, + 505, + 313 + ], + "score": 1.0, + "content": "high dimensions. In 2006 47th Annual IEEE Symposium on Foundations of Computer Science", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 312, + 382, + 324 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 382, + 324 + ], + "score": 1.0, + "content": "(FOCS’06), pp. 459–468, Oct 2006. doi: 10.1109/FOCS.2006.49.", + "type": "text" + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 329, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 104, + 329, + 505, + 344 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 340, + 504, + 354 + ], + "spans": [ + { + "bbox": [ + 114, + 340, + 504, + 354 + ], + "score": 1.0, + "content": "learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 117, + 353, + 199, + 364 + ], + "spans": [ + { + "bbox": [ + 117, + 353, + 199, + 364 + ], + "score": 1.0, + "content": "abs/1409.0473.", + "type": "text" + } + ], + "index": 20, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 369, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 104, + 369, + 505, + 384 + ], + "score": 1.0, + "content": "Antoine Bordes, Nicolas Usunier, Sumit Chopra, and Jason Weston. Large-scale simple question", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 114, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "answering with memory networks. CoRR, abs/1506.02075, 2015. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 117, + 393, + 205, + 404 + ], + "spans": [ + { + "bbox": [ + 117, + 393, + 205, + 404 + ], + "score": 1.0, + "content": "abs/1506.02075.", + "type": "text" + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 410, + 504, + 423 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 504, + 423 + ], + "score": 1.0, + "content": "Sarath Chandar, Sungjin Ahn, Hugo Larochelle, Pascal Vincent, Gerald Tesauro, and Yoshua Ben-", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 421, + 428, + 434 + ], + "spans": [ + { + "bbox": [ + 115, + 421, + 428, + 434 + ], + "score": 1.0, + "content": "gio. Hierarchical memory networks. arXiv preprint arXiv:1605.07427, 2016.", + "type": "text" + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 452 + ], + "score": 1.0, + "content": "Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Fethi Bougares, Holger Schwenk, and", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 449, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 115, + 449, + 505, + 464 + ], + "score": 1.0, + "content": "Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical ma-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 460, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 114, + 460, + 505, + 475 + ], + "score": 1.0, + "content": "chine translation. CoRR, abs/1406.1078, 2014. URL http://arxiv.org/abs/1406.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 473, + 146, + 484 + ], + "spans": [ + { + "bbox": [ + 115, + 473, + 146, + 484 + ], + "score": 1.0, + "content": "1078.", + "type": "text" + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 489, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 104, + 489, + 505, + 505 + ], + "score": 1.0, + "content": "Li Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE Trans.", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 501, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 115, + 501, + 505, + 514 + ], + "score": 1.0, + "content": "Pattern Anal. Mach. Intell., 28(4):594–611, April 2006. ISSN 0162-8828. doi: 10.1109/TPAMI.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 116, + 513, + 416, + 525 + ], + "spans": [ + { + "bbox": [ + 116, + 513, + 416, + 525 + ], + "score": 1.0, + "content": "2006.79. URL http://dx.doi.org/10.1109/TPAMI.2006.79.", + "type": "text" + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 530, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 545 + ], + "score": 1.0, + "content": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401,", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 541, + 349, + 555 + ], + "spans": [ + { + "bbox": [ + 115, + 541, + 349, + 555 + ], + "score": 1.0, + "content": "2014. URL http://arxiv.org/abs/1410.5401.", + "type": "text" + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 559, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 505, + 574 + ], + "score": 1.0, + "content": "C¸ aglar Gulc¸ehre, Sarath Chandar, Kyunghyun Cho, and Yoshua Bengio. Dynamic neural turing ¨", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 571, + 434, + 584 + ], + "spans": [ + { + "bbox": [ + 115, + 571, + 434, + 584 + ], + "score": 1.0, + "content": "machine with soft and hard addressing schemes. CoRR, abs/1607.00036, 2016.", + "type": "text" + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 587, + 506, + 604 + ], + "spans": [ + { + "bbox": [ + 103, + 587, + 506, + 604 + ], + "score": 1.0, + "content": "Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 599, + 462, + 614 + ], + "spans": [ + { + "bbox": [ + 114, + 599, + 462, + 614 + ], + "score": 1.0, + "content": "children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015.", + "type": "text" + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 617, + 505, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 632 + ], + "score": 1.0, + "content": "Geoffrey Hinton, Li Deng, Dong Yu, George Dahl, Abdelrahman Mohamed, Navdeep Jaitly, An-", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 628, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 114, + 628, + 505, + 644 + ], + "score": 1.0, + "content": "drew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara Sainath, and Brian Kingsbury. Deep", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 114, + 640, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 114, + 640, + 505, + 654 + ], + "score": 1.0, + "content": "neural networks for acoustic modeling in speech recognition: The shared views of four research", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 651, + 372, + 665 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 372, + 665 + ], + "score": 1.0, + "content": "groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 669, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 505, + 684 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 680, + 191, + 693 + ], + "spans": [ + { + "bbox": [ + 116, + 680, + 191, + 693 + ], + "score": 1.0, + "content": "1735–1780, 1997.", + "type": "text" + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "Piotr Indyk and Rajeev Motwani. Approximate nearest neighbors: towards removing the curse of", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 708, + 505, + 724 + ], + "spans": [ + { + "bbox": [ + 114, + 708, + 505, + 724 + ], + "score": 1.0, + "content": "dimensionality. In Proceedings of the thirtieth annual ACM symposium on Theory of computing,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 115, + 721, + 223, + 732 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 223, + 732 + ], + "score": 1.0, + "content": "pp. 604–613. ACM, 1998.", + "type": "text" + } + ], + "index": 47, + "is_list_end_line": true + } + ], + "index": 31, + "bbox_fs": [ + 103, + 289, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 104, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 104, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Łukasz Kaiser and Samy Bengio. Can active memory replace attention? In Advances in Neural", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 93, + 307, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 93, + 307, + 106 + ], + "score": 1.0, + "content": "Information Processing Systems, (NIPS), 2016.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 112, + 504, + 136 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 117, + 124, + 412, + 135 + ], + "spans": [ + { + "bbox": [ + 117, + 124, + 412, + 135 + ], + "score": 1.0, + "content": "abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 142, + 504, + 165 + ], + "lines": [ + { + "bbox": [ + 106, + 142, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 142, + 506, + 155 + ], + "score": 1.0, + "content": "Gregory Koch. Siamese neural networks for one-shot image recognition. PhD thesis, University of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 153, + 178, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 153, + 178, + 165 + ], + "score": 1.0, + "content": "Toronto, 2015.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 106, + 171, + 504, + 195 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 504, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 504, + 185 + ], + "score": 1.0, + "content": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. Imagenet classification with deep convolu-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 183, + 457, + 196 + ], + "spans": [ + { + "bbox": [ + 116, + 183, + 457, + 196 + ], + "score": 1.0, + "content": "tional neural network. In Advances in Neural Information Processing Systems, 2012.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 201, + 505, + 225 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 216 + ], + "score": 1.0, + "content": "Brenden M Lake, Ruslan Salakhutdinov, Jason Gross, and Joshua B Tenenbaum. One shot learning", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 213, + 249, + 225 + ], + "spans": [ + { + "bbox": [ + 115, + 213, + 249, + 225 + ], + "score": 1.0, + "content": "of simple visual concepts. 2011.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 504, + 255 + ], + "lines": [ + { + "bbox": [ + 105, + 231, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 245 + ], + "score": 1.0, + "content": "Manjunath Kudlur Oriol Vinyals, Samy Bengio. Order matters: Sequence to sequence for sets. In", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 243, + 400, + 255 + ], + "spans": [ + { + "bbox": [ + 115, + 243, + 400, + 255 + ], + "score": 1.0, + "content": "International Conference on Learning Representations (ICLR), 2016a.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 261, + 504, + 285 + ], + "lines": [ + { + "bbox": [ + 105, + 260, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 506, + 275 + ], + "score": 1.0, + "content": "Timothy Lillicrap Koray Kavukcuoglu Daan Wierstra Oriol Vinyals, Charles Blundell. Matching", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 273, + 371, + 285 + ], + "spans": [ + { + "bbox": [ + 115, + 273, + 371, + 285 + ], + "score": 1.0, + "content": "networks for one shot learning. CoRR, abs/1606.04080, 2016b.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 108, + 291, + 503, + 325 + ], + "lines": [ + { + "bbox": [ + 105, + 291, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 505, + 304 + ], + "score": 1.0, + "content": "Jack W Rae, Jonathan J Hunt, Tim Harley, Ivo Danihelka, Andrew Senior, Greg Wayne, Alex", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Graves, and Timothy P Lillicrap. Scaling memory-augmented neural networks with sparse reads", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 314, + 445, + 326 + ], + "spans": [ + { + "bbox": [ + 116, + 314, + 445, + 326 + ], + "score": 1.0, + "content": "and writes. In Advances in Neural Information Processing Systems, (NIPS), 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 105, + 332, + 503, + 355 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 505, + 345 + ], + "score": 1.0, + "content": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. One-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 344, + 465, + 356 + ], + "spans": [ + { + "bbox": [ + 115, + 344, + 465, + 356 + ], + "score": 1.0, + "content": "shot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 362, + 502, + 385 + ], + "lines": [ + { + "bbox": [ + 106, + 362, + 504, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 504, + 375 + ], + "score": 1.0, + "content": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 373, + 347, + 385 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 347, + 385 + ], + "score": 1.0, + "content": "recognition and clustering. In CVPR, pp. 815–823, 2015.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 392, + 502, + 415 + ], + "lines": [ + { + "bbox": [ + 105, + 391, + 504, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 504, + 406 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. Weakly supervised memory", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 403, + 495, + 416 + ], + "spans": [ + { + "bbox": [ + 116, + 403, + 495, + 416 + ], + "score": 1.0, + "content": "networks. CoRR, abs/1503.08895, 2015. URL http://arxiv.org/abs/1503.08895.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 502, + 445 + ], + "lines": [ + { + "bbox": [ + 106, + 423, + 504, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 504, + 434 + ], + "score": 1.0, + "content": "Ilya Sutskever, Oriol Vinyals, and Quoc VV Le. Sequence to sequence learning with neural net-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 433, + 461, + 446 + ], + "spans": [ + { + "bbox": [ + 116, + 433, + 461, + 446 + ], + "score": 1.0, + "content": "works. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 108, + 451, + 503, + 475 + ], + "lines": [ + { + "bbox": [ + 106, + 451, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 505, + 465 + ], + "score": 1.0, + "content": "Oriol Vinyals, Charles Blundell, Timothy P. Lillicrap, Koray Kavukcuoglu, and Daan Wierstra.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 462, + 407, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 407, + 475 + ], + "score": 1.0, + "content": "Matching networks for one shot learning. CoRR, abs/1606.04080, 2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 481, + 503, + 505 + ], + "lines": [ + { + "bbox": [ + 105, + 481, + 504, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 504, + 495 + ], + "score": 1.0, + "content": "Kilian Q Weinberger and Lawrence K Saul. Distance metric learning for large margin nearest neigh-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 492, + 450, + 505 + ], + "spans": [ + { + "bbox": [ + 116, + 492, + 450, + 505 + ], + "score": 1.0, + "content": "bor classification. Journal of Machine Learning Research, 10(Feb):207–244, 2009.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 504, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 525 + ], + "score": 1.0, + "content": "Jason Weston, Samy Bengio, and Nicolas Usunier. Wsabie: Scaling up to large vocabulary image", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 115, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "annotation. In Proceedings of the International Joint Conference on Artificial Intelligence, IJCAI,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 533, + 144, + 546 + ], + "spans": [ + { + "bbox": [ + 115, + 533, + 144, + 546 + ], + "score": 1.0, + "content": "2011.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 503, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. CoRR, abs/1410.3916, 2014.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 117, + 564, + 323, + 575 + ], + "spans": [ + { + "bbox": [ + 117, + 564, + 323, + 575 + ], + "score": 1.0, + "content": "URL http://arxiv.org/abs/1410.3916.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 596 + ], + "score": 1.0, + "content": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 593, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 115, + 593, + 505, + 606 + ], + "score": 1.0, + "content": "Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin John-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 603, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 114, + 603, + 506, + 618 + ], + "score": 1.0, + "content": "son, Xiaobing Liu, Łukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 116, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 627, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 116, + 627, + 505, + 638 + ], + "score": 1.0, + "content": "Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 115, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "machine translation system: Bridging the gap between human and machine translation. CoRR,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 648, + 424, + 661 + ], + "spans": [ + { + "bbox": [ + 115, + 648, + 424, + 661 + ], + "score": 1.0, + "content": "abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 108, + 667, + 504, + 701 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "score": 1.0, + "content": "Kelvin Xu, Jimmy Lei Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 115, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 117, + 689, + 268, + 700 + ], + "spans": [ + { + "bbox": [ + 117, + 689, + 268, + 700 + ], + "score": 1.0, + "content": "with visual attention. In ICML, 2015.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 106, + 708, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "Wojciech Zaremba and Ilya Sutskever. Reinforcement learning neural turing machines. CoRR,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 718, + 425, + 731 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 425, + 731 + ], + "score": 1.0, + "content": "abs/1505.00521, 2015. URL http://arxiv.org/abs/1505.00521.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 293, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 294, + 38 + ], + "score": 1.0, + "content": "Published as a conference paper at ICLR 2017", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 104, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 104, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Łukasz Kaiser and Samy Bengio. Can active memory replace attention? In Advances in Neural", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 93, + 307, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 93, + 307, + 106 + ], + "score": 1.0, + "content": "Information Processing Systems, (NIPS), 2016.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 104, + 81, + 505, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 112, + 504, + 136 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 505, + 125 + ], + "score": 1.0, + "content": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 117, + 124, + 412, + 135 + ], + "spans": [ + { + "bbox": [ + 117, + 124, + 412, + 135 + ], + "score": 1.0, + "content": "abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 106, + 112, + 505, + 135 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 142, + 504, + 165 + ], + "lines": [ + { + "bbox": [ + 106, + 142, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 142, + 506, + 155 + ], + "score": 1.0, + "content": "Gregory Koch. Siamese neural networks for one-shot image recognition. PhD thesis, University of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 153, + 178, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 153, + 178, + 165 + ], + "score": 1.0, + "content": "Toronto, 2015.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 106, + 142, + 506, + 165 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 171, + 504, + 195 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 504, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 504, + 185 + ], + "score": 1.0, + "content": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. Imagenet classification with deep convolu-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 183, + 457, + 196 + ], + "spans": [ + { + "bbox": [ + 116, + 183, + 457, + 196 + ], + "score": 1.0, + "content": "tional neural network. In Advances in Neural Information Processing Systems, 2012.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 106, + 171, + 504, + 196 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 201, + 505, + 225 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 505, + 216 + ], + "score": 1.0, + "content": "Brenden M Lake, Ruslan Salakhutdinov, Jason Gross, and Joshua B Tenenbaum. One shot learning", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 213, + 249, + 225 + ], + "spans": [ + { + "bbox": [ + 115, + 213, + 249, + 225 + ], + "score": 1.0, + "content": "of simple visual concepts. 2011.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 199, + 505, + 225 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 504, + 255 + ], + "lines": [ + { + "bbox": [ + 105, + 231, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 245 + ], + "score": 1.0, + "content": "Manjunath Kudlur Oriol Vinyals, Samy Bengio. Order matters: Sequence to sequence for sets. In", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 243, + 400, + 255 + ], + "spans": [ + { + "bbox": [ + 115, + 243, + 400, + 255 + ], + "score": 1.0, + "content": "International Conference on Learning Representations (ICLR), 2016a.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 231, + 505, + 255 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 261, + 504, + 285 + ], + "lines": [ + { + "bbox": [ + 105, + 260, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 506, + 275 + ], + "score": 1.0, + "content": "Timothy Lillicrap Koray Kavukcuoglu Daan Wierstra Oriol Vinyals, Charles Blundell. Matching", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 273, + 371, + 285 + ], + "spans": [ + { + "bbox": [ + 115, + 273, + 371, + 285 + ], + "score": 1.0, + "content": "networks for one shot learning. CoRR, abs/1606.04080, 2016b.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 260, + 506, + 285 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 291, + 503, + 325 + ], + "lines": [ + { + "bbox": [ + 105, + 291, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 291, + 505, + 304 + ], + "score": 1.0, + "content": "Jack W Rae, Jonathan J Hunt, Tim Harley, Ivo Danihelka, Andrew Senior, Greg Wayne, Alex", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Graves, and Timothy P Lillicrap. Scaling memory-augmented neural networks with sparse reads", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 314, + 445, + 326 + ], + "spans": [ + { + "bbox": [ + 116, + 314, + 445, + 326 + ], + "score": 1.0, + "content": "and writes. In Advances in Neural Information Processing Systems, (NIPS), 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 291, + 505, + 326 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 332, + 503, + 355 + ], + "lines": [ + { + "bbox": [ + 106, + 333, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 106, + 333, + 505, + 345 + ], + "score": 1.0, + "content": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. One-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 344, + 465, + 356 + ], + "spans": [ + { + "bbox": [ + 115, + 344, + 465, + 356 + ], + "score": 1.0, + "content": "shot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 106, + 333, + 505, + 356 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 362, + 502, + 385 + ], + "lines": [ + { + "bbox": [ + 106, + 362, + 504, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 504, + 375 + ], + "score": 1.0, + "content": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 373, + 347, + 385 + ], + "spans": [ + { + "bbox": [ + 116, + 373, + 347, + 385 + ], + "score": 1.0, + "content": "recognition and clustering. In CVPR, pp. 815–823, 2015.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 106, + 362, + 504, + 385 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 392, + 502, + 415 + ], + "lines": [ + { + "bbox": [ + 105, + 391, + 504, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 504, + 406 + ], + "score": 1.0, + "content": "Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. Weakly supervised memory", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 403, + 495, + 416 + ], + "spans": [ + { + "bbox": [ + 116, + 403, + 495, + 416 + ], + "score": 1.0, + "content": "networks. CoRR, abs/1503.08895, 2015. URL http://arxiv.org/abs/1503.08895.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 391, + 504, + 416 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 502, + 445 + ], + "lines": [ + { + "bbox": [ + 106, + 423, + 504, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 504, + 434 + ], + "score": 1.0, + "content": "Ilya Sutskever, Oriol Vinyals, and Quoc VV Le. Sequence to sequence learning with neural net-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 433, + 461, + 446 + ], + "spans": [ + { + "bbox": [ + 116, + 433, + 461, + 446 + ], + "score": 1.0, + "content": "works. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23.5, + "bbox_fs": [ + 106, + 423, + 504, + 446 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 451, + 503, + 475 + ], + "lines": [ + { + "bbox": [ + 106, + 451, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 505, + 465 + ], + "score": 1.0, + "content": "Oriol Vinyals, Charles Blundell, Timothy P. Lillicrap, Koray Kavukcuoglu, and Daan Wierstra.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 462, + 407, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 407, + 475 + ], + "score": 1.0, + "content": "Matching networks for one shot learning. CoRR, abs/1606.04080, 2016.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 106, + 451, + 505, + 475 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 481, + 503, + 505 + ], + "lines": [ + { + "bbox": [ + 105, + 481, + 504, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 504, + 495 + ], + "score": 1.0, + "content": "Kilian Q Weinberger and Lawrence K Saul. Distance metric learning for large margin nearest neigh-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 492, + 450, + 505 + ], + "spans": [ + { + "bbox": [ + 116, + 492, + 450, + 505 + ], + "score": 1.0, + "content": "bor classification. Journal of Machine Learning Research, 10(Feb):207–244, 2009.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 481, + 504, + 505 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 504, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 525 + ], + "score": 1.0, + "content": "Jason Weston, Samy Bengio, and Nicolas Usunier. Wsabie: Scaling up to large vocabulary image", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 115, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "annotation. In Proceedings of the International Joint Conference on Artificial Intelligence, IJCAI,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 533, + 144, + 546 + ], + "spans": [ + { + "bbox": [ + 115, + 533, + 144, + 546 + ], + "score": 1.0, + "content": "2011.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 510, + 505, + 546 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 503, + 575 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. CoRR, abs/1410.3916, 2014.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 117, + 564, + 323, + 575 + ], + "spans": [ + { + "bbox": [ + 117, + 564, + 323, + 575 + ], + "score": 1.0, + "content": "URL http://arxiv.org/abs/1410.3916.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 552, + 505, + 575 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 581, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 581, + 505, + 596 + ], + "score": 1.0, + "content": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 593, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 115, + 593, + 505, + 606 + ], + "score": 1.0, + "content": "Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin John-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 603, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 114, + 603, + 506, + 618 + ], + "score": 1.0, + "content": "son, Xiaobing Liu, Łukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 116, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 627, + 505, + 638 + ], + "spans": [ + { + "bbox": [ + 116, + 627, + 505, + 638 + ], + "score": 1.0, + "content": "Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 115, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "machine translation system: Bridging the gap between human and machine translation. CoRR,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 648, + 424, + 661 + ], + "spans": [ + { + "bbox": [ + 115, + 648, + 424, + 661 + ], + "score": 1.0, + "content": "abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37, + "bbox_fs": [ + 106, + 581, + 506, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 667, + 504, + 701 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 680 + ], + "score": 1.0, + "content": "Kelvin Xu, Jimmy Lei Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 115, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 117, + 689, + 268, + 700 + ], + "spans": [ + { + "bbox": [ + 117, + 689, + 268, + 700 + ], + "score": 1.0, + "content": "with visual attention. In ICML, 2015.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 666, + 505, + 700 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 708, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "Wojciech Zaremba and Ilya Sutskever. Reinforcement learning neural turing machines. CoRR,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 718, + 425, + 731 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 425, + 731 + ], + "score": 1.0, + "content": "abs/1505.00521, 2015. URL http://arxiv.org/abs/1505.00521.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 106, + 708, + 505, + 731 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file