| Configuration | Value |
| Optimizer | AdamW (Loshchilov & Hutter,2017) |
| Pre-training epochs | 300 |
| Peak learning rate | 1.2e-3 |
| Batch size | 2048 |
| Weight decay | 0.05 |
| Optimizer momentum | β1,β2 = 0.9,0.95 (Chen et al.,2020a) |
| Learning rate schedule | Cosine decay |
| Warmup epochs | 20 |
| Gradient clipping | 3.0 |
| Dropout (Srivastava et al., 2014) | X |
| Stochastic depth (Huang et al.,2016) | X |
| LayerScale (Touvron et al., 2021b) | X |
| Data augmentation | RandomResizedCrop |
| Pos.emb.in Transformer layers | 1-D absolute pos. emb. (Dosovitskiy et al., 2020) |
| Patch size | 16 |
| Pre-training resolution | 224 |
"
+ },
+ {
+ "category_id": 1,
+ "poly": [
+ 297,
+ 1148,
+ 1404,
+ 1148,
+ 1404,
+ 1363,
+ 297,
+ 1363
+ ],
+ "score": 0.977
+ },
+ {
+ "category_id": 1,
+ "poly": [
+ 299,
+ 1009,
+ 1402,
+ 1009,
+ 1402,
+ 1134,
+ 299,
+ 1134
+ ],
+ "score": 0.975
+ },
+ {
+ "category_id": 1,
+ "poly": [
+ 298,
+ 872,
+ 1403,
+ 872,
+ 1403,
+ 994,
+ 298,
+ 994
+ ],
+ "score": 0.974
+ },
+ {
+ "category_id": 3,
+ "poly": [
+ 299,
+ 223,
+ 1401,
+ 223,
+ 1401,
+ 432,
+ 299,
+ 432
+ ],
+ "score": 0.97
+ },
+ {
+ "category_id": 4,
+ "poly": [
+ 298,
+ 456,
+ 1404,
+ 456,
+ 1404,
+ 549,
+ 298,
+ 549
+ ],
+ "score": 0.96
+ },
+ {
+ "category_id": 1,
+ "poly": [
+ 299,
+ 667,
+ 1399,
+ 667,
+ 1399,
+ 760,
+ 299,
+ 760
+ ],
+ "score": 0.96
+ },
+ {
+ "category_id": 6,
+ "poly": [
+ 299,
+ 1388,
+ 1403,
+ 1388,
+ 1403,
+ 1483,
+ 299,
+ 1483
+ ],
+ "score": 0.914
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 299,
+ 76,
+ 814,
+ 76,
+ 814,
+ 105,
+ 299,
+ 105
+ ],
+ "score": 0.89
+ },
+ {
+ "category_id": 0,
+ "poly": [
+ 302,
+ 803,
+ 750,
+ 803,
+ 750,
+ 838,
+ 302,
+ 838
+ ],
+ "score": 0.88
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 836,
+ 2088,
+ 865,
+ 2088,
+ 865,
+ 2113,
+ 836,
+ 2113
+ ],
+ "score": 0.868
+ },
+ {
+ "category_id": 0,
+ "poly": [
+ 301,
+ 598,
+ 824,
+ 598,
+ 824,
+ 635,
+ 301,
+ 635
+ ],
+ "score": 0.836
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 723,
+ 1241,
+ 845,
+ 1241,
+ 845,
+ 1270,
+ 723,
+ 1270
+ ],
+ "score": 0.9,
+ "latex": "5 1 2 \\times 5 1 2"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 829,
+ 486,
+ 883,
+ 486,
+ 883,
+ 515,
+ 829,
+ 515
+ ],
+ "score": 0.87,
+ "latex": "7 5 \\%"
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 328.0,
+ 212.0,
+ 980.0,
+ 212.0,
+ 980.0,
+ 344.0,
+ 328.0,
+ 344.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1065.0,
+ 224.0,
+ 1328.0,
+ 224.0,
+ 1328.0,
+ 330.0,
+ 1065.0,
+ 330.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 454.0,
+ 1404.0,
+ 454.0,
+ 1404.0,
+ 492.0,
+ 294.0,
+ 492.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 487.0,
+ 828.0,
+ 487.0,
+ 828.0,
+ 521.0,
+ 296.0,
+ 521.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 884.0,
+ 487.0,
+ 1404.0,
+ 487.0,
+ 1404.0,
+ 521.0,
+ 884.0,
+ 521.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 515.0,
+ 975.0,
+ 515.0,
+ 975.0,
+ 554.0,
+ 293.0,
+ 554.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1389.0,
+ 1403.0,
+ 1389.0,
+ 1403.0,
+ 1423.0,
+ 294.0,
+ 1423.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1420.0,
+ 1407.0,
+ 1420.0,
+ 1407.0,
+ 1457.0,
+ 294.0,
+ 1457.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1448.0,
+ 734.0,
+ 1448.0,
+ 734.0,
+ 1489.0,
+ 293.0,
+ 1489.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 72.0,
+ 816.0,
+ 72.0,
+ 816.0,
+ 108.0,
+ 296.0,
+ 108.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 800.0,
+ 753.0,
+ 800.0,
+ 753.0,
+ 844.0,
+ 294.0,
+ 844.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 832.0,
+ 2085.0,
+ 870.0,
+ 2085.0,
+ 870.0,
+ 2122.0,
+ 832.0,
+ 2122.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 291.0,
+ 595.0,
+ 830.0,
+ 595.0,
+ 830.0,
+ 639.0,
+ 291.0,
+ 639.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 292.0,
+ 1146.0,
+ 1404.0,
+ 1146.0,
+ 1404.0,
+ 1185.0,
+ 292.0,
+ 1185.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1179.0,
+ 1406.0,
+ 1179.0,
+ 1406.0,
+ 1214.0,
+ 294.0,
+ 1214.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 1210.0,
+ 1406.0,
+ 1210.0,
+ 1406.0,
+ 1244.0,
+ 296.0,
+ 1244.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1241.0,
+ 722.0,
+ 1241.0,
+ 722.0,
+ 1275.0,
+ 295.0,
+ 1275.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 846.0,
+ 1241.0,
+ 1406.0,
+ 1241.0,
+ 1406.0,
+ 1275.0,
+ 846.0,
+ 1275.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 292.0,
+ 1268.0,
+ 1404.0,
+ 1268.0,
+ 1404.0,
+ 1306.0,
+ 292.0,
+ 1306.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1302.0,
+ 1404.0,
+ 1302.0,
+ 1404.0,
+ 1337.0,
+ 295.0,
+ 1337.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1332.0,
+ 838.0,
+ 1332.0,
+ 838.0,
+ 1366.0,
+ 295.0,
+ 1366.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1009.0,
+ 1406.0,
+ 1009.0,
+ 1406.0,
+ 1046.0,
+ 294.0,
+ 1046.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1042.0,
+ 1406.0,
+ 1042.0,
+ 1406.0,
+ 1075.0,
+ 295.0,
+ 1075.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1073.0,
+ 1404.0,
+ 1073.0,
+ 1404.0,
+ 1105.0,
+ 295.0,
+ 1105.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1102.0,
+ 1198.0,
+ 1102.0,
+ 1198.0,
+ 1138.0,
+ 295.0,
+ 1138.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 873.0,
+ 1403.0,
+ 873.0,
+ 1403.0,
+ 905.0,
+ 294.0,
+ 905.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 902.0,
+ 1405.0,
+ 902.0,
+ 1405.0,
+ 934.0,
+ 293.0,
+ 934.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 291.0,
+ 931.0,
+ 1404.0,
+ 931.0,
+ 1404.0,
+ 970.0,
+ 291.0,
+ 970.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 962.0,
+ 974.0,
+ 962.0,
+ 974.0,
+ 998.0,
+ 295.0,
+ 998.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 666.0,
+ 1403.0,
+ 666.0,
+ 1403.0,
+ 704.0,
+ 294.0,
+ 704.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 700.0,
+ 1402.0,
+ 700.0,
+ 1402.0,
+ 730.0,
+ 296.0,
+ 730.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 728.0,
+ 1064.0,
+ 728.0,
+ 1064.0,
+ 765.0,
+ 294.0,
+ 765.0
+ ],
+ "score": 1.0,
+ "text": ""
+ }
+ ],
+ "page_info": {
+ "page_no": 17,
+ "width": 1700,
+ "height": 2200
+ }
+ },
+ {
+ "layout_dets": [
+ {
+ "category_id": 5,
+ "poly": [
+ 294,
+ 1075,
+ 1407,
+ 1075,
+ 1407,
+ 1666,
+ 294,
+ 1666
+ ],
+ "score": 0.983,
+ "html": "| Configuration | 100 epoch FT | 300 epoch FT |
| Optimizer | AdamW (Loshchilov & Hutter,2017) |
| Peak learning rate | 12e-3 |
| Layer-wise learning rate decay (Bao et al., 2022) | X |
| Batch size | 2048 |
| Weight decay | 0.02 |
| Learning rate schedule | Cosine decay |
| Warmup epochs | 5 |
| Loss function | Binary cross-entropy loss |
| Gradient clipping | X |
| Dropout (Srivastava et al.,2014) | X |
| Stochastic depth (Huang et al., 2016) | X |
| Mixup (Zhang et al.,2017a) | 0.1 |
| Cutmix (Yun et al., 2019) | 1.0 | |
| Label smoothing (Szegedy et al., 2016) | 0.1 | × |
| Repeated augmentation (Berman et al.,2O19; Hoffer et al., 2019) | X | √ |
| Random augmentation (Cubuk et al., 2020) | 6/0.5 | 7/0.5 |
| Fine-tuning resolution | 160 | 224 |
| Test resolution | 224 |
| Test crop ratio | 0.95 |
"
+ },
+ {
+ "category_id": 5,
+ "poly": [
+ 346,
+ 309,
+ 1349,
+ 309,
+ 1349,
+ 929,
+ 346,
+ 929
+ ],
+ "score": 0.983,
+ "html": "| Configuration | Value |
| Optimizer | AdamW (Loshchilov & Hutter,2017) |
| Fine-tuning epochs | 200 (S),100 (B) |
| Peak learning rate | 8e-3 |
| Layer-wise learning rate decay (Bao et al.,2022) | 0.8 (Clark et al., 2020) |
| Batch size | 2048 |
| Weight decay | 0.05 |
| Optimizer momentum | β1,β2 = 0.9,0.999 |
| Learning rate schedule | Cosine decay |
| Warmup epochs | 5 |
| Loss function | Cross-entropy loss |
| Gradient clipping | X |
| Dropout (Srivastava et al., 2014) | X |
| Stochastic depth (Huang et al., 2016) | 0.1 |
| Mixup (Zhang et al., 2017a) | 0.8 |
| Cutmix (Yun et al.,2019) | 1.0 |
| Label smoothing (Szegedy et al., 2016) | 0.1 |
| Random augmentation (Cubuk et al., 2020) | 9 /0.5 |
| Patch size | 16 |
| Fine-tuning resolution | 224 |
| Test resolution | 224 |
"
+ },
+ {
+ "category_id": 1,
+ "poly": [
+ 299,
+ 1788,
+ 1403,
+ 1788,
+ 1403,
+ 1882,
+ 299,
+ 1882
+ ],
+ "score": 0.957
+ },
+ {
+ "category_id": 6,
+ "poly": [
+ 297,
+ 957,
+ 1404,
+ 957,
+ 1404,
+ 1050,
+ 297,
+ 1050
+ ],
+ "score": 0.938
+ },
+ {
+ "category_id": 6,
+ "poly": [
+ 300,
+ 223,
+ 1396,
+ 223,
+ 1396,
+ 287,
+ 300,
+ 287
+ ],
+ "score": 0.936
+ },
+ {
+ "category_id": 0,
+ "poly": [
+ 300,
+ 1718,
+ 587,
+ 1718,
+ 587,
+ 1754,
+ 300,
+ 1754
+ ],
+ "score": 0.905
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 300,
+ 76,
+ 815,
+ 76,
+ 815,
+ 104,
+ 300,
+ 104
+ ],
+ "score": 0.897
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 836,
+ 2088,
+ 865,
+ 2088,
+ 865,
+ 2112,
+ 836,
+ 2112
+ ],
+ "score": 0.851
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 954.0,
+ 1405.0,
+ 954.0,
+ 1405.0,
+ 994.0,
+ 294.0,
+ 994.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 987.0,
+ 1406.0,
+ 987.0,
+ 1406.0,
+ 1028.0,
+ 294.0,
+ 1028.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1018.0,
+ 447.0,
+ 1018.0,
+ 447.0,
+ 1053.0,
+ 295.0,
+ 1053.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 220.0,
+ 1401.0,
+ 220.0,
+ 1401.0,
+ 261.0,
+ 295.0,
+ 261.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 297.0,
+ 255.0,
+ 1379.0,
+ 255.0,
+ 1379.0,
+ 291.0,
+ 297.0,
+ 291.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1714.0,
+ 592.0,
+ 1714.0,
+ 592.0,
+ 1762.0,
+ 293.0,
+ 1762.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 73.0,
+ 816.0,
+ 73.0,
+ 816.0,
+ 108.0,
+ 296.0,
+ 108.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 832.0,
+ 2085.0,
+ 870.0,
+ 2085.0,
+ 870.0,
+ 2124.0,
+ 832.0,
+ 2124.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1786.0,
+ 1403.0,
+ 1786.0,
+ 1403.0,
+ 1824.0,
+ 295.0,
+ 1824.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1820.0,
+ 1403.0,
+ 1820.0,
+ 1403.0,
+ 1854.0,
+ 295.0,
+ 1854.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1848.0,
+ 468.0,
+ 1848.0,
+ 468.0,
+ 1887.0,
+ 295.0,
+ 1887.0
+ ],
+ "score": 1.0,
+ "text": ""
+ }
+ ],
+ "page_info": {
+ "page_no": 18,
+ "width": 1700,
+ "height": 2200
+ }
+ },
+ {
+ "layout_dets": [
+ {
+ "category_id": 3,
+ "poly": [
+ 294,
+ 298,
+ 1403,
+ 298,
+ 1403,
+ 1777,
+ 294,
+ 1777
+ ],
+ "score": 0.977
+ },
+ {
+ "category_id": 4,
+ "poly": [
+ 296,
+ 1798,
+ 1405,
+ 1798,
+ 1405,
+ 1952,
+ 296,
+ 1952
+ ],
+ "score": 0.967
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 299,
+ 76,
+ 814,
+ 76,
+ 814,
+ 104,
+ 299,
+ 104
+ ],
+ "score": 0.89
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 835,
+ 2088,
+ 866,
+ 2088,
+ 866,
+ 2113,
+ 835,
+ 2113
+ ],
+ "score": 0.857
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 623.0,
+ 329.0,
+ 671.0,
+ 329.0,
+ 671.0,
+ 357.0,
+ 623.0,
+ 357.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 729.0,
+ 329.0,
+ 780.0,
+ 329.0,
+ 780.0,
+ 358.0,
+ 729.0,
+ 358.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 952.0,
+ 312.0,
+ 1397.0,
+ 312.0,
+ 1397.0,
+ 380.0,
+ 952.0,
+ 380.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1006.0,
+ 404.0,
+ 1070.0,
+ 404.0,
+ 1070.0,
+ 437.0,
+ 1006.0,
+ 437.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1241.0,
+ 406.0,
+ 1295.0,
+ 406.0,
+ 1295.0,
+ 434.0,
+ 1241.0,
+ 434.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 957.0,
+ 687.0,
+ 1170.0,
+ 687.0,
+ 1170.0,
+ 743.0,
+ 957.0,
+ 743.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1172.0,
+ 697.0,
+ 1231.0,
+ 697.0,
+ 1231.0,
+ 732.0,
+ 1172.0,
+ 732.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1292.0,
+ 695.0,
+ 1346.0,
+ 695.0,
+ 1346.0,
+ 733.0,
+ 1292.0,
+ 733.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 945.0,
+ 758.0,
+ 1359.0,
+ 758.0,
+ 1359.0,
+ 825.0,
+ 945.0,
+ 825.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 964.0,
+ 857.0,
+ 1057.0,
+ 857.0,
+ 1057.0,
+ 879.0,
+ 964.0,
+ 879.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1177.0,
+ 931.0,
+ 1203.0,
+ 931.0,
+ 1203.0,
+ 959.0,
+ 1177.0,
+ 959.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1197.0,
+ 934.0,
+ 1231.0,
+ 934.0,
+ 1231.0,
+ 959.0,
+ 1197.0,
+ 959.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1141.0,
+ 937.0,
+ 1154.0,
+ 937.0,
+ 1154.0,
+ 950.0,
+ 1141.0,
+ 950.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1175.0,
+ 954.0,
+ 1195.0,
+ 954.0,
+ 1195.0,
+ 973.0,
+ 1175.0,
+ 973.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 398.0,
+ 1057.0,
+ 839.0,
+ 1057.0,
+ 839.0,
+ 1120.0,
+ 398.0,
+ 1120.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 387.0,
+ 1130.0,
+ 840.0,
+ 1130.0,
+ 840.0,
+ 1197.0,
+ 387.0,
+ 1197.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 453.0,
+ 1227.0,
+ 487.0,
+ 1227.0,
+ 487.0,
+ 1250.0,
+ 453.0,
+ 1250.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 558.0,
+ 1301.0,
+ 599.0,
+ 1301.0,
+ 599.0,
+ 1330.0,
+ 558.0,
+ 1330.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 376.0,
+ 1420.0,
+ 847.0,
+ 1420.0,
+ 847.0,
+ 1500.0,
+ 376.0,
+ 1500.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 963.0,
+ 1421.0,
+ 1174.0,
+ 1421.0,
+ 1174.0,
+ 1493.0,
+ 963.0,
+ 1493.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1235.0,
+ 1445.0,
+ 1289.0,
+ 1445.0,
+ 1289.0,
+ 1473.0,
+ 1235.0,
+ 1473.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1293.0,
+ 1443.0,
+ 1334.0,
+ 1443.0,
+ 1334.0,
+ 1479.0,
+ 1293.0,
+ 1479.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 320.0,
+ 1534.0,
+ 339.0,
+ 1534.0,
+ 339.0,
+ 1546.0,
+ 320.0,
+ 1546.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 374.0,
+ 1498.0,
+ 844.0,
+ 1498.0,
+ 844.0,
+ 1574.0,
+ 374.0,
+ 1574.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 873.0,
+ 1531.0,
+ 913.0,
+ 1531.0,
+ 913.0,
+ 1547.0,
+ 873.0,
+ 1547.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 954.0,
+ 1503.0,
+ 1387.0,
+ 1503.0,
+ 1387.0,
+ 1567.0,
+ 954.0,
+ 1567.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 311.0,
+ 1556.0,
+ 352.0,
+ 1556.0,
+ 352.0,
+ 1589.0,
+ 311.0,
+ 1589.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 310.0,
+ 1585.0,
+ 334.0,
+ 1585.0,
+ 334.0,
+ 1603.0,
+ 310.0,
+ 1603.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 402.0,
+ 1597.0,
+ 449.0,
+ 1597.0,
+ 449.0,
+ 1620.0,
+ 402.0,
+ 1620.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 443.0,
+ 1598.0,
+ 494.0,
+ 1598.0,
+ 494.0,
+ 1620.0,
+ 443.0,
+ 1620.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1159.0,
+ 1433.0,
+ 1249.0,
+ 1433.0,
+ 1249.0,
+ 1494.0,
+ 1159.0,
+ 1494.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1797.0,
+ 1403.0,
+ 1797.0,
+ 1403.0,
+ 1834.0,
+ 294.0,
+ 1834.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1830.0,
+ 1403.0,
+ 1830.0,
+ 1403.0,
+ 1863.0,
+ 295.0,
+ 1863.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1858.0,
+ 1405.0,
+ 1858.0,
+ 1405.0,
+ 1895.0,
+ 295.0,
+ 1895.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1888.0,
+ 1405.0,
+ 1888.0,
+ 1405.0,
+ 1927.0,
+ 293.0,
+ 1927.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1919.0,
+ 684.0,
+ 1919.0,
+ 684.0,
+ 1954.0,
+ 294.0,
+ 1954.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 73.0,
+ 815.0,
+ 73.0,
+ 815.0,
+ 108.0,
+ 296.0,
+ 108.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 829.0,
+ 2083.0,
+ 872.0,
+ 2083.0,
+ 872.0,
+ 2124.0,
+ 829.0,
+ 2124.0
+ ],
+ "score": 1.0,
+ "text": ""
+ }
+ ],
+ "page_info": {
+ "page_no": 19,
+ "width": 1700,
+ "height": 2200
+ }
+ },
+ {
+ "layout_dets": [
+ {
+ "category_id": 3,
+ "poly": [
+ 297,
+ 205,
+ 1402,
+ 205,
+ 1402,
+ 1794,
+ 297,
+ 1794
+ ],
+ "score": 0.973
+ },
+ {
+ "category_id": 4,
+ "poly": [
+ 295,
+ 1812,
+ 1406,
+ 1812,
+ 1406,
+ 2059,
+ 295,
+ 2059
+ ],
+ "score": 0.947
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 299,
+ 76,
+ 814,
+ 76,
+ 814,
+ 104,
+ 299,
+ 104
+ ],
+ "score": 0.875
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 835,
+ 2088,
+ 863,
+ 2088,
+ 863,
+ 2112,
+ 835,
+ 2112
+ ],
+ "score": 0.85
+ },
+ {
+ "category_id": 1,
+ "poly": [
+ 297,
+ 2001,
+ 1366,
+ 2001,
+ 1366,
+ 2058,
+ 297,
+ 2058
+ ],
+ "score": 0.134
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 454,
+ 1905,
+ 494,
+ 1905,
+ 494,
+ 1934,
+ 454,
+ 1934
+ ],
+ "score": 0.87,
+ "latex": "\\times 8"
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 502.0,
+ 231.0,
+ 537.0,
+ 231.0,
+ 537.0,
+ 259.0,
+ 502.0,
+ 259.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 686.0,
+ 231.0,
+ 754.0,
+ 231.0,
+ 754.0,
+ 261.0,
+ 686.0,
+ 261.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 884.0,
+ 231.0,
+ 961.0,
+ 231.0,
+ 961.0,
+ 261.0,
+ 884.0,
+ 261.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1187.0,
+ 229.0,
+ 1246.0,
+ 229.0,
+ 1246.0,
+ 261.0,
+ 1187.0,
+ 261.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 312.0,
+ 262.0,
+ 381.0,
+ 262.0,
+ 381.0,
+ 289.0,
+ 312.0,
+ 289.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 446.0,
+ 261.0,
+ 500.0,
+ 261.0,
+ 500.0,
+ 290.0,
+ 446.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 534.0,
+ 264.0,
+ 595.0,
+ 264.0,
+ 595.0,
+ 289.0,
+ 534.0,
+ 289.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 647.0,
+ 259.0,
+ 706.0,
+ 259.0,
+ 706.0,
+ 290.0,
+ 647.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 733.0,
+ 261.0,
+ 799.0,
+ 261.0,
+ 799.0,
+ 290.0,
+ 733.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 849.0,
+ 261.0,
+ 905.0,
+ 261.0,
+ 905.0,
+ 290.0,
+ 849.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 936.0,
+ 261.0,
+ 1002.0,
+ 261.0,
+ 1002.0,
+ 290.0,
+ 936.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1050.0,
+ 259.0,
+ 1106.0,
+ 259.0,
+ 1106.0,
+ 290.0,
+ 1050.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1136.0,
+ 261.0,
+ 1203.0,
+ 261.0,
+ 1203.0,
+ 290.0,
+ 1136.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1235.0,
+ 259.0,
+ 1292.0,
+ 259.0,
+ 1292.0,
+ 290.0,
+ 1235.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1323.0,
+ 264.0,
+ 1384.0,
+ 264.0,
+ 1384.0,
+ 289.0,
+ 1323.0,
+ 289.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 399.0,
+ 305.0,
+ 417.0,
+ 305.0,
+ 417.0,
+ 336.0,
+ 399.0,
+ 336.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 401.0,
+ 503.0,
+ 416.0,
+ 503.0,
+ 416.0,
+ 516.0,
+ 401.0,
+ 516.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 871.0,
+ 1408.0,
+ 1018.0,
+ 1408.0,
+ 1018.0,
+ 1513.0,
+ 871.0,
+ 1513.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 686.0,
+ 1431.0,
+ 797.0,
+ 1431.0,
+ 797.0,
+ 1499.0,
+ 686.0,
+ 1499.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1315.0,
+ 333.5,
+ 1384.0,
+ 333.5,
+ 1384.0,
+ 356.5,
+ 1315.0,
+ 356.5
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 744.0,
+ 686.0,
+ 786.0,
+ 686.0,
+ 786.0,
+ 711.0,
+ 744.0,
+ 711.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1810.0,
+ 1406.0,
+ 1810.0,
+ 1406.0,
+ 1850.0,
+ 293.0,
+ 1850.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1844.0,
+ 1407.0,
+ 1844.0,
+ 1407.0,
+ 1878.0,
+ 295.0,
+ 1878.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 292.0,
+ 1872.0,
+ 1407.0,
+ 1872.0,
+ 1407.0,
+ 1909.0,
+ 292.0,
+ 1909.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1903.0,
+ 453.0,
+ 1903.0,
+ 453.0,
+ 1938.0,
+ 293.0,
+ 1938.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 495.0,
+ 1903.0,
+ 1406.0,
+ 1903.0,
+ 1406.0,
+ 1938.0,
+ 495.0,
+ 1938.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1933.0,
+ 1404.0,
+ 1933.0,
+ 1404.0,
+ 1968.0,
+ 293.0,
+ 1968.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1966.0,
+ 1382.0,
+ 1966.0,
+ 1382.0,
+ 1999.0,
+ 295.0,
+ 1999.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 1997.0,
+ 1365.0,
+ 1997.0,
+ 1365.0,
+ 2036.0,
+ 296.0,
+ 2036.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 2028.0,
+ 745.0,
+ 2028.0,
+ 745.0,
+ 2062.0,
+ 294.0,
+ 2062.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 73.0,
+ 815.0,
+ 73.0,
+ 815.0,
+ 108.0,
+ 296.0,
+ 108.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 829.0,
+ 2084.0,
+ 869.0,
+ 2084.0,
+ 869.0,
+ 2125.0,
+ 829.0,
+ 2125.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1994.0,
+ 1366.0,
+ 1994.0,
+ 1366.0,
+ 2037.0,
+ 295.0,
+ 2037.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 2027.0,
+ 744.0,
+ 2027.0,
+ 744.0,
+ 2061.0,
+ 294.0,
+ 2061.0
+ ],
+ "score": 1.0,
+ "text": ""
+ }
+ ],
+ "page_info": {
+ "page_no": 20,
+ "width": 1700,
+ "height": 2200
+ }
+ },
+ {
+ "layout_dets": [
+ {
+ "category_id": 3,
+ "poly": [
+ 299,
+ 261,
+ 1402,
+ 261,
+ 1402,
+ 1858,
+ 299,
+ 1858
+ ],
+ "score": 0.973
+ },
+ {
+ "category_id": 4,
+ "poly": [
+ 296,
+ 1874,
+ 1406,
+ 1874,
+ 1406,
+ 1968,
+ 296,
+ 1968
+ ],
+ "score": 0.961
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 299,
+ 76,
+ 814,
+ 76,
+ 814,
+ 104,
+ 299,
+ 104
+ ],
+ "score": 0.886
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 835,
+ 2088,
+ 865,
+ 2088,
+ 865,
+ 2113,
+ 835,
+ 2113
+ ],
+ "score": 0.848
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 501.0,
+ 289.0,
+ 537.0,
+ 289.0,
+ 537.0,
+ 317.0,
+ 501.0,
+ 317.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 687.0,
+ 285.0,
+ 756.0,
+ 285.0,
+ 756.0,
+ 321.0,
+ 687.0,
+ 321.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 885.0,
+ 289.0,
+ 961.0,
+ 289.0,
+ 961.0,
+ 319.0,
+ 885.0,
+ 319.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1185.0,
+ 289.0,
+ 1246.0,
+ 289.0,
+ 1246.0,
+ 319.0,
+ 1185.0,
+ 319.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 310.0,
+ 319.0,
+ 383.0,
+ 319.0,
+ 383.0,
+ 347.0,
+ 310.0,
+ 347.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 446.0,
+ 317.0,
+ 501.0,
+ 317.0,
+ 501.0,
+ 347.0,
+ 446.0,
+ 347.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 534.0,
+ 321.0,
+ 595.0,
+ 321.0,
+ 595.0,
+ 345.0,
+ 534.0,
+ 345.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 650.0,
+ 321.0,
+ 700.0,
+ 321.0,
+ 700.0,
+ 345.0,
+ 650.0,
+ 345.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 736.0,
+ 321.0,
+ 797.0,
+ 321.0,
+ 797.0,
+ 345.0,
+ 736.0,
+ 345.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 849.0,
+ 314.0,
+ 905.0,
+ 314.0,
+ 905.0,
+ 351.0,
+ 849.0,
+ 351.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 936.0,
+ 321.0,
+ 999.0,
+ 321.0,
+ 999.0,
+ 345.0,
+ 936.0,
+ 345.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1049.0,
+ 319.0,
+ 1106.0,
+ 319.0,
+ 1106.0,
+ 349.0,
+ 1049.0,
+ 349.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1137.0,
+ 321.0,
+ 1200.0,
+ 321.0,
+ 1200.0,
+ 345.0,
+ 1137.0,
+ 345.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1235.0,
+ 319.0,
+ 1291.0,
+ 319.0,
+ 1291.0,
+ 349.0,
+ 1235.0,
+ 349.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1323.0,
+ 321.0,
+ 1386.0,
+ 321.0,
+ 1386.0,
+ 345.0,
+ 1323.0,
+ 345.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 403.0,
+ 1162.0,
+ 417.0,
+ 1162.0,
+ 417.0,
+ 1174.0,
+ 403.0,
+ 1174.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 405.0,
+ 1540.0,
+ 417.0,
+ 1540.0,
+ 417.0,
+ 1558.0,
+ 405.0,
+ 1558.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 442.0,
+ 1539.0,
+ 516.0,
+ 1539.0,
+ 516.0,
+ 1569.0,
+ 442.0,
+ 1569.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1064.0,
+ 1540.0,
+ 1185.0,
+ 1540.0,
+ 1185.0,
+ 1565.0,
+ 1064.0,
+ 1565.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 1323.0,
+ 1540.0,
+ 1371.0,
+ 1540.0,
+ 1371.0,
+ 1563.0,
+ 1323.0,
+ 1563.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 401.0,
+ 1733.0,
+ 419.0,
+ 1733.0,
+ 419.0,
+ 1761.0,
+ 401.0,
+ 1761.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 690.0,
+ 921.0,
+ 805.0,
+ 921.0,
+ 805.0,
+ 994.0,
+ 690.0,
+ 994.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1875.0,
+ 1403.0,
+ 1875.0,
+ 1403.0,
+ 1909.0,
+ 295.0,
+ 1909.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1905.0,
+ 1404.0,
+ 1905.0,
+ 1404.0,
+ 1939.0,
+ 294.0,
+ 1939.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1936.0,
+ 1339.0,
+ 1936.0,
+ 1339.0,
+ 1970.0,
+ 294.0,
+ 1970.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 73.0,
+ 815.0,
+ 73.0,
+ 815.0,
+ 108.0,
+ 296.0,
+ 108.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 831.0,
+ 2085.0,
+ 869.0,
+ 2085.0,
+ 869.0,
+ 2124.0,
+ 831.0,
+ 2124.0
+ ],
+ "score": 1.0,
+ "text": ""
+ }
+ ],
+ "page_info": {
+ "page_no": 21,
+ "width": 1700,
+ "height": 2200
+ }
+ }
+]
\ No newline at end of file
diff --git a/parse/dev/LtKcMgGOeLt/LtKcMgGOeLt.md b/parse/dev/LtKcMgGOeLt/LtKcMgGOeLt.md
new file mode 100644
index 0000000000000000000000000000000000000000..1131957c712759950e9c169d615827cfba5019ad
--- /dev/null
+++ b/parse/dev/LtKcMgGOeLt/LtKcMgGOeLt.md
@@ -0,0 +1,430 @@
+# WHEN VISION TRANSFORMERS OUTPERFORM RESNETS WITHOUT PRE-TRAINING OR STRONG DATA AUGMENTATIONS
+
+Xiangning Chen1,2∗, Cho-Jui Hsieh2, Boqing Gong1 1Google Research, 2Department of Computer Science, UCLA {xiangningc, bgong}@google.com, chohsieh@cs.ucla.edu
+
+# ABSTRACT
+
+Vision Transformers (ViTs) and MLPs signal further efforts on replacing handwired features or inductive biases with general-purpose neural architectures. Existing works empower the models by massive data, such as large-scale pre-training and/or repeated strong data augmentations, and still report optimization-related problems (e.g., sensitivity to initialization and learning rates). Hence, this paper investigates ViTs and MLP-Mixers from the lens of loss geometry, intending to improve the models’ data efficiency at training and generalization at inference. Visualization and Hessian reveal extremely sharp local minima of converged models. By promoting smoothness with a recently proposed sharpnessaware optimizer, we substantially improve the accuracy and robustness of ViTs and MLP-Mixers on various tasks spanning supervised, adversarial, contrastive, and transfer learning (e.g., $+ 5 . 3 \%$ and $+ 1 1 . 0 \%$ top-1 accuracy on ImageNet for ViT-B/16 and Mixer-B/16, respectively, with the simple Inception-style preprocessing). We show that the improved smoothness attributes to sparser active neurons in the first few layers. The resultant ViTs outperform ResNets of similar size and throughput when trained from scratch on ImageNet without large-scale pre-training or strong data augmentations. Model checkpoints are available at https://github.com/google-research/vision_transformer.
+
+# 1 INTRODUCTION
+
+Transformers (Vaswani et al., 2017) have become the de-facto model of choice in natural language processing (NLP) (Devlin et al., 2018; Radford et al., 2018). In computer vision, there has recently been a surge of interest in end-to-end Transformers (Dosovitskiy et al., 2021; Touvron et al., 2021b; Liu et al., 2021b; Fan et al., 2021; Arnab et al., 2021; Bertasius et al., 2021; Akbari et al., 2021) and MLPs (Tolstikhin et al., 2021; Touvron et al., 2021a; Liu et al., 2021a; Melas-Kyriazi, 2021), prompting the efforts to replace hand-wired features or inductive biases with general-purpose neural architectures powered by data-driven training. We envision these efforts may lead to a unified knowledge base that produces versatile representations for different data modalities, simplifying the inference and deployment of deep learning models in various application scenarios.
+
+Despite the appealing potential of moving toward general-purpose neural architectures, the lack of convolution-like inductive biases also challenges the training of vision Transformers (ViTs) and MLPs. When trained on ImageNet (Deng et al., 2009) with the conventional Inception-style data preprocessing (Szegedy et al., 2016), Transformers “yield modest accuracies of a few percentage points below ResNets of comparable size” (Dosovitskiy et al., 2021). To boost the performance, existing works resort to large-scale pre-training (Dosovitskiy et al., 2021; Arnab et al., 2021; Akbari et al., 2021) and repeated strong data augmentations (Touvron et al., 2021b), resulting in excessive demands of data, computing, and sophisticated tuning of many hyperparameters. For instance, Dosovitskiy et al. (Dosovitskiy et al., 2021) pre-train ViTs using 304M labeled images, and Touvron et al. (2021b) repeatedly stack four strong image augmentations.
+
+In this paper, we show ViTs can outperform ResNets (He et al., 2016) of even bigger sizes in both accuracy and various forms of robustness by using a principled optimizer, without the need for largescale pre-training or strong data augmentations. MLP-Mixers (Tolstikhin et al., 2021) also become on par with ResNets.
+
+We first study the architectures fully trained on ImageNet from the lens of loss landscapes and draw the following findings. First, visualization and Hessian matrices of the loss landscapes reveal that Transformers and MLP-Mixers converge at extremely sharp local minima, whose largest principal curvatures are almost an order of magnitude bigger than ResNets’. Such effect accumulates when the gradients backpropagate from the last layer to the first, and the initial embedding layer suffers the largest eigenvalue of the corresponding sub-diagonal Hessian. Second, the networks all have very small training errors, and MLP-Mixers are more prone to overfitting than ViTs of more parameters (because of the difference in self-attention). Third, ViTs and MLP-Mixers have worse “trainabilities” than ResNets following the neural tangent kernel analyses (Xiao et al., 2020).
+
+Therefore, we need improved learning algorithms to prevent the convergence to a sharp local minimum when it comes to the convolution-free ViTs and MLP-Mixers. The first-order optimizers (e.g., SGD and Adam (Kingma & Ba, 2015)) only seek the model parameters that minimize the training error. They dismiss the higher-order information such as flatness that correlates with generalization (Keskar et al., 2017; Kleinberg et al., 2018; Jastrz˛ebski et al., 2019; Smith & Le, 2018; Chaudhari et al., 2017).
+
+The above study and reasoning lead us to the recently proposed sharpness-aware minimizer (SAM) (Foret et al., 2021) that explicitly smooths the loss geometry during model training. SAM strives to find a solution whose entire neighborhood has low losses rather than focus on any singleton point. We show that the resultant models exhibit smoother loss landscapes, and their generalization capabilities improve tremendously across different tasks including supervised, adversarial, contrastive, and transfer learning (e.g., $+ 5 . 3 \%$ and $+ 1 1 . 0 \%$ top-1 accuracy on ImageNet for ViT-B/16 and Mixer-B/16, respectively, with the simple Inception-style preprocessing). The enhanced ViTs achieve better accuracy and robustness than ResNets of similar and bigger sizes when trained from scratch on ImageNet, without large-scale pre-training or strong data augmentations. Moreover, we demonstrate that SAM can even enable ViT to be effectively trained with (momentum) SGD, which usually lies far behind Adam when training Transformers (Zhang et al., 2020).
+
+By analyzing some intrinsic model properties, we observe that SAM increases the sparsity of active neurons (especially for the first few layers), which contribute to the reduced Hessian eigenvalues. The weight norms increase, implying the commonly used weight decay may not be an effective regularization alone. A side observation is that, unlike ResNets and MLP-Mixers, ViTs have extremely sparse active neurons (see Figure 2 (right)), revealing the potential for network pruning (Akbari et al., 2021). Another interesting finding is that the improved ViTs appear to have visually more interpretable attention maps. Finally, we draw similarities between SAM and strong augmentations (e.g., mixup) in that they both smooth the average loss geometry and encourage the models to behave linearly between training images.
+
+# 2 BACKGROUND AND RELATED WORK
+
+We briefly review ViTs, MLP-Mixers, and some related works in this section.
+
+Dosovitskiy et al. (2021) show that a pure Transformer architecture (Vaswani et al., 2017) can achieve state-of-the-art accuracy on image classification by pre-training it on large datasets such as ImageNet-21k (Deng et al., 2009) and JFT-300M (Sun et al., 2017). Their vision Transformer (ViT) is a stack of residual blocks, each containing a multi-head self-attention, layer normalization (Ba et al., 2016), and a MLP layer. ViT first embeds an input image $x \in \mathbb { R } ^ { H \times \tilde { W } \times C }$ into a sequence of features $\boldsymbol { z } \in \mathbb { R } ^ { N \times D }$ by applying a linear projection over $N$ nonoverlapping image patches $\bar { \boldsymbol { x } _ { p } } \in \mathbb { R } ^ { N \times ( P ^ { 2 } \cdot C ) }$ , where $D$ is the feature dimension, $P$ is the patch resolution, and $N = H W / P ^ { 2 }$ is the sequence length. The self-attention layers in ViT are global and do not possess the locality and translation equivariance of convolutions. ViT is compatible with the popular architectures in NLP (Devlin et al., 2018; Radford et al., 2018) and, similar to its NLP counterparts, requires pretraining over massive datasets (Dosovitskiy et al., 2021; Akbari et al., 2021; Arnab et al., 2021) or strong data augmentations (Touvron et al., 2021b). Some works specialize the ViT architectures for visual data (Liu et al., 2021b; Yuan et al., 2021; Fan et al., 2021; Bertasius et al., 2021).
+
+Table 1: Number of paramettraining error at convergence K condition num, average flatness $\kappa$ Hessian, accura ominate eigenvalue on ImageNet, and $\lambda _ { m a x }$ $L _ { t r a i n }$ $L _ { t r a i n } ^ { \mathcal { N } }$ $\kappa$ gions; SAM rescues that and leads to better generalization.
+
+| Model | Task | SAM p |
| ResNet |
| ResNet-50-SAM ResNet-101-SAM ResNet-152-SAM ResNet-50x2-SAM ResNet-101x2-SAM ResNet-152x2-SAM ResNet-50-SAM | supervised supervised supervised supervised supervised supervised | 0.02 0.05 0.02 0.05 0.05 0.05 0.05 |
| ResNet-152-SAM adversarial ViT |
| ViT-S/16-SAM ViT-S/14-SAM ViT-S/8-SAM ViT-B/32-SAM ViT-B/16-SAM | supervised supervised supervised supervised | 0.1 0.1 0.15 0.15 0.2 |
| ViT-B/16-AUG-SAM ViT-S/16-SAM ViT-B/32-SAM | supervised supervised adversarial | 0.05 0.1 |
| ViT-B/16-SAM | adversarial | 0.1 0.1 |
| | |
| supervised contrastive | |
| | |
| adversarial | |
| | |
| ViT-S/16-SAM | | 0.02 |
| ViT-B/16-SAM | | |
| supervised contrastive | 0.02 |
| MLP-Mixer | |
| Mixer-S/32-SAM | | |
| Mixer-S/16-SAM | supervised | 0.1 |
| supervised | 0.15 |
| Mixer-S/8-SAM | supervised | 0.2 |
| Mixer-B/32-SAM | supervised | 0.35 |
| Mixer-B/16-SAM | supervised | 0.6 |
| Mixer-B/8-SAM | | 0.6 |
| supervised | |
| Mixer-B/16-AUG-SAM | supervised | 0.2 |
| Mixer-S/16-SAM | adversarial | 0.05 |
| | |
| Mixer-B/32-SAM | adversarial | 0.25 |
| Mixer-B/16-SAM | adversarial | 0.25 |
+
+# F HESSIAN EIGENVALUE
+
+The Hessian matrix requires second-order derivative, so we compute the Hessian (and all the subdiagonal Hessian) $\lambda _ { m a x }$ using $10 \%$ of the ImageNet training images (i.e., i1k (1/10)) via power iteration 1, where we use 100 iterations to ensure its convergence.
+
+# G NTK CONDITION NUMBER
+
+We approximate the neural tangent kernel on the i1k (1/10) subset by averaging over block diagonal entries (with block size $4 8 \times 4 8 )$ ) in the full NTK. Notice that the computation is based on the architecture at initialization without training. As the activation plays an important role when computing NTK — we find that smoother activation functions enjoy smaller condition numbers, we replace the GELU in ViT and MLP-Mixer with ReLU for a fair comparison with ResNet.
+
+# H TRAINING DETAILS
+
+We use image resolution $2 2 4 \times 2 2 4$ during fine-tuning on downstream tasks, other settings exactly follow (Dosovitskiy et al., 2021; Tolstikhin et al., 2021) (see Table 9). Note that we do not employ SAM during fine-tuning. We perform a grid search over the base learning rates on small sub-splits of the training sets $10 \%$ for Flowers and Pets, $2 \%$ for CIFAR-10/100). After that, we fine-tune on the entire training sets and report the results on the respective test sets.
+
+Table 12: Hyperparameters for training from scratch on ImageNet with basic Inception-style preprocessing and $2 2 4 \times 2 2 4$ image resolution.
+
+| Model | Task | SAM p |
| ResNet |
| ResNet-50-SAM ResNet-101-SAM ResNet-152-SAM ResNet-50x2-SAM ResNet-101x2-SAM ResNet-152x2-SAM ResNet-50-SAM | supervised supervised supervised supervised supervised supervised | 0.02 0.05 0.02 0.05 0.05 0.05 0.05 |
| ResNet-152-SAM adversarial ViT |
| ViT-S/16-SAM ViT-S/14-SAM ViT-S/8-SAM ViT-B/32-SAM ViT-B/16-SAM | supervised supervised supervised supervised | 0.1 0.1 0.15 0.15 0.2 |
| ViT-B/16-AUG-SAM ViT-S/16-SAM ViT-B/32-SAM | supervised supervised adversarial | 0.05 0.1 |
| ViT-B/16-SAM | adversarial | 0.1 0.1 |
| | |
| supervised contrastive | |
| | |
| adversarial | |
| | |
| ViT-S/16-SAM | | 0.02 |
| ViT-B/16-SAM | | |
| supervised contrastive | 0.02 |
| MLP-Mixer | |
| Mixer-S/32-SAM | | |
| Mixer-S/16-SAM | supervised | 0.1 |
| supervised | 0.15 |
| Mixer-S/8-SAM | supervised | 0.2 |
| Mixer-B/32-SAM | supervised | 0.35 |
| Mixer-B/16-SAM | supervised | 0.6 |
| Mixer-B/8-SAM | | 0.6 |
| supervised | |
| Mixer-B/16-AUG-SAM | supervised | 0.2 |
| Mixer-S/16-SAM | adversarial | 0.05 |
| | |
| Mixer-B/32-SAM | adversarial | 0.25 |
| Mixer-B/16-SAM | adversarial | 0.25 |
",
+ "bbox": [
+ 338,
+ 133,
+ 663,
+ 551
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "F HESSIAN EIGENVALUE ",
+ "text_level": 1,
+ "bbox": [
+ 174,
+ 577,
+ 398,
+ 593
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "The Hessian matrix requires second-order derivative, so we compute the Hessian (and all the subdiagonal Hessian) $\\lambda _ { m a x }$ using $10 \\%$ of the ImageNet training images (i.e., i1k (1/10)) via power iteration 1, where we use 100 iterations to ensure its convergence. ",
+ "bbox": [
+ 174,
+ 609,
+ 825,
+ 651
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "G NTK CONDITION NUMBER ",
+ "text_level": 1,
+ "bbox": [
+ 176,
+ 671,
+ 436,
+ 689
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "We approximate the neural tangent kernel on the i1k (1/10) subset by averaging over block diagonal entries (with block size $4 8 \\times 4 8 )$ ) in the full NTK. Notice that the computation is based on the architecture at initialization without training. As the activation plays an important role when computing NTK — we find that smoother activation functions enjoy smaller condition numbers, we replace the GELU in ViT and MLP-Mixer with ReLU for a fair comparison with ResNet. ",
+ "bbox": [
+ 174,
+ 704,
+ 825,
+ 773
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "H TRAINING DETAILS ",
+ "text_level": 1,
+ "bbox": [
+ 176,
+ 796,
+ 374,
+ 813
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "We use image resolution $2 2 4 \\times 2 2 4$ during fine-tuning on downstream tasks, other settings exactly follow (Dosovitskiy et al., 2021; Tolstikhin et al., 2021) (see Table 9). Note that we do not employ SAM during fine-tuning. We perform a grid search over the base learning rates on small sub-splits of the training sets $10 \\%$ for Flowers and Pets, $2 \\%$ for CIFAR-10/100). After that, we fine-tune on the entire training sets and report the results on the respective test sets. ",
+ "bbox": [
+ 174,
+ 828,
+ 825,
+ 898
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "table",
+ "img_path": "images/2a52a48fdbd5f01328a730ab36ffb56ebf8987bc59561d4bc083f0dc1647bdda.jpg",
+ "table_caption": [
+ "Table 12: Hyperparameters for training from scratch on ImageNet with basic Inception-style preprocessing and $2 2 4 \\times 2 2 4$ image resolution. "
+ ],
+ "table_footnote": [],
+ "table_body": "| Model | Task | SAM p |
| ResNet |
| ResNet-50-SAM ResNet-101-SAM ResNet-152-SAM ResNet-50x2-SAM ResNet-101x2-SAM ResNet-152x2-SAM ResNet-50-SAM | supervised supervised supervised supervised supervised supervised | 0.02 0.05 0.02 0.05 0.05 0.05 0.05 |
| ResNet-152-SAM adversarial ViT |
| ViT-S/16-SAM ViT-S/14-SAM ViT-S/8-SAM ViT-B/32-SAM ViT-B/16-SAM | supervised supervised supervised supervised | 0.1 0.1 0.15 0.15 0.2 |
| ViT-B/16-AUG-SAM ViT-S/16-SAM ViT-B/32-SAM | supervised supervised adversarial | 0.05 0.1 |
| ViT-B/16-SAM | adversarial | 0.1 0.1 |
| | |
| supervised contrastive | |
| | |
| adversarial | |
| | |
| ViT-S/16-SAM | | 0.02 |
| ViT-B/16-SAM | | |
| supervised contrastive | 0.02 |
| MLP-Mixer | |
| Mixer-S/32-SAM | | |
| Mixer-S/16-SAM | supervised | 0.1 |
| supervised | 0.15 |
| Mixer-S/8-SAM | supervised | 0.2 |
| Mixer-B/32-SAM | supervised | 0.35 |
| Mixer-B/16-SAM | supervised | 0.6 |
| Mixer-B/8-SAM | | 0.6 |
| supervised | |
| Mixer-B/16-AUG-SAM | supervised | 0.2 |
| Mixer-S/16-SAM | adversarial | 0.05 |
| | |
| Mixer-B/32-SAM | adversarial | 0.25 |
| Mixer-B/16-SAM | adversarial | 0.25 |
",
+ "type": "table",
+ "image_path": "1beebf9f7f5e48b922f58a5d7c61546b51986b29b6a4ff4c41a77d17c6e59012.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 13,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 207,
+ 106,
+ 406,
+ 120.3913043478261
+ ],
+ "spans": [],
+ "index": 2
+ },
+ {
+ "bbox": [
+ 207,
+ 120.3913043478261,
+ 406,
+ 134.7826086956522
+ ],
+ "spans": [],
+ "index": 3
+ },
+ {
+ "bbox": [
+ 207,
+ 134.7826086956522,
+ 406,
+ 149.17391304347828
+ ],
+ "spans": [],
+ "index": 4
+ },
+ {
+ "bbox": [
+ 207,
+ 149.17391304347828,
+ 406,
+ 163.56521739130437
+ ],
+ "spans": [],
+ "index": 5
+ },
+ {
+ "bbox": [
+ 207,
+ 163.56521739130437,
+ 406,
+ 177.95652173913047
+ ],
+ "spans": [],
+ "index": 6
+ },
+ {
+ "bbox": [
+ 207,
+ 177.95652173913047,
+ 406,
+ 192.34782608695656
+ ],
+ "spans": [],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 207,
+ 192.34782608695656,
+ 406,
+ 206.73913043478265
+ ],
+ "spans": [],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 207,
+ 206.73913043478265,
+ 406,
+ 221.13043478260875
+ ],
+ "spans": [],
+ "index": 9
+ },
+ {
+ "bbox": [
+ 207,
+ 221.13043478260875,
+ 406,
+ 235.52173913043484
+ ],
+ "spans": [],
+ "index": 10
+ },
+ {
+ "bbox": [
+ 207,
+ 235.52173913043484,
+ 406,
+ 249.91304347826093
+ ],
+ "spans": [],
+ "index": 11
+ },
+ {
+ "bbox": [
+ 207,
+ 249.91304347826093,
+ 406,
+ 264.304347826087
+ ],
+ "spans": [],
+ "index": 12
+ },
+ {
+ "bbox": [
+ 207,
+ 264.304347826087,
+ 406,
+ 278.69565217391306
+ ],
+ "spans": [],
+ "index": 13
+ },
+ {
+ "bbox": [
+ 207,
+ 278.69565217391306,
+ 406,
+ 293.0869565217391
+ ],
+ "spans": [],
+ "index": 14
+ },
+ {
+ "bbox": [
+ 207,
+ 293.0869565217391,
+ 406,
+ 307.4782608695652
+ ],
+ "spans": [],
+ "index": 15
+ },
+ {
+ "bbox": [
+ 207,
+ 307.4782608695652,
+ 406,
+ 321.86956521739125
+ ],
+ "spans": [],
+ "index": 16
+ },
+ {
+ "bbox": [
+ 207,
+ 321.86956521739125,
+ 406,
+ 336.2608695652173
+ ],
+ "spans": [],
+ "index": 17
+ },
+ {
+ "bbox": [
+ 207,
+ 336.2608695652173,
+ 406,
+ 350.6521739130434
+ ],
+ "spans": [],
+ "index": 18
+ },
+ {
+ "bbox": [
+ 207,
+ 350.6521739130434,
+ 406,
+ 365.04347826086945
+ ],
+ "spans": [],
+ "index": 19
+ },
+ {
+ "bbox": [
+ 207,
+ 365.04347826086945,
+ 406,
+ 379.4347826086955
+ ],
+ "spans": [],
+ "index": 20
+ },
+ {
+ "bbox": [
+ 207,
+ 379.4347826086955,
+ 406,
+ 393.8260869565216
+ ],
+ "spans": [],
+ "index": 21
+ },
+ {
+ "bbox": [
+ 207,
+ 393.8260869565216,
+ 406,
+ 408.21739130434764
+ ],
+ "spans": [],
+ "index": 22
+ },
+ {
+ "bbox": [
+ 207,
+ 408.21739130434764,
+ 406,
+ 422.6086956521737
+ ],
+ "spans": [],
+ "index": 23
+ },
+ {
+ "bbox": [
+ 207,
+ 422.6086956521737,
+ 406,
+ 436.9999999999998
+ ],
+ "spans": [],
+ "index": 24
+ }
+ ]
+ }
+ ],
+ "index": 6.75
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 107,
+ 457,
+ 244,
+ 470
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 456,
+ 245,
+ 472
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 456,
+ 245,
+ 472
+ ],
+ "score": 1.0,
+ "content": "F HESSIAN EIGENVALUE",
+ "type": "text"
+ }
+ ],
+ "index": 25
+ }
+ ],
+ "index": 25
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 483,
+ 505,
+ 516
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 482,
+ 505,
+ 496
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 482,
+ 505,
+ 496
+ ],
+ "score": 1.0,
+ "content": "The Hessian matrix requires second-order derivative, so we compute the Hessian (and all the sub-",
+ "type": "text"
+ }
+ ],
+ "index": 26
+ },
+ {
+ "bbox": [
+ 105,
+ 493,
+ 506,
+ 507
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 493,
+ 182,
+ 507
+ ],
+ "score": 1.0,
+ "content": "diagonal Hessian)",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 183,
+ 494,
+ 206,
+ 505
+ ],
+ "score": 0.92,
+ "content": "\\lambda _ { m a x }",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 207,
+ 493,
+ 234,
+ 507
+ ],
+ "score": 1.0,
+ "content": "using",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 234,
+ 494,
+ 254,
+ 504
+ ],
+ "score": 0.86,
+ "content": "10 \\%",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 254,
+ 493,
+ 506,
+ 507
+ ],
+ "score": 1.0,
+ "content": "of the ImageNet training images (i.e., i1k (1/10)) via power",
+ "type": "text"
+ }
+ ],
+ "index": 27
+ },
+ {
+ "bbox": [
+ 105,
+ 504,
+ 370,
+ 517
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 504,
+ 370,
+ 517
+ ],
+ "score": 1.0,
+ "content": "iteration 1, where we use 100 iterations to ensure its convergence.",
+ "type": "text"
+ }
+ ],
+ "index": 28
+ }
+ ],
+ "index": 27
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 532,
+ 267,
+ 546
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 268,
+ 547
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 268,
+ 547
+ ],
+ "score": 1.0,
+ "content": "G NTK CONDITION NUMBER",
+ "type": "text"
+ }
+ ],
+ "index": 29
+ }
+ ],
+ "index": 29
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 558,
+ 505,
+ 613
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 558,
+ 505,
+ 571
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 558,
+ 505,
+ 571
+ ],
+ "score": 1.0,
+ "content": "We approximate the neural tangent kernel on the i1k (1/10) subset by averaging over block diagonal",
+ "type": "text"
+ }
+ ],
+ "index": 30
+ },
+ {
+ "bbox": [
+ 106,
+ 570,
+ 504,
+ 581
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 570,
+ 201,
+ 581
+ ],
+ "score": 1.0,
+ "content": "entries (with block size",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 201,
+ 570,
+ 236,
+ 581
+ ],
+ "score": 0.88,
+ "content": "4 8 \\times 4 8 )",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 236,
+ 570,
+ 504,
+ 581
+ ],
+ "score": 1.0,
+ "content": ") in the full NTK. Notice that the computation is based on the archi-",
+ "type": "text"
+ }
+ ],
+ "index": 31
+ },
+ {
+ "bbox": [
+ 105,
+ 578,
+ 505,
+ 594
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 578,
+ 505,
+ 594
+ ],
+ "score": 1.0,
+ "content": "tecture at initialization without training. As the activation plays an important role when computing",
+ "type": "text"
+ }
+ ],
+ "index": 32
+ },
+ {
+ "bbox": [
+ 105,
+ 590,
+ 505,
+ 604
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 590,
+ 505,
+ 604
+ ],
+ "score": 1.0,
+ "content": "NTK — we find that smoother activation functions enjoy smaller condition numbers, we replace the",
+ "type": "text"
+ }
+ ],
+ "index": 33
+ },
+ {
+ "bbox": [
+ 105,
+ 601,
+ 419,
+ 615
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 601,
+ 419,
+ 615
+ ],
+ "score": 1.0,
+ "content": "GELU in ViT and MLP-Mixer with ReLU for a fair comparison with ResNet.",
+ "type": "text"
+ }
+ ],
+ "index": 34
+ }
+ ],
+ "index": 32
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 631,
+ 229,
+ 644
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 629,
+ 230,
+ 645
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 629,
+ 230,
+ 645
+ ],
+ "score": 1.0,
+ "content": "H TRAINING DETAILS",
+ "type": "text"
+ }
+ ],
+ "index": 35
+ }
+ ],
+ "index": 35
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 656,
+ 505,
+ 712
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 107,
+ 657,
+ 504,
+ 668
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 107,
+ 657,
+ 208,
+ 668
+ ],
+ "score": 1.0,
+ "content": "We use image resolution",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 208,
+ 657,
+ 252,
+ 667
+ ],
+ "score": 0.89,
+ "content": "2 2 4 \\times 2 2 4",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 253,
+ 657,
+ 504,
+ 668
+ ],
+ "score": 1.0,
+ "content": "during fine-tuning on downstream tasks, other settings exactly",
+ "type": "text"
+ }
+ ],
+ "index": 36
+ },
+ {
+ "bbox": [
+ 105,
+ 666,
+ 505,
+ 680
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 666,
+ 505,
+ 680
+ ],
+ "score": 1.0,
+ "content": "follow (Dosovitskiy et al., 2021; Tolstikhin et al., 2021) (see Table 9). Note that we do not employ",
+ "type": "text"
+ }
+ ],
+ "index": 37
+ },
+ {
+ "bbox": [
+ 106,
+ 678,
+ 505,
+ 690
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 678,
+ 505,
+ 690
+ ],
+ "score": 1.0,
+ "content": "SAM during fine-tuning. We perform a grid search over the base learning rates on small sub-splits",
+ "type": "text"
+ }
+ ],
+ "index": 38
+ },
+ {
+ "bbox": [
+ 105,
+ 688,
+ 505,
+ 702
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 688,
+ 187,
+ 702
+ ],
+ "score": 1.0,
+ "content": "of the training sets",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 188,
+ 690,
+ 207,
+ 700
+ ],
+ "score": 0.86,
+ "content": "10 \\%",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 207,
+ 688,
+ 296,
+ 702
+ ],
+ "score": 1.0,
+ "content": "for Flowers and Pets,",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 296,
+ 689,
+ 311,
+ 700
+ ],
+ "score": 0.85,
+ "content": "2 \\%",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 311,
+ 688,
+ 505,
+ 702
+ ],
+ "score": 1.0,
+ "content": "for CIFAR-10/100). After that, we fine-tune on",
+ "type": "text"
+ }
+ ],
+ "index": 39
+ },
+ {
+ "bbox": [
+ 106,
+ 701,
+ 389,
+ 713
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 701,
+ 389,
+ 713
+ ],
+ "score": 1.0,
+ "content": "the entire training sets and report the results on the respective test sets.",
+ "type": "text"
+ }
+ ],
+ "index": 40
+ }
+ ],
+ "index": 38
+ }
+ ],
+ "page_idx": 17,
+ "page_size": [
+ 612,
+ 792
+ ],
+ "discarded_blocks": [
+ {
+ "type": "discarded",
+ "bbox": [
+ 108,
+ 27,
+ 293,
+ 37
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 25,
+ 293,
+ 38
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 25,
+ 293,
+ 38
+ ],
+ "score": 1.0,
+ "content": "Published as a conference paper at ICLR 2022",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "type": "discarded",
+ "bbox": [
+ 300,
+ 751,
+ 311,
+ 760
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 299,
+ 750,
+ 313,
+ 763
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 299,
+ 750,
+ 313,
+ 763
+ ],
+ "score": 1.0,
+ "content": "18",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "type": "discarded",
+ "bbox": [
+ 118,
+ 722,
+ 366,
+ 732
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 119,
+ 720,
+ 367,
+ 733
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 119,
+ 720,
+ 367,
+ 733
+ ],
+ "score": 1.0,
+ "content": "1https://en.wikipedia.org/wiki/Power_iteration",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "para_blocks": [
+ {
+ "type": "table",
+ "bbox": [
+ 207,
+ 106,
+ 406,
+ 437
+ ],
+ "blocks": [
+ {
+ "type": "table_caption",
+ "bbox": [
+ 108,
+ 80,
+ 503,
+ 103
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 80,
+ 505,
+ 93
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 80,
+ 275,
+ 93
+ ],
+ "score": 1.0,
+ "content": "Table 11: The SAM perturbation strength",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 275,
+ 82,
+ 282,
+ 92
+ ],
+ "score": 0.81,
+ "content": "\\rho",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 282,
+ 80,
+ 505,
+ 93
+ ],
+ "score": 1.0,
+ "content": "for training on ImageNet. ViTs and MLP-Mixers favor",
+ "type": "text"
+ }
+ ],
+ "index": 0
+ },
+ {
+ "bbox": [
+ 106,
+ 91,
+ 491,
+ 104
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 91,
+ 131,
+ 104
+ ],
+ "score": 1.0,
+ "content": "larger",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 132,
+ 93,
+ 139,
+ 103
+ ],
+ "score": 0.75,
+ "content": "\\rho",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 139,
+ 91,
+ 491,
+ 104
+ ],
+ "score": 1.0,
+ "content": "than ResNets does. Larger models with longer patch sequences need stronger strengths.",
+ "type": "text"
+ }
+ ],
+ "index": 1
+ }
+ ],
+ "index": 0.5
+ },
+ {
+ "type": "table_body",
+ "bbox": [
+ 207,
+ 106,
+ 406,
+ 437
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 207,
+ 106,
+ 406,
+ 437
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 207,
+ 106,
+ 406,
+ 437
+ ],
+ "score": 0.97,
+ "html": "| Model | Task | SAM p |
| ResNet |
| ResNet-50-SAM ResNet-101-SAM ResNet-152-SAM ResNet-50x2-SAM ResNet-101x2-SAM ResNet-152x2-SAM ResNet-50-SAM | supervised supervised supervised supervised supervised supervised | 0.02 0.05 0.02 0.05 0.05 0.05 0.05 |
| ResNet-152-SAM adversarial ViT |
| ViT-S/16-SAM ViT-S/14-SAM ViT-S/8-SAM ViT-B/32-SAM ViT-B/16-SAM | supervised supervised supervised supervised | 0.1 0.1 0.15 0.15 0.2 |
| ViT-B/16-AUG-SAM ViT-S/16-SAM ViT-B/32-SAM | supervised supervised adversarial | 0.05 0.1 |
| ViT-B/16-SAM | adversarial | 0.1 0.1 |
| | |
| supervised contrastive | |
| | |
| adversarial | |
| | |
| ViT-S/16-SAM | | 0.02 |
| ViT-B/16-SAM | | |
| supervised contrastive | 0.02 |
| MLP-Mixer | |
| Mixer-S/32-SAM | | |
| Mixer-S/16-SAM | supervised | 0.1 |
| supervised | 0.15 |
| Mixer-S/8-SAM | supervised | 0.2 |
| Mixer-B/32-SAM | supervised | 0.35 |
| Mixer-B/16-SAM | supervised | 0.6 |
| Mixer-B/8-SAM | | 0.6 |
| supervised | |
| Mixer-B/16-AUG-SAM | supervised | 0.2 |
| Mixer-S/16-SAM | adversarial | 0.05 |
| | |
| Mixer-B/32-SAM | adversarial | 0.25 |
| Mixer-B/16-SAM | adversarial | 0.25 |
",
+ "type": "table",
+ "image_path": "1beebf9f7f5e48b922f58a5d7c61546b51986b29b6a4ff4c41a77d17c6e59012.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 13,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 207,
+ 106,
+ 406,
+ 120.3913043478261
+ ],
+ "spans": [],
+ "index": 2
+ },
+ {
+ "bbox": [
+ 207,
+ 120.3913043478261,
+ 406,
+ 134.7826086956522
+ ],
+ "spans": [],
+ "index": 3
+ },
+ {
+ "bbox": [
+ 207,
+ 134.7826086956522,
+ 406,
+ 149.17391304347828
+ ],
+ "spans": [],
+ "index": 4
+ },
+ {
+ "bbox": [
+ 207,
+ 149.17391304347828,
+ 406,
+ 163.56521739130437
+ ],
+ "spans": [],
+ "index": 5
+ },
+ {
+ "bbox": [
+ 207,
+ 163.56521739130437,
+ 406,
+ 177.95652173913047
+ ],
+ "spans": [],
+ "index": 6
+ },
+ {
+ "bbox": [
+ 207,
+ 177.95652173913047,
+ 406,
+ 192.34782608695656
+ ],
+ "spans": [],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 207,
+ 192.34782608695656,
+ 406,
+ 206.73913043478265
+ ],
+ "spans": [],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 207,
+ 206.73913043478265,
+ 406,
+ 221.13043478260875
+ ],
+ "spans": [],
+ "index": 9
+ },
+ {
+ "bbox": [
+ 207,
+ 221.13043478260875,
+ 406,
+ 235.52173913043484
+ ],
+ "spans": [],
+ "index": 10
+ },
+ {
+ "bbox": [
+ 207,
+ 235.52173913043484,
+ 406,
+ 249.91304347826093
+ ],
+ "spans": [],
+ "index": 11
+ },
+ {
+ "bbox": [
+ 207,
+ 249.91304347826093,
+ 406,
+ 264.304347826087
+ ],
+ "spans": [],
+ "index": 12
+ },
+ {
+ "bbox": [
+ 207,
+ 264.304347826087,
+ 406,
+ 278.69565217391306
+ ],
+ "spans": [],
+ "index": 13
+ },
+ {
+ "bbox": [
+ 207,
+ 278.69565217391306,
+ 406,
+ 293.0869565217391
+ ],
+ "spans": [],
+ "index": 14
+ },
+ {
+ "bbox": [
+ 207,
+ 293.0869565217391,
+ 406,
+ 307.4782608695652
+ ],
+ "spans": [],
+ "index": 15
+ },
+ {
+ "bbox": [
+ 207,
+ 307.4782608695652,
+ 406,
+ 321.86956521739125
+ ],
+ "spans": [],
+ "index": 16
+ },
+ {
+ "bbox": [
+ 207,
+ 321.86956521739125,
+ 406,
+ 336.2608695652173
+ ],
+ "spans": [],
+ "index": 17
+ },
+ {
+ "bbox": [
+ 207,
+ 336.2608695652173,
+ 406,
+ 350.6521739130434
+ ],
+ "spans": [],
+ "index": 18
+ },
+ {
+ "bbox": [
+ 207,
+ 350.6521739130434,
+ 406,
+ 365.04347826086945
+ ],
+ "spans": [],
+ "index": 19
+ },
+ {
+ "bbox": [
+ 207,
+ 365.04347826086945,
+ 406,
+ 379.4347826086955
+ ],
+ "spans": [],
+ "index": 20
+ },
+ {
+ "bbox": [
+ 207,
+ 379.4347826086955,
+ 406,
+ 393.8260869565216
+ ],
+ "spans": [],
+ "index": 21
+ },
+ {
+ "bbox": [
+ 207,
+ 393.8260869565216,
+ 406,
+ 408.21739130434764
+ ],
+ "spans": [],
+ "index": 22
+ },
+ {
+ "bbox": [
+ 207,
+ 408.21739130434764,
+ 406,
+ 422.6086956521737
+ ],
+ "spans": [],
+ "index": 23
+ },
+ {
+ "bbox": [
+ 207,
+ 422.6086956521737,
+ 406,
+ 436.9999999999998
+ ],
+ "spans": [],
+ "index": 24
+ }
+ ]
+ }
+ ],
+ "index": 6.75
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 107,
+ 457,
+ 244,
+ 470
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 456,
+ 245,
+ 472
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 456,
+ 245,
+ 472
+ ],
+ "score": 1.0,
+ "content": "F HESSIAN EIGENVALUE",
+ "type": "text"
+ }
+ ],
+ "index": 25
+ }
+ ],
+ "index": 25
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 483,
+ 505,
+ 516
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 482,
+ 505,
+ 496
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 482,
+ 505,
+ 496
+ ],
+ "score": 1.0,
+ "content": "The Hessian matrix requires second-order derivative, so we compute the Hessian (and all the sub-",
+ "type": "text"
+ }
+ ],
+ "index": 26
+ },
+ {
+ "bbox": [
+ 105,
+ 493,
+ 506,
+ 507
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 493,
+ 182,
+ 507
+ ],
+ "score": 1.0,
+ "content": "diagonal Hessian)",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 183,
+ 494,
+ 206,
+ 505
+ ],
+ "score": 0.92,
+ "content": "\\lambda _ { m a x }",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 207,
+ 493,
+ 234,
+ 507
+ ],
+ "score": 1.0,
+ "content": "using",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 234,
+ 494,
+ 254,
+ 504
+ ],
+ "score": 0.86,
+ "content": "10 \\%",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 254,
+ 493,
+ 506,
+ 507
+ ],
+ "score": 1.0,
+ "content": "of the ImageNet training images (i.e., i1k (1/10)) via power",
+ "type": "text"
+ }
+ ],
+ "index": 27
+ },
+ {
+ "bbox": [
+ 105,
+ 504,
+ 370,
+ 517
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 504,
+ 370,
+ 517
+ ],
+ "score": 1.0,
+ "content": "iteration 1, where we use 100 iterations to ensure its convergence.",
+ "type": "text"
+ }
+ ],
+ "index": 28
+ }
+ ],
+ "index": 27,
+ "bbox_fs": [
+ 105,
+ 482,
+ 506,
+ 517
+ ]
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 532,
+ 267,
+ 546
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 268,
+ 547
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 268,
+ 547
+ ],
+ "score": 1.0,
+ "content": "G NTK CONDITION NUMBER",
+ "type": "text"
+ }
+ ],
+ "index": 29
+ }
+ ],
+ "index": 29
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 558,
+ 505,
+ 613
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 558,
+ 505,
+ 571
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 558,
+ 505,
+ 571
+ ],
+ "score": 1.0,
+ "content": "We approximate the neural tangent kernel on the i1k (1/10) subset by averaging over block diagonal",
+ "type": "text"
+ }
+ ],
+ "index": 30
+ },
+ {
+ "bbox": [
+ 106,
+ 570,
+ 504,
+ 581
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 570,
+ 201,
+ 581
+ ],
+ "score": 1.0,
+ "content": "entries (with block size",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 201,
+ 570,
+ 236,
+ 581
+ ],
+ "score": 0.88,
+ "content": "4 8 \\times 4 8 )",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 236,
+ 570,
+ 504,
+ 581
+ ],
+ "score": 1.0,
+ "content": ") in the full NTK. Notice that the computation is based on the archi-",
+ "type": "text"
+ }
+ ],
+ "index": 31
+ },
+ {
+ "bbox": [
+ 105,
+ 578,
+ 505,
+ 594
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 578,
+ 505,
+ 594
+ ],
+ "score": 1.0,
+ "content": "tecture at initialization without training. As the activation plays an important role when computing",
+ "type": "text"
+ }
+ ],
+ "index": 32
+ },
+ {
+ "bbox": [
+ 105,
+ 590,
+ 505,
+ 604
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 590,
+ 505,
+ 604
+ ],
+ "score": 1.0,
+ "content": "NTK — we find that smoother activation functions enjoy smaller condition numbers, we replace the",
+ "type": "text"
+ }
+ ],
+ "index": 33
+ },
+ {
+ "bbox": [
+ 105,
+ 601,
+ 419,
+ 615
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 601,
+ 419,
+ 615
+ ],
+ "score": 1.0,
+ "content": "GELU in ViT and MLP-Mixer with ReLU for a fair comparison with ResNet.",
+ "type": "text"
+ }
+ ],
+ "index": 34
+ }
+ ],
+ "index": 32,
+ "bbox_fs": [
+ 105,
+ 558,
+ 505,
+ 615
+ ]
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 631,
+ 229,
+ 644
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 629,
+ 230,
+ 645
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 629,
+ 230,
+ 645
+ ],
+ "score": 1.0,
+ "content": "H TRAINING DETAILS",
+ "type": "text"
+ }
+ ],
+ "index": 35
+ }
+ ],
+ "index": 35
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 656,
+ 505,
+ 712
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 107,
+ 657,
+ 504,
+ 668
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 107,
+ 657,
+ 208,
+ 668
+ ],
+ "score": 1.0,
+ "content": "We use image resolution",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 208,
+ 657,
+ 252,
+ 667
+ ],
+ "score": 0.89,
+ "content": "2 2 4 \\times 2 2 4",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 253,
+ 657,
+ 504,
+ 668
+ ],
+ "score": 1.0,
+ "content": "during fine-tuning on downstream tasks, other settings exactly",
+ "type": "text"
+ }
+ ],
+ "index": 36
+ },
+ {
+ "bbox": [
+ 105,
+ 666,
+ 505,
+ 680
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 666,
+ 505,
+ 680
+ ],
+ "score": 1.0,
+ "content": "follow (Dosovitskiy et al., 2021; Tolstikhin et al., 2021) (see Table 9). Note that we do not employ",
+ "type": "text"
+ }
+ ],
+ "index": 37
+ },
+ {
+ "bbox": [
+ 106,
+ 678,
+ 505,
+ 690
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 678,
+ 505,
+ 690
+ ],
+ "score": 1.0,
+ "content": "SAM during fine-tuning. We perform a grid search over the base learning rates on small sub-splits",
+ "type": "text"
+ }
+ ],
+ "index": 38
+ },
+ {
+ "bbox": [
+ 105,
+ 688,
+ 505,
+ 702
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 688,
+ 187,
+ 702
+ ],
+ "score": 1.0,
+ "content": "of the training sets",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 188,
+ 690,
+ 207,
+ 700
+ ],
+ "score": 0.86,
+ "content": "10 \\%",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 207,
+ 688,
+ 296,
+ 702
+ ],
+ "score": 1.0,
+ "content": "for Flowers and Pets,",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 296,
+ 689,
+ 311,
+ 700
+ ],
+ "score": 0.85,
+ "content": "2 \\%",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 311,
+ 688,
+ 505,
+ 702
+ ],
+ "score": 1.0,
+ "content": "for CIFAR-10/100). After that, we fine-tune on",
+ "type": "text"
+ }
+ ],
+ "index": 39
+ },
+ {
+ "bbox": [
+ 106,
+ 701,
+ 389,
+ 713
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 701,
+ 389,
+ 713
+ ],
+ "score": 1.0,
+ "content": "the entire training sets and report the results on the respective test sets.",
+ "type": "text"
+ }
+ ],
+ "index": 40
+ }
+ ],
+ "index": 38,
+ "bbox_fs": [
+ 105,
+ 657,
+ 505,
+ 713
+ ]
+ }
+ ]
+ },
+ {
+ "preproc_blocks": [
+ {
+ "type": "table",
+ "bbox": [
+ 177,
+ 105,
+ 436,
+ 267
+ ],
+ "blocks": [
+ {
+ "type": "table_caption",
+ "bbox": [
+ 106,
+ 80,
+ 501,
+ 102
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 79,
+ 503,
+ 94
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 79,
+ 503,
+ 94
+ ],
+ "score": 1.0,
+ "content": "Table 12: Hyperparameters for training from scratch on ImageNet with basic Inception-style pre-",
+ "type": "text"
+ }
+ ],
+ "index": 0
+ },
+ {
+ "bbox": [
+ 105,
+ 91,
+ 285,
+ 104
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 91,
+ 168,
+ 104
+ ],
+ "score": 1.0,
+ "content": "processing and",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 169,
+ 91,
+ 212,
+ 102
+ ],
+ "score": 0.89,
+ "content": "2 2 4 \\times 2 2 4",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 213,
+ 91,
+ 285,
+ 104
+ ],
+ "score": 1.0,
+ "content": "image resolution.",
+ "type": "text"
+ }
+ ],
+ "index": 1
+ }
+ ],
+ "index": 0.5
+ },
+ {
+ "type": "table_body",
+ "bbox": [
+ 177,
+ 105,
+ 436,
+ 267
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 177,
+ 105,
+ 436,
+ 267
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 177,
+ 105,
+ 436,
+ 267
+ ],
+ "score": 0.981,
+ "html": "| Model | Task | SAM p |
| ResNet |
| ResNet-50-SAM ResNet-101-SAM ResNet-152-SAM ResNet-50x2-SAM ResNet-101x2-SAM ResNet-152x2-SAM ResNet-50-SAM | supervised supervised supervised supervised supervised supervised | 0.02 0.05 0.02 0.05 0.05 0.05 0.05 |
| ResNet-152-SAM adversarial ViT |
| ViT-S/16-SAM ViT-S/14-SAM ViT-S/8-SAM ViT-B/32-SAM ViT-B/16-SAM | supervised supervised supervised supervised | 0.1 0.1 0.15 0.15 0.2 |
| ViT-B/16-AUG-SAM ViT-S/16-SAM ViT-B/32-SAM | supervised supervised adversarial | 0.05 0.1 |
| ViT-B/16-SAM | adversarial | 0.1 0.1 |
| | |
| supervised contrastive | |
| | |
| adversarial | |
| | |
| ViT-S/16-SAM | | 0.02 |
| ViT-B/16-SAM | | |
| supervised contrastive | 0.02 |
| MLP-Mixer | |
| Mixer-S/32-SAM | | |
| Mixer-S/16-SAM | supervised | 0.1 |
| supervised | 0.15 |
| Mixer-S/8-SAM | supervised | 0.2 |
| Mixer-B/32-SAM | supervised | 0.35 |
| Mixer-B/16-SAM | supervised | 0.6 |
| Mixer-B/8-SAM | | 0.6 |
| supervised | |
| Mixer-B/16-AUG-SAM | supervised | 0.2 |
| Mixer-S/16-SAM | adversarial | 0.05 |
| | |
| Mixer-B/32-SAM | adversarial | 0.25 |
| Mixer-B/16-SAM | adversarial | 0.25 |
"
+ },
+ {
+ "category_id": 6,
+ "poly": [
+ 300,
+ 224,
+ 1398,
+ 224,
+ 1398,
+ 287,
+ 300,
+ 287
+ ],
+ "score": 0.935
+ },
+ {
+ "category_id": 0,
+ "poly": [
+ 299,
+ 1270,
+ 678,
+ 1270,
+ 678,
+ 1307,
+ 299,
+ 1307
+ ],
+ "score": 0.916
+ },
+ {
+ "category_id": 0,
+ "poly": [
+ 301,
+ 1479,
+ 743,
+ 1479,
+ 743,
+ 1517,
+ 301,
+ 1517
+ ],
+ "score": 0.894
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 300,
+ 75,
+ 815,
+ 75,
+ 815,
+ 104,
+ 300,
+ 104
+ ],
+ "score": 0.89
+ },
+ {
+ "category_id": 0,
+ "poly": [
+ 300,
+ 1753,
+ 638,
+ 1753,
+ 638,
+ 1789,
+ 300,
+ 1789
+ ],
+ "score": 0.875
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 836,
+ 2088,
+ 865,
+ 2088,
+ 865,
+ 2112,
+ 836,
+ 2112
+ ],
+ "score": 0.857
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 329,
+ 2006,
+ 1019,
+ 2006,
+ 1019,
+ 2034,
+ 329,
+ 2034
+ ],
+ "score": 0.501
+ },
+ {
+ "category_id": 2,
+ "poly": [
+ 331,
+ 2006,
+ 1018,
+ 2006,
+ 1018,
+ 2034,
+ 331,
+ 2034
+ ],
+ "score": 0.399
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 509,
+ 1374,
+ 574,
+ 1374,
+ 574,
+ 1404,
+ 509,
+ 1404
+ ],
+ "score": 0.92,
+ "latex": "\\lambda _ { m a x }"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 579,
+ 1825,
+ 702,
+ 1825,
+ 702,
+ 1854,
+ 579,
+ 1854
+ ],
+ "score": 0.89,
+ "latex": "2 2 4 \\times 2 2 4"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 561,
+ 1584,
+ 656,
+ 1584,
+ 656,
+ 1614,
+ 561,
+ 1614
+ ],
+ "score": 0.88,
+ "latex": "4 8 \\times 4 8 )"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 652,
+ 1373,
+ 706,
+ 1373,
+ 706,
+ 1402,
+ 652,
+ 1402
+ ],
+ "score": 0.86,
+ "latex": "10 \\%"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 523,
+ 1917,
+ 576,
+ 1917,
+ 576,
+ 1945,
+ 523,
+ 1945
+ ],
+ "score": 0.86,
+ "latex": "10 \\%"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 824,
+ 1916,
+ 865,
+ 1916,
+ 865,
+ 1945,
+ 824,
+ 1945
+ ],
+ "score": 0.85,
+ "latex": "2 \\%"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 766,
+ 230,
+ 785,
+ 230,
+ 785,
+ 257,
+ 766,
+ 257
+ ],
+ "score": 0.81,
+ "latex": "\\rho"
+ },
+ {
+ "category_id": 13,
+ "poly": [
+ 367,
+ 259,
+ 387,
+ 259,
+ 387,
+ 287,
+ 367,
+ 287
+ ],
+ "score": 0.75,
+ "latex": "\\rho"
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 224.0,
+ 765.0,
+ 224.0,
+ 765.0,
+ 259.0,
+ 296.0,
+ 259.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 786.0,
+ 224.0,
+ 1403.0,
+ 224.0,
+ 1403.0,
+ 259.0,
+ 786.0,
+ 259.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 254.0,
+ 366.0,
+ 254.0,
+ 366.0,
+ 290.0,
+ 296.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 388.0,
+ 254.0,
+ 1366.0,
+ 254.0,
+ 1366.0,
+ 290.0,
+ 388.0,
+ 290.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 292.0,
+ 1268.0,
+ 681.0,
+ 1268.0,
+ 681.0,
+ 1312.0,
+ 292.0,
+ 1312.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 1480.0,
+ 747.0,
+ 1480.0,
+ 747.0,
+ 1521.0,
+ 296.0,
+ 1521.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 296.0,
+ 72.0,
+ 816.0,
+ 72.0,
+ 816.0,
+ 108.0,
+ 296.0,
+ 108.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1749.0,
+ 641.0,
+ 1749.0,
+ 641.0,
+ 1794.0,
+ 293.0,
+ 1794.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 832.0,
+ 2085.0,
+ 870.0,
+ 2085.0,
+ 870.0,
+ 2122.0,
+ 832.0,
+ 2122.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 333.0,
+ 2002.0,
+ 1021.0,
+ 2002.0,
+ 1021.0,
+ 2037.0,
+ 333.0,
+ 2037.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 334.0,
+ 2002.0,
+ 1022.0,
+ 2002.0,
+ 1022.0,
+ 2037.0,
+ 334.0,
+ 2037.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 297.0,
+ 1551.0,
+ 1405.0,
+ 1551.0,
+ 1405.0,
+ 1588.0,
+ 297.0,
+ 1588.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 297.0,
+ 1586.0,
+ 560.0,
+ 1586.0,
+ 560.0,
+ 1615.0,
+ 297.0,
+ 1615.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 657.0,
+ 1586.0,
+ 1401.0,
+ 1586.0,
+ 1401.0,
+ 1615.0,
+ 657.0,
+ 1615.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1608.0,
+ 1404.0,
+ 1608.0,
+ 1404.0,
+ 1652.0,
+ 293.0,
+ 1652.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 292.0,
+ 1641.0,
+ 1404.0,
+ 1641.0,
+ 1404.0,
+ 1680.0,
+ 292.0,
+ 1680.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1672.0,
+ 1165.0,
+ 1672.0,
+ 1165.0,
+ 1711.0,
+ 293.0,
+ 1711.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1339.0,
+ 1405.0,
+ 1339.0,
+ 1405.0,
+ 1380.0,
+ 293.0,
+ 1380.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1370.0,
+ 508.0,
+ 1370.0,
+ 508.0,
+ 1410.0,
+ 293.0,
+ 1410.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 575.0,
+ 1370.0,
+ 651.0,
+ 1370.0,
+ 651.0,
+ 1410.0,
+ 575.0,
+ 1410.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 707.0,
+ 1370.0,
+ 1407.0,
+ 1370.0,
+ 1407.0,
+ 1410.0,
+ 707.0,
+ 1410.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 294.0,
+ 1401.0,
+ 1030.0,
+ 1401.0,
+ 1030.0,
+ 1438.0,
+ 294.0,
+ 1438.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 298.0,
+ 1825.0,
+ 578.0,
+ 1825.0,
+ 578.0,
+ 1858.0,
+ 298.0,
+ 1858.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 703.0,
+ 1825.0,
+ 1402.0,
+ 1825.0,
+ 1402.0,
+ 1858.0,
+ 703.0,
+ 1858.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1851.0,
+ 1403.0,
+ 1851.0,
+ 1403.0,
+ 1891.0,
+ 293.0,
+ 1891.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1886.0,
+ 1404.0,
+ 1886.0,
+ 1404.0,
+ 1919.0,
+ 295.0,
+ 1919.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 293.0,
+ 1912.0,
+ 522.0,
+ 1912.0,
+ 522.0,
+ 1952.0,
+ 293.0,
+ 1952.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 577.0,
+ 1912.0,
+ 823.0,
+ 1912.0,
+ 823.0,
+ 1952.0,
+ 577.0,
+ 1952.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 866.0,
+ 1912.0,
+ 1405.0,
+ 1912.0,
+ 1405.0,
+ 1952.0,
+ 866.0,
+ 1952.0
+ ],
+ "score": 1.0,
+ "text": ""
+ },
+ {
+ "category_id": 15,
+ "poly": [
+ 295.0,
+ 1948.0,
+ 1083.0,
+ 1948.0,
+ 1083.0,
+ 1982.0,
+ 295.0,
+ 1982.0
+ ],
+ "score": 1.0,
+ "text": ""
+ }
+ ],
+ "page_info": {
+ "page_no": 17,
+ "width": 1700,
+ "height": 2200
+ }
+ },
+ {
+ "layout_dets": [
+ {
+ "category_id": 1,
+ "poly": [
+ 297,
+ 1489,
+ 1404,
+ 1489,
+ 1404,
+ 1797,
+ 297,
+ 1797
+ ],
+ "score": 0.983
+ },
+ {
+ "category_id": 1,
+ "poly": [
+ 297,
+ 1038,
+ 1405,
+ 1038,
+ 1405,
+ 1376,
+ 297,
+ 1376
+ ],
+ "score": 0.981
+ },
+ {
+ "category_id": 5,
+ "poly": [
+ 493,
+ 294,
+ 1212,
+ 294,
+ 1212,
+ 743,
+ 493,
+ 743
+ ],
+ "score": 0.981,
+ "html": "| Model | Param.↓ | Valid↓ | Test↓ |
| Adaptive Inputs (Baevski & Auli, 2018) | 247M | 17.97 | 18.70 |
| Transformer-XL (Dai et al., 2019) | 257M | 1 | 18.3 |
| Shortformer (Press et al.,2021) | 247M | 17.47 | 18.15 |
| Sandwich Transformer (Press et al., 2020) | 247M | 1 | 17.96 |
| Staged Training (Press et al.,2021) | 247M | | 17.56 |
| Compressive Transformer (Rae et al., 2020) | 329M | | 17.1 |
| Routing Transformer (Roy et al., 2020) | | = | 15.8 |
| kNN-LM (Khandelwal et al., 2020) | 247M | 15.81 | 15.79 |
| Sinusoidal, L = 3072 | 247M | 17.95 | 18.67 |
| Rotary,L = 3072 | 247M | 17.98 | 18.72 |
| T5 Bias,L = 3072 | 247M | 17.37 | 18.12 |
| L = 512,Lyalid = 3072 | 247M | 18.30 | 19.01 |
| L = 3072,Lvalid = 3072 | 247M | 16.97 | 17.66 |
",
+ "bbox": [
+ 251,
+ 378,
+ 746,
+ 609
+ ],
+ "page_idx": 19
+ },
+ {
+ "type": "text",
+ "text": "A.3 RESULTS ON THE TORONTO BOOK CORPUS ",
+ "text_level": 1,
+ "bbox": [
+ 174,
+ 643,
+ 519,
+ 659
+ ],
+ "page_idx": 19
+ },
+ {
+ "type": "text",
+ "text": "To ensure that our results are not specific to the WikiText-103 corpus, we next apply our model and the baselines to a different domain while using a similar model architecture and the same ALiBi slopes as those used in the previous subsection. ",
+ "bbox": [
+ 174,
+ 671,
+ 823,
+ 713
+ ],
+ "page_idx": 19
+ },
+ {
+ "type": "text",
+ "text": "We emphasize that our set of slopes was chosen by running experiments on the WikiText-103 corpus, and here we apply that set of slopes to a model trained on a very different text domain. Throughout the entire process of developing this method, we ran only one set of experiments on this domain using the previously selected set of slopes. ",
+ "bbox": [
+ 174,
+ 720,
+ 825,
+ 776
+ ],
+ "page_idx": 19
+ },
+ {
+ "type": "text",
+ "text": "Specifically, we use the Toronto BooksCorpus (Zhu et al., 2015), which has been used to train BERT (Devlin et al., 2019) (in conjuction with the English Wikipedia). The corpus is about 700M tokens (2.9 GB). ",
+ "bbox": [
+ 174,
+ 784,
+ 825,
+ 825
+ ],
+ "page_idx": 19
+ },
+ {
+ "type": "text",
+ "text": "We use the same train/validation/test split as Khandelwal et al. (2020) and their tokenization, which uses BERT’s vocabulary of 29K byte-pair encodings. Since the vocabulary is much smaller than WikiText-103’s, we replace the adaptive word embedding and softmax of Baevski & Auli (2018) with a tied word embedding and softmax matrix (Press & Wolf, 2017; Inan et al., 2017). ",
+ "bbox": [
+ 176,
+ 832,
+ 823,
+ 888
+ ],
+ "page_idx": 19
+ },
+ {
+ "type": "text",
+ "text": "Our results in Figure 9 (and Table 8) replicate our success on the WikiText-103 dataset. Our model surpasses the sinusoidal baseline when trained on the same amount of input tokens $( L )$ and, in addition, our model is able to extrapolate to longer sequences at inference. This occurs even though our set of slopes was not tuned on this dataset. This result establishes the generality of ALiBi and the particular set of slopes we found and suggests that they may be used on different text domains without further hyperparameter tuning. ",
+ "bbox": [
+ 174,
+ 895,
+ 823,
+ 924
+ ],
+ "page_idx": 19
+ },
+ {
+ "type": "image",
+ "img_path": "images/5d2b57b38065977c1ee49f4412f8f13fc2f5d4c03b7b10ce48b0b3cb02da17e1.jpg",
+ "image_caption": [
+ "Figure 9: ALiBi-enabled models evaluated on different input lengths on the Toronto BookCorpus. Our models extrapolate to longer sequence lengths and outperform the sinusoidal baseline even when trained on much shorter sequences. "
+ ],
+ "image_footnote": [],
+ "bbox": [
+ 256,
+ 103,
+ 740,
+ 285
+ ],
+ "page_idx": 20
+ },
+ {
+ "type": "text",
+ "text": "",
+ "bbox": [
+ 174,
+ 375,
+ 825,
+ 431
+ ],
+ "page_idx": 20
+ },
+ {
+ "type": "text",
+ "text": "Tables 9 and 10 present the perplexities for our ALiBi models, the baselines, and the current state of the art on the Toronto BookCorpus validation and test sets. Our results here mirror our results on WikiText-103: we improve over the sinusoidal baseline even when AliBi is trained on fewer tokens. ",
+ "bbox": [
+ 174,
+ 438,
+ 825,
+ 481
+ ],
+ "page_idx": 20
+ },
+ {
+ "type": "text",
+ "text": "Table 8: ALiBi models extrapolating on the Toronto BookCorpus development set. ∗For the results of the sinusoidal models, $L = L _ { \\nu a l i d }$ (so we do not test the extrapolation abilities of those models here). ",
+ "bbox": [
+ 173,
+ 493,
+ 826,
+ 536
+ ],
+ "page_idx": 20
+ },
+ {
+ "type": "table",
+ "img_path": "images/e889b3a1178ecef869e7adf7daa4ad6ca8d1038dc0a6951439d94a7de2d0b10e.jpg",
+ "table_caption": [
+ "Table 9: Validation and test perplexities on the Toronto Book Corpus dataset. "
+ ],
+ "table_footnote": [],
+ "table_body": "| Model | Param.↓ | Valid↓ | Test↓ |
| Adaptive Inputs (Baevski & Auli, 2018) | 247M | 17.97 | 18.70 |
| Transformer-XL (Dai et al., 2019) | 257M | 1 | 18.3 |
| Shortformer (Press et al.,2021) | 247M | 17.47 | 18.15 |
| Sandwich Transformer (Press et al., 2020) | 247M | 1 | 17.96 |
| Staged Training (Press et al.,2021) | 247M | | 17.56 |
| Compressive Transformer (Rae et al., 2020) | 329M | | 17.1 |
| Routing Transformer (Roy et al., 2020) | | = | 15.8 |
| kNN-LM (Khandelwal et al., 2020) | 247M | 15.81 | 15.79 |
| Sinusoidal, L = 3072 | 247M | 17.95 | 18.67 |
| Rotary,L = 3072 | 247M | 17.98 | 18.72 |
| T5 Bias,L = 3072 | 247M | 17.37 | 18.12 |
| L = 512,Lyalid = 3072 | 247M | 18.30 | 19.01 |
| L = 3072,Lvalid = 3072 | 247M | 16.97 | 17.66 |
",
+ "type": "table",
+ "image_path": "0bd91b63ce4703aa872d8ff65c4a443fd070ffa7f726c8265da5e790e9ab1d6d.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 10,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 154,
+ 300,
+ 457,
+ 361.0
+ ],
+ "spans": [],
+ "index": 9
+ },
+ {
+ "bbox": [
+ 154,
+ 361.0,
+ 457,
+ 422.0
+ ],
+ "spans": [],
+ "index": 10
+ },
+ {
+ "bbox": [
+ 154,
+ 422.0,
+ 457,
+ 483.0
+ ],
+ "spans": [],
+ "index": 11
+ }
+ ]
+ }
+ ],
+ "index": 10
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 107,
+ 510,
+ 318,
+ 522
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 509,
+ 319,
+ 523
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 509,
+ 319,
+ 523
+ ],
+ "score": 1.0,
+ "content": "A.3 RESULTS ON THE TORONTO BOOK CORPUS",
+ "type": "text"
+ }
+ ],
+ "index": 12
+ }
+ ],
+ "index": 12
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 532,
+ 504,
+ 565
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 505,
+ 544
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 505,
+ 544
+ ],
+ "score": 1.0,
+ "content": "To ensure that our results are not specific to the WikiText-103 corpus, we next apply our model and",
+ "type": "text"
+ }
+ ],
+ "index": 13
+ },
+ {
+ "bbox": [
+ 106,
+ 543,
+ 505,
+ 555
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 543,
+ 505,
+ 555
+ ],
+ "score": 1.0,
+ "content": "the baselines to a different domain while using a similar model architecture and the same ALiBi",
+ "type": "text"
+ }
+ ],
+ "index": 14
+ },
+ {
+ "bbox": [
+ 106,
+ 554,
+ 298,
+ 567
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 554,
+ 298,
+ 567
+ ],
+ "score": 1.0,
+ "content": "slopes as those used in the previous subsection.",
+ "type": "text"
+ }
+ ],
+ "index": 15
+ }
+ ],
+ "index": 14
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 571,
+ 505,
+ 615
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 570,
+ 505,
+ 584
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 570,
+ 505,
+ 584
+ ],
+ "score": 1.0,
+ "content": "We emphasize that our set of slopes was chosen by running experiments on the WikiText-103 corpus,",
+ "type": "text"
+ }
+ ],
+ "index": 16
+ },
+ {
+ "bbox": [
+ 106,
+ 583,
+ 505,
+ 594
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 583,
+ 505,
+ 594
+ ],
+ "score": 1.0,
+ "content": "and here we apply that set of slopes to a model trained on a very different text domain. Throughout",
+ "type": "text"
+ }
+ ],
+ "index": 17
+ },
+ {
+ "bbox": [
+ 105,
+ 593,
+ 505,
+ 606
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 593,
+ 505,
+ 606
+ ],
+ "score": 1.0,
+ "content": "the entire process of developing this method, we ran only one set of experiments on this domain",
+ "type": "text"
+ }
+ ],
+ "index": 18
+ },
+ {
+ "bbox": [
+ 106,
+ 605,
+ 278,
+ 617
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 605,
+ 278,
+ 617
+ ],
+ "score": 1.0,
+ "content": "using the previously selected set of slopes.",
+ "type": "text"
+ }
+ ],
+ "index": 19
+ }
+ ],
+ "index": 17.5
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 621,
+ 505,
+ 654
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 620,
+ 506,
+ 633
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 620,
+ 506,
+ 633
+ ],
+ "score": 1.0,
+ "content": "Specifically, we use the Toronto BooksCorpus (Zhu et al., 2015), which has been used to train",
+ "type": "text"
+ }
+ ],
+ "index": 20
+ },
+ {
+ "bbox": [
+ 105,
+ 631,
+ 506,
+ 644
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 631,
+ 506,
+ 644
+ ],
+ "score": 1.0,
+ "content": "BERT (Devlin et al., 2019) (in conjuction with the English Wikipedia). The corpus is about 700M",
+ "type": "text"
+ }
+ ],
+ "index": 21
+ },
+ {
+ "bbox": [
+ 106,
+ 643,
+ 176,
+ 654
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 643,
+ 176,
+ 654
+ ],
+ "score": 1.0,
+ "content": "tokens (2.9 GB).",
+ "type": "text"
+ }
+ ],
+ "index": 22
+ }
+ ],
+ "index": 21
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 108,
+ 659,
+ 504,
+ 704
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 660,
+ 506,
+ 672
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 660,
+ 506,
+ 672
+ ],
+ "score": 1.0,
+ "content": "We use the same train/validation/test split as Khandelwal et al. (2020) and their tokenization, which",
+ "type": "text"
+ }
+ ],
+ "index": 23
+ },
+ {
+ "bbox": [
+ 105,
+ 670,
+ 506,
+ 684
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 670,
+ 506,
+ 684
+ ],
+ "score": 1.0,
+ "content": "uses BERT’s vocabulary of 29K byte-pair encodings. Since the vocabulary is much smaller than",
+ "type": "text"
+ }
+ ],
+ "index": 24
+ },
+ {
+ "bbox": [
+ 106,
+ 681,
+ 505,
+ 694
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 681,
+ 505,
+ 694
+ ],
+ "score": 1.0,
+ "content": "WikiText-103’s, we replace the adaptive word embedding and softmax of Baevski & Auli (2018)",
+ "type": "text"
+ }
+ ],
+ "index": 25
+ },
+ {
+ "bbox": [
+ 106,
+ 693,
+ 460,
+ 705
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 693,
+ 460,
+ 705
+ ],
+ "score": 1.0,
+ "content": "with a tied word embedding and softmax matrix (Press & Wolf, 2017; Inan et al., 2017).",
+ "type": "text"
+ }
+ ],
+ "index": 26
+ }
+ ],
+ "index": 24.5
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 709,
+ 504,
+ 732
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 709,
+ 505,
+ 722
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 709,
+ 505,
+ 722
+ ],
+ "score": 1.0,
+ "content": "Our results in Figure 9 (and Table 8) replicate our success on the WikiText-103 dataset. Our model",
+ "type": "text"
+ }
+ ],
+ "index": 27
+ },
+ {
+ "bbox": [
+ 105,
+ 720,
+ 506,
+ 733
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 720,
+ 456,
+ 733
+ ],
+ "score": 1.0,
+ "content": "surpasses the sinusoidal baseline when trained on the same amount of input tokens",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 457,
+ 721,
+ 471,
+ 731
+ ],
+ "score": 0.5,
+ "content": "( L )",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 471,
+ 720,
+ 506,
+ 733
+ ],
+ "score": 1.0,
+ "content": "and, in",
+ "type": "text"
+ }
+ ],
+ "index": 28
+ }
+ ],
+ "index": 27.5
+ }
+ ],
+ "page_idx": 19,
+ "page_size": [
+ 612,
+ 792
+ ],
+ "discarded_blocks": [
+ {
+ "type": "discarded",
+ "bbox": [
+ 108,
+ 27,
+ 293,
+ 37
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 26,
+ 294,
+ 38
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 26,
+ 294,
+ 38
+ ],
+ "score": 1.0,
+ "content": "Published as a conference paper at ICLR 2022",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "type": "discarded",
+ "bbox": [
+ 300,
+ 751,
+ 311,
+ 760
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 298,
+ 750,
+ 313,
+ 764
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 298,
+ 750,
+ 313,
+ 764
+ ],
+ "score": 1.0,
+ "content": "",
+ "type": "text",
+ "height": 14,
+ "width": 15
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "para_blocks": [
+ {
+ "type": "table",
+ "bbox": [
+ 144,
+ 116,
+ 466,
+ 224
+ ],
+ "blocks": [
+ {
+ "type": "table_caption",
+ "bbox": [
+ 106,
+ 80,
+ 505,
+ 103
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 79,
+ 505,
+ 92
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 79,
+ 505,
+ 92
+ ],
+ "score": 1.0,
+ "content": "Table 6: Test perplexity and runtime on WikiText-103 for two of our ALiBi models and models that",
+ "type": "text"
+ }
+ ],
+ "index": 0
+ },
+ {
+ "bbox": [
+ 106,
+ 91,
+ 296,
+ 103
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 91,
+ 296,
+ 103
+ ],
+ "score": 1.0,
+ "content": "use the sinusoidal, rotary and T5 bias methods.",
+ "type": "text"
+ }
+ ],
+ "index": 1
+ }
+ ],
+ "index": 0.5
+ },
+ {
+ "type": "table_body",
+ "bbox": [
+ 144,
+ 116,
+ 466,
+ 224
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 144,
+ 116,
+ 466,
+ 224
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 144,
+ 116,
+ 466,
+ 224
+ ],
+ "score": 0.982,
+ "html": "| Model | Param.↓ | Valid↓ | Test↓ |
| Adaptive Inputs (Baevski & Auli, 2018) | 247M | 17.97 | 18.70 |
| Transformer-XL (Dai et al., 2019) | 257M | 1 | 18.3 |
| Shortformer (Press et al.,2021) | 247M | 17.47 | 18.15 |
| Sandwich Transformer (Press et al., 2020) | 247M | 1 | 17.96 |
| Staged Training (Press et al.,2021) | 247M | | 17.56 |
| Compressive Transformer (Rae et al., 2020) | 329M | | 17.1 |
| Routing Transformer (Roy et al., 2020) | | = | 15.8 |
| kNN-LM (Khandelwal et al., 2020) | 247M | 15.81 | 15.79 |
| Sinusoidal, L = 3072 | 247M | 17.95 | 18.67 |
| Rotary,L = 3072 | 247M | 17.98 | 18.72 |
| T5 Bias,L = 3072 | 247M | 17.37 | 18.12 |
| L = 512,Lyalid = 3072 | 247M | 18.30 | 19.01 |
| L = 3072,Lvalid = 3072 | 247M | 16.97 | 17.66 |
",
+ "type": "table",
+ "image_path": "0bd91b63ce4703aa872d8ff65c4a443fd070ffa7f726c8265da5e790e9ab1d6d.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 10,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 154,
+ 300,
+ 457,
+ 361.0
+ ],
+ "spans": [],
+ "index": 9
+ },
+ {
+ "bbox": [
+ 154,
+ 361.0,
+ 457,
+ 422.0
+ ],
+ "spans": [],
+ "index": 10
+ },
+ {
+ "bbox": [
+ 154,
+ 422.0,
+ 457,
+ 483.0
+ ],
+ "spans": [],
+ "index": 11
+ }
+ ]
+ }
+ ],
+ "index": 10
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 107,
+ 510,
+ 318,
+ 522
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 509,
+ 319,
+ 523
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 509,
+ 319,
+ 523
+ ],
+ "score": 1.0,
+ "content": "A.3 RESULTS ON THE TORONTO BOOK CORPUS",
+ "type": "text"
+ }
+ ],
+ "index": 12
+ }
+ ],
+ "index": 12
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 532,
+ 504,
+ 565
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 505,
+ 544
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 532,
+ 505,
+ 544
+ ],
+ "score": 1.0,
+ "content": "To ensure that our results are not specific to the WikiText-103 corpus, we next apply our model and",
+ "type": "text"
+ }
+ ],
+ "index": 13
+ },
+ {
+ "bbox": [
+ 106,
+ 543,
+ 505,
+ 555
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 543,
+ 505,
+ 555
+ ],
+ "score": 1.0,
+ "content": "the baselines to a different domain while using a similar model architecture and the same ALiBi",
+ "type": "text"
+ }
+ ],
+ "index": 14
+ },
+ {
+ "bbox": [
+ 106,
+ 554,
+ 298,
+ 567
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 554,
+ 298,
+ 567
+ ],
+ "score": 1.0,
+ "content": "slopes as those used in the previous subsection.",
+ "type": "text"
+ }
+ ],
+ "index": 15
+ }
+ ],
+ "index": 14,
+ "bbox_fs": [
+ 106,
+ 532,
+ 505,
+ 567
+ ]
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 571,
+ 505,
+ 615
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 570,
+ 505,
+ 584
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 570,
+ 505,
+ 584
+ ],
+ "score": 1.0,
+ "content": "We emphasize that our set of slopes was chosen by running experiments on the WikiText-103 corpus,",
+ "type": "text"
+ }
+ ],
+ "index": 16
+ },
+ {
+ "bbox": [
+ 106,
+ 583,
+ 505,
+ 594
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 583,
+ 505,
+ 594
+ ],
+ "score": 1.0,
+ "content": "and here we apply that set of slopes to a model trained on a very different text domain. Throughout",
+ "type": "text"
+ }
+ ],
+ "index": 17
+ },
+ {
+ "bbox": [
+ 105,
+ 593,
+ 505,
+ 606
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 593,
+ 505,
+ 606
+ ],
+ "score": 1.0,
+ "content": "the entire process of developing this method, we ran only one set of experiments on this domain",
+ "type": "text"
+ }
+ ],
+ "index": 18
+ },
+ {
+ "bbox": [
+ 106,
+ 605,
+ 278,
+ 617
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 605,
+ 278,
+ 617
+ ],
+ "score": 1.0,
+ "content": "using the previously selected set of slopes.",
+ "type": "text"
+ }
+ ],
+ "index": 19
+ }
+ ],
+ "index": 17.5,
+ "bbox_fs": [
+ 105,
+ 570,
+ 505,
+ 617
+ ]
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 621,
+ 505,
+ 654
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 620,
+ 506,
+ 633
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 620,
+ 506,
+ 633
+ ],
+ "score": 1.0,
+ "content": "Specifically, we use the Toronto BooksCorpus (Zhu et al., 2015), which has been used to train",
+ "type": "text"
+ }
+ ],
+ "index": 20
+ },
+ {
+ "bbox": [
+ 105,
+ 631,
+ 506,
+ 644
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 631,
+ 506,
+ 644
+ ],
+ "score": 1.0,
+ "content": "BERT (Devlin et al., 2019) (in conjuction with the English Wikipedia). The corpus is about 700M",
+ "type": "text"
+ }
+ ],
+ "index": 21
+ },
+ {
+ "bbox": [
+ 106,
+ 643,
+ 176,
+ 654
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 643,
+ 176,
+ 654
+ ],
+ "score": 1.0,
+ "content": "tokens (2.9 GB).",
+ "type": "text"
+ }
+ ],
+ "index": 22
+ }
+ ],
+ "index": 21,
+ "bbox_fs": [
+ 105,
+ 620,
+ 506,
+ 654
+ ]
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 108,
+ 659,
+ 504,
+ 704
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 660,
+ 506,
+ 672
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 660,
+ 506,
+ 672
+ ],
+ "score": 1.0,
+ "content": "We use the same train/validation/test split as Khandelwal et al. (2020) and their tokenization, which",
+ "type": "text"
+ }
+ ],
+ "index": 23
+ },
+ {
+ "bbox": [
+ 105,
+ 670,
+ 506,
+ 684
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 670,
+ 506,
+ 684
+ ],
+ "score": 1.0,
+ "content": "uses BERT’s vocabulary of 29K byte-pair encodings. Since the vocabulary is much smaller than",
+ "type": "text"
+ }
+ ],
+ "index": 24
+ },
+ {
+ "bbox": [
+ 106,
+ 681,
+ 505,
+ 694
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 681,
+ 505,
+ 694
+ ],
+ "score": 1.0,
+ "content": "WikiText-103’s, we replace the adaptive word embedding and softmax of Baevski & Auli (2018)",
+ "type": "text"
+ }
+ ],
+ "index": 25
+ },
+ {
+ "bbox": [
+ 106,
+ 693,
+ 460,
+ 705
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 693,
+ 460,
+ 705
+ ],
+ "score": 1.0,
+ "content": "with a tied word embedding and softmax matrix (Press & Wolf, 2017; Inan et al., 2017).",
+ "type": "text"
+ }
+ ],
+ "index": 26
+ }
+ ],
+ "index": 24.5,
+ "bbox_fs": [
+ 105,
+ 660,
+ 506,
+ 705
+ ]
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 709,
+ 504,
+ 732
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 709,
+ 505,
+ 722
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 709,
+ 505,
+ 722
+ ],
+ "score": 1.0,
+ "content": "Our results in Figure 9 (and Table 8) replicate our success on the WikiText-103 dataset. Our model",
+ "type": "text"
+ }
+ ],
+ "index": 27
+ },
+ {
+ "bbox": [
+ 105,
+ 720,
+ 506,
+ 733
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 720,
+ 456,
+ 733
+ ],
+ "score": 1.0,
+ "content": "surpasses the sinusoidal baseline when trained on the same amount of input tokens",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 457,
+ 721,
+ 471,
+ 731
+ ],
+ "score": 0.5,
+ "content": "( L )",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 471,
+ 720,
+ 506,
+ 733
+ ],
+ "score": 1.0,
+ "content": "and, in",
+ "type": "text"
+ }
+ ],
+ "index": 28
+ },
+ {
+ "bbox": [
+ 106,
+ 298,
+ 505,
+ 309
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 298,
+ 505,
+ 309
+ ],
+ "score": 1.0,
+ "content": "addition, our model is able to extrapolate to longer sequences at inference. This occurs even though",
+ "type": "text",
+ "cross_page": true
+ }
+ ],
+ "index": 6
+ },
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "score": 1.0,
+ "content": "our set of slopes was not tuned on this dataset. This result establishes the generality of ALiBi and",
+ "type": "text",
+ "cross_page": true
+ }
+ ],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 106,
+ 320,
+ 505,
+ 332
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 320,
+ 505,
+ 332
+ ],
+ "score": 1.0,
+ "content": "the particular set of slopes we found and suggests that they may be used on different text domains",
+ "type": "text",
+ "cross_page": true
+ }
+ ],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 106,
+ 331,
+ 264,
+ 344
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 331,
+ 264,
+ 344
+ ],
+ "score": 1.0,
+ "content": "without further hyperparameter tuning.",
+ "type": "text",
+ "cross_page": true
+ }
+ ],
+ "index": 9
+ }
+ ],
+ "index": 27.5,
+ "bbox_fs": [
+ 105,
+ 709,
+ 506,
+ 733
+ ]
+ }
+ ]
+ },
+ {
+ "preproc_blocks": [
+ {
+ "type": "image",
+ "bbox": [
+ 157,
+ 82,
+ 453,
+ 226
+ ],
+ "blocks": [
+ {
+ "type": "image_body",
+ "bbox": [
+ 157,
+ 82,
+ 453,
+ 226
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 157,
+ 82,
+ 453,
+ 226
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 157,
+ 82,
+ 453,
+ 226
+ ],
+ "score": 0.972,
+ "type": "image",
+ "image_path": "5d2b57b38065977c1ee49f4412f8f13fc2f5d4c03b7b10ce48b0b3cb02da17e1.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 1,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 157,
+ 82,
+ 453,
+ 130.0
+ ],
+ "spans": [],
+ "index": 0
+ },
+ {
+ "bbox": [
+ 157,
+ 130.0,
+ 453,
+ 178.0
+ ],
+ "spans": [],
+ "index": 1
+ },
+ {
+ "bbox": [
+ 157,
+ 178.0,
+ 453,
+ 226.0
+ ],
+ "spans": [],
+ "index": 2
+ }
+ ]
+ },
+ {
+ "type": "image_caption",
+ "bbox": [
+ 106,
+ 242,
+ 505,
+ 276
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 241,
+ 505,
+ 255
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 241,
+ 505,
+ 255
+ ],
+ "score": 1.0,
+ "content": "Figure 9: ALiBi-enabled models evaluated on different input lengths on the Toronto BookCorpus.",
+ "type": "text"
+ }
+ ],
+ "index": 3
+ },
+ {
+ "bbox": [
+ 106,
+ 253,
+ 505,
+ 266
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 253,
+ 505,
+ 266
+ ],
+ "score": 1.0,
+ "content": "Our models extrapolate to longer sequence lengths and outperform the sinusoidal baseline even",
+ "type": "text"
+ }
+ ],
+ "index": 4
+ },
+ {
+ "bbox": [
+ 106,
+ 264,
+ 273,
+ 277
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 264,
+ 273,
+ 277
+ ],
+ "score": 1.0,
+ "content": "when trained on much shorter sequences.",
+ "type": "text"
+ }
+ ],
+ "index": 5
+ }
+ ],
+ "index": 4
+ }
+ ],
+ "index": 2.5
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 297,
+ 505,
+ 342
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 298,
+ 505,
+ 309
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 298,
+ 505,
+ 309
+ ],
+ "score": 1.0,
+ "content": "addition, our model is able to extrapolate to longer sequences at inference. This occurs even though",
+ "type": "text"
+ }
+ ],
+ "index": 6
+ },
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "score": 1.0,
+ "content": "our set of slopes was not tuned on this dataset. This result establishes the generality of ALiBi and",
+ "type": "text"
+ }
+ ],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 106,
+ 320,
+ 505,
+ 332
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 320,
+ 505,
+ 332
+ ],
+ "score": 1.0,
+ "content": "the particular set of slopes we found and suggests that they may be used on different text domains",
+ "type": "text"
+ }
+ ],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 106,
+ 331,
+ 264,
+ 344
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 331,
+ 264,
+ 344
+ ],
+ "score": 1.0,
+ "content": "without further hyperparameter tuning.",
+ "type": "text"
+ }
+ ],
+ "index": 9
+ }
+ ],
+ "index": 7.5
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 347,
+ 505,
+ 381
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 348,
+ 505,
+ 360
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 348,
+ 505,
+ 360
+ ],
+ "score": 1.0,
+ "content": "Tables 9 and 10 present the perplexities for our ALiBi models, the baselines, and the current state",
+ "type": "text"
+ }
+ ],
+ "index": 10
+ },
+ {
+ "bbox": [
+ 106,
+ 360,
+ 505,
+ 370
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 360,
+ 505,
+ 370
+ ],
+ "score": 1.0,
+ "content": "of the art on the Toronto BookCorpus validation and test sets. Our results here mirror our results on",
+ "type": "text"
+ }
+ ],
+ "index": 11
+ },
+ {
+ "bbox": [
+ 106,
+ 369,
+ 505,
+ 382
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 369,
+ 505,
+ 382
+ ],
+ "score": 1.0,
+ "content": "WikiText-103: we improve over the sinusoidal baseline even when AliBi is trained on fewer tokens.",
+ "type": "text"
+ }
+ ],
+ "index": 12
+ }
+ ],
+ "index": 11
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 106,
+ 391,
+ 506,
+ 425
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 392,
+ 505,
+ 403
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 392,
+ 505,
+ 403
+ ],
+ "score": 1.0,
+ "content": "Table 8: ALiBi models extrapolating on the Toronto BookCorpus development set. ∗For the results",
+ "type": "text"
+ }
+ ],
+ "index": 13
+ },
+ {
+ "bbox": [
+ 105,
+ 401,
+ 506,
+ 416
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 401,
+ 212,
+ 416
+ ],
+ "score": 1.0,
+ "content": "of the sinusoidal models,",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 212,
+ 403,
+ 254,
+ 414
+ ],
+ "score": 0.92,
+ "content": "L = L _ { \\nu a l i d }",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 254,
+ 401,
+ 506,
+ 416
+ ],
+ "score": 1.0,
+ "content": "(so we do not test the extrapolation abilities of those models",
+ "type": "text"
+ }
+ ],
+ "index": 14
+ },
+ {
+ "bbox": [
+ 104,
+ 412,
+ 133,
+ 427
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 104,
+ 412,
+ 133,
+ 427
+ ],
+ "score": 1.0,
+ "content": "here).",
+ "type": "text"
+ }
+ ],
+ "index": 15
+ }
+ ],
+ "index": 14
+ },
+ {
+ "type": "table",
+ "bbox": [
+ 226,
+ 439,
+ 384,
+ 526
+ ],
+ "blocks": [
+ {
+ "type": "table_body",
+ "bbox": [
+ 226,
+ 439,
+ 384,
+ 526
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 226,
+ 439,
+ 384,
+ 526
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 226,
+ 439,
+ 384,
+ 526
+ ],
+ "score": 0.974,
+ "html": "| // Simulated Annealing from simanneal import Annealer def barrier_SA(arch，model，sd1，sd2，w2，init_state，tmax，tmin，steps，train_inputs, |
| def | train_targets，train_avg_org_models，nchannels，nclasses，nunits): |
| class BarrierCalculationProblem(Annealer): """anealer with a travelling salesman problem. 11 11 11 |
| __init__(self，state): super(BarrierCalculationProblem，self).__init__(state）# important! |
|
|
| def move(self): |
| """Swaps two cities in the route.""" |
|
|
| initial_energy = self.energy() |
| for j in range(5): |
| fori in range(len(self.state[j])): X = self.state[j][i] a = random.randint(O，len(x)- 1) |
| b = random.randint(o，len(x)- 1) | |
| self.state[j][i][a]，self.state[j][i][b]=self.state[j][i][b], |
| |
| self.state[j][i][a] | |
| return self.energy()- initial_energy | |
| def energy(self): | |
| """Calculates the cost for proposed permutation."" | |
| permuted_models = [] | |
| for i in range(5): | |
| permuted_models.append(permute(arch，model，self.state[i]，sd2[i]，w2[i], | |
| nchannels，nclasses,nunits)) | |
| #### form one model which is the average of 5 permuted models | |
| permuted_avg = copy.deepcopy(model) | |
| new_params = OrderedDict() | |
| for key in sd2[O].keys(): | |
| param = 0 | |
| |
| fori in range(len(permuted_models)): | |
| param = param + permuted_models[i][key] | |
| new_params[key]= param /len(permuted_models) | |
| |
| permuted_avg.load_state_dict(new_params) | |
| eval_train = evaluate_model(permuted_avg，train_inputs，train_targets)['top1' | |
| |
| cost = 1 - eval_train | |
| |
| |
| return cost | |
+
+# B IMPROVE SEARCH ALGORITHM
+
+In the main text we use simulated annealing (SA) to find the winning permutation $\pi$ . Figure 6 shows that SA is only able to reduce the barrier, and reducing search space $\left( \mathrm { n } = 2 \right)$ ) helps in finding better permutations. However, a critical question still remains: Is there an algorithm that finds better permutations?
+
+He et al. (2018) proposed an algorithms that merges correlated, pre-trained deep neural networks for cross-model compression. Their objective is to zip two neural networks, optimized for two different tasks, into one network. The ultimate network does both tasks without losing too much accuracy on each task. Their algorithm is based on layer-wise neuron sharing, which uses f(weights, post activations) to find which neurons could be zipped together. They define the similarity (or equivalently difference) of two neurons as below (Eq. 12 in the original paper):
+
+$$
+\delta _ { n _ { A } , n _ { B } } = \frac { 1 } { 2 } ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } ) . ( ( H _ { l , i } ^ { A } ) ^ { - 1 } + ( H _ { l , i } ^ { B } ) ^ { - 1 } ) ^ { - 1 } . ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } )
+$$
+
+We also used their "functional difference" as a measure for neuron matching between two randomly initialized trained networks. They used post activation as an approximation for Hessian matrices. Calculating the difference between each pair of neurons based on Equation 2, gives an $m \times m$ matrix (m is width of the network). In the second step, neurons with minimum distance are matched together in a greedy way i.e., if $n _ { i , A }$ and $n _ { j , B }$ have the minimum distance, row $i$ and column $j$ is removed from the distance matrix. Figure 15 shows that using functional difference, the barrier could be improved.
+
+
+Figure 15: Performance of Functional Difference compared to Simulated Annealing. Functional Difference could indeed find better permutations, improving the barrier size between two solutions.
+
+# C MAKING ENSEMBLES
+
+As stated before, our conjecture has implications for ensemble methods. If two solutions lie at the periphery of a wide and flat low loss region (a basin where models are linearly connected to each other), then ensembling them in their weight space (averaging), creates a model tending to the center of the region, which leads to performance improvement. However, Simulated Annealing could not find the optimal permutations for all cases. Section B shows that using matching algorithms like functional difference could help to find better permutations. Motivated to create ensembles, Wortsman et al. (2021) start with two (or more) random initializations and learn a subspace (a line or simplex) connecting them. Throughout training they sample one (or more) points on this line and add the loss at this point to the loss of training. In order to enforce diversity in function space, they also add a regularization term as cosine similarity of two endpoints of the line. However as they enforce two models to be in a line, the functional diversity of the final ensemble is limited compare to our methods. Here we combine their method with functional difference to make best of both worlds.
+
+In this experiment, we train two randomly initialized networks separately, and then use functional difference to decrease the barrier between final solutions. Then we use learning subspace method to make them in one basin. Our results on MLP with one hidden layer and width of 1024 neurons on MNIST and CIFAR10 shows that this method outperforms the others.
+
+| // Simulated Annealing from simanneal import Annealer def barrier_SA(arch，model，sd1，sd2，w2，init_state，tmax，tmin，steps，train_inputs, |
| def | train_targets，train_avg_org_models，nchannels，nclasses，nunits): |
| class BarrierCalculationProblem(Annealer): """anealer with a travelling salesman problem. 11 11 11 |
| __init__(self，state): super(BarrierCalculationProblem，self).__init__(state）# important! |
|
|
| def move(self): |
| """Swaps two cities in the route.""" |
|
|
| initial_energy = self.energy() |
| for j in range(5): |
| fori in range(len(self.state[j])): X = self.state[j][i] a = random.randint(O，len(x)- 1) |
| b = random.randint(o，len(x)- 1) | |
| self.state[j][i][a]，self.state[j][i][b]=self.state[j][i][b], |
| |
| self.state[j][i][a] | |
| return self.energy()- initial_energy | |
| def energy(self): | |
| """Calculates the cost for proposed permutation."" | |
| permuted_models = [] | |
| for i in range(5): | |
| permuted_models.append(permute(arch，model，self.state[i]，sd2[i]，w2[i], | |
| nchannels，nclasses,nunits)) | |
| #### form one model which is the average of 5 permuted models | |
| permuted_avg = copy.deepcopy(model) | |
| new_params = OrderedDict() | |
| for key in sd2[O].keys(): | |
| param = 0 | |
| |
| fori in range(len(permuted_models)): | |
| param = param + permuted_models[i][key] | |
| new_params[key]= param /len(permuted_models) | |
| |
| permuted_avg.load_state_dict(new_params) | |
| eval_train = evaluate_model(permuted_avg，train_inputs，train_targets)['top1' | |
| |
| cost = 1 - eval_train | |
| |
| |
| return cost | |
",
+ "bbox": [
+ 173,
+ 338,
+ 805,
+ 852
+ ],
+ "page_idx": 16
+ },
+ {
+ "type": "text",
+ "text": "B IMPROVE SEARCH ALGORITHM ",
+ "text_level": 1,
+ "bbox": [
+ 176,
+ 102,
+ 470,
+ 118
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "In the main text we use simulated annealing (SA) to find the winning permutation $\\pi$ . Figure 6 shows that SA is only able to reduce the barrier, and reducing search space $\\left( \\mathrm { n } = 2 \\right)$ ) helps in finding better permutations. However, a critical question still remains: Is there an algorithm that finds better permutations? ",
+ "bbox": [
+ 174,
+ 133,
+ 825,
+ 189
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "He et al. (2018) proposed an algorithms that merges correlated, pre-trained deep neural networks for cross-model compression. Their objective is to zip two neural networks, optimized for two different tasks, into one network. The ultimate network does both tasks without losing too much accuracy on each task. Their algorithm is based on layer-wise neuron sharing, which uses f(weights, post activations) to find which neurons could be zipped together. They define the similarity (or equivalently difference) of two neurons as below (Eq. 12 in the original paper): ",
+ "bbox": [
+ 174,
+ 195,
+ 825,
+ 280
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "equation",
+ "img_path": "images/af652a4f6754b7b4b21a5168a360b40113fbc2d5eca6936206b034f70cf8c8a3.jpg",
+ "text": "$$\n\\delta _ { n _ { A } , n _ { B } } = \\frac { 1 } { 2 } ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } ) . ( ( H _ { l , i } ^ { A } ) ^ { - 1 } + ( H _ { l , i } ^ { B } ) ^ { - 1 } ) ^ { - 1 } . ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } )\n$$",
+ "text_format": "latex",
+ "bbox": [
+ 287,
+ 304,
+ 712,
+ 334
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "We also used their \"functional difference\" as a measure for neuron matching between two randomly initialized trained networks. They used post activation as an approximation for Hessian matrices. Calculating the difference between each pair of neurons based on Equation 2, gives an $m \\times m$ matrix (m is width of the network). In the second step, neurons with minimum distance are matched together in a greedy way i.e., if $n _ { i , A }$ and $n _ { j , B }$ have the minimum distance, row $i$ and column $j$ is removed from the distance matrix. Figure 15 shows that using functional difference, the barrier could be improved. ",
+ "bbox": [
+ 173,
+ 345,
+ 826,
+ 444
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "image",
+ "img_path": "images/f94f98c5a4042b025956dbf1cfd7f75bc63cf72eb70d49433a556e5ff578b706.jpg",
+ "image_caption": [
+ "Figure 15: Performance of Functional Difference compared to Simulated Annealing. Functional Difference could indeed find better permutations, improving the barrier size between two solutions. "
+ ],
+ "image_footnote": [],
+ "bbox": [
+ 334,
+ 462,
+ 660,
+ 656
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "C MAKING ENSEMBLES ",
+ "text_level": 1,
+ "bbox": [
+ 176,
+ 726,
+ 390,
+ 741
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "As stated before, our conjecture has implications for ensemble methods. If two solutions lie at the periphery of a wide and flat low loss region (a basin where models are linearly connected to each other), then ensembling them in their weight space (averaging), creates a model tending to the center of the region, which leads to performance improvement. However, Simulated Annealing could not find the optimal permutations for all cases. Section B shows that using matching algorithms like functional difference could help to find better permutations. Motivated to create ensembles, Wortsman et al. (2021) start with two (or more) random initializations and learn a subspace (a line or simplex) connecting them. Throughout training they sample one (or more) points on this line and add the loss at this point to the loss of training. In order to enforce diversity in function space, they also add a regularization term as cosine similarity of two endpoints of the line. However as they enforce two models to be in a line, the functional diversity of the final ensemble is limited compare to our methods. Here we combine their method with functional difference to make best of both worlds. ",
+ "bbox": [
+ 173,
+ 757,
+ 825,
+ 924
+ ],
+ "page_idx": 17
+ },
+ {
+ "type": "text",
+ "text": "In this experiment, we train two randomly initialized networks separately, and then use functional difference to decrease the barrier between final solutions. Then we use learning subspace method to make them in one basin. Our results on MLP with one hidden layer and width of 1024 neurons on MNIST and CIFAR10 shows that this method outperforms the others. ",
+ "bbox": [
+ 174,
+ 103,
+ 825,
+ 160
+ ],
+ "page_idx": 18
+ },
+ {
+ "type": "table",
+ "img_path": "images/7ef6bc7132ce7ff695a50e342f0ada048b39aa89f342c2aca4f383144fc7261f.jpg",
+ "table_caption": [],
+ "table_footnote": [
+ "1 Functional Difference (He et al., 2018) 2 Subspace Learning (Wortsman et al., 2021) "
+ ],
+ "table_body": "| // Simulated Annealing from simanneal import Annealer def barrier_SA(arch，model，sd1，sd2，w2，init_state，tmax，tmin，steps，train_inputs, |
| def | train_targets，train_avg_org_models，nchannels，nclasses，nunits): |
| class BarrierCalculationProblem(Annealer): """anealer with a travelling salesman problem. 11 11 11 |
| __init__(self，state): super(BarrierCalculationProblem，self).__init__(state）# important! |
|
|
| def move(self): |
| """Swaps two cities in the route.""" |
|
|
| initial_energy = self.energy() |
| for j in range(5): |
| fori in range(len(self.state[j])): X = self.state[j][i] a = random.randint(O，len(x)- 1) |
| b = random.randint(o，len(x)- 1) | |
| self.state[j][i][a]，self.state[j][i][b]=self.state[j][i][b], |
| |
| self.state[j][i][a] | |
| return self.energy()- initial_energy | |
| def energy(self): | |
| """Calculates the cost for proposed permutation."" | |
| permuted_models = [] | |
| for i in range(5): | |
| permuted_models.append(permute(arch，model，self.state[i]，sd2[i]，w2[i], | |
| nchannels，nclasses,nunits)) | |
| #### form one model which is the average of 5 permuted models | |
| permuted_avg = copy.deepcopy(model) | |
| new_params = OrderedDict() | |
| for key in sd2[O].keys(): | |
| param = 0 | |
| |
| fori in range(len(permuted_models)): | |
| param = param + permuted_models[i][key] | |
| new_params[key]= param /len(permuted_models) | |
| |
| permuted_avg.load_state_dict(new_params) | |
| eval_train = evaluate_model(permuted_avg，train_inputs，train_targets)['top1' | |
| |
| cost = 1 - eval_train | |
| |
| |
| return cost | |
",
+ "type": "table",
+ "image_path": "2c612175ecfa4139f29851c43f4142126d89cb1a91f59a54a1bd5b18924754d2.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 8,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 106,
+ 268,
+ 493,
+ 403.66666666666663
+ ],
+ "spans": [],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 106,
+ 403.66666666666663,
+ 493,
+ 539.3333333333333
+ ],
+ "spans": [],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 106,
+ 539.3333333333333,
+ 493,
+ 674.9999999999999
+ ],
+ "spans": [],
+ "index": 9
+ }
+ ]
+ }
+ ],
+ "index": 8
+ }
+ ],
+ "page_idx": 16,
+ "page_size": [
+ 612,
+ 792
+ ],
+ "discarded_blocks": [
+ {
+ "type": "discarded",
+ "bbox": [
+ 108,
+ 27,
+ 293,
+ 37
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 26,
+ 294,
+ 38
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 26,
+ 294,
+ 38
+ ],
+ "score": 1.0,
+ "content": "Published as a conference paper at ICLR 2022",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "type": "discarded",
+ "bbox": [
+ 300,
+ 751,
+ 310,
+ 760
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 299,
+ 750,
+ 312,
+ 764
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 299,
+ 750,
+ 312,
+ 764
+ ],
+ "score": 1.0,
+ "content": "",
+ "type": "text",
+ "height": 14,
+ "width": 13
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "type": "discarded",
+ "bbox": [
+ 121,
+ 667,
+ 434,
+ 719
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 121,
+ 676,
+ 433,
+ 687
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 121,
+ 676,
+ 160,
+ 687
+ ],
+ "score": 1.0,
+ "content": "bcp_auto",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 160,
+ 678,
+ 168,
+ 685
+ ],
+ "score": 0.41,
+ "content": "=",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 169,
+ 676,
+ 433,
+ 687
+ ],
+ "score": 1.0,
+ "content": "{'tmax': tmax, 'tmin': tmin, 'steps': steps, 'updates': 100}",
+ "type": "text"
+ }
+ ]
+ },
+ {
+ "bbox": [
+ 122,
+ 687,
+ 236,
+ 697
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 122,
+ 687,
+ 236,
+ 697
+ ],
+ "score": 1.0,
+ "content": "bcp.set_schedule(bcp_auto)",
+ "type": "text"
+ }
+ ]
+ },
+ {
+ "bbox": [
+ 122,
+ 696,
+ 258,
+ 707
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 122,
+ 696,
+ 187,
+ 707
+ ],
+ "score": 1.0,
+ "content": "winning_state,",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 188,
+ 698,
+ 203,
+ 705
+ ],
+ "score": 0.32,
+ "content": "\\texttt { \\small e } =",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 204,
+ 696,
+ 258,
+ 707
+ ],
+ "score": 1.0,
+ "content": "bcp.anneal()",
+ "type": "text"
+ }
+ ]
+ },
+ {
+ "bbox": [
+ 122,
+ 707,
+ 212,
+ 717
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 122,
+ 707,
+ 212,
+ 717
+ ],
+ "score": 1.0,
+ "content": "return winning_state",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "para_blocks": [
+ {
+ "type": "table",
+ "bbox": [
+ 124,
+ 80,
+ 487,
+ 175
+ ],
+ "blocks": [
+ {
+ "type": "table_body",
+ "bbox": [
+ 124,
+ 80,
+ 487,
+ 175
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 124,
+ 80,
+ 487,
+ 175
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 124,
+ 80,
+ 487,
+ 175
+ ],
+ "score": 0.981,
+ "html": "| // Simulated Annealing from simanneal import Annealer def barrier_SA(arch，model，sd1，sd2，w2，init_state，tmax，tmin，steps，train_inputs, |
| def | train_targets，train_avg_org_models，nchannels，nclasses，nunits): |
| class BarrierCalculationProblem(Annealer): """anealer with a travelling salesman problem. 11 11 11 |
| __init__(self，state): super(BarrierCalculationProblem，self).__init__(state）# important! |
|
|
| def move(self): |
| """Swaps two cities in the route.""" |
|
|
| initial_energy = self.energy() |
| for j in range(5): |
| fori in range(len(self.state[j])): X = self.state[j][i] a = random.randint(O，len(x)- 1) |
| b = random.randint(o，len(x)- 1) | |
| self.state[j][i][a]，self.state[j][i][b]=self.state[j][i][b], |
| |
| self.state[j][i][a] | |
| return self.energy()- initial_energy | |
| def energy(self): | |
| """Calculates the cost for proposed permutation."" | |
| permuted_models = [] | |
| for i in range(5): | |
| permuted_models.append(permute(arch，model，self.state[i]，sd2[i]，w2[i], | |
| nchannels，nclasses,nunits)) | |
| #### form one model which is the average of 5 permuted models | |
| permuted_avg = copy.deepcopy(model) | |
| new_params = OrderedDict() | |
| for key in sd2[O].keys(): | |
| param = 0 | |
| |
| fori in range(len(permuted_models)): | |
| param = param + permuted_models[i][key] | |
| new_params[key]= param /len(permuted_models) | |
| |
| permuted_avg.load_state_dict(new_params) | |
| eval_train = evaluate_model(permuted_avg，train_inputs，train_targets)['top1' | |
| |
| cost = 1 - eval_train | |
| |
| |
| return cost | |
",
+ "type": "table",
+ "image_path": "2c612175ecfa4139f29851c43f4142126d89cb1a91f59a54a1bd5b18924754d2.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 8,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 106,
+ 268,
+ 493,
+ 403.66666666666663
+ ],
+ "spans": [],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 106,
+ 403.66666666666663,
+ 493,
+ 539.3333333333333
+ ],
+ "spans": [],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 106,
+ 539.3333333333333,
+ 493,
+ 674.9999999999999
+ ],
+ "spans": [],
+ "index": 9
+ }
+ ]
+ }
+ ],
+ "index": 8
+ }
+ ]
+ },
+ {
+ "preproc_blocks": [
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 81,
+ 288,
+ 94
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 80,
+ 290,
+ 95
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 80,
+ 290,
+ 95
+ ],
+ "score": 1.0,
+ "content": "B IMPROVE SEARCH ALGORITHM",
+ "type": "text"
+ }
+ ],
+ "index": 0
+ }
+ ],
+ "index": 0
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 106,
+ 505,
+ 150
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 106,
+ 506,
+ 118
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 106,
+ 453,
+ 118
+ ],
+ "score": 1.0,
+ "content": "In the main text we use simulated annealing (SA) to find the winning permutation",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 453,
+ 108,
+ 460,
+ 116
+ ],
+ "score": 0.7,
+ "content": "\\pi",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 461,
+ 106,
+ 506,
+ 118
+ ],
+ "score": 1.0,
+ "content": ". Figure 6",
+ "type": "text"
+ }
+ ],
+ "index": 1
+ },
+ {
+ "bbox": [
+ 105,
+ 115,
+ 505,
+ 130
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 115,
+ 411,
+ 130
+ ],
+ "score": 1.0,
+ "content": "shows that SA is only able to reduce the barrier, and reducing search space",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 411,
+ 118,
+ 437,
+ 128
+ ],
+ "score": 0.83,
+ "content": "\\left( \\mathrm { n } = 2 \\right)",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 437,
+ 115,
+ 505,
+ 130
+ ],
+ "score": 1.0,
+ "content": ") helps in finding",
+ "type": "text"
+ }
+ ],
+ "index": 2
+ },
+ {
+ "bbox": [
+ 105,
+ 128,
+ 505,
+ 140
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 128,
+ 505,
+ 140
+ ],
+ "score": 1.0,
+ "content": "better permutations. However, a critical question still remains: Is there an algorithm that finds better",
+ "type": "text"
+ }
+ ],
+ "index": 3
+ },
+ {
+ "bbox": [
+ 105,
+ 140,
+ 165,
+ 150
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 140,
+ 165,
+ 150
+ ],
+ "score": 1.0,
+ "content": "permutations?",
+ "type": "text"
+ }
+ ],
+ "index": 4
+ }
+ ],
+ "index": 2.5
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 155,
+ 505,
+ 222
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 156,
+ 505,
+ 168
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 156,
+ 505,
+ 168
+ ],
+ "score": 1.0,
+ "content": "He et al. (2018) proposed an algorithms that merges correlated, pre-trained deep neural networks for",
+ "type": "text"
+ }
+ ],
+ "index": 5
+ },
+ {
+ "bbox": [
+ 105,
+ 167,
+ 505,
+ 179
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 167,
+ 505,
+ 179
+ ],
+ "score": 1.0,
+ "content": "cross-model compression. Their objective is to zip two neural networks, optimized for two different",
+ "type": "text"
+ }
+ ],
+ "index": 6
+ },
+ {
+ "bbox": [
+ 105,
+ 177,
+ 506,
+ 191
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 177,
+ 506,
+ 191
+ ],
+ "score": 1.0,
+ "content": "tasks, into one network. The ultimate network does both tasks without losing too much accuracy",
+ "type": "text"
+ }
+ ],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 106,
+ 189,
+ 505,
+ 201
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 189,
+ 505,
+ 201
+ ],
+ "score": 1.0,
+ "content": "on each task. Their algorithm is based on layer-wise neuron sharing, which uses f(weights, post",
+ "type": "text"
+ }
+ ],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 105,
+ 199,
+ 505,
+ 212
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 199,
+ 505,
+ 212
+ ],
+ "score": 1.0,
+ "content": "activations) to find which neurons could be zipped together. They define the similarity (or equivalently",
+ "type": "text"
+ }
+ ],
+ "index": 9
+ },
+ {
+ "bbox": [
+ 106,
+ 210,
+ 373,
+ 223
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 210,
+ 373,
+ 223
+ ],
+ "score": 1.0,
+ "content": "difference) of two neurons as below (Eq. 12 in the original paper):",
+ "type": "text"
+ }
+ ],
+ "index": 10
+ }
+ ],
+ "index": 7.5
+ },
+ {
+ "type": "interline_equation",
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "score": 0.92,
+ "content": "\\delta _ { n _ { A } , n _ { B } } = \\frac { 1 } { 2 } ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } ) . ( ( H _ { l , i } ^ { A } ) ^ { - 1 } + ( H _ { l , i } ^ { B } ) ^ { - 1 } ) ^ { - 1 } . ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } )",
+ "type": "interline_equation",
+ "image_path": "af652a4f6754b7b4b21a5168a360b40113fbc2d5eca6936206b034f70cf8c8a3.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 11,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "spans": [],
+ "index": 11
+ }
+ ]
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 106,
+ 274,
+ 506,
+ 352
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 275,
+ 505,
+ 288
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 275,
+ 505,
+ 288
+ ],
+ "score": 1.0,
+ "content": "We also used their \"functional difference\" as a measure for neuron matching between two randomly",
+ "type": "text"
+ }
+ ],
+ "index": 12
+ },
+ {
+ "bbox": [
+ 106,
+ 287,
+ 506,
+ 298
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 287,
+ 506,
+ 298
+ ],
+ "score": 1.0,
+ "content": "initialized trained networks. They used post activation as an approximation for Hessian matrices.",
+ "type": "text"
+ }
+ ],
+ "index": 13
+ },
+ {
+ "bbox": [
+ 106,
+ 298,
+ 505,
+ 309
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 298,
+ 445,
+ 309
+ ],
+ "score": 1.0,
+ "content": "Calculating the difference between each pair of neurons based on Equation 2, gives an",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 446,
+ 298,
+ 476,
+ 308
+ ],
+ "score": 0.89,
+ "content": "m \\times m",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 477,
+ 298,
+ 505,
+ 309
+ ],
+ "score": 1.0,
+ "content": "matrix",
+ "type": "text"
+ }
+ ],
+ "index": 14
+ },
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "score": 1.0,
+ "content": "(m is width of the network). In the second step, neurons with minimum distance are matched together",
+ "type": "text"
+ }
+ ],
+ "index": 15
+ },
+ {
+ "bbox": [
+ 105,
+ 318,
+ 505,
+ 331
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 318,
+ 200,
+ 331
+ ],
+ "score": 1.0,
+ "content": "in a greedy way i.e., if",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 200,
+ 320,
+ 219,
+ 331
+ ],
+ "score": 0.9,
+ "content": "n _ { i , A }",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 219,
+ 318,
+ 237,
+ 331
+ ],
+ "score": 1.0,
+ "content": "and",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 238,
+ 320,
+ 257,
+ 331
+ ],
+ "score": 0.89,
+ "content": "n _ { j , B }",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 258,
+ 318,
+ 394,
+ 331
+ ],
+ "score": 1.0,
+ "content": "have the minimum distance, row",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 394,
+ 320,
+ 399,
+ 329
+ ],
+ "score": 0.69,
+ "content": "i",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 399,
+ 318,
+ 450,
+ 331
+ ],
+ "score": 1.0,
+ "content": "and column",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 451,
+ 320,
+ 457,
+ 330
+ ],
+ "score": 0.82,
+ "content": "j",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 457,
+ 318,
+ 505,
+ 331
+ ],
+ "score": 1.0,
+ "content": "is removed",
+ "type": "text"
+ }
+ ],
+ "index": 16
+ },
+ {
+ "bbox": [
+ 105,
+ 329,
+ 506,
+ 342
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 329,
+ 506,
+ 342
+ ],
+ "score": 1.0,
+ "content": "from the distance matrix. Figure 15 shows that using functional difference, the barrier could be",
+ "type": "text"
+ }
+ ],
+ "index": 17
+ },
+ {
+ "bbox": [
+ 105,
+ 341,
+ 150,
+ 354
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 341,
+ 150,
+ 354
+ ],
+ "score": 1.0,
+ "content": "improved.",
+ "type": "text"
+ }
+ ],
+ "index": 18
+ }
+ ],
+ "index": 15
+ },
+ {
+ "type": "image",
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "blocks": [
+ {
+ "type": "image_body",
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "score": 0.973,
+ "type": "image",
+ "image_path": "f94f98c5a4042b025956dbf1cfd7f75bc63cf72eb70d49433a556e5ff578b706.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 24.5,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 378.8333333333333
+ ],
+ "spans": [],
+ "index": 19
+ },
+ {
+ "bbox": [
+ 205,
+ 378.8333333333333,
+ 404,
+ 391.66666666666663
+ ],
+ "spans": [],
+ "index": 20
+ },
+ {
+ "bbox": [
+ 205,
+ 391.66666666666663,
+ 404,
+ 404.49999999999994
+ ],
+ "spans": [],
+ "index": 21
+ },
+ {
+ "bbox": [
+ 205,
+ 404.49999999999994,
+ 404,
+ 417.33333333333326
+ ],
+ "spans": [],
+ "index": 22
+ },
+ {
+ "bbox": [
+ 205,
+ 417.33333333333326,
+ 404,
+ 430.1666666666666
+ ],
+ "spans": [],
+ "index": 23
+ },
+ {
+ "bbox": [
+ 205,
+ 430.1666666666666,
+ 404,
+ 442.9999999999999
+ ],
+ "spans": [],
+ "index": 24
+ },
+ {
+ "bbox": [
+ 205,
+ 442.9999999999999,
+ 404,
+ 455.8333333333332
+ ],
+ "spans": [],
+ "index": 25
+ },
+ {
+ "bbox": [
+ 205,
+ 455.8333333333332,
+ 404,
+ 468.6666666666665
+ ],
+ "spans": [],
+ "index": 26
+ },
+ {
+ "bbox": [
+ 205,
+ 468.6666666666665,
+ 404,
+ 481.49999999999983
+ ],
+ "spans": [],
+ "index": 27
+ },
+ {
+ "bbox": [
+ 205,
+ 481.49999999999983,
+ 404,
+ 494.33333333333314
+ ],
+ "spans": [],
+ "index": 28
+ },
+ {
+ "bbox": [
+ 205,
+ 494.33333333333314,
+ 404,
+ 507.16666666666646
+ ],
+ "spans": [],
+ "index": 29
+ },
+ {
+ "bbox": [
+ 205,
+ 507.16666666666646,
+ 404,
+ 519.9999999999998
+ ],
+ "spans": [],
+ "index": 30
+ }
+ ]
+ },
+ {
+ "type": "image_caption",
+ "bbox": [
+ 105,
+ 532,
+ 504,
+ 554
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 531,
+ 505,
+ 543
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 531,
+ 505,
+ 543
+ ],
+ "score": 1.0,
+ "content": "Figure 15: Performance of Functional Difference compared to Simulated Annealing. Functional Differ-",
+ "type": "text"
+ }
+ ],
+ "index": 31
+ },
+ {
+ "bbox": [
+ 106,
+ 542,
+ 443,
+ 554
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 542,
+ 443,
+ 554
+ ],
+ "score": 1.0,
+ "content": "ence could indeed find better permutations, improving the barrier size between two solutions.",
+ "type": "text"
+ }
+ ],
+ "index": 32
+ }
+ ],
+ "index": 31.5
+ }
+ ],
+ "index": 28.0
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 575,
+ 239,
+ 587
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 573,
+ 240,
+ 590
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 573,
+ 240,
+ 590
+ ],
+ "score": 1.0,
+ "content": "C MAKING ENSEMBLES",
+ "type": "text"
+ }
+ ],
+ "index": 33
+ }
+ ],
+ "index": 33
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 106,
+ 600,
+ 505,
+ 732
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 600,
+ 505,
+ 612
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 600,
+ 505,
+ 612
+ ],
+ "score": 1.0,
+ "content": "As stated before, our conjecture has implications for ensemble methods. If two solutions lie at the",
+ "type": "text"
+ }
+ ],
+ "index": 34
+ },
+ {
+ "bbox": [
+ 105,
+ 612,
+ 505,
+ 623
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 612,
+ 505,
+ 623
+ ],
+ "score": 1.0,
+ "content": "periphery of a wide and flat low loss region (a basin where models are linearly connected to each",
+ "type": "text"
+ }
+ ],
+ "index": 35
+ },
+ {
+ "bbox": [
+ 105,
+ 622,
+ 506,
+ 635
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 622,
+ 506,
+ 635
+ ],
+ "score": 1.0,
+ "content": "other), then ensembling them in their weight space (averaging), creates a model tending to the center",
+ "type": "text"
+ }
+ ],
+ "index": 36
+ },
+ {
+ "bbox": [
+ 105,
+ 632,
+ 505,
+ 646
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 632,
+ 505,
+ 646
+ ],
+ "score": 1.0,
+ "content": "of the region, which leads to performance improvement. However, Simulated Annealing could not",
+ "type": "text"
+ }
+ ],
+ "index": 37
+ },
+ {
+ "bbox": [
+ 106,
+ 643,
+ 505,
+ 656
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 643,
+ 505,
+ 656
+ ],
+ "score": 1.0,
+ "content": "find the optimal permutations for all cases. Section B shows that using matching algorithms like",
+ "type": "text"
+ }
+ ],
+ "index": 38
+ },
+ {
+ "bbox": [
+ 105,
+ 655,
+ 506,
+ 667
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 655,
+ 506,
+ 667
+ ],
+ "score": 1.0,
+ "content": "functional difference could help to find better permutations. Motivated to create ensembles, Wortsman",
+ "type": "text"
+ }
+ ],
+ "index": 39
+ },
+ {
+ "bbox": [
+ 106,
+ 666,
+ 505,
+ 678
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 666,
+ 505,
+ 678
+ ],
+ "score": 1.0,
+ "content": "et al. (2021) start with two (or more) random initializations and learn a subspace (a line or simplex)",
+ "type": "text"
+ }
+ ],
+ "index": 40
+ },
+ {
+ "bbox": [
+ 105,
+ 677,
+ 506,
+ 689
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 677,
+ 506,
+ 689
+ ],
+ "score": 1.0,
+ "content": "connecting them. Throughout training they sample one (or more) points on this line and add the",
+ "type": "text"
+ }
+ ],
+ "index": 41
+ },
+ {
+ "bbox": [
+ 106,
+ 688,
+ 505,
+ 700
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 688,
+ 505,
+ 700
+ ],
+ "score": 1.0,
+ "content": "loss at this point to the loss of training. In order to enforce diversity in function space, they also",
+ "type": "text"
+ }
+ ],
+ "index": 42
+ },
+ {
+ "bbox": [
+ 106,
+ 699,
+ 505,
+ 711
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 699,
+ 505,
+ 711
+ ],
+ "score": 1.0,
+ "content": "add a regularization term as cosine similarity of two endpoints of the line. However as they enforce",
+ "type": "text"
+ }
+ ],
+ "index": 43
+ },
+ {
+ "bbox": [
+ 105,
+ 709,
+ 506,
+ 722
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 709,
+ 506,
+ 722
+ ],
+ "score": 1.0,
+ "content": "two models to be in a line, the functional diversity of the final ensemble is limited compare to our",
+ "type": "text"
+ }
+ ],
+ "index": 44
+ },
+ {
+ "bbox": [
+ 106,
+ 721,
+ 506,
+ 731
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 721,
+ 506,
+ 731
+ ],
+ "score": 1.0,
+ "content": "methods. Here we combine their method with functional difference to make best of both worlds.",
+ "type": "text"
+ }
+ ],
+ "index": 45
+ }
+ ],
+ "index": 39.5
+ }
+ ],
+ "page_idx": 17,
+ "page_size": [
+ 612,
+ 792
+ ],
+ "discarded_blocks": [
+ {
+ "type": "discarded",
+ "bbox": [
+ 107,
+ 27,
+ 293,
+ 37
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 26,
+ 294,
+ 38
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 26,
+ 294,
+ 38
+ ],
+ "score": 1.0,
+ "content": "Published as a conference paper at ICLR 2022",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "type": "discarded",
+ "bbox": [
+ 300,
+ 751,
+ 310,
+ 760
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 299,
+ 750,
+ 312,
+ 763
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 299,
+ 750,
+ 312,
+ 763
+ ],
+ "score": 1.0,
+ "content": "18",
+ "type": "text"
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "para_blocks": [
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 81,
+ 288,
+ 94
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 80,
+ 290,
+ 95
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 80,
+ 290,
+ 95
+ ],
+ "score": 1.0,
+ "content": "B IMPROVE SEARCH ALGORITHM",
+ "type": "text"
+ }
+ ],
+ "index": 0
+ }
+ ],
+ "index": 0
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 106,
+ 505,
+ 150
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 106,
+ 506,
+ 118
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 106,
+ 453,
+ 118
+ ],
+ "score": 1.0,
+ "content": "In the main text we use simulated annealing (SA) to find the winning permutation",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 453,
+ 108,
+ 460,
+ 116
+ ],
+ "score": 0.7,
+ "content": "\\pi",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 461,
+ 106,
+ 506,
+ 118
+ ],
+ "score": 1.0,
+ "content": ". Figure 6",
+ "type": "text"
+ }
+ ],
+ "index": 1
+ },
+ {
+ "bbox": [
+ 105,
+ 115,
+ 505,
+ 130
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 115,
+ 411,
+ 130
+ ],
+ "score": 1.0,
+ "content": "shows that SA is only able to reduce the barrier, and reducing search space",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 411,
+ 118,
+ 437,
+ 128
+ ],
+ "score": 0.83,
+ "content": "\\left( \\mathrm { n } = 2 \\right)",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 437,
+ 115,
+ 505,
+ 130
+ ],
+ "score": 1.0,
+ "content": ") helps in finding",
+ "type": "text"
+ }
+ ],
+ "index": 2
+ },
+ {
+ "bbox": [
+ 105,
+ 128,
+ 505,
+ 140
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 128,
+ 505,
+ 140
+ ],
+ "score": 1.0,
+ "content": "better permutations. However, a critical question still remains: Is there an algorithm that finds better",
+ "type": "text"
+ }
+ ],
+ "index": 3
+ },
+ {
+ "bbox": [
+ 105,
+ 140,
+ 165,
+ 150
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 140,
+ 165,
+ 150
+ ],
+ "score": 1.0,
+ "content": "permutations?",
+ "type": "text"
+ }
+ ],
+ "index": 4
+ }
+ ],
+ "index": 2.5,
+ "bbox_fs": [
+ 105,
+ 106,
+ 506,
+ 150
+ ]
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 155,
+ 505,
+ 222
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 156,
+ 505,
+ 168
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 156,
+ 505,
+ 168
+ ],
+ "score": 1.0,
+ "content": "He et al. (2018) proposed an algorithms that merges correlated, pre-trained deep neural networks for",
+ "type": "text"
+ }
+ ],
+ "index": 5
+ },
+ {
+ "bbox": [
+ 105,
+ 167,
+ 505,
+ 179
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 167,
+ 505,
+ 179
+ ],
+ "score": 1.0,
+ "content": "cross-model compression. Their objective is to zip two neural networks, optimized for two different",
+ "type": "text"
+ }
+ ],
+ "index": 6
+ },
+ {
+ "bbox": [
+ 105,
+ 177,
+ 506,
+ 191
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 177,
+ 506,
+ 191
+ ],
+ "score": 1.0,
+ "content": "tasks, into one network. The ultimate network does both tasks without losing too much accuracy",
+ "type": "text"
+ }
+ ],
+ "index": 7
+ },
+ {
+ "bbox": [
+ 106,
+ 189,
+ 505,
+ 201
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 189,
+ 505,
+ 201
+ ],
+ "score": 1.0,
+ "content": "on each task. Their algorithm is based on layer-wise neuron sharing, which uses f(weights, post",
+ "type": "text"
+ }
+ ],
+ "index": 8
+ },
+ {
+ "bbox": [
+ 105,
+ 199,
+ 505,
+ 212
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 199,
+ 505,
+ 212
+ ],
+ "score": 1.0,
+ "content": "activations) to find which neurons could be zipped together. They define the similarity (or equivalently",
+ "type": "text"
+ }
+ ],
+ "index": 9
+ },
+ {
+ "bbox": [
+ 106,
+ 210,
+ 373,
+ 223
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 210,
+ 373,
+ 223
+ ],
+ "score": 1.0,
+ "content": "difference) of two neurons as below (Eq. 12 in the original paper):",
+ "type": "text"
+ }
+ ],
+ "index": 10
+ }
+ ],
+ "index": 7.5,
+ "bbox_fs": [
+ 105,
+ 156,
+ 506,
+ 223
+ ]
+ },
+ {
+ "type": "interline_equation",
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "score": 0.92,
+ "content": "\\delta _ { n _ { A } , n _ { B } } = \\frac { 1 } { 2 } ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } ) . ( ( H _ { l , i } ^ { A } ) ^ { - 1 } + ( H _ { l , i } ^ { B } ) ^ { - 1 } ) ^ { - 1 } . ( w _ { l , i } ^ { A } - w _ { l , i } ^ { B } )",
+ "type": "interline_equation",
+ "image_path": "af652a4f6754b7b4b21a5168a360b40113fbc2d5eca6936206b034f70cf8c8a3.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 11,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 176,
+ 241,
+ 436,
+ 265
+ ],
+ "spans": [],
+ "index": 11
+ }
+ ]
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 106,
+ 274,
+ 506,
+ 352
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 275,
+ 505,
+ 288
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 275,
+ 505,
+ 288
+ ],
+ "score": 1.0,
+ "content": "We also used their \"functional difference\" as a measure for neuron matching between two randomly",
+ "type": "text"
+ }
+ ],
+ "index": 12
+ },
+ {
+ "bbox": [
+ 106,
+ 287,
+ 506,
+ 298
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 287,
+ 506,
+ 298
+ ],
+ "score": 1.0,
+ "content": "initialized trained networks. They used post activation as an approximation for Hessian matrices.",
+ "type": "text"
+ }
+ ],
+ "index": 13
+ },
+ {
+ "bbox": [
+ 106,
+ 298,
+ 505,
+ 309
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 298,
+ 445,
+ 309
+ ],
+ "score": 1.0,
+ "content": "Calculating the difference between each pair of neurons based on Equation 2, gives an",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 446,
+ 298,
+ 476,
+ 308
+ ],
+ "score": 0.89,
+ "content": "m \\times m",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 477,
+ 298,
+ 505,
+ 309
+ ],
+ "score": 1.0,
+ "content": "matrix",
+ "type": "text"
+ }
+ ],
+ "index": 14
+ },
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 309,
+ 505,
+ 320
+ ],
+ "score": 1.0,
+ "content": "(m is width of the network). In the second step, neurons with minimum distance are matched together",
+ "type": "text"
+ }
+ ],
+ "index": 15
+ },
+ {
+ "bbox": [
+ 105,
+ 318,
+ 505,
+ 331
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 318,
+ 200,
+ 331
+ ],
+ "score": 1.0,
+ "content": "in a greedy way i.e., if",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 200,
+ 320,
+ 219,
+ 331
+ ],
+ "score": 0.9,
+ "content": "n _ { i , A }",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 219,
+ 318,
+ 237,
+ 331
+ ],
+ "score": 1.0,
+ "content": "and",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 238,
+ 320,
+ 257,
+ 331
+ ],
+ "score": 0.89,
+ "content": "n _ { j , B }",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 258,
+ 318,
+ 394,
+ 331
+ ],
+ "score": 1.0,
+ "content": "have the minimum distance, row",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 394,
+ 320,
+ 399,
+ 329
+ ],
+ "score": 0.69,
+ "content": "i",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 399,
+ 318,
+ 450,
+ 331
+ ],
+ "score": 1.0,
+ "content": "and column",
+ "type": "text"
+ },
+ {
+ "bbox": [
+ 451,
+ 320,
+ 457,
+ 330
+ ],
+ "score": 0.82,
+ "content": "j",
+ "type": "inline_equation"
+ },
+ {
+ "bbox": [
+ 457,
+ 318,
+ 505,
+ 331
+ ],
+ "score": 1.0,
+ "content": "is removed",
+ "type": "text"
+ }
+ ],
+ "index": 16
+ },
+ {
+ "bbox": [
+ 105,
+ 329,
+ 506,
+ 342
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 329,
+ 506,
+ 342
+ ],
+ "score": 1.0,
+ "content": "from the distance matrix. Figure 15 shows that using functional difference, the barrier could be",
+ "type": "text"
+ }
+ ],
+ "index": 17
+ },
+ {
+ "bbox": [
+ 105,
+ 341,
+ 150,
+ 354
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 341,
+ 150,
+ 354
+ ],
+ "score": 1.0,
+ "content": "improved.",
+ "type": "text"
+ }
+ ],
+ "index": 18
+ }
+ ],
+ "index": 15,
+ "bbox_fs": [
+ 105,
+ 275,
+ 506,
+ 354
+ ]
+ },
+ {
+ "type": "image",
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "blocks": [
+ {
+ "type": "image_body",
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 520
+ ],
+ "score": 0.973,
+ "type": "image",
+ "image_path": "f94f98c5a4042b025956dbf1cfd7f75bc63cf72eb70d49433a556e5ff578b706.jpg"
+ }
+ ]
+ }
+ ],
+ "index": 24.5,
+ "virtual_lines": [
+ {
+ "bbox": [
+ 205,
+ 366,
+ 404,
+ 378.8333333333333
+ ],
+ "spans": [],
+ "index": 19
+ },
+ {
+ "bbox": [
+ 205,
+ 378.8333333333333,
+ 404,
+ 391.66666666666663
+ ],
+ "spans": [],
+ "index": 20
+ },
+ {
+ "bbox": [
+ 205,
+ 391.66666666666663,
+ 404,
+ 404.49999999999994
+ ],
+ "spans": [],
+ "index": 21
+ },
+ {
+ "bbox": [
+ 205,
+ 404.49999999999994,
+ 404,
+ 417.33333333333326
+ ],
+ "spans": [],
+ "index": 22
+ },
+ {
+ "bbox": [
+ 205,
+ 417.33333333333326,
+ 404,
+ 430.1666666666666
+ ],
+ "spans": [],
+ "index": 23
+ },
+ {
+ "bbox": [
+ 205,
+ 430.1666666666666,
+ 404,
+ 442.9999999999999
+ ],
+ "spans": [],
+ "index": 24
+ },
+ {
+ "bbox": [
+ 205,
+ 442.9999999999999,
+ 404,
+ 455.8333333333332
+ ],
+ "spans": [],
+ "index": 25
+ },
+ {
+ "bbox": [
+ 205,
+ 455.8333333333332,
+ 404,
+ 468.6666666666665
+ ],
+ "spans": [],
+ "index": 26
+ },
+ {
+ "bbox": [
+ 205,
+ 468.6666666666665,
+ 404,
+ 481.49999999999983
+ ],
+ "spans": [],
+ "index": 27
+ },
+ {
+ "bbox": [
+ 205,
+ 481.49999999999983,
+ 404,
+ 494.33333333333314
+ ],
+ "spans": [],
+ "index": 28
+ },
+ {
+ "bbox": [
+ 205,
+ 494.33333333333314,
+ 404,
+ 507.16666666666646
+ ],
+ "spans": [],
+ "index": 29
+ },
+ {
+ "bbox": [
+ 205,
+ 507.16666666666646,
+ 404,
+ 519.9999999999998
+ ],
+ "spans": [],
+ "index": 30
+ }
+ ]
+ },
+ {
+ "type": "image_caption",
+ "bbox": [
+ 105,
+ 532,
+ 504,
+ 554
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 106,
+ 531,
+ 505,
+ 543
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 531,
+ 505,
+ 543
+ ],
+ "score": 1.0,
+ "content": "Figure 15: Performance of Functional Difference compared to Simulated Annealing. Functional Differ-",
+ "type": "text"
+ }
+ ],
+ "index": 31
+ },
+ {
+ "bbox": [
+ 106,
+ 542,
+ 443,
+ 554
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 542,
+ 443,
+ 554
+ ],
+ "score": 1.0,
+ "content": "ence could indeed find better permutations, improving the barrier size between two solutions.",
+ "type": "text"
+ }
+ ],
+ "index": 32
+ }
+ ],
+ "index": 31.5
+ }
+ ],
+ "index": 28.0
+ },
+ {
+ "type": "title",
+ "bbox": [
+ 108,
+ 575,
+ 239,
+ 587
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 573,
+ 240,
+ 590
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 573,
+ 240,
+ 590
+ ],
+ "score": 1.0,
+ "content": "C MAKING ENSEMBLES",
+ "type": "text"
+ }
+ ],
+ "index": 33
+ }
+ ],
+ "index": 33
+ },
+ {
+ "type": "text",
+ "bbox": [
+ 106,
+ 600,
+ 505,
+ 732
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 600,
+ 505,
+ 612
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 600,
+ 505,
+ 612
+ ],
+ "score": 1.0,
+ "content": "As stated before, our conjecture has implications for ensemble methods. If two solutions lie at the",
+ "type": "text"
+ }
+ ],
+ "index": 34
+ },
+ {
+ "bbox": [
+ 105,
+ 612,
+ 505,
+ 623
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 612,
+ 505,
+ 623
+ ],
+ "score": 1.0,
+ "content": "periphery of a wide and flat low loss region (a basin where models are linearly connected to each",
+ "type": "text"
+ }
+ ],
+ "index": 35
+ },
+ {
+ "bbox": [
+ 105,
+ 622,
+ 506,
+ 635
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 622,
+ 506,
+ 635
+ ],
+ "score": 1.0,
+ "content": "other), then ensembling them in their weight space (averaging), creates a model tending to the center",
+ "type": "text"
+ }
+ ],
+ "index": 36
+ },
+ {
+ "bbox": [
+ 105,
+ 632,
+ 505,
+ 646
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 632,
+ 505,
+ 646
+ ],
+ "score": 1.0,
+ "content": "of the region, which leads to performance improvement. However, Simulated Annealing could not",
+ "type": "text"
+ }
+ ],
+ "index": 37
+ },
+ {
+ "bbox": [
+ 106,
+ 643,
+ 505,
+ 656
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 643,
+ 505,
+ 656
+ ],
+ "score": 1.0,
+ "content": "find the optimal permutations for all cases. Section B shows that using matching algorithms like",
+ "type": "text"
+ }
+ ],
+ "index": 38
+ },
+ {
+ "bbox": [
+ 105,
+ 655,
+ 506,
+ 667
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 655,
+ 506,
+ 667
+ ],
+ "score": 1.0,
+ "content": "functional difference could help to find better permutations. Motivated to create ensembles, Wortsman",
+ "type": "text"
+ }
+ ],
+ "index": 39
+ },
+ {
+ "bbox": [
+ 106,
+ 666,
+ 505,
+ 678
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 666,
+ 505,
+ 678
+ ],
+ "score": 1.0,
+ "content": "et al. (2021) start with two (or more) random initializations and learn a subspace (a line or simplex)",
+ "type": "text"
+ }
+ ],
+ "index": 40
+ },
+ {
+ "bbox": [
+ 105,
+ 677,
+ 506,
+ 689
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 677,
+ 506,
+ 689
+ ],
+ "score": 1.0,
+ "content": "connecting them. Throughout training they sample one (or more) points on this line and add the",
+ "type": "text"
+ }
+ ],
+ "index": 41
+ },
+ {
+ "bbox": [
+ 106,
+ 688,
+ 505,
+ 700
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 688,
+ 505,
+ 700
+ ],
+ "score": 1.0,
+ "content": "loss at this point to the loss of training. In order to enforce diversity in function space, they also",
+ "type": "text"
+ }
+ ],
+ "index": 42
+ },
+ {
+ "bbox": [
+ 106,
+ 699,
+ 505,
+ 711
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 699,
+ 505,
+ 711
+ ],
+ "score": 1.0,
+ "content": "add a regularization term as cosine similarity of two endpoints of the line. However as they enforce",
+ "type": "text"
+ }
+ ],
+ "index": 43
+ },
+ {
+ "bbox": [
+ 105,
+ 709,
+ 506,
+ 722
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 709,
+ 506,
+ 722
+ ],
+ "score": 1.0,
+ "content": "two models to be in a line, the functional diversity of the final ensemble is limited compare to our",
+ "type": "text"
+ }
+ ],
+ "index": 44
+ },
+ {
+ "bbox": [
+ 106,
+ 721,
+ 506,
+ 731
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 106,
+ 721,
+ 506,
+ 731
+ ],
+ "score": 1.0,
+ "content": "methods. Here we combine their method with functional difference to make best of both worlds.",
+ "type": "text"
+ }
+ ],
+ "index": 45
+ }
+ ],
+ "index": 39.5,
+ "bbox_fs": [
+ 105,
+ 600,
+ 506,
+ 731
+ ]
+ }
+ ]
+ },
+ {
+ "preproc_blocks": [
+ {
+ "type": "text",
+ "bbox": [
+ 107,
+ 82,
+ 505,
+ 127
+ ],
+ "lines": [
+ {
+ "bbox": [
+ 105,
+ 83,
+ 505,
+ 95
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 83,
+ 505,
+ 95
+ ],
+ "score": 1.0,
+ "content": "In this experiment, we train two randomly initialized networks separately, and then use functional",
+ "type": "text"
+ }
+ ],
+ "index": 0
+ },
+ {
+ "bbox": [
+ 105,
+ 93,
+ 505,
+ 106
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 93,
+ 505,
+ 106
+ ],
+ "score": 1.0,
+ "content": "difference to decrease the barrier between final solutions. Then we use learning subspace method to",
+ "type": "text"
+ }
+ ],
+ "index": 1
+ },
+ {
+ "bbox": [
+ 105,
+ 105,
+ 505,
+ 117
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 105,
+ 505,
+ 117
+ ],
+ "score": 1.0,
+ "content": "make them in one basin. Our results on MLP with one hidden layer and width of 1024 neurons on",
+ "type": "text"
+ }
+ ],
+ "index": 2
+ },
+ {
+ "bbox": [
+ 105,
+ 115,
+ 387,
+ 128
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 105,
+ 115,
+ 387,
+ 128
+ ],
+ "score": 1.0,
+ "content": "MNIST and CIFAR10 shows that this method outperforms the others.",
+ "type": "text"
+ }
+ ],
+ "index": 3
+ }
+ ],
+ "index": 1.5
+ },
+ {
+ "type": "table",
+ "bbox": [
+ 172,
+ 140,
+ 438,
+ 186
+ ],
+ "blocks": [
+ {
+ "type": "table_body",
+ "bbox": [
+ 172,
+ 140,
+ 438,
+ 186
+ ],
+ "group_id": 0,
+ "lines": [
+ {
+ "bbox": [
+ 172,
+ 140,
+ 438,
+ 186
+ ],
+ "spans": [
+ {
+ "bbox": [
+ 172,
+ 140,
+ 438,
+ 186
+ ],
+ "score": 0.874,
+ "html": "