diff --git "a/parse/train/SkhU2fcll/SkhU2fcll_middle.json" "b/parse/train/SkhU2fcll/SkhU2fcll_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/SkhU2fcll/SkhU2fcll_middle.json" @@ -0,0 +1,34196 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 471, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 473, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 473, + 96 + ], + "score": 1.0, + "content": "DEEP MULTI-TASK REPRESENTATION LEARNING:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 396, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 396, + 117 + ], + "score": 1.0, + "content": "A TENSOR FACTORISATION APPROACH", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 135, + 345, + 168 + ], + "lines": [ + { + "bbox": [ + 113, + 134, + 280, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 134, + 280, + 147 + ], + "score": 1.0, + "content": "Yongxin Yang, Timothy M. Hospedales", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 113, + 146, + 255, + 158 + ], + "spans": [ + { + "bbox": [ + 113, + 146, + 255, + 158 + ], + "score": 1.0, + "content": "Queen Mary, University of London", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 113, + 157, + 345, + 170 + ], + "spans": [ + { + "bbox": [ + 113, + 157, + 345, + 170 + ], + "score": 1.0, + "content": "{yongxin.yang, t.hospedales}@qmul.ac.uk", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 278, + 197, + 333, + 209 + ], + "lines": [ + { + "bbox": [ + 276, + 197, + 335, + 210 + ], + "spans": [ + { + "bbox": [ + 276, + 197, + 335, + 210 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 223, + 468, + 343 + ], + "lines": [ + { + "bbox": [ + 141, + 223, + 469, + 234 + ], + "spans": [ + { + "bbox": [ + 141, + 223, + 469, + 234 + ], + "score": 1.0, + "content": "Most contemporary multi-task learning methods assume linear models. This set-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 233, + 470, + 246 + ], + "spans": [ + { + "bbox": [ + 141, + 233, + 470, + 246 + ], + "score": 1.0, + "content": "ting is considered shallow in the era of deep learning. In this paper, we present", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 245, + 469, + 256 + ], + "spans": [ + { + "bbox": [ + 141, + 245, + 469, + 256 + ], + "score": 1.0, + "content": "a new deep multi-task representation learning framework that learns cross-task", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 255, + 470, + 269 + ], + "spans": [ + { + "bbox": [ + 141, + 255, + 470, + 269 + ], + "score": 1.0, + "content": "sharing structure at every layer in a deep network. Our approach is based on", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 266, + 469, + 279 + ], + "spans": [ + { + "bbox": [ + 141, + 266, + 469, + 279 + ], + "score": 1.0, + "content": "generalising the matrix factorisation techniques explicitly or implicitly used by", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 278, + 469, + 290 + ], + "spans": [ + { + "bbox": [ + 141, + 278, + 469, + 290 + ], + "score": 1.0, + "content": "many conventional MTL algorithms to tensor factorisation, to realise automatic", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 288, + 470, + 301 + ], + "spans": [ + { + "bbox": [ + 141, + 288, + 470, + 301 + ], + "score": 1.0, + "content": "learning of end-to-end knowledge sharing in deep networks. This is in contrast", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "spans": [ + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "score": 1.0, + "content": "to existing deep learning approaches that need a user-defined multi-task sharing", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 310, + 469, + 322 + ], + "spans": [ + { + "bbox": [ + 141, + 310, + 469, + 322 + ], + "score": 1.0, + "content": "strategy. Our approach applies to both homogeneous and heterogeneous MTL.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 321, + 469, + 334 + ], + "spans": [ + { + "bbox": [ + 141, + 321, + 469, + 334 + ], + "score": 1.0, + "content": "Experiments demonstrate the efficacy of our deep multi-task representation learn-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 333, + 394, + 345 + ], + "spans": [ + { + "bbox": [ + 141, + 333, + 394, + 345 + ], + "score": 1.0, + "content": "ing in terms of both higher accuracy and fewer design choices.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 108, + 365, + 206, + 377 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 208, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 208, + 380 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 390, + 505, + 467 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "The paradigm of multi-task learning is to learn multiple related tasks simultaneously so that knowl-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 401, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 412 + ], + "score": 1.0, + "content": "edge obtained from each task can be re-used by the others. Early work in this area focused on neural", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "network models (Caruana, 1997), while more recent methods have shifted focus to kernel methods,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 423, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 435 + ], + "score": 1.0, + "content": "sparsity and low-dimensional task representations of linear models (Evgeniou & Pontil, 2004; Ar-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 433, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 505, + 448 + ], + "score": 1.0, + "content": "gyriou et al., 2008; Kumar & Daume III, 2012). Nevertheless given the impressive practical efficacy ´", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 445, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 457 + ], + "score": 1.0, + "content": "of contemporary deep neural networks (DNN)s in many important applications, we are motivated to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 456, + 293, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 293, + 469 + ], + "score": 1.0, + "content": "revisit MTL from a deep learning perspective.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 472, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "While the machine learning community has focused on MTL for shallow linear models recently, ap-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 484, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 496 + ], + "score": 1.0, + "content": "plications have continued to exploit neural network MTL (Zhang et al., 2014; Liu et al., 2015). The", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "score": 1.0, + "content": "typical design pattern dates back at least 20 years (Caruana, 1997): define a DNN with shared lower", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "representation layers, which then forks into separate layers and losses for each task. The sharing", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "structure is defined manually: full-sharing up to the fork, and full separation after the fork. However", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "score": 1.0, + "content": "this complicates DNN architecture design because the user must specify the sharing structure: How", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "many task specific layers? How many task independent layers? How to structure sharing if there are", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 550, + 249, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 249, + 561 + ], + "score": 1.0, + "content": "many tasks of varying relatedness?", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "score": 1.0, + "content": "In this paper we present a method for end-to-end multi-task learning in DNNs. This contribution", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 576, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 590 + ], + "score": 1.0, + "content": "can be seen as generalising shallow MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008;", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 585, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 506, + 603 + ], + "score": 1.0, + "content": "Kumar & Daume III, 2012) to learning how to share ´ at every layer of a deep network; or as learning", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 506, + 612 + ], + "score": 1.0, + "content": "the sharing structure for deep MTL (Caruana, 1997; Zhang et al., 2014; Spieckermann et al., 2014;", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 609, + 474, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 474, + 623 + ], + "score": 1.0, + "content": "Liu et al., 2015) which currently must be defined manually on a problem-by-problem basis.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 627, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "Before proceeding it is worth explicitly distinguishing some different problem settings, which have", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "all been loosely referred to as MTL in the literature. Homogeneous MTL: Each task corresponds", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "to a single output. For example, MNIST digit recognition is commonly used to evaluate MTL algo-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 104, + 659, + 506, + 673 + ], + "score": 1.0, + "content": "rithms by casting it as 10 binary classification tasks (Kumar & Daume III, 2012). ´ Heterogeneous", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "MTL: Each task corresponds to a unique set of output(s) (Zhang et al., 2014). For example, one", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "score": 1.0, + "content": "may want simultaneously predict a person’s age (task one: multi-class classification or regression)", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 693, + 438, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 438, + 707 + ], + "score": 1.0, + "content": "as well as identify their gender (task two: binary classification) from a face image.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "In this paper, we propose a multi-task learning method that works on all these settings. The key idea", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 719, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 505, + 733 + ], + "score": 1.0, + "content": "is to use tensor factorisation to divide each set of model parameters (i.e., both FC weight matrices,", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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": [ + 303, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 471, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 473, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 473, + 96 + ], + "score": 1.0, + "content": "DEEP MULTI-TASK REPRESENTATION LEARNING:", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 98, + 396, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 98, + 396, + 117 + ], + "score": 1.0, + "content": "A TENSOR FACTORISATION APPROACH", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 135, + 345, + 168 + ], + "lines": [ + { + "bbox": [ + 113, + 134, + 280, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 134, + 280, + 147 + ], + "score": 1.0, + "content": "Yongxin Yang, Timothy M. Hospedales", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 113, + 146, + 255, + 158 + ], + "spans": [ + { + "bbox": [ + 113, + 146, + 255, + 158 + ], + "score": 1.0, + "content": "Queen Mary, University of London", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 113, + 157, + 345, + 170 + ], + "spans": [ + { + "bbox": [ + 113, + 157, + 345, + 170 + ], + "score": 1.0, + "content": "{yongxin.yang, t.hospedales}@qmul.ac.uk", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 113, + 134, + 345, + 170 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 197, + 333, + 209 + ], + "lines": [ + { + "bbox": [ + 276, + 197, + 335, + 210 + ], + "spans": [ + { + "bbox": [ + 276, + 197, + 335, + 210 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 223, + 468, + 343 + ], + "lines": [ + { + "bbox": [ + 141, + 223, + 469, + 234 + ], + "spans": [ + { + "bbox": [ + 141, + 223, + 469, + 234 + ], + "score": 1.0, + "content": "Most contemporary multi-task learning methods assume linear models. This set-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 233, + 470, + 246 + ], + "spans": [ + { + "bbox": [ + 141, + 233, + 470, + 246 + ], + "score": 1.0, + "content": "ting is considered shallow in the era of deep learning. In this paper, we present", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 245, + 469, + 256 + ], + "spans": [ + { + "bbox": [ + 141, + 245, + 469, + 256 + ], + "score": 1.0, + "content": "a new deep multi-task representation learning framework that learns cross-task", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 255, + 470, + 269 + ], + "spans": [ + { + "bbox": [ + 141, + 255, + 470, + 269 + ], + "score": 1.0, + "content": "sharing structure at every layer in a deep network. Our approach is based on", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 266, + 469, + 279 + ], + "spans": [ + { + "bbox": [ + 141, + 266, + 469, + 279 + ], + "score": 1.0, + "content": "generalising the matrix factorisation techniques explicitly or implicitly used by", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 278, + 469, + 290 + ], + "spans": [ + { + "bbox": [ + 141, + 278, + 469, + 290 + ], + "score": 1.0, + "content": "many conventional MTL algorithms to tensor factorisation, to realise automatic", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 288, + 470, + 301 + ], + "spans": [ + { + "bbox": [ + 141, + 288, + 470, + 301 + ], + "score": 1.0, + "content": "learning of end-to-end knowledge sharing in deep networks. This is in contrast", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "spans": [ + { + "bbox": [ + 141, + 299, + 469, + 312 + ], + "score": 1.0, + "content": "to existing deep learning approaches that need a user-defined multi-task sharing", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 310, + 469, + 322 + ], + "spans": [ + { + "bbox": [ + 141, + 310, + 469, + 322 + ], + "score": 1.0, + "content": "strategy. Our approach applies to both homogeneous and heterogeneous MTL.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 321, + 469, + 334 + ], + "spans": [ + { + "bbox": [ + 141, + 321, + 469, + 334 + ], + "score": 1.0, + "content": "Experiments demonstrate the efficacy of our deep multi-task representation learn-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 333, + 394, + 345 + ], + "spans": [ + { + "bbox": [ + 141, + 333, + 394, + 345 + ], + "score": 1.0, + "content": "ing in terms of both higher accuracy and fewer design choices.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 11, + "bbox_fs": [ + 141, + 223, + 470, + 345 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 365, + 206, + 377 + ], + "lines": [ + { + "bbox": [ + 105, + 363, + 208, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 208, + 380 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 390, + 505, + 467 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "The paradigm of multi-task learning is to learn multiple related tasks simultaneously so that knowl-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 401, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 505, + 412 + ], + "score": 1.0, + "content": "edge obtained from each task can be re-used by the others. Early work in this area focused on neural", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "network models (Caruana, 1997), while more recent methods have shifted focus to kernel methods,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 423, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 435 + ], + "score": 1.0, + "content": "sparsity and low-dimensional task representations of linear models (Evgeniou & Pontil, 2004; Ar-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 433, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 505, + 448 + ], + "score": 1.0, + "content": "gyriou et al., 2008; Kumar & Daume III, 2012). Nevertheless given the impressive practical efficacy ´", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 445, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 457 + ], + "score": 1.0, + "content": "of contemporary deep neural networks (DNN)s in many important applications, we are motivated to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 456, + 293, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 293, + 469 + ], + "score": 1.0, + "content": "revisit MTL from a deep learning perspective.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21, + "bbox_fs": [ + 104, + 390, + 505, + 469 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 472, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "While the machine learning community has focused on MTL for shallow linear models recently, ap-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 484, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 496 + ], + "score": 1.0, + "content": "plications have continued to exploit neural network MTL (Zhang et al., 2014; Liu et al., 2015). The", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 507 + ], + "score": 1.0, + "content": "typical design pattern dates back at least 20 years (Caruana, 1997): define a DNN with shared lower", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 104, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "representation layers, which then forks into separate layers and losses for each task. The sharing", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 505, + 529 + ], + "score": 1.0, + "content": "structure is defined manually: full-sharing up to the fork, and full separation after the fork. However", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 540 + ], + "score": 1.0, + "content": "this complicates DNN architecture design because the user must specify the sharing structure: How", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 551 + ], + "score": 1.0, + "content": "many task specific layers? How many task independent layers? How to structure sharing if there are", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 550, + 249, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 249, + 561 + ], + "score": 1.0, + "content": "many tasks of varying relatedness?", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28.5, + "bbox_fs": [ + 104, + 471, + 506, + 561 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 578 + ], + "score": 1.0, + "content": "In this paper we present a method for end-to-end multi-task learning in DNNs. This contribution", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 576, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 505, + 590 + ], + "score": 1.0, + "content": "can be seen as generalising shallow MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008;", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 585, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 506, + 603 + ], + "score": 1.0, + "content": "Kumar & Daume III, 2012) to learning how to share ´ at every layer of a deep network; or as learning", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 506, + 612 + ], + "score": 1.0, + "content": "the sharing structure for deep MTL (Caruana, 1997; Zhang et al., 2014; Spieckermann et al., 2014;", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 609, + 474, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 474, + 623 + ], + "score": 1.0, + "content": "Liu et al., 2015) which currently must be defined manually on a problem-by-problem basis.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 567, + 506, + 623 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 627, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "Before proceeding it is worth explicitly distinguishing some different problem settings, which have", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "all been loosely referred to as MTL in the literature. Homogeneous MTL: Each task corresponds", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "to a single output. For example, MNIST digit recognition is commonly used to evaluate MTL algo-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 104, + 659, + 506, + 673 + ], + "score": 1.0, + "content": "rithms by casting it as 10 binary classification tasks (Kumar & Daume III, 2012). ´ Heterogeneous", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "MTL: Each task corresponds to a unique set of output(s) (Zhang et al., 2014). For example, one", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 505, + 694 + ], + "score": 1.0, + "content": "may want simultaneously predict a person’s age (task one: multi-class classification or regression)", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 693, + 438, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 438, + 707 + ], + "score": 1.0, + "content": "as well as identify their gender (task two: binary classification) from a face image.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 41, + "bbox_fs": [ + 104, + 627, + 506, + 707 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "In this paper, we propose a multi-task learning method that works on all these settings. The key idea", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 719, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 505, + 733 + ], + "score": 1.0, + "content": "is to use tensor factorisation to divide each set of model parameters (i.e., both FC weight matrices,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "and convolutional kernel tensors) into shared and task-specific parts. It is a natural generalisation", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "score": 1.0, + "content": "of shallow MTL methods that explicitly or implicitly are based on matrix factorisation (Evgeniou &", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Daum ´ e III, 2007). As linear methods, ´", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 116, + 504, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 504, + 127 + ], + "score": 1.0, + "content": "these typically require pre-engineered features. In contrast, as a deep network, our generalisation", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "score": 1.0, + "content": "can learn directly from raw image data, determining sharing structure in a layer-wise fashion. For", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "the simplest NN architecture – no hidden layer, single output – our method reduces to matrix-based", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 504, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 504, + 161 + ], + "score": 1.0, + "content": "ones, therefore matrix-based methods including (Evgeniou & Pontil, 2004; Argyriou et al., 2008;", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 159, + 391, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 391, + 172 + ], + "score": 1.0, + "content": "Kumar & Daume III, 2012; Daum ´ e III, 2007) are special cases of ours. ´", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 709, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "and convolutional kernel tensors) into shared and task-specific parts. It is a natural generalisation", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 505, + 105 + ], + "score": 1.0, + "content": "of shallow MTL methods that explicitly or implicitly are based on matrix factorisation (Evgeniou &", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 117 + ], + "score": 1.0, + "content": "Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Daum ´ e III, 2007). As linear methods, ´", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 116, + 504, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 116, + 504, + 127 + ], + "score": 1.0, + "content": "these typically require pre-engineered features. In contrast, as a deep network, our generalisation", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 139 + ], + "score": 1.0, + "content": "can learn directly from raw image data, determining sharing structure in a layer-wise fashion. For", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "the simplest NN architecture – no hidden layer, single output – our method reduces to matrix-based", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 504, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 504, + 161 + ], + "score": 1.0, + "content": "ones, therefore matrix-based methods including (Evgeniou & Pontil, 2004; Argyriou et al., 2008;", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 159, + 391, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 391, + 172 + ], + "score": 1.0, + "content": "Kumar & Daume III, 2012; Daum ´ e III, 2007) are special cases of ours. ´", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 108, + 190, + 210, + 203 + ], + "lines": [ + { + "bbox": [ + 104, + 189, + 213, + 206 + ], + "spans": [ + { + "bbox": [ + 104, + 189, + 213, + 206 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 217, + 505, + 339 + ], + "lines": [ + { + "bbox": [ + 105, + 217, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 505, + 230 + ], + "score": 1.0, + "content": "Multi-Task Learning Most contemporary MTL algorithms assume that the input and model are", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 229, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 229, + 127, + 240 + ], + "score": 1.0, + "content": "both", + "type": "text" + }, + { + "bbox": [ + 127, + 229, + 136, + 239 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 229, + 284, + 240 + ], + "score": 1.0, + "content": "-dimensional vectors. The models of", + "type": "text" + }, + { + "bbox": [ + 285, + 229, + 293, + 239 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 229, + 423, + 240 + ], + "score": 1.0, + "content": "tasks can then be stacked into a", + "type": "text" + }, + { + "bbox": [ + 423, + 229, + 452, + 239 + ], + "score": 0.91, + "content": "D \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 229, + 505, + 240 + ], + "score": 1.0, + "content": "sized matrix", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 239, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 118, + 250 + ], + "score": 0.56, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 239, + 506, + 253 + ], + "score": 1.0, + "content": ". Despite different motivations and implementations, many matrix-based MTL methods work", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 251, + 504, + 263 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 209, + 263 + ], + "score": 1.0, + "content": "by placing constrains on", + "type": "text" + }, + { + "bbox": [ + 209, + 251, + 221, + 261 + ], + "score": 0.52, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 251, + 327, + 263 + ], + "score": 1.0, + "content": ". For example, posing an", + "type": "text" + }, + { + "bbox": [ + 327, + 251, + 343, + 263 + ], + "score": 0.9, + "content": "\\ell _ { 2 , 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 251, + 383, + 263 + ], + "score": 1.0, + "content": "norm on", + "type": "text" + }, + { + "bbox": [ + 383, + 251, + 396, + 261 + ], + "score": 0.62, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 251, + 491, + 263 + ], + "score": 1.0, + "content": "to encourage low-rank", + "type": "text" + }, + { + "bbox": [ + 492, + 251, + 504, + 261 + ], + "score": 0.65, + "content": "W", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 262, + 506, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 407, + 274 + ], + "score": 1.0, + "content": "(Argyriou et al., 2008). Similarly, (Kumar & Daume III, 2012) factorises ´", + "type": "text" + }, + { + "bbox": [ + 408, + 262, + 420, + 272 + ], + "score": 0.43, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 262, + 433, + 274 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 433, + 262, + 474, + 272 + ], + "score": 0.9, + "content": "W = L S", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 262, + 506, + 274 + ], + "score": 1.0, + "content": ", i.e., it", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 273, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 506, + 286 + ], + "score": 1.0, + "content": "assigns a lower rank as a hyper-parameter. An earlier work (Evgeniou & Pontil, 2004) proposes", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 252, + 296 + ], + "score": 1.0, + "content": "that the linear model for each task", + "type": "text" + }, + { + "bbox": [ + 252, + 285, + 257, + 294 + ], + "score": 0.69, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 284, + 333, + 296 + ], + "score": 1.0, + "content": "can be written as", + "type": "text" + }, + { + "bbox": [ + 333, + 284, + 398, + 295 + ], + "score": 0.93, + "content": "w _ { t } = \\hat { w } _ { t } + \\hat { w } _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 284, + 505, + 296 + ], + "score": 1.0, + "content": ". This is the factorisation", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 293, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 199, + 306 + ], + "score": 0.91, + "content": "L = [ \\hat { w } _ { 0 } , \\hat { w } _ { 1 } , \\dots , \\hat { w } _ { T } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 293, + 218, + 308 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 218, + 294, + 284, + 306 + ], + "score": 0.92, + "content": "{ \\cal S } = [ { \\bf 1 } _ { 1 \\times T } ; { \\bf I } _ { T } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 293, + 505, + 308 + ], + "score": 1.0, + "content": ". In fact, such matrix factorisation encompasses many", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 304, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 104, + 304, + 298, + 319 + ], + "score": 1.0, + "content": "MTL methods. E.g., (Xue et al., 2007) assumes", + "type": "text" + }, + { + "bbox": [ + 299, + 306, + 314, + 318 + ], + "score": 0.89, + "content": "S _ { \\cdot , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 304, + 390, + 319 + ], + "score": 1.0, + "content": "(the ith column of", + "type": "text" + }, + { + "bbox": [ + 390, + 306, + 398, + 316 + ], + "score": 0.76, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 304, + 506, + 319 + ], + "score": 1.0, + "content": ") is a unit vector generated", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 331, + 329 + ], + "score": 1.0, + "content": "by a Dirichlet Process and (Passos et al., 2012) models", + "type": "text" + }, + { + "bbox": [ + 331, + 317, + 343, + 327 + ], + "score": 0.74, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 316, + 505, + 329 + ], + "score": 1.0, + "content": "using linear factor analysis with Indian", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 327, + 343, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 331, + 340 + ], + "score": 1.0, + "content": "Buffet Process (Griffiths & Ghahramani, 2011) prior on", + "type": "text" + }, + { + "bbox": [ + 331, + 328, + 339, + 337 + ], + "score": 0.76, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 327, + 343, + 340 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 344, + 505, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 343, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 505, + 356 + ], + "score": 1.0, + "content": "Tensor Factorisation In deep learning, tensor factorisation has been used to exploit factorised", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "tensors’ fewer parameters than the original (e.g., 4-way convolutional kernel) tensor, and thus com-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 365, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 506, + 379 + ], + "score": 1.0, + "content": "press and/or speed up the model, e.g., (Lebedev et al., 2015; Novikov et al., 2015). For shallow linear", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "score": 1.0, + "content": "MTL, tensor factorisation has been used to address problems where tasks are described by multiple", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 388, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 506, + 401 + ], + "score": 1.0, + "content": "independent factors rather than merely indexed by a single factor (Yang & Hospedales, 2015). Here", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 398, + 504, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 121, + 413 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 122, + 400, + 131, + 409 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 398, + 400, + 413 + ], + "score": 1.0, + "content": "-dimensional linear models for all unique tasks stack into a tensor", + "type": "text" + }, + { + "bbox": [ + 401, + 400, + 412, + 410 + ], + "score": 0.81, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 398, + 447, + 413 + ], + "score": 1.0, + "content": ", of e.g.", + "type": "text" + }, + { + "bbox": [ + 447, + 399, + 504, + 411 + ], + "score": 0.92, + "content": "D \\times T _ { 1 } \\times T _ { 2 }", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "score": 1.0, + "content": "in the case of two task factors. Knowledge sharing is then achieved by imposing tensor norms on", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 420, + 506, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 119, + 432 + ], + "score": 0.73, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 420, + 506, + 434 + ], + "score": 1.0, + "content": "(Romera-paredes et al., 2013; Wimalawarne et al., 2014). Our framework factors tensors for the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 431, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 429, + 445 + ], + "score": 1.0, + "content": "different reason that for DNN models, parameters include convolutional kernels (", + "type": "text" + }, + { + "bbox": [ + 429, + 433, + 439, + 442 + ], + "score": 0.71, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 431, + 505, + 445 + ], + "score": 1.0, + "content": "-way tensors) or", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 146, + 454 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "FC layer weight matrices (2-way tensors). Stacking up these parameters for many tasks", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 454, + 488, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 145, + 466 + ], + "score": 1.0, + "content": "results in", + "type": "text" + }, + { + "bbox": [ + 145, + 454, + 230, + 465 + ], + "score": 0.92, + "content": "D _ { 1 } \\times \\cdots \\times D _ { N } \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 454, + 488, + 466 + ], + "score": 1.0, + "content": "tensors within which we share knowledge through factorisation.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 470, + 505, + 647 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "score": 1.0, + "content": "Heterogeneous MTL and DNNs Some studies consider heterogeneous MTL, where tasks may", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "score": 1.0, + "content": "have different numbers of outputs (Caruana, 1997). This differs from the previously discussed stud-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 493, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 506 + ], + "score": 1.0, + "content": "ies (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Bonilla et al., 2007; Jacob et al., 2009; Kumar", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "& Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) which implicitly as- ´", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "score": 1.0, + "content": "sume that each task has a single output. Heterogeneous MTL typically uses neural networks with", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "score": 1.0, + "content": "multiple sets of outputs and losses. E.g., Huang et al. (2013) proposes a shared-hidden-layer DNN", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "score": 1.0, + "content": "model for multilingual speech processing, where each task corresponds to an individual language.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Zhang et al. (2014) uses a DNN to find facial landmarks (regression) as well as recognise facial", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 505, + 571 + ], + "score": 1.0, + "content": "attributes (classification); while Liu et al. (2015) proposes a DNN for query classification and in-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 569, + 504, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 504, + 582 + ], + "score": 1.0, + "content": "formation retrieval (ranking for web search). A key commonality of these studies is that they all", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "score": 1.0, + "content": "require a user-defined parameter sharing strategy. A typical design pattern is to use shared layers", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "(same parameters) for lower layers of the DNN and then split (independent parameters) for the top", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 602, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 616 + ], + "score": 1.0, + "content": "layers. However, there is no systematic way to make such design choices, so researchers usually rely", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "score": 1.0, + "content": "on trial-and-error, further complicating the already somewhat dark art of DNN design. In contrast,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "our method learns where and how much to share representation parameters across the tasks, hence", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 636, + 332, + 648 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 332, + 648 + ], + "score": 1.0, + "content": "significantly reducing the space of DNN design choices.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 107, + 652, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 651, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 506, + 664 + ], + "score": 1.0, + "content": "Parametrised DNNs Our MTL approach is a parameterised DNN (Sigaud et al., 2015), in that", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 662, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 506, + 676 + ], + "score": 1.0, + "content": "DNN weights are dynamically generated given some side information – in the case of MTL, given", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 673, + 505, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 673, + 505, + 686 + ], + "score": 1.0, + "content": "the task identity. In a related example of speaker-adaptive speech recognition (Tan et al., 2016) there", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 685, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 506, + 698 + ], + "score": 1.0, + "content": "may be several clusters in the data (e.g., gender, acoustic conditions), and each speaker’s model", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 100, + 695, + 509, + 730 + ], + "spans": [ + { + "bbox": [ + 100, + 695, + 165, + 730 + ], + "score": 1.0, + "content": "could be a linweight matrix", + "type": "text" + }, + { + "bbox": [ + 187, + 695, + 238, + 730 + ], + "score": 1.0, + "content": "mbination oas a sum of", + "type": "text" + }, + { + "bbox": [ + 249, + 695, + 252, + 730 + ], + "score": 1.0, + "content": "h", + "type": "text" + }, + { + "bbox": [ + 259, + 695, + 303, + 730 + ], + "score": 1.0, + "content": "e latent taase models", + "type": "text" + }, + { + "bbox": [ + 315, + 695, + 337, + 730 + ], + "score": 1.0, + "content": "cluste, i.e.,", + "type": "text" + }, + { + "bbox": [ + 438, + 695, + 492, + 730 + ], + "score": 1.0, + "content": "each speaker . The differe", + "type": "text" + }, + { + "bbox": [ + 492, + 697, + 497, + 706 + ], + "score": 0.63, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 498, + 695, + 509, + 730 + ], + "score": 1.0, + "content": "’se", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 165, + 707, + 438, + 722 + ], + "spans": [ + { + "bbox": [ + 165, + 708, + 187, + 720 + ], + "score": 0.89, + "content": "W ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 710, + 249, + 720 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 708, + 315, + 720 + ], + "score": 0.84, + "content": "\\tilde { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 707, + 438, + 722 + ], + "score": 0.93, + "content": "\\begin{array} { r } { W ^ { ( i ) } = \\sum _ { k = 1 } ^ { K } \\lambda _ { p } ^ { ( i ) } \\tilde { W } ^ { ( p ) } } \\end{array}", + "type": "inline_equation" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 252, + 734 + ], + "score": 1.0, + "content": "between speakers/tasks comes from", + "type": "text" + }, + { + "bbox": [ + 252, + 721, + 259, + 730 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 719, + 506, + 734 + ], + "score": 1.0, + "content": "and the base models are shared. An advantage of this is that,", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 50 + } + ], + "page_idx": 1, + "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, + 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": [ + 107, + 82, + 505, + 171 + ], + "lines": [], + "index": 3.5, + "bbox_fs": [ + 105, + 83, + 505, + 172 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 190, + 210, + 203 + ], + "lines": [ + { + "bbox": [ + 104, + 189, + 213, + 206 + ], + "spans": [ + { + "bbox": [ + 104, + 189, + 213, + 206 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 217, + 505, + 339 + ], + "lines": [ + { + "bbox": [ + 105, + 217, + 505, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 505, + 230 + ], + "score": 1.0, + "content": "Multi-Task Learning Most contemporary MTL algorithms assume that the input and model are", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 229, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 229, + 127, + 240 + ], + "score": 1.0, + "content": "both", + "type": "text" + }, + { + "bbox": [ + 127, + 229, + 136, + 239 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 229, + 284, + 240 + ], + "score": 1.0, + "content": "-dimensional vectors. The models of", + "type": "text" + }, + { + "bbox": [ + 285, + 229, + 293, + 239 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 229, + 423, + 240 + ], + "score": 1.0, + "content": "tasks can then be stacked into a", + "type": "text" + }, + { + "bbox": [ + 423, + 229, + 452, + 239 + ], + "score": 0.91, + "content": "D \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 229, + 505, + 240 + ], + "score": 1.0, + "content": "sized matrix", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 239, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 118, + 250 + ], + "score": 0.56, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 239, + 506, + 253 + ], + "score": 1.0, + "content": ". Despite different motivations and implementations, many matrix-based MTL methods work", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 251, + 504, + 263 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 209, + 263 + ], + "score": 1.0, + "content": "by placing constrains on", + "type": "text" + }, + { + "bbox": [ + 209, + 251, + 221, + 261 + ], + "score": 0.52, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 251, + 327, + 263 + ], + "score": 1.0, + "content": ". For example, posing an", + "type": "text" + }, + { + "bbox": [ + 327, + 251, + 343, + 263 + ], + "score": 0.9, + "content": "\\ell _ { 2 , 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 251, + 383, + 263 + ], + "score": 1.0, + "content": "norm on", + "type": "text" + }, + { + "bbox": [ + 383, + 251, + 396, + 261 + ], + "score": 0.62, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 251, + 491, + 263 + ], + "score": 1.0, + "content": "to encourage low-rank", + "type": "text" + }, + { + "bbox": [ + 492, + 251, + 504, + 261 + ], + "score": 0.65, + "content": "W", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 262, + 506, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 407, + 274 + ], + "score": 1.0, + "content": "(Argyriou et al., 2008). Similarly, (Kumar & Daume III, 2012) factorises ´", + "type": "text" + }, + { + "bbox": [ + 408, + 262, + 420, + 272 + ], + "score": 0.43, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 262, + 433, + 274 + ], + "score": 1.0, + "content": "as", + "type": "text" + }, + { + "bbox": [ + 433, + 262, + 474, + 272 + ], + "score": 0.9, + "content": "W = L S", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 262, + 506, + 274 + ], + "score": 1.0, + "content": ", i.e., it", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 273, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 506, + 286 + ], + "score": 1.0, + "content": "assigns a lower rank as a hyper-parameter. An earlier work (Evgeniou & Pontil, 2004) proposes", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 252, + 296 + ], + "score": 1.0, + "content": "that the linear model for each task", + "type": "text" + }, + { + "bbox": [ + 252, + 285, + 257, + 294 + ], + "score": 0.69, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 284, + 333, + 296 + ], + "score": 1.0, + "content": "can be written as", + "type": "text" + }, + { + "bbox": [ + 333, + 284, + 398, + 295 + ], + "score": 0.93, + "content": "w _ { t } = \\hat { w } _ { t } + \\hat { w } _ { 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 284, + 505, + 296 + ], + "score": 1.0, + "content": ". This is the factorisation", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 293, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 199, + 306 + ], + "score": 0.91, + "content": "L = [ \\hat { w } _ { 0 } , \\hat { w } _ { 1 } , \\dots , \\hat { w } _ { T } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 293, + 218, + 308 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 218, + 294, + 284, + 306 + ], + "score": 0.92, + "content": "{ \\cal S } = [ { \\bf 1 } _ { 1 \\times T } ; { \\bf I } _ { T } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 293, + 505, + 308 + ], + "score": 1.0, + "content": ". In fact, such matrix factorisation encompasses many", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 304, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 104, + 304, + 298, + 319 + ], + "score": 1.0, + "content": "MTL methods. E.g., (Xue et al., 2007) assumes", + "type": "text" + }, + { + "bbox": [ + 299, + 306, + 314, + 318 + ], + "score": 0.89, + "content": "S _ { \\cdot , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 314, + 304, + 390, + 319 + ], + "score": 1.0, + "content": "(the ith column of", + "type": "text" + }, + { + "bbox": [ + 390, + 306, + 398, + 316 + ], + "score": 0.76, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 304, + 506, + 319 + ], + "score": 1.0, + "content": ") is a unit vector generated", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 316, + 331, + 329 + ], + "score": 1.0, + "content": "by a Dirichlet Process and (Passos et al., 2012) models", + "type": "text" + }, + { + "bbox": [ + 331, + 317, + 343, + 327 + ], + "score": 0.74, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 316, + 505, + 329 + ], + "score": 1.0, + "content": "using linear factor analysis with Indian", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 327, + 343, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 331, + 340 + ], + "score": 1.0, + "content": "Buffet Process (Griffiths & Ghahramani, 2011) prior on", + "type": "text" + }, + { + "bbox": [ + 331, + 328, + 339, + 337 + ], + "score": 0.76, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 327, + 343, + 340 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 14, + "bbox_fs": [ + 104, + 217, + 506, + 340 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 344, + 505, + 465 + ], + "lines": [ + { + "bbox": [ + 105, + 343, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 505, + 356 + ], + "score": 1.0, + "content": "Tensor Factorisation In deep learning, tensor factorisation has been used to exploit factorised", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "tensors’ fewer parameters than the original (e.g., 4-way convolutional kernel) tensor, and thus com-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 365, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 506, + 379 + ], + "score": 1.0, + "content": "press and/or speed up the model, e.g., (Lebedev et al., 2015; Novikov et al., 2015). For shallow linear", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 390 + ], + "score": 1.0, + "content": "MTL, tensor factorisation has been used to address problems where tasks are described by multiple", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 388, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 506, + 401 + ], + "score": 1.0, + "content": "independent factors rather than merely indexed by a single factor (Yang & Hospedales, 2015). Here", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 398, + 504, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 121, + 413 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 122, + 400, + 131, + 409 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 398, + 400, + 413 + ], + "score": 1.0, + "content": "-dimensional linear models for all unique tasks stack into a tensor", + "type": "text" + }, + { + "bbox": [ + 401, + 400, + 412, + 410 + ], + "score": 0.81, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 413, + 398, + 447, + 413 + ], + "score": 1.0, + "content": ", of e.g.", + "type": "text" + }, + { + "bbox": [ + 447, + 399, + 504, + 411 + ], + "score": 0.92, + "content": "D \\times T _ { 1 } \\times T _ { 2 }", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "score": 1.0, + "content": "in the case of two task factors. Knowledge sharing is then achieved by imposing tensor norms on", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 420, + 506, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 119, + 432 + ], + "score": 0.73, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 420, + 506, + 434 + ], + "score": 1.0, + "content": "(Romera-paredes et al., 2013; Wimalawarne et al., 2014). Our framework factors tensors for the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 431, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 429, + 445 + ], + "score": 1.0, + "content": "different reason that for DNN models, parameters include convolutional kernels (", + "type": "text" + }, + { + "bbox": [ + 429, + 433, + 439, + 442 + ], + "score": 0.71, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 439, + 431, + 505, + 445 + ], + "score": 1.0, + "content": "-way tensors) or", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 146, + 454 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "FC layer weight matrices (2-way tensors). Stacking up these parameters for many tasks", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 454, + 488, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 145, + 466 + ], + "score": 1.0, + "content": "results in", + "type": "text" + }, + { + "bbox": [ + 145, + 454, + 230, + 465 + ], + "score": 0.92, + "content": "D _ { 1 } \\times \\cdots \\times D _ { N } \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 454, + 488, + 466 + ], + "score": 1.0, + "content": "tensors within which we share knowledge through factorisation.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 343, + 506, + 466 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 470, + 505, + 647 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "score": 1.0, + "content": "Heterogeneous MTL and DNNs Some studies consider heterogeneous MTL, where tasks may", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 505, + 494 + ], + "score": 1.0, + "content": "have different numbers of outputs (Caruana, 1997). This differs from the previously discussed stud-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 493, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 505, + 506 + ], + "score": 1.0, + "content": "ies (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Bonilla et al., 2007; Jacob et al., 2009; Kumar", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "& Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) which implicitly as- ´", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 528 + ], + "score": 1.0, + "content": "sume that each task has a single output. Heterogeneous MTL typically uses neural networks with", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "score": 1.0, + "content": "multiple sets of outputs and losses. E.g., Huang et al. (2013) proposes a shared-hidden-layer DNN", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 551 + ], + "score": 1.0, + "content": "model for multilingual speech processing, where each task corresponds to an individual language.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Zhang et al. (2014) uses a DNN to find facial landmarks (regression) as well as recognise facial", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 505, + 571 + ], + "score": 1.0, + "content": "attributes (classification); while Liu et al. (2015) proposes a DNN for query classification and in-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 569, + 504, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 504, + 582 + ], + "score": 1.0, + "content": "formation retrieval (ranking for web search). A key commonality of these studies is that they all", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "score": 1.0, + "content": "require a user-defined parameter sharing strategy. A typical design pattern is to use shared layers", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 605 + ], + "score": 1.0, + "content": "(same parameters) for lower layers of the DNN and then split (independent parameters) for the top", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 602, + 505, + 616 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 616 + ], + "score": 1.0, + "content": "layers. However, there is no systematic way to make such design choices, so researchers usually rely", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 627 + ], + "score": 1.0, + "content": "on trial-and-error, further complicating the already somewhat dark art of DNN design. In contrast,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 637 + ], + "score": 1.0, + "content": "our method learns where and how much to share representation parameters across the tasks, hence", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 636, + 332, + 648 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 332, + 648 + ], + "score": 1.0, + "content": "significantly reducing the space of DNN design choices.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 470, + 506, + 648 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 652, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 651, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 506, + 664 + ], + "score": 1.0, + "content": "Parametrised DNNs Our MTL approach is a parameterised DNN (Sigaud et al., 2015), in that", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 662, + 506, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 662, + 506, + 676 + ], + "score": 1.0, + "content": "DNN weights are dynamically generated given some side information – in the case of MTL, given", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 673, + 505, + 686 + ], + "spans": [ + { + "bbox": [ + 105, + 673, + 505, + 686 + ], + "score": 1.0, + "content": "the task identity. In a related example of speaker-adaptive speech recognition (Tan et al., 2016) there", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 685, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 506, + 698 + ], + "score": 1.0, + "content": "may be several clusters in the data (e.g., gender, acoustic conditions), and each speaker’s model", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 100, + 695, + 509, + 730 + ], + "spans": [ + { + "bbox": [ + 100, + 695, + 165, + 730 + ], + "score": 1.0, + "content": "could be a linweight matrix", + "type": "text" + }, + { + "bbox": [ + 187, + 695, + 238, + 730 + ], + "score": 1.0, + "content": "mbination oas a sum of", + "type": "text" + }, + { + "bbox": [ + 249, + 695, + 252, + 730 + ], + "score": 1.0, + "content": "h", + "type": "text" + }, + { + "bbox": [ + 259, + 695, + 303, + 730 + ], + "score": 1.0, + "content": "e latent taase models", + "type": "text" + }, + { + "bbox": [ + 315, + 695, + 337, + 730 + ], + "score": 1.0, + "content": "cluste, i.e.,", + "type": "text" + }, + { + "bbox": [ + 438, + 695, + 492, + 730 + ], + "score": 1.0, + "content": "each speaker . The differe", + "type": "text" + }, + { + "bbox": [ + 492, + 697, + 497, + 706 + ], + "score": 0.63, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 498, + 695, + 509, + 730 + ], + "score": 1.0, + "content": "’se", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 165, + 707, + 438, + 722 + ], + "spans": [ + { + "bbox": [ + 165, + 708, + 187, + 720 + ], + "score": 0.89, + "content": "W ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 710, + 249, + 720 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 303, + 708, + 315, + 720 + ], + "score": 0.84, + "content": "\\tilde { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 707, + 438, + 722 + ], + "score": 0.93, + "content": "\\begin{array} { r } { W ^ { ( i ) } = \\sum _ { k = 1 } ^ { K } \\lambda _ { p } ^ { ( i ) } \\tilde { W } ^ { ( p ) } } \\end{array}", + "type": "inline_equation" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 252, + 734 + ], + "score": 1.0, + "content": "between speakers/tasks comes from", + "type": "text" + }, + { + "bbox": [ + 252, + 721, + 259, + 730 + ], + "score": 0.77, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 719, + 506, + 734 + ], + "score": 1.0, + "content": "and the base models are shared. An advantage of this is that,", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 81, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 306, + 94 + ], + "score": 1.0, + "content": "when new data come, one can choose to re-train", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 307, + 83, + 314, + 92 + ], + "score": 0.73, + "content": "\\lambda", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 315, + 82, + 424, + 94 + ], + "score": 1.0, + "content": "parameters only, and keep", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 425, + 81, + 437, + 93 + ], + "score": 0.8, + "content": "\\tilde { W }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 437, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "fixed. This will", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "significantly reduce the number of parameters to learn, and consequently the required training data.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "score": 1.0, + "content": "Beyond this, Yang & Hospedales (2015) show that it is possible to train another neural network to", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 160, + 129 + ], + "score": 1.0, + "content": "predict those", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 160, + 116, + 168, + 125 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 168, + 114, + 506, + 129 + ], + "score": 1.0, + "content": "values from some abstract metadata. Thus a model for an unseen task can be gener-", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "ated on-the-fly with no training instances given an abstract description of the task. The techniques", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "developed here are compatible with both these ideas of generating models with minimal or no effort.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 50, + "bbox_fs": [ + 100, + 651, + 509, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 149 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 306, + 94 + ], + "score": 1.0, + "content": "when new data come, one can choose to re-train", + "type": "text" + }, + { + "bbox": [ + 307, + 83, + 314, + 92 + ], + "score": 0.73, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 82, + 424, + 94 + ], + "score": 1.0, + "content": "parameters only, and keep", + "type": "text" + }, + { + "bbox": [ + 425, + 81, + 437, + 93 + ], + "score": 0.8, + "content": "\\tilde { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 82, + 505, + 94 + ], + "score": 1.0, + "content": "fixed. This will", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "significantly reduce the number of parameters to learn, and consequently the required training data.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 116 + ], + "score": 1.0, + "content": "Beyond this, Yang & Hospedales (2015) show that it is possible to train another neural network to", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 160, + 129 + ], + "score": 1.0, + "content": "predict those", + "type": "text" + }, + { + "bbox": [ + 160, + 116, + 168, + 125 + ], + "score": 0.75, + "content": "\\lambda", + "type": "inline_equation" + }, + { + "bbox": [ + 168, + 114, + 506, + 129 + ], + "score": 1.0, + "content": "values from some abstract metadata. Thus a model for an unseen task can be gener-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "ated on-the-fly with no training instances given an abstract description of the task. The techniques", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 150 + ], + "score": 1.0, + "content": "developed here are compatible with both these ideas of generating models with minimal or no effort.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 108, + 167, + 209, + 180 + ], + "lines": [ + { + "bbox": [ + 104, + 165, + 211, + 183 + ], + "spans": [ + { + "bbox": [ + 104, + 165, + 211, + 183 + ], + "score": 1.0, + "content": "3 METHODOLOGY", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 107, + 193, + 200, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 193, + 200, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 193, + 200, + 205 + ], + "score": 1.0, + "content": "3.1 PRELIMINARIES", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 214, + 505, + 296 + ], + "lines": [ + { + "bbox": [ + 106, + 214, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 505, + 227 + ], + "score": 1.0, + "content": "We first recap some tensor factorisation basics before explaining how to factorise DNN weight", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 225, + 504, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 306, + 239 + ], + "score": 1.0, + "content": "tensors for multi-task representation learning. An", + "type": "text" + }, + { + "bbox": [ + 307, + 226, + 317, + 236 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 225, + 365, + 239 + ], + "score": 1.0, + "content": "-way tensor", + "type": "text" + }, + { + "bbox": [ + 365, + 226, + 377, + 236 + ], + "score": 0.82, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 225, + 423, + 239 + ], + "score": 1.0, + "content": "with shape", + "type": "text" + }, + { + "bbox": [ + 424, + 226, + 504, + 237 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 } \\times \\cdot \\cdot \\cdot D _ { N }", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 237, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 104, + 237, + 129, + 254 + ], + "score": 1.0, + "content": "is an", + "type": "text" + }, + { + "bbox": [ + 129, + 239, + 140, + 249 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 237, + 263, + 254 + ], + "score": 1.0, + "content": "-dimensional array containing", + "type": "text" + }, + { + "bbox": [ + 263, + 237, + 305, + 251 + ], + "score": 0.92, + "content": "\\textstyle \\prod _ { n = 1 } ^ { N } D _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 237, + 506, + 254 + ], + "score": 1.0, + "content": "elements. Scalars, vectors, and matrices can be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 249, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 138, + 262 + ], + "score": 1.0, + "content": "seen as", + "type": "text" + }, + { + "bbox": [ + 138, + 250, + 155, + 261 + ], + "score": 0.33, + "content": "0 , 1", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 249, + 506, + 262 + ], + "score": 1.0, + "content": ", and 2-way tensors respectively, although the term tensor is usually used for 3-way or", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 174, + 273 + ], + "score": 1.0, + "content": "higher. A mode-", + "type": "text" + }, + { + "bbox": [ + 174, + 262, + 181, + 271 + ], + "score": 0.77, + "content": "\\boldsymbol { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 261, + 215, + 273 + ], + "score": 1.0, + "content": "fibre of", + "type": "text" + }, + { + "bbox": [ + 215, + 261, + 227, + 271 + ], + "score": 0.83, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 261, + 245, + 273 + ], + "score": 1.0, + "content": "is a", + "type": "text" + }, + { + "bbox": [ + 245, + 261, + 260, + 272 + ], + "score": 0.92, + "content": "D _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "-dimensional vector obtained by fixing all but the nth index.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 270, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 104, + 270, + 150, + 286 + ], + "score": 1.0, + "content": "The mode-", + "type": "text" + }, + { + "bbox": [ + 150, + 273, + 157, + 281 + ], + "score": 0.79, + "content": "\\boldsymbol { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 270, + 198, + 286 + ], + "score": 1.0, + "content": "flattening", + "type": "text" + }, + { + "bbox": [ + 198, + 272, + 219, + 284 + ], + "score": 0.92, + "content": "W _ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 270, + 231, + 286 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 232, + 272, + 244, + 282 + ], + "score": 0.84, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 270, + 324, + 286 + ], + "score": 1.0, + "content": "is the matrix of size", + "type": "text" + }, + { + "bbox": [ + 325, + 271, + 385, + 284 + ], + "score": 0.93, + "content": "\\begin{array} { r } { D _ { n } \\times \\prod _ { i = n } D _ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 270, + 506, + 286 + ], + "score": 1.0, + "content": "constructed by concatenating", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 282, + 306, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 144, + 298 + ], + "score": 1.0, + "content": "all of the", + "type": "text" + }, + { + "bbox": [ + 145, + 283, + 182, + 297 + ], + "score": 0.92, + "content": "\\Pi _ { i \\lnot n } D _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 282, + 208, + 298 + ], + "score": 1.0, + "content": "mode-", + "type": "text" + }, + { + "bbox": [ + 209, + 286, + 216, + 294 + ], + "score": 0.78, + "content": "\\mathbf { \\nabla } \\cdot n", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 282, + 306, + 298 + ], + "score": 1.0, + "content": "fibres along columns.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 300, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "score": 1.0, + "content": "The dot product of two tensors is a natural extension of matrix dot product, e.g., if we have a tensor", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 107, + 311, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 107, + 312, + 116, + 322 + ], + "score": 0.8, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 311, + 145, + 324 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 145, + 312, + 215, + 322 + ], + "score": 0.91, + "content": "M _ { 1 } \\times M _ { 2 } \\times \\cdot \\cdot \\cdot P", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 311, + 266, + 324 + ], + "score": 1.0, + "content": "and a tensor", + "type": "text" + }, + { + "bbox": [ + 266, + 312, + 274, + 321 + ], + "score": 0.82, + "content": "\\boldsymbol { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 311, + 303, + 324 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 303, + 312, + 372, + 322 + ], + "score": 0.9, + "content": "P \\times N _ { 1 } \\times N _ { 2 } \\dots", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 311, + 463, + 324 + ], + "score": 1.0, + "content": ", the tensor dot product", + "type": "text" + }, + { + "bbox": [ + 463, + 312, + 486, + 322 + ], + "score": 0.86, + "content": "\\mathcal { A } \\bullet \\mathcal { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 311, + 505, + 324 + ], + "score": 1.0, + "content": "will", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 320, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 182, + 338 + ], + "score": 1.0, + "content": "be a tensor of size", + "type": "text" + }, + { + "bbox": [ + 183, + 322, + 302, + 334 + ], + "score": 0.92, + "content": "M _ { 1 } \\times M _ { 2 } \\times \\cdots N _ { 1 } \\times N _ { 2 } \\cdot \\cdot \\cdot", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 320, + 394, + 338 + ], + "score": 1.0, + "content": "by matrix dot product", + "type": "text" + }, + { + "bbox": [ + 395, + 322, + 438, + 336 + ], + "score": 0.94, + "content": "A _ { ( - 1 ) } ^ { T } B _ { ( 1 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 320, + 506, + 338 + ], + "score": 1.0, + "content": "and reshaping1.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 333, + 504, + 353 + ], + "spans": [ + { + "bbox": [ + 104, + 333, + 411, + 353 + ], + "score": 1.0, + "content": "More generally, tensor dot product can be performed along specified axes,", + "type": "text" + }, + { + "bbox": [ + 412, + 335, + 504, + 351 + ], + "score": 0.92, + "content": "\\mathcal { A } \\bullet _ { ( i , j ) } \\mathcal { B } = A _ { ( i ) } ^ { T } B _ { ( j ) }", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 348, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 327, + 362 + ], + "score": 1.0, + "content": "and reshaping. Here the subscripts indicate the axes of", + "type": "text" + }, + { + "bbox": [ + 327, + 350, + 336, + 360 + ], + "score": 0.82, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 337, + 348, + 354, + 362 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 355, + 350, + 363, + 360 + ], + "score": 0.82, + "content": "\\boldsymbol { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 348, + 505, + 362 + ], + "score": 1.0, + "content": "at which dot product is performed.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 360, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 153, + 373 + ], + "score": 1.0, + "content": "E.g., when", + "type": "text" + }, + { + "bbox": [ + 154, + 361, + 163, + 370 + ], + "score": 0.82, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 360, + 205, + 373 + ], + "score": 1.0, + "content": "is of size", + "type": "text" + }, + { + "bbox": [ + 205, + 361, + 309, + 371 + ], + "score": 0.91, + "content": "M _ { 1 } \\times P \\times M _ { 3 } \\times \\cdot \\cdot \\cdot M _ { I }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 360, + 329, + 373 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 330, + 361, + 338, + 371 + ], + "score": 0.83, + "content": "\\boldsymbol { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 360, + 380, + 373 + ], + "score": 1.0, + "content": "is of size", + "type": "text" + }, + { + "bbox": [ + 380, + 361, + 480, + 371 + ], + "score": 0.92, + "content": "N _ { 1 } \\times N _ { 2 } \\times P \\times \\cdot \\cdot \\cdot N _ { J }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 360, + 506, + 373 + ], + "score": 1.0, + "content": ", then", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 107, + 370, + 396, + 385 + ], + "spans": [ + { + "bbox": [ + 107, + 372, + 149, + 385 + ], + "score": 0.95, + "content": "\\mathbf { \\mathcal { A } } \\bullet _ { ( 2 , 3 ) } B", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 370, + 222, + 385 + ], + "score": 1.0, + "content": "is a tensor of size", + "type": "text" + }, + { + "bbox": [ + 222, + 372, + 392, + 383 + ], + "score": 0.91, + "content": "M _ { 1 } \\times M _ { 3 } \\times \\cdots M _ { I } \\times N _ { 1 } \\times N _ { 2 } \\times \\cdots N _ { J }", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 370, + 396, + 385 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 505, + 470 + ], + "lines": [ + { + "bbox": [ + 106, + 393, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 329, + 404 + ], + "score": 1.0, + "content": "Matrix-based Knowledge Sharing Assume we have", + "type": "text" + }, + { + "bbox": [ + 329, + 393, + 338, + 402 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 393, + 491, + 404 + ], + "score": 1.0, + "content": "linear models (tasks) parametrised by", + "type": "text" + }, + { + "bbox": [ + 491, + 393, + 500, + 402 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 393, + 505, + 404 + ], + "score": 1.0, + "content": "-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 403, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 403, + 405, + 415 + ], + "score": 1.0, + "content": "dimensional weight vectors, so the collection of all models forms a size", + "type": "text" + }, + { + "bbox": [ + 405, + 404, + 435, + 414 + ], + "score": 0.91, + "content": "D \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 403, + 467, + 415 + ], + "score": 1.0, + "content": "matrix", + "type": "text" + }, + { + "bbox": [ + 467, + 404, + 479, + 413 + ], + "score": 0.78, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 403, + 505, + 415 + ], + "score": 1.0, + "content": ". One", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 414, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 489, + 426 + ], + "score": 1.0, + "content": "commonly used MTL approach (Kumar & Daume III, 2012) is to place a structure constraint on ´", + "type": "text" + }, + { + "bbox": [ + 489, + 415, + 501, + 425 + ], + "score": 0.75, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 414, + 506, + 426 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 425, + 507, + 438 + ], + "spans": [ + { + "bbox": [ + 104, + 425, + 126, + 438 + ], + "score": 1.0, + "content": "e.g.,", + "type": "text" + }, + { + "bbox": [ + 126, + 425, + 165, + 435 + ], + "score": 0.9, + "content": "W = L S", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 425, + 196, + 438 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 196, + 426, + 204, + 435 + ], + "score": 0.82, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 425, + 222, + 438 + ], + "score": 1.0, + "content": "is a", + "type": "text" + }, + { + "bbox": [ + 222, + 426, + 253, + 436 + ], + "score": 0.91, + "content": "D \\times K", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 425, + 300, + 438 + ], + "score": 1.0, + "content": "matrix and", + "type": "text" + }, + { + "bbox": [ + 300, + 426, + 308, + 435 + ], + "score": 0.83, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 425, + 326, + 438 + ], + "score": 1.0, + "content": "is a", + "type": "text" + }, + { + "bbox": [ + 326, + 426, + 356, + 436 + ], + "score": 0.9, + "content": "K \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 425, + 507, + 438 + ], + "score": 1.0, + "content": "matrix. This factorisation recovers a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 436, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 162, + 447 + ], + "score": 1.0, + "content": "shared factor", + "type": "text" + }, + { + "bbox": [ + 162, + 437, + 169, + 446 + ], + "score": 0.84, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 436, + 272, + 447 + ], + "score": 1.0, + "content": "and a task-specific factor", + "type": "text" + }, + { + "bbox": [ + 272, + 437, + 280, + 446 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 436, + 396, + 447 + ], + "score": 1.0, + "content": ". One can see the columns of", + "type": "text" + }, + { + "bbox": [ + 397, + 437, + 404, + 446 + ], + "score": 0.83, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 436, + 505, + 447 + ], + "score": 1.0, + "content": "as latent basis tasks, and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 148, + 460 + ], + "score": 1.0, + "content": "the model", + "type": "text" + }, + { + "bbox": [ + 149, + 446, + 166, + 457 + ], + "score": 0.9, + "content": "w ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 446, + 196, + 460 + ], + "score": 1.0, + "content": "for the", + "type": "text" + }, + { + "bbox": [ + 196, + 448, + 201, + 457 + ], + "score": 0.33, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "th task is the linear combination of those latent basis tasks with task-specific", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 456, + 176, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 156, + 471 + ], + "score": 1.0, + "content": "information", + "type": "text" + }, + { + "bbox": [ + 156, + 459, + 171, + 470 + ], + "score": 0.88, + "content": "S _ { \\cdot , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 456, + 176, + 471 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25 + }, + { + "type": "interline_equation", + "bbox": [ + 231, + 471, + 380, + 506 + ], + "lines": [ + { + "bbox": [ + 231, + 471, + 380, + 506 + ], + "spans": [ + { + "bbox": [ + 231, + 471, + 380, + 506 + ], + "score": 0.95, + "content": "w ^ { ( i ) } : = W _ { \\cdot , i } = L S _ { \\cdot , i } = \\sum _ { k = 1 } ^ { K } L _ { \\cdot , k } S _ { k , i }", + "type": "interline_equation", + "image_path": "5b8ee652294c847b2431b22fe1f7d9c8f40b2f901cc59791208337af60d171ef.jpg" + } + ] + } + ], + "index": 29.5, + "virtual_lines": [ + { + "bbox": [ + 231, + 471, + 380, + 488.5 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 231, + 488.5, + 380, + 506.0 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 510, + 505, + 558 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "From Single to Multiple Outputs Consider extending this matrix factorisation approach to the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 524, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 357, + 536 + ], + "score": 1.0, + "content": "case of multiple outputs. The model for each task is then a", + "type": "text" + }, + { + "bbox": [ + 357, + 524, + 398, + 536 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 524, + 448, + 536 + ], + "score": 1.0, + "content": "matrix, for", + "type": "text" + }, + { + "bbox": [ + 448, + 525, + 462, + 536 + ], + "score": 0.88, + "content": "D _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 524, + 505, + 536 + ], + "score": 1.0, + "content": "input and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 536, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 107, + 536, + 120, + 547 + ], + "score": 0.87, + "content": "D _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 121, + 536, + 402, + 548 + ], + "score": 1.0, + "content": "output dimensions. The collection of all those matrices constructs a", + "type": "text" + }, + { + "bbox": [ + 402, + 536, + 462, + 547 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 } \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 536, + 505, + 548 + ], + "score": 1.0, + "content": "tensor. A", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 547, + 302, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 302, + 559 + ], + "score": 1.0, + "content": "straightforward extension of Eq. 1 to this case is", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "interline_equation", + "bbox": [ + 241, + 565, + 370, + 600 + ], + "lines": [ + { + "bbox": [ + 241, + 565, + 370, + 600 + ], + "spans": [ + { + "bbox": [ + 241, + 565, + 370, + 600 + ], + "score": 0.95, + "content": "W ^ { ( i ) } : = \\mathcal { W } _ { \\cdot , \\cdot , i } = \\sum _ { k = 1 } ^ { K } \\mathcal { L } _ { \\cdot , \\cdot , k } S _ { k , i }", + "type": "interline_equation", + "image_path": "7fb02959fdc6351b2ebdb7bc54a4fd50a4d09a07363755bb6e60978d312fa3c9.jpg" + } + ] + } + ], + "index": 35.5, + "virtual_lines": [ + { + "bbox": [ + 241, + 565, + 370, + 582.5 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 241, + 582.5, + 370, + 600.0 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 606, + 505, + 709 + ], + "lines": [ + { + "bbox": [ + 104, + 606, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 104, + 606, + 361, + 624 + ], + "score": 1.0, + "content": "This is equivalent to imposing the same structural constraint on", + "type": "text" + }, + { + "bbox": [ + 361, + 607, + 382, + 623 + ], + "score": 0.92, + "content": "W _ { ( 3 ) } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 606, + 506, + 624 + ], + "score": 1.0, + "content": "(transposed mode-3 flattening", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 117, + 634 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 118, + 621, + 129, + 631 + ], + "score": 0.79, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "). It is important to note that this allows knowledge sharing across the tasks only. I.e., knowl-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 633, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 644 + ], + "score": 1.0, + "content": "edge sharing is only across-tasks not across dimensions within a task. However it may be that the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "score": 1.0, + "content": "knowledge learned in the mapping to one output dimension may be useful to the others within one", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 654, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 666 + ], + "score": 1.0, + "content": "task. E.g., consider recognising photos of handwritten and print digits – it may be useful to share", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 664, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 677 + ], + "score": 1.0, + "content": "across handwritten-print; as well as across different digits within each. In order to support general", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 676, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 688 + ], + "score": 1.0, + "content": "knowledge sharing across both tasks and outputs within tasks, we propose to use more general tensor", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "factorisation techniques. Unlike for matrices, there are multiple definitions of tensor factorisation,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 698, + 476, + 710 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 476, + 710 + ], + "score": 1.0, + "content": "and we use Tucker (Tucker, 1966) and Tensor Train (TT) (Oseledets, 2011) decompositions.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 721, + 339, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 720, + 340, + 733 + ], + "spans": [ + { + "bbox": [ + 119, + 720, + 340, + 733 + ], + "score": 1.0, + "content": "1We slightly abuse ‘-1’ referring to the last axis of the tensor.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 108, + 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, + 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": [ + 107, + 82, + 505, + 149 + ], + "lines": [], + "index": 2.5, + "bbox_fs": [ + 105, + 81, + 506, + 150 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 167, + 209, + 180 + ], + "lines": [ + { + "bbox": [ + 104, + 165, + 211, + 183 + ], + "spans": [ + { + "bbox": [ + 104, + 165, + 211, + 183 + ], + "score": 1.0, + "content": "3 METHODOLOGY", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 107, + 193, + 200, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 193, + 200, + 205 + ], + "spans": [ + { + "bbox": [ + 106, + 193, + 200, + 205 + ], + "score": 1.0, + "content": "3.1 PRELIMINARIES", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 214, + 505, + 296 + ], + "lines": [ + { + "bbox": [ + 106, + 214, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 214, + 505, + 227 + ], + "score": 1.0, + "content": "We first recap some tensor factorisation basics before explaining how to factorise DNN weight", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 225, + 504, + 239 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 306, + 239 + ], + "score": 1.0, + "content": "tensors for multi-task representation learning. An", + "type": "text" + }, + { + "bbox": [ + 307, + 226, + 317, + 236 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 225, + 365, + 239 + ], + "score": 1.0, + "content": "-way tensor", + "type": "text" + }, + { + "bbox": [ + 365, + 226, + 377, + 236 + ], + "score": 0.82, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 378, + 225, + 423, + 239 + ], + "score": 1.0, + "content": "with shape", + "type": "text" + }, + { + "bbox": [ + 424, + 226, + 504, + 237 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 } \\times \\cdot \\cdot \\cdot D _ { N }", + "type": "inline_equation" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 237, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 104, + 237, + 129, + 254 + ], + "score": 1.0, + "content": "is an", + "type": "text" + }, + { + "bbox": [ + 129, + 239, + 140, + 249 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 237, + 263, + 254 + ], + "score": 1.0, + "content": "-dimensional array containing", + "type": "text" + }, + { + "bbox": [ + 263, + 237, + 305, + 251 + ], + "score": 0.92, + "content": "\\textstyle \\prod _ { n = 1 } ^ { N } D _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 237, + 506, + 254 + ], + "score": 1.0, + "content": "elements. Scalars, vectors, and matrices can be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 249, + 506, + 262 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 138, + 262 + ], + "score": 1.0, + "content": "seen as", + "type": "text" + }, + { + "bbox": [ + 138, + 250, + 155, + 261 + ], + "score": 0.33, + "content": "0 , 1", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 249, + 506, + 262 + ], + "score": 1.0, + "content": ", and 2-way tensors respectively, although the term tensor is usually used for 3-way or", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 174, + 273 + ], + "score": 1.0, + "content": "higher. A mode-", + "type": "text" + }, + { + "bbox": [ + 174, + 262, + 181, + 271 + ], + "score": 0.77, + "content": "\\boldsymbol { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 261, + 215, + 273 + ], + "score": 1.0, + "content": "fibre of", + "type": "text" + }, + { + "bbox": [ + 215, + 261, + 227, + 271 + ], + "score": 0.83, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 261, + 245, + 273 + ], + "score": 1.0, + "content": "is a", + "type": "text" + }, + { + "bbox": [ + 245, + 261, + 260, + 272 + ], + "score": 0.92, + "content": "D _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "-dimensional vector obtained by fixing all but the nth index.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 104, + 270, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 104, + 270, + 150, + 286 + ], + "score": 1.0, + "content": "The mode-", + "type": "text" + }, + { + "bbox": [ + 150, + 273, + 157, + 281 + ], + "score": 0.79, + "content": "\\boldsymbol { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 270, + 198, + 286 + ], + "score": 1.0, + "content": "flattening", + "type": "text" + }, + { + "bbox": [ + 198, + 272, + 219, + 284 + ], + "score": 0.92, + "content": "W _ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 270, + 231, + 286 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 232, + 272, + 244, + 282 + ], + "score": 0.84, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 270, + 324, + 286 + ], + "score": 1.0, + "content": "is the matrix of size", + "type": "text" + }, + { + "bbox": [ + 325, + 271, + 385, + 284 + ], + "score": 0.93, + "content": "\\begin{array} { r } { D _ { n } \\times \\prod _ { i = n } D _ { i } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 270, + 506, + 286 + ], + "score": 1.0, + "content": "constructed by concatenating", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 282, + 306, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 144, + 298 + ], + "score": 1.0, + "content": "all of the", + "type": "text" + }, + { + "bbox": [ + 145, + 283, + 182, + 297 + ], + "score": 0.92, + "content": "\\Pi _ { i \\lnot n } D _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 182, + 282, + 208, + 298 + ], + "score": 1.0, + "content": "mode-", + "type": "text" + }, + { + "bbox": [ + 209, + 286, + 216, + 294 + ], + "score": 0.78, + "content": "\\mathbf { \\nabla } \\cdot n", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 282, + 306, + 298 + ], + "score": 1.0, + "content": "fibres along columns.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 11, + "bbox_fs": [ + 104, + 214, + 506, + 298 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 300, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "score": 1.0, + "content": "The dot product of two tensors is a natural extension of matrix dot product, e.g., if we have a tensor", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 107, + 311, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 107, + 312, + 116, + 322 + ], + "score": 0.8, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 116, + 311, + 145, + 324 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 145, + 312, + 215, + 322 + ], + "score": 0.91, + "content": "M _ { 1 } \\times M _ { 2 } \\times \\cdot \\cdot \\cdot P", + "type": "inline_equation" + }, + { + "bbox": [ + 215, + 311, + 266, + 324 + ], + "score": 1.0, + "content": "and a tensor", + "type": "text" + }, + { + "bbox": [ + 266, + 312, + 274, + 321 + ], + "score": 0.82, + "content": "\\boldsymbol { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 311, + 303, + 324 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 303, + 312, + 372, + 322 + ], + "score": 0.9, + "content": "P \\times N _ { 1 } \\times N _ { 2 } \\dots", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 311, + 463, + 324 + ], + "score": 1.0, + "content": ", the tensor dot product", + "type": "text" + }, + { + "bbox": [ + 463, + 312, + 486, + 322 + ], + "score": 0.86, + "content": "\\mathcal { A } \\bullet \\mathcal { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 311, + 505, + 324 + ], + "score": 1.0, + "content": "will", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 320, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 182, + 338 + ], + "score": 1.0, + "content": "be a tensor of size", + "type": "text" + }, + { + "bbox": [ + 183, + 322, + 302, + 334 + ], + "score": 0.92, + "content": "M _ { 1 } \\times M _ { 2 } \\times \\cdots N _ { 1 } \\times N _ { 2 } \\cdot \\cdot \\cdot", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 320, + 394, + 338 + ], + "score": 1.0, + "content": "by matrix dot product", + "type": "text" + }, + { + "bbox": [ + 395, + 322, + 438, + 336 + ], + "score": 0.94, + "content": "A _ { ( - 1 ) } ^ { T } B _ { ( 1 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 320, + 506, + 338 + ], + "score": 1.0, + "content": "and reshaping1.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 333, + 504, + 353 + ], + "spans": [ + { + "bbox": [ + 104, + 333, + 411, + 353 + ], + "score": 1.0, + "content": "More generally, tensor dot product can be performed along specified axes,", + "type": "text" + }, + { + "bbox": [ + 412, + 335, + 504, + 351 + ], + "score": 0.92, + "content": "\\mathcal { A } \\bullet _ { ( i , j ) } \\mathcal { B } = A _ { ( i ) } ^ { T } B _ { ( j ) }", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 348, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 327, + 362 + ], + "score": 1.0, + "content": "and reshaping. Here the subscripts indicate the axes of", + "type": "text" + }, + { + "bbox": [ + 327, + 350, + 336, + 360 + ], + "score": 0.82, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 337, + 348, + 354, + 362 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 355, + 350, + 363, + 360 + ], + "score": 0.82, + "content": "\\boldsymbol { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 348, + 505, + 362 + ], + "score": 1.0, + "content": "at which dot product is performed.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 360, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 153, + 373 + ], + "score": 1.0, + "content": "E.g., when", + "type": "text" + }, + { + "bbox": [ + 154, + 361, + 163, + 370 + ], + "score": 0.82, + "content": "\\mathcal { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 360, + 205, + 373 + ], + "score": 1.0, + "content": "is of size", + "type": "text" + }, + { + "bbox": [ + 205, + 361, + 309, + 371 + ], + "score": 0.91, + "content": "M _ { 1 } \\times P \\times M _ { 3 } \\times \\cdot \\cdot \\cdot M _ { I }", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 360, + 329, + 373 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 330, + 361, + 338, + 371 + ], + "score": 0.83, + "content": "\\boldsymbol { B }", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 360, + 380, + 373 + ], + "score": 1.0, + "content": "is of size", + "type": "text" + }, + { + "bbox": [ + 380, + 361, + 480, + 371 + ], + "score": 0.92, + "content": "N _ { 1 } \\times N _ { 2 } \\times P \\times \\cdot \\cdot \\cdot N _ { J }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 360, + 506, + 373 + ], + "score": 1.0, + "content": ", then", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 107, + 370, + 396, + 385 + ], + "spans": [ + { + "bbox": [ + 107, + 372, + 149, + 385 + ], + "score": 0.95, + "content": "\\mathbf { \\mathcal { A } } \\bullet _ { ( 2 , 3 ) } B", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 370, + 222, + 385 + ], + "score": 1.0, + "content": "is a tensor of size", + "type": "text" + }, + { + "bbox": [ + 222, + 372, + 392, + 383 + ], + "score": 0.91, + "content": "M _ { 1 } \\times M _ { 3 } \\times \\cdots M _ { I } \\times N _ { 1 } \\times N _ { 2 } \\times \\cdots N _ { J }", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 370, + 396, + 385 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18, + "bbox_fs": [ + 104, + 299, + 506, + 385 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 505, + 470 + ], + "lines": [ + { + "bbox": [ + 106, + 393, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 329, + 404 + ], + "score": 1.0, + "content": "Matrix-based Knowledge Sharing Assume we have", + "type": "text" + }, + { + "bbox": [ + 329, + 393, + 338, + 402 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 393, + 491, + 404 + ], + "score": 1.0, + "content": "linear models (tasks) parametrised by", + "type": "text" + }, + { + "bbox": [ + 491, + 393, + 500, + 402 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 393, + 505, + 404 + ], + "score": 1.0, + "content": "-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 403, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 403, + 405, + 415 + ], + "score": 1.0, + "content": "dimensional weight vectors, so the collection of all models forms a size", + "type": "text" + }, + { + "bbox": [ + 405, + 404, + 435, + 414 + ], + "score": 0.91, + "content": "D \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 403, + 467, + 415 + ], + "score": 1.0, + "content": "matrix", + "type": "text" + }, + { + "bbox": [ + 467, + 404, + 479, + 413 + ], + "score": 0.78, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 403, + 505, + 415 + ], + "score": 1.0, + "content": ". One", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 414, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 489, + 426 + ], + "score": 1.0, + "content": "commonly used MTL approach (Kumar & Daume III, 2012) is to place a structure constraint on ´", + "type": "text" + }, + { + "bbox": [ + 489, + 415, + 501, + 425 + ], + "score": 0.75, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 414, + 506, + 426 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 425, + 507, + 438 + ], + "spans": [ + { + "bbox": [ + 104, + 425, + 126, + 438 + ], + "score": 1.0, + "content": "e.g.,", + "type": "text" + }, + { + "bbox": [ + 126, + 425, + 165, + 435 + ], + "score": 0.9, + "content": "W = L S", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 425, + 196, + 438 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 196, + 426, + 204, + 435 + ], + "score": 0.82, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 425, + 222, + 438 + ], + "score": 1.0, + "content": "is a", + "type": "text" + }, + { + "bbox": [ + 222, + 426, + 253, + 436 + ], + "score": 0.91, + "content": "D \\times K", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 425, + 300, + 438 + ], + "score": 1.0, + "content": "matrix and", + "type": "text" + }, + { + "bbox": [ + 300, + 426, + 308, + 435 + ], + "score": 0.83, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 425, + 326, + 438 + ], + "score": 1.0, + "content": "is a", + "type": "text" + }, + { + "bbox": [ + 326, + 426, + 356, + 436 + ], + "score": 0.9, + "content": "K \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 425, + 507, + 438 + ], + "score": 1.0, + "content": "matrix. This factorisation recovers a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 436, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 162, + 447 + ], + "score": 1.0, + "content": "shared factor", + "type": "text" + }, + { + "bbox": [ + 162, + 437, + 169, + 446 + ], + "score": 0.84, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 436, + 272, + 447 + ], + "score": 1.0, + "content": "and a task-specific factor", + "type": "text" + }, + { + "bbox": [ + 272, + 437, + 280, + 446 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 436, + 396, + 447 + ], + "score": 1.0, + "content": ". One can see the columns of", + "type": "text" + }, + { + "bbox": [ + 397, + 437, + 404, + 446 + ], + "score": 0.83, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 436, + 505, + 447 + ], + "score": 1.0, + "content": "as latent basis tasks, and", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 446, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 148, + 460 + ], + "score": 1.0, + "content": "the model", + "type": "text" + }, + { + "bbox": [ + 149, + 446, + 166, + 457 + ], + "score": 0.9, + "content": "w ^ { ( i ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 446, + 196, + 460 + ], + "score": 1.0, + "content": "for the", + "type": "text" + }, + { + "bbox": [ + 196, + 448, + 201, + 457 + ], + "score": 0.33, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 446, + 505, + 460 + ], + "score": 1.0, + "content": "th task is the linear combination of those latent basis tasks with task-specific", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 456, + 176, + 471 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 156, + 471 + ], + "score": 1.0, + "content": "information", + "type": "text" + }, + { + "bbox": [ + 156, + 459, + 171, + 470 + ], + "score": 0.88, + "content": "S _ { \\cdot , i }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 456, + 176, + 471 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 25, + "bbox_fs": [ + 104, + 393, + 507, + 471 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 231, + 471, + 380, + 506 + ], + "lines": [ + { + "bbox": [ + 231, + 471, + 380, + 506 + ], + "spans": [ + { + "bbox": [ + 231, + 471, + 380, + 506 + ], + "score": 0.95, + "content": "w ^ { ( i ) } : = W _ { \\cdot , i } = L S _ { \\cdot , i } = \\sum _ { k = 1 } ^ { K } L _ { \\cdot , k } S _ { k , i }", + "type": "interline_equation", + "image_path": "5b8ee652294c847b2431b22fe1f7d9c8f40b2f901cc59791208337af60d171ef.jpg" + } + ] + } + ], + "index": 29.5, + "virtual_lines": [ + { + "bbox": [ + 231, + 471, + 380, + 488.5 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 231, + 488.5, + 380, + 506.0 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 510, + 505, + 558 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "From Single to Multiple Outputs Consider extending this matrix factorisation approach to the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 524, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 357, + 536 + ], + "score": 1.0, + "content": "case of multiple outputs. The model for each task is then a", + "type": "text" + }, + { + "bbox": [ + 357, + 524, + 398, + 536 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 524, + 448, + 536 + ], + "score": 1.0, + "content": "matrix, for", + "type": "text" + }, + { + "bbox": [ + 448, + 525, + 462, + 536 + ], + "score": 0.88, + "content": "D _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 524, + 505, + 536 + ], + "score": 1.0, + "content": "input and", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 536, + 505, + 548 + ], + "spans": [ + { + "bbox": [ + 107, + 536, + 120, + 547 + ], + "score": 0.87, + "content": "D _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 121, + 536, + 402, + 548 + ], + "score": 1.0, + "content": "output dimensions. The collection of all those matrices constructs a", + "type": "text" + }, + { + "bbox": [ + 402, + 536, + 462, + 547 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 } \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 462, + 536, + 505, + 548 + ], + "score": 1.0, + "content": "tensor. A", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 547, + 302, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 302, + 559 + ], + "score": 1.0, + "content": "straightforward extension of Eq. 1 to this case is", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 510, + 505, + 559 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 241, + 565, + 370, + 600 + ], + "lines": [ + { + "bbox": [ + 241, + 565, + 370, + 600 + ], + "spans": [ + { + "bbox": [ + 241, + 565, + 370, + 600 + ], + "score": 0.95, + "content": "W ^ { ( i ) } : = \\mathcal { W } _ { \\cdot , \\cdot , i } = \\sum _ { k = 1 } ^ { K } \\mathcal { L } _ { \\cdot , \\cdot , k } S _ { k , i }", + "type": "interline_equation", + "image_path": "7fb02959fdc6351b2ebdb7bc54a4fd50a4d09a07363755bb6e60978d312fa3c9.jpg" + } + ] + } + ], + "index": 35.5, + "virtual_lines": [ + { + "bbox": [ + 241, + 565, + 370, + 582.5 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 241, + 582.5, + 370, + 600.0 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 606, + 505, + 709 + ], + "lines": [ + { + "bbox": [ + 104, + 606, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 104, + 606, + 361, + 624 + ], + "score": 1.0, + "content": "This is equivalent to imposing the same structural constraint on", + "type": "text" + }, + { + "bbox": [ + 361, + 607, + 382, + 623 + ], + "score": 0.92, + "content": "W _ { ( 3 ) } ^ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 606, + 506, + 624 + ], + "score": 1.0, + "content": "(transposed mode-3 flattening", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 117, + 634 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 118, + 621, + 129, + 631 + ], + "score": 0.79, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "). It is important to note that this allows knowledge sharing across the tasks only. I.e., knowl-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 633, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 505, + 644 + ], + "score": 1.0, + "content": "edge sharing is only across-tasks not across dimensions within a task. However it may be that the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 505, + 655 + ], + "score": 1.0, + "content": "knowledge learned in the mapping to one output dimension may be useful to the others within one", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 654, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 106, + 654, + 505, + 666 + ], + "score": 1.0, + "content": "task. E.g., consider recognising photos of handwritten and print digits – it may be useful to share", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 664, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 677 + ], + "score": 1.0, + "content": "across handwritten-print; as well as across different digits within each. In order to support general", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 676, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 688 + ], + "score": 1.0, + "content": "knowledge sharing across both tasks and outputs within tasks, we propose to use more general tensor", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 505, + 699 + ], + "score": 1.0, + "content": "factorisation techniques. Unlike for matrices, there are multiple definitions of tensor factorisation,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 698, + 476, + 710 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 476, + 710 + ], + "score": 1.0, + "content": "and we use Tucker (Tucker, 1966) and Tensor Train (TT) (Oseledets, 2011) decompositions.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 41, + "bbox_fs": [ + 104, + 606, + 506, + 710 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 82, + 360, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 361, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 361, + 95 + ], + "score": 1.0, + "content": "3.2 TENSOR FACTORISATION FOR KNOWLEDGE SHARING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 105, + 505, + 141 + ], + "lines": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 249, + 119 + ], + "score": 1.0, + "content": "Tucker Decomposition Given an", + "type": "text" + }, + { + "bbox": [ + 249, + 107, + 260, + 117 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 105, + 335, + 119 + ], + "score": 1.0, + "content": "-way tensor of size", + "type": "text" + }, + { + "bbox": [ + 335, + 106, + 411, + 117 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 } \\cdot \\cdot \\cdot \\times D _ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 105, + 505, + 119 + ], + "score": 1.0, + "content": ", Tucker decomposition", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 104, + 115, + 505, + 131 + ], + "spans": [ + { + "bbox": [ + 104, + 115, + 194, + 131 + ], + "score": 1.0, + "content": "outputs a core tensor", + "type": "text" + }, + { + "bbox": [ + 194, + 118, + 202, + 128 + ], + "score": 0.81, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 115, + 233, + 131 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 234, + 118, + 315, + 129 + ], + "score": 0.92, + "content": "K _ { 1 } \\times K _ { 2 } \\cdot \\cdot \\cdot \\times K _ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 115, + 337, + 131 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 337, + 119, + 348, + 128 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 115, + 386, + 131 + ], + "score": 1.0, + "content": "matrices", + "type": "text" + }, + { + "bbox": [ + 386, + 117, + 406, + 128 + ], + "score": 0.88, + "content": "U ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 115, + 438, + 131 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 438, + 118, + 480, + 129 + ], + "score": 0.92, + "content": "D _ { n } \\times K _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 115, + 505, + 131 + ], + "score": 1.0, + "content": ", such", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 128, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 128, + 142 + ], + "score": 1.0, + "content": "that,", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "interline_equation", + "bbox": [ + 154, + 161, + 455, + 219 + ], + "lines": [ + { + "bbox": [ + 154, + 161, + 455, + 219 + ], + "spans": [ + { + "bbox": [ + 154, + 161, + 455, + 219 + ], + "score": 0.94, + "content": "\\begin{array} { r c l } { { \\mathcal { W } _ { d _ { 1 } , d _ { 2 } , \\dots , d _ { N } } } } & { { = } } & { { \\displaystyle \\sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \\sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \\cdots \\sum _ { k _ { N } = 1 } ^ { K _ { N } } S _ { k _ { 1 } , k _ { 2 } , \\dots , k _ { N } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } U _ { d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \\cdots U _ { d _ { N } , k _ { N } } ^ { ( N ) } } } \\\\ { { \\mathcal { W } } } & { { = } } & { { \\displaystyle \\mathcal { S } \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 1 ) } \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 2 ) } \\cdots \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( N ) } } } \\end{array}", + "type": "interline_equation", + "image_path": "58784d828622e9c555ebcf8d3c4b15b9dc9cd4670d87e1d8bd5899c1d2045b92.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 154, + 161, + 455, + 180.33333333333334 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 154, + 180.33333333333334, + 455, + 199.66666666666669 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 154, + 199.66666666666669, + 455, + 219.00000000000003 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 228, + 505, + 275 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "score": 1.0, + "content": "Tucker decomposition is usually implemented by an alternating least squares (ALS) method (Kolda", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "score": 1.0, + "content": "& Bader, 2009). However (Lathauwer et al., 2000) treat it as a higher-order singular value decom-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 250, + 507, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 318, + 264 + ], + "score": 1.0, + "content": "position (HOSVD), which is more efficient to solve:", + "type": "text" + }, + { + "bbox": [ + 319, + 250, + 339, + 262 + ], + "score": 0.9, + "content": "U ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 250, + 396, + 264 + ], + "score": 1.0, + "content": "is exactly the", + "type": "text" + }, + { + "bbox": [ + 396, + 252, + 405, + 262 + ], + "score": 0.81, + "content": "U", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 250, + 507, + 264 + ], + "score": 1.0, + "content": "matrix from the SVD of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 262, + 379, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 132, + 276 + ], + "score": 1.0, + "content": "mode-", + "type": "text" + }, + { + "bbox": [ + 132, + 264, + 139, + 272 + ], + "score": 0.78, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 262, + 180, + 276 + ], + "score": 1.0, + "content": "flattening", + "type": "text" + }, + { + "bbox": [ + 181, + 263, + 203, + 276 + ], + "score": 0.92, + "content": "W _ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 262, + 215, + 276 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 215, + 263, + 227, + 273 + ], + "score": 0.84, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 262, + 308, + 276 + ], + "score": 1.0, + "content": ", and the core tensor", + "type": "text" + }, + { + "bbox": [ + 309, + 263, + 317, + 272 + ], + "score": 0.85, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 262, + 379, + 276 + ], + "score": 1.0, + "content": "is obtained by,", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5 + }, + { + "type": "interline_equation", + "bbox": [ + 213, + 287, + 397, + 307 + ], + "lines": [ + { + "bbox": [ + 213, + 287, + 397, + 307 + ], + "spans": [ + { + "bbox": [ + 213, + 287, + 397, + 307 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\pmb { \\mathscr { S } } = \\mathscr { W } \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( 1 ) } \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( 2 ) } \\cdots \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( N ) } } \\end{array}", + "type": "interline_equation", + "image_path": "46c9d60fdb02c762e1783427318bb210d5aec8d640b28d1cd8d90e3ac324a4f2.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 213, + 287, + 397, + 307 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 320, + 505, + 356 + ], + "lines": [ + { + "bbox": [ + 104, + 319, + 507, + 334 + ], + "spans": [ + { + "bbox": [ + 104, + 319, + 465, + 334 + ], + "score": 1.0, + "content": "Tensor Train Decomposition Tensor Train (TT) Decomposition outputs 2 matrices", + "type": "text" + }, + { + "bbox": [ + 466, + 320, + 485, + 331 + ], + "score": 0.9, + "content": "U ^ { ( 1 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 319, + 507, + 334 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 330, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 107, + 332, + 129, + 343 + ], + "score": 0.89, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 330, + 162, + 346 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 163, + 333, + 203, + 344 + ], + "score": 0.91, + "content": "D _ { 1 } \\times K _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 330, + 223, + 346 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 223, + 333, + 280, + 344 + ], + "score": 0.91, + "content": "K _ { N - 1 } \\times D _ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 330, + 354, + 346 + ], + "score": 1.0, + "content": "respectively, and", + "type": "text" + }, + { + "bbox": [ + 354, + 333, + 390, + 345 + ], + "score": 0.88, + "content": "( N - 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 330, + 452, + 346 + ], + "score": 1.0, + "content": "3-way tensors", + "type": "text" + }, + { + "bbox": [ + 452, + 332, + 473, + 343 + ], + "score": 0.89, + "content": "\\mathcal { U } ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 330, + 505, + 346 + ], + "score": 1.0, + "content": "of size", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 343, + 353, + 357 + ], + "spans": [ + { + "bbox": [ + 107, + 344, + 184, + 356 + ], + "score": 0.91, + "content": "K _ { n - 1 } \\times D _ { n } \\times K _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 343, + 255, + 357 + ], + "score": 1.0, + "content": ". The elements of", + "type": "text" + }, + { + "bbox": [ + 255, + 345, + 267, + 354 + ], + "score": 0.83, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 343, + 353, + 357 + ], + "score": 1.0, + "content": "can be computed by,", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13 + }, + { + "type": "interline_equation", + "bbox": [ + 146, + 376, + 464, + 448 + ], + "lines": [ + { + "bbox": [ + 146, + 376, + 464, + 448 + ], + "spans": [ + { + "bbox": [ + 146, + 376, + 464, + 448 + ], + "score": 0.93, + "content": "\\begin{array} { l c l } { { \\displaystyle \\mathcal { W } _ { d _ { 1 } , d _ { 2 } , \\dots , d _ { N } } } } & { { = } } & { { \\displaystyle \\sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \\sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \\cdots \\sum _ { k _ { N - 1 } = 1 } ^ { K _ { N - 1 } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } \\mathcal { U } _ { k _ { 1 } , d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \\mathcal { U } _ { k _ { 2 } , d _ { 3 } , k _ { 3 } } ^ { ( 3 ) } \\cdots U _ { k _ { N - 1 } , d _ { N } } ^ { ( N ) } } } \\\\ { { } } & { { = } } & { { \\displaystyle U _ { d _ { 1 } , l } ^ { ( 1 ) } \\mathcal { U } _ { , d _ { 2 } , l } ^ { ( 2 ) } \\mathcal { U } _ { , d _ { 3 } , \\cdot } ^ { ( 3 ) } \\cdots U _ { \\cdot , d _ { N } } ^ { ( d ) } } } \\\\ { { \\displaystyle \\mathcal { W } } } & { { = } } & { { \\displaystyle U ^ { ( 1 ) } \\bullet \\mathcal { U } ^ { ( 2 ) } \\cdot \\cdots \\bullet U ^ { ( N ) } } } \\end{array}", + "type": "interline_equation", + "image_path": "aaad1a1718515311ee6d1f0a1eda7d952ddd0f7a518c89592faad850694e83d0.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 146, + 376, + 464, + 400.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 146, + 400.0, + 464, + 424.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 146, + 424.0, + 464, + 448.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 504, + 487 + ], + "lines": [ + { + "bbox": [ + 103, + 458, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 103, + 458, + 159, + 478 + ], + "score": 1.0, + "content": "where U (n)·,d ,·", + "type": "text" + }, + { + "bbox": [ + 156, + 459, + 234, + 479 + ], + "score": 1.0, + "content": "is a matrix of size", + "type": "text" + }, + { + "bbox": [ + 235, + 463, + 285, + 475 + ], + "score": 0.92, + "content": "K _ { n - 1 } \\times K _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 286, + 459, + 334, + 479 + ], + "score": 1.0, + "content": "sliced from", + "type": "text" + }, + { + "bbox": [ + 334, + 462, + 354, + 473 + ], + "score": 0.91, + "content": "\\mathcal { U } ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 459, + 471, + 479 + ], + "score": 1.0, + "content": "with the second axis fixed at", + "type": "text" + }, + { + "bbox": [ + 471, + 464, + 482, + 474 + ], + "score": 0.88, + "content": "d _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 459, + 506, + 479 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 474, + 486, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 486, + 487 + ], + "score": 1.0, + "content": "TT decomposition is typically realised with a recursive SVD-based solution (Oseledets, 2011).", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 505, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 446, + 504 + ], + "score": 1.0, + "content": "Knowledge Sharing If the final axis of the input tensor above indexes tasks, i.e. if", + "type": "text" + }, + { + "bbox": [ + 446, + 492, + 484, + 503 + ], + "score": 0.92, + "content": "D _ { N } = T", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 491, + 505, + 504 + ], + "score": 1.0, + "content": "then", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 502, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 165, + 517 + ], + "score": 1.0, + "content": "the last factor", + "type": "text" + }, + { + "bbox": [ + 165, + 503, + 187, + 514 + ], + "score": 0.9, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 502, + 505, + 517 + ], + "score": 1.0, + "content": "in both decompositions encodes a matrix of task specific knowledge, and the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 514, + 266, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 266, + 528 + ], + "score": 1.0, + "content": "other factors encode shared knowledge.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 107, + 541, + 341, + 552 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 342, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 342, + 554 + ], + "score": 1.0, + "content": "3.3 DEEP MULTI-TASK REPRESENTATION LEARNING", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 505, + 639 + ], + "lines": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "score": 1.0, + "content": "To realise deep multi-task representation learning (DMTRL), we learn one DNN per-task each with", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 572, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 586 + ], + "score": 1.0, + "content": "the same architecture2. However each corresponding layer’s weights are generated with one of the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 584, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 596 + ], + "score": 1.0, + "content": "knowledge sharing structures in Eq. 2, Eq. 4 or Eq. 8. It is important to note that we apply these", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 594, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 506, + 608 + ], + "score": 1.0, + "content": "‘right-to-left’ in order to generate weight tensors with the specified sharing structure, rather than", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "actually applying Tucker or TT to decompose an input tensor. In the forward pass, we synthesise", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 167, + 629 + ], + "score": 1.0, + "content": "weight tensors", + "type": "text" + }, + { + "bbox": [ + 168, + 617, + 180, + 627 + ], + "score": 0.77, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "and perform inference as usual, so the method can be thought of as tensor com-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 628, + 250, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 250, + 640 + ], + "score": 1.0, + "content": "position rather than decomposition.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 106, + 645, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 505, + 656 + ], + "score": 1.0, + "content": "Our weight generation (construct tensors from smaller pieces) does not introduce non-differentiable", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "score": 1.0, + "content": "terms, so our deep multi-task representation learner is trainable via standard backpropagation.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 666, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 679 + ], + "score": 1.0, + "content": "Specifically, in the backward pass over FC layers, rather than directly learning the 3-way tensor", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 118, + 688 + ], + "score": 0.75, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 677, + 223, + 690 + ], + "score": 1.0, + "content": ", our methods learn either", + "type": "text" + }, + { + "bbox": [ + 223, + 677, + 288, + 689 + ], + "score": 0.91, + "content": "\\{ S , U _ { 1 } , U _ { 2 } , U _ { 3 } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 677, + 393, + 690 + ], + "score": 1.0, + "content": "(DMTRL-Tucker, Eq. 4),", + "type": "text" + }, + { + "bbox": [ + 393, + 677, + 446, + 690 + ], + "score": 0.92, + "content": "\\{ U _ { 1 } , \\mathcal { U } _ { 2 } , U _ { 3 } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "(DMTRL-TT,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 686, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 104, + 686, + 233, + 704 + ], + "score": 1.0, + "content": "Eq. 8), or in the simplest case", + "type": "text" + }, + { + "bbox": [ + 233, + 689, + 262, + 700 + ], + "score": 0.9, + "content": "\\{ \\mathcal { L } , S \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 686, + 305, + 704 + ], + "score": 1.0, + "content": "(DMTRL-", + "type": "text" + }, + { + "bbox": [ + 306, + 688, + 329, + 699 + ], + "score": 0.28, + "content": "\\mathrm { . L A F ^ { 3 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 686, + 505, + 704 + ], + "score": 1.0, + "content": ", Eq. 2). Besides FC layers, contemporary", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 115, + 710, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 118, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "2Except heterogeneous MTL, where the output layer is necessarily unshared due to different dimensionality.", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 719, + 251, + 734 + ], + "spans": [ + { + "bbox": [ + 118, + 719, + 251, + 734 + ], + "score": 1.0, + "content": "3LAF refers to Last Axis Flattening.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 26, + 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, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 82, + 360, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 361, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 361, + 95 + ], + "score": 1.0, + "content": "3.2 TENSOR FACTORISATION FOR KNOWLEDGE SHARING", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 105, + 505, + 141 + ], + "lines": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 249, + 119 + ], + "score": 1.0, + "content": "Tucker Decomposition Given an", + "type": "text" + }, + { + "bbox": [ + 249, + 107, + 260, + 117 + ], + "score": 0.81, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 105, + 335, + 119 + ], + "score": 1.0, + "content": "-way tensor of size", + "type": "text" + }, + { + "bbox": [ + 335, + 106, + 411, + 117 + ], + "score": 0.91, + "content": "D _ { 1 } \\times D _ { 2 } \\cdot \\cdot \\cdot \\times D _ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 105, + 505, + 119 + ], + "score": 1.0, + "content": ", Tucker decomposition", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 104, + 115, + 505, + 131 + ], + "spans": [ + { + "bbox": [ + 104, + 115, + 194, + 131 + ], + "score": 1.0, + "content": "outputs a core tensor", + "type": "text" + }, + { + "bbox": [ + 194, + 118, + 202, + 128 + ], + "score": 0.81, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 115, + 233, + 131 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 234, + 118, + 315, + 129 + ], + "score": 0.92, + "content": "K _ { 1 } \\times K _ { 2 } \\cdot \\cdot \\cdot \\times K _ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 115, + 337, + 131 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 337, + 119, + 348, + 128 + ], + "score": 0.82, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 115, + 386, + 131 + ], + "score": 1.0, + "content": "matrices", + "type": "text" + }, + { + "bbox": [ + 386, + 117, + 406, + 128 + ], + "score": 0.88, + "content": "U ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 115, + 438, + 131 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 438, + 118, + 480, + 129 + ], + "score": 0.92, + "content": "D _ { n } \\times K _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 115, + 505, + 131 + ], + "score": 1.0, + "content": ", such", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 128, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 128, + 142 + ], + "score": 1.0, + "content": "that,", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 104, + 105, + 505, + 142 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 154, + 161, + 455, + 219 + ], + "lines": [ + { + "bbox": [ + 154, + 161, + 455, + 219 + ], + "spans": [ + { + "bbox": [ + 154, + 161, + 455, + 219 + ], + "score": 0.94, + "content": "\\begin{array} { r c l } { { \\mathcal { W } _ { d _ { 1 } , d _ { 2 } , \\dots , d _ { N } } } } & { { = } } & { { \\displaystyle \\sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \\sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \\cdots \\sum _ { k _ { N } = 1 } ^ { K _ { N } } S _ { k _ { 1 } , k _ { 2 } , \\dots , k _ { N } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } U _ { d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \\cdots U _ { d _ { N } , k _ { N } } ^ { ( N ) } } } \\\\ { { \\mathcal { W } } } & { { = } } & { { \\displaystyle \\mathcal { S } \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 1 ) } \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 2 ) } \\cdots \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( N ) } } } \\end{array}", + "type": "interline_equation", + "image_path": "58784d828622e9c555ebcf8d3c4b15b9dc9cd4670d87e1d8bd5899c1d2045b92.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 154, + 161, + 455, + 180.33333333333334 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 154, + 180.33333333333334, + 455, + 199.66666666666669 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 154, + 199.66666666666669, + 455, + 219.00000000000003 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 228, + 505, + 275 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 505, + 241 + ], + "score": 1.0, + "content": "Tucker decomposition is usually implemented by an alternating least squares (ALS) method (Kolda", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 239, + 505, + 252 + ], + "score": 1.0, + "content": "& Bader, 2009). However (Lathauwer et al., 2000) treat it as a higher-order singular value decom-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 250, + 507, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 318, + 264 + ], + "score": 1.0, + "content": "position (HOSVD), which is more efficient to solve:", + "type": "text" + }, + { + "bbox": [ + 319, + 250, + 339, + 262 + ], + "score": 0.9, + "content": "U ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 250, + 396, + 264 + ], + "score": 1.0, + "content": "is exactly the", + "type": "text" + }, + { + "bbox": [ + 396, + 252, + 405, + 262 + ], + "score": 0.81, + "content": "U", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 250, + 507, + 264 + ], + "score": 1.0, + "content": "matrix from the SVD of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 262, + 379, + 276 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 132, + 276 + ], + "score": 1.0, + "content": "mode-", + "type": "text" + }, + { + "bbox": [ + 132, + 264, + 139, + 272 + ], + "score": 0.78, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 262, + 180, + 276 + ], + "score": 1.0, + "content": "flattening", + "type": "text" + }, + { + "bbox": [ + 181, + 263, + 203, + 276 + ], + "score": 0.92, + "content": "W _ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 262, + 215, + 276 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 215, + 263, + 227, + 273 + ], + "score": 0.84, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 227, + 262, + 308, + 276 + ], + "score": 1.0, + "content": ", and the core tensor", + "type": "text" + }, + { + "bbox": [ + 309, + 263, + 317, + 272 + ], + "score": 0.85, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 262, + 379, + 276 + ], + "score": 1.0, + "content": "is obtained by,", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 228, + 507, + 276 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 213, + 287, + 397, + 307 + ], + "lines": [ + { + "bbox": [ + 213, + 287, + 397, + 307 + ], + "spans": [ + { + "bbox": [ + 213, + 287, + 397, + 307 + ], + "score": 0.91, + "content": "\\begin{array} { r } { \\pmb { \\mathscr { S } } = \\mathscr { W } \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( 1 ) } \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( 2 ) } \\cdots \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( N ) } } \\end{array}", + "type": "interline_equation", + "image_path": "46c9d60fdb02c762e1783427318bb210d5aec8d640b28d1cd8d90e3ac324a4f2.jpg" + } + ] + } + ], + "index": 11, + "virtual_lines": [ + { + "bbox": [ + 213, + 287, + 397, + 307 + ], + "spans": [], + "index": 11 + } + ] + }, + { + "type": "text", + "bbox": [ + 108, + 320, + 505, + 356 + ], + "lines": [ + { + "bbox": [ + 104, + 319, + 507, + 334 + ], + "spans": [ + { + "bbox": [ + 104, + 319, + 465, + 334 + ], + "score": 1.0, + "content": "Tensor Train Decomposition Tensor Train (TT) Decomposition outputs 2 matrices", + "type": "text" + }, + { + "bbox": [ + 466, + 320, + 485, + 331 + ], + "score": 0.9, + "content": "U ^ { ( 1 ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 319, + 507, + 334 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 330, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 107, + 332, + 129, + 343 + ], + "score": 0.89, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 330, + 162, + 346 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 163, + 333, + 203, + 344 + ], + "score": 0.91, + "content": "D _ { 1 } \\times K _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 330, + 223, + 346 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 223, + 333, + 280, + 344 + ], + "score": 0.91, + "content": "K _ { N - 1 } \\times D _ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 330, + 354, + 346 + ], + "score": 1.0, + "content": "respectively, and", + "type": "text" + }, + { + "bbox": [ + 354, + 333, + 390, + 345 + ], + "score": 0.88, + "content": "( N - 2 )", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 330, + 452, + 346 + ], + "score": 1.0, + "content": "3-way tensors", + "type": "text" + }, + { + "bbox": [ + 452, + 332, + 473, + 343 + ], + "score": 0.89, + "content": "\\mathcal { U } ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 330, + 505, + 346 + ], + "score": 1.0, + "content": "of size", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 343, + 353, + 357 + ], + "spans": [ + { + "bbox": [ + 107, + 344, + 184, + 356 + ], + "score": 0.91, + "content": "K _ { n - 1 } \\times D _ { n } \\times K _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 343, + 255, + 357 + ], + "score": 1.0, + "content": ". The elements of", + "type": "text" + }, + { + "bbox": [ + 255, + 345, + 267, + 354 + ], + "score": 0.83, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 343, + 353, + 357 + ], + "score": 1.0, + "content": "can be computed by,", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13, + "bbox_fs": [ + 104, + 319, + 507, + 357 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 146, + 376, + 464, + 448 + ], + "lines": [ + { + "bbox": [ + 146, + 376, + 464, + 448 + ], + "spans": [ + { + "bbox": [ + 146, + 376, + 464, + 448 + ], + "score": 0.93, + "content": "\\begin{array} { l c l } { { \\displaystyle \\mathcal { W } _ { d _ { 1 } , d _ { 2 } , \\dots , d _ { N } } } } & { { = } } & { { \\displaystyle \\sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \\sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \\cdots \\sum _ { k _ { N - 1 } = 1 } ^ { K _ { N - 1 } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } \\mathcal { U } _ { k _ { 1 } , d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \\mathcal { U } _ { k _ { 2 } , d _ { 3 } , k _ { 3 } } ^ { ( 3 ) } \\cdots U _ { k _ { N - 1 } , d _ { N } } ^ { ( N ) } } } \\\\ { { } } & { { = } } & { { \\displaystyle U _ { d _ { 1 } , l } ^ { ( 1 ) } \\mathcal { U } _ { , d _ { 2 } , l } ^ { ( 2 ) } \\mathcal { U } _ { , d _ { 3 } , \\cdot } ^ { ( 3 ) } \\cdots U _ { \\cdot , d _ { N } } ^ { ( d ) } } } \\\\ { { \\displaystyle \\mathcal { W } } } & { { = } } & { { \\displaystyle U ^ { ( 1 ) } \\bullet \\mathcal { U } ^ { ( 2 ) } \\cdot \\cdots \\bullet U ^ { ( N ) } } } \\end{array}", + "type": "interline_equation", + "image_path": "aaad1a1718515311ee6d1f0a1eda7d952ddd0f7a518c89592faad850694e83d0.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 146, + 376, + 464, + 400.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 146, + 400.0, + 464, + 424.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 146, + 424.0, + 464, + 448.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 504, + 487 + ], + "lines": [ + { + "bbox": [ + 103, + 458, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 103, + 458, + 159, + 478 + ], + "score": 1.0, + "content": "where U (n)·,d ,·", + "type": "text" + }, + { + "bbox": [ + 156, + 459, + 234, + 479 + ], + "score": 1.0, + "content": "is a matrix of size", + "type": "text" + }, + { + "bbox": [ + 235, + 463, + 285, + 475 + ], + "score": 0.92, + "content": "K _ { n - 1 } \\times K _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 286, + 459, + 334, + 479 + ], + "score": 1.0, + "content": "sliced from", + "type": "text" + }, + { + "bbox": [ + 334, + 462, + 354, + 473 + ], + "score": 0.91, + "content": "\\mathcal { U } ^ { ( n ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 459, + 471, + 479 + ], + "score": 1.0, + "content": "with the second axis fixed at", + "type": "text" + }, + { + "bbox": [ + 471, + 464, + 482, + 474 + ], + "score": 0.88, + "content": "d _ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 459, + 506, + 479 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 474, + 486, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 486, + 487 + ], + "score": 1.0, + "content": "TT decomposition is typically realised with a recursive SVD-based solution (Oseledets, 2011).", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5, + "bbox_fs": [ + 103, + 458, + 506, + 487 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 505, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 491, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 446, + 504 + ], + "score": 1.0, + "content": "Knowledge Sharing If the final axis of the input tensor above indexes tasks, i.e. if", + "type": "text" + }, + { + "bbox": [ + 446, + 492, + 484, + 503 + ], + "score": 0.92, + "content": "D _ { N } = T", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 491, + 505, + 504 + ], + "score": 1.0, + "content": "then", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 502, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 165, + 517 + ], + "score": 1.0, + "content": "the last factor", + "type": "text" + }, + { + "bbox": [ + 165, + 503, + 187, + 514 + ], + "score": 0.9, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 502, + 505, + 517 + ], + "score": 1.0, + "content": "in both decompositions encodes a matrix of task specific knowledge, and the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 514, + 266, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 266, + 528 + ], + "score": 1.0, + "content": "other factors encode shared knowledge.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 491, + 505, + 528 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 541, + 341, + 552 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 342, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 342, + 554 + ], + "score": 1.0, + "content": "3.3 DEEP MULTI-TASK REPRESENTATION LEARNING", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 505, + 639 + ], + "lines": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 106, + 562, + 505, + 574 + ], + "score": 1.0, + "content": "To realise deep multi-task representation learning (DMTRL), we learn one DNN per-task each with", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 572, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 586 + ], + "score": 1.0, + "content": "the same architecture2. However each corresponding layer’s weights are generated with one of the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 584, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 596 + ], + "score": 1.0, + "content": "knowledge sharing structures in Eq. 2, Eq. 4 or Eq. 8. It is important to note that we apply these", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 594, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 506, + 608 + ], + "score": 1.0, + "content": "‘right-to-left’ in order to generate weight tensors with the specified sharing structure, rather than", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "actually applying Tucker or TT to decompose an input tensor. In the forward pass, we synthesise", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 617, + 505, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 167, + 629 + ], + "score": 1.0, + "content": "weight tensors", + "type": "text" + }, + { + "bbox": [ + 168, + 617, + 180, + 627 + ], + "score": 0.77, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 617, + 505, + 629 + ], + "score": 1.0, + "content": "and perform inference as usual, so the method can be thought of as tensor com-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 628, + 250, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 250, + 640 + ], + "score": 1.0, + "content": "position rather than decomposition.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 562, + 506, + 640 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 106, + 645, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 505, + 656 + ], + "score": 1.0, + "content": "Our weight generation (construct tensors from smaller pieces) does not introduce non-differentiable", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 669 + ], + "score": 1.0, + "content": "terms, so our deep multi-task representation learner is trainable via standard backpropagation.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 666, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 679 + ], + "score": 1.0, + "content": "Specifically, in the backward pass over FC layers, rather than directly learning the 3-way tensor", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 118, + 688 + ], + "score": 0.75, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 677, + 223, + 690 + ], + "score": 1.0, + "content": ", our methods learn either", + "type": "text" + }, + { + "bbox": [ + 223, + 677, + 288, + 689 + ], + "score": 0.91, + "content": "\\{ S , U _ { 1 } , U _ { 2 } , U _ { 3 } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 677, + 393, + 690 + ], + "score": 1.0, + "content": "(DMTRL-Tucker, Eq. 4),", + "type": "text" + }, + { + "bbox": [ + 393, + 677, + 446, + 690 + ], + "score": 0.92, + "content": "\\{ U _ { 1 } , \\mathcal { U } _ { 2 } , U _ { 3 } \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "(DMTRL-TT,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 686, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 104, + 686, + 233, + 704 + ], + "score": 1.0, + "content": "Eq. 8), or in the simplest case", + "type": "text" + }, + { + "bbox": [ + 233, + 689, + 262, + 700 + ], + "score": 0.9, + "content": "\\{ \\mathcal { L } , S \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 686, + 305, + 704 + ], + "score": 1.0, + "content": "(DMTRL-", + "type": "text" + }, + { + "bbox": [ + 306, + 688, + 329, + 699 + ], + "score": 0.28, + "content": "\\mathrm { . L A F ^ { 3 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 686, + 505, + 704 + ], + "score": 1.0, + "content": ", Eq. 2). Besides FC layers, contemporary", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33, + "bbox_fs": [ + 104, + 645, + 505, + 704 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 128, + 81, + 483, + 305 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 128, + 81, + 483, + 305 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 128, + 81, + 483, + 305 + ], + "spans": [ + { + "bbox": [ + 128, + 81, + 483, + 305 + ], + "score": 0.979, + "type": "image", + "image_path": "bbff1fe62fcb72612a1068843c26d12df81ac25b5a13fefd9886eeb50c6f4718.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 128, + 81, + 483, + 155.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 128, + 155.66666666666669, + 483, + 230.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 128, + 230.33333333333337, + 483, + 305.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 319, + 505, + 363 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 319, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 505, + 331 + ], + "score": 1.0, + "content": "Figure 1: Illustrative example with two tasks corresponding to two neural networks in homogeneous", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "(single output) and heterogeneous (different output dimension) cases. Weight layers grouped by", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "solid rectangles are tied across networks. Weight layers grouped by dashed rectangles are softly", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 352, + 421, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 421, + 365 + ], + "score": 1.0, + "content": "shared across networks with our method. Ungrouped weights are independent.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "image_caption", + "bbox": [ + 107, + 364, + 505, + 418 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "score": 1.0, + "content": "Homogeneous MTL Shallow: Left is STL (two independent networks); right is MTL. In the case", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "of vector input and no hidden layer, our method is equivalent to conventional matrix-based MTL", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "methods. Homogeneous MTL Deep: STL (Left) is independent networks. User-defined-MTL (UD-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "score": 1.0, + "content": "MTL) selects layers to share/separate. Our DMTRL learns sharing at every layer. Heterogeneous", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 406, + 496, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 496, + 421 + ], + "score": 1.0, + "content": "MTL: UD-MTL selects layers to share/separate. DMTRL learns sharing at every shareable layer.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 440, + 505, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 440, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 453 + ], + "score": 1.0, + "content": "DNN designs often exploit convolutional layers. Those layers usually contain kernel filter parame-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 240, + 464 + ], + "score": 1.0, + "content": "ters that are 3-way tensors of size", + "type": "text" + }, + { + "bbox": [ + 241, + 452, + 290, + 462 + ], + "score": 0.9, + "content": "H \\times W \\times C", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 451, + 323, + 464 + ], + "score": 1.0, + "content": ", (where", + "type": "text" + }, + { + "bbox": [ + 323, + 452, + 333, + 461 + ], + "score": 0.82, + "content": "H", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 451, + 372, + 464 + ], + "score": 1.0, + "content": "is height,", + "type": "text" + }, + { + "bbox": [ + 373, + 452, + 385, + 462 + ], + "score": 0.57, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 451, + 439, + 464 + ], + "score": 1.0, + "content": "is width, and", + "type": "text" + }, + { + "bbox": [ + 439, + 452, + 448, + 461 + ], + "score": 0.83, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "is the number", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 276, + 475 + ], + "score": 1.0, + "content": "of input channels) or 4-way tensors of size", + "type": "text" + }, + { + "bbox": [ + 276, + 463, + 344, + 473 + ], + "score": 0.89, + "content": "H \\times W \\times C \\times M", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 462, + 374, + 475 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 375, + 463, + 386, + 472 + ], + "score": 0.77, + "content": "M", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "is the number of filters in this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "score": 1.0, + "content": "layer (i.e., the number of output channels). The proposed methods naturally extend to convolution", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 484, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 497 + ], + "score": 1.0, + "content": "layers as convolution just adds more axes on the left-hand side. E.g., the collection of parameters", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 247, + 507 + ], + "score": 1.0, + "content": "from a given convolutional layer of", + "type": "text" + }, + { + "bbox": [ + 248, + 496, + 256, + 505 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 495, + 416, + 507 + ], + "score": 1.0, + "content": "neural networks forms a tensor of shape", + "type": "text" + }, + { + "bbox": [ + 416, + 495, + 501, + 506 + ], + "score": 0.9, + "content": "H \\times W \\times C \\times M \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 495, + 505, + 507 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 107, + 512, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "These knowledge sharing strategies provide a way to softly share parameters across the correspond-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 523, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 535 + ], + "score": 1.0, + "content": "ing layers of each task’s DNN: where, what, and how much to share are learned from data. This is", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 533, + 506, + 548 + ], + "spans": [ + { + "bbox": [ + 104, + 533, + 506, + 548 + ], + "score": 1.0, + "content": "in contrast to the conventional Deep-MTL approach of manually selecting a set of layers to undergo", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 545, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 506, + 558 + ], + "score": 1.0, + "content": "hard parameter sharing: by tying weights so each task uses exactly the same weight matrix/tensor", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "for the corresponding layer (Zhang et al., 2014; Liu et al., 2015); and a set of layers to be completely", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 568, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 505, + 580 + ], + "score": 1.0, + "content": "separate: by using independent weight matrices/tensors. In contrast our approach benefits from:", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "(i) automatically learning this sharing structure from data rather than requiring user trial and error,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 589, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 602 + ], + "score": 1.0, + "content": "and (ii) smoothly interpolating between fully shared and fully segregated layers, rather than a hard", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 600, + 504, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 504, + 612 + ], + "score": 1.0, + "content": "switching between these states. An illustration of the proposed framework for different problem", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 611, + 232, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 232, + 624 + ], + "score": 1.0, + "content": "settings can be found in Fig. 1.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 22.5 + }, + { + "type": "title", + "bbox": [ + 108, + 640, + 200, + 652 + ], + "lines": [ + { + "bbox": [ + 105, + 639, + 201, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 201, + 654 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 710 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 677 + ], + "score": 1.0, + "content": "Implementation Details Our method is implemented with TensorFlow (Abadi et al., 2015). The", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 189, + 689 + ], + "score": 1.0, + "content": "code is released on", + "type": "text" + }, + { + "bbox": [ + 189, + 676, + 224, + 687 + ], + "score": 0.48, + "content": "\\mathrm { G i t H u b ^ { 4 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 676, + 505, + 689 + ], + "score": 1.0, + "content": ". For DMTRL-Tucker, DMTRL-TT, and DMTRL-LAF, we need to", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "assign the rank of each weight tensor. The DNN architecture itself may be complicated and so", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "can benefit from different ranks at different layers, but grid-search is impractical. However, since", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 722, + 280, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 720, + 281, + 733 + ], + "spans": [ + { + "bbox": [ + 119, + 720, + 281, + 733 + ], + "score": 1.0, + "content": "4https://github.com/wOOL/DMTRL", + "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, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 128, + 81, + 483, + 305 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 128, + 81, + 483, + 305 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 128, + 81, + 483, + 305 + ], + "spans": [ + { + "bbox": [ + 128, + 81, + 483, + 305 + ], + "score": 0.979, + "type": "image", + "image_path": "bbff1fe62fcb72612a1068843c26d12df81ac25b5a13fefd9886eeb50c6f4718.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 128, + 81, + 483, + 155.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 128, + 155.66666666666669, + 483, + 230.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 128, + 230.33333333333337, + 483, + 305.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 319, + 505, + 363 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 319, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 505, + 331 + ], + "score": 1.0, + "content": "Figure 1: Illustrative example with two tasks corresponding to two neural networks in homogeneous", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "(single output) and heterogeneous (different output dimension) cases. Weight layers grouped by", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "solid rectangles are tied across networks. Weight layers grouped by dashed rectangles are softly", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 352, + 421, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 421, + 365 + ], + "score": 1.0, + "content": "shared across networks with our method. Ungrouped weights are independent.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "image_caption", + "bbox": [ + 107, + 364, + 505, + 418 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 375 + ], + "score": 1.0, + "content": "Homogeneous MTL Shallow: Left is STL (two independent networks); right is MTL. In the case", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 505, + 386 + ], + "score": 1.0, + "content": "of vector input and no hidden layer, our method is equivalent to conventional matrix-based MTL", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "methods. Homogeneous MTL Deep: STL (Left) is independent networks. User-defined-MTL (UD-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 409 + ], + "score": 1.0, + "content": "MTL) selects layers to share/separate. Our DMTRL learns sharing at every layer. Heterogeneous", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 406, + 496, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 496, + 421 + ], + "score": 1.0, + "content": "MTL: UD-MTL selects layers to share/separate. DMTRL learns sharing at every shareable layer.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 440, + 505, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 440, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 453 + ], + "score": 1.0, + "content": "DNN designs often exploit convolutional layers. Those layers usually contain kernel filter parame-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 240, + 464 + ], + "score": 1.0, + "content": "ters that are 3-way tensors of size", + "type": "text" + }, + { + "bbox": [ + 241, + 452, + 290, + 462 + ], + "score": 0.9, + "content": "H \\times W \\times C", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 451, + 323, + 464 + ], + "score": 1.0, + "content": ", (where", + "type": "text" + }, + { + "bbox": [ + 323, + 452, + 333, + 461 + ], + "score": 0.82, + "content": "H", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 451, + 372, + 464 + ], + "score": 1.0, + "content": "is height,", + "type": "text" + }, + { + "bbox": [ + 373, + 452, + 385, + 462 + ], + "score": 0.57, + "content": "W", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 451, + 439, + 464 + ], + "score": 1.0, + "content": "is width, and", + "type": "text" + }, + { + "bbox": [ + 439, + 452, + 448, + 461 + ], + "score": 0.83, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 448, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "is the number", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 276, + 475 + ], + "score": 1.0, + "content": "of input channels) or 4-way tensors of size", + "type": "text" + }, + { + "bbox": [ + 276, + 463, + 344, + 473 + ], + "score": 0.89, + "content": "H \\times W \\times C \\times M", + "type": "inline_equation" + }, + { + "bbox": [ + 344, + 462, + 374, + 475 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 375, + 463, + 386, + 472 + ], + "score": 0.77, + "content": "M", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "is the number of filters in this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "score": 1.0, + "content": "layer (i.e., the number of output channels). The proposed methods naturally extend to convolution", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 484, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 505, + 497 + ], + "score": 1.0, + "content": "layers as convolution just adds more axes on the left-hand side. E.g., the collection of parameters", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 247, + 507 + ], + "score": 1.0, + "content": "from a given convolutional layer of", + "type": "text" + }, + { + "bbox": [ + 248, + 496, + 256, + 505 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 495, + 416, + 507 + ], + "score": 1.0, + "content": "neural networks forms a tensor of shape", + "type": "text" + }, + { + "bbox": [ + 416, + 495, + 501, + 506 + ], + "score": 0.9, + "content": "H \\times W \\times C \\times M \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 495, + 505, + 507 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 440, + 505, + 507 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 512, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "These knowledge sharing strategies provide a way to softly share parameters across the correspond-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 523, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 506, + 535 + ], + "score": 1.0, + "content": "ing layers of each task’s DNN: where, what, and how much to share are learned from data. This is", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 533, + 506, + 548 + ], + "spans": [ + { + "bbox": [ + 104, + 533, + 506, + 548 + ], + "score": 1.0, + "content": "in contrast to the conventional Deep-MTL approach of manually selecting a set of layers to undergo", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 545, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 506, + 558 + ], + "score": 1.0, + "content": "hard parameter sharing: by tying weights so each task uses exactly the same weight matrix/tensor", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 505, + 569 + ], + "score": 1.0, + "content": "for the corresponding layer (Zhang et al., 2014; Liu et al., 2015); and a set of layers to be completely", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 568, + 505, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 505, + 580 + ], + "score": 1.0, + "content": "separate: by using independent weight matrices/tensors. In contrast our approach benefits from:", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 505, + 591 + ], + "score": 1.0, + "content": "(i) automatically learning this sharing structure from data rather than requiring user trial and error,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 589, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 602 + ], + "score": 1.0, + "content": "and (ii) smoothly interpolating between fully shared and fully segregated layers, rather than a hard", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 600, + 504, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 600, + 504, + 612 + ], + "score": 1.0, + "content": "switching between these states. An illustration of the proposed framework for different problem", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 611, + 232, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 232, + 624 + ], + "score": 1.0, + "content": "settings can be found in Fig. 1.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 22.5, + "bbox_fs": [ + 104, + 512, + 506, + 624 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 640, + 200, + 652 + ], + "lines": [ + { + "bbox": [ + 105, + 639, + 201, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 201, + 654 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 710 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 677 + ], + "score": 1.0, + "content": "Implementation Details Our method is implemented with TensorFlow (Abadi et al., 2015). The", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 676, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 189, + 689 + ], + "score": 1.0, + "content": "code is released on", + "type": "text" + }, + { + "bbox": [ + 189, + 676, + 224, + 687 + ], + "score": 0.48, + "content": "\\mathrm { G i t H u b ^ { 4 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 676, + 505, + 689 + ], + "score": 1.0, + "content": ". For DMTRL-Tucker, DMTRL-TT, and DMTRL-LAF, we need to", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "assign the rank of each weight tensor. The DNN architecture itself may be complicated and so", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "can benefit from different ranks at different layers, but grid-search is impractical. However, since", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "both Tucker and TT decomposition methods have SVD-based solutions, and vanilla SVD is directly", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "applicable to DMTRL-LAF, we can initialise the model and set the ranks as follows: First train the", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "DNNs independently in single task learning mode. Then pack the layer-wise parameters as the input", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "for tensor decomposition. When SVD is applied, set a threshold for relative error so SVD will pick", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 506, + 139 + ], + "score": 1.0, + "content": "the appropriate rank. Thus our method needs only a single hyper parameter of max reconstruction", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 172, + 150 + ], + "score": 1.0, + "content": "error (we set to", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 172, + 137, + 212, + 148 + ], + "score": 0.91, + "content": "\\epsilon = 1 0 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 213, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "throughout) that indirectly specifies the ranks of every layer. Note that", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "score": 1.0, + "content": "training from random initialisation also works, but the STL-based initialisation makes rank selection", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 505, + 171 + ], + "score": 1.0, + "content": "easy and transparent. Nevertheless, like (Kumar & Daume III, 2012) the framework is not sensitive ´", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 170, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 505, + 183 + ], + "score": 1.0, + "content": "to rank choice so long as they are big enough. If random initialisation is desired to eliminate the", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 181, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 104, + 181, + 505, + 195 + ], + "score": 1.0, + "content": "pre-training requirement, good practice is to initialise parameter tensors by a suitable random weight", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "distribution first, then do decomposition, and use the decomposed values for initialising the factors", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "(the real learnable parameters in our framework). In this way, the resulting re-composed tensors will", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "score": 1.0, + "content": "have approximately the intended distribution. Our sharing is applied to weight parameters only, bias", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 225, + 444, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 444, + 237 + ], + "score": 1.0, + "content": "terms are not shared. Apart from initialisation, decomposition is not used anywhere.", + "type": "text", + "cross_page": true + } + ], + "index": 13 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 665, + 505, + 711 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 236 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "both Tucker and TT decomposition methods have SVD-based solutions, and vanilla SVD is directly", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 106 + ], + "score": 1.0, + "content": "applicable to DMTRL-LAF, we can initialise the model and set the ranks as follows: First train the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "DNNs independently in single task learning mode. Then pack the layer-wise parameters as the input", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 127 + ], + "score": 1.0, + "content": "for tensor decomposition. When SVD is applied, set a threshold for relative error so SVD will pick", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 127, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 506, + 139 + ], + "score": 1.0, + "content": "the appropriate rank. Thus our method needs only a single hyper parameter of max reconstruction", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 172, + 150 + ], + "score": 1.0, + "content": "error (we set to", + "type": "text" + }, + { + "bbox": [ + 172, + 137, + 212, + 148 + ], + "score": 0.91, + "content": "\\epsilon = 1 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "throughout) that indirectly specifies the ranks of every layer. Note that", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 161 + ], + "score": 1.0, + "content": "training from random initialisation also works, but the STL-based initialisation makes rank selection", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 505, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 505, + 171 + ], + "score": 1.0, + "content": "easy and transparent. Nevertheless, like (Kumar & Daume III, 2012) the framework is not sensitive ´", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 170, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 505, + 183 + ], + "score": 1.0, + "content": "to rank choice so long as they are big enough. If random initialisation is desired to eliminate the", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 181, + 505, + 195 + ], + "spans": [ + { + "bbox": [ + 104, + 181, + 505, + 195 + ], + "score": 1.0, + "content": "pre-training requirement, good practice is to initialise parameter tensors by a suitable random weight", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "distribution first, then do decomposition, and use the decomposed values for initialising the factors", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 216 + ], + "score": 1.0, + "content": "(the real learnable parameters in our framework). In this way, the resulting re-composed tensors will", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "spans": [ + { + "bbox": [ + 105, + 214, + 505, + 227 + ], + "score": 1.0, + "content": "have approximately the intended distribution. Our sharing is applied to weight parameters only, bias", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 225, + 444, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 444, + 237 + ], + "score": 1.0, + "content": "terms are not shared. Apart from initialisation, decomposition is not used anywhere.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 6.5 + }, + { + "type": "title", + "bbox": [ + 108, + 251, + 224, + 263 + ], + "lines": [ + { + "bbox": [ + 106, + 251, + 226, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 226, + 264 + ], + "score": 1.0, + "content": "4.1 HOMOGENEOUS MTL", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 504, + 327 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "Dataset, Settings and Baselines We use MNIST handwritten digits. The task is to recognise digit", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 284, + 506, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 296 + ], + "score": 1.0, + "content": "images zero to nine. When this dataset is used for the evaluation of MTL methods, ten 1-vs-all", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "score": 1.0, + "content": "binary classification problems usually define ten tasks (Kumar & Daume III, 2012). The dataset has ´", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 304, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 104, + 304, + 506, + 320 + ], + "score": 1.0, + "content": "a given train (60,000 images) and test (10,000 images) split. Each instance is a monochrome image", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 317, + 190, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 135, + 329 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 135, + 317, + 186, + 327 + ], + "score": 0.93, + "content": "2 8 \\times 2 8 \\times 1", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 317, + 190, + 329 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 333, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 505, + 346 + ], + "score": 1.0, + "content": "We use a modified LeNet (LeCun et al., 1998) as the CNN architecture. The first convolutional layer", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 345, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 189, + 356 + ], + "score": 1.0, + "content": "has 32 filters of size", + "type": "text" + }, + { + "bbox": [ + 189, + 345, + 213, + 355 + ], + "score": 0.89, + "content": "5 \\times 5", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 345, + 267, + 356 + ], + "score": 1.0, + "content": ", followed by", + "type": "text" + }, + { + "bbox": [ + 267, + 345, + 291, + 355 + ], + "score": 0.88, + "content": "2 \\times 2", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 345, + 505, + 356 + ], + "score": 1.0, + "content": "max pooling. The second convolutional layer has 64", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 160, + 368 + ], + "score": 1.0, + "content": "filters of size", + "type": "text" + }, + { + "bbox": [ + 161, + 356, + 184, + 366 + ], + "score": 0.9, + "content": "4 \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 356, + 236, + 368 + ], + "score": 1.0, + "content": ", and again a", + "type": "text" + }, + { + "bbox": [ + 236, + 356, + 259, + 366 + ], + "score": 0.88, + "content": "2 \\times 2", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "max pooling. After these two convolutional layers, two fully", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "score": 1.0, + "content": "connected layers with 512 and 1 output(s) are placed sequentially. The convolutional and first FC", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 377, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 172, + 391 + ], + "score": 1.0, + "content": "layer use RELU", + "type": "text" + }, + { + "bbox": [ + 173, + 378, + 248, + 389 + ], + "score": 0.94, + "content": "f ( x ) = \\operatorname* { m a x } ( x , 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 377, + 403, + 391 + ], + "score": 1.0, + "content": "activation function. We use hinge loss,", + "type": "text" + }, + { + "bbox": [ + 403, + 378, + 501, + 390 + ], + "score": 0.91, + "content": "\\ell ( y ) = \\operatorname* { m a x } ( 0 , 1 - \\hat { y } \\cdot y )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 377, + 506, + 391 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 388, + 428, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 133, + 401 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 389, + 165, + 400 + ], + "score": 0.91, + "content": "y \\in \\pm 1", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 388, + 246, + 401 + ], + "score": 1.0, + "content": "is the true label and", + "type": "text" + }, + { + "bbox": [ + 246, + 389, + 253, + 400 + ], + "score": 0.85, + "content": "\\hat { y }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 388, + 428, + 401 + ], + "score": 1.0, + "content": "is the output of each task’s neural network.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "Conventional matrix-based MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "score": 1.0, + "content": "& Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) are linear models taking ´", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 428, + 504, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 504, + 440 + ], + "score": 1.0, + "content": "vector input only, so they need a preprocessing that flattens the image into a vector, and typically", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 439, + 504, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 504, + 451 + ], + "score": 1.0, + "content": "reduce dimension by PCA. As per our motivation for studying Deep MTL, our methods decisively", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "score": 1.0, + "content": "outperform such shallow linear baselines. Thus to find a stronger MTL competitor, we instead search", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 460, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 473 + ], + "score": 1.0, + "content": "user defined architectures for Deep-MTL parameter sharing (cf (Zhang et al., 2014; Liu et al., 2015;", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "Caruana, 1997)). In all of the four parametrised layers (pooling has no parameters), we set the first", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 117, + 492 + ], + "score": 0.6, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 122, + 482, + 174, + 493 + ], + "score": 0.88, + "content": "\\left( 1 \\leq N \\leq 3 \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 482, + 505, + 495 + ], + "score": 1.0, + "content": ") to be hard shared5. We then use cross-validation to select among the three user-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 493, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 305, + 505 + ], + "score": 1.0, + "content": "defined MTL architectures and the best option is", + "type": "text" + }, + { + "bbox": [ + 305, + 493, + 335, + 504 + ], + "score": 0.88, + "content": "N = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 493, + 505, + 505 + ], + "score": 1.0, + "content": ", i.e., the first three layers are fully shared", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "score": 1.0, + "content": "(we denote this model UD-MTL). For our methods, all four parametrised layers are softly shared", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "score": 1.0, + "content": "with the different factorisation approaches. To evaluate different MTL methods and a baseline of", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 526, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 538 + ], + "score": 1.0, + "content": "single task learning (STL), we take ten different fractions of the given 60K training split, train the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "score": 1.0, + "content": "model, and test on the 10K testing split. For each fraction, we repeat the experiment 5 times with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 548, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 548, + 505, + 560 + ], + "score": 1.0, + "content": "randomly sampled training data. We report two performance metrics: (1) the mean error rate of the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "score": 1.0, + "content": "ten binary classification problems and (2) the error rate of recognising a digit by ranking each task’s", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 571, + 299, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 299, + 582 + ], + "score": 1.0, + "content": "1-vs-all output (multi-class classification error).", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "Results As we can see in Fig. 2, all MTL approaches outperform STL, and the advantage is more", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "significant when the training data is small. The proposed methods, DMTRL-TT and DMTRL-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 609, + 504, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 504, + 621 + ], + "score": 1.0, + "content": "Tucker outperform the best user-defined MTL when the training data is very small, and their perfor-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 619, + 318, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 318, + 633 + ], + "score": 1.0, + "content": "mance is comparable when the training data is large.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5 + }, + { + "type": "text", + "bbox": [ + 108, + 636, + 504, + 670 + ], + "lines": [ + { + "bbox": [ + 105, + 636, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 649 + ], + "score": 1.0, + "content": "Further Discussion For a slightly unfair comparison, in the case of binary classification with 1000", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "score": 1.0, + "content": "training data, shallow matrix-based MTL methods with PCA feature (Kang et al., 2011; Kumar &", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 216, + 671 + ], + "score": 1.0, + "content": "Daume III, 2012) reported ´", + "type": "text" + }, + { + "bbox": [ + 217, + 658, + 279, + 669 + ], + "score": 0.62, + "content": "1 4 . 0 \\% / \\ 1 3 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "error rate. With the same amount of data, our methods", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 47 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 681, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 117, + 679, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 117, + 679, + 506, + 695 + ], + "score": 1.0, + "content": "5This is not strictly all possible user-defined sharing options. For example, another possibility is the first", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 691, + 504, + 703 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 504, + 703 + ], + "score": 1.0, + "content": "convolutional layer and the first FC layer could be fully shared, with the second convolutional layer being in-", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 702, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 702, + 505, + 713 + ], + "score": 1.0, + "content": "dependent (task specific). However, this is against the intuition that lower/earlier layers are more task agnostic,", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "and later layers more task specific. Note that sharing the last layer is technically possible but not intuitive, and", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 721, + 450, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 450, + 732 + ], + "score": 1.0, + "content": "in any case not meaningful unless at least one early layer is unshared, as the tasks are different.", + "type": "text" + } + ] + } + ] + }, + { + "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": [ + 107, + 82, + 505, + 236 + ], + "lines": [], + "index": 6.5, + "bbox_fs": [ + 104, + 82, + 506, + 237 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 251, + 224, + 263 + ], + "lines": [ + { + "bbox": [ + 106, + 251, + 226, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 226, + 264 + ], + "score": 1.0, + "content": "4.1 HOMOGENEOUS MTL", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 504, + 327 + ], + "lines": [ + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "Dataset, Settings and Baselines We use MNIST handwritten digits. The task is to recognise digit", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 284, + 506, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 296 + ], + "score": 1.0, + "content": "images zero to nine. When this dataset is used for the evaluation of MTL methods, ten 1-vs-all", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "score": 1.0, + "content": "binary classification problems usually define ten tasks (Kumar & Daume III, 2012). The dataset has ´", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 304, + 506, + 320 + ], + "spans": [ + { + "bbox": [ + 104, + 304, + 506, + 320 + ], + "score": 1.0, + "content": "a given train (60,000 images) and test (10,000 images) split. Each instance is a monochrome image", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 317, + 190, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 135, + 329 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 135, + 317, + 186, + 327 + ], + "score": 0.93, + "content": "2 8 \\times 2 8 \\times 1", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 317, + 190, + 329 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17, + "bbox_fs": [ + 104, + 273, + 506, + 329 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 399 + ], + "lines": [ + { + "bbox": [ + 105, + 333, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 505, + 346 + ], + "score": 1.0, + "content": "We use a modified LeNet (LeCun et al., 1998) as the CNN architecture. The first convolutional layer", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 345, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 189, + 356 + ], + "score": 1.0, + "content": "has 32 filters of size", + "type": "text" + }, + { + "bbox": [ + 189, + 345, + 213, + 355 + ], + "score": 0.89, + "content": "5 \\times 5", + "type": "inline_equation" + }, + { + "bbox": [ + 213, + 345, + 267, + 356 + ], + "score": 1.0, + "content": ", followed by", + "type": "text" + }, + { + "bbox": [ + 267, + 345, + 291, + 355 + ], + "score": 0.88, + "content": "2 \\times 2", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 345, + 505, + 356 + ], + "score": 1.0, + "content": "max pooling. The second convolutional layer has 64", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 356, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 160, + 368 + ], + "score": 1.0, + "content": "filters of size", + "type": "text" + }, + { + "bbox": [ + 161, + 356, + 184, + 366 + ], + "score": 0.9, + "content": "4 \\times 4", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 356, + 236, + 368 + ], + "score": 1.0, + "content": ", and again a", + "type": "text" + }, + { + "bbox": [ + 236, + 356, + 259, + 366 + ], + "score": 0.88, + "content": "2 \\times 2", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 356, + 505, + 368 + ], + "score": 1.0, + "content": "max pooling. After these two convolutional layers, two fully", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "score": 1.0, + "content": "connected layers with 512 and 1 output(s) are placed sequentially. The convolutional and first FC", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 377, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 172, + 391 + ], + "score": 1.0, + "content": "layer use RELU", + "type": "text" + }, + { + "bbox": [ + 173, + 378, + 248, + 389 + ], + "score": 0.94, + "content": "f ( x ) = \\operatorname* { m a x } ( x , 0 )", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 377, + 403, + 391 + ], + "score": 1.0, + "content": "activation function. We use hinge loss,", + "type": "text" + }, + { + "bbox": [ + 403, + 378, + 501, + 390 + ], + "score": 0.91, + "content": "\\ell ( y ) = \\operatorname* { m a x } ( 0 , 1 - \\hat { y } \\cdot y )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 377, + 506, + 391 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 388, + 428, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 388, + 133, + 401 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 389, + 165, + 400 + ], + "score": 0.91, + "content": "y \\in \\pm 1", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 388, + 246, + 401 + ], + "score": 1.0, + "content": "is the true label and", + "type": "text" + }, + { + "bbox": [ + 246, + 389, + 253, + 400 + ], + "score": 0.85, + "content": "\\hat { y }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 388, + 428, + 401 + ], + "score": 1.0, + "content": "is the output of each task’s neural network.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 333, + 506, + 401 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "Conventional matrix-based MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 505, + 430 + ], + "score": 1.0, + "content": "& Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) are linear models taking ´", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 428, + 504, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 504, + 440 + ], + "score": 1.0, + "content": "vector input only, so they need a preprocessing that flattens the image into a vector, and typically", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 439, + 504, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 504, + 451 + ], + "score": 1.0, + "content": "reduce dimension by PCA. As per our motivation for studying Deep MTL, our methods decisively", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 462 + ], + "score": 1.0, + "content": "outperform such shallow linear baselines. Thus to find a stronger MTL competitor, we instead search", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 460, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 473 + ], + "score": 1.0, + "content": "user defined architectures for Deep-MTL parameter sharing (cf (Zhang et al., 2014; Liu et al., 2015;", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "Caruana, 1997)). In all of the four parametrised layers (pooling has no parameters), we set the first", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 117, + 492 + ], + "score": 0.6, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 122, + 482, + 174, + 493 + ], + "score": 0.88, + "content": "\\left( 1 \\leq N \\leq 3 \\right)", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 482, + 505, + 495 + ], + "score": 1.0, + "content": ") to be hard shared5. We then use cross-validation to select among the three user-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 493, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 305, + 505 + ], + "score": 1.0, + "content": "defined MTL architectures and the best option is", + "type": "text" + }, + { + "bbox": [ + 305, + 493, + 335, + 504 + ], + "score": 0.88, + "content": "N = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 493, + 505, + 505 + ], + "score": 1.0, + "content": ", i.e., the first three layers are fully shared", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "score": 1.0, + "content": "(we denote this model UD-MTL). For our methods, all four parametrised layers are softly shared", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 506, + 528 + ], + "score": 1.0, + "content": "with the different factorisation approaches. To evaluate different MTL methods and a baseline of", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 526, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 538 + ], + "score": 1.0, + "content": "single task learning (STL), we take ten different fractions of the given 60K training split, train the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 550 + ], + "score": 1.0, + "content": "model, and test on the 10K testing split. For each fraction, we repeat the experiment 5 times with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 548, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 548, + 505, + 560 + ], + "score": 1.0, + "content": "randomly sampled training data. We report two performance metrics: (1) the mean error rate of the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 506, + 572 + ], + "score": 1.0, + "content": "ten binary classification problems and (2) the error rate of recognising a digit by ranking each task’s", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 571, + 299, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 299, + 582 + ], + "score": 1.0, + "content": "1-vs-all output (multi-class classification error).", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 405, + 506, + 582 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 504, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "Results As we can see in Fig. 2, all MTL approaches outperform STL, and the advantage is more", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "significant when the training data is small. The proposed methods, DMTRL-TT and DMTRL-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 609, + 504, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 504, + 621 + ], + "score": 1.0, + "content": "Tucker outperform the best user-defined MTL when the training data is very small, and their perfor-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 619, + 318, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 318, + 633 + ], + "score": 1.0, + "content": "mance is comparable when the training data is large.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43.5, + "bbox_fs": [ + 105, + 586, + 506, + 633 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 636, + 504, + 670 + ], + "lines": [ + { + "bbox": [ + 105, + 636, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 649 + ], + "score": 1.0, + "content": "Further Discussion For a slightly unfair comparison, in the case of binary classification with 1000", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "score": 1.0, + "content": "training data, shallow matrix-based MTL methods with PCA feature (Kang et al., 2011; Kumar &", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 216, + 671 + ], + "score": 1.0, + "content": "Daume III, 2012) reported ´", + "type": "text" + }, + { + "bbox": [ + 217, + 658, + 279, + 669 + ], + "score": 0.62, + "content": "1 4 . 0 \\% / \\ 1 3 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "error rate. With the same amount of data, our methods", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 277, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 195, + 290 + ], + "score": 1.0, + "content": "have error rate below", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 195, + 277, + 210, + 288 + ], + "score": 0.87, + "content": "6 \\%", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 210, + 277, + 505, + 290 + ], + "score": 1.0, + "content": ". This shows the importance of our deep end-to-end multi-task represen-", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 288, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 300 + ], + "score": 1.0, + "content": "tation learning contribution versus conventional shallow MTL. Since the error rates in (Kang et al.,", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 299, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 505, + 311 + ], + "score": 1.0, + "content": "2011; Kumar & Daume III, 2012) were produced on a private subset of MNIST dataset with PCA ´", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 310, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 322 + ], + "score": 1.0, + "content": "representations only, to ensure a direct comparison, we implement several classic MTL methods and", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "score": 1.0, + "content": "compare them in Appendix A.", + "type": "text", + "cross_page": true + } + ], + "index": 8 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 636, + 505, + 671 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 135, + 78, + 475, + 216 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 135, + 78, + 475, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 78, + 475, + 216 + ], + "spans": [ + { + "bbox": [ + 135, + 78, + 475, + 216 + ], + "score": 0.97, + "type": "image", + "image_path": "4b3890f21ecf8c5319aa5bc69860e1ea77bf2f965ce0b0fb0495902f41401c7c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 135, + 78, + 475, + 124.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 135, + 124.0, + 475, + 170.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 135, + 170.0, + 475, + 216.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 111, + 226, + 495, + 239 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 225, + 497, + 241 + ], + "spans": [ + { + "bbox": [ + 114, + 225, + 497, + 241 + ], + "score": 1.0, + "content": "Figure 2: Homogeneous MTL: digit recognition on MNIST dataset. Each digit provides a task.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 107, + 277, + 505, + 332 + ], + "lines": [ + { + "bbox": [ + 105, + 277, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 277, + 195, + 290 + ], + "score": 1.0, + "content": "have error rate below", + "type": "text" + }, + { + "bbox": [ + 195, + 277, + 210, + 288 + ], + "score": 0.87, + "content": "6 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 210, + 277, + 505, + 290 + ], + "score": 1.0, + "content": ". This shows the importance of our deep end-to-end multi-task represen-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 288, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 505, + 300 + ], + "score": 1.0, + "content": "tation learning contribution versus conventional shallow MTL. Since the error rates in (Kang et al.,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 299, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 505, + 311 + ], + "score": 1.0, + "content": "2011; Kumar & Daume III, 2012) were produced on a private subset of MNIST dataset with PCA ´", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 310, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 505, + 322 + ], + "score": 1.0, + "content": "representations only, to ensure a direct comparison, we implement several classic MTL methods and", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 322, + 230, + 334 + ], + "score": 1.0, + "content": "compare them in Appendix A.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 504, + 360 + ], + "lines": [ + { + "bbox": [ + 105, + 338, + 504, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 504, + 351 + ], + "score": 1.0, + "content": "For readers interested in the connection to model capacity (number of parameters), we present fur-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 349, + 223, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 223, + 361 + ], + "score": 1.0, + "content": "ther analysis in Appendix B.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 107, + 394, + 307, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 394, + 308, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 308, + 407 + ], + "score": 1.0, + "content": "4.2 HETEROGENEOUS MTL: FACE ANALYSIS", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 424, + 505, + 577 + ], + "lines": [ + { + "bbox": [ + 106, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "Dataset, Settings and Baselines The AdienceFaces (Eidinger et al., 2014) is a large-scale face", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 435, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 506, + 447 + ], + "score": 1.0, + "content": "images dataset with the labels of each person’s gender and age group. We use this dataset for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "the evaluation of heterogeneous MTL with two tasks: (i) gender classification (two classes) and", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 456, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 506, + 469 + ], + "score": 1.0, + "content": "(ii) age group classification (eight classes). Two independent CNN models for this benchmark are", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 468, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 506, + 479 + ], + "score": 1.0, + "content": "introduced in (Levi & Hassncer, 2015). The two CNNs have the same architecture except for the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 498, + 491 + ], + "score": 1.0, + "content": "last fully-connected layer, since the heterogeneous tasks have different number of outputs (two", + "type": "text" + }, + { + "bbox": [ + 499, + 479, + 505, + 489 + ], + "score": 0.27, + "content": "/", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 488, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 104, + 488, + 506, + 502 + ], + "score": 1.0, + "content": "eight). We take these CNNs from (Levi & Hassncer, 2015) as the STL baseline. We again search", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "for the best possible user-defined MTL architecture as a strong competitor: the proposed CNN has", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "six layers – three convolutional and three fully-connected layers. The last fully-connected layer has", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 522, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 506, + 535 + ], + "score": 1.0, + "content": "non-shareable parameters because they are of different size. To search the MTL design-space, we", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 185, + 546 + ], + "score": 1.0, + "content": "try setting the first", + "type": "text" + }, + { + "bbox": [ + 185, + 533, + 196, + 543 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 533, + 255, + 545 + ], + "score": 0.89, + "content": "\\mathrm { ~ 1 ~ } \\leq N \\leq \\mathrm { ~ 5 ~ }", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 533, + 506, + 546 + ], + "score": 1.0, + "content": ") layers to be hard shared between the tasks. Running 5-fold", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 454, + 557 + ], + "score": 1.0, + "content": "cross-validation on the train set to evaluate the architectures, we find the best choice is", + "type": "text" + }, + { + "bbox": [ + 454, + 545, + 483, + 555 + ], + "score": 0.89, + "content": "N = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "(i.e.,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 554, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 505, + 567 + ], + "score": 1.0, + "content": "all layers fully shared before the final heterogeneous outputs). For our proposed methods, all the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 566, + 425, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 425, + 578 + ], + "score": 1.0, + "content": "layers before the last heterogeneous dimensionality FC layers are softly shared.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 616 + ], + "lines": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "We select increasing fractions of the AdienceFaces train split randomly, train the model, and evaluate", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "on the same test set. For reference, there are 12245 images with gender labelled for training, 4007", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 604, + 500, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 500, + 618 + ], + "score": 1.0, + "content": "ones for testing, and 11823 images with age group labelled for training, and 4316 ones for testing.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "Results Fig. 3 shows the error rate for each task. For the gender recognition task, we find that:", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "score": 1.0, + "content": "(i) User-defined MTL is not consistently better than STL, but (ii) our methods, esp., DMTRL-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 642, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 506, + 658 + ], + "score": 1.0, + "content": "Tucker, consistently outperform both STL and the best user-defined MTL. For the harder age group", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "classification task, our methods generally improve on STL. However UD-MTL does not consistently", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "improve on STL, and even reduces performance when the training set is bigger. This is the negative", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "transfer phenomenon (Rosenstein et al., 2005), where using a transfer learning algorithm is worse", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 686, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 506, + 702 + ], + "score": 1.0, + "content": "than not using it. This difference in outcomes is attributed to sufficient data eventually providing", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "some effective task-specific representation. Our methods can discover and exploit this, but UD-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "MTL’s hard switch between sharing and not sharing can not represent or exploit such increasing", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 241, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 241, + 733 + ], + "score": 1.0, + "content": "task-specificity of representation.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 33.5 + } + ], + "page_idx": 6, + "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": [ + 303, + 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": "image", + "bbox": [ + 135, + 78, + 475, + 216 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 135, + 78, + 475, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 78, + 475, + 216 + ], + "spans": [ + { + "bbox": [ + 135, + 78, + 475, + 216 + ], + "score": 0.97, + "type": "image", + "image_path": "4b3890f21ecf8c5319aa5bc69860e1ea77bf2f965ce0b0fb0495902f41401c7c.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 135, + 78, + 475, + 124.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 135, + 124.0, + 475, + 170.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 135, + 170.0, + 475, + 216.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 111, + 226, + 495, + 239 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 225, + 497, + 241 + ], + "spans": [ + { + "bbox": [ + 114, + 225, + 497, + 241 + ], + "score": 1.0, + "content": "Figure 2: Homogeneous MTL: digit recognition on MNIST dataset. Each digit provides a task.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 107, + 277, + 505, + 332 + ], + "lines": [], + "index": 6, + "bbox_fs": [ + 105, + 277, + 505, + 334 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 504, + 360 + ], + "lines": [ + { + "bbox": [ + 105, + 338, + 504, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 504, + 351 + ], + "score": 1.0, + "content": "For readers interested in the connection to model capacity (number of parameters), we present fur-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 349, + 223, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 223, + 361 + ], + "score": 1.0, + "content": "ther analysis in Appendix B.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 338, + 504, + 361 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 394, + 307, + 406 + ], + "lines": [ + { + "bbox": [ + 105, + 394, + 308, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 308, + 407 + ], + "score": 1.0, + "content": "4.2 HETEROGENEOUS MTL: FACE ANALYSIS", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 424, + 505, + 577 + ], + "lines": [ + { + "bbox": [ + 106, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "Dataset, Settings and Baselines The AdienceFaces (Eidinger et al., 2014) is a large-scale face", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 435, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 506, + 447 + ], + "score": 1.0, + "content": "images dataset with the labels of each person’s gender and age group. We use this dataset for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "the evaluation of heterogeneous MTL with two tasks: (i) gender classification (two classes) and", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 456, + 506, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 506, + 469 + ], + "score": 1.0, + "content": "(ii) age group classification (eight classes). Two independent CNN models for this benchmark are", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 468, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 506, + 479 + ], + "score": 1.0, + "content": "introduced in (Levi & Hassncer, 2015). The two CNNs have the same architecture except for the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 498, + 491 + ], + "score": 1.0, + "content": "last fully-connected layer, since the heterogeneous tasks have different number of outputs (two", + "type": "text" + }, + { + "bbox": [ + 499, + 479, + 505, + 489 + ], + "score": 0.27, + "content": "/", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 488, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 104, + 488, + 506, + 502 + ], + "score": 1.0, + "content": "eight). We take these CNNs from (Levi & Hassncer, 2015) as the STL baseline. We again search", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "for the best possible user-defined MTL architecture as a strong competitor: the proposed CNN has", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "six layers – three convolutional and three fully-connected layers. The last fully-connected layer has", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 522, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 506, + 535 + ], + "score": 1.0, + "content": "non-shareable parameters because they are of different size. To search the MTL design-space, we", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 533, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 185, + 546 + ], + "score": 1.0, + "content": "try setting the first", + "type": "text" + }, + { + "bbox": [ + 185, + 533, + 196, + 543 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 200, + 533, + 255, + 545 + ], + "score": 0.89, + "content": "\\mathrm { ~ 1 ~ } \\leq N \\leq \\mathrm { ~ 5 ~ }", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 533, + 506, + 546 + ], + "score": 1.0, + "content": ") layers to be hard shared between the tasks. Running 5-fold", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 544, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 454, + 557 + ], + "score": 1.0, + "content": "cross-validation on the train set to evaluate the architectures, we find the best choice is", + "type": "text" + }, + { + "bbox": [ + 454, + 545, + 483, + 555 + ], + "score": 0.89, + "content": "N = 5", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 544, + 505, + 557 + ], + "score": 1.0, + "content": "(i.e.,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 554, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 505, + 567 + ], + "score": 1.0, + "content": "all layers fully shared before the final heterogeneous outputs). For our proposed methods, all the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 566, + 425, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 425, + 578 + ], + "score": 1.0, + "content": "layers before the last heterogeneous dimensionality FC layers are softly shared.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 18.5, + "bbox_fs": [ + 104, + 423, + 506, + 578 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 582, + 505, + 616 + ], + "lines": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 505, + 595 + ], + "score": 1.0, + "content": "We select increasing fractions of the AdienceFaces train split randomly, train the model, and evaluate", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "on the same test set. For reference, there are 12245 images with gender labelled for training, 4007", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 604, + 500, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 500, + 618 + ], + "score": 1.0, + "content": "ones for testing, and 11823 images with age group labelled for training, and 4316 ones for testing.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 583, + 505, + 618 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 622, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 634 + ], + "score": 1.0, + "content": "Results Fig. 3 shows the error rate for each task. For the gender recognition task, we find that:", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "score": 1.0, + "content": "(i) User-defined MTL is not consistently better than STL, but (ii) our methods, esp., DMTRL-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 642, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 506, + 658 + ], + "score": 1.0, + "content": "Tucker, consistently outperform both STL and the best user-defined MTL. For the harder age group", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "classification task, our methods generally improve on STL. However UD-MTL does not consistently", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "improve on STL, and even reduces performance when the training set is bigger. This is the negative", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "transfer phenomenon (Rosenstein et al., 2005), where using a transfer learning algorithm is worse", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 686, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 506, + 702 + ], + "score": 1.0, + "content": "than not using it. This difference in outcomes is attributed to sufficient data eventually providing", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "some effective task-specific representation. Our methods can discover and exploit this, but UD-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 104, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "MTL’s hard switch between sharing and not sharing can not represent or exploit such increasing", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 241, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 241, + 733 + ], + "score": 1.0, + "content": "task-specificity of representation.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 33.5, + "bbox_fs": [ + 104, + 621, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 136, + 78, + 475, + 216 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 136, + 78, + 475, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 136, + 78, + 475, + 216 + ], + "spans": [ + { + "bbox": [ + 136, + 78, + 475, + 216 + ], + "score": 0.97, + "type": "image", + "image_path": "cb0b2ea66c83cfafe25a3bd6b663ffeb9e04a95ebdb2fde22b382108561d05b8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 136, + 78, + 475, + 124.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 136, + 124.0, + 475, + 170.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 136, + 170.0, + 475, + 216.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 133, + 227, + 474, + 239 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 134, + 226, + 476, + 240 + ], + "spans": [ + { + "bbox": [ + 134, + 226, + 476, + 240 + ], + "score": 1.0, + "content": "Figure 3: Heterogeneous MTL: Age and Gender recognition in AdienceFace dataset.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 107, + 260, + 383, + 272 + ], + "lines": [ + { + "bbox": [ + 105, + 260, + 383, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 383, + 274 + ], + "score": 1.0, + "content": "4.3 HETEROGENEOUS MTL: MULTI-ALPHABET RECOGNITION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 282, + 505, + 360 + ], + "lines": [ + { + "bbox": [ + 106, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "Dataset, Settings and Baselines We next consider the task of learning to recognise handwritten", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "score": 1.0, + "content": "letters in multiple languages using the Omniglot (Lake et al., 2015) dataset. Omniglot contains", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "score": 1.0, + "content": "handwritten characters in 50 different alphabets (e.g., Cyrillic, Korean, Tengwar), each with its own", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 315, + 505, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 228, + 328 + ], + "score": 1.0, + "content": "number of unique characters", + "type": "text" + }, + { + "bbox": [ + 229, + 316, + 267, + 326 + ], + "score": 0.84, + "content": "1 4 \\sim 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 315, + 505, + 328 + ], + "score": 1.0, + "content": "). In total, there are 1623 unique characters, and each has", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 326, + 504, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 504, + 338 + ], + "score": 1.0, + "content": "exactly 20 instances. Here each task corresponds to an alphabet, and the goal is to recognise its", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 337, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 505, + 351 + ], + "score": 1.0, + "content": "characters. MTL has a clear motivation here, as cross-alphabet knowledge sharing is likely to be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 349, + 504, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 504, + 361 + ], + "score": 1.0, + "content": "useful as one is unlikely to have extensive training data for a wide variety of less common alphabets.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 365, + 505, + 420 + ], + "lines": [ + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 255, + 378 + ], + "score": 1.0, + "content": "The images are monochrome of size", + "type": "text" + }, + { + "bbox": [ + 255, + 365, + 299, + 376 + ], + "score": 0.89, + "content": "1 0 5 \\times 1 0 5", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 364, + 482, + 378 + ], + "score": 1.0, + "content": ". We design a CNN with 3 convolutional and", + "type": "text" + }, + { + "bbox": [ + 483, + 365, + 505, + 376 + ], + "score": 0.3, + "content": "2 \\ : \\mathrm { F C }", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 300, + 388 + ], + "score": 1.0, + "content": "layers. The first conv layer has 8 filters of size", + "type": "text" + }, + { + "bbox": [ + 300, + 377, + 324, + 387 + ], + "score": 0.9, + "content": "5 \\times 5", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "; the second conv layer has 12 filters of size", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 386, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 131, + 398 + ], + "score": 0.9, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 386, + 359, + 399 + ], + "score": 1.0, + "content": ", and the third convolutional layer has 16 filters of size", + "type": "text" + }, + { + "bbox": [ + 360, + 387, + 384, + 398 + ], + "score": 0.9, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 386, + 505, + 399 + ], + "score": 1.0, + "content": ". Each convolutional layer is", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 397, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 164, + 411 + ], + "score": 1.0, + "content": "followed by a", + "type": "text" + }, + { + "bbox": [ + 165, + 398, + 189, + 408 + ], + "score": 0.89, + "content": "2 \\times 2", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 397, + 505, + 411 + ], + "score": 1.0, + "content": "max-pooling. The first FC layer has 64 neurons, and the second FC layer has", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 409, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 505, + 421 + ], + "score": 1.0, + "content": "size corresponding to the number of unique classes in the alphabet. The activation function is tanh.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 425, + 505, + 470 + ], + "lines": [ + { + "bbox": [ + 106, + 426, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 505, + 438 + ], + "score": 1.0, + "content": "We use a similar strategy to find the best user-defined MTL model: the CNN has 5 parametrised", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 437, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 439, + 448 + ], + "score": 1.0, + "content": "layers, of which 4 layers are potentially shareable. So we tried hard-sharing the first", + "type": "text" + }, + { + "bbox": [ + 439, + 437, + 449, + 447 + ], + "score": 0.74, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 437, + 453, + 448 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 454, + 437, + 502, + 448 + ], + "score": 0.87, + "content": "1 \\leq N \\leq 4 ,", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 437, + 505, + 448 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 448, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 472, + 460 + ], + "score": 1.0, + "content": "layers. Evaluating these options by 5-fold cross-validation, the best option turned out to be", + "type": "text" + }, + { + "bbox": [ + 472, + 448, + 501, + 458 + ], + "score": 0.87, + "content": "N = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 448, + 505, + 460 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 459, + 504, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 504, + 470 + ], + "score": 1.0, + "content": "i.e., the first three layers are hard shared. For our methods, all four shareable layers are softly shared.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 475, + 505, + 509 + ], + "lines": [ + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "score": 1.0, + "content": "Since there is no standard train/test split for this dataset, we use the following setting: We repeat-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 487, + 505, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 193, + 499 + ], + "score": 1.0, + "content": "edly pick at random", + "type": "text" + }, + { + "bbox": [ + 193, + 487, + 236, + 498 + ], + "score": 0.9, + "content": "5 , \\ldots 9 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 487, + 417, + 499 + ], + "score": 1.0, + "content": "of images per class for training. Note that", + "type": "text" + }, + { + "bbox": [ + 418, + 487, + 433, + 497 + ], + "score": 0.86, + "content": "5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 487, + 505, + 499 + ], + "score": 1.0, + "content": "is the minimum,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 498, + 426, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 426, + 509 + ], + "score": 1.0, + "content": "corresponding to one-shot learning. The remaining data are used for evaluation.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 514, + 505, + 548 + ], + "lines": [ + { + "bbox": [ + 106, + 514, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 505, + 527 + ], + "score": 1.0, + "content": "Results Fig. 4 reports the average error rate across all 50 tasks (alphabets). Our proposed MTL", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 525, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 537 + ], + "score": 1.0, + "content": "methods surpass the STL baseline in all cases. User-defined MTL does not work well when the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 536, + 439, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 415, + 548 + ], + "score": 1.0, + "content": "training data is very small, but does help when training fraction is larger than", + "type": "text" + }, + { + "bbox": [ + 416, + 536, + 435, + 547 + ], + "score": 0.88, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 536, + 439, + 548 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 553, + 505, + 697 + ], + "lines": [ + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "score": 1.0, + "content": "Measuring the Learned Sharing Compared to the conventional user-defined sharing architec-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 563, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 104, + 563, + 506, + 578 + ], + "score": 1.0, + "content": "tures, our method learns how to share from data. We next try to quantify the amount of sharing", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 575, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 443, + 588 + ], + "score": 1.0, + "content": "estimated by our model on the Omniglot data. Returning to the key factorisation", + "type": "text" + }, + { + "bbox": [ + 443, + 576, + 486, + 586 + ], + "score": 0.91, + "content": "\\mathscr { W } = \\mathscr { L } S", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 575, + 506, + 588 + ], + "score": 1.0, + "content": ", we", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 159, + 599 + ], + "score": 1.0, + "content": "can find that", + "type": "text" + }, + { + "bbox": [ + 159, + 587, + 167, + 596 + ], + "score": 0.82, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 586, + 409, + 599 + ], + "score": 1.0, + "content": "-like matrix appears in all variants of proposed method. It is", + "type": "text" + }, + { + "bbox": [ + 409, + 587, + 417, + 596 + ], + "score": 0.79, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "in DMTRL-LAF, the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 596, + 507, + 612 + ], + "spans": [ + { + "bbox": [ + 104, + 596, + 152, + 612 + ], + "score": 1.0, + "content": "transposed", + "type": "text" + }, + { + "bbox": [ + 153, + 597, + 175, + 608 + ], + "score": 0.9, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 596, + 277, + 612 + ], + "score": 1.0, + "content": "in DMTRL-Tucker, and", + "type": "text" + }, + { + "bbox": [ + 277, + 597, + 300, + 608 + ], + "score": 0.91, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 596, + 370, + 612 + ], + "score": 1.0, + "content": "in DMTRL-TT", + "type": "text" + }, + { + "bbox": [ + 371, + 599, + 381, + 609 + ], + "score": 0.68, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 596, + 456, + 612 + ], + "score": 1.0, + "content": "is the last axis of", + "type": "text" + }, + { + "bbox": [ + 456, + 599, + 468, + 609 + ], + "score": 0.77, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 596, + 478, + 612 + ], + "score": 1.0, + "content": ").", + "type": "text" + }, + { + "bbox": [ + 478, + 599, + 486, + 609 + ], + "score": 0.8, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 596, + 507, + 612 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 107, + 608, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 107, + 609, + 138, + 620 + ], + "score": 0.93, + "content": "K \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 608, + 217, + 622 + ], + "score": 1.0, + "content": "size matrix, where", + "type": "text" + }, + { + "bbox": [ + 217, + 610, + 226, + 619 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 608, + 340, + 622 + ], + "score": 1.0, + "content": "is the number of tasks, and", + "type": "text" + }, + { + "bbox": [ + 341, + 610, + 352, + 619 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 608, + 506, + 622 + ], + "score": 1.0, + "content": "is the number of latent tasks (Kumar", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "score": 1.0, + "content": "& Daume III, 2012) or the dimension of task coding (Yang & Hospedales, 2015). Each column ´", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 631, + 506, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 118, + 644 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 118, + 632, + 126, + 641 + ], + "score": 0.82, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 631, + 506, + 644 + ], + "score": 1.0, + "content": "is a set of coefficients that produce the final weight matrix/tensor by linear combination. If", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 642, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 506, + 655 + ], + "score": 1.0, + "content": "we put STL and user-defined MTL (for a certain shared layer) in this framework, we see that STL", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 653, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 234, + 666 + ], + "score": 1.0, + "content": "is to assign (rather than learn)", + "type": "text" + }, + { + "bbox": [ + 234, + 654, + 242, + 663 + ], + "score": 0.82, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 653, + 342, + 666 + ], + "score": 1.0, + "content": "to be an identity matrix", + "type": "text" + }, + { + "bbox": [ + 343, + 654, + 354, + 664 + ], + "score": 0.88, + "content": "I _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 653, + 506, + 666 + ], + "score": 1.0, + "content": ". Similarly, user-defined MTL (for a", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 240, + 677 + ], + "score": 1.0, + "content": "certain shared layer) is to assign", + "type": "text" + }, + { + "bbox": [ + 240, + 664, + 248, + 674 + ], + "score": 0.83, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 663, + 506, + 677 + ], + "score": 1.0, + "content": "to be a matrix with all zeros but one particular row is all ones,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 675, + 506, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 126, + 688 + ], + "score": 1.0, + "content": "e.g.,", + "type": "text" + }, + { + "bbox": [ + 126, + 675, + 185, + 687 + ], + "score": 0.92, + "content": "S = [ \\mathbf { 1 } _ { 1 \\times T } ; \\mathbf { 0 } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 675, + 477, + 688 + ], + "score": 1.0, + "content": ". Between these two extremes, our method learns the sharing structure in", + "type": "text" + }, + { + "bbox": [ + 477, + 676, + 485, + 685 + ], + "score": 0.75, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 675, + 506, + 688 + ], + "score": 1.0, + "content": ". We", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 686, + 394, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 394, + 699 + ], + "score": 1.0, + "content": "propose the following equation to measure the learned sharing strength:", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33 + }, + { + "type": "interline_equation", + "bbox": [ + 192, + 704, + 419, + 735 + ], + "lines": [ + { + "bbox": [ + 192, + 704, + 419, + 735 + ], + "spans": [ + { + "bbox": [ + 192, + 704, + 419, + 735 + ], + "score": 0.94, + "content": "\\rho = \\frac { 1 } { { \\binom { T } { 2 } } } \\sum _ { i < j } \\Omega ( S _ { \\cdot , i } , S _ { \\cdot , j } ) = \\frac { 2 } { T ( T - 1 ) } \\sum _ { i < j } \\Omega ( S _ { \\cdot , i } , S _ { \\cdot , j } )", + "type": "interline_equation", + "image_path": "954950dce55c861123763a36980f4e93559d92ef06137de75f0103e94e11fa67.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 192, + 704, + 419, + 719.5 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 192, + 719.5, + 419, + 735.0 + ], + "spans": [], + "index": 41 + } + ] + } + ], + "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": "image", + "bbox": [ + 136, + 78, + 475, + 216 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 136, + 78, + 475, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 136, + 78, + 475, + 216 + ], + "spans": [ + { + "bbox": [ + 136, + 78, + 475, + 216 + ], + "score": 0.97, + "type": "image", + "image_path": "cb0b2ea66c83cfafe25a3bd6b663ffeb9e04a95ebdb2fde22b382108561d05b8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 136, + 78, + 475, + 124.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 136, + 124.0, + 475, + 170.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 136, + 170.0, + 475, + 216.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 133, + 227, + 474, + 239 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 134, + 226, + 476, + 240 + ], + "spans": [ + { + "bbox": [ + 134, + 226, + 476, + 240 + ], + "score": 1.0, + "content": "Figure 3: Heterogeneous MTL: Age and Gender recognition in AdienceFace dataset.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "title", + "bbox": [ + 107, + 260, + 383, + 272 + ], + "lines": [ + { + "bbox": [ + 105, + 260, + 383, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 260, + 383, + 274 + ], + "score": 1.0, + "content": "4.3 HETEROGENEOUS MTL: MULTI-ALPHABET RECOGNITION", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 282, + 505, + 360 + ], + "lines": [ + { + "bbox": [ + 106, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "Dataset, Settings and Baselines We next consider the task of learning to recognise handwritten", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 306 + ], + "score": 1.0, + "content": "letters in multiple languages using the Omniglot (Lake et al., 2015) dataset. Omniglot contains", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 505, + 317 + ], + "score": 1.0, + "content": "handwritten characters in 50 different alphabets (e.g., Cyrillic, Korean, Tengwar), each with its own", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 315, + 505, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 228, + 328 + ], + "score": 1.0, + "content": "number of unique characters", + "type": "text" + }, + { + "bbox": [ + 229, + 316, + 267, + 326 + ], + "score": 0.84, + "content": "1 4 \\sim 5 5", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 315, + 505, + 328 + ], + "score": 1.0, + "content": "). In total, there are 1623 unique characters, and each has", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 326, + 504, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 504, + 338 + ], + "score": 1.0, + "content": "exactly 20 instances. Here each task corresponds to an alphabet, and the goal is to recognise its", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 337, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 505, + 351 + ], + "score": 1.0, + "content": "characters. MTL has a clear motivation here, as cross-alphabet knowledge sharing is likely to be", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 349, + 504, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 504, + 361 + ], + "score": 1.0, + "content": "useful as one is unlikely to have extensive training data for a wide variety of less common alphabets.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 282, + 505, + 361 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 365, + 505, + 420 + ], + "lines": [ + { + "bbox": [ + 105, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 255, + 378 + ], + "score": 1.0, + "content": "The images are monochrome of size", + "type": "text" + }, + { + "bbox": [ + 255, + 365, + 299, + 376 + ], + "score": 0.89, + "content": "1 0 5 \\times 1 0 5", + "type": "inline_equation" + }, + { + "bbox": [ + 299, + 364, + 482, + 378 + ], + "score": 1.0, + "content": ". We design a CNN with 3 convolutional and", + "type": "text" + }, + { + "bbox": [ + 483, + 365, + 505, + 376 + ], + "score": 0.3, + "content": "2 \\ : \\mathrm { F C }", + "type": "inline_equation" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 300, + 388 + ], + "score": 1.0, + "content": "layers. The first conv layer has 8 filters of size", + "type": "text" + }, + { + "bbox": [ + 300, + 377, + 324, + 387 + ], + "score": 0.9, + "content": "5 \\times 5", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "; the second conv layer has 12 filters of size", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 386, + 505, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 131, + 398 + ], + "score": 0.9, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 386, + 359, + 399 + ], + "score": 1.0, + "content": ", and the third convolutional layer has 16 filters of size", + "type": "text" + }, + { + "bbox": [ + 360, + 387, + 384, + 398 + ], + "score": 0.9, + "content": "3 \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 386, + 505, + 399 + ], + "score": 1.0, + "content": ". Each convolutional layer is", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 397, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 164, + 411 + ], + "score": 1.0, + "content": "followed by a", + "type": "text" + }, + { + "bbox": [ + 165, + 398, + 189, + 408 + ], + "score": 0.89, + "content": "2 \\times 2", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 397, + 505, + 411 + ], + "score": 1.0, + "content": "max-pooling. The first FC layer has 64 neurons, and the second FC layer has", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 409, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 505, + 421 + ], + "score": 1.0, + "content": "size corresponding to the number of unique classes in the alphabet. The activation function is tanh.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 364, + 505, + 421 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 425, + 505, + 470 + ], + "lines": [ + { + "bbox": [ + 106, + 426, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 505, + 438 + ], + "score": 1.0, + "content": "We use a similar strategy to find the best user-defined MTL model: the CNN has 5 parametrised", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 437, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 439, + 448 + ], + "score": 1.0, + "content": "layers, of which 4 layers are potentially shareable. So we tried hard-sharing the first", + "type": "text" + }, + { + "bbox": [ + 439, + 437, + 449, + 447 + ], + "score": 0.74, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 437, + 453, + 448 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 454, + 437, + 502, + 448 + ], + "score": 0.87, + "content": "1 \\leq N \\leq 4 ,", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 437, + 505, + 448 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 448, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 472, + 460 + ], + "score": 1.0, + "content": "layers. Evaluating these options by 5-fold cross-validation, the best option turned out to be", + "type": "text" + }, + { + "bbox": [ + 472, + 448, + 501, + 458 + ], + "score": 0.87, + "content": "N = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 448, + 505, + 460 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 459, + 504, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 504, + 470 + ], + "score": 1.0, + "content": "i.e., the first three layers are hard shared. For our methods, all four shareable layers are softly shared.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 426, + 505, + 470 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 475, + 505, + 509 + ], + "lines": [ + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "score": 1.0, + "content": "Since there is no standard train/test split for this dataset, we use the following setting: We repeat-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 487, + 505, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 193, + 499 + ], + "score": 1.0, + "content": "edly pick at random", + "type": "text" + }, + { + "bbox": [ + 193, + 487, + 236, + 498 + ], + "score": 0.9, + "content": "5 , \\ldots 9 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 487, + 417, + 499 + ], + "score": 1.0, + "content": "of images per class for training. Note that", + "type": "text" + }, + { + "bbox": [ + 418, + 487, + 433, + 497 + ], + "score": 0.86, + "content": "5 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 487, + 505, + 499 + ], + "score": 1.0, + "content": "is the minimum,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 498, + 426, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 426, + 509 + ], + "score": 1.0, + "content": "corresponding to one-shot learning. The remaining data are used for evaluation.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 474, + 505, + 509 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 514, + 505, + 548 + ], + "lines": [ + { + "bbox": [ + 106, + 514, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 505, + 527 + ], + "score": 1.0, + "content": "Results Fig. 4 reports the average error rate across all 50 tasks (alphabets). Our proposed MTL", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 525, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 537 + ], + "score": 1.0, + "content": "methods surpass the STL baseline in all cases. User-defined MTL does not work well when the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 536, + 439, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 415, + 548 + ], + "score": 1.0, + "content": "training data is very small, but does help when training fraction is larger than", + "type": "text" + }, + { + "bbox": [ + 416, + 536, + 435, + 547 + ], + "score": 0.88, + "content": "5 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 435, + 536, + 439, + 548 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 514, + 505, + 548 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 553, + 505, + 697 + ], + "lines": [ + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 554, + 504, + 565 + ], + "score": 1.0, + "content": "Measuring the Learned Sharing Compared to the conventional user-defined sharing architec-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 563, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 104, + 563, + 506, + 578 + ], + "score": 1.0, + "content": "tures, our method learns how to share from data. We next try to quantify the amount of sharing", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 575, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 443, + 588 + ], + "score": 1.0, + "content": "estimated by our model on the Omniglot data. Returning to the key factorisation", + "type": "text" + }, + { + "bbox": [ + 443, + 576, + 486, + 586 + ], + "score": 0.91, + "content": "\\mathscr { W } = \\mathscr { L } S", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 575, + 506, + 588 + ], + "score": 1.0, + "content": ", we", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 159, + 599 + ], + "score": 1.0, + "content": "can find that", + "type": "text" + }, + { + "bbox": [ + 159, + 587, + 167, + 596 + ], + "score": 0.82, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 586, + 409, + 599 + ], + "score": 1.0, + "content": "-like matrix appears in all variants of proposed method. It is", + "type": "text" + }, + { + "bbox": [ + 409, + 587, + 417, + 596 + ], + "score": 0.79, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 418, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "in DMTRL-LAF, the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 596, + 507, + 612 + ], + "spans": [ + { + "bbox": [ + 104, + 596, + 152, + 612 + ], + "score": 1.0, + "content": "transposed", + "type": "text" + }, + { + "bbox": [ + 153, + 597, + 175, + 608 + ], + "score": 0.9, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 596, + 277, + 612 + ], + "score": 1.0, + "content": "in DMTRL-Tucker, and", + "type": "text" + }, + { + "bbox": [ + 277, + 597, + 300, + 608 + ], + "score": 0.91, + "content": "U ^ { ( N ) }", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 596, + 370, + 612 + ], + "score": 1.0, + "content": "in DMTRL-TT", + "type": "text" + }, + { + "bbox": [ + 371, + 599, + 381, + 609 + ], + "score": 0.68, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 596, + 456, + 612 + ], + "score": 1.0, + "content": "is the last axis of", + "type": "text" + }, + { + "bbox": [ + 456, + 599, + 468, + 609 + ], + "score": 0.77, + "content": "\\mathcal { W }", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 596, + 478, + 612 + ], + "score": 1.0, + "content": ").", + "type": "text" + }, + { + "bbox": [ + 478, + 599, + 486, + 609 + ], + "score": 0.8, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 596, + 507, + 612 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 107, + 608, + 506, + 622 + ], + "spans": [ + { + "bbox": [ + 107, + 609, + 138, + 620 + ], + "score": 0.93, + "content": "K \\times T", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 608, + 217, + 622 + ], + "score": 1.0, + "content": "size matrix, where", + "type": "text" + }, + { + "bbox": [ + 217, + 610, + 226, + 619 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 608, + 340, + 622 + ], + "score": 1.0, + "content": "is the number of tasks, and", + "type": "text" + }, + { + "bbox": [ + 341, + 610, + 352, + 619 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 608, + 506, + 622 + ], + "score": 1.0, + "content": "is the number of latent tasks (Kumar", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 506, + 633 + ], + "score": 1.0, + "content": "& Daume III, 2012) or the dimension of task coding (Yang & Hospedales, 2015). Each column ´", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 631, + 506, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 118, + 644 + ], + "score": 1.0, + "content": "of", + "type": "text" + }, + { + "bbox": [ + 118, + 632, + 126, + 641 + ], + "score": 0.82, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 631, + 506, + 644 + ], + "score": 1.0, + "content": "is a set of coefficients that produce the final weight matrix/tensor by linear combination. If", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 642, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 506, + 655 + ], + "score": 1.0, + "content": "we put STL and user-defined MTL (for a certain shared layer) in this framework, we see that STL", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 653, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 234, + 666 + ], + "score": 1.0, + "content": "is to assign (rather than learn)", + "type": "text" + }, + { + "bbox": [ + 234, + 654, + 242, + 663 + ], + "score": 0.82, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 653, + 342, + 666 + ], + "score": 1.0, + "content": "to be an identity matrix", + "type": "text" + }, + { + "bbox": [ + 343, + 654, + 354, + 664 + ], + "score": 0.88, + "content": "I _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 653, + 506, + 666 + ], + "score": 1.0, + "content": ". Similarly, user-defined MTL (for a", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 240, + 677 + ], + "score": 1.0, + "content": "certain shared layer) is to assign", + "type": "text" + }, + { + "bbox": [ + 240, + 664, + 248, + 674 + ], + "score": 0.83, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 663, + 506, + 677 + ], + "score": 1.0, + "content": "to be a matrix with all zeros but one particular row is all ones,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 675, + 506, + 688 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 126, + 688 + ], + "score": 1.0, + "content": "e.g.,", + "type": "text" + }, + { + "bbox": [ + 126, + 675, + 185, + 687 + ], + "score": 0.92, + "content": "S = [ \\mathbf { 1 } _ { 1 \\times T } ; \\mathbf { 0 } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 675, + 477, + 688 + ], + "score": 1.0, + "content": ". Between these two extremes, our method learns the sharing structure in", + "type": "text" + }, + { + "bbox": [ + 477, + 676, + 485, + 685 + ], + "score": 0.75, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 675, + 506, + 688 + ], + "score": 1.0, + "content": ". We", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 686, + 394, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 394, + 699 + ], + "score": 1.0, + "content": "propose the following equation to measure the learned sharing strength:", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33, + "bbox_fs": [ + 104, + 554, + 507, + 699 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 192, + 704, + 419, + 735 + ], + "lines": [ + { + "bbox": [ + 192, + 704, + 419, + 735 + ], + "spans": [ + { + "bbox": [ + 192, + 704, + 419, + 735 + ], + "score": 0.94, + "content": "\\rho = \\frac { 1 } { { \\binom { T } { 2 } } } \\sum _ { i < j } \\Omega ( S _ { \\cdot , i } , S _ { \\cdot , j } ) = \\frac { 2 } { T ( T - 1 ) } \\sum _ { i < j } \\Omega ( S _ { \\cdot , i } , S _ { \\cdot , j } )", + "type": "interline_equation", + "image_path": "954950dce55c861123763a36980f4e93559d92ef06137de75f0103e94e11fa67.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 192, + 704, + 419, + 719.5 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 192, + 719.5, + 419, + 735.0 + ], + "spans": [], + "index": 41 + } + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 135, + 79, + 476, + 260 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 135, + 79, + 476, + 260 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 79, + 476, + 260 + ], + "spans": [ + { + "bbox": [ + 135, + 79, + 476, + 260 + ], + "score": 0.973, + "type": "image", + "image_path": "b4e9921c310609c64d55abce2351e70d7c7124ec9b4585bed886236cdd6c9de3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 135, + 79, + 476, + 139.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 135, + 139.33333333333334, + 476, + 199.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 135, + 199.66666666666669, + 476, + 260.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 272, + 505, + 306 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 272, + 504, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 504, + 285 + ], + "score": 1.0, + "content": "Figure 4: Results of multi-task learning of multilingual character recognition (Omniglot dataset).", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "score": 1.0, + "content": "Below: Illustration of the language pairs estimated to be the most related (left - Georgian Mkhedruli", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 294, + 471, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 471, + 307 + ], + "score": 1.0, + "content": "and Inuktitut) and most unrelated (right - Balinese and ULOG) character recognition tasks.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 340, + 505, + 428 + ], + "lines": [ + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 129, + 353 + ], + "score": 1.0, + "content": "Here", + "type": "text" + }, + { + "bbox": [ + 129, + 340, + 159, + 352 + ], + "score": 0.93, + "content": "\\Omega ( a , b )", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 339, + 319, + 353 + ], + "score": 1.0, + "content": "is a similarity measure for two vectors", + "type": "text" + }, + { + "bbox": [ + 319, + 343, + 326, + 350 + ], + "score": 0.73, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 339, + 344, + 353 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 344, + 341, + 351, + 350 + ], + "score": 0.72, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 339, + 472, + 353 + ], + "score": 1.0, + "content": "and we use cosine similarity.", + "type": "text" + }, + { + "bbox": [ + 473, + 342, + 479, + 352 + ], + "score": 0.79, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 352, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 339, + 364 + ], + "score": 1.0, + "content": "average on all combinations of column-wise similarity. So", + "type": "text" + }, + { + "bbox": [ + 339, + 353, + 346, + 363 + ], + "score": 0.75, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 352, + 505, + 364 + ], + "score": 1.0, + "content": "measures how much sharing is encoded", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 362, + 504, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 118, + 375 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 119, + 363, + 126, + 372 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 362, + 162, + 375 + ], + "score": 1.0, + "content": "between", + "type": "text" + }, + { + "bbox": [ + 162, + 363, + 187, + 374 + ], + "score": 0.91, + "content": "\\rho = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 362, + 308, + 375 + ], + "score": 1.0, + "content": "for STL (nothing to share) and", + "type": "text" + }, + { + "bbox": [ + 309, + 363, + 333, + 374 + ], + "score": 0.91, + "content": "\\rho = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 362, + 504, + 375 + ], + "score": 1.0, + "content": "for user-defined MTL (completely shared).", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 373, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 373, + 131, + 386 + ], + "score": 1.0, + "content": "Since", + "type": "text" + }, + { + "bbox": [ + 131, + 374, + 139, + 383 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 373, + 505, + 386 + ], + "score": 1.0, + "content": "is a real-valued matrix in our scenario, we normalise it before applying Eq. 9: First we take", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "absolute values, because large either positive or negative value suggests a significant coefficient.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 257, + 407 + ], + "score": 1.0, + "content": "Second we normalise each column of", + "type": "text" + }, + { + "bbox": [ + 257, + 396, + 264, + 405 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "by applying a softmax function, so the sum of every column", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 406, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 428, + 418 + ], + "score": 1.0, + "content": "is 1. The motivation behind the second step is to make a matched range of our", + "type": "text" + }, + { + "bbox": [ + 429, + 406, + 437, + 416 + ], + "score": 0.8, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 406, + 459, + 418 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 459, + 406, + 492, + 417 + ], + "score": 0.92, + "content": "S = I _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 406, + 506, + 418 + ], + "score": 1.0, + "content": "or", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 416, + 466, + 430 + ], + "spans": [ + { + "bbox": [ + 107, + 417, + 165, + 429 + ], + "score": 0.92, + "content": "S = [ \\mathbf { 1 } _ { 1 \\times T } ; \\mathbf { 0 } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 416, + 466, + 430 + ], + "score": 1.0, + "content": ", as for those two cases, the sum of each column is 1 and the range is [0, 1].", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 434, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 456, + 447 + ], + "score": 1.0, + "content": "For the Omniglot experiment, we plot the measured sharing amount for training fraction", + "type": "text" + }, + { + "bbox": [ + 456, + 433, + 475, + 444 + ], + "score": 0.87, + "content": "1 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 433, + 506, + 447 + ], + "score": 1.0, + "content": ". Fig. 4", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 445, + 506, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 457 + ], + "score": 1.0, + "content": "reveals that three proposed methods tend to share more for bottom layers (‘Conv1’, ‘Conv2’, and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "‘Conv3’) and share less for top layer (‘FC1’). This is qualitatively similar to the best user-defined", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 466, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 307, + 479 + ], + "score": 1.0, + "content": "MTL, where the first three layers are fully shared", + "type": "text" + }, + { + "bbox": [ + 307, + 468, + 333, + 479 + ], + "score": 0.88, + "content": "( \\rho = 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 466, + 505, + 479 + ], + "score": 1.0, + "content": ") and the 4th layer is completely not shared", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 109, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 109, + 478, + 136, + 489 + ], + "score": 0.86, + "content": "\\rho = 0 ,", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "). However, our methods: (i) learn this structure in a purely data-driven way and (ii) benefits", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "score": 1.0, + "content": "from the ability to smoothly interpolate between high and low degrees of sharing as depth increases.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 499, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 506, + 513 + ], + "score": 1.0, + "content": "As an illustration, Fig. 4 also shows example text from the most and least similar language pairs as", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 510, + 494, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 494, + 523 + ], + "score": 1.0, + "content": "estimated at our multilingual character recogniser’s FC1 layer (the result can vary across layers).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17.5 + }, + { + "type": "title", + "bbox": [ + 108, + 554, + 195, + 566 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 197, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 197, + 569 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 588, + 505, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "In this paper, we propose a novel framework for end-to-end multi-task representation learning in", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 612 + ], + "score": 1.0, + "content": "contemporary deep neural networks. The key idea is to generalise matrix factorisation-based multi-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "task ideas to tensor factorisation, in order to flexibly share knowledge in fully connected and convo-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 620, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 505, + 635 + ], + "score": 1.0, + "content": "lutional DNN layers. Our method provides consistently better performance than single task learning", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 632, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 644 + ], + "score": 1.0, + "content": "and comparable or better performance than the best results from exhaustive search of user-defined", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 642, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 505, + 656 + ], + "score": 1.0, + "content": "MTL architectures. It reduces the design choices and architectural search space that must be ex-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "plored in the workflow of Deep MTL architecture design (Caruana, 1997; Zhang et al., 2014; Liu", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "et al., 2015), relieving researchers of the need to decide how to structure layer sharing/segregation.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "score": 1.0, + "content": "Instead sharing structure is determined in a data-driven way on a layer-by-layer basis that moreover", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 686, + 482, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 482, + 700 + ], + "score": 1.0, + "content": "allows a smooth interpolation between sharing and not sharing in progressively deeper layers.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Acknowledgements This work was supported by EPSRC (EP/L023385/1), and the European", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 720, + 473, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 473, + 733 + ], + "score": 1.0, + "content": "Union’s Horizon 2020 research and innovation program under grant agreement No 640891.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5 + } + ], + "page_idx": 8, + "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, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 135, + 79, + 476, + 260 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 135, + 79, + 476, + 260 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 79, + 476, + 260 + ], + "spans": [ + { + "bbox": [ + 135, + 79, + 476, + 260 + ], + "score": 0.973, + "type": "image", + "image_path": "b4e9921c310609c64d55abce2351e70d7c7124ec9b4585bed886236cdd6c9de3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 135, + 79, + 476, + 139.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 135, + 139.33333333333334, + 476, + 199.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 135, + 199.66666666666669, + 476, + 260.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 272, + 505, + 306 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 272, + 504, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 504, + 285 + ], + "score": 1.0, + "content": "Figure 4: Results of multi-task learning of multilingual character recognition (Omniglot dataset).", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 506, + 297 + ], + "score": 1.0, + "content": "Below: Illustration of the language pairs estimated to be the most related (left - Georgian Mkhedruli", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 294, + 471, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 471, + 307 + ], + "score": 1.0, + "content": "and Inuktitut) and most unrelated (right - Balinese and ULOG) character recognition tasks.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 340, + 505, + 428 + ], + "lines": [ + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 129, + 353 + ], + "score": 1.0, + "content": "Here", + "type": "text" + }, + { + "bbox": [ + 129, + 340, + 159, + 352 + ], + "score": 0.93, + "content": "\\Omega ( a , b )", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 339, + 319, + 353 + ], + "score": 1.0, + "content": "is a similarity measure for two vectors", + "type": "text" + }, + { + "bbox": [ + 319, + 343, + 326, + 350 + ], + "score": 0.73, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 339, + 344, + 353 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 344, + 341, + 351, + 350 + ], + "score": 0.72, + "content": "b", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 339, + 472, + 353 + ], + "score": 1.0, + "content": "and we use cosine similarity.", + "type": "text" + }, + { + "bbox": [ + 473, + 342, + 479, + 352 + ], + "score": 0.79, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 352, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 339, + 364 + ], + "score": 1.0, + "content": "average on all combinations of column-wise similarity. So", + "type": "text" + }, + { + "bbox": [ + 339, + 353, + 346, + 363 + ], + "score": 0.75, + "content": "\\rho", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 352, + 505, + 364 + ], + "score": 1.0, + "content": "measures how much sharing is encoded", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 362, + 504, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 118, + 375 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 119, + 363, + 126, + 372 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 127, + 362, + 162, + 375 + ], + "score": 1.0, + "content": "between", + "type": "text" + }, + { + "bbox": [ + 162, + 363, + 187, + 374 + ], + "score": 0.91, + "content": "\\rho = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 362, + 308, + 375 + ], + "score": 1.0, + "content": "for STL (nothing to share) and", + "type": "text" + }, + { + "bbox": [ + 309, + 363, + 333, + 374 + ], + "score": 0.91, + "content": "\\rho = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 362, + 504, + 375 + ], + "score": 1.0, + "content": "for user-defined MTL (completely shared).", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 373, + 505, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 373, + 131, + 386 + ], + "score": 1.0, + "content": "Since", + "type": "text" + }, + { + "bbox": [ + 131, + 374, + 139, + 383 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 373, + 505, + 386 + ], + "score": 1.0, + "content": "is a real-valued matrix in our scenario, we normalise it before applying Eq. 9: First we take", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "absolute values, because large either positive or negative value suggests a significant coefficient.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 257, + 407 + ], + "score": 1.0, + "content": "Second we normalise each column of", + "type": "text" + }, + { + "bbox": [ + 257, + 396, + 264, + 405 + ], + "score": 0.81, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "by applying a softmax function, so the sum of every column", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 406, + 506, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 428, + 418 + ], + "score": 1.0, + "content": "is 1. The motivation behind the second step is to make a matched range of our", + "type": "text" + }, + { + "bbox": [ + 429, + 406, + 437, + 416 + ], + "score": 0.8, + "content": "S", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 406, + 459, + 418 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 459, + 406, + 492, + 417 + ], + "score": 0.92, + "content": "S = I _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 406, + 506, + 418 + ], + "score": 1.0, + "content": "or", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 416, + 466, + 430 + ], + "spans": [ + { + "bbox": [ + 107, + 417, + 165, + 429 + ], + "score": 0.92, + "content": "S = [ \\mathbf { 1 } _ { 1 \\times T } ; \\mathbf { 0 } ]", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 416, + 466, + 430 + ], + "score": 1.0, + "content": ", as for those two cases, the sum of each column is 1 and the range is [0, 1].", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 339, + 506, + 430 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 434, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 433, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 456, + 447 + ], + "score": 1.0, + "content": "For the Omniglot experiment, we plot the measured sharing amount for training fraction", + "type": "text" + }, + { + "bbox": [ + 456, + 433, + 475, + 444 + ], + "score": 0.87, + "content": "1 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 433, + 506, + 447 + ], + "score": 1.0, + "content": ". Fig. 4", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 445, + 506, + 457 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 506, + 457 + ], + "score": 1.0, + "content": "reveals that three proposed methods tend to share more for bottom layers (‘Conv1’, ‘Conv2’, and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "‘Conv3’) and share less for top layer (‘FC1’). This is qualitatively similar to the best user-defined", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 466, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 307, + 479 + ], + "score": 1.0, + "content": "MTL, where the first three layers are fully shared", + "type": "text" + }, + { + "bbox": [ + 307, + 468, + 333, + 479 + ], + "score": 0.88, + "content": "( \\rho = 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 466, + 505, + 479 + ], + "score": 1.0, + "content": ") and the 4th layer is completely not shared", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 109, + 478, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 109, + 478, + 136, + 489 + ], + "score": 0.86, + "content": "\\rho = 0 ,", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 478, + 505, + 491 + ], + "score": 1.0, + "content": "). However, our methods: (i) learn this structure in a purely data-driven way and (ii) benefits", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 502 + ], + "score": 1.0, + "content": "from the ability to smoothly interpolate between high and low degrees of sharing as depth increases.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 499, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 506, + 513 + ], + "score": 1.0, + "content": "As an illustration, Fig. 4 also shows example text from the most and least similar language pairs as", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 510, + 494, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 494, + 523 + ], + "score": 1.0, + "content": "estimated at our multilingual character recogniser’s FC1 layer (the result can vary across layers).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 433, + 506, + 523 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 554, + 195, + 566 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 197, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 197, + 569 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 588, + 505, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 601 + ], + "score": 1.0, + "content": "In this paper, we propose a novel framework for end-to-end multi-task representation learning in", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 600, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 612 + ], + "score": 1.0, + "content": "contemporary deep neural networks. The key idea is to generalise matrix factorisation-based multi-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "task ideas to tensor factorisation, in order to flexibly share knowledge in fully connected and convo-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 620, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 620, + 505, + 635 + ], + "score": 1.0, + "content": "lutional DNN layers. Our method provides consistently better performance than single task learning", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 632, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 644 + ], + "score": 1.0, + "content": "and comparable or better performance than the best results from exhaustive search of user-defined", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 642, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 642, + 505, + 656 + ], + "score": 1.0, + "content": "MTL architectures. It reduces the design choices and architectural search space that must be ex-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 667 + ], + "score": 1.0, + "content": "plored in the workflow of Deep MTL architecture design (Caruana, 1997; Zhang et al., 2014; Liu", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "et al., 2015), relieving researchers of the need to decide how to structure layer sharing/segregation.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 688 + ], + "score": 1.0, + "content": "Instead sharing structure is determined in a data-driven way on a layer-by-layer basis that moreover", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 686, + 482, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 482, + 700 + ], + "score": 1.0, + "content": "allows a smooth interpolation between sharing and not sharing in progressively deeper layers.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 588, + 505, + 700 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "Acknowledgements This work was supported by EPSRC (EP/L023385/1), and the European", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 720, + 473, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 473, + 733 + ], + "score": 1.0, + "content": "Union’s Horizon 2020 research and innovation program under grant agreement No 640891.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 708, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 175, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 505, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "score": 1.0, + "content": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 110, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 115, + 110, + 505, + 123 + ], + "score": 1.0, + "content": "Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 133, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 115, + 133, + 505, + 146 + ], + "score": 1.0, + "content": "Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 144, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 115, + 144, + 505, + 157 + ], + "score": 1.0, + "content": "Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vin-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 154, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 505, + 168 + ], + "score": 1.0, + "content": "cent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 164, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 505, + 180 + ], + "score": 1.0, + "content": "berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 115, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 186, + 178, + 201 + ], + "spans": [ + { + "bbox": [ + 115, + 186, + 178, + 201 + ], + "score": 1.0, + "content": "tensorflow.org.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 206, + 503, + 229 + ], + "lines": [ + { + "bbox": [ + 105, + 205, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 505, + 219 + ], + "score": 1.0, + "content": "Andreas Argyriou, Theodoros Evgeniou, and Massimiliano Pontil. Convex multi-task feature learn-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 218, + 239, + 230 + ], + "spans": [ + { + "bbox": [ + 115, + 218, + 239, + 230 + ], + "score": 1.0, + "content": "ing. Machine Learning, 2008.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 235, + 503, + 258 + ], + "lines": [ + { + "bbox": [ + 105, + 234, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 505, + 250 + ], + "score": 1.0, + "content": "Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 247, + 345, + 260 + ], + "spans": [ + { + "bbox": [ + 116, + 247, + 345, + 260 + ], + "score": 1.0, + "content": "In Neural Information Processing Systems (NIPS), 2007.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 106, + 265, + 350, + 277 + ], + "lines": [ + { + "bbox": [ + 105, + 265, + 350, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 350, + 278 + ], + "score": 1.0, + "content": "Rich Caruana. Multitask learning. Machine Learning, 1997.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 284, + 382, + 296 + ], + "lines": [ + { + "bbox": [ + 105, + 283, + 384, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 384, + 297 + ], + "score": 1.0, + "content": "Hal Daume III. Frustratingly easy domain adaptation. In ´ ACL, 2007.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 302, + 502, + 325 + ], + "lines": [ + { + "bbox": [ + 106, + 302, + 504, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 504, + 315 + ], + "score": 1.0, + "content": "Eran Eidinger, Roee Enbar, and Tal Hassner. Age and gender estimation of unfiltered faces. IEEE", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 117, + 313, + 353, + 326 + ], + "spans": [ + { + "bbox": [ + 117, + 313, + 353, + 326 + ], + "score": 1.0, + "content": "Transactions on Information Forensics and Security, 2014.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 106, + 332, + 504, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 345 + ], + "score": 1.0, + "content": "Theodoros Evgeniou and Massimiliano Pontil. Regularized multi–task learning. In Knowledge", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 343, + 288, + 356 + ], + "spans": [ + { + "bbox": [ + 116, + 343, + 288, + 356 + ], + "score": 1.0, + "content": "Discovery and Data Mining (KDD), 2004.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 361, + 503, + 385 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 505, + 375 + ], + "score": 1.0, + "content": "Thomas L. Griffiths and Zoubin Ghahramani. The indian buffet process: An introduction and review.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 373, + 336, + 385 + ], + "spans": [ + { + "bbox": [ + 115, + 373, + 336, + 385 + ], + "score": 1.0, + "content": "Journal of Machine Learning Research (JMLR), 2011.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 106, + 391, + 505, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 391, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 405 + ], + "score": 1.0, + "content": "Jui-Ting Huang, Jinyu Li, Dong Yu, Li Deng, and Yifan Gong. Cross-language knowledge transfer", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 403, + 504, + 415 + ], + "spans": [ + { + "bbox": [ + 116, + 403, + 504, + 415 + ], + "score": 1.0, + "content": "using multilingual deep neural network with shared hidden layers. In International Conference", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 414, + 366, + 426 + ], + "spans": [ + { + "bbox": [ + 116, + 414, + 366, + 426 + ], + "score": 1.0, + "content": "on Acoustics, Speech, and Signal Processing (ICASSP), 2013.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 504, + 455 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 446 + ], + "score": 1.0, + "content": "Laurent Jacob, Jean-philippe Vert, and Francis R Bach. Clustered multi-task learning: A convex", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 443, + 398, + 456 + ], + "spans": [ + { + "bbox": [ + 116, + 443, + 398, + 456 + ], + "score": 1.0, + "content": "formulation. In Neural Information Processing Systems (NIPS), 2009.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 503, + 484 + ], + "lines": [ + { + "bbox": [ + 106, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "Zhuoliang Kang, Kristen Grauman, and Fei Sha. Learning with whom to share in multi-task feature", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 472, + 418, + 485 + ], + "spans": [ + { + "bbox": [ + 115, + 472, + 418, + 485 + ], + "score": 1.0, + "content": "learning. In International Conference on Machine Learning (ICML), 2011.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 503, + 503 + ], + "lines": [ + { + "bbox": [ + 106, + 491, + 504, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 504, + 504 + ], + "score": 1.0, + "content": "Tamara G. Kolda and Brett W. Bader. Tensor decompositions and applications. SIAM Review, 2009.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 509, + 504, + 533 + ], + "lines": [ + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "Abhishek Kumar and Hal Daume III. Learning task grouping and overlap in multi-task learning. In ´", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 520, + 369, + 533 + ], + "spans": [ + { + "bbox": [ + 116, + 520, + 369, + 533 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML), 2012.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 105, + 539, + 504, + 562 + ], + "lines": [ + { + "bbox": [ + 105, + 537, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 554 + ], + "score": 1.0, + "content": "Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 550, + 343, + 562 + ], + "spans": [ + { + "bbox": [ + 116, + 550, + 343, + 562 + ], + "score": 1.0, + "content": "through probabilistic program induction. Science, 2015.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 569, + 504, + 592 + ], + "lines": [ + { + "bbox": [ + 105, + 567, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 505, + 583 + ], + "score": 1.0, + "content": "Lieven De Lathauwer, Bart De Moor, and Joos Vandewalle. A multilinear singular value decompo-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 581, + 378, + 592 + ], + "spans": [ + { + "bbox": [ + 116, + 581, + 378, + 592 + ], + "score": 1.0, + "content": "sition. SIAM Journal on Matrix Analysis and Applications, 2000.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 108, + 598, + 504, + 632 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 612 + ], + "score": 1.0, + "content": "Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan V. Oseledets, and Victor S. Lempitsky.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "Speeding-up convolutional neural networks using fine-tuned cp-decomposition. In International", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 621, + 340, + 633 + ], + "spans": [ + { + "bbox": [ + 116, + 621, + 340, + 633 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2015.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 108, + 639, + 503, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 653 + ], + "score": 1.0, + "content": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 651, + 296, + 663 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 296, + 663 + ], + "score": 1.0, + "content": "recognition. Proceedings of the IEEE, 1998.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5 + }, + { + "type": "text", + "bbox": [ + 107, + 669, + 504, + 691 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "G. Levi and T. Hassncer. Age and gender classification using convolutional neural networks. In", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 117, + 680, + 401, + 693 + ], + "spans": [ + { + "bbox": [ + 117, + 680, + 401, + 693 + ], + "score": 1.0, + "content": "Computer Vision and Pattern Recognition Workshops (CVPRW), 2015.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + }, + { + "type": "text", + "bbox": [ + 108, + 698, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "Xiaodong Liu, Jianfeng Gao, Xiaodong He, Li Deng, Kevin Duh, and Ye-Yi Wang. Representa-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "tion learning using multi-task deep neural networks for semantic classification and information", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 721, + 216, + 731 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 216, + 731 + ], + "score": 1.0, + "content": "retrieval. NAACL, 2015.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + } + ], + "page_idx": 9, + "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": [ + 301, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 175, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 100, + 505, + 199 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 505, + 113 + ], + "score": 1.0, + "content": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 110, + 505, + 123 + ], + "spans": [ + { + "bbox": [ + 115, + 110, + 505, + 123 + ], + "score": 1.0, + "content": "Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 133, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 115, + 133, + 505, + 146 + ], + "score": 1.0, + "content": "Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 144, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 115, + 144, + 505, + 157 + ], + "score": 1.0, + "content": "Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vin-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 154, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 505, + 168 + ], + "score": 1.0, + "content": "cent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 164, + 505, + 180 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 505, + 180 + ], + "score": 1.0, + "content": "berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 115, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 186, + 178, + 201 + ], + "spans": [ + { + "bbox": [ + 115, + 186, + 178, + 201 + ], + "score": 1.0, + "content": "tensorflow.org.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 99, + 505, + 201 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 206, + 503, + 229 + ], + "lines": [ + { + "bbox": [ + 105, + 205, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 505, + 219 + ], + "score": 1.0, + "content": "Andreas Argyriou, Theodoros Evgeniou, and Massimiliano Pontil. Convex multi-task feature learn-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 218, + 239, + 230 + ], + "spans": [ + { + "bbox": [ + 115, + 218, + 239, + 230 + ], + "score": 1.0, + "content": "ing. Machine Learning, 2008.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 205, + 505, + 230 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 235, + 503, + 258 + ], + "lines": [ + { + "bbox": [ + 105, + 234, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 505, + 250 + ], + "score": 1.0, + "content": "Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 247, + 345, + 260 + ], + "spans": [ + { + "bbox": [ + 116, + 247, + 345, + 260 + ], + "score": 1.0, + "content": "In Neural Information Processing Systems (NIPS), 2007.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 234, + 505, + 260 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 265, + 350, + 277 + ], + "lines": [ + { + "bbox": [ + 105, + 265, + 350, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 265, + 350, + 278 + ], + "score": 1.0, + "content": "Rich Caruana. Multitask learning. Machine Learning, 1997.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 265, + 350, + 278 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 284, + 382, + 296 + ], + "lines": [ + { + "bbox": [ + 105, + 283, + 384, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 283, + 384, + 297 + ], + "score": 1.0, + "content": "Hal Daume III. Frustratingly easy domain adaptation. In ´ ACL, 2007.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 283, + 384, + 297 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 302, + 502, + 325 + ], + "lines": [ + { + "bbox": [ + 106, + 302, + 504, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 504, + 315 + ], + "score": 1.0, + "content": "Eran Eidinger, Roee Enbar, and Tal Hassner. Age and gender estimation of unfiltered faces. IEEE", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 117, + 313, + 353, + 326 + ], + "spans": [ + { + "bbox": [ + 117, + 313, + 353, + 326 + ], + "score": 1.0, + "content": "Transactions on Information Forensics and Security, 2014.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16.5, + "bbox_fs": [ + 106, + 302, + 504, + 326 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 332, + 504, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 330, + 505, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 345 + ], + "score": 1.0, + "content": "Theodoros Evgeniou and Massimiliano Pontil. Regularized multi–task learning. In Knowledge", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 343, + 288, + 356 + ], + "spans": [ + { + "bbox": [ + 116, + 343, + 288, + 356 + ], + "score": 1.0, + "content": "Discovery and Data Mining (KDD), 2004.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 330, + 505, + 356 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 361, + 503, + 385 + ], + "lines": [ + { + "bbox": [ + 106, + 361, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 361, + 505, + 375 + ], + "score": 1.0, + "content": "Thomas L. Griffiths and Zoubin Ghahramani. The indian buffet process: An introduction and review.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 373, + 336, + 385 + ], + "spans": [ + { + "bbox": [ + 115, + 373, + 336, + 385 + ], + "score": 1.0, + "content": "Journal of Machine Learning Research (JMLR), 2011.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5, + "bbox_fs": [ + 106, + 361, + 505, + 385 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 391, + 505, + 425 + ], + "lines": [ + { + "bbox": [ + 105, + 391, + 505, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 405 + ], + "score": 1.0, + "content": "Jui-Ting Huang, Jinyu Li, Dong Yu, Li Deng, and Yifan Gong. Cross-language knowledge transfer", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 403, + 504, + 415 + ], + "spans": [ + { + "bbox": [ + 116, + 403, + 504, + 415 + ], + "score": 1.0, + "content": "using multilingual deep neural network with shared hidden layers. In International Conference", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 414, + 366, + 426 + ], + "spans": [ + { + "bbox": [ + 116, + 414, + 366, + 426 + ], + "score": 1.0, + "content": "on Acoustics, Speech, and Signal Processing (ICASSP), 2013.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 391, + 505, + 426 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 504, + 455 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 505, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 446 + ], + "score": 1.0, + "content": "Laurent Jacob, Jean-philippe Vert, and Francis R Bach. Clustered multi-task learning: A convex", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 443, + 398, + 456 + ], + "spans": [ + { + "bbox": [ + 116, + 443, + 398, + 456 + ], + "score": 1.0, + "content": "formulation. In Neural Information Processing Systems (NIPS), 2009.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 430, + 505, + 456 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 503, + 484 + ], + "lines": [ + { + "bbox": [ + 106, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "Zhuoliang Kang, Kristen Grauman, and Fei Sha. Learning with whom to share in multi-task feature", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 472, + 418, + 485 + ], + "spans": [ + { + "bbox": [ + 115, + 472, + 418, + 485 + ], + "score": 1.0, + "content": "learning. In International Conference on Machine Learning (ICML), 2011.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27.5, + "bbox_fs": [ + 106, + 462, + 505, + 485 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 491, + 503, + 503 + ], + "lines": [ + { + "bbox": [ + 106, + 491, + 504, + 504 + ], + "spans": [ + { + "bbox": [ + 106, + 491, + 504, + 504 + ], + "score": 1.0, + "content": "Tamara G. Kolda and Brett W. Bader. Tensor decompositions and applications. SIAM Review, 2009.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29, + "bbox_fs": [ + 106, + 491, + 504, + 504 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 509, + 504, + 533 + ], + "lines": [ + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "Abhishek Kumar and Hal Daume III. Learning task grouping and overlap in multi-task learning. In ´", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 116, + 520, + 369, + 533 + ], + "spans": [ + { + "bbox": [ + 116, + 520, + 369, + 533 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML), 2012.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30.5, + "bbox_fs": [ + 106, + 510, + 505, + 533 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 539, + 504, + 562 + ], + "lines": [ + { + "bbox": [ + 105, + 537, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 505, + 554 + ], + "score": 1.0, + "content": "Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 550, + 343, + 562 + ], + "spans": [ + { + "bbox": [ + 116, + 550, + 343, + 562 + ], + "score": 1.0, + "content": "through probabilistic program induction. Science, 2015.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 537, + 505, + 562 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 569, + 504, + 592 + ], + "lines": [ + { + "bbox": [ + 105, + 567, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 505, + 583 + ], + "score": 1.0, + "content": "Lieven De Lathauwer, Bart De Moor, and Joos Vandewalle. A multilinear singular value decompo-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 581, + 378, + 592 + ], + "spans": [ + { + "bbox": [ + 116, + 581, + 378, + 592 + ], + "score": 1.0, + "content": "sition. SIAM Journal on Matrix Analysis and Applications, 2000.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 567, + 505, + 592 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 598, + 504, + 632 + ], + "lines": [ + { + "bbox": [ + 106, + 597, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 612 + ], + "score": 1.0, + "content": "Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan V. Oseledets, and Victor S. Lempitsky.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "Speeding-up convolutional neural networks using fine-tuned cp-decomposition. In International", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 621, + 340, + 633 + ], + "spans": [ + { + "bbox": [ + 116, + 621, + 340, + 633 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2015.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 37, + "bbox_fs": [ + 106, + 597, + 505, + 633 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 639, + 503, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 653 + ], + "score": 1.0, + "content": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 651, + 296, + 663 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 296, + 663 + ], + "score": 1.0, + "content": "recognition. Proceedings of the IEEE, 1998.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5, + "bbox_fs": [ + 106, + 637, + 505, + 663 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 669, + 504, + 691 + ], + "lines": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 505, + 681 + ], + "score": 1.0, + "content": "G. Levi and T. Hassncer. Age and gender classification using convolutional neural networks. In", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 117, + 680, + 401, + 693 + ], + "spans": [ + { + "bbox": [ + 117, + 680, + 401, + 693 + ], + "score": 1.0, + "content": "Computer Vision and Pattern Recognition Workshops (CVPRW), 2015.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5, + "bbox_fs": [ + 105, + 668, + 505, + 693 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 698, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "Xiaodong Liu, Jianfeng Gao, Xiaodong He, Li Deng, Kevin Duh, and Ye-Yi Wang. Representa-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 116, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "tion learning using multi-task deep neural networks for semantic classification and information", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 721, + 216, + 731 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 216, + 731 + ], + "score": 1.0, + "content": "retrieval. NAACL, 2015.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 106, + 698, + 505, + 731 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Alexander Novikov, Dmitry Podoprikhin, Anton Osokin, and Dmitry Vetrov. Tensorizing neural", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 388, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 388, + 106 + ], + "score": 1.0, + "content": "networks. In Neural Information Processing Systems (NIPS), 2015.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 105, + 111, + 471, + 125 + ], + "lines": [ + { + "bbox": [ + 105, + 111, + 471, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 471, + 126 + ], + "score": 1.0, + "content": "I. V. Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 2011.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 105, + 131, + 503, + 154 + ], + "lines": [ + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "score": 1.0, + "content": "Alexandre Passos, Piyush Rai, Jacques Wainer, and Hal Daume III. Flexible modeling of latent task ´", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 115, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "structures in multitask learning. In International Conference on Machine Learning (ICML), 2012.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 160, + 504, + 184 + ], + "lines": [ + { + "bbox": [ + 106, + 162, + 504, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 162, + 504, + 173 + ], + "score": 1.0, + "content": "Bernardino Romera-paredes, Hane Aung, Nadia Bianchi-berthouze, and Massimiliano Pontil. Mul-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 172, + 488, + 185 + ], + "spans": [ + { + "bbox": [ + 116, + 172, + 488, + 185 + ], + "score": 1.0, + "content": "tilinear multitask learning. In International Conference on Machine Learning (ICML), 2013.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 105, + 190, + 504, + 214 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 505, + 203 + ], + "score": 1.0, + "content": "Michael T. Rosenstein, Zvika Marx, Leslie Pack Kaelbling, and Thomas G. Dietterich. To transfer", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 202, + 446, + 214 + ], + "spans": [ + { + "bbox": [ + 115, + 202, + 446, + 214 + ], + "score": 1.0, + "content": "or not to transfer. In In NIPS Workshop, Inductive Transfer: 10 Years Later, 2005.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 220, + 503, + 244 + ], + "lines": [ + { + "bbox": [ + 105, + 219, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 505, + 235 + ], + "score": 1.0, + "content": "Olivier Sigaud, Clement Masson, David Filliat, and Freek Stulp. Gated networks: an inventory.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 231, + 169, + 243 + ], + "spans": [ + { + "bbox": [ + 115, + 231, + 169, + 243 + ], + "score": 1.0, + "content": "arXiv, 2015.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 250, + 505, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "score": 1.0, + "content": "Sigurd Spieckermann, Steffen Udluft, and Thomas Runkler. Data-effiicient temporal regression with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 114, + 260, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 114, + 260, + 506, + 275 + ], + "score": 1.0, + "content": "multitask recurrent neural networks. In NIPS Workshop on Transfer and Multi-Task Learning,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 272, + 143, + 285 + ], + "spans": [ + { + "bbox": [ + 114, + 272, + 143, + 285 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 106, + 291, + 504, + 315 + ], + "lines": [ + { + "bbox": [ + 106, + 291, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 304 + ], + "score": 1.0, + "content": "Tian Tan, Yanmin Qian, and Kai Yu. Cluster adaptive training for deep neural network based acoustic", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 116, + 302, + 472, + 315 + ], + "spans": [ + { + "bbox": [ + 116, + 302, + 472, + 315 + ], + "score": 1.0, + "content": "model. IEEE/ACM Trans. Audio, Speech & Language Processing, 24(3):459–468, 2016.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 106, + 321, + 480, + 333 + ], + "lines": [ + { + "bbox": [ + 105, + 320, + 480, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 480, + 334 + ], + "score": 1.0, + "content": "L. R. Tucker. Some mathematical notes on three-mode factor analysis. Psychometrika, 1966.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 340, + 504, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "Kishan Wimalawarne, Masashi Sugiyama, and Ryota Tomioka. Multitask learning meets tensor", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 115, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "factorization: task imputation via convex optimization. In Neural Information Processing Systems", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 362, + 174, + 375 + ], + "spans": [ + { + "bbox": [ + 116, + 362, + 174, + 375 + ], + "score": 1.0, + "content": "(NIPS), 2014.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 105, + 380, + 504, + 404 + ], + "lines": [ + { + "bbox": [ + 106, + 380, + 504, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 504, + 393 + ], + "score": 1.0, + "content": "Ya Xue, Xuejun Liao, Lawrence Carin, and Balaji Krishnapuram. Multi-task learning for classifica-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 392, + 472, + 405 + ], + "spans": [ + { + "bbox": [ + 115, + 392, + 472, + 405 + ], + "score": 1.0, + "content": "tion with dirichlet process priors. Journal of Machine Learning Research (JMLR), 2007.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 106, + 410, + 503, + 434 + ], + "lines": [ + { + "bbox": [ + 107, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 107, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "Yongxin Yang and Timothy M. Hospedales. A unified perspective on multi-domain and multi-task", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 422, + 445, + 434 + ], + "spans": [ + { + "bbox": [ + 115, + 422, + 445, + 434 + ], + "score": 1.0, + "content": "learning. In International Conference on Learning Representations (ICLR), 2015.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 440, + 503, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "Zhanpeng Zhang, Ping Luo, Chen Change Loy, and Xiaoou Tang. Facial landmark detection by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 452, + 464, + 464 + ], + "spans": [ + { + "bbox": [ + 116, + 452, + 464, + 464 + ], + "score": 1.0, + "content": "deep multi-task learning. In European Conference on Computer Vision (ECCV), 2014.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + } + ], + "page_idx": 10, + "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": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Alexander Novikov, Dmitry Podoprikhin, Anton Osokin, and Dmitry Vetrov. Tensorizing neural", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 388, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 388, + 106 + ], + "score": 1.0, + "content": "networks. In Neural Information Processing Systems (NIPS), 2015.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 81, + 505, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 111, + 471, + 125 + ], + "lines": [ + { + "bbox": [ + 105, + 111, + 471, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 471, + 126 + ], + "score": 1.0, + "content": "I. V. Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 2011.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 111, + 471, + 126 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 131, + 503, + 154 + ], + "lines": [ + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 505, + 144 + ], + "score": 1.0, + "content": "Alexandre Passos, Piyush Rai, Jacques Wainer, and Hal Daume III. Flexible modeling of latent task ´", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 142, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 115, + 142, + 505, + 155 + ], + "score": 1.0, + "content": "structures in multitask learning. In International Conference on Machine Learning (ICML), 2012.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 106, + 132, + 505, + 155 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 160, + 504, + 184 + ], + "lines": [ + { + "bbox": [ + 106, + 162, + 504, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 162, + 504, + 173 + ], + "score": 1.0, + "content": "Bernardino Romera-paredes, Hane Aung, Nadia Bianchi-berthouze, and Massimiliano Pontil. Mul-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 116, + 172, + 488, + 185 + ], + "spans": [ + { + "bbox": [ + 116, + 172, + 488, + 185 + ], + "score": 1.0, + "content": "tilinear multitask learning. In International Conference on Machine Learning (ICML), 2013.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5, + "bbox_fs": [ + 106, + 162, + 504, + 185 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 190, + 504, + 214 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 505, + 203 + ], + "score": 1.0, + "content": "Michael T. Rosenstein, Zvika Marx, Leslie Pack Kaelbling, and Thomas G. Dietterich. To transfer", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 202, + 446, + 214 + ], + "spans": [ + { + "bbox": [ + 115, + 202, + 446, + 214 + ], + "score": 1.0, + "content": "or not to transfer. In In NIPS Workshop, Inductive Transfer: 10 Years Later, 2005.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 106, + 190, + 505, + 214 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 220, + 503, + 244 + ], + "lines": [ + { + "bbox": [ + 105, + 219, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 505, + 235 + ], + "score": 1.0, + "content": "Olivier Sigaud, Clement Masson, David Filliat, and Freek Stulp. Gated networks: an inventory.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 231, + 169, + 243 + ], + "spans": [ + { + "bbox": [ + 115, + 231, + 169, + 243 + ], + "score": 1.0, + "content": "arXiv, 2015.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 219, + 505, + 243 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 250, + 505, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 505, + 263 + ], + "score": 1.0, + "content": "Sigurd Spieckermann, Steffen Udluft, and Thomas Runkler. Data-effiicient temporal regression with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 114, + 260, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 114, + 260, + 506, + 275 + ], + "score": 1.0, + "content": "multitask recurrent neural networks. In NIPS Workshop on Transfer and Multi-Task Learning,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 272, + 143, + 285 + ], + "spans": [ + { + "bbox": [ + 114, + 272, + 143, + 285 + ], + "score": 1.0, + "content": "2014.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 250, + 506, + 285 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 291, + 504, + 315 + ], + "lines": [ + { + "bbox": [ + 106, + 291, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 291, + 505, + 304 + ], + "score": 1.0, + "content": "Tian Tan, Yanmin Qian, and Kai Yu. Cluster adaptive training for deep neural network based acoustic", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 116, + 302, + 472, + 315 + ], + "spans": [ + { + "bbox": [ + 116, + 302, + 472, + 315 + ], + "score": 1.0, + "content": "model. IEEE/ACM Trans. Audio, Speech & Language Processing, 24(3):459–468, 2016.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 106, + 291, + 505, + 315 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 321, + 480, + 333 + ], + "lines": [ + { + "bbox": [ + 105, + 320, + 480, + 334 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 480, + 334 + ], + "score": 1.0, + "content": "L. R. Tucker. Some mathematical notes on three-mode factor analysis. Psychometrika, 1966.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 320, + 480, + 334 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 340, + 504, + 374 + ], + "lines": [ + { + "bbox": [ + 106, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "Kishan Wimalawarne, Masashi Sugiyama, and Ryota Tomioka. Multitask learning meets tensor", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 351, + 505, + 364 + ], + "spans": [ + { + "bbox": [ + 115, + 351, + 505, + 364 + ], + "score": 1.0, + "content": "factorization: task imputation via convex optimization. In Neural Information Processing Systems", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 362, + 174, + 375 + ], + "spans": [ + { + "bbox": [ + 116, + 362, + 174, + 375 + ], + "score": 1.0, + "content": "(NIPS), 2014.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 106, + 340, + 505, + 375 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 380, + 504, + 404 + ], + "lines": [ + { + "bbox": [ + 106, + 380, + 504, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 504, + 393 + ], + "score": 1.0, + "content": "Ya Xue, Xuejun Liao, Lawrence Carin, and Balaji Krishnapuram. Multi-task learning for classifica-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 392, + 472, + 405 + ], + "spans": [ + { + "bbox": [ + 115, + 392, + 472, + 405 + ], + "score": 1.0, + "content": "tion with dirichlet process priors. Journal of Machine Learning Research (JMLR), 2007.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5, + "bbox_fs": [ + 106, + 380, + 504, + 405 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 410, + 503, + 434 + ], + "lines": [ + { + "bbox": [ + 107, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 107, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "Yongxin Yang and Timothy M. Hospedales. A unified perspective on multi-domain and multi-task", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 422, + 445, + 434 + ], + "spans": [ + { + "bbox": [ + 115, + 422, + 445, + 434 + ], + "score": 1.0, + "content": "learning. In International Conference on Learning Representations (ICLR), 2015.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 107, + 411, + 505, + 434 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 440, + 503, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "Zhanpeng Zhang, Ping Luo, Chen Change Loy, and Xiaoou Tang. Facial landmark detection by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 452, + 464, + 464 + ], + "spans": [ + { + "bbox": [ + 116, + 452, + 464, + 464 + ], + "score": 1.0, + "content": "deep multi-task learning. In European Conference on Computer Vision (ECCV), 2014.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 106, + 441, + 505, + 464 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 421, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 423, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 423, + 96 + ], + "score": 1.0, + "content": "A COMPARISON WITH CLASSIC (SHALLOW) MTL METHODS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 106, + 506, + 183 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "We provide a comparison with classic (shallow, matrix-based) MTL methods for the first experiment", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 117, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 277, + 129 + ], + "score": 1.0, + "content": "(MNIST, binary one-vs-rest classification,", + "type": "text" + }, + { + "bbox": [ + 277, + 117, + 292, + 128 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 117, + 506, + 129 + ], + "score": 1.0, + "content": "training data, mean of error rates for 10-fold CV). A", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "score": 1.0, + "content": "subtlety in making this comparison is what feature should the classic methods use? Conventionally", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 139, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 106, + 139, + 505, + 152 + ], + "score": 1.0, + "content": "they use a PCA feature (obtained by flattening the image, then dimension reduction by PCA). How-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 162 + ], + "score": 1.0, + "content": "ever for visual recognition tasks, performance is better with deep features – a key motivation for our", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "score": 1.0, + "content": "focus on deep approaches to MTL. We therefore also compare the classic methods when using a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 171, + 464, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 171, + 464, + 184 + ], + "score": 1.0, + "content": "feature extracted from the penultimate layer of the CNN network used in our experiment.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4 + }, + { + "type": "table", + "bbox": [ + 178, + 193, + 433, + 295 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 178, + 193, + 433, + 295 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 178, + 193, + 433, + 295 + ], + "spans": [ + { + "bbox": [ + 178, + 193, + 433, + 295 + ], + "score": 0.98, + "html": "
ModelPCAFeatureCNNFeature
Single Task Learning16.8911.52
Evgeniou & Pontil (2004)15.2710.32
Argyriou et al. (2008)15.649.56
Kumar & Daumé I (2012)14.089.41
DMTRL-LAF-8.25
DMTRL-Tucker9.24
DMTRL-TT7.31
UD-MTL9.34
", + "type": "table", + "image_path": "a1ef0d76eea7bf0386e1248977bb3ffdda8efc45672ac4bfa9ef8491df23dd39.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 178, + 193, + 433, + 227.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 178, + 227.0, + 433, + 261.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 178, + 261.0, + 433, + 295.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 114, + 303, + 491, + 315 + ], + "lines": [ + { + "bbox": [ + 118, + 303, + 489, + 317 + ], + "spans": [ + { + "bbox": [ + 118, + 303, + 473, + 317 + ], + "score": 1.0, + "content": "Table 1: Comparison with classic MTL methods. MNIST binary classification error rate", + "type": "text" + }, + { + "bbox": [ + 473, + 304, + 489, + 315 + ], + "score": 0.78, + "content": "( \\% )", + "type": "inline_equation" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 326, + 505, + 404 + ], + "lines": [ + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "As expected, the classic methods improve on STL, and they perform significantly better with CNN", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 337, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 505, + 350 + ], + "score": 1.0, + "content": "than PCA features. However, our DMTRL methods still outperform the best classic methods, even", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 347, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 505, + 362 + ], + "score": 1.0, + "content": "when they are enhanced by CNN features. This is due to soft (cf hard) sharing of the feature extrac-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 358, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 505, + 373 + ], + "score": 1.0, + "content": "tion layers and the ability of end-to-end training of both the classifier and feature extractor. Finally,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "we note that more fundamentally, the classic methods are restricted to binary problems (due to their", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "matrix-based nature) and so, unlike our tensor-based approach, they are unsuitable for multi-class", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 393, + 318, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 318, + 405 + ], + "score": 1.0, + "content": "problems like omniglot and age-group classification.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 107, + 420, + 329, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 330, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 330, + 434 + ], + "score": 1.0, + "content": "B MODEL CAPACITY AND PERFORMANCE", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "table", + "bbox": [ + 161, + 477, + 449, + 558 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 444, + 505, + 468 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 444, + 506, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 506, + 457 + ], + "score": 1.0, + "content": "We list the number of parameters for each model in the first experiment (MNIST, binary one-vs-rest", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 456, + 465, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 252, + 468 + ], + "score": 1.0, + "content": "classification) and the performance (", + "type": "text" + }, + { + "bbox": [ + 252, + 456, + 267, + 466 + ], + "score": 0.83, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 456, + 465, + 468 + ], + "score": 1.0, + "content": "training data, mean of error rate for 10-fold CV).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "table_body", + "bbox": [ + 161, + 477, + 449, + 558 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 161, + 477, + 449, + 558 + ], + "spans": [ + { + "bbox": [ + 161, + 477, + 449, + 558 + ], + "score": 0.982, + "html": "
ModelError Rate (%)Number of parametersRatio
STL11.524351K1.00
DMTRL-LAF8.251632K0.38
DMTRL-Tucker9.241740K0.40
DMTRL-TT7.312187K0.50
UD-MTL9.34436K0.10
UD-MTL-Large9.391644K0.38
", + "type": "table", + "image_path": "4f1ee70ad07989a347e57668ffe84fc239a5c6dcf46e8f69cc375648f9fca301.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 161, + 477, + 449, + 504.0 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 161, + 504.0, + 449, + 531.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 161, + 531.0, + 449, + 558.0 + ], + "spans": [], + "index": 24 + } + ] + } + ], + "index": 21.75 + }, + { + "type": "text", + "bbox": [ + 155, + 565, + 456, + 577 + ], + "lines": [ + { + "bbox": [ + 153, + 564, + 458, + 580 + ], + "spans": [ + { + "bbox": [ + 153, + 564, + 458, + 580 + ], + "score": 1.0, + "content": "Table 2: Comparison of deep models: Error rate and number of parameters.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 588, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 602 + ], + "score": 1.0, + "content": "The conventional hard-sharing method (UD-MTL) design is to share all layers except the top layer.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 244, + 612 + ], + "score": 1.0, + "content": "Its number of parameter is roughly", + "type": "text" + }, + { + "bbox": [ + 244, + 599, + 264, + 610 + ], + "score": 0.88, + "content": "1 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "of the single task learning method (STL), as most parameters", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "score": 1.0, + "content": "are shared across the 10 tasks corresponding to 10 digits. Our soft-sharing methods also significantly", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 622, + 491, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 491, + 635 + ], + "score": 1.0, + "content": "reduce the number of parameters compared to STL, but are larger than UD-MTL’s hard sharing.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 638, + 505, + 683 + ], + "lines": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "To compare our method to UD-MTL, while controlling for network capacity, we expanded UD-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "score": 1.0, + "content": "MDL by adding more hidden neurons so its number of parameter is close to our methods (denoted", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 661, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 505, + 672 + ], + "score": 1.0, + "content": "UD-MTL-Large). However UD-MDL performance does not increase. This is evidence that our", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 671, + 427, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 427, + 684 + ], + "score": 1.0, + "content": "model’s good performance is not simply due to greater capacity than UD-MTL.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31.5 + } + ], + "page_idx": 11, + "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": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 421, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 423, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 423, + 96 + ], + "score": 1.0, + "content": "A COMPARISON WITH CLASSIC (SHALLOW) MTL METHODS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 106, + 506, + 183 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 505, + 119 + ], + "score": 1.0, + "content": "We provide a comparison with classic (shallow, matrix-based) MTL methods for the first experiment", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 117, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 277, + 129 + ], + "score": 1.0, + "content": "(MNIST, binary one-vs-rest classification,", + "type": "text" + }, + { + "bbox": [ + 277, + 117, + 292, + 128 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 117, + 506, + 129 + ], + "score": 1.0, + "content": "training data, mean of error rates for 10-fold CV). A", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 141 + ], + "score": 1.0, + "content": "subtlety in making this comparison is what feature should the classic methods use? Conventionally", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 139, + 505, + 152 + ], + "spans": [ + { + "bbox": [ + 106, + 139, + 505, + 152 + ], + "score": 1.0, + "content": "they use a PCA feature (obtained by flattening the image, then dimension reduction by PCA). How-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 150, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 505, + 162 + ], + "score": 1.0, + "content": "ever for visual recognition tasks, performance is better with deep features – a key motivation for our", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 506, + 174 + ], + "score": 1.0, + "content": "focus on deep approaches to MTL. We therefore also compare the classic methods when using a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 171, + 464, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 171, + 464, + 184 + ], + "score": 1.0, + "content": "feature extracted from the penultimate layer of the CNN network used in our experiment.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 106, + 506, + 184 + ] + }, + { + "type": "table", + "bbox": [ + 178, + 193, + 433, + 295 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 178, + 193, + 433, + 295 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 178, + 193, + 433, + 295 + ], + "spans": [ + { + "bbox": [ + 178, + 193, + 433, + 295 + ], + "score": 0.98, + "html": "
ModelPCAFeatureCNNFeature
Single Task Learning16.8911.52
Evgeniou & Pontil (2004)15.2710.32
Argyriou et al. (2008)15.649.56
Kumar & Daumé I (2012)14.089.41
DMTRL-LAF-8.25
DMTRL-Tucker9.24
DMTRL-TT7.31
UD-MTL9.34
", + "type": "table", + "image_path": "a1ef0d76eea7bf0386e1248977bb3ffdda8efc45672ac4bfa9ef8491df23dd39.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 178, + 193, + 433, + 227.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 178, + 227.0, + 433, + 261.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 178, + 261.0, + 433, + 295.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 114, + 303, + 491, + 315 + ], + "lines": [ + { + "bbox": [ + 118, + 303, + 489, + 317 + ], + "spans": [ + { + "bbox": [ + 118, + 303, + 473, + 317 + ], + "score": 1.0, + "content": "Table 1: Comparison with classic MTL methods. MNIST binary classification error rate", + "type": "text" + }, + { + "bbox": [ + 473, + 304, + 489, + 315 + ], + "score": 0.78, + "content": "( \\% )", + "type": "inline_equation" + } + ], + "index": 11 + } + ], + "index": 11, + "bbox_fs": [ + 118, + 303, + 489, + 317 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 326, + 505, + 404 + ], + "lines": [ + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 339 + ], + "score": 1.0, + "content": "As expected, the classic methods improve on STL, and they perform significantly better with CNN", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 337, + 505, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 505, + 350 + ], + "score": 1.0, + "content": "than PCA features. However, our DMTRL methods still outperform the best classic methods, even", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 347, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 505, + 362 + ], + "score": 1.0, + "content": "when they are enhanced by CNN features. This is due to soft (cf hard) sharing of the feature extrac-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 358, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 358, + 505, + 373 + ], + "score": 1.0, + "content": "tion layers and the ability of end-to-end training of both the classifier and feature extractor. Finally,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "we note that more fundamentally, the classic methods are restricted to binary problems (due to their", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 394 + ], + "score": 1.0, + "content": "matrix-based nature) and so, unlike our tensor-based approach, they are unsuitable for multi-class", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 393, + 318, + 405 + ], + "spans": [ + { + "bbox": [ + 106, + 393, + 318, + 405 + ], + "score": 1.0, + "content": "problems like omniglot and age-group classification.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 326, + 505, + 405 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 420, + 329, + 433 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 330, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 330, + 434 + ], + "score": 1.0, + "content": "B MODEL CAPACITY AND PERFORMANCE", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "table", + "bbox": [ + 161, + 477, + 449, + 558 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 444, + 505, + 468 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 444, + 506, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 506, + 457 + ], + "score": 1.0, + "content": "We list the number of parameters for each model in the first experiment (MNIST, binary one-vs-rest", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 456, + 465, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 252, + 468 + ], + "score": 1.0, + "content": "classification) and the performance (", + "type": "text" + }, + { + "bbox": [ + 252, + 456, + 267, + 466 + ], + "score": 0.83, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 456, + 465, + 468 + ], + "score": 1.0, + "content": "training data, mean of error rate for 10-fold CV).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "table_body", + "bbox": [ + 161, + 477, + 449, + 558 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 161, + 477, + 449, + 558 + ], + "spans": [ + { + "bbox": [ + 161, + 477, + 449, + 558 + ], + "score": 0.982, + "html": "
ModelError Rate (%)Number of parametersRatio
STL11.524351K1.00
DMTRL-LAF8.251632K0.38
DMTRL-Tucker9.241740K0.40
DMTRL-TT7.312187K0.50
UD-MTL9.34436K0.10
UD-MTL-Large9.391644K0.38
", + "type": "table", + "image_path": "4f1ee70ad07989a347e57668ffe84fc239a5c6dcf46e8f69cc375648f9fca301.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 161, + 477, + 449, + 504.0 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 161, + 504.0, + 449, + 531.0 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 161, + 531.0, + 449, + 558.0 + ], + "spans": [], + "index": 24 + } + ] + } + ], + "index": 21.75 + }, + { + "type": "text", + "bbox": [ + 155, + 565, + 456, + 577 + ], + "lines": [ + { + "bbox": [ + 153, + 564, + 458, + 580 + ], + "spans": [ + { + "bbox": [ + 153, + 564, + 458, + 580 + ], + "score": 1.0, + "content": "Table 2: Comparison of deep models: Error rate and number of parameters.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25, + "bbox_fs": [ + 153, + 564, + 458, + 580 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 588, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 505, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 602 + ], + "score": 1.0, + "content": "The conventional hard-sharing method (UD-MTL) design is to share all layers except the top layer.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 244, + 612 + ], + "score": 1.0, + "content": "Its number of parameter is roughly", + "type": "text" + }, + { + "bbox": [ + 244, + 599, + 264, + 610 + ], + "score": 0.88, + "content": "1 0 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "of the single task learning method (STL), as most parameters", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 623 + ], + "score": 1.0, + "content": "are shared across the 10 tasks corresponding to 10 digits. Our soft-sharing methods also significantly", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 622, + 491, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 491, + 635 + ], + "score": 1.0, + "content": "reduce the number of parameters compared to STL, but are larger than UD-MTL’s hard sharing.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 587, + 505, + 635 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 638, + 505, + 683 + ], + "lines": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 651 + ], + "score": 1.0, + "content": "To compare our method to UD-MTL, while controlling for network capacity, we expanded UD-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 506, + 662 + ], + "score": 1.0, + "content": "MDL by adding more hidden neurons so its number of parameter is close to our methods (denoted", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 661, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 505, + 672 + ], + "score": 1.0, + "content": "UD-MTL-Large). However UD-MDL performance does not increase. This is evidence that our", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 671, + 427, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 427, + 684 + ], + "score": 1.0, + "content": "model’s good performance is not simply due to greater capacity than UD-MTL.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 638, + 506, + 684 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file