diff --git "a/parse/train/SkNQeiRpb/SkNQeiRpb_middle.json" "b/parse/train/SkNQeiRpb/SkNQeiRpb_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/SkNQeiRpb/SkNQeiRpb_middle.json" @@ -0,0 +1,21442 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "TRAINING DEEP AUTOENCODERS FOR RECOM-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 246, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 246, + 117 + ], + "score": 1.0, + "content": "MENDER SYSTEMS", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 136, + 244, + 157 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 278, + 187, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "spans": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 217, + 468, + 338 + ], + "lines": [ + { + "bbox": [ + 142, + 217, + 470, + 230 + ], + "spans": [ + { + "bbox": [ + 142, + 217, + 470, + 230 + ], + "score": 1.0, + "content": "This paper proposes a new model for the rating prediction task in recommender", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 228, + 470, + 241 + ], + "spans": [ + { + "bbox": [ + 141, + 228, + 470, + 241 + ], + "score": 1.0, + "content": "systems which significantly outperforms previous state-of-the art models on a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 239, + 470, + 252 + ], + "spans": [ + { + "bbox": [ + 141, + 239, + 470, + 252 + ], + "score": 1.0, + "content": "time-split Netflix data set. Our model is based on deep autoencoder with 6 lay-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 251, + 469, + 262 + ], + "spans": [ + { + "bbox": [ + 141, + 251, + 469, + 262 + ], + "score": 1.0, + "content": "ers and is trained end-to-end without any layer-wise pre-training. We empirically", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 261, + 469, + 273 + ], + "spans": [ + { + "bbox": [ + 142, + 261, + 469, + 273 + ], + "score": 1.0, + "content": "demonstrate that: a) deep autoencoder models generalize much better than the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 272, + 470, + 284 + ], + "spans": [ + { + "bbox": [ + 141, + 272, + 470, + 284 + ], + "score": 1.0, + "content": "shallow ones, b) non-linear activation functions with negative parts are crucial", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 283, + 470, + 296 + ], + "spans": [ + { + "bbox": [ + 141, + 283, + 470, + 296 + ], + "score": 1.0, + "content": "for training deep models, and c) heavy use of regularization techniques such as", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 294, + 470, + 307 + ], + "spans": [ + { + "bbox": [ + 141, + 294, + 470, + 307 + ], + "score": 1.0, + "content": "dropout is necessary to prevent overfitting. We also propose a new training al-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 306, + 470, + 317 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 470, + 317 + ], + "score": 1.0, + "content": "gorithm based on iterative output re-feeding to overcome natural sparseness of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 316, + 469, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 316, + 469, + 329 + ], + "score": 1.0, + "content": "collaborate filtering. The new algorithm significantly speeds up training and im-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 328, + 256, + 339 + ], + "spans": [ + { + "bbox": [ + 141, + 328, + 256, + 339 + ], + "score": 1.0, + "content": "proves model performance.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 108, + 374, + 206, + 387 + ], + "lines": [ + { + "bbox": [ + 105, + 373, + 208, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 208, + 390 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 504, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 404, + 504, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 504, + 417 + ], + "score": 1.0, + "content": "Sites like Amazon, Netflix and Spotify use recommender systems to suggest items to users. Recom-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "score": 1.0, + "content": "mender systems can be divided into two categories: context-based and personalized recommenda-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 426, + 132, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 132, + 439 + ], + "score": 1.0, + "content": "tions.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 509 + ], + "lines": [ + { + "bbox": [ + 105, + 443, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 505, + 456 + ], + "score": 1.0, + "content": "Context based recommendations take into account contextual factors such as location, date and time", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "score": 1.0, + "content": "(Adomavicius & Tuzhilin, 2011). Personalized recommendations typically suggest items to users", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 465, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 505, + 478 + ], + "score": 1.0, + "content": "using the collaborative filtering (CF) approach. In this approach the user’s interests are predicted", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 475, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 505, + 491 + ], + "score": 1.0, + "content": "based on the analysis of tastes and preference of other users in the system and implicitly inferring", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "“similarity” between them. The underlying assumption is that two people who have similar tastes,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 498, + 500, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 500, + 511 + ], + "score": 1.0, + "content": "have a higher likelihood of having the same opinion on an item than two randomly chosen people.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 515, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 506, + 527 + ], + "score": 1.0, + "content": "In designing recommender systems, the goal is to improve the accuracy of predictions. The Netflix", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 525, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 538 + ], + "score": 1.0, + "content": "Prize contest provides the most famous example of this problem (Bennett et al., 2007): Netflix held", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 537, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 506, + 550 + ], + "score": 1.0, + "content": "the Netflix Prize to substantially improve the accuracy of the algorithm to predict user ratings for", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 547, + 504, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 439, + 562 + ], + "score": 1.0, + "content": "films. This is a classic CF problem: Infer the missing entries in an mxn matrix,", + "type": "text" + }, + { + "bbox": [ + 440, + 549, + 449, + 559 + ], + "score": 0.69, + "content": "R", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 547, + 482, + 562 + ], + "score": 1.0, + "content": ", whose", + "type": "text" + }, + { + "bbox": [ + 483, + 548, + 504, + 560 + ], + "score": 0.91, + "content": "( i , j )", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 559, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 324, + 572 + ], + "score": 1.0, + "content": "entry describes the ratings given by the ith user to the", + "type": "text" + }, + { + "bbox": [ + 325, + 560, + 330, + 571 + ], + "score": 0.53, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 559, + 506, + 572 + ], + "score": 1.0, + "content": "th item. The performance is then measured", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 571, + 273, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 273, + 582 + ], + "score": 1.0, + "content": "using Root Mean Squared Error (RMSE).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 697 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "Training very deep autoencoders is non trivial both from optimization and regularization points of", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "score": 1.0, + "content": "view. Early works on training auto-enocoders adapted layer-wise pre-training to solve optimiza-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "tion issues (Hinton & Salakhutdinov, 2006). In this work, we empirically show that optimization", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 619, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 104, + 619, + 505, + 633 + ], + "score": 1.0, + "content": "difficulties of training deep autoencoders can be solved by using scaled exponential linear units", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 107, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 107, + 631, + 140, + 642 + ], + "score": 0.39, + "content": "( S E L U s ,", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ")(Klambauer et al., 2017). This enables training without any layer-wise pre-training or resid-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 641, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 656 + ], + "score": 1.0, + "content": "ual connections. Since publicly available data sets for CF are relatively small, sufficiently large", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "score": 1.0, + "content": "models can easily overfit. To prevent overfitting we employ heavy dropout with drop probability as", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "score": 1.0, + "content": "high as 0.8. We also introduce a new output re-feeding training algorithm which helps to bypass", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 674, + 506, + 687 + ], + "spans": [ + { + "bbox": [ + 104, + 674, + 506, + 687 + ], + "score": 1.0, + "content": "the natural sparseness of updates in collaborative filtering and helps to further improve the model", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 162, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 162, + 698 + ], + "score": 1.0, + "content": "performance.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 36.5 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 722, + 361, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 720, + 362, + 733 + ], + "spans": [ + { + "bbox": [ + 119, + 720, + 362, + 733 + ], + "score": 1.0, + "content": "1Our code is available at https://github.com/Anonymous", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "TRAINING DEEP AUTOENCODERS FOR RECOM-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 246, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 246, + 117 + ], + "score": 1.0, + "content": "MENDER SYSTEMS", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 136, + 244, + 157 + ], + "lines": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "spans": [ + { + "bbox": [ + 113, + 136, + 201, + 147 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "spans": [ + { + "bbox": [ + 112, + 146, + 245, + 159 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 112, + 136, + 245, + 159 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 187, + 333, + 199 + ], + "lines": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "spans": [ + { + "bbox": [ + 276, + 186, + 335, + 200 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 217, + 468, + 338 + ], + "lines": [ + { + "bbox": [ + 142, + 217, + 470, + 230 + ], + "spans": [ + { + "bbox": [ + 142, + 217, + 470, + 230 + ], + "score": 1.0, + "content": "This paper proposes a new model for the rating prediction task in recommender", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 228, + 470, + 241 + ], + "spans": [ + { + "bbox": [ + 141, + 228, + 470, + 241 + ], + "score": 1.0, + "content": "systems which significantly outperforms previous state-of-the art models on a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 239, + 470, + 252 + ], + "spans": [ + { + "bbox": [ + 141, + 239, + 470, + 252 + ], + "score": 1.0, + "content": "time-split Netflix data set. Our model is based on deep autoencoder with 6 lay-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 251, + 469, + 262 + ], + "spans": [ + { + "bbox": [ + 141, + 251, + 469, + 262 + ], + "score": 1.0, + "content": "ers and is trained end-to-end without any layer-wise pre-training. We empirically", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 261, + 469, + 273 + ], + "spans": [ + { + "bbox": [ + 142, + 261, + 469, + 273 + ], + "score": 1.0, + "content": "demonstrate that: a) deep autoencoder models generalize much better than the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 272, + 470, + 284 + ], + "spans": [ + { + "bbox": [ + 141, + 272, + 470, + 284 + ], + "score": 1.0, + "content": "shallow ones, b) non-linear activation functions with negative parts are crucial", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 283, + 470, + 296 + ], + "spans": [ + { + "bbox": [ + 141, + 283, + 470, + 296 + ], + "score": 1.0, + "content": "for training deep models, and c) heavy use of regularization techniques such as", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 294, + 470, + 307 + ], + "spans": [ + { + "bbox": [ + 141, + 294, + 470, + 307 + ], + "score": 1.0, + "content": "dropout is necessary to prevent overfitting. We also propose a new training al-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 306, + 470, + 317 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 470, + 317 + ], + "score": 1.0, + "content": "gorithm based on iterative output re-feeding to overcome natural sparseness of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 316, + 469, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 316, + 469, + 329 + ], + "score": 1.0, + "content": "collaborate filtering. The new algorithm significantly speeds up training and im-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 328, + 256, + 339 + ], + "spans": [ + { + "bbox": [ + 141, + 328, + 256, + 339 + ], + "score": 1.0, + "content": "proves model performance.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 10, + "bbox_fs": [ + 141, + 217, + 470, + 339 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 374, + 206, + 387 + ], + "lines": [ + { + "bbox": [ + 105, + 373, + 208, + 390 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 208, + 390 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 504, + 437 + ], + "lines": [ + { + "bbox": [ + 105, + 404, + 504, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 504, + 417 + ], + "score": 1.0, + "content": "Sites like Amazon, Netflix and Spotify use recommender systems to suggest items to users. Recom-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "spans": [ + { + "bbox": [ + 106, + 416, + 504, + 428 + ], + "score": 1.0, + "content": "mender systems can be divided into two categories: context-based and personalized recommenda-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 426, + 132, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 132, + 439 + ], + "score": 1.0, + "content": "tions.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 404, + 504, + 439 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 443, + 505, + 509 + ], + "lines": [ + { + "bbox": [ + 105, + 443, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 505, + 456 + ], + "score": 1.0, + "content": "Context based recommendations take into account contextual factors such as location, date and time", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "score": 1.0, + "content": "(Adomavicius & Tuzhilin, 2011). Personalized recommendations typically suggest items to users", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 465, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 505, + 478 + ], + "score": 1.0, + "content": "using the collaborative filtering (CF) approach. In this approach the user’s interests are predicted", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 475, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 505, + 491 + ], + "score": 1.0, + "content": "based on the analysis of tastes and preference of other users in the system and implicitly inferring", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 505, + 500 + ], + "score": 1.0, + "content": "“similarity” between them. The underlying assumption is that two people who have similar tastes,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 498, + 500, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 500, + 511 + ], + "score": 1.0, + "content": "have a higher likelihood of having the same opinion on an item than two randomly chosen people.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 443, + 505, + 511 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 515, + 504, + 581 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 506, + 527 + ], + "score": 1.0, + "content": "In designing recommender systems, the goal is to improve the accuracy of predictions. The Netflix", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 525, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 538 + ], + "score": 1.0, + "content": "Prize contest provides the most famous example of this problem (Bennett et al., 2007): Netflix held", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 537, + 506, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 506, + 550 + ], + "score": 1.0, + "content": "the Netflix Prize to substantially improve the accuracy of the algorithm to predict user ratings for", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 547, + 504, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 439, + 562 + ], + "score": 1.0, + "content": "films. This is a classic CF problem: Infer the missing entries in an mxn matrix,", + "type": "text" + }, + { + "bbox": [ + 440, + 549, + 449, + 559 + ], + "score": 0.69, + "content": "R", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 547, + 482, + 562 + ], + "score": 1.0, + "content": ", whose", + "type": "text" + }, + { + "bbox": [ + 483, + 548, + 504, + 560 + ], + "score": 0.91, + "content": "( i , j )", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 559, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 324, + 572 + ], + "score": 1.0, + "content": "entry describes the ratings given by the ith user to the", + "type": "text" + }, + { + "bbox": [ + 325, + 560, + 330, + 571 + ], + "score": 0.53, + "content": "j", + "type": "inline_equation" + }, + { + "bbox": [ + 331, + 559, + 506, + 572 + ], + "score": 1.0, + "content": "th item. The performance is then measured", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 571, + 273, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 273, + 582 + ], + "score": 1.0, + "content": "using Root Mean Squared Error (RMSE).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 515, + 506, + 582 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 505, + 697 + ], + "lines": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 599 + ], + "score": 1.0, + "content": "Training very deep autoencoders is non trivial both from optimization and regularization points of", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 611 + ], + "score": 1.0, + "content": "view. Early works on training auto-enocoders adapted layer-wise pre-training to solve optimiza-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "tion issues (Hinton & Salakhutdinov, 2006). In this work, we empirically show that optimization", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 619, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 104, + 619, + 505, + 633 + ], + "score": 1.0, + "content": "difficulties of training deep autoencoders can be solved by using scaled exponential linear units", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 107, + 631, + 505, + 644 + ], + "spans": [ + { + "bbox": [ + 107, + 631, + 140, + 642 + ], + "score": 0.39, + "content": "( S E L U s ,", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 631, + 505, + 644 + ], + "score": 1.0, + "content": ")(Klambauer et al., 2017). This enables training without any layer-wise pre-training or resid-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 641, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 656 + ], + "score": 1.0, + "content": "ual connections. Since publicly available data sets for CF are relatively small, sufficiently large", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 505, + 666 + ], + "score": 1.0, + "content": "models can easily overfit. To prevent overfitting we employ heavy dropout with drop probability as", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "score": 1.0, + "content": "high as 0.8. We also introduce a new output re-feeding training algorithm which helps to bypass", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 674, + 506, + 687 + ], + "spans": [ + { + "bbox": [ + 104, + 674, + 506, + 687 + ], + "score": 1.0, + "content": "the natural sparseness of updates in collaborative filtering and helps to further improve the model", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 687, + 162, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 162, + 698 + ], + "score": 1.0, + "content": "performance.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 36.5, + "bbox_fs": [ + 104, + 588, + 506, + 698 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 200, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 203, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 203, + 95 + ], + "score": 1.0, + "content": "1.1 RELATED WORK", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 111, + 505, + 232 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "score": 1.0, + "content": "Deep learning (LeCun et al., 2015) has led to breakthroughs in image recognition, natural language", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 122, + 506, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 506, + 136 + ], + "score": 1.0, + "content": "understanding, and reinforcement learning. Naturally, these successes fuel an interest for using", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 133, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 505, + 146 + ], + "score": 1.0, + "content": "deep learning in recommender systems. First attempts at using deep learning for recommender", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 144, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 157 + ], + "score": 1.0, + "content": "systems involved restricted Boltzman machines (RBM) (Salakhutdinov et al., 2007). Several re-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 155, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 155, + 506, + 168 + ], + "score": 1.0, + "content": "cent approaches use autoencoders (Sedhain et al., 2015; Strub & Mary, 2015), feed-forward neural", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 167, + 506, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 179 + ], + "score": 1.0, + "content": "networks (He et al., 2017), neural autoregressive architectures (Zheng et al., 2016) and recurrent", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "recommender networks (Wu et al., 2017). Many popular matrix factorization techniques can be", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "score": 1.0, + "content": "thought of as a form of dimensionality reduction. It is, therefore, natural to adapt deep autoencoders", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 356, + 212 + ], + "score": 1.0, + "content": "for this task as well. I-AutoRec (item-based autoencoder) and", + "type": "text" + }, + { + "bbox": [ + 356, + 200, + 364, + 209 + ], + "score": 0.41, + "content": "U _ { ☉ }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "-AutoRec (user-based autoencoder)", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "score": 1.0, + "content": "are first successful attempts to do so Sedhain et al. (2015). Stacked de-noising autoencoders has", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 222, + 411, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 222, + 411, + 233 + ], + "score": 1.0, + "content": "been sucesfully used on this task as well (Li et al., 2015; Wang et al., 2015).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 337 + ], + "lines": [ + { + "bbox": [ + 106, + 238, + 504, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 504, + 250 + ], + "score": 1.0, + "content": "There are many non deep learning types of approaches to collaborative filtering (CF) (Breese et al.,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 248, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 262 + ], + "score": 1.0, + "content": "1998; Ricci et al., 2011). Matrix factorization techniques, such as alternating least squares (ALS)", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "(Kim & Park, 2008; Koren et al., 2009) and probabilistic matrix factorization (Mnih & Salakhutdi-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "score": 1.0, + "content": "nov, 2008) are particularly popular. The most robust systems may incorporate several ideas together", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "such as the winning solution to the Netflix Prize competition (Koren, 2009). Note that Netflix Prize", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 292, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 292, + 505, + 306 + ], + "score": 1.0, + "content": "data also includes temporal signal - time when each rating has been made. Thus, several classic", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 465, + 316 + ], + "score": 1.0, + "content": "CF approaches has been extended to incorporate temporal information such as TimeSVD", + "type": "text" + }, + { + "bbox": [ + 465, + 304, + 477, + 314 + ], + "score": 0.55, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "Koren", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "score": 1.0, + "content": "(2010), as well as more recent RNN-based techniques such as recurrent recommender networks Wu", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 326, + 159, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 159, + 337 + ], + "score": 1.0, + "content": "et al. (2017).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16 + }, + { + "type": "title", + "bbox": [ + 107, + 374, + 164, + 387 + ], + "lines": [ + { + "bbox": [ + 104, + 371, + 167, + 389 + ], + "spans": [ + { + "bbox": [ + 104, + 371, + 167, + 389 + ], + "score": 1.0, + "content": "2 MODEL", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 456 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 210, + 424 + ], + "score": 1.0, + "content": "Our model is inspired by", + "type": "text" + }, + { + "bbox": [ + 211, + 412, + 219, + 421 + ], + "score": 0.47, + "content": "U", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "-AutoRec approach with several important distinctions. We train much", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "deeper models. To enable this without any pre-training, we: a) use “scaled exponential linear units”", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "score": 1.0, + "content": "(SELUs) Klambauer et al. (2017), b) use high dropout rates, and d) use iterative output re-feeding", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 444, + 172, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 172, + 459 + ], + "score": 1.0, + "content": "during training.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 424, + 474 + ], + "score": 1.0, + "content": "An autoencoder is a network which implements two transformations - encoder", + "type": "text" + }, + { + "bbox": [ + 424, + 461, + 505, + 474 + ], + "score": 0.86, + "content": "e n c o d e ( x ) : R ^ { n } \\to", + "type": "inline_equation" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 107, + 472, + 120, + 483 + ], + "score": 0.87, + "content": "R ^ { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 471, + 138, + 486 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 138, + 472, + 234, + 484 + ], + "score": 0.81, + "content": "d e c o d e r ( z ) : R ^ { d } \\to R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 471, + 388, + 486 + ], + "score": 1.0, + "content": ". The “goal” of autoenoder is to obtain", + "type": "text" + }, + { + "bbox": [ + 388, + 473, + 394, + 482 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "dimensional representation", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 280, + 496 + ], + "score": 1.0, + "content": "of data such that an error measure between", + "type": "text" + }, + { + "bbox": [ + 280, + 485, + 287, + 493 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 484, + 305, + 496 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 306, + 483, + 419, + 496 + ], + "score": 0.9, + "content": "f ( x ) = d e c o d e ( e n c o d e ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 484, + 505, + 496 + ], + "score": 1.0, + "content": "is minimized Hinton", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 493, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 508 + ], + "score": 1.0, + "content": "& Zemel (1994). Figure 1 depicts typical 4-layer autoencoder network. If noise is added to the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "data during encoding step, the autoencoder is called de-noising. Autoencoder is an excellent tool", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "score": 1.0, + "content": "for dimensionality reduction and can be thought of as a strict generalization of principle component", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 527, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 506, + 540 + ], + "score": 1.0, + "content": "analysis (PCA) Hinton & Salakhutdinov (2006). An autoencoder without non-linear activations", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "and only with “code” layer should be able to learn PCA transformation in the encoder if trained to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 550, + 272, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 272, + 561 + ], + "score": 1.0, + "content": "optimize mean squared error (MSE) loss.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 505, + 632 + ], + "lines": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "In our model, both encoder and decoder parts of the autoencoder consist of feed-forward neural", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 577, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 338, + 589 + ], + "score": 1.0, + "content": "networks with classical fully connected layers computing", + "type": "text" + }, + { + "bbox": [ + 338, + 577, + 412, + 589 + ], + "score": 0.92, + "content": "l = f ( W * x + b )", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 577, + 443, + 589 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 443, + 578, + 450, + 588 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 577, + 505, + 589 + ], + "score": 1.0, + "content": "is some non-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "linear activation function. If range of the activation function is smaller than that of data, the last layer", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 486, + 612 + ], + "score": 1.0, + "content": "of the decoder should be kept linear. We found it to be very important for activation function", + "type": "text" + }, + { + "bbox": [ + 486, + 599, + 493, + 611 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "in", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "score": 1.0, + "content": "hidden layers to contain non-zero negative part, and we use SELU units in most of our experiments", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 621, + 220, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 220, + 633 + ], + "score": 1.0, + "content": "(see Section 3.2 for details).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 107, + 638, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 650 + ], + "score": 1.0, + "content": "If decoder mirrors encoder architecture (as it does in our model), then one can constrain decoder’s", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 648, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 140, + 661 + ], + "score": 1.0, + "content": "weights", + "type": "text" + }, + { + "bbox": [ + 141, + 648, + 156, + 661 + ], + "score": 0.91, + "content": "\\boldsymbol { W } _ { d } ^ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 648, + 333, + 661 + ], + "score": 1.0, + "content": "to be equal to transposed encoder weights", + "type": "text" + }, + { + "bbox": [ + 333, + 648, + 348, + 661 + ], + "score": 0.91, + "content": "W _ { e } ^ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 648, + 471, + 661 + ], + "score": 1.0, + "content": "from the corresponding layer", + "type": "text" + }, + { + "bbox": [ + 471, + 649, + 476, + 659 + ], + "score": 0.49, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 648, + 506, + 661 + ], + "score": 1.0, + "content": ". Such", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "score": 1.0, + "content": "autoencoder is called constrained or tied and has almost two times less free parameters than uncon-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 671, + 160, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 160, + 682 + ], + "score": 1.0, + "content": "strained one.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Forward pass and inference. During forward pass (and inference) the model takes user represented", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 289, + 711 + ], + "score": 1.0, + "content": "by his vector of ratings from the training set", + "type": "text" + }, + { + "bbox": [ + 289, + 699, + 322, + 709 + ], + "score": 0.89, + "content": "x \\in R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 698, + 354, + 711 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 355, + 701, + 362, + 709 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 698, + 487, + 711 + ], + "score": 1.0, + "content": "is number of items. Note that", + "type": "text" + }, + { + "bbox": [ + 487, + 700, + 494, + 709 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 285, + 721 + ], + "score": 1.0, + "content": "very sparse, while the output of the decoder,", + "type": "text" + }, + { + "bbox": [ + 285, + 710, + 330, + 722 + ], + "score": 0.92, + "content": "f ( x ) \\in R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 710, + 506, + 721 + ], + "score": 1.0, + "content": "is dense and contains rating predictions for", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 200, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 200, + 733 + ], + "score": 1.0, + "content": "all items in the corpus.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 200, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 203, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 203, + 95 + ], + "score": 1.0, + "content": "1.1 RELATED WORK", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 111, + 505, + 232 + ], + "lines": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 110, + 505, + 125 + ], + "score": 1.0, + "content": "Deep learning (LeCun et al., 2015) has led to breakthroughs in image recognition, natural language", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 122, + 506, + 136 + ], + "spans": [ + { + "bbox": [ + 105, + 122, + 506, + 136 + ], + "score": 1.0, + "content": "understanding, and reinforcement learning. Naturally, these successes fuel an interest for using", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 133, + 505, + 146 + ], + "spans": [ + { + "bbox": [ + 105, + 133, + 505, + 146 + ], + "score": 1.0, + "content": "deep learning in recommender systems. First attempts at using deep learning for recommender", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 144, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 157 + ], + "score": 1.0, + "content": "systems involved restricted Boltzman machines (RBM) (Salakhutdinov et al., 2007). Several re-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 155, + 506, + 168 + ], + "spans": [ + { + "bbox": [ + 105, + 155, + 506, + 168 + ], + "score": 1.0, + "content": "cent approaches use autoencoders (Sedhain et al., 2015; Strub & Mary, 2015), feed-forward neural", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 167, + 506, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 179 + ], + "score": 1.0, + "content": "networks (He et al., 2017), neural autoregressive architectures (Zheng et al., 2016) and recurrent", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "recommender networks (Wu et al., 2017). Many popular matrix factorization techniques can be", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 201 + ], + "score": 1.0, + "content": "thought of as a form of dimensionality reduction. It is, therefore, natural to adapt deep autoencoders", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 199, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 356, + 212 + ], + "score": 1.0, + "content": "for this task as well. I-AutoRec (item-based autoencoder) and", + "type": "text" + }, + { + "bbox": [ + 356, + 200, + 364, + 209 + ], + "score": 0.41, + "content": "U _ { ☉ }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 199, + 505, + 212 + ], + "score": 1.0, + "content": "-AutoRec (user-based autoencoder)", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 505, + 222 + ], + "score": 1.0, + "content": "are first successful attempts to do so Sedhain et al. (2015). Stacked de-noising autoencoders has", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 222, + 411, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 222, + 411, + 233 + ], + "score": 1.0, + "content": "been sucesfully used on this task as well (Li et al., 2015; Wang et al., 2015).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 110, + 506, + 233 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 337 + ], + "lines": [ + { + "bbox": [ + 106, + 238, + 504, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 504, + 250 + ], + "score": 1.0, + "content": "There are many non deep learning types of approaches to collaborative filtering (CF) (Breese et al.,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 248, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 248, + 505, + 262 + ], + "score": 1.0, + "content": "1998; Ricci et al., 2011). Matrix factorization techniques, such as alternating least squares (ALS)", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 259, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 505, + 273 + ], + "score": 1.0, + "content": "(Kim & Park, 2008; Koren et al., 2009) and probabilistic matrix factorization (Mnih & Salakhutdi-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 505, + 283 + ], + "score": 1.0, + "content": "nov, 2008) are particularly popular. The most robust systems may incorporate several ideas together", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "such as the winning solution to the Netflix Prize competition (Koren, 2009). Note that Netflix Prize", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 292, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 292, + 505, + 306 + ], + "score": 1.0, + "content": "data also includes temporal signal - time when each rating has been made. Thus, several classic", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 303, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 465, + 316 + ], + "score": 1.0, + "content": "CF approaches has been extended to incorporate temporal information such as TimeSVD", + "type": "text" + }, + { + "bbox": [ + 465, + 304, + 477, + 314 + ], + "score": 0.55, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 303, + 506, + 316 + ], + "score": 1.0, + "content": "Koren", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 506, + 327 + ], + "score": 1.0, + "content": "(2010), as well as more recent RNN-based techniques such as recurrent recommender networks Wu", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 326, + 159, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 159, + 337 + ], + "score": 1.0, + "content": "et al. (2017).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 238, + 506, + 337 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 374, + 164, + 387 + ], + "lines": [ + { + "bbox": [ + 104, + 371, + 167, + 389 + ], + "spans": [ + { + "bbox": [ + 104, + 371, + 167, + 389 + ], + "score": 1.0, + "content": "2 MODEL", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 456 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 210, + 424 + ], + "score": 1.0, + "content": "Our model is inspired by", + "type": "text" + }, + { + "bbox": [ + 211, + 412, + 219, + 421 + ], + "score": 0.47, + "content": "U", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 411, + 505, + 424 + ], + "score": 1.0, + "content": "-AutoRec approach with several important distinctions. We train much", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 505, + 435 + ], + "score": 1.0, + "content": "deeper models. To enable this without any pre-training, we: a) use “scaled exponential linear units”", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 505, + 447 + ], + "score": 1.0, + "content": "(SELUs) Klambauer et al. (2017), b) use high dropout rates, and d) use iterative output re-feeding", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 444, + 172, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 444, + 172, + 459 + ], + "score": 1.0, + "content": "during training.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 411, + 505, + 459 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 424, + 474 + ], + "score": 1.0, + "content": "An autoencoder is a network which implements two transformations - encoder", + "type": "text" + }, + { + "bbox": [ + 424, + 461, + 505, + 474 + ], + "score": 0.86, + "content": "e n c o d e ( x ) : R ^ { n } \\to", + "type": "inline_equation" + } + ], + "index": 26 + }, + { + "bbox": [ + 107, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 107, + 472, + 120, + 483 + ], + "score": 0.87, + "content": "R ^ { d }", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 471, + 138, + 486 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 138, + 472, + 234, + 484 + ], + "score": 0.81, + "content": "d e c o d e r ( z ) : R ^ { d } \\to R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 471, + 388, + 486 + ], + "score": 1.0, + "content": ". The “goal” of autoenoder is to obtain", + "type": "text" + }, + { + "bbox": [ + 388, + 473, + 394, + 482 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "dimensional representation", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 280, + 496 + ], + "score": 1.0, + "content": "of data such that an error measure between", + "type": "text" + }, + { + "bbox": [ + 280, + 485, + 287, + 493 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 484, + 305, + 496 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 306, + 483, + 419, + 496 + ], + "score": 0.9, + "content": "f ( x ) = d e c o d e ( e n c o d e ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 484, + 505, + 496 + ], + "score": 1.0, + "content": "is minimized Hinton", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 493, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 508 + ], + "score": 1.0, + "content": "& Zemel (1994). Figure 1 depicts typical 4-layer autoencoder network. If noise is added to the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 504, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 519 + ], + "score": 1.0, + "content": "data during encoding step, the autoencoder is called de-noising. Autoencoder is an excellent tool", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "spans": [ + { + "bbox": [ + 106, + 517, + 505, + 529 + ], + "score": 1.0, + "content": "for dimensionality reduction and can be thought of as a strict generalization of principle component", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 527, + 506, + 540 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 506, + 540 + ], + "score": 1.0, + "content": "analysis (PCA) Hinton & Salakhutdinov (2006). An autoencoder without non-linear activations", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "and only with “code” layer should be able to learn PCA transformation in the encoder if trained to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 550, + 272, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 272, + 561 + ], + "score": 1.0, + "content": "optimize mean squared error (MSE) loss.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 461, + 506, + 561 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 505, + 632 + ], + "lines": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "In our model, both encoder and decoder parts of the autoencoder consist of feed-forward neural", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 577, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 338, + 589 + ], + "score": 1.0, + "content": "networks with classical fully connected layers computing", + "type": "text" + }, + { + "bbox": [ + 338, + 577, + 412, + 589 + ], + "score": 0.92, + "content": "l = f ( W * x + b )", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 577, + 443, + 589 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 443, + 578, + 450, + 588 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 451, + 577, + 505, + 589 + ], + "score": 1.0, + "content": "is some non-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "linear activation function. If range of the activation function is smaller than that of data, the last layer", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 486, + 612 + ], + "score": 1.0, + "content": "of the decoder should be kept linear. We found it to be very important for activation function", + "type": "text" + }, + { + "bbox": [ + 486, + 599, + 493, + 611 + ], + "score": 0.84, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "in", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 623 + ], + "score": 1.0, + "content": "hidden layers to contain non-zero negative part, and we use SELU units in most of our experiments", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 621, + 220, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 220, + 633 + ], + "score": 1.0, + "content": "(see Section 3.2 for details).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 37.5, + "bbox_fs": [ + 105, + 565, + 505, + 633 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 638, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 637, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 650 + ], + "score": 1.0, + "content": "If decoder mirrors encoder architecture (as it does in our model), then one can constrain decoder’s", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 648, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 140, + 661 + ], + "score": 1.0, + "content": "weights", + "type": "text" + }, + { + "bbox": [ + 141, + 648, + 156, + 661 + ], + "score": 0.91, + "content": "\\boldsymbol { W } _ { d } ^ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 648, + 333, + 661 + ], + "score": 1.0, + "content": "to be equal to transposed encoder weights", + "type": "text" + }, + { + "bbox": [ + 333, + 648, + 348, + 661 + ], + "score": 0.91, + "content": "W _ { e } ^ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 648, + 471, + 661 + ], + "score": 1.0, + "content": "from the corresponding layer", + "type": "text" + }, + { + "bbox": [ + 471, + 649, + 476, + 659 + ], + "score": 0.49, + "content": "l", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 648, + 506, + 661 + ], + "score": 1.0, + "content": ". Such", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "score": 1.0, + "content": "autoencoder is called constrained or tied and has almost two times less free parameters than uncon-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 671, + 160, + 682 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 160, + 682 + ], + "score": 1.0, + "content": "strained one.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 637, + 506, + 682 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "Forward pass and inference. During forward pass (and inference) the model takes user represented", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 289, + 711 + ], + "score": 1.0, + "content": "by his vector of ratings from the training set", + "type": "text" + }, + { + "bbox": [ + 289, + 699, + 322, + 709 + ], + "score": 0.89, + "content": "x \\in R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 698, + 354, + 711 + ], + "score": 1.0, + "content": ", where", + "type": "text" + }, + { + "bbox": [ + 355, + 701, + 362, + 709 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 698, + 487, + 711 + ], + "score": 1.0, + "content": "is number of items. Note that", + "type": "text" + }, + { + "bbox": [ + 487, + 700, + 494, + 709 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 285, + 721 + ], + "score": 1.0, + "content": "very sparse, while the output of the decoder,", + "type": "text" + }, + { + "bbox": [ + 285, + 710, + 330, + 722 + ], + "score": 0.92, + "content": "f ( x ) \\in R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 330, + 710, + 506, + 721 + ], + "score": 1.0, + "content": "is dense and contains rating predictions for", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 720, + 200, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 200, + 733 + ], + "score": 1.0, + "content": "all items in the corpus.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 687, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 82, + 201, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 202, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 202, + 95 + ], + "score": 1.0, + "content": "2.1 LOSS FUNCTION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 105, + 103, + 504, + 126 + ], + "lines": [ + { + "bbox": [ + 106, + 103, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 103, + 400, + 115 + ], + "score": 1.0, + "content": "Since it doesn’t make sense to predict zeros in user’s representation vector", + "type": "text" + }, + { + "bbox": [ + 400, + 106, + 407, + 113 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 103, + 505, + 115 + ], + "score": 1.0, + "content": ", we follow the approach", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 113, + 407, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 407, + 127 + ], + "score": 1.0, + "content": "from Sedhain et al. (2015) and optimize Masked Mean Squared Error loss:", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5 + }, + { + "type": "interline_equation", + "bbox": [ + 247, + 130, + 364, + 161 + ], + "lines": [ + { + "bbox": [ + 247, + 130, + 364, + 161 + ], + "spans": [ + { + "bbox": [ + 247, + 130, + 364, + 161 + ], + "score": 0.95, + "content": "M M S E = \\frac { m _ { i } * ( r _ { i } - y _ { i } ) ^ { 2 } } { \\sum _ { i = 0 } ^ { i = n } m _ { i } }", + "type": "interline_equation", + "image_path": "1897d4b1db1749e191b172c3dd7d98ae749d38dd07fd68a752082ec3404f525a.jpg" + } + ] + } + ], + "index": 3.5, + "virtual_lines": [ + { + "bbox": [ + 247, + 130, + 364, + 145.5 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 247, + 145.5, + 364, + 161.0 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 164, + 504, + 199 + ], + "lines": [ + { + "bbox": [ + 106, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 133, + 177 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 167, + 142, + 176 + ], + "score": 0.86, + "content": "r _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 164, + 206, + 177 + ], + "score": 1.0, + "content": "is actual rating,", + "type": "text" + }, + { + "bbox": [ + 206, + 167, + 215, + 176 + ], + "score": 0.85, + "content": "y _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 164, + 378, + 177 + ], + "score": 1.0, + "content": "is reconstructed, or predicted rating, and", + "type": "text" + }, + { + "bbox": [ + 379, + 166, + 392, + 176 + ], + "score": 0.87, + "content": "m _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "is a mask function such that", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 176, + 506, + 187 + ], + "spans": [ + { + "bbox": [ + 107, + 177, + 140, + 187 + ], + "score": 0.91, + "content": "m _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 176, + 150, + 187 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 150, + 176, + 180, + 187 + ], + "score": 0.91, + "content": "r _ { i } \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 176, + 199, + 187 + ], + "score": 1.0, + "content": "else", + "type": "text" + }, + { + "bbox": [ + 199, + 177, + 232, + 187 + ], + "score": 0.89, + "content": "m _ { i } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 176, + 506, + 187 + ], + "score": 1.0, + "content": ". Note that there is a straightforward relation between RMSE score", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 187, + 277, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 182, + 199 + ], + "score": 1.0, + "content": "and MMSE score:", + "type": "text" + }, + { + "bbox": [ + 182, + 187, + 274, + 199 + ], + "score": 0.9, + "content": "R M S E = \\sqrt { M M S E }", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 188, + 277, + 199 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 107, + 213, + 217, + 224 + ], + "lines": [ + { + "bbox": [ + 106, + 213, + 218, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 218, + 226 + ], + "score": 1.0, + "content": "2.2 DENSE RE-FEEDING", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 233, + 505, + 311 + ], + "lines": [ + { + "bbox": [ + 106, + 234, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 265, + 246 + ], + "score": 1.0, + "content": "During training and inference, an input", + "type": "text" + }, + { + "bbox": [ + 265, + 234, + 298, + 244 + ], + "score": 0.91, + "content": "x \\in R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 234, + 505, + 246 + ], + "score": 1.0, + "content": "is very sparse because no user can realistically rate", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 245, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 505, + 257 + ], + "score": 1.0, + "content": "but a tiny fractions of all items. This poses problem for model training. Bayesian approches can", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 255, + 504, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 483, + 269 + ], + "score": 1.0, + "content": "be used to overcome this issue (Wang et al., 2015). On the other hand, autoencoder’s output", + "type": "text" + }, + { + "bbox": [ + 483, + 255, + 504, + 267 + ], + "score": 0.91, + "content": "f ( x )", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 266, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 349, + 279 + ], + "score": 1.0, + "content": "is dense. Lets consider an idealized scenario with a perfect", + "type": "text" + }, + { + "bbox": [ + 349, + 267, + 356, + 278 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 266, + 385, + 279 + ], + "score": 1.0, + "content": ". Then", + "type": "text" + }, + { + "bbox": [ + 386, + 266, + 487, + 278 + ], + "score": 0.91, + "content": "f ( x ) _ { i } = x _ { i } , \\forall i : x _ { i } \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 266, + 505, + 279 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 277, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 107, + 277, + 130, + 289 + ], + "score": 0.91, + "content": "f ( { \\boldsymbol { x } } ) _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 277, + 343, + 290 + ], + "score": 1.0, + "content": "accurately predicts all user’s future ratings for items", + "type": "text" + }, + { + "bbox": [ + 343, + 278, + 384, + 288 + ], + "score": 0.91, + "content": "i : x _ { i } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 277, + 506, + 290 + ], + "score": 1.0, + "content": ". This means that if user rates", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 288, + 506, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 146, + 302 + ], + "score": 1.0, + "content": "new item", + "type": "text" + }, + { + "bbox": [ + 146, + 289, + 153, + 298 + ], + "score": 0.75, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 288, + 279, + 302 + ], + "score": 1.0, + "content": "(thereby creating a new vector", + "type": "text" + }, + { + "bbox": [ + 280, + 289, + 289, + 299 + ], + "score": 0.82, + "content": "x ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 288, + 314, + 302 + ], + "score": 1.0, + "content": ") then", + "type": "text" + }, + { + "bbox": [ + 315, + 288, + 365, + 300 + ], + "score": 0.92, + "content": "f ( x ) _ { k } = x _ { k } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 288, + 384, + 302 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 384, + 288, + 441, + 300 + ], + "score": 0.94, + "content": "f ( x ) = f ( x ^ { \\prime } )", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 288, + 506, + 302 + ], + "score": 1.0, + "content": ". Hence, in this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 298, + 481, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 183, + 313 + ], + "score": 1.0, + "content": "idealized scenario,", + "type": "text" + }, + { + "bbox": [ + 183, + 299, + 222, + 311 + ], + "score": 0.93, + "content": "y = f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 298, + 438, + 313 + ], + "score": 1.0, + "content": "should be a fixed point of a well trained autoencoder:", + "type": "text" + }, + { + "bbox": [ + 438, + 299, + 477, + 311 + ], + "score": 0.92, + "content": "f ( y ) = y", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 298, + 481, + 313 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 108, + 316, + 505, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 330 + ], + "score": 1.0, + "content": "To explicitly enforce fixed-point constraint and to be able to perform dense training updates, we", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 328, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 505, + 339 + ], + "score": 1.0, + "content": "augment every optimization iteration with an iterative dense re-feeding steps (3 and 4 below) as", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 142, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 142, + 350 + ], + "score": 1.0, + "content": "follows:", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 129, + 358, + 505, + 427 + ], + "lines": [ + { + "bbox": [ + 129, + 358, + 454, + 372 + ], + "spans": [ + { + "bbox": [ + 129, + 358, + 196, + 372 + ], + "score": 1.0, + "content": "1. Given sparse", + "type": "text" + }, + { + "bbox": [ + 196, + 362, + 203, + 369 + ], + "score": 0.68, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 358, + 269, + 372 + ], + "score": 1.0, + "content": ", compute dense", + "type": "text" + }, + { + "bbox": [ + 269, + 359, + 289, + 371 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 358, + 454, + 372 + ], + "score": 1.0, + "content": "and loss using equation 1 (forward pass)", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 129, + 374, + 398, + 386 + ], + "spans": [ + { + "bbox": [ + 129, + 374, + 398, + 386 + ], + "score": 1.0, + "content": "2. Compute gradients and perform weight update (backward pass)", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 128, + 388, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 128, + 388, + 165, + 402 + ], + "score": 1.0, + "content": "3. Treat", + "type": "text" + }, + { + "bbox": [ + 165, + 389, + 186, + 401 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 388, + 312, + 402 + ], + "score": 1.0, + "content": "as a new example and compute", + "type": "text" + }, + { + "bbox": [ + 312, + 388, + 345, + 401 + ], + "score": 0.92, + "content": "f ( f ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 388, + 392, + 402 + ], + "score": 1.0, + "content": ". Now both", + "type": "text" + }, + { + "bbox": [ + 392, + 389, + 412, + 401 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 388, + 430, + 402 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 430, + 389, + 464, + 401 + ], + "score": 0.92, + "content": "f ( f ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 388, + 505, + 402 + ], + "score": 1.0, + "content": "are dense", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 400, + 444, + 412 + ], + "spans": [ + { + "bbox": [ + 141, + 400, + 286, + 412 + ], + "score": 1.0, + "content": "and the loss from equation 1 has all", + "type": "text" + }, + { + "bbox": [ + 286, + 402, + 296, + 410 + ], + "score": 0.72, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 400, + 444, + 412 + ], + "score": 1.0, + "content": "as non-zeros. (second forward pass)", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 129, + 415, + 428, + 428 + ], + "spans": [ + { + "bbox": [ + 129, + 415, + 428, + 428 + ], + "score": 1.0, + "content": "4. Compute gradients and perform weight update (second backward pass)", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 108, + 435, + 406, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 434, + 406, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 406, + 448 + ], + "score": 1.0, + "content": "Steps (3) and (4) can be also performed more than once for every iteration.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "title", + "bbox": [ + 108, + 462, + 275, + 475 + ], + "lines": [ + { + "bbox": [ + 104, + 461, + 276, + 478 + ], + "spans": [ + { + "bbox": [ + 104, + 461, + 276, + 478 + ], + "score": 1.0, + "content": "3 EXPERIMENTS AND RESULTS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 108, + 487, + 218, + 499 + ], + "lines": [ + { + "bbox": [ + 106, + 488, + 219, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 219, + 500 + ], + "score": 1.0, + "content": "3.1 EXPERIMENT SETUP", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 508, + 505, + 596 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "score": 1.0, + "content": "For the rating prediction task, it is often most relevant to predict future ratings given the past ones", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 518, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 505, + 532 + ], + "score": 1.0, + "content": "instead of predicting ratings missing at random. For evaluation purposes we followed Wu et al.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "score": 1.0, + "content": "(2017) exactly by splitting the original Netflix Prize Bennett et al. (2007) training set into several", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "training and testing intervals based on time. Training interval contains ratings which came in earlier", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "than the ones from testing interval. Testing interval is then randomly split into Test and Validation", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 329, + 576 + ], + "score": 1.0, + "content": "subsets so that each rating from testing interval has a", + "type": "text" + }, + { + "bbox": [ + 330, + 563, + 350, + 574 + ], + "score": 0.87, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "chance of appearing in either subset.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 574, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 505, + 587 + ], + "score": 1.0, + "content": "Users and items that do not appear in the training set are removed from both test and validation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 585, + 309, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 309, + 597 + ], + "score": 1.0, + "content": "subsets. Table 1 provides details on the data sets.2", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 107, + 602, + 505, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 602, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 614 + ], + "score": 1.0, + "content": "For most of our experiments we uses a batch size of 128, trained using SGD with momentum of 0.9", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "score": 1.0, + "content": "and learning rate of 0.001. We used xavier initialization to initialize parameters. Note, that unlike", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 623, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 506, + 637 + ], + "score": 1.0, + "content": "Strub & Mary (2015) we did not use any layer-wise pre-training. We believe that we were able to", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 635, + 450, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 450, + 648 + ], + "score": 1.0, + "content": "do so successfully because of choosing the right activation function (see Section 3.2).", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + }, + { + "type": "title", + "bbox": [ + 109, + 660, + 286, + 671 + ], + "lines": [ + { + "bbox": [ + 106, + 659, + 288, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 288, + 672 + ], + "score": 1.0, + "content": "3.2 EFFECTS OF THE ACTIVATION TYPES", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 108, + 680, + 504, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "To explore the effects of using different activation functions, we tested some of the most popular", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 691, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 386, + 704 + ], + "score": 1.0, + "content": "choices in deep learning : sigmoid, “rectified linear units” (RELU),", + "type": "text" + }, + { + "bbox": [ + 386, + 691, + 455, + 703 + ], + "score": 0.9, + "content": "m a x ( r e l u ( x ) , 6 )", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 691, + 505, + 704 + ], + "score": 1.0, + "content": "or RELU6,", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 711, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "2Note, that while checking our data set statistics with first author of (Wu et al., 2017) it was determined that", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 721, + 414, + 731 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 393, + 731 + ], + "score": 1.0, + "content": "their publication contained the following typo: “Netflix 6m” should be “Netflix", + "type": "text" + }, + { + "bbox": [ + 393, + 722, + 409, + 731 + ], + "score": 0.68, + "content": "3 \\mathrm { m } ^ { \\dag }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 721, + 414, + 731 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 26, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "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": "title", + "bbox": [ + 107, + 82, + 201, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 202, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 202, + 95 + ], + "score": 1.0, + "content": "2.1 LOSS FUNCTION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 105, + 103, + 504, + 126 + ], + "lines": [ + { + "bbox": [ + 106, + 103, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 106, + 103, + 400, + 115 + ], + "score": 1.0, + "content": "Since it doesn’t make sense to predict zeros in user’s representation vector", + "type": "text" + }, + { + "bbox": [ + 400, + 106, + 407, + 113 + ], + "score": 0.78, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 103, + 505, + 115 + ], + "score": 1.0, + "content": ", we follow the approach", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 113, + 407, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 407, + 127 + ], + "score": 1.0, + "content": "from Sedhain et al. (2015) and optimize Masked Mean Squared Error loss:", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5, + "bbox_fs": [ + 105, + 103, + 505, + 127 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 247, + 130, + 364, + 161 + ], + "lines": [ + { + "bbox": [ + 247, + 130, + 364, + 161 + ], + "spans": [ + { + "bbox": [ + 247, + 130, + 364, + 161 + ], + "score": 0.95, + "content": "M M S E = \\frac { m _ { i } * ( r _ { i } - y _ { i } ) ^ { 2 } } { \\sum _ { i = 0 } ^ { i = n } m _ { i } }", + "type": "interline_equation", + "image_path": "1897d4b1db1749e191b172c3dd7d98ae749d38dd07fd68a752082ec3404f525a.jpg" + } + ] + } + ], + "index": 3.5, + "virtual_lines": [ + { + "bbox": [ + 247, + 130, + 364, + 145.5 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 247, + 145.5, + 364, + 161.0 + ], + "spans": [], + "index": 4 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 164, + 504, + 199 + ], + "lines": [ + { + "bbox": [ + 106, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 106, + 164, + 133, + 177 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 167, + 142, + 176 + ], + "score": 0.86, + "content": "r _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 164, + 206, + 177 + ], + "score": 1.0, + "content": "is actual rating,", + "type": "text" + }, + { + "bbox": [ + 206, + 167, + 215, + 176 + ], + "score": 0.85, + "content": "y _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 164, + 378, + 177 + ], + "score": 1.0, + "content": "is reconstructed, or predicted rating, and", + "type": "text" + }, + { + "bbox": [ + 379, + 166, + 392, + 176 + ], + "score": 0.87, + "content": "m _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 392, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "is a mask function such that", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 176, + 506, + 187 + ], + "spans": [ + { + "bbox": [ + 107, + 177, + 140, + 187 + ], + "score": 0.91, + "content": "m _ { i } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 176, + 150, + 187 + ], + "score": 1.0, + "content": "if", + "type": "text" + }, + { + "bbox": [ + 150, + 176, + 180, + 187 + ], + "score": 0.91, + "content": "r _ { i } \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 176, + 199, + 187 + ], + "score": 1.0, + "content": "else", + "type": "text" + }, + { + "bbox": [ + 199, + 177, + 232, + 187 + ], + "score": 0.89, + "content": "m _ { i } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 176, + 506, + 187 + ], + "score": 1.0, + "content": ". Note that there is a straightforward relation between RMSE score", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 187, + 277, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 182, + 199 + ], + "score": 1.0, + "content": "and MMSE score:", + "type": "text" + }, + { + "bbox": [ + 182, + 187, + 274, + 199 + ], + "score": 0.9, + "content": "R M S E = \\sqrt { M M S E }", + "type": "inline_equation" + }, + { + "bbox": [ + 274, + 188, + 277, + 199 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 164, + 506, + 199 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 213, + 217, + 224 + ], + "lines": [ + { + "bbox": [ + 106, + 213, + 218, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 218, + 226 + ], + "score": 1.0, + "content": "2.2 DENSE RE-FEEDING", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 233, + 505, + 311 + ], + "lines": [ + { + "bbox": [ + 106, + 234, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 265, + 246 + ], + "score": 1.0, + "content": "During training and inference, an input", + "type": "text" + }, + { + "bbox": [ + 265, + 234, + 298, + 244 + ], + "score": 0.91, + "content": "x \\in R ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 234, + 505, + 246 + ], + "score": 1.0, + "content": "is very sparse because no user can realistically rate", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 245, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 505, + 257 + ], + "score": 1.0, + "content": "but a tiny fractions of all items. This poses problem for model training. Bayesian approches can", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 255, + 504, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 483, + 269 + ], + "score": 1.0, + "content": "be used to overcome this issue (Wang et al., 2015). On the other hand, autoencoder’s output", + "type": "text" + }, + { + "bbox": [ + 483, + 255, + 504, + 267 + ], + "score": 0.91, + "content": "f ( x )", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 266, + 505, + 279 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 349, + 279 + ], + "score": 1.0, + "content": "is dense. Lets consider an idealized scenario with a perfect", + "type": "text" + }, + { + "bbox": [ + 349, + 267, + 356, + 278 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 266, + 385, + 279 + ], + "score": 1.0, + "content": ". Then", + "type": "text" + }, + { + "bbox": [ + 386, + 266, + 487, + 278 + ], + "score": 0.91, + "content": "f ( x ) _ { i } = x _ { i } , \\forall i : x _ { i } \\neq 0", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 266, + 505, + 279 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 277, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 107, + 277, + 130, + 289 + ], + "score": 0.91, + "content": "f ( { \\boldsymbol { x } } ) _ { i }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 277, + 343, + 290 + ], + "score": 1.0, + "content": "accurately predicts all user’s future ratings for items", + "type": "text" + }, + { + "bbox": [ + 343, + 278, + 384, + 288 + ], + "score": 0.91, + "content": "i : x _ { i } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 277, + 506, + 290 + ], + "score": 1.0, + "content": ". This means that if user rates", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 288, + 506, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 146, + 302 + ], + "score": 1.0, + "content": "new item", + "type": "text" + }, + { + "bbox": [ + 146, + 289, + 153, + 298 + ], + "score": 0.75, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 154, + 288, + 279, + 302 + ], + "score": 1.0, + "content": "(thereby creating a new vector", + "type": "text" + }, + { + "bbox": [ + 280, + 289, + 289, + 299 + ], + "score": 0.82, + "content": "x ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 288, + 314, + 302 + ], + "score": 1.0, + "content": ") then", + "type": "text" + }, + { + "bbox": [ + 315, + 288, + 365, + 300 + ], + "score": 0.92, + "content": "f ( x ) _ { k } = x _ { k } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 288, + 384, + 302 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 384, + 288, + 441, + 300 + ], + "score": 0.94, + "content": "f ( x ) = f ( x ^ { \\prime } )", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 288, + 506, + 302 + ], + "score": 1.0, + "content": ". Hence, in this", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 298, + 481, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 183, + 313 + ], + "score": 1.0, + "content": "idealized scenario,", + "type": "text" + }, + { + "bbox": [ + 183, + 299, + 222, + 311 + ], + "score": 0.93, + "content": "y = f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 298, + 438, + 313 + ], + "score": 1.0, + "content": "should be a fixed point of a well trained autoencoder:", + "type": "text" + }, + { + "bbox": [ + 438, + 299, + 477, + 311 + ], + "score": 0.92, + "content": "f ( y ) = y", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 298, + 481, + 313 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 234, + 506, + 313 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 316, + 505, + 349 + ], + "lines": [ + { + "bbox": [ + 105, + 315, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 505, + 330 + ], + "score": 1.0, + "content": "To explicitly enforce fixed-point constraint and to be able to perform dense training updates, we", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 328, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 505, + 339 + ], + "score": 1.0, + "content": "augment every optimization iteration with an iterative dense re-feeding steps (3 and 4 below) as", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 142, + 350 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 142, + 350 + ], + "score": 1.0, + "content": "follows:", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 315, + 505, + 350 + ] + }, + { + "type": "index", + "bbox": [ + 129, + 358, + 505, + 427 + ], + "lines": [ + { + "bbox": [ + 129, + 358, + 454, + 372 + ], + "spans": [ + { + "bbox": [ + 129, + 358, + 196, + 372 + ], + "score": 1.0, + "content": "1. Given sparse", + "type": "text" + }, + { + "bbox": [ + 196, + 362, + 203, + 369 + ], + "score": 0.68, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 358, + 269, + 372 + ], + "score": 1.0, + "content": ", compute dense", + "type": "text" + }, + { + "bbox": [ + 269, + 359, + 289, + 371 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 358, + 454, + 372 + ], + "score": 1.0, + "content": "and loss using equation 1 (forward pass)", + "type": "text" + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 129, + 374, + 398, + 386 + ], + "spans": [ + { + "bbox": [ + 129, + 374, + 398, + 386 + ], + "score": 1.0, + "content": "2. Compute gradients and perform weight update (backward pass)", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 128, + 388, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 128, + 388, + 165, + 402 + ], + "score": 1.0, + "content": "3. Treat", + "type": "text" + }, + { + "bbox": [ + 165, + 389, + 186, + 401 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 388, + 312, + 402 + ], + "score": 1.0, + "content": "as a new example and compute", + "type": "text" + }, + { + "bbox": [ + 312, + 388, + 345, + 401 + ], + "score": 0.92, + "content": "f ( f ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 346, + 388, + 392, + 402 + ], + "score": 1.0, + "content": ". Now both", + "type": "text" + }, + { + "bbox": [ + 392, + 389, + 412, + 401 + ], + "score": 0.92, + "content": "f ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 388, + 430, + 402 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 430, + 389, + 464, + 401 + ], + "score": 0.92, + "content": "f ( f ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 388, + 505, + 402 + ], + "score": 1.0, + "content": "are dense", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 400, + 444, + 412 + ], + "spans": [ + { + "bbox": [ + 141, + 400, + 286, + 412 + ], + "score": 1.0, + "content": "and the loss from equation 1 has all", + "type": "text" + }, + { + "bbox": [ + 286, + 402, + 296, + 410 + ], + "score": 0.72, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 400, + 444, + 412 + ], + "score": 1.0, + "content": "as non-zeros. (second forward pass)", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 129, + 415, + 428, + 428 + ], + "spans": [ + { + "bbox": [ + 129, + 415, + 428, + 428 + ], + "score": 1.0, + "content": "4. Compute gradients and perform weight update (second backward pass)", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + } + ], + "index": 21, + "bbox_fs": [ + 128, + 358, + 505, + 428 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 435, + 406, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 434, + 406, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 406, + 448 + ], + "score": 1.0, + "content": "Steps (3) and (4) can be also performed more than once for every iteration.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24, + "bbox_fs": [ + 106, + 434, + 406, + 448 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 462, + 275, + 475 + ], + "lines": [ + { + "bbox": [ + 104, + 461, + 276, + 478 + ], + "spans": [ + { + "bbox": [ + 104, + 461, + 276, + 478 + ], + "score": 1.0, + "content": "3 EXPERIMENTS AND RESULTS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 108, + 487, + 218, + 499 + ], + "lines": [ + { + "bbox": [ + 106, + 488, + 219, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 219, + 500 + ], + "score": 1.0, + "content": "3.1 EXPERIMENT SETUP", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 508, + 505, + 596 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 520 + ], + "score": 1.0, + "content": "For the rating prediction task, it is often most relevant to predict future ratings given the past ones", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 518, + 505, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 505, + 532 + ], + "score": 1.0, + "content": "instead of predicting ratings missing at random. For evaluation purposes we followed Wu et al.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 505, + 543 + ], + "score": 1.0, + "content": "(2017) exactly by splitting the original Netflix Prize Bennett et al. (2007) training set into several", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 505, + 554 + ], + "score": 1.0, + "content": "training and testing intervals based on time. Training interval contains ratings which came in earlier", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 106, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "than the ones from testing interval. Testing interval is then randomly split into Test and Validation", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 563, + 329, + 576 + ], + "score": 1.0, + "content": "subsets so that each rating from testing interval has a", + "type": "text" + }, + { + "bbox": [ + 330, + 563, + 350, + 574 + ], + "score": 0.87, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "chance of appearing in either subset.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 574, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 505, + 587 + ], + "score": 1.0, + "content": "Users and items that do not appear in the training set are removed from both test and validation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 585, + 309, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 309, + 597 + ], + "score": 1.0, + "content": "subsets. Table 1 provides details on the data sets.2", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 509, + 505, + 597 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 602, + 505, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 602, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 505, + 614 + ], + "score": 1.0, + "content": "For most of our experiments we uses a batch size of 128, trained using SGD with momentum of 0.9", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "score": 1.0, + "content": "and learning rate of 0.001. We used xavier initialization to initialize parameters. Note, that unlike", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 623, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 623, + 506, + 637 + ], + "score": 1.0, + "content": "Strub & Mary (2015) we did not use any layer-wise pre-training. We believe that we were able to", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 635, + 450, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 450, + 648 + ], + "score": 1.0, + "content": "do so successfully because of choosing the right activation function (see Section 3.2).", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 602, + 506, + 648 + ] + }, + { + "type": "title", + "bbox": [ + 109, + 660, + 286, + 671 + ], + "lines": [ + { + "bbox": [ + 106, + 659, + 288, + 672 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 288, + 672 + ], + "score": 1.0, + "content": "3.2 EFFECTS OF THE ACTIVATION TYPES", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 108, + 680, + 504, + 703 + ], + "lines": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 505, + 693 + ], + "score": 1.0, + "content": "To explore the effects of using different activation functions, we tested some of the most popular", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 691, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 106, + 691, + 386, + 704 + ], + "score": 1.0, + "content": "choices in deep learning : sigmoid, “rectified linear units” (RELU),", + "type": "text" + }, + { + "bbox": [ + 386, + 691, + 455, + 703 + ], + "score": 0.9, + "content": "m a x ( r e l u ( x ) , 6 )", + "type": "inline_equation" + }, + { + "bbox": [ + 456, + 691, + 505, + 704 + ], + "score": 1.0, + "content": "or RELU6,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "hyperbolic tangent (TANH), “exponential linear units” (ELU) (Clevert et al., 2015), leaky relu", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "(LRELU) (Xu et al., 2015) , “self-gated activation function” (SWISH) (Ramachandran et al., 2017),", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 616, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 616, + 506, + 629 + ], + "score": 1.0, + "content": "and “scaled exponential linear units” (Klambauer et al., 2017) (SELU) on the 4 layer autoencoder", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "with 128 units in each hidden layer. Because ratings are on the scale from 1 to 5, we keep last layer", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "of the decoder linear for sigmoid and tanh-based models. In all other models activation function is", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 649, + 190, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 190, + 662 + ], + "score": 1.0, + "content": "applied in all layers.", + "type": "text", + "cross_page": true + } + ], + "index": 16 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 680, + 505, + 704 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 130, + 82, + 482, + 308 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 130, + 82, + 482, + 308 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 130, + 82, + 482, + 308 + ], + "spans": [ + { + "bbox": [ + 130, + 82, + 482, + 308 + ], + "score": 0.972, + "type": "image", + "image_path": "09a17f90285f07af06cb356344fc9c7e4c66332e57baa5666e3e4a13acf00cc6.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 130, + 82, + 482, + 157.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 130, + 157.33333333333331, + 482, + 232.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 130, + 232.66666666666663, + 482, + 307.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 325, + 505, + 359 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 324, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 505, + 338 + ], + "score": 1.0, + "content": "Figure 1: AutoEncoder consists of two neural networks, encoder and decoder, fused together on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 336, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 213, + 349 + ], + "score": 1.0, + "content": "the “representation” layer", + "type": "text" + }, + { + "bbox": [ + 213, + 338, + 220, + 346 + ], + "score": 0.67, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 336, + 313, + 349 + ], + "score": 1.0, + "content": ". Encoder has 2 layers", + "type": "text" + }, + { + "bbox": [ + 314, + 338, + 324, + 347 + ], + "score": 0.84, + "content": "e _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 336, + 343, + 349 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 344, + 338, + 354, + 347 + ], + "score": 0.84, + "content": "e _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 336, + 460, + 349 + ], + "score": 1.0, + "content": "and decoder has 2 layers", + "type": "text" + }, + { + "bbox": [ + 460, + 337, + 471, + 347 + ], + "score": 0.88, + "content": "d _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 336, + 490, + 349 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 490, + 336, + 501, + 347 + ], + "score": 0.86, + "content": "d _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 336, + 505, + 349 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 347, + 279, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 267, + 360 + ], + "score": 1.0, + "content": "Dropout may be applied to coding layer", + "type": "text" + }, + { + "bbox": [ + 268, + 349, + 274, + 357 + ], + "score": 0.72, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 347, + 279, + 360 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "table", + "bbox": [ + 159, + 424, + 452, + 538 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 105, + 398, + 505, + 421 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "Table 1: Subsets of Netflix Prize training set used in our experiments. We made sure that these splits", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 409, + 303, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 303, + 421 + ], + "score": 1.0, + "content": "match exactly the ones used in (Wu et al., 2017).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "table_body", + "bbox": [ + 159, + 424, + 452, + 538 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 159, + 424, + 452, + 538 + ], + "spans": [ + { + "bbox": [ + 159, + 424, + 452, + 538 + ], + "score": 0.981, + "html": "
Full3 months6 months1 year
06/05-11/05
Training Users12/99-11/05 477,41209/05-11/05 311,315390,79506/04-05/05 345,855
Ratings98,074,90113,675,40229,179,00941,451,832
Testing Users12/0512/0512/0506/05
", + "type": "table", + "image_path": "98febd8b2de97993caeb17fa47cd2eb95b84983871e8e9652b9662c8b7406a28.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 159, + 424, + 452, + 462.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 159, + 462.0, + 452, + 500.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 159, + 500.0, + 452, + 538.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 7.75 + }, + { + "type": "text", + "bbox": [ + 106, + 593, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "hyperbolic tangent (TANH), “exponential linear units” (ELU) (Clevert et al., 2015), leaky relu", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 605, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 505, + 618 + ], + "score": 1.0, + "content": "(LRELU) (Xu et al., 2015) , “self-gated activation function” (SWISH) (Ramachandran et al., 2017),", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 616, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 106, + 616, + 506, + 629 + ], + "score": 1.0, + "content": "and “scaled exponential linear units” (Klambauer et al., 2017) (SELU) on the 4 layer autoencoder", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "with 128 units in each hidden layer. Because ratings are on the scale from 1 to 5, we keep last layer", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 505, + 650 + ], + "score": 1.0, + "content": "of the decoder linear for sigmoid and tanh-based models. In all other models activation function is", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 649, + 190, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 190, + 662 + ], + "score": 1.0, + "content": "applied in all layers.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "We found that on this task ELU, SELU and LRELU perform much better than SIGMOID, RELU,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "RELU6, TANH and SWISH. Figure 2 clearly demonstrates this. There are two properties which", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "seems to separate activations which perform well from those which do not: a) non-zero negative", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "part and b) unbounded positive part. Hence, we conclude, that in this setting these properties are im-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "portant for successful training. Thus, we use SELU activation units and tune SELU-based networks", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 720, + 176, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 176, + 734 + ], + "score": 1.0, + "content": "for performance.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 8 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 130, + 82, + 482, + 308 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 130, + 82, + 482, + 308 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 130, + 82, + 482, + 308 + ], + "spans": [ + { + "bbox": [ + 130, + 82, + 482, + 308 + ], + "score": 0.972, + "type": "image", + "image_path": "09a17f90285f07af06cb356344fc9c7e4c66332e57baa5666e3e4a13acf00cc6.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 130, + 82, + 482, + 157.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 130, + 157.33333333333331, + 482, + 232.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 130, + 232.66666666666663, + 482, + 307.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 325, + 505, + 359 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 324, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 505, + 338 + ], + "score": 1.0, + "content": "Figure 1: AutoEncoder consists of two neural networks, encoder and decoder, fused together on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 336, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 336, + 213, + 349 + ], + "score": 1.0, + "content": "the “representation” layer", + "type": "text" + }, + { + "bbox": [ + 213, + 338, + 220, + 346 + ], + "score": 0.67, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 336, + 313, + 349 + ], + "score": 1.0, + "content": ". Encoder has 2 layers", + "type": "text" + }, + { + "bbox": [ + 314, + 338, + 324, + 347 + ], + "score": 0.84, + "content": "e _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 336, + 343, + 349 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 344, + 338, + 354, + 347 + ], + "score": 0.84, + "content": "e _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 336, + 460, + 349 + ], + "score": 1.0, + "content": "and decoder has 2 layers", + "type": "text" + }, + { + "bbox": [ + 460, + 337, + 471, + 347 + ], + "score": 0.88, + "content": "d _ { 1 }", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 336, + 490, + 349 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 490, + 336, + 501, + 347 + ], + "score": 0.86, + "content": "d _ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 336, + 505, + 349 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 347, + 279, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 267, + 360 + ], + "score": 1.0, + "content": "Dropout may be applied to coding layer", + "type": "text" + }, + { + "bbox": [ + 268, + 349, + 274, + 357 + ], + "score": 0.72, + "content": "z", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 347, + 279, + 360 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "table", + "bbox": [ + 159, + 424, + 452, + 538 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 105, + 398, + 505, + 421 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "Table 1: Subsets of Netflix Prize training set used in our experiments. We made sure that these splits", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 409, + 303, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 409, + 303, + 421 + ], + "score": 1.0, + "content": "match exactly the ones used in (Wu et al., 2017).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "table_body", + "bbox": [ + 159, + 424, + 452, + 538 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 159, + 424, + 452, + 538 + ], + "spans": [ + { + "bbox": [ + 159, + 424, + 452, + 538 + ], + "score": 0.981, + "html": "
Full3 months6 months1 year
06/05-11/05
Training Users12/99-11/05 477,41209/05-11/05 311,315390,79506/04-05/05 345,855
Ratings98,074,90113,675,40229,179,00941,451,832
Testing Users12/0512/0512/0506/05
", + "type": "table", + "image_path": "98febd8b2de97993caeb17fa47cd2eb95b84983871e8e9652b9662c8b7406a28.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 159, + 424, + 452, + 462.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 159, + 462.0, + 452, + 500.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 159, + 500.0, + 452, + 538.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 7.75 + }, + { + "type": "text", + "bbox": [ + 106, + 593, + 505, + 660 + ], + "lines": [], + "index": 13.5, + "bbox_fs": [ + 105, + 594, + 506, + 662 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "spans": [ + { + "bbox": [ + 106, + 666, + 505, + 677 + ], + "score": 1.0, + "content": "We found that on this task ELU, SELU and LRELU perform much better than SIGMOID, RELU,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "RELU6, TANH and SWISH. Figure 2 clearly demonstrates this. There are two properties which", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "seems to separate activations which perform well from those which do not: a) non-zero negative", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "part and b) unbounded positive part. Hence, we conclude, that in this setting these properties are im-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "portant for successful training. Thus, we use SELU activation units and tune SELU-based networks", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 720, + 176, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 176, + 734 + ], + "score": 1.0, + "content": "for performance.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 666, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 84, + 500, + 276 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 84, + 500, + 276 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 84, + 500, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 500, + 276 + ], + "score": 0.96, + "type": "image", + "image_path": "aec9a2eced5f723ac04e892d3f29d7e2ede096781d457488e2eaddd2ec164ecb.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 84, + 500, + 148.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 148.0, + 500, + 212.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 212.0, + 500, + 276.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 293, + 505, + 338 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "Figure 2: Training RMSE per mini-batch. All lines correspond to 4-layers autoencoder (2 layer", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 304, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 506, + 317 + ], + "score": 1.0, + "content": "encoder and 2 layer decoder) with hidden unit dimensions of 128. Different line colors correspond", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 316, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 328 + ], + "score": 1.0, + "content": "to different activation functions. TANH and SIGMOID lines are very similar as well as lines for", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 326, + 424, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 424, + 339 + ], + "score": 1.0, + "content": "ELU and SELU. The best performing activation functions are ELU and SELU.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "title", + "bbox": [ + 107, + 358, + 238, + 370 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 239, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 239, + 370 + ], + "score": 1.0, + "content": "3.3 OVER-FITTING THE DATA", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 379, + 504, + 413 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 505, + 392 + ], + "score": 1.0, + "content": "The largest data set we use for training, “Netflix Full” from Table 1, contains 98M ratings given by", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 389, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 337, + 403 + ], + "score": 1.0, + "content": "477K users. Number of movies (e.g. items) in this set is", + "type": "text" + }, + { + "bbox": [ + 337, + 391, + 369, + 401 + ], + "score": 0.76, + "content": "n = 1 7", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 389, + 506, + 403 + ], + "score": 1.0, + "content": ", 768. Therefore, the first layer of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 400, + 415, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 179, + 415 + ], + "score": 1.0, + "content": "encoder will have", + "type": "text" + }, + { + "bbox": [ + 180, + 402, + 219, + 412 + ], + "score": 0.91, + "content": "d * n + d", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 400, + 282, + 415 + ], + "score": 1.0, + "content": "weights, where", + "type": "text" + }, + { + "bbox": [ + 283, + 402, + 289, + 411 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 400, + 415, + 415 + ], + "score": 1.0, + "content": "is number of units in the layer.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 418, + 505, + 462 + ], + "lines": [ + { + "bbox": [ + 106, + 418, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 505, + 430 + ], + "score": 1.0, + "content": "For modern deep learning algorithms and hardware this is relatively small task. If we start with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 430, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 451, + 442 + ], + "score": 1.0, + "content": "single layer encoders and decoders we can quickly overfit to the training data even for", + "type": "text" + }, + { + "bbox": [ + 452, + 430, + 459, + 439 + ], + "score": 0.79, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 430, + 505, + 442 + ], + "score": 1.0, + "content": "as small as", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "score": 1.0, + "content": "512. Figure 3 clearly demonstrates this. Switching from unconstrained autoencoder to constrained", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 452, + 362, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 362, + 463 + ], + "score": 1.0, + "content": "reduces over-fitting, but does not completely solve the problem.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5 + }, + { + "type": "image", + "bbox": [ + 106, + 475, + 505, + 599 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 475, + 505, + 599 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 475, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 505, + 599 + ], + "score": 0.961, + "type": "image", + "image_path": "63b7bb1ea66cdf6bb9ca0bb346e6100321c6a5f1f9ea9693554e275cb0692ba0.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 106, + 475, + 505, + 516.3333333333334 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 106, + 516.3333333333334, + 505, + 557.6666666666667 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 106, + 557.6666666666667, + 505, + 599.0000000000001 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 613, + 504, + 636 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 613, + 504, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 504, + 626 + ], + "score": 1.0, + "content": "Figure 3: Single layer autoencoder with 128, 256, 512 and 1024 hidden units in the coding layer. A:", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 624, + 342, + 638 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 342, + 638 + ], + "score": 1.0, + "content": "training RMSE per epoch; B: evaluation RMSE per epoch.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + } + ], + "index": 17.25 + }, + { + "type": "title", + "bbox": [ + 107, + 656, + 196, + 667 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 198, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 198, + 668 + ], + "score": 1.0, + "content": "3.4 GOING DEEPER", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 107, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 107, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "While making layers wider helps bring training loss down, adding more layers is often correlated", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "with a network’s ability to generalize. In this set of experiments we show that this is indeed the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 318, + 711 + ], + "score": 1.0, + "content": "case here. We choose small enough dimensionality", + "type": "text" + }, + { + "bbox": [ + 319, + 699, + 356, + 709 + ], + "score": 0.85, + "content": "d = 1 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 699, + 505, + 711 + ], + "score": 1.0, + "content": ") for all hidden layers to easily avoid", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "over-fitting and start adding more layers. Table 2 shows that there is a positive correlation between", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 720, + 305, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 305, + 734 + ], + "score": 1.0, + "content": "the number of layers and the evaluation accuracy.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 25, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 106, + 84, + 500, + 276 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 84, + 500, + 276 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 84, + 500, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 84, + 500, + 276 + ], + "score": 0.96, + "type": "image", + "image_path": "aec9a2eced5f723ac04e892d3f29d7e2ede096781d457488e2eaddd2ec164ecb.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 84, + 500, + 148.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 148.0, + 500, + 212.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 212.0, + 500, + 276.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 293, + 505, + 338 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 506, + 306 + ], + "score": 1.0, + "content": "Figure 2: Training RMSE per mini-batch. All lines correspond to 4-layers autoencoder (2 layer", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 304, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 506, + 317 + ], + "score": 1.0, + "content": "encoder and 2 layer decoder) with hidden unit dimensions of 128. Different line colors correspond", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 316, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 328 + ], + "score": 1.0, + "content": "to different activation functions. TANH and SIGMOID lines are very similar as well as lines for", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 326, + 424, + 339 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 424, + 339 + ], + "score": 1.0, + "content": "ELU and SELU. The best performing activation functions are ELU and SELU.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "title", + "bbox": [ + 107, + 358, + 238, + 370 + ], + "lines": [ + { + "bbox": [ + 106, + 358, + 239, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 358, + 239, + 370 + ], + "score": 1.0, + "content": "3.3 OVER-FITTING THE DATA", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 379, + 504, + 413 + ], + "lines": [ + { + "bbox": [ + 105, + 378, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 505, + 392 + ], + "score": 1.0, + "content": "The largest data set we use for training, “Netflix Full” from Table 1, contains 98M ratings given by", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 389, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 337, + 403 + ], + "score": 1.0, + "content": "477K users. Number of movies (e.g. items) in this set is", + "type": "text" + }, + { + "bbox": [ + 337, + 391, + 369, + 401 + ], + "score": 0.76, + "content": "n = 1 7", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 389, + 506, + 403 + ], + "score": 1.0, + "content": ", 768. Therefore, the first layer of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 400, + 415, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 179, + 415 + ], + "score": 1.0, + "content": "encoder will have", + "type": "text" + }, + { + "bbox": [ + 180, + 402, + 219, + 412 + ], + "score": 0.91, + "content": "d * n + d", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 400, + 282, + 415 + ], + "score": 1.0, + "content": "weights, where", + "type": "text" + }, + { + "bbox": [ + 283, + 402, + 289, + 411 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 400, + 415, + 415 + ], + "score": 1.0, + "content": "is number of units in the layer.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 378, + 506, + 415 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 418, + 505, + 462 + ], + "lines": [ + { + "bbox": [ + 106, + 418, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 505, + 430 + ], + "score": 1.0, + "content": "For modern deep learning algorithms and hardware this is relatively small task. If we start with", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 430, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 451, + 442 + ], + "score": 1.0, + "content": "single layer encoders and decoders we can quickly overfit to the training data even for", + "type": "text" + }, + { + "bbox": [ + 452, + 430, + 459, + 439 + ], + "score": 0.79, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 459, + 430, + 505, + 442 + ], + "score": 1.0, + "content": "as small as", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 452 + ], + "score": 1.0, + "content": "512. Figure 3 clearly demonstrates this. Switching from unconstrained autoencoder to constrained", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 452, + 362, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 362, + 463 + ], + "score": 1.0, + "content": "reduces over-fitting, but does not completely solve the problem.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12.5, + "bbox_fs": [ + 106, + 418, + 505, + 463 + ] + }, + { + "type": "image", + "bbox": [ + 106, + 475, + 505, + 599 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 475, + 505, + 599 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 475, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 505, + 599 + ], + "score": 0.961, + "type": "image", + "image_path": "63b7bb1ea66cdf6bb9ca0bb346e6100321c6a5f1f9ea9693554e275cb0692ba0.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 106, + 475, + 505, + 516.3333333333334 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 106, + 516.3333333333334, + 505, + 557.6666666666667 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 106, + 557.6666666666667, + 505, + 599.0000000000001 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 613, + 504, + 636 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 613, + 504, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 504, + 626 + ], + "score": 1.0, + "content": "Figure 3: Single layer autoencoder with 128, 256, 512 and 1024 hidden units in the coding layer. A:", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 624, + 342, + 638 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 342, + 638 + ], + "score": 1.0, + "content": "training RMSE per epoch; B: evaluation RMSE per epoch.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + } + ], + "index": 17.25 + }, + { + "type": "title", + "bbox": [ + 107, + 656, + 196, + 667 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 198, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 198, + 668 + ], + "score": 1.0, + "content": "3.4 GOING DEEPER", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 107, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 107, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "While making layers wider helps bring training loss down, adding more layers is often correlated", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "with a network’s ability to generalize. In this set of experiments we show that this is indeed the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 318, + 711 + ], + "score": 1.0, + "content": "case here. We choose small enough dimensionality", + "type": "text" + }, + { + "bbox": [ + 319, + 699, + 356, + 709 + ], + "score": 0.85, + "content": "d = 1 2 8", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 699, + 505, + 711 + ], + "score": 1.0, + "content": ") for all hidden layers to easily avoid", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "over-fitting and start adding more layers. Table 2 shows that there is a positive correlation between", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 720, + 305, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 305, + 734 + ], + "score": 1.0, + "content": "the number of layers and the evaluation accuracy.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 677, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 190, + 115, + 421, + 217 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 504, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 506, + 101 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 506, + 101 + ], + "score": 1.0, + "content": "Table 2: Depth helps generalization. Evaluation RMSE of the models with different number of", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 322, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 322, + 111 + ], + "score": 1.0, + "content": "layers. In all cases the hidden layer dimension is 128.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 190, + 115, + 421, + 217 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 115, + 421, + 217 + ], + "spans": [ + { + "bbox": [ + 190, + 115, + 421, + 217 + ], + "score": 0.975, + "html": "
Number of layersEvaluation RMSEparams
21.1464,566,504
40.96154,599,528
60.93784,632,552
8 100.93644,665,576
120.9340 0.93284,698,600
4,731,624
", + "type": "table", + "image_path": "88fcfcca1263e20a032f9acfaef74ea8491daebbea86756b7bd10814e85b9e95.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 190, + 115, + 421, + 129.57142857142858 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 190, + 129.57142857142858, + 421, + 144.14285714285717 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 190, + 144.14285714285717, + 421, + 158.71428571428575 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 190, + 158.71428571428575, + 421, + 173.28571428571433 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 190, + 173.28571428571433, + 421, + 187.85714285714292 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 190, + 187.85714285714292, + 421, + 202.4285714285715 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 190, + 202.4285714285715, + 421, + 217.00000000000009 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "Going from one layer in encoder and decoder to three layers in both provides good improvement in", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "score": 1.0, + "content": "evaluation RMSE (from 1.146 to 0.9378). After that, blindly adding more layers does help, however", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 376, + 289 + ], + "score": 1.0, + "content": "it provides diminishing returns. Note that the model with single", + "type": "text" + }, + { + "bbox": [ + 376, + 276, + 416, + 286 + ], + "score": 0.89, + "content": "d \\ : = \\ : 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 275, + 505, + 289 + ], + "score": 1.0, + "content": "layer in encoder and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 286, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 505, + 300 + ], + "score": 1.0, + "content": "decoder has 9,115,240 parameters which is almost two times more than any of these deep models", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 298, + 330, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 330, + 310 + ], + "score": 1.0, + "content": "while having much worse evauation RMSE (above 1.0).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 107, + 323, + 174, + 335 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 176, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 176, + 336 + ], + "score": 1.0, + "content": "3.5 DROPOUT", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 344, + 505, + 444 + ], + "lines": [ + { + "bbox": [ + 105, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "Section 3.4 shows us that adding too many small layers eventually hits diminishing returns. Thus, we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 354, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 505, + 369 + ], + "score": 1.0, + "content": "start experimenting with model architecture and hyper-parameters more broadly. Our most promis-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 279, + 379 + ], + "score": 1.0, + "content": "ing model has the following architecture:", + "type": "text" + }, + { + "bbox": [ + 279, + 366, + 399, + 378 + ], + "score": 0.59, + "content": "n , 5 1 2 , 5 1 2 , 1 0 2 4 , 5 1 2 , 5 1 2 , n .", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 366, + 505, + 379 + ], + "score": 1.0, + "content": ", which means 3 layers in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 377, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 506, + 389 + ], + "score": 1.0, + "content": "encoder (512,512,1024), coding layer of 1024 and 3 layers in decoder of size 512,512,n. This", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "score": 1.0, + "content": "model, however, quickly over-fits if trained with no regularization. To regularize it, we tried several", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "score": 1.0, + "content": "dropout values and, interestingly, very high values of drop probability (e.g. 0.8) turned out to be", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 408, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 104, + 408, + 506, + 424 + ], + "score": 1.0, + "content": "the best. See Figure 4 for evaluation RMSE. We apply dropout on the encoder output only, e.g.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 263, + 433 + ], + "score": 0.86, + "content": "f ( x ) = d e c o d e ( d r o p o u t ( e n c o d e ( x ) ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 421, + 505, + 434 + ], + "score": 1.0, + "content": ". We tried applying dropout after every layer of the model", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 432, + 395, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 395, + 445 + ], + "score": 1.0, + "content": "but that stifled training convergence and did not improve generalization.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19 + }, + { + "type": "image", + "bbox": [ + 182, + 454, + 428, + 580 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 182, + 454, + 428, + 580 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 182, + 454, + 428, + 580 + ], + "spans": [ + { + "bbox": [ + 182, + 454, + 428, + 580 + ], + "score": 0.967, + "type": "image", + "image_path": "1d42da41c3ad8938ff124090a7abb4a7d64268bb5591f52f0509568c13480560.jpg" + } + ] + } + ], + "index": 25, + "virtual_lines": [ + { + "bbox": [ + 182, + 454, + 428, + 496.0 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 182, + 496.0, + 428, + 538.0 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 182, + 538.0, + 428, + 580.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 595, + 506, + 640 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "score": 1.0, + "content": "Figure 4: Effects of dropout. Y-axis: evaluation RMSE, X-axis: epoch number. Model with no", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 607, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 506, + 619 + ], + "score": 1.0, + "content": "dropout (Drop Prob 0.0) clearly over-fits. Model with drop probability of 0.5 over-fits as well (but", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "score": 1.0, + "content": "much slowly). Models with drop probabilities of 0.65 and 0.8 result in RMSEs of 0.9192 and 0.9183", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 629, + 176, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 176, + 643 + ], + "score": 1.0, + "content": "correspondingly.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + } + ], + "index": 26.75 + }, + { + "type": "title", + "bbox": [ + 108, + 667, + 216, + 678 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 217, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 217, + 678 + ], + "score": 1.0, + "content": "3.6 DENSE RE-FEEDING", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "Iterative dense re-feeding (see Section 2.2) provides us with additional improvement in evaluation", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 237, + 711 + ], + "score": 1.0, + "content": "accuracy for our 6-layer-model:", + "type": "text" + }, + { + "bbox": [ + 237, + 700, + 245, + 709 + ], + "score": 0.44, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 699, + 311, + 711 + ], + "score": 1.0, + "content": ", 512, 512, 1024,", + "type": "text" + }, + { + "bbox": [ + 311, + 699, + 343, + 711 + ], + "score": 0.48, + "content": "d p ( 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 699, + 384, + 711 + ], + "score": 1.0, + "content": ", 512, 512,", + "type": "text" + }, + { + "bbox": [ + 385, + 700, + 392, + 709 + ], + "score": 0.64, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "(referred to as Baseline be-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 455, + 723 + ], + "score": 1.0, + "content": "low). Here each parameter denotes the number of inputs, hidden units, or outputs and", + "type": "text" + }, + { + "bbox": [ + 455, + 709, + 487, + 721 + ], + "score": 0.86, + "content": "d p ( 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "dropout layer with a drop probability of 0.8. Just applying output re-feeding did not have significant", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 310, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 190, + 115, + 421, + 217 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 504, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 506, + 101 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 506, + 101 + ], + "score": 1.0, + "content": "Table 2: Depth helps generalization. Evaluation RMSE of the models with different number of", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 100, + 322, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 322, + 111 + ], + "score": 1.0, + "content": "layers. In all cases the hidden layer dimension is 128.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 190, + 115, + 421, + 217 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 190, + 115, + 421, + 217 + ], + "spans": [ + { + "bbox": [ + 190, + 115, + 421, + 217 + ], + "score": 0.975, + "html": "
Number of layersEvaluation RMSEparams
21.1464,566,504
40.96154,599,528
60.93784,632,552
8 100.93644,665,576
120.9340 0.93284,698,600
4,731,624
", + "type": "table", + "image_path": "88fcfcca1263e20a032f9acfaef74ea8491daebbea86756b7bd10814e85b9e95.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 190, + 115, + 421, + 129.57142857142858 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 190, + 129.57142857142858, + 421, + 144.14285714285717 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 190, + 144.14285714285717, + 421, + 158.71428571428575 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 190, + 158.71428571428575, + 421, + 173.28571428571433 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 190, + 173.28571428571433, + 421, + 187.85714285714292 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 190, + 187.85714285714292, + 421, + 202.4285714285715 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 190, + 202.4285714285715, + 421, + 217.00000000000009 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 254, + 505, + 309 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "Going from one layer in encoder and decoder to three layers in both provides good improvement in", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 278 + ], + "score": 1.0, + "content": "evaluation RMSE (from 1.146 to 0.9378). After that, blindly adding more layers does help, however", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 275, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 376, + 289 + ], + "score": 1.0, + "content": "it provides diminishing returns. Note that the model with single", + "type": "text" + }, + { + "bbox": [ + 376, + 276, + 416, + 286 + ], + "score": 0.89, + "content": "d \\ : = \\ : 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 275, + 505, + 289 + ], + "score": 1.0, + "content": "layer in encoder and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 286, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 505, + 300 + ], + "score": 1.0, + "content": "decoder has 9,115,240 parameters which is almost two times more than any of these deep models", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 298, + 330, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 330, + 310 + ], + "score": 1.0, + "content": "while having much worse evauation RMSE (above 1.0).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 254, + 505, + 310 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 323, + 174, + 335 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 176, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 176, + 336 + ], + "score": 1.0, + "content": "3.5 DROPOUT", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 344, + 505, + 444 + ], + "lines": [ + { + "bbox": [ + 105, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "Section 3.4 shows us that adding too many small layers eventually hits diminishing returns. Thus, we", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 354, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 505, + 369 + ], + "score": 1.0, + "content": "start experimenting with model architecture and hyper-parameters more broadly. Our most promis-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 366, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 279, + 379 + ], + "score": 1.0, + "content": "ing model has the following architecture:", + "type": "text" + }, + { + "bbox": [ + 279, + 366, + 399, + 378 + ], + "score": 0.59, + "content": "n , 5 1 2 , 5 1 2 , 1 0 2 4 , 5 1 2 , 5 1 2 , n .", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 366, + 505, + 379 + ], + "score": 1.0, + "content": ", which means 3 layers in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 377, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 506, + 389 + ], + "score": 1.0, + "content": "encoder (512,512,1024), coding layer of 1024 and 3 layers in decoder of size 512,512,n. This", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "score": 1.0, + "content": "model, however, quickly over-fits if trained with no regularization. To regularize it, we tried several", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "score": 1.0, + "content": "dropout values and, interestingly, very high values of drop probability (e.g. 0.8) turned out to be", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 408, + 506, + 424 + ], + "spans": [ + { + "bbox": [ + 104, + 408, + 506, + 424 + ], + "score": 1.0, + "content": "the best. See Figure 4 for evaluation RMSE. We apply dropout on the encoder output only, e.g.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 263, + 433 + ], + "score": 0.86, + "content": "f ( x ) = d e c o d e ( d r o p o u t ( e n c o d e ( x ) ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 421, + 505, + 434 + ], + "score": 1.0, + "content": ". We tried applying dropout after every layer of the model", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 432, + 395, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 395, + 445 + ], + "score": 1.0, + "content": "but that stifled training convergence and did not improve generalization.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19, + "bbox_fs": [ + 104, + 343, + 506, + 445 + ] + }, + { + "type": "image", + "bbox": [ + 182, + 454, + 428, + 580 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 182, + 454, + 428, + 580 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 182, + 454, + 428, + 580 + ], + "spans": [ + { + "bbox": [ + 182, + 454, + 428, + 580 + ], + "score": 0.967, + "type": "image", + "image_path": "1d42da41c3ad8938ff124090a7abb4a7d64268bb5591f52f0509568c13480560.jpg" + } + ] + } + ], + "index": 25, + "virtual_lines": [ + { + "bbox": [ + 182, + 454, + 428, + 496.0 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 182, + 496.0, + 428, + 538.0 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 182, + 538.0, + 428, + 580.0 + ], + "spans": [], + "index": 26 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 595, + 506, + 640 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "score": 1.0, + "content": "Figure 4: Effects of dropout. Y-axis: evaluation RMSE, X-axis: epoch number. Model with no", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 607, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 106, + 607, + 506, + 619 + ], + "score": 1.0, + "content": "dropout (Drop Prob 0.0) clearly over-fits. Model with drop probability of 0.5 over-fits as well (but", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "score": 1.0, + "content": "much slowly). Models with drop probabilities of 0.65 and 0.8 result in RMSEs of 0.9192 and 0.9183", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 629, + 176, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 176, + 643 + ], + "score": 1.0, + "content": "correspondingly.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + } + ], + "index": 26.75 + }, + { + "type": "title", + "bbox": [ + 108, + 667, + 216, + 678 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 217, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 217, + 678 + ], + "score": 1.0, + "content": "3.6 DENSE RE-FEEDING", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "Iterative dense re-feeding (see Section 2.2) provides us with additional improvement in evaluation", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 237, + 711 + ], + "score": 1.0, + "content": "accuracy for our 6-layer-model:", + "type": "text" + }, + { + "bbox": [ + 237, + 700, + 245, + 709 + ], + "score": 0.44, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 699, + 311, + 711 + ], + "score": 1.0, + "content": ", 512, 512, 1024,", + "type": "text" + }, + { + "bbox": [ + 311, + 699, + 343, + 711 + ], + "score": 0.48, + "content": "d p ( 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 699, + 384, + 711 + ], + "score": 1.0, + "content": ", 512, 512,", + "type": "text" + }, + { + "bbox": [ + 385, + 700, + 392, + 709 + ], + "score": 0.64, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "(referred to as Baseline be-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 455, + 723 + ], + "score": 1.0, + "content": "low). Here each parameter denotes the number of inputs, hidden units, or outputs and", + "type": "text" + }, + { + "bbox": [ + 455, + 709, + 487, + 721 + ], + "score": 0.86, + "content": "d p ( 0 . 8 )", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "dropout layer with a drop probability of 0.8. Just applying output re-feeding did not have significant", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 218, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 506, + 231 + ], + "score": 1.0, + "content": "impact on the model performance. However, in conjunction with the higher learning rate, it did", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 230, + 505, + 242 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 505, + 242 + ], + "score": 1.0, + "content": "significantly increase the model performance. Note, that with this higher learning rate (0.005) but", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 241, + 424, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 424, + 253 + ], + "score": 1.0, + "content": "without dense re-feeding, the model started to diverge. See Figure 5 for details.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 688, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 180, + 114, + 430, + 173 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 105, + 89, + 504, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Table 3: Test RMSE of different models. I-AR, U-AR and RRN numbers are taken from (Wu et al.,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 98, + 134, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 98, + 134, + 113 + ], + "score": 1.0, + "content": "2017)", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 180, + 114, + 430, + 173 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 180, + 114, + 430, + 173 + ], + "spans": [ + { + "bbox": [ + 180, + 114, + 430, + 173 + ], + "score": 0.974, + "html": "
DataSetI-ARU-ARRRNDeepRec
Netflix 3 months Netfix Full
0.97780.98360.94270.9373
0.93640.96470.92240.9099
", + "type": "table", + "image_path": "89ef14c3de00dd1d762baf07ab626bac7c2f3f10836603e833ad767ad6532fab.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 180, + 114, + 430, + 133.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 180, + 133.66666666666666, + 430, + 153.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 180, + 153.33333333333331, + 430, + 172.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 107, + 218, + 505, + 252 + ], + "lines": [ + { + "bbox": [ + 105, + 218, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 506, + 231 + ], + "score": 1.0, + "content": "impact on the model performance. However, in conjunction with the higher learning rate, it did", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 230, + 505, + 242 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 505, + 242 + ], + "score": 1.0, + "content": "significantly increase the model performance. Note, that with this higher learning rate (0.005) but", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 241, + 424, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 424, + 253 + ], + "score": 1.0, + "content": "without dense re-feeding, the model started to diverge. See Figure 5 for details.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "image", + "bbox": [ + 183, + 273, + 425, + 424 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 183, + 273, + 425, + 424 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 183, + 273, + 425, + 424 + ], + "spans": [ + { + "bbox": [ + 183, + 273, + 425, + 424 + ], + "score": 0.967, + "type": "image", + "image_path": "b589cd81bc68f7c0374d34eb5d18286cf197a9628be19ee2e0751e9faaaf5554.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 183, + 273, + 425, + 286.72727272727275 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 183, + 286.72727272727275, + 425, + 300.4545454545455 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 183, + 300.4545454545455, + 425, + 314.18181818181824 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 183, + 314.18181818181824, + 425, + 327.909090909091 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 183, + 327.909090909091, + 425, + 341.63636363636374 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 183, + 341.63636363636374, + 425, + 355.3636363636365 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 183, + 355.3636363636365, + 425, + 369.09090909090924 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 183, + 369.09090909090924, + 425, + 382.818181818182 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 183, + 382.818181818182, + 425, + 396.54545454545473 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 183, + 396.54545454545473, + 425, + 410.2727272727275 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 183, + 410.2727272727275, + 425, + 424.0000000000002 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 441, + 505, + 496 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 371, + 453 + ], + "score": 1.0, + "content": "Figure 5: Effects of dense re-feeding. Y-axis: evaluation RMSE,", + "type": "text" + }, + { + "bbox": [ + 371, + 441, + 380, + 451 + ], + "score": 0.28, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "-axis: epoch number. Baseline", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "model was trained with learning rate of 0.001. Applying re-feeding step with the same learning", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "rate almost did not help (Baseline RF). Learning rate of 0.005 (Baseline LR 0.005) is too big for", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 472, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 505, + 488 + ], + "score": 1.0, + "content": "baseline model without re-feeding. However, increasing both learning rate and applying re-feeding", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 485, + 279, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 279, + 498 + ], + "score": 1.0, + "content": "step clearly helps (Baseline LR 0.005 RF).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + } + ], + "index": 17.0 + }, + { + "type": "text", + "bbox": [ + 108, + 523, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "Applying dense re-feeding and increasing the learning rate, allowed us to further improve the evalua-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 533, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 505, + 547 + ], + "score": 1.0, + "content": "tion RMSE from 0.9167 to 0.9100. Picking a checkpoint with best evaluation RMSE and computing", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 545, + 459, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 459, + 558 + ], + "score": 1.0, + "content": "test RMSE gives as 0.9099, which we believe is significantly better than other methods.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25 + }, + { + "type": "title", + "bbox": [ + 108, + 580, + 290, + 591 + ], + "lines": [ + { + "bbox": [ + 106, + 580, + 291, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 291, + 592 + ], + "score": 1.0, + "content": "3.7 COMPARISON WITH OTHER METHODS", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "We compare our best model with Recurrent Recommender Network from Wu et al. (2017) which", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "has been shown to outperform PMF (Mnih & Salakhutdinov, 2008), T-SVD (Koren, 2010) and I/U-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "AR (Sedhain et al., 2015) on the data we use (see Table 1 for data description). Note, that unlike", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 636, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 651 + ], + "score": 1.0, + "content": "T-SVD and RRN, our method does not explicitly take into account temporal dynamics of ratings.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "Yet, Table 3 shows that it is still capable of outperforming these methods on future rating prediction", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "task. We train each model using only the training set and compute evaluation RMSE for 100 epochs.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 670, + 424, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 424, + 683 + ], + "score": 1.0, + "content": "Then the checkpoint with the highest evaluation RMSE is tested on the test set.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "“Netflix 3 months” has 7 times less training data compared to “Netflix full”, it is therefore, not", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "surprising that the model’s performance is significantly worse if trained on this data alone (0.9373", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "vs 0.9099). In fact, the model that performs best on “Netflix full” over-fits on this set, and we had", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 390, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 390, + 732 + ], + "score": 1.0, + "content": "to reduce the model’s complexity accordingly (see Table 4 for details).", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "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": "table", + "bbox": [ + 180, + 114, + 430, + 173 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 105, + 89, + 504, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 505, + 102 + ], + "score": 1.0, + "content": "Table 3: Test RMSE of different models. I-AR, U-AR and RRN numbers are taken from (Wu et al.,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 98, + 134, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 98, + 134, + 113 + ], + "score": 1.0, + "content": "2017)", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 180, + 114, + 430, + 173 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 180, + 114, + 430, + 173 + ], + "spans": [ + { + "bbox": [ + 180, + 114, + 430, + 173 + ], + "score": 0.974, + "html": "
DataSetI-ARU-ARRRNDeepRec
Netflix 3 months Netfix Full
0.97780.98360.94270.9373
0.93640.96470.92240.9099
", + "type": "table", + "image_path": "89ef14c3de00dd1d762baf07ab626bac7c2f3f10836603e833ad767ad6532fab.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 180, + 114, + 430, + 133.66666666666666 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 180, + 133.66666666666666, + 430, + 153.33333333333331 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 180, + 153.33333333333331, + 430, + 172.99999999999997 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 107, + 218, + 505, + 252 + ], + "lines": [], + "index": 6, + "bbox_fs": [ + 105, + 218, + 506, + 253 + ], + "lines_deleted": true + }, + { + "type": "image", + "bbox": [ + 183, + 273, + 425, + 424 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 183, + 273, + 425, + 424 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 183, + 273, + 425, + 424 + ], + "spans": [ + { + "bbox": [ + 183, + 273, + 425, + 424 + ], + "score": 0.967, + "type": "image", + "image_path": "b589cd81bc68f7c0374d34eb5d18286cf197a9628be19ee2e0751e9faaaf5554.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 183, + 273, + 425, + 286.72727272727275 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 183, + 286.72727272727275, + 425, + 300.4545454545455 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 183, + 300.4545454545455, + 425, + 314.18181818181824 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 183, + 314.18181818181824, + 425, + 327.909090909091 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 183, + 327.909090909091, + 425, + 341.63636363636374 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 183, + 341.63636363636374, + 425, + 355.3636363636365 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 183, + 355.3636363636365, + 425, + 369.09090909090924 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 183, + 369.09090909090924, + 425, + 382.818181818182 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 183, + 382.818181818182, + 425, + 396.54545454545473 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 183, + 396.54545454545473, + 425, + 410.2727272727275 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 183, + 410.2727272727275, + 425, + 424.0000000000002 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 441, + 505, + 496 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 441, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 371, + 453 + ], + "score": 1.0, + "content": "Figure 5: Effects of dense re-feeding. Y-axis: evaluation RMSE,", + "type": "text" + }, + { + "bbox": [ + 371, + 441, + 380, + 451 + ], + "score": 0.28, + "content": "\\mathbf { X }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 441, + 505, + 453 + ], + "score": 1.0, + "content": "-axis: epoch number. Baseline", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "model was trained with learning rate of 0.001. Applying re-feeding step with the same learning", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 506, + 476 + ], + "score": 1.0, + "content": "rate almost did not help (Baseline RF). Learning rate of 0.005 (Baseline LR 0.005) is too big for", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 472, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 505, + 488 + ], + "score": 1.0, + "content": "baseline model without re-feeding. However, increasing both learning rate and applying re-feeding", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 485, + 279, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 279, + 498 + ], + "score": 1.0, + "content": "step clearly helps (Baseline LR 0.005 RF).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + } + ], + "index": 17.0 + }, + { + "type": "text", + "bbox": [ + 108, + 523, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 536 + ], + "score": 1.0, + "content": "Applying dense re-feeding and increasing the learning rate, allowed us to further improve the evalua-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 533, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 505, + 547 + ], + "score": 1.0, + "content": "tion RMSE from 0.9167 to 0.9100. Picking a checkpoint with best evaluation RMSE and computing", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 545, + 459, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 459, + 558 + ], + "score": 1.0, + "content": "test RMSE gives as 0.9099, which we believe is significantly better than other methods.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 523, + 505, + 558 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 580, + 290, + 591 + ], + "lines": [ + { + "bbox": [ + 106, + 580, + 291, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 580, + 291, + 592 + ], + "score": 1.0, + "content": "3.7 COMPARISON WITH OTHER METHODS", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "We compare our best model with Recurrent Recommender Network from Wu et al. (2017) which", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "has been shown to outperform PMF (Mnih & Salakhutdinov, 2008), T-SVD (Koren, 2010) and I/U-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 505, + 639 + ], + "score": 1.0, + "content": "AR (Sedhain et al., 2015) on the data we use (see Table 1 for data description). Note, that unlike", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 636, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 505, + 651 + ], + "score": 1.0, + "content": "T-SVD and RRN, our method does not explicitly take into account temporal dynamics of ratings.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "Yet, Table 3 shows that it is still capable of outperforming these methods on future rating prediction", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "task. We train each model using only the training set and compute evaluation RMSE for 100 epochs.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 670, + 424, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 424, + 683 + ], + "score": 1.0, + "content": "Then the checkpoint with the highest evaluation RMSE is tested on the test set.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 605, + 505, + 683 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "“Netflix 3 months” has 7 times less training data compared to “Netflix full”, it is therefore, not", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "surprising that the model’s performance is significantly worse if trained on this data alone (0.9373", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "vs 0.9099). In fact, the model that performs best on “Netflix full” over-fits on this set, and we had", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 720, + 390, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 390, + 732 + ], + "score": 1.0, + "content": "to reduce the model’s complexity accordingly (see Table 4 for details).", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 687, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 161, + 115, + 449, + 196 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 504, + 112 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 504, + 100 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 504, + 100 + ], + "score": 1.0, + "content": "Table 4: Test RMSE achieved by DeepRec on different Netflix subsets. All models are trained with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 101, + 321, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 101, + 321, + 112 + ], + "score": 1.0, + "content": "one iterative output re-feeding step per each iteration.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 161, + 115, + 449, + 196 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 161, + 115, + 449, + 196 + ], + "spans": [ + { + "bbox": [ + 161, + 115, + 449, + 196 + ], + "score": 0.979, + "html": "
DataSetRMSEModel Architecture
Netflix 3 months0.9373n,128,256,256,dp(0.65),256,128,n
Netflix 6 months0.9207n,256,256,512,dp(0.8),256,256,n
Netflix 1 year0.9225n,256,256,512,dp(0.8),256,256, n
Netfix Full0.9099n,512,512,1024,dp(0.8),512,512, n
", + "type": "table", + "image_path": "89907b1ebad481827acd0332cbbaef5f201eabc2a54538f92e01b86f1cd34677.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 161, + 115, + 449, + 142.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 161, + 142.0, + 449, + 169.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 161, + 169.0, + 449, + 196.0 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "title", + "bbox": [ + 107, + 230, + 196, + 243 + ], + "lines": [ + { + "bbox": [ + 104, + 229, + 197, + 246 + ], + "spans": [ + { + "bbox": [ + 104, + 229, + 197, + 246 + ], + "score": 1.0, + "content": "4 CONCLUSION", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 255, + 505, + 344 + ], + "lines": [ + { + "bbox": [ + 105, + 255, + 505, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 505, + 269 + ], + "score": 1.0, + "content": "Deep learning has revolutionized many areas of machine learning, and it is poised do so with recom-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 268, + 504, + 279 + ], + "spans": [ + { + "bbox": [ + 106, + 268, + 504, + 279 + ], + "score": 1.0, + "content": "mender systems as well. In this paper we demonstrated how very deep autoencoders can be success-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "score": 1.0, + "content": "fully trained even on relatively small amounts of data by using both well established (dropout) and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "relatively recent (“scaled exponential linear units”) deep learning techniques. Further, we introduced", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 300, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 505, + 312 + ], + "score": 1.0, + "content": "iterative output re-feeding - a technique which allowed us to perform dense updates in collaborative", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 310, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 506, + 325 + ], + "score": 1.0, + "content": "filtering, increase learning rate and further improve generalization performance of our model. On", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "score": 1.0, + "content": "the task of future rating prediction, our model outperforms other approaches even without using", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 333, + 219, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 219, + 345 + ], + "score": 1.0, + "content": "additional temporal signals.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 349, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "score": 1.0, + "content": "While our code supports item-based model (such as I-AutoRec) we argue that this approach is less", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 360, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 506, + 374 + ], + "score": 1.0, + "content": "practical than user-based model (U-AutoRec). This is because in real-world recommender systems,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "there are usually much more users then items. Finally, when building personalized recommender", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 383, + 472, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 472, + 395 + ], + "score": 1.0, + "content": "system and faced with scaling problems, it can be acceptable to sample items but not users.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "title", + "bbox": [ + 108, + 407, + 200, + 417 + ], + "lines": [ + { + "bbox": [ + 107, + 407, + 200, + 418 + ], + "spans": [ + { + "bbox": [ + 107, + 407, + 200, + 418 + ], + "score": 1.0, + "content": "ACKNOWLEDGMENTS", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 108, + 425, + 504, + 447 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 506, + 439 + ], + "score": 1.0, + "content": "We thank the author of (Wu et al., 2017), Chao-Yuan Wu, for fruitfull discussion and help validating", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 436, + 161, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 161, + 448 + ], + "score": 1.0, + "content": "our data sets.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 107, + 464, + 175, + 477 + ], + "lines": [ + { + "bbox": [ + 106, + 465, + 176, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 176, + 478 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 483, + 503, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 504, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 504, + 497 + ], + "score": 1.0, + "content": "Gediminas Adomavicius and Alexander Tuzhilin. Context-aware recommender systems. In Recom-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 494, + 344, + 506 + ], + "spans": [ + { + "bbox": [ + 116, + 494, + 344, + 506 + ], + "score": 1.0, + "content": "mender systems handbook, pp. 217–253. Springer, 2011.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 513, + 504, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 511, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 527 + ], + "score": 1.0, + "content": "James Bennett, Stan Lanning, and Netflix Netflix. The netflix prize. In In KDD Cup and Workshop", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 525, + 247, + 537 + ], + "spans": [ + { + "bbox": [ + 116, + 525, + 247, + 537 + ], + "score": 1.0, + "content": "in conjunction with KDD, 2007.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 543, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "score": 1.0, + "content": "John S. Breese, David Heckerman, and Carl Kadie. Empirical analysis of predictive algorithms for", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 117, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 117, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "collaborative filtering. In Proceedings of the Fourteenth Conference on Uncertainty in Artificial", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 567, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 116, + 567, + 505, + 578 + ], + "score": 1.0, + "content": "Intelligence, UAI’98, pp. 43–52, San Francisco, CA, USA, 1998. Morgan Kaufmann Publishers", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 577, + 504, + 590 + ], + "spans": [ + { + "bbox": [ + 115, + 577, + 504, + 590 + ], + "score": 1.0, + "content": "Inc. ISBN 1-55860-555-X. URL http://dl.acm.org/citation.cfm?id=2074094.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 588, + 163, + 599 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 163, + 599 + ], + "score": 1.0, + "content": "2074100.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 105, + 606, + 504, + 630 + ], + "lines": [ + { + "bbox": [ + 106, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network´", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 618, + 451, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 618, + 451, + 631 + ], + "score": 1.0, + "content": "learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 108, + 637, + 503, + 672 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "Xiangnan He, Lizi Liao, Hanwang Zhang, Liqiang Nie, Xia Hu, and Tat-Seng Chua. Neural col-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 115, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "laborative filtering. In Proceedings of the 26th International Conference on World Wide Web, pp.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 659, + 444, + 672 + ], + "spans": [ + { + "bbox": [ + 116, + 659, + 444, + 672 + ], + "score": 1.0, + "content": "173–182. International World Wide Web Conferences Steering Committee, 2017.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 679, + 503, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "score": 1.0, + "content": "Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 690, + 302, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 302, + 702 + ], + "score": 1.0, + "content": "networks. science, 313(5786):504–507, 2006.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 107, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 107, + 709, + 319, + 721 + ], + "score": 1.0, + "content": "Geoffrey E Hinton and Richard S. Zemel.", + "type": "text" + }, + { + "bbox": [ + 338, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "Autoencoders, minimum description", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 718, + 504, + 734 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 286, + 734 + ], + "score": 1.0, + "content": "length and helmholtz free energy.", + "type": "text" + }, + { + "bbox": [ + 295, + 720, + 504, + 732 + ], + "score": 1.0, + "content": "In J. D. Cowan, G. Tesauro, and J. Al-", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 300, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 161, + 115, + 449, + 196 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 89, + 504, + 112 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 89, + 504, + 100 + ], + "spans": [ + { + "bbox": [ + 106, + 89, + 504, + 100 + ], + "score": 1.0, + "content": "Table 4: Test RMSE achieved by DeepRec on different Netflix subsets. All models are trained with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 101, + 321, + 112 + ], + "spans": [ + { + "bbox": [ + 106, + 101, + 321, + 112 + ], + "score": 1.0, + "content": "one iterative output re-feeding step per each iteration.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 161, + 115, + 449, + 196 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 161, + 115, + 449, + 196 + ], + "spans": [ + { + "bbox": [ + 161, + 115, + 449, + 196 + ], + "score": 0.979, + "html": "
DataSetRMSEModel Architecture
Netflix 3 months0.9373n,128,256,256,dp(0.65),256,128,n
Netflix 6 months0.9207n,256,256,512,dp(0.8),256,256,n
Netflix 1 year0.9225n,256,256,512,dp(0.8),256,256, n
Netfix Full0.9099n,512,512,1024,dp(0.8),512,512, n
", + "type": "table", + "image_path": "89907b1ebad481827acd0332cbbaef5f201eabc2a54538f92e01b86f1cd34677.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 161, + 115, + 449, + 142.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 161, + 142.0, + 449, + 169.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 161, + 169.0, + 449, + 196.0 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "title", + "bbox": [ + 107, + 230, + 196, + 243 + ], + "lines": [ + { + "bbox": [ + 104, + 229, + 197, + 246 + ], + "spans": [ + { + "bbox": [ + 104, + 229, + 197, + 246 + ], + "score": 1.0, + "content": "4 CONCLUSION", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 255, + 505, + 344 + ], + "lines": [ + { + "bbox": [ + 105, + 255, + 505, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 505, + 269 + ], + "score": 1.0, + "content": "Deep learning has revolutionized many areas of machine learning, and it is poised do so with recom-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 268, + 504, + 279 + ], + "spans": [ + { + "bbox": [ + 106, + 268, + 504, + 279 + ], + "score": 1.0, + "content": "mender systems as well. In this paper we demonstrated how very deep autoencoders can be success-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 290 + ], + "score": 1.0, + "content": "fully trained even on relatively small amounts of data by using both well established (dropout) and", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 289, + 505, + 301 + ], + "score": 1.0, + "content": "relatively recent (“scaled exponential linear units”) deep learning techniques. Further, we introduced", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 300, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 505, + 312 + ], + "score": 1.0, + "content": "iterative output re-feeding - a technique which allowed us to perform dense updates in collaborative", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 310, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 506, + 325 + ], + "score": 1.0, + "content": "filtering, increase learning rate and further improve generalization performance of our model. On", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "spans": [ + { + "bbox": [ + 105, + 321, + 506, + 335 + ], + "score": 1.0, + "content": "the task of future rating prediction, our model outperforms other approaches even without using", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 333, + 219, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 333, + 219, + 345 + ], + "score": 1.0, + "content": "additional temporal signals.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 255, + 506, + 345 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 349, + 505, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "score": 1.0, + "content": "While our code supports item-based model (such as I-AutoRec) we argue that this approach is less", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 360, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 506, + 374 + ], + "score": 1.0, + "content": "practical than user-based model (U-AutoRec). This is because in real-world recommender systems,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "there are usually much more users then items. Finally, when building personalized recommender", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 383, + 472, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 472, + 395 + ], + "score": 1.0, + "content": "system and faced with scaling problems, it can be acceptable to sample items but not users.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 349, + 506, + 395 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 407, + 200, + 417 + ], + "lines": [ + { + "bbox": [ + 107, + 407, + 200, + 418 + ], + "spans": [ + { + "bbox": [ + 107, + 407, + 200, + 418 + ], + "score": 1.0, + "content": "ACKNOWLEDGMENTS", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 108, + 425, + 504, + 447 + ], + "lines": [ + { + "bbox": [ + 105, + 423, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 506, + 439 + ], + "score": 1.0, + "content": "We thank the author of (Wu et al., 2017), Chao-Yuan Wu, for fruitfull discussion and help validating", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 436, + 161, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 436, + 161, + 448 + ], + "score": 1.0, + "content": "our data sets.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 423, + 506, + 448 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 464, + 175, + 477 + ], + "lines": [ + { + "bbox": [ + 106, + 465, + 176, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 465, + 176, + 478 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 483, + 503, + 506 + ], + "lines": [ + { + "bbox": [ + 105, + 482, + 504, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 504, + 497 + ], + "score": 1.0, + "content": "Gediminas Adomavicius and Alexander Tuzhilin. Context-aware recommender systems. In Recom-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 494, + 344, + 506 + ], + "spans": [ + { + "bbox": [ + 116, + 494, + 344, + 506 + ], + "score": 1.0, + "content": "mender systems handbook, pp. 217–253. Springer, 2011.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 482, + 504, + 506 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 513, + 504, + 536 + ], + "lines": [ + { + "bbox": [ + 105, + 511, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 527 + ], + "score": 1.0, + "content": "James Bennett, Stan Lanning, and Netflix Netflix. The netflix prize. In In KDD Cup and Workshop", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 525, + 247, + 537 + ], + "spans": [ + { + "bbox": [ + 116, + 525, + 247, + 537 + ], + "score": 1.0, + "content": "in conjunction with KDD, 2007.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 511, + 505, + 537 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 543, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 505, + 556 + ], + "score": 1.0, + "content": "John S. Breese, David Heckerman, and Carl Kadie. Empirical analysis of predictive algorithms for", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 117, + 556, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 117, + 556, + 505, + 568 + ], + "score": 1.0, + "content": "collaborative filtering. In Proceedings of the Fourteenth Conference on Uncertainty in Artificial", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 567, + 505, + 578 + ], + "spans": [ + { + "bbox": [ + 116, + 567, + 505, + 578 + ], + "score": 1.0, + "content": "Intelligence, UAI’98, pp. 43–52, San Francisco, CA, USA, 1998. Morgan Kaufmann Publishers", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 577, + 504, + 590 + ], + "spans": [ + { + "bbox": [ + 115, + 577, + 504, + 590 + ], + "score": 1.0, + "content": "Inc. ISBN 1-55860-555-X. URL http://dl.acm.org/citation.cfm?id=2074094.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 588, + 163, + 599 + ], + "spans": [ + { + "bbox": [ + 115, + 588, + 163, + 599 + ], + "score": 1.0, + "content": "2074100.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28, + "bbox_fs": [ + 106, + 544, + 505, + 599 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 606, + 504, + 630 + ], + "lines": [ + { + "bbox": [ + 106, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network´", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 618, + 451, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 618, + 451, + 631 + ], + "score": 1.0, + "content": "learning by exponential linear units (elus). arXiv preprint arXiv:1511.07289, 2015.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5, + "bbox_fs": [ + 106, + 606, + 505, + 631 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 637, + 503, + 672 + ], + "lines": [ + { + "bbox": [ + 106, + 637, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 637, + 505, + 651 + ], + "score": 1.0, + "content": "Xiangnan He, Lizi Liao, Hanwang Zhang, Liqiang Nie, Xia Hu, and Tat-Seng Chua. Neural col-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 648, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 115, + 648, + 505, + 662 + ], + "score": 1.0, + "content": "laborative filtering. In Proceedings of the 26th International Conference on World Wide Web, pp.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 659, + 444, + 672 + ], + "spans": [ + { + "bbox": [ + 116, + 659, + 444, + 672 + ], + "score": 1.0, + "content": "173–182. International World Wide Web Conferences Steering Committee, 2017.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 106, + 637, + 505, + 672 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 679, + 503, + 702 + ], + "lines": [ + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 505, + 691 + ], + "score": 1.0, + "content": "Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 690, + 302, + 702 + ], + "spans": [ + { + "bbox": [ + 116, + 690, + 302, + 702 + ], + "score": 1.0, + "content": "networks. science, 313(5786):504–507, 2006.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 106, + 679, + 505, + 702 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 502, + 732 + ], + "lines": [ + { + "bbox": [ + 107, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 107, + 709, + 319, + 721 + ], + "score": 1.0, + "content": "Geoffrey E Hinton and Richard S. Zemel.", + "type": "text" + }, + { + "bbox": [ + 338, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "Autoencoders, minimum description", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 718, + 504, + 734 + ], + "spans": [ + { + "bbox": [ + 115, + 718, + 286, + 734 + ], + "score": 1.0, + "content": "length and helmholtz free energy.", + "type": "text" + }, + { + "bbox": [ + 295, + 720, + 504, + 732 + ], + "score": 1.0, + "content": "In J. D. Cowan, G. Tesauro, and J. Al-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 115, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "spector (eds.), Advances in Neural Information Processing Systems 6, pp. 3–", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 92, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 92, + 231, + 106 + ], + "score": 1.0, + "content": "10. Morgan-Kaufmann,", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 236, + 93, + 264, + 105 + ], + "score": 1.0, + "content": "1994.", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 299, + 92, + 505, + 106 + ], + "score": 1.0, + "content": "URL http://papers.nips.cc/paper/", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 103, + 541, + 118 + ], + "spans": [ + { + "bbox": [ + 115, + 103, + 541, + 118 + ], + "score": 1.0, + "content": "798-autoencoders-minimum-description-length-and-helmholtz-free-energy.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 116, + 139, + 126 + ], + "spans": [ + { + "bbox": [ + 114, + 116, + 139, + 126 + ], + "score": 1.0, + "content": "pdf.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + } + ], + "index": 38.5, + "bbox_fs": [ + 107, + 708, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 115, + 82, + 538, + 127 + ], + "lines": [ + { + "bbox": [ + 115, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 115, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "spector (eds.), Advances in Neural Information Processing Systems 6, pp. 3–", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 92, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 92, + 231, + 106 + ], + "score": 1.0, + "content": "10. Morgan-Kaufmann,", + "type": "text" + }, + { + "bbox": [ + 236, + 93, + 264, + 105 + ], + "score": 1.0, + "content": "1994.", + "type": "text" + }, + { + "bbox": [ + 299, + 92, + 505, + 106 + ], + "score": 1.0, + "content": "URL http://papers.nips.cc/paper/", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 103, + 541, + 118 + ], + "spans": [ + { + "bbox": [ + 115, + 103, + 541, + 118 + ], + "score": 1.0, + "content": "798-autoencoders-minimum-description-length-and-helmholtz-free-energy.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 116, + 139, + 126 + ], + "spans": [ + { + "bbox": [ + 114, + 116, + 139, + 126 + ], + "score": 1.0, + "content": "pdf.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 108, + 134, + 505, + 168 + ], + "lines": [ + { + "bbox": [ + 105, + 132, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 149 + ], + "score": 1.0, + "content": "Hyunsoo Kim and Haesun Park. Nonnegative matrix factorization based on alternating nonneg-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 117, + 146, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 117, + 146, + 505, + 157 + ], + "score": 1.0, + "content": "ativity constrained least squares and active set method. SIAM journal on matrix analysis and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 156, + 259, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 156, + 259, + 168 + ], + "score": 1.0, + "content": "applications, 30(2):713–730, 2008.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 174, + 504, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 173, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 189 + ], + "score": 1.0, + "content": "Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 186, + 348, + 198 + ], + "spans": [ + { + "bbox": [ + 115, + 186, + 348, + 198 + ], + "score": 1.0, + "content": "neural networks. arXiv preprint arXiv:1706.02515, 2017.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 107, + 204, + 504, + 228 + ], + "lines": [ + { + "bbox": [ + 106, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "Yehuda Koren. The bellkor solution to the netflix grand prize. Netflix prize documentation, 81:1–10,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 215, + 142, + 228 + ], + "spans": [ + { + "bbox": [ + 115, + 215, + 142, + 228 + ], + "score": 1.0, + "content": "2009.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 504, + 258 + ], + "lines": [ + { + "bbox": [ + 106, + 234, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 505, + 248 + ], + "score": 1.0, + "content": "Yehuda Koren. Collaborative filtering with temporal dynamics. Communications of the ACM, 53", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 246, + 186, + 258 + ], + "spans": [ + { + "bbox": [ + 116, + 246, + 186, + 258 + ], + "score": 1.0, + "content": "(4):89–97, 2010.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 107, + 264, + 504, + 288 + ], + "lines": [ + { + "bbox": [ + 106, + 264, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 505, + 278 + ], + "score": 1.0, + "content": "Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 276, + 250, + 288 + ], + "spans": [ + { + "bbox": [ + 115, + 276, + 250, + 288 + ], + "score": 1.0, + "content": "systems. Computer, 42(8), 2009.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 294, + 504, + 318 + ], + "lines": [ + { + "bbox": [ + 105, + 293, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 505, + 308 + ], + "score": 1.0, + "content": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 304, + 144, + 318 + ], + "spans": [ + { + "bbox": [ + 114, + 304, + 144, + 318 + ], + "score": 1.0, + "content": "2015.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 324, + 504, + 358 + ], + "lines": [ + { + "bbox": [ + 105, + 324, + 504, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 504, + 338 + ], + "score": 1.0, + "content": "Sheng Li, Jaya Kawale, and Yun Fu. Deep collaborative filtering via marginalized denoising auto-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 336, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 116, + 336, + 505, + 348 + ], + "score": 1.0, + "content": "encoder. In Proceedings of the 24th ACM International on Conference on Information and Knowl-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 346, + 301, + 358 + ], + "spans": [ + { + "bbox": [ + 116, + 346, + 301, + 358 + ], + "score": 1.0, + "content": "edge Management, pp. 811–820. ACM, 2015.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 365, + 504, + 388 + ], + "lines": [ + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "Andriy Mnih and Ruslan R Salakhutdinov. Probabilistic matrix factorization. In Advances in neural", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 376, + 336, + 389 + ], + "spans": [ + { + "bbox": [ + 115, + 376, + 336, + 389 + ], + "score": 1.0, + "content": "information processing systems, pp. 1257–1264, 2008.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 107, + 394, + 503, + 418 + ], + "lines": [ + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "Prajit Ramachandran, Barret Zoph, and Quoc V Le. Swish: a self-gated activation function. arXiv", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 406, + 254, + 417 + ], + "spans": [ + { + "bbox": [ + 114, + 406, + 254, + 417 + ], + "score": 1.0, + "content": "preprint arXiv:1710.05941, 2017.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 424, + 504, + 448 + ], + "lines": [ + { + "bbox": [ + 105, + 424, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 438 + ], + "score": 1.0, + "content": "Francesco Ricci, Lior Rokach, and Bracha Shapira. Introduction to recommender systems hand-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 436, + 393, + 448 + ], + "spans": [ + { + "bbox": [ + 116, + 436, + 393, + 448 + ], + "score": 1.0, + "content": "book. In Recommender systems handbook, pp. 1–35. Springer, 2011.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 454, + 504, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "score": 1.0, + "content": "Ruslan Salakhutdinov, Andriy Mnih, and Geoffrey Hinton. Restricted boltzmann machines for", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 465, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 115, + 465, + 506, + 480 + ], + "score": 1.0, + "content": "collaborative filtering. In Proceedings of the 24th international conference on Machine learning,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 477, + 224, + 488 + ], + "spans": [ + { + "bbox": [ + 115, + 477, + 224, + 488 + ], + "score": 1.0, + "content": "pp. 791–798. ACM, 2007.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 106, + 495, + 504, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 495, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 505, + 509 + ], + "score": 1.0, + "content": "Suvash Sedhain, Aditya Krishna Menon, Scott Sanner, and Lexing Xie. Autorec: Autoencoders", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 116, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "meet collaborative filtering. In Proceedings of the 24th International Conference on World Wide", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 117, + 517, + 245, + 531 + ], + "spans": [ + { + "bbox": [ + 117, + 517, + 245, + 531 + ], + "score": 1.0, + "content": "Web, pp. 111–112. ACM, 2015.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 104, + 536, + 504, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "Florian Strub and Jer´ emie Mary. Collaborative filtering with stacked denoising autoencoders and ´", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 547, + 426, + 560 + ], + "spans": [ + { + "bbox": [ + 115, + 547, + 426, + 560 + ], + "score": 1.0, + "content": "sparse inputs. In NIPS workshop on machine learning for eCommerce, 2015.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 504, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 504, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 504, + 580 + ], + "score": 1.0, + "content": "Hao Wang, Naiyan Wang, and Dit-Yan Yeung. Collaborative deep learning for recommender sys-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 116, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "tems. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discov-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 589, + 322, + 600 + ], + "spans": [ + { + "bbox": [ + 116, + 589, + 322, + 600 + ], + "score": 1.0, + "content": "ery and Data Mining, pp. 1235–1244. ACM, 2015.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 607, + 505, + 663 + ], + "lines": [ + { + "bbox": [ + 106, + 606, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 621 + ], + "score": 1.0, + "content": "Chao-Yuan Wu, Amr Ahmed, Alex Beutel, Alexander J. Smola, and How Jing. Recurrent recom-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 117, + 619, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 117, + 619, + 505, + 631 + ], + "score": 1.0, + "content": "mender networks. In Proceedings of the Tenth ACM International Conference on Web Search", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 629, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 115, + 629, + 505, + 642 + ], + "score": 1.0, + "content": "and Data Mining, WSDM ’17, pp. 495–503, New York, NY, USA, 2017. ACM. ISBN 978-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 115, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "1-4503-4675-7. doi: 10.1145/3018661.3018689. URL http://doi.acm.org/10.1145/", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 651, + 212, + 663 + ], + "spans": [ + { + "bbox": [ + 116, + 651, + 212, + 663 + ], + "score": 1.0, + "content": "3018661.3018689.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 106, + 669, + 503, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "Bing Xu, Naiyan Wang, Tianqi Chen, and Mu Li. Empirical evaluation of rectified activations in", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 681, + 374, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 374, + 693 + ], + "score": 1.0, + "content": "convolutional network. arXiv preprint arXiv:1505.00853, 2015.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 107, + 700, + 504, + 723 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "Yin Zheng, Bangsheng Tang, Wenkui Ding, and Hanning Zhou. A neural autoregressive approach", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 711, + 381, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 711, + 381, + 723 + ], + "score": 1.0, + "content": "to collaborative filtering. arXiv preprint arXiv:1605.09477, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 115, + 82, + 538, + 127 + ], + "lines": [], + "index": 1.5, + "bbox_fs": [ + 114, + 82, + 541, + 126 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 108, + 134, + 505, + 168 + ], + "lines": [ + { + "bbox": [ + 105, + 132, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 149 + ], + "score": 1.0, + "content": "Hyunsoo Kim and Haesun Park. Nonnegative matrix factorization based on alternating nonneg-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 117, + 146, + 505, + 157 + ], + "spans": [ + { + "bbox": [ + 117, + 146, + 505, + 157 + ], + "score": 1.0, + "content": "ativity constrained least squares and active set method. SIAM journal on matrix analysis and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 156, + 259, + 168 + ], + "spans": [ + { + "bbox": [ + 115, + 156, + 259, + 168 + ], + "score": 1.0, + "content": "applications, 30(2):713–730, 2008.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 132, + 505, + 168 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 174, + 504, + 198 + ], + "lines": [ + { + "bbox": [ + 105, + 173, + 506, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 189 + ], + "score": 1.0, + "content": "Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 186, + 348, + 198 + ], + "spans": [ + { + "bbox": [ + 115, + 186, + 348, + 198 + ], + "score": 1.0, + "content": "neural networks. arXiv preprint arXiv:1706.02515, 2017.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 173, + 506, + 198 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 204, + 504, + 228 + ], + "lines": [ + { + "bbox": [ + 106, + 204, + 505, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 204, + 505, + 217 + ], + "score": 1.0, + "content": "Yehuda Koren. The bellkor solution to the netflix grand prize. Netflix prize documentation, 81:1–10,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 215, + 142, + 228 + ], + "spans": [ + { + "bbox": [ + 115, + 215, + 142, + 228 + ], + "score": 1.0, + "content": "2009.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 106, + 204, + 505, + 228 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 504, + 258 + ], + "lines": [ + { + "bbox": [ + 106, + 234, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 505, + 248 + ], + "score": 1.0, + "content": "Yehuda Koren. Collaborative filtering with temporal dynamics. Communications of the ACM, 53", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 246, + 186, + 258 + ], + "spans": [ + { + "bbox": [ + 116, + 246, + 186, + 258 + ], + "score": 1.0, + "content": "(4):89–97, 2010.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 106, + 234, + 505, + 258 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 264, + 504, + 288 + ], + "lines": [ + { + "bbox": [ + 106, + 264, + 505, + 278 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 505, + 278 + ], + "score": 1.0, + "content": "Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 276, + 250, + 288 + ], + "spans": [ + { + "bbox": [ + 115, + 276, + 250, + 288 + ], + "score": 1.0, + "content": "systems. Computer, 42(8), 2009.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 264, + 505, + 288 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 294, + 504, + 318 + ], + "lines": [ + { + "bbox": [ + 105, + 293, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 505, + 308 + ], + "score": 1.0, + "content": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 304, + 144, + 318 + ], + "spans": [ + { + "bbox": [ + 114, + 304, + 144, + 318 + ], + "score": 1.0, + "content": "2015.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 293, + 505, + 318 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 324, + 504, + 358 + ], + "lines": [ + { + "bbox": [ + 105, + 324, + 504, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 504, + 338 + ], + "score": 1.0, + "content": "Sheng Li, Jaya Kawale, and Yun Fu. Deep collaborative filtering via marginalized denoising auto-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 336, + 505, + 348 + ], + "spans": [ + { + "bbox": [ + 116, + 336, + 505, + 348 + ], + "score": 1.0, + "content": "encoder. In Proceedings of the 24th ACM International on Conference on Information and Knowl-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 116, + 346, + 301, + 358 + ], + "spans": [ + { + "bbox": [ + 116, + 346, + 301, + 358 + ], + "score": 1.0, + "content": "edge Management, pp. 811–820. ACM, 2015.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 324, + 505, + 358 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 365, + 504, + 388 + ], + "lines": [ + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 505, + 378 + ], + "score": 1.0, + "content": "Andriy Mnih and Ruslan R Salakhutdinov. Probabilistic matrix factorization. In Advances in neural", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 376, + 336, + 389 + ], + "spans": [ + { + "bbox": [ + 115, + 376, + 336, + 389 + ], + "score": 1.0, + "content": "information processing systems, pp. 1257–1264, 2008.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5, + "bbox_fs": [ + 106, + 364, + 505, + 389 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 394, + 503, + 418 + ], + "lines": [ + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "Prajit Ramachandran, Barret Zoph, and Quoc V Le. Swish: a self-gated activation function. arXiv", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 406, + 254, + 417 + ], + "spans": [ + { + "bbox": [ + 114, + 406, + 254, + 417 + ], + "score": 1.0, + "content": "preprint arXiv:1710.05941, 2017.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 106, + 394, + 505, + 417 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 424, + 504, + 448 + ], + "lines": [ + { + "bbox": [ + 105, + 424, + 505, + 438 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 438 + ], + "score": 1.0, + "content": "Francesco Ricci, Lior Rokach, and Bracha Shapira. Introduction to recommender systems hand-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 436, + 393, + 448 + ], + "spans": [ + { + "bbox": [ + 116, + 436, + 393, + 448 + ], + "score": 1.0, + "content": "book. In Recommender systems handbook, pp. 1–35. Springer, 2011.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 424, + 505, + 448 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 454, + 504, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 467 + ], + "score": 1.0, + "content": "Ruslan Salakhutdinov, Andriy Mnih, and Geoffrey Hinton. Restricted boltzmann machines for", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 465, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 115, + 465, + 506, + 480 + ], + "score": 1.0, + "content": "collaborative filtering. In Proceedings of the 24th international conference on Machine learning,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 477, + 224, + 488 + ], + "spans": [ + { + "bbox": [ + 115, + 477, + 224, + 488 + ], + "score": 1.0, + "content": "pp. 791–798. ACM, 2007.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 106, + 455, + 506, + 488 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 495, + 504, + 529 + ], + "lines": [ + { + "bbox": [ + 106, + 495, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 505, + 509 + ], + "score": 1.0, + "content": "Suvash Sedhain, Aditya Krishna Menon, Scott Sanner, and Lexing Xie. Autorec: Autoencoders", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 116, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "meet collaborative filtering. In Proceedings of the 24th International Conference on World Wide", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 117, + 517, + 245, + 531 + ], + "spans": [ + { + "bbox": [ + 117, + 517, + 245, + 531 + ], + "score": 1.0, + "content": "Web, pp. 111–112. ACM, 2015.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 30, + "bbox_fs": [ + 106, + 495, + 505, + 531 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 536, + 504, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "Florian Strub and Jer´ emie Mary. Collaborative filtering with stacked denoising autoencoders and ´", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 547, + 426, + 560 + ], + "spans": [ + { + "bbox": [ + 115, + 547, + 426, + 560 + ], + "score": 1.0, + "content": "sparse inputs. In NIPS workshop on machine learning for eCommerce, 2015.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 536, + 505, + 560 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 504, + 601 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 504, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 504, + 580 + ], + "score": 1.0, + "content": "Hao Wang, Naiyan Wang, and Dit-Yan Yeung. Collaborative deep learning for recommender sys-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 116, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "tems. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discov-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 589, + 322, + 600 + ], + "spans": [ + { + "bbox": [ + 116, + 589, + 322, + 600 + ], + "score": 1.0, + "content": "ery and Data Mining, pp. 1235–1244. ACM, 2015.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 565, + 505, + 600 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 607, + 505, + 663 + ], + "lines": [ + { + "bbox": [ + 106, + 606, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 621 + ], + "score": 1.0, + "content": "Chao-Yuan Wu, Amr Ahmed, Alex Beutel, Alexander J. Smola, and How Jing. Recurrent recom-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 117, + 619, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 117, + 619, + 505, + 631 + ], + "score": 1.0, + "content": "mender networks. In Proceedings of the Tenth ACM International Conference on Web Search", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 629, + 505, + 642 + ], + "spans": [ + { + "bbox": [ + 115, + 629, + 505, + 642 + ], + "score": 1.0, + "content": "and Data Mining, WSDM ’17, pp. 495–503, New York, NY, USA, 2017. ACM. ISBN 978-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 639, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 115, + 639, + 505, + 653 + ], + "score": 1.0, + "content": "1-4503-4675-7. doi: 10.1145/3018661.3018689. URL http://doi.acm.org/10.1145/", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 651, + 212, + 663 + ], + "spans": [ + { + "bbox": [ + 116, + 651, + 212, + 663 + ], + "score": 1.0, + "content": "3018661.3018689.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39, + "bbox_fs": [ + 106, + 606, + 505, + 663 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 669, + 503, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "Bing Xu, Naiyan Wang, Tianqi Chen, and Mu Li. Empirical evaluation of rectified activations in", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 681, + 374, + 693 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 374, + 693 + ], + "score": 1.0, + "content": "convolutional network. arXiv preprint arXiv:1505.00853, 2015.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 106, + 670, + 505, + 693 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 700, + 504, + 723 + ], + "lines": [ + { + "bbox": [ + 106, + 699, + 505, + 713 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 713 + ], + "score": 1.0, + "content": "Yin Zheng, Bangsheng Tang, Wenkui Ding, and Hanning Zhou. A neural autoregressive approach", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 115, + 711, + 381, + 723 + ], + "spans": [ + { + "bbox": [ + 115, + 711, + 381, + 723 + ], + "score": 1.0, + "content": "to collaborative filtering. arXiv preprint arXiv:1605.09477, 2016.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 106, + 699, + 505, + 723 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file