| Method | Data | Backbone | F-measure | FPS |
| None | Full |
| TextBoxes [22] | SynText800k, IC13, IC15, TT | ResNet-50-FPN | 36.3 | 48.9 | 1.4 |
| Mask TextSpotter'18 [31] | SynText800k, IC13, IC15, TT | ResNet-50-FPN | 52.9 | 71.8 | 4.8 |
| Two-stage [37] | SynText800k, IC13, IC15, TT | ResNet-50-SAM | 45.0 | - | - |
| TextNet [37] | SynText800k, IC13, IC15, TT | ResNet-50-SAM | 54.0 | - | 2.7 |
| Li et al. [20] | SynText840k, IC13, IC15, TT, MLT, AddF2k | ResNet-101-FPN | 57.80 | - | 1.4 |
| Mask TextSpotter'19 [21] | SynText800k, IC13, IC15, TT, AddF2k | ResNet-50-FPN | 65.3 | 77.4 | 2.0 |
| Qin et al. [34] | SynText200k, IC15, COCO-Text, TT, MLT
+Private: 30k (manual label), 1m (partial label) | ResNet-50-MSF | 67.8 | - | 4.8 |
| CharNet [24] | SynText800k, IC15, MLT, TT | ResNet-50-Hourglass57 | 66.2 | - | 1.2 |
| TextDragon [44] | SynText800k, IC15, TT | VGG16 | 48.8 | 74.8 | - |
| ABCNet-F | SynText150k, COCO-Text, TT, MLT | ResNet-50-FPN | 61.9 | 74.1 | 22.8 |
| ABCNet | 64.2 | 75.7 | 17.9 |
| ABCNet-MS | 69.5 | 78.4 | 6.9 |
+
+Table 2: Scene text spotting results on Total-Text. ABCNet-F is faster as the short size of input image is 600. MS: multi-scale testing. "None" represents recognition without any lexicon. "Full" lexicon contains all words in test set. Datasets: AddF2k [48]; IC13 [17]; IC15 [16]; TT [5]; MLT [32]; COCO-Text [40].
+
+| Scheme | Individual Quantization (SAT) | Adaptive Bit-widths | BitOPs |
| Name | Bit-width | Size | Top-1 Acc. | Name | Size | Top-1 Acc. |
| Original | MobileNet V1 | 8 bit | 4.10 MB | 72.6 | | | 72.4 (-0.2) | 36.40 B |
| MobileNet V1 | 6 bit | 3.34 MB | 72.3 | AB-MobileNet V1 [8, 6, 5, 4] bits | FP | 72.4 (0.1) | 20.81 B |
| MobileNet V1 | 5 bit | 2.96 MB | 71.9 | 72.1 (0.2) | 14.68 B |
| MobileNet V1 | 4 bit | 2.58 MB | 71.3 | 71.1 (-0.2) | 9.67 B |
| MobileNet V2 | 8 bit | 3.44 MB | 72.5 | | | 72.6 (0.1) | 19.25 B |
| MobileNet V2 | 6 bit | 2.92 MB | 72.3 | AB-MobileNet V2 [8, 6, 5, 4] bits | FP | 72.4 (0.1) | 11.17 B |
| MobileNet V2 | 5 bit | 2.66 MB | 72.0 | 72.1 (0.1) | 7.99 B |
| MobileNet V2 | 4 bit | 2.40 MB | 71.1 | 70.8 (-0.3) | 5.39 B |
| ResNet50 | 4 bit | 13.34 MB | 76.3 | AB-ResNet50 [4, 3, 2] bits | FP | 76.1 (-0.2) | 71.81 B |
| ResNet50 | 3 bit | 10.55 MB | 75.9 | 75.8 (-0.1) | 43.75 B |
| ResNet50 | 2 bit | 7.75 MB | 73.3 | 73.2 (-0.1) | 23.71 B |
| Modified | MobileNet V1 | 8 bit | 4.10 MB | 72.6 | | | 72.3 (-0.3) | 36.40 B |
| MobileNet V1 | 6 bit | 3.34 MB | 72.4 | AB-MobileNet V1 [8, 6, 5, 4] bits | 4.35 MB | 72.3 (-0.1) | 20.81 B |
| MobileNet V1 | 5 bit | 2.96 MB | 72.2 | 72.0 (-0.2) | 14.68 B |
| MobileNet V1 | 4 bit | 2.58 MB | 70.5 | 70.4 (-0.1) | 9.67 B |
| MobileNet V2 | 8 bit | 3.44 MB | 72.7 | | | 72.3 (-0.4) | 19.25 B |
| MobileNet V2 | 6 bit | 2.92 MB | 72.5 | AB-MobileNet V2 [8, 6, 5, 4] bits | 3.83 MB | 72.3 (-0.2) | 11.17 B |
| MobileNet V2 | 5 bit | 2.66 MB | 72.1 | 72.0 (-0.1) | 7.99 B |
| MobileNet V2 | 4 bit | 2.40 MB | 70.3 | 70.3 (0.0) | 5.39 B |
+
+Table 4. Comparison between individual quantization and AdaBits quantization for top-1 validation accuracy $(\%)$ of MobileNet V1/V2 and ResNet50 on ImageNet. Note that we use two quantization schemes to compare our AdaBits with SAT baseline models where "original" denotes the original DoReFa scheme and "modified" denote the modified scheme in Eq. (3) which enables producing weights for lower bit-width from the 8-bit model. "FP" denotes the full-precision models is needed to recover weights in different bit-widths.
+
+# 6. Discussion and Future Work
+
+Our approach for adaptive bit-width indicates that bitwidth of quantized models is an additional degree of freedom besides channel number, depth, kernel-size and resolution for adaptive models. Previous work [18, 47] demonstrate the possibility to utilize the trained adaptive models for neural architecture search algorithms, based on which improved architectures can be discovered under predefined resource constraints. This suggests we might be able to employ the quantized models with adaptive bit-widths to search for bit-width in each layer or channel, for the purpose of mixed-precision quantization [10, 44, 42, 41, 26]. On the other hand, adding bit-widths to the list of channel numbers, depth, kernel-size, and resolution enlarges design space for adaptive models, which could enable more powerful adaptive models and facilitate more real world applications, such as face alignment [30, 50] and compressive imaging system [29].
+
+Evaluation of AdaBits with other quantization methods is another future work. Due to numerous algorithms for neural network quantization, we only select a state-of-the-art algorithm SAT to validate the effectiveness of adaptive bit-width. Since our joint training approach is general and can be combined with any quantization algorithms based on quantization-aware training, we believe similar results can be achieved by combining other quantization approaches
+
+with our AdaBits algorithm.
+
+# 7. Conclusion
+
+In this paper, we investigate the possibility to adaptively configure bit-widths for deep neural networks. After investigating several baseline methods, we propose a joint training approach to optimize all selected bit-widths in the quantized model. Another treatment named Switchable Clipping Level is proposed to privatize clipping level parameters to each bit-width and to eliminate undesired interference between different bit-widths. The final AdaBits approach achieves similar accuracies as models quantized with different bit-widths individually, for a wide range of models including MobileNet V1/V2 and ResNet50 on the ImageNet dataset. This new kind of adaptive models widen the choices for designing dynamic models which can instantly adapt to different hardwares and resource constraints.
+
+# 8. Acknowledgement
+
+The authors would like to appreciate invaluable discussion with Professor Hao Chen from University of California Davis and Professor Yi Ma from University of California Berkeley. They also would like to thank Hongyi Zhang, Yangyue Wan, Xiaochen Lian and Xiaojie Jin from ByteDance Inc., Yingwei Li and Jieru Mei from John Hopkins University, and Chaosheng Dong from University of Pittsburgh for technical discussion.
+
+# References
+
+[1] Yu Bai, Yu-Xiang Wang, and Edo Liberty. Proxquant: Quantized neural networks via proximal operators. arXiv preprint arXiv:1810.00861, 2018. 2
+[2] Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pages 549-558, 2018. 2
+[3] Han Cai, Chuang Gan, and Song Han. Once for all: Train one network and specialize it for efficient deployment. arXiv preprint arXiv:1908.09791, 2019. 1, 2
+[4] Han Cai, Ligeng Zhu, and Song Han. Proxylessnas: Direct neural architecture search on target task and hardware. arXiv preprint arXiv:1812.00332, 2018. 2
+[5] Yukang Chen, Tong Yang, Xiangyu Zhang, Gaofeng Meng, Chunhong Pan, and Jian Sun. Detnas: Backbone search for object detection. arXiv preprint arXiv:1903.10979, 2019. 2
+[6] Jungwook Choi, Zhuo Wang, Swagath Venkataramani, Pierce I-Jen Chuang, Vijayalakshmi Srinivasan, and Kailash Gopalakrishnan. Pact: Parameterized clipping activation for quantized neural networks. arXiv preprint arXiv:1805.06085, 2018. 2, 3, 6, 7
+[7] Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In Advances in neural information processing systems, pages 3123-3131, 2015. 2
+[8] Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to + 1 or-1. arXiv preprint arXiv:1602.02830, 2016. 2
+[9] Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018. 2
+[10] Ahmed T. Elthakeb, Prannoy Pilligundla, FatemehSadat Mireshghallah, Amir Yazdanbakhsh, Sicun Gao, and Hadi Esmaeilzadeh. Releg: an automatic reinforcement learning approach for deep quantization of neural networks. arXiv preprint arXiv:1811.01704, 2018. 2, 8
+[11] Xinyu Gong, Shiyu Chang, Yifan Jiang, and Zhangyang Wang. Autogan: Neural architecture search for generative adversarial networks. arXiv preprint arXiv:1908.03835, 2019. 2
+[12] Priya Goyal, Piotr Dolkar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. 7
+[13] Sorin Grigorescu, Bogdan Trasnea, Tiberiu Cocias, and Gigel Macesanu. A survey of deep learning techniques for autonomous driving. Journal of Field Robotics, 2019. 1
+[14] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770-778, 2016. 1
+
+[15] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pages 630-645. Springer, 2016. 1
+[16] Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. 1
+[17] Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2704-2713, 2018. 2
+[18] Qing Jin, Linjie Yang, and Zhenyu Liao. Towards efficient training for neural network quantization. arXiv preprint arXiv:1912.10207, 2019. 1, 2, 3, 4, 5, 7, 8
+[19] Cong Leng, Zesheng Dou, Hao Li, Shenghuo Zhu, and Rong Jin. Extremely low bit neural network: Squeeze the last bit out with admm. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. 2
+[20] Fengfu Li, Bo Zhang, and Bin Liu. Ternary weight networks. arXiv preprint arXiv:1605.04711, 2016. 2
+[21] Yingwei Li, Xiaojie Jin, Jieru Mei, Xiaochen Lian, Linjie Yang, Cihang Xie, Qihang Yu, Yuyin Zhou, Song Bai, and Alan Yuille. Autonl: Neural architecture search for lightweight non-local networks in mobile vision. In submission, 2020. 2
+[22] Yingwei Li, Zhuotun Zhu, Yuyin Zhou, Yingda Xia, Wei Shen, Elliot K. Fishman, and Alan L. Yuille. Volumetric Medical Image Segmentation: A 3D Deep Coarse-to-Fine Framework and Its Adversarial Examples, pages 69-91. Springer International Publishing, Cham, 2019. 1
+[23] Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan L Yuille, and Li Fei-Fei. Autodeplab: Hierarchical neural architecture search for semantic image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 82–92, 2019. 2
+[24] Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pages 19–34, 2018. 2
+[25] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.7
+[26] Qian Lou, Lantao Liu, Minje Kim, and Lei Jiang. Autoqb: Automl for network quantization and binarization on mobile devices. arXiv preprint arXiv:1902.05690, 2019. 2, 8
+[27] Jieru Mei, Yingwei Li, Xiaochen Lian, Xiaojie Jin, Linjie Yang, Alan Yuille, and Jianchao Yang. Atom{nas}: Fine-grained end-to-end neural architecture search. In International Conference on Learning Representations, 2020. 2
+[28] Naveen Mellempudi, Abhisek Kundu, Dheevatsa Mudigere, Dipankar Das, Bharat Kaul, and Pradeep Dubey. Ternary neu
+
+ral networks with fine-grained quantization. arXiv preprint arXiv:1705.01462, 2017. 2
+[29] Xin Miao, Xin Yuan, Yunchen Pu, and Vassilis Athitsos. λ-net: Reconstruct hyperspectral images from a snapshot measurement. In IEEE/CVF Conference on Computer Vision (ICCV), volume 1, 2019. 8
+[30] Xin Miao, Xiantong Zhen, Xianglong Liu, Cheng Deng, Vassilis Athitsos, and Heng Huang. Direct shape regression networks for end-to-end face alignment. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5040-5049, 2018. 8
+[31] Asit Mishra and Debbie Marr. Apprentice: Using knowledge distillation techniques to improve low-precision network accuracy. arXiv preprint arXiv:1711.05852, 2017. 2
+[32] Asit Mishra, Eriko Nurvitadhi, Jeffrey J Cook, and Debbie Marr. Wprn: wide reduced-precision networks. arXiv preprint arXiv:1709.01134, 2017. 2
+[33] Eunhyeok Park, Junwhan Ahn, and Sungjoo Yoo. Weighted-entropy-based quantization for deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5456–5464, 2017. 2
+[34] Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018. 2
+[35] Prajit Ramachandran, Barret Zoph, and Quoc V. Le. Searching for activation functions, 2018. 2
+[36] Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In European Conference on Computer Vision, pages 525-542. Springer, 2016. 2
+[37] Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zh-moginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4510-4520, 2018. 1
+[38] Dimitrios Stamoulis, Ruizhou Ding, Di Wang, Dimitrios Lymberopoulos, Bodhi Priyantha, Jie Liu, and Diana Marculescu. Single-path nas: Designing hardware-efficient convnets in less than 4 hours. arXiv preprint arXiv:1904.02877, 2019. 2
+[39] Mingxing Tan, Bo Chen, Ruoming Pang, Vijay Vasudevan, Mark Sandler, Andrew Howard, and Quoc V Le. Mnasnet: Platform-aware neural architecture search for mobile. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2820-2828, 2019. 1
+[40] Alex Teichman and Sebastian Thrun. Practical object recognition in autonomous driving and beyond. In Advanced Robotics and its Social Impacts, pages 35-38. IEEE, 2011. 1
+[41] Stefan Uhlich, Lukas Mauch, Kazuki Yoshiyama, Fabien Cardinaux, Javier Alonso Garcia, Stephen Tiedemann, Thomas Kemp, and Akira Nakamura. Differentiable quantization of deep neural networks. arXiv preprint arXiv:1905.11452, 2019. 2, 8
+[42] Kuan Wang, Zhijian Liu, Yujun Lin, Ji Lin, and Song Han. Haq: Hardware-aware automated quantization with mixed precision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8612-8620, 2019. 2, 8
+
+[43] Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 10734-10742, 2019. 2
+[44] Bichen Wu, Yanghan Wang, Peizhao Zhang, Yuandong Tian, Peter Vajda, and Kurt Keutzer. Mixed precision quantization of convnets via differentiable neural architecture search. arXiv preprint arXiv:1812.00090, 2018. 2, 8
+[45] Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. Snas: stochastic neural architecture search. arXiv preprint arXiv:1812.09926, 2018. 2
+[46] Chen Xu, Jianqiang Yao, Zhouchen Lin, Wenwu Ou, Yuanbin Cao, Zhirong Wang, and Hongbin Zha. Alternating multi-bit quantization for recurrent neural networks. arXiv preprint arXiv:1802.00150, 2018. 2
+[47] Jiahui Yu and Thomas S. Huang. Network slimming by slimmable networks: Towards one-shot architecture search for channel numbers. CoRR, abs/1903.11728, 2019. 4, 8
+[48] Jiahui Yu, Pengchong Jin, Hanxiao Liu, Gabriel Bender Pieter-Jan Kindermans, Mingxing Tan, Thomas S. Huang, Xiaodan Song, Ruoming Pang, and Quoc V Le. Bignas: Scaling up neural architecture search with big single-stage models. arXiv preprint arXiv:2003.11142, 2020. 1, 2
+[49] Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang. Slimmable neural networks. arXiv preprint arXiv:1812.08928, 2018. 1, 2, 5
+[50] Lei Yue, Xin Miao, Pengbo Wang, Baochang Zhang, Xiantong Zhen, and Xianbin Cao. Attentional alignment networks. In BMVC, volume 2, page 7, 2018. 8
+[51] Shuchang Zhou, Yuxin Wu, Zekun Ni, Xinyu Zhou, He Wen, and Yuheng Zou. Dorefa-net: Training low bitwidth convolutional neural networks with low bitwidth gradients. arXiv preprint arXiv:1606.06160, 2016. 2, 3
+[52] Shu-Chang Zhou, Yu-Zhi Wang, He Wen, Qin-Yao He, and Yu-Heng Zou. Balanced quantization: An effective and efficient approach to quantized neural networks. Journal of Computer Science and Technology, 32(4):667-682, 2017. 2
+[53] Yuyin Zhou, Yingwei Li, Zhishuai Zhang, Yan Wang, Angtian Wang, Elliot K Fishman, Alan L Yuille, and Seyoun Park. Hyper-pairing network for multi-phase pancreatic ductal adenocarcinoma segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pages 155–163. Springer, 2019. 1
+[54] Chenzhuo Zhu, Song Han, Huizi Mao, and William J Dally. Trained ternary quantization. arXiv preprint arXiv:1612.01064, 2016. 2
+[55] Shilin Zhu, Xin Dong, and Hao Su. Binary ensemble neural network: More bits per network or more networks per bit? In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4923-4932, 2019. 2
+[56] Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. 1, 2
+[57] Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image
+
+recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 8697-8710, 2018.
\ No newline at end of file
diff --git a/adabitsneuralnetworkquantizationwithadaptivebitwidths/images.zip b/adabitsneuralnetworkquantizationwithadaptivebitwidths/images.zip
new file mode 100644
index 0000000000000000000000000000000000000000..9b8c9e364cd8cbb35b8eda9c6051198ca7bdf324
--- /dev/null
+++ b/adabitsneuralnetworkquantizationwithadaptivebitwidths/images.zip
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c694ce715443f72dc2b4ddb47b5b9f52a0cbcfb024a74c7409959b23be8f0297
+size 380012
diff --git a/adabitsneuralnetworkquantizationwithadaptivebitwidths/layout.json b/adabitsneuralnetworkquantizationwithadaptivebitwidths/layout.json
new file mode 100644
index 0000000000000000000000000000000000000000..880f2bfe69214407ac8253792d4ad86c584eed34
--- /dev/null
+++ b/adabitsneuralnetworkquantizationwithadaptivebitwidths/layout.json
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6b7b068399d2d10f96c813829a42d69716c56b1b2b4ba6e7c8c0088286fc9ab
+size 319273
diff --git a/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_content_list.json b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_content_list.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7222422c739a46c9f4de3278313cd10205c4418
--- /dev/null
+++ b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_content_list.json
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54f69ea76a8f5f2957e83980a943d1e2e779bc84e45b877f180620db16dd4101
+size 95716
diff --git a/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_model.json b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_model.json
new file mode 100644
index 0000000000000000000000000000000000000000..c2f338dcc756115dd962be15f6531e670ca59735
--- /dev/null
+++ b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_model.json
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27aceaafab4f19505af432963df7f3b6a2d50bc18ce5647d16bf6b980127d713
+size 114614
diff --git a/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_origin.pdf b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_origin.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..540115eefad149267465544a8abeba1588009527
--- /dev/null
+++ b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/e2e1a401-7356-40b3-8ce1-f8b2e211ed85_origin.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d4098c1242de1e201663e95620482cbaf9a139547fc784944519bca30012d19
+size 772194
diff --git a/adacofadaptivecollaborationofflowsforvideoframeinterpolation/full.md b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/full.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0419fa8ad1526a7d6abb540203bf3a7c96774c9
--- /dev/null
+++ b/adacofadaptivecollaborationofflowsforvideoframeinterpolation/full.md
@@ -0,0 +1,462 @@
+# AdaCoF: Adaptive Collaboration of Flows for Video Frame Interpolation
+
+Hyeongmin Lee $^{1}$ Taeoh Kim $^{1}$ Tae-young Chung $^{1}$ Daehyun Pak $^{1}$ Yuseok Ban $^{2}$ Sangyoun Lee $^{1*}$
+
+$^{1}$ Yonsei University
+
+{minimonia,kto,tato0220,koasing,sylee}@yonsei.ac.kr
+
+$^{2}$ Agency for Defense Development
+
+ban@add.re.kr
+
+# Abstract
+
+Video frame interpolation is one of the most challenging tasks in video processing research. Recently, many studies based on deep learning have been suggested. Most of these methods focus on finding locations with useful information to estimate each output pixel using their own frame warping operations. However, many of them have Degrees of Freedom (DoF) limitations and fail to deal with the complex motions found in real world videos. To solve this problem, we propose a new warping module named Adaptive Collaboration of Flows (AdaCoF). Our method estimates both kernel weights and offset vectors for each target pixel to synthesize the output frame. AdaCoF is one of the most generalized warping modules compared to other approaches, and covers most of them as special cases of it. Therefore, it can deal with a significantly wide domain of complex motions. To further improve our framework and synthesize more realistic outputs, we introduce dual-frame adversarial loss which is applicable only to video frame interpolation tasks. The experimental results show that our method outperforms the state-of-the-art methods for both fixed training set environments and the Middlebury benchmark. Our source code is available at https://github.com/HyeongminLEE/AdaCoF-pytorch.
+
+# 1. Introduction
+
+Synthesizing the intermediate frame when consecutive frames have been provided is one of the main research topics in the video processing area. Using a frame interpolation algorithm, we can obtain slow-motion videos from ordinary videos without using professional high-speed cameras. In addition, we can freely convert the frame rates of the videos so it can be applied to the video coding system. To interpolate the intermediate frame of a video requires an understanding of motion, unlike image pixel interpolation. Unfortunately, real world videos contain not only simple motions, but also large and complex ones, making the task
+
+
+(a) The Kernel-Based Approach
+
+
+(b) The Flow-Based Approach
+
+
+(c) Kernel and Flow Combined
+
+
+(d) Ours
+Figure 1: Overall description of the main streams and our method. The blue parts of each figure represent the reference points for generating the target pixel.
+
+significantly more difficult.
+
+Most of the approaches define video frame interpolation as a problem of finding reference locations in input frames which include information for estimating each output pixel value. This can be seen as a motion estimation process, because the task involves tracking the path of the target pixel. Therefore, each algorithm covers its own motion domain, and this area is directly related to the performance. To handle motion in real world videos, we need a generalized operation that can refer to any number of pixels in any location in the input frames. However, most of the existing approaches have a variety of limitations in Degrees of Freedom (DoF).
+
+One is the kernel-based approach (Figure 1 (a)) [34, 35], which adaptively estimates the large-sized kernel for each pixel and synthesizes the intermediate frame by convolving the kernels with the input. This approach finds the proper reference location by assigning large weights to the pixels
+
+of interest. However, it does not refer to any location, as it cannot deal with large motions beyond the kernel size. It is not efficient to keep the large size of the kernel even though the motion is small. The second approach is the flow-based approach (Figure 1 (b)) [20, 27], which estimates the flow vector directly pointing to the reference location for each output pixel. However, it cannot refer to any number of pixels because only one location is referred to in each input frame. Therefore, it is not suitable for complex motions and the result may suffer from lack of information when the input frame is of low-quality. Recently, methods of combining kernel-based and flow-based approaches are proposed to compensate for each other's limitations (Figure 1 (c)) [49, 3]. They multiply the kernels with the location pointed to by the flow vector. Therefore, they can refer to any location plus some additional neighboring pixels. However, this approach is not much different from the flow based approach as it uses significantly fewer reference points than the kernel-based one. In addition, there is room for improvement in terms of DoF because the shape of the kernel is a fixed square.
+
+In this paper, we propose an operation that refers to any number of pixels and any location called Adaptive Collaboration of Flows (AdaCoF). To synthesize a target pixel, we estimate multiple flows, called offset vectors, pointing to the reference locations and sample them. Then the target pixel is obtained by linearly combining the sampled values. Our method is inspired by deformable convolution (DefConv) [8], but AdaCoF is significantly different from it in some points. First, DefConv has a shared weight for all positions, and it is not suitable for video because there are various motions in each position of a frame. Therefore, we allow the weights to be spatially adaptive. Second, AdaCoF is used as an independent module for frame warping, not for feature extraction as DefConv. Therefore, we obtain the weights as the outputs of a neural network, instead of training them as learnable parameters. Third, we add dilation for the starting point of the offset vectors to enforce the them to search a wider area. Lastly, we add an occlusion mask to utilize only one of the two input frames when one of the reference pixels is occluded. As shown in Figure 1 (d), it can refer to any number within any location in the input frames, because the sizes and shapes of the kernels are not fixed. Therefore, our method has the highest DoF compared to most of the other competitive algorithms, and therefore can deal with various complex motions in real world videos. To make the synthesized frames more realistic, we further train a discriminator to detect the generated frame given the output and one of the input frames. Then we train the generator to maximize the entropy of the discriminator using dual-frame adversarial loss. Experimental results on various benchmarks show the effectiveness of AdaCoF over the latest state-of-the-art approaches.
+
+# 2. Related Work
+
+Most of the classic video frame interpolation methods estimate the dense flow maps using optical flow algorithms [12, 19, 44, 46] and warp the input frames [1, 4, 47, 50]. Therefore, the performance of these approaches largely depends on optical flow algorithms. Also, optical flow based approaches have limitations in many cases, such as occlusions, large motion, and brightness changes. Although there are some approaches without using external optical flow modules [25, 29], they still have difficulty in dealing with these problems. Meyer et al. [32] regard video frames as linear combinations of wavelets with different directions and frequencies. This approach interpolates each wavelet's phase and magnitude. This method makes notable progress in both performance and running time. Their recent work also applies deep learning to this approach [31]. However, it still has limitations for large motions of high frequency components.
+
+Recent work has demonstrated the success of applying deep learning in the field of computer vision [10, 14, 18, 21, 23, 41], which, in turn, inspires various deep learning based frame interpolation methods. As all we require for training neural networks are three consecutive video frames, learning based approaches are appropriate for this task. Long et al. [28] propose a CNN architecture that uses two input frames and directly estimates the intermediate frame. However, this type of approach often leads to blurry results. Some other methods focus on where to find the output pixel from the input frames, instead of directly estimating the image. This paradigm is based on the fact that at least one input frame contains the output pixel, even in the case of occlusion. Niklaus et al. [34] estimate a kernel for each location and obtains the output pixel by convolving it over input patches. Each kernel samples the proper input pixels by combining them selectively. However, this requires a lot of memory and estimating large kernels for every pixel is computationally expensive. Niklaus et al. [35] solve this problem by estimating each kernel from the outer product of two vectors. However, this approach cannot handle motions larger than the kernel size and it is still wasteful to estimate large kernels for small motions. Liu et al. [27] estimate a flow map that consists of vectors directly pointing to reference locations. They sample the proper pixels according to the flow map. However, as they assume that the forward and backward flows are the same, it is difficult to handle complex motions. Jiang et al. [20] propose a similar algorithm, but they estimate the forward and backward flows separately. They also improve the flow computation stage by defining the warping loss. However, it could be risky to get only one pixel value from each frame, especially when the input patches are of poor quality. To solve these problems, Reda et al. [38] and Bao et al. [3] combine kernel and flow map based approaches. They multiply
+
+small-sized kernels with the locations pointed by the flow vectors. However, the reference points are still limited in a small area because the kernels maintain their square shape, which results in low DoF.
+
+There are some approaches that use additional information to solve problems in video frame interpolation. Niklaus et al. [33] exploit the context informations extracted from ResNet-18 [18] to enable the informative interpolation and succeed in obtaining high-quality results. In addition, Bao et al. [2] use depth maps estimated from hourglass architecture [6] to solve the occlusion problems. Lastly, Liu et al. [26] obtain better performance with cycle consistency loss and additional edge maps. These approaches can be independently applied to many other algorithms, including our approach.
+
+# 3. Proposed Approach
+
+# 3.1. Video Frame Interpolation
+
+Given consecutive video frames $I_{n}$ and $I_{n + 1}$ , where $n \in \mathbb{Z}$ is a frame index, our goal is to find the intermediate frame $I_{out}$ . All the information required to produce $I_{out}$ can be obtained from $I_{n}$ and $I_{n + 1}$ . Therefore, all we have to do is find the relations between them. We regard the relation as a warping operation $\mathcal{T}$ from $I_{n}$ and $I_{n + 1}$ to $I_{out}$ . For the forward and backward warping operations $\mathcal{T}_f$ and $\mathcal{T}_b$ , we can consider $I_{out}$ as a combination of $\mathcal{T}_f(I_n)$ and $\mathcal{T}_b(I_{n + 1})$ as follows.
+
+$$
+I _ {o u t} = \mathcal {T} _ {f} (I _ {n}) + \mathcal {T} _ {b} (I _ {n + 1}) \tag {1}
+$$
+
+The frame interpolation task results in a problem of how the spatial transform $\mathcal{T}$ can be found. We employ a new operation called Adaptive Collaboration of Flows (AdaCoF) for $\mathcal{T}$ , which convolve the input image with adaptive kernel weights and offset vectors for each output pixel.
+
+Occlusion reasoning. Let both the input and output image sizes be $M \times N$ . In the case of occlusion, the target pixel will not be visible in one of the input images. Therefore we define occlusion map $V \in [0,1]^{M \times N}$ and modify Equation (1) as follows.
+
+$$
+I _ {o u t} = V \odot \mathcal {T} _ {f} (I _ {n}) + (J - V) \odot \mathcal {T} _ {b} (I _ {n + 1}), \tag {2}
+$$
+
+where $\odot$ is a pixel-wise multiplication and $J$ is an $M\times N$ matrix of ones. For the target pixel $(i,j)$ , $V(i,j) = 1$ implies that the pixel is visible only in $I_{n}$ and $V(i,j) = 0$ implies that it is visible only in $I_{n + 1}$ .
+
+
+(a) $d = 0$
+
+
+(b) $d = 1$
+
+
+(c) $d = 2$
+Figure 2: Illustration of the offset vectors of AdaCoF under various dilations.
+
+# 3.2. Adaptive Collaboration of Flows
+
+Let the frame warped from $I$ be $\hat{I}$ . When we define $\mathcal{T}$ as a classic convolution, we can write $\hat{I}$ as follows.
+
+$$
+\hat {I} (i, j) = \sum_ {k = 0} ^ {F - 1} \sum_ {l = 0} ^ {F - 1} W _ {k, l} I (i + k, j + l), \tag {3}
+$$
+
+where $F$ is the kernel size and $W_{k,l}$ are the kernel weights. The input image $I$ is considered to be padded so that the original input and output size are equal. Deformable convolution [8] adds offset vectors $\Delta p_{k,l} = (\alpha_{k,l},\beta_{k,l})$ to the classic convolution as follows.
+
+$$
+\hat {I} (i, j) = \sum_ {k = 0} ^ {F - 1} \sum_ {l = 0} ^ {F - 1} W _ {k, l} I (i + k + \alpha_ {k, l}, j + l + \beta_ {k, l}) \tag {4}
+$$
+
+AdaCoF, unlike the classic deformable convolutions, does not share the kernel weights over the different pixels. Therefore the notation for the kernel weights $W_{k,l}$ should be written as follows.
+
+$$
+\hat {I} (i, j) = \sum_ {k = 0} ^ {F - 1} \sum_ {l = 0} ^ {F - 1} W _ {k, l} (i, j) I (i + k + \alpha_ {k, l}, j + l + \beta_ {k, l}) \tag {5}
+$$
+
+The offset values $\alpha_{k,l}$ and $\beta_{k,l}$ may not be integer values. In other words, $(\alpha_{k,l},\beta_{k,l})$ could point to an arbitrary location, not only the grid point. Therefore, the pixel value of $I$ for any location has to be defined. We use bilinear interpolation to obtain the values of non-grid location as DCNs [8]. It also makes the module differentiable; therefore, the whole network can be trained end-to-end.
+
+Dilation. We found that dilating the starting point of the offset vectors helps AdaCoF to explore wider area as shown in Figure 2. Therefore, we add dilation term $d \in \{0,1,2,\ldots\}$ to the operation as follows.
+
+$$
+\begin{array}{l} \hat {I} (i, j) = \\ \sum_ {k = 0} ^ {F - 1} \sum_ {l = 0} ^ {F - 1} W _ {k, l} (i, j) I (i + d k + \alpha_ {k, l}, j + d l + \beta_ {k, l}) \tag {6} \\ \end{array}
+$$
+
+
+Figure 3: The neural network architecture. The model consists of three main parts: the U-Net, sub-networks, and Adaptive Collaboration of Flows (AdaCoF). The U-Net architecture extracts features from the input image. Then the sub-networks estimates the parameters needed for AdaCoF from the extracted features. The output's height and width of each sub-network are the same as that of the input. Each parameter group for an output pixel is obtained as a 1D vector along the channel axis. The AdaCoF part synthesizes the intermediate frame using the input frames and parameters.
+
+# 3.3. Network Architecture
+
+We design a fully convolutional neural network which estimates the kernel weights $W_{k,l}$ , offset vectors $(\alpha_{k,l},\beta_{k,l})$ , and occlusion map $V$ . Therefore, any video frames size can be used as the input. Furthermore, because each module of the neural network is differentiable, it is end-to-end trainable. Our neural network starts with the U-Net architecture, which consists of encoder, decoder, and skip connections [39]. Each processing unit basically contains $3\times 3$ convolution and ReLU activation. For the encoder part, we use average pooling to extract the features. And for the decoder part, we use bilinear interpolation for the upsampling. After the U-Net architecture, the seven sub-networks finally estimate the outputs $(W_{k,l},\alpha_{k,l},\beta_{k,l}$ for each frame and $V$ . We use sigmoid activation for $V$ to satisfy $V\in [0,1]^{M\times N}$ . Moreover, as the weights $W_{k,l}$ for each pixel have to be non-negative and must add up to 1, softmax layers are used for the constraints. More specific architectures of the network are described in Figure 3.
+
+# 3.4. Objective Functions
+
+Loss Function. First, we have to reduce a difference between the model output $I_{out}$ and ground truth $I_{gt}$ . We use $\ell_1$ norm for the loss as follows.
+
+$$
+\mathcal {L} _ {1} = \left\| I _ {\text {o u t}} - I _ {g t} \right\| _ {1} \tag {7}
+$$
+
+The $\ell_2$ norm can be used, but it is known that the $\ell_2$ norm-based optimization leads to blurry results in most of the image synthesis tasks [16, 28, 30, 43]. Following Liu et al. [27], we use the Charbonnier Function $\Phi(x) = (x^2 + \epsilon^2)^{1/2}$ for optimizing $\ell_1$ norm, where $\epsilon = 0.001$ .
+
+Perceptual Loss. Perceptual loss has been found to be effective in producing visually more realistic outputs [11, 21, 51]. We add the perceptual loss with the feature extractor $\mathcal{F}$ from conv4_3 of ImageNet pretrained VGG16 network.
+
+$$
+\mathcal {L} _ {v g g} = \left\| \mathcal {F} \left(I _ {\text {o u t}}\right) - \mathcal {F} \left(I _ {g t}\right) \right\| _ {2} \tag {8}
+$$
+
+Dual-Frame Adversarial Loss. It is known that training the networks with adversarial loss [15] can lead to results of higher quality and sharpness, instead of increasing mean squared error [24, 5]. This could be applied to video frame interpolation tasks. However, simply applying it to the single output frame does not consider the temporal consistency and leads to a disparate result compared to the input frames. What we want is to make the synthesized frame appear natural among the adjacent frames, not the other real images. Therefore, we concatenate the generated frame and one of the input frames in the temporal order and train the discriminator $C$ to distinguish which of the two is the generated frame with the following loss.
+
+$$
+- \mathcal {L} _ {C} = \log (C ([ I _ {n}, I _ {\text {o u t}} ])) + \log (1 - C ([ I _ {\text {o u t}}, I _ {n + 1} ])), \tag {9}
+$$
+
+| Train | Test | cls.acc. | MSE | EMD |
| vanilla | vanilla | 0.8172 | 0.3101 | 0.0481 |
| constant dilation rate = [2,1] | 0.8072 | 0.5163 | 0.0610 |
| second nearest integer dilation | 0.8091 | 0.5368 | 0.0620 |
| mean of nearest two integer dilations | 0.8117 | 0.4558 | 0.0576 |
| nearest integer dilation | 0.8114 | 0.4322 | 0.0562 |
| adaptive fractional dilation | 0.8132 | 0.4133 | 0.0553 |
| AFDC | vanilla | 0.8085 | 0.3210 | 0.0581 |
| constant dilation rate = [2,1] | 0.8132 | 0.3182 | 0.0576 |
| second nearest integer dilation | 0.8156 | 0.3003 | 0.0476 |
| mean of nearest two integer dilations | 0.8274 | 0.2771 | 0.0457 |
| nearest integer dilation | 0.8277 | 0.2757 | 0.0457 |
| adaptive fractional dilation | 0.8295 | 0.2743 | 0.0445 |
+
+
+Figure 8: Comparison of discrimination to the change of aspect ratios.
+
+aesthetically pleasing photography angles is not trivial.
+
+Due to the constraint of training dataset, we admit that the learned perception related to the aspect ratios is not satisfactory yet even the model learns from different aspect ratios. As a matter of fact, the learning ability is available for our proposed method when training on a more specific targeted dataset. It could be utilized in automatic/auxiliary photo enhancement with not only color space transformation but also with spatial transformation, e.g. profile editing, multi-shot selection and automatic resizing.
+
+# 4.4. Comparison With the State-of-the-Art Results
+
+We have compared our adaptive fractional dilated CNN with the state-of-the-art methods in Table 4. The results of these methods are directly obtained from the corresponding papers. As shown in Table 4, our proposed AFDC outperforms other methods in terms ofcls.acc and MSE, which are the most widely targeted metrics. Compared with NIMA(Inception-v2) [27] which uses the same EMD loss, our experimental results have shown that preserving the image aesthetic information completely results in better performance on image aesthetics assessment. We follow the same motivation from MNA-CMM-Scene [16], while our
+
+Table 3: The test result comparison of different convolutions: The results are obtained with trained parameters by vanilla Conv (above) and AFDC (below). Test processes are conducted by different calculation methods for interpolation weights, w in Eq. (5). Vanilla Conv, constant dilation, nearest integer dilation and second nearest integer dilation can be interpreted as feeding one-hot interpolation weight vector into the networks.
+
+| Disease label | Attributes |
| Normal | central reflux of macula |
| Age-related macular degeneration-early [AMD (early)] | hemorrhage, ..., macular edema |
| Age-related macular degeneration-atrophic [AMD (atrophic)] | hemorrhage, ..., macular edema |
| Age-related macular degeneration-exudative [AMD (exudative)] | hemorrhage, ...,drusen, atrophy |
| Central serous chorioretinopathy | macular edema, ..., intraretinal fluid |
| Retinal vein occlusion branch (RVO(B)) | hemorrhage, ..., vitreous hemorrhage |
| Diabetic retinopathy (DR) | hemorrhage, ..., neovascularization |
| Glaucoma | pale optic disc, enlarged cupping |
| Myopic maculopathy | disc change, macular hole |
| Myopic choroidal neovascularization | geographic atrophy, ..., hemorrhage |
+
+parts $^{1}$ . Thirteen universities compiled this dataset, and multiple expert ophthalmologists annotated the images with image-level labels. $60\%$ of the dataset was used for training, $20\%$ of it was used for validation, and the remaining $20\%$ was used for testing. The second is ImageNet-150K-sub, which is a subset of ImageNet-150K [22]. ImageNet-150K is a subset of the ILSVRC2012 dataset [28] with 150,000 images. In ImageNet-150K, 148 images from the training set and 2 images from the validation set were selected from the dataset for each of the 1,000 categories. Twenty-five attributes for each image were annotated in this dataset by multiple experts for each image. Each attribute has three kinds of labels, in which -1 means absent, 0 means uncertain, and is treated as missing in [22], and 1 means present. We treat an attribute with 1 as present and -1 as absent. Because "uncertain" cannot provide useful information on an attribute, we treat an attribute with 0 as missing. We randomly select a subset of 100 classes to conduct our experiment. We call this dataset "ImageNet-150K-sub."
+
+Here, we experimented with the dataset with attribute annotation for each class and the dataset with attribute annotation for each image respectively. We wanted to compare the performance and see whether the simple annotation could improve the experiment performance or not.
+
+# 4.2. Implementation details
+
+Before the training, we preprocessed the fundus images by cropping them to remove the black regions because these regions contain no information. After that, we resized the images to $512 \times 512$ pixels. During the training phase, we augmented the dataset with randomly rotated and horizontally and vertically flipped images from the dataset. The CNN model was implemented by using PyTorch trained on a Quadro GV100. We initially fine-tuned the ResNet50 [10] with ImageNet [4]. A gradient descent optimizer was used with a momentum of 0.9. We trained our CNN model
+
+with a batch size of 16 and an initial learning rate of 0.01. We chose iCarL [26] as the baseline of our work. For the experiment with fundus images, 10 images for each base class were stored as exemplars. For the experiment with the ImageNet-150K-sub, 20 images for each base class were stored as exemplars.
+
+# 4.3. Evaluation on incremental learning
+
+Incremental learning was evaluated by the curve of the classification accuracies after each phase. We also calculated the average of all of the accuracies, i.e., average incremental accuracy.
+
+We compared our proposed method ADINet with the state-of-the-art on our private fundus image dataset. We compared the results of ADINet with the results from learning without forgetting (LwF) [20], incremental classifier and representation learning (iCaRL) [26], and end-to-end incremental learning (EEIL) [2]. Figure 4 shows the results with an incremental setting of 10, 5, and 2 phases. The average incremental accuracies are shown in the bracket next to each method. As shown in Fig. 4, ADINet outperformed the state-of-the-art either in terms of the trend of the classification accuracy curve or average incremental accuracy. Particularly, with 5 phases, the increase of ADINet was more than $10\%$ over iCaRL [26]. According to Fig. 4, it can be seen that ADINet could retain the knowledge of the base classes, which solved the imbalance between the base and new classes. The average incremental accuracies of ADINet with 10, 5, and 2 phases are $82.7\%$ , $83.2\%$ , and $83.1\%$ , respectively. According to Fig. 4, it can be seen that as the incremental phase increased, the performance dropped due to catastrophic forgetting on our fundus image dataset.
+
+We also compared ADINet for the dataset of ImageNet-150K-sub. We show the performance of the proposed method on the validation dataset. Figure 5 shows the results of comparison with 10, 5, and 2 phases. The average incremental accuracies of ADINet with 10, 5, and 2 phases were $87.4\%$ , $87.3\%$ , and $82.5\%$ respectively.
+
+The average incremental accuracy of ADINet for the fundus dataset was not as good as the average incremental accuracy for the ImageNet-150K-sub due to the dataset in ImageNet-150K-sub having more significant variance, which can be easier to classify. ImageNet-150K-sub provides attribute labels per image, but our fundus dataset provides only attribute labels per class. However, observing the results curves of these two datasets, we found that only using attribute labels per class can also alleviate the catastrophic forgetting of incremental learning effectively in each phase. On the basis of the results, our method still can boost the performance of incremental learning with only attribute labels per class.
+
+Table 2. Classification results on fundus image dataset
+
+| Scenario | Fine-tuning type | Fine-tuning method | Loss \( \ell \) in (1) | Variables \( \theta \) in (1) | dataset \( \mathcal{D} \) in (1) |
| \( {\mathcal{F}}_{1} \) | Partial (with fixed \( {\mathbf{\theta }}_{\mathrm{p}} \))1 | ST | \( {\ell }_{\mathrm{f}} \) | \( {\mathbf{\theta }}_{\mathrm{f}} \) | \( {\mathcal{D}}_{\mathrm{f}} \) |
| \( {\mathcal{F}}_{2} \) | Partial (with fixed \( {\mathbf{\theta }}_{\mathrm{p}} \)) | AT | \( {\ell }_{\mathrm{f}} \) | \( {\mathbf{\theta }}_{\mathrm{f}} \) | \( {\mathcal{D}}_{\mathrm{f}} \) |
| \( {\mathcal{F}}_{3} \) | Full2 | ST | \( {\ell }_{\mathrm{f}} \) | \( {\left\lbrack {\mathbf{\theta }}_{\mathrm{p}}^{T},{\mathbf{\theta }}_{\mathrm{f}}^{T}\right\rbrack }^{T} \) | \( {\mathcal{D}}_{\mathrm{f}} \) |
| \( {\mathcal{F}}_{4} \) | Full | AT | \( {\ell }_{\mathrm{f}} \) | \( {\left\lbrack {\mathbf{\theta }}_{\mathrm{p}}^{T},{\mathbf{\theta }}_{\mathrm{f}}^{T}\right\rbrack }^{T} \) | \( {\mathcal{D}}_{\mathrm{f}} \) |
+
+1 Fixed $\theta_{\mathrm{p}}^{*}$ signifies the model learnt in a given pretraining scenario.
+Full fine-tuning retrans $\theta_{\mathrm{p}}$
+
+Given a pretrained model $\theta_{\mathrm{p}}$ , adversarial fine-tuning could have two forms: a) AT for partial fine-tuning and b) AT for full fine-tuning. Here the former case a) solves a supervised fine-tuning task under the fixed model $(\theta_{\mathrm{p}})$ , and the latter case b) solves a supervised fine-tuning task by retraining $\theta_{\mathrm{p}}$ . In Table 2, we summarize different scenarios when AT meets supervised fine-tuning.
+
+It is worth noting that our study on the integration of AT with a pretraining+fine-tuning scheme $(\mathcal{P}_i, \mathcal{F}_j)$ provided by Tables 1-2 is different from [14], which conducted one-shot AT over a supervised classification task integrated with a rotation self-supervision task.
+
+In order to explore the network robustness against different configurations $\{(\mathcal{P}_i,\mathcal{F}_j)\}$ , we ask: is AT for robust pretraining sufficient to boost the adversarial robustness of fine-tuning? What is the influence of fine-tuning strategies (partial or full) on the adversarial robustness of image classification? How does the type of self-supervised pretraining task affect the classifier's robustness?
+
+We provide detailed answers to the above questions in Sec. 4.3, Sec. 4.4 and Sec. 4.5. In a nutshell, we find that robust representation learnt from adversarial pretraining is transferable to down-stream fine-tuning tasks to some extent. However, a more significant robustness improvement is obtained by adversarial fine-tuning. Moreover, AT for full fine-tuning outperforms that for partial fine-tuning in terms of both robust accuracy and standard accuracy (except the Jigsaw-specified self-supervision task). Furthermore, different self-supervised tasks demonstrate diverse adversarial vulnerability. As will be evident later, such diversified tasks provide complementary benefits to model robustness and therefore can be combined.
+
+# 3.3. AT by leveraging ensemble of multiple self-supervised learning tasks
+
+In what follows, we generalize AT to learn a robust pretrained model by leveraging the diversified pretraining tasks. More specifically, consider $M$ self-supervised pretraining tasks $\{\mathcal{T}_{\mathrm{P}}^{(i)}\}_{i = 1}^{M}$ , each of which obeys the formulation in Section 3.1. We generalize problem (1) to
+
+$$
+\underset {\boldsymbol {\theta} _ {r}, \left\{\boldsymbol {\theta} _ {\mathrm {p c}} ^ {(i)} \right\}} {\text {m i n i m i z e}} \mathbb {E} _ {\mathbf {x} \sim \mathcal {D} _ {p}} \left[ \mathcal {L} _ {\text {a d v}} \left(\boldsymbol {\theta} _ {\mathrm {p}}, \left\{\boldsymbol {\theta} _ {\mathrm {p c}} ^ {(i)} \right\}, \mathbf {x}\right) \right], \tag {2}
+$$
+
+where $\mathcal{L}_{\mathrm{adv}}$ denotes the adversarial loss given by
+
+$$
+\begin{array}{l} \mathcal {L} _ {\mathrm {a d v}} \left(\boldsymbol {\theta} _ {\mathrm {p}}, \left\{\boldsymbol {\theta} _ {\mathrm {p c}} ^ {(i)} \right\}, \mathbf {x}\right) \\ := \underset {\{\| \boldsymbol {\delta} ^ {(i)} \| _ {\infty} \leq \epsilon \}} {\text {m a x i m i z e}} \sum_ {i = 1} ^ {M} \ell_ {\mathrm {p}} ^ {(i)} \left(\boldsymbol {\theta} _ {\mathrm {p}}, \boldsymbol {\theta} _ {\mathrm {p c}} ^ {(i)}, \mathbf {x} + \boldsymbol {\delta} ^ {(i)}\right) \\ + \lambda g \left(\boldsymbol {\theta} _ {\mathrm {p}}, \left\{\boldsymbol {\theta} _ {\mathrm {p c}} ^ {(i)} \right\}, \left\{\boldsymbol {\delta} ^ {(i)} \right\}\right). \tag {3} \\ \end{array}
+$$
+
+In (2), for ease of notation, we replace $\{\cdot\}_{i=1}^{M}$ with $\{\cdot\}$ , $\theta_{\mathrm{p}}$ denotes the common network shared among different self-supervised tasks, and $\theta_{\mathrm{pc}}^{(i)}$ denotes a sub-network customized for the $i$ th task. We refer readers to Figure 2 for an overview of our proposed model architecture. In (3), $\ell_{\mathrm{p}}^{(i)}$ denotes the $i$ th pretraining loss, $g$ denotes a diversity-promoting regularizer, and $\lambda \geq 0$ is a regularization parameter. Note that $\lambda = 0$ gives the averaging ensemble strategy. In our case, we perform grid search to tune $\lambda$ around the value chosen in [26]. Details are referred to the supplement.
+
+Spurred by [26, 37], we quantify the diversity-promoting regularizer $g$ through the orthogonality of input gradients of different self-supervised pretraining losses,
+
+$$
+g \left(\boldsymbol {\theta} _ {\mathrm {p}}, \left\{\boldsymbol {\theta} _ {\mathrm {p c}} ^ {(i)} \right\}, \left\{\boldsymbol {\delta} ^ {(i)} \right\}\right) := \log \det \left(\mathbf {G} ^ {T} \mathbf {G}\right), \tag {4}
+$$
+
+where each column of $\mathbf{G}$ corresponds to a normalized input gradient $\{\nabla_{\delta_i}\ell_p^{(i)}(\pmb {\theta}_p,\pmb{\theta}_{pc}^{(i)},\mathbf{x} + \pmb{\delta}^{(i)})\}$ , and $g$ reaches the maximum value 0 as input gradients become orthogonal, otherwise it is negative. The rationale behind the diversity-promoting adversarial loss (3) is that we aim to design a robust model $\pmb{\theta}_{\mathrm{p}}$ by defending attacks from diversified perturbation directions.
+
+# 4. Experiments and Results
+
+In this section, we design and conduct extensive experiments to examine the network robustness against different configurations $\{(\mathcal{P}_i,\mathcal{F}_j)\}$ for image classification. First, we show adversarial self-supervised pretraining (namely, $\mathcal{P}_3$ in Table 1) improves the performance of downstream tasks. We also discuss the influence of different fine-tuning strategies $\mathcal{F}_j$ on the adversarial robustness. Second, we show the diverse impacts of different self-supervised tasks on their resulting pretrained models. Third, we ensemble those self-supervised tasks to perform adversarial pretraining. At the fine-tuning phase, we also ensemble three best models with the configuration $(\mathcal{P}_3,\mathcal{F}_4)$ and show its performance superiority. Last, we report extensive ablation studies to reveal the influence of the size of the datasets $\mathcal{D}_{\mathrm{p}}$ and the resolution of images in $\mathcal{D}_{\mathrm{p}}$ , as well as other defense options beyond AT.
+
+# 4.1. Datasets
+
+Dataset Details We consider four different datasets in our experiments: CIFAR-10, CIFAR-10-C [13], CIFAR-100 and R-ImageNet-224 (a specifically constructed "restricted" version of ImageNet, with resolution $224 \times 224$ ). For the last one, we indeed to demonstrate our approach on high-resolution data despite the computational challenge. We follow [29] to choose 10 super classes which contain a total of 190 ImageNet classes. The detailed classes distribution of each super class can be found in our supplement.
+
+For the ablation study of different pretraining dataset sizes, we sample more training images from the 80 Million Tiny Images dataset [33] where CIFAR-10 was selected from. Using the same 10 super classes, we form CIFAR-30K (i.e., 30,000 for images), CIFAR-50K, CIFAR-150K for training, and keep another 10,000 images for hold-out testing.
+
+Dataset Usage In Sec. 4.3, Sec. 4.4 and Sec. 4.5, for all results, we use CIFAR-10 training set for both pretraining and fine-tuning. We evaluate our models on the CIFAR-10 testing set and CIFAR-10-C. In Sec. 4.6, we use CIFAR-10, CIFAR-30K, CIFAR-50K, CIFAR-150K and R-ImageNet-224 for pretraining, and CIFAR-10 training set for fine-tuning, while evaluating on CIFAR-10 testing set. We also validate our approaches on CIFAR-100 in the supplement. In all of our experiments, we randomly split the original training set into a training set and a validation set (the ratio is 9:1).
+
+
+Figure 2: The overall framework of ensemble adversarial pretraining. The pretrained weights $\theta_{\mathrm{p}}$ are the first three blocks of ResNet-50v2 [11]; Green arrows $(\rightarrow)$ , Blue arrows $(\rightarrow)$ and Red arrows $(\rightarrow)$ represent the feed forward paths of Selfie, Jigsaw and Rotation, respectively.
+
+# 4.2. Implementation Details
+
+Model Architecture: For pretraining with the Selfie task, we identically follow the setting in [35]. For Rotation and Jigsaw pretraining tasks, we use ResNet-50v2 [12]. For the fine-tuning, we use ResNet-50v2 for all. Each fine-tuning network will inherit the corresponding robust pretrained weights to initialize the first three blocks of ResNet-50v2, while leaving the remaining blocks randomly initialized.
+
+Training & Evaluation Details: All pretraining and fine-tuning tasks are trained using SGD with 0.9 momentum. We use batch sizes of 256 for CIFAR-10, ImageNet-32 and 64 for R-ImageNet-224. All pretraining tasks adopt cosine learning rates. The maximum and minimum learning rates are 0.1 and $10^{-6}$ for Rotation and Jigsaw pretraining; 0.025 and $10^{-6}$ for Selfie pretraining; and 0.001 and $10^{-8}$ for ensemble pretraining. All fine-tuning phases follow a multi-step learning rate schedule, starting from 0.1 and decayed by 10 times at epochs 30 and 50 for a 100 epochs training.
+
+We use 10-step and 20-step $\ell_{\infty}$ PGD attacks [21] for adversarial training and evaluation, respectively. Unless otherwise specified, we follow [14]'s setting with $\epsilon = \frac{8.0}{225}$ and $\alpha = \frac{2.0}{255}$ . For all adversarial evaluations, we use the full testing datasets (i.e. 10,000 images for CIFAR-10) to generate adversarial images. We also consider unforeseen attacks [17, 13].
+
+Evaluation Metrics & Model Picking Criteria: We follow [40] to use: i) Standard Testing Accuracy (TA): the classification accuracy on the clean test dataset; II) Robust Testing Accuracy (RA): the classification accuracy on the attacked test dataset. In our experiments, we use TA to pick models for a better trade-off with RA. Results of models picked using RA criterion are included in the supplement.
+
+# 4.3. Adversarial self-supervised pertraining & finetuning helps classification robustness
+
+We systematically study all possible configurations of pretraining and fine-tuning considered in Table 1 and Table 2, where recall that the expression $(\mathcal{P}_i,\mathcal{F}_j)$ denotes a specified pretraining+fine-tuning scheme. The baseline schemes are given by the end-to-end standard training (ST), namely, $(\mathcal{P}_1,\mathcal{F}_3)$ and the end-to-end adversarial training (AT), namely, $(\mathcal{P}_1,\mathcal{F}_4)$ . Table 3 shows TA, RA, and iteration complexity of fine-tuning (in terms of number of epochs) under different pretraining+fine-tuning strategies involving different self-supervised pretraining tasks, Selfie, Rotation and Jigsaw. In what follows, we analyze the results of Table 3 and provide additional insights.
+
+We begin by focusing on the scenario of integrating the standard pretraining strategy $\mathcal{P}_2$ with fine-tuning schemes $\mathcal{F}_3$ and $\mathcal{F}_4$ used in baseline methods. Several observations can be made from the comparison $(\mathcal{P}_2, \mathcal{F}_3)$ vs. $(\mathcal{P}_1, \mathcal{F}_3)$ and $(\mathcal{P}_2, \mathcal{F}_4)$ vs. $(\mathcal{P}_1, \mathcal{F}_4)$ in Table 3. 1) The use of self-supervised pretraining consistently improves TA and/or RA even if only standard pretraining is conducted; 2) The use of adversarial fine-tuning $\mathcal{F}_4$ (against standard fine-tuning $\mathcal{F}_3$ ) is crucial, leading to significantly improved RA under both $\mathcal{P}_1$ and $\mathcal{P}_2$ ; 3) Compared $(\mathcal{P}_1, \mathcal{F}_4)$ with $(\mathcal{P}_2, \mathcal{F}_4)$ , the use of self-supervised pretraining offers better eventual model robustness (around $3\%$ improvement) and faster fine-tuning speed (almost saving the half number of epochs).
+
+Next, we investigate how the adversarial pretraining (namely, $\mathcal{P}_3$ ) affects the eventual model robustness. It is shown by $(\mathcal{P}_3,\mathcal{F}_1)$ and $(\mathcal{P}_3,\mathcal{F}_2)$ in Table 3 that the robust feature representation learnt from $\mathcal{P}_3$ benefits adversarial robustness even in the case of partial fine-tuning, but the use of adversarial partial fine-tuning, namely, $(\mathcal{P}_3,\mathcal{F}_2)$ , yields a $30\%$ more improvement. We also observe from the case of $(\mathcal{P}_3,\mathcal{F}_3)$ that the standard full fine-tuning harms the ro
+
+Table 3: Evaluation Results of Eight Different $(\mathcal{P}_i,\mathcal{F}_j)$ Scenarios. Table 1 and Table 2 provide detailed definitions for $\mathcal{P}_1$ (without pre-training), $\mathcal{P}_2$ (standard self-supervision pre-training), $\mathcal{P}_3$ (adversarial self-supervision pre-training), $\mathcal{F}_1$ (partial standard fine-tuning), $\mathcal{F}_2$ (partial adversarial fine-tuning), $\mathcal{F}_3$ (full standard fine-tuning), and $\mathcal{F}_4$ (full adversarial fine-tuning). The best results are highlighted $(1^{\mathrm{st}},2^{\mathrm{nd}})$ under each column of different self-supervised pretraining tasks.
+
+| Method | Dir. | Disc. | Eat | Greet | Phone | Photo | Pose | Pur. | Sit | SitD. | Smoke | Wait | WalkD. | Walk | WalkT. | Avg |
| Martinez et al. ICCV'17 [27] | 51.8 | 56.2 | 58.1 | 59.0 | 69.5 | 78.4 | 55.2 | 58.1 | 74.0 | 94.6 | 62.3 | 59.1 | 65.1 | 49.5 | 52.4 | 62.9 |
| Fang et al. AAAI'18 [14] | 50.1 | 54.3 | 57.0 | 57.1 | 66.6 | 73.3 | 53.4 | 55.7 | 72.8 | 88.6 | 60.3 | 57.7 | 62.7 | 47.5 | 50.6 | 60.4 |
| Yang et al. CVPR'18 [43] | 51.5 | 58.9 | 50.4 | 57.0 | 62.1 | 65.4 | 49.8 | 52.7 | 69.2 | 85.2 | 57.4 | 58.4 | 43.6 | 60.1 | 47.7 | 58.6 |
| Pavlakos et al. CVPR'18 [34] | 48.5 | 54.4 | 54.4 | 52.0 | 59.4 | 65.3 | 49.9 | 52.9 | 65.8 | 71.1 | 56.6 | 52.9 | 60.9 | 44.7 | 47.8 | 56.2 |
| Luvizon et al. CVPR'18 [25] | 49.2 | 51.6 | 47.6 | 50.5 | 51.8 | 60.3 | 48.5 | 51.7 | 61.5 | 70.9 | 53.7 | 48.9 | 57.9 | 44.4 | 48.9 | 53.2 |
| Hossain et al. ECCV'18 [19] | 48.4 | 50.7 | 57.2 | 55.2 | 63.1 | 72.6 | 53.0 | 51.7 | 66.1 | 80.9 | 59.0 | 57.3 | 62.4 | 46.6 | 49.6 | 58.3 |
| Lee et al. ECCV'18 [21] | 40.2 | 49.2 | 47.8 | 52.6 | 50.1 | 75.0 | 50.2 | 43.0 | 55.8 | 73.9 | 54.1 | 55.6 | 58.2 | 43.3 | 43.3 | 52.8 |
| Dabral et al. ECCV'18 [13] | 44.8 | 50.4 | 44.7 | 49.0 | 52.9 | 61.4 | 43.5 | 45.5 | 63.1 | 87.3 | 51.7 | 48.5 | 52.2 | 37.6 | 41.9 | 52.1 |
| Zhao et al. CVPR'19 [48] | 47.3 | 60.7 | 51.4 | 60.5 | 61.1 | 49.9 | 47.3 | 68.1 | 86.2 | 55.0 | 67.8 | 61.0 | 42.1 | 60.6 | 45.3 | 57.6 |
| Pavillo et al. CVPR'19 [35] | 45.2 | 46.7 | 43.3 | 45.6 | 48.1 | 55.1 | 44.6 | 44.3 | 57.3 | 65.8 | 47.1 | 44.0 | 49.0 | 32.8 | 33.9 | 46.8 |
| Ours (n=243 CPN causal) | 42.3 | 46.3 | 41.4 | 46.9 | 50.1 | 56.2 | 45.1 | 44.1 | 58.0 | 65.0 | 48.4 | 44.5 | 47.1 | 32.5 | 33.2 | 46.7 |
| Ours (n=243 CPN) | 41.8 | 44.8 | 41.1 | 44.9 | 47.4 | 54.1 | 43.4 | 42.2 | 56.2 | 63.6 | 45.3 | 43.5 | 45.3 | 31.3 | 32.2 | 45.1 |
| Martinez et al. ICCV'17 [27] | 37.7 | 44.4 | 40.3 | 42.1 | 48.2 | 54.9 | 44.4 | 42.1 | 54.6 | 58.0 | 45.1 | 46.4 | 47.6 | 36.4 | 40.4 | 45.5 |
| Hossain et al. ECCV'18 [19] | 35.2 | 40.8 | 37.2 | 37.4 | 43.2 | 44.0 | 38.9 | 35.6 | 42.3 | 44.6 | 39.7 | 39.7 | 40.2 | 32.8 | 35.5 | 39.2 |
| Lee et al. ECCV'18 [21] | 32.1 | 36.6 | 34.4 | 37.8 | 44.5 | 49.9 | 40.9 | 36.2 | 44.1 | 45.6 | 35.3 | 35.9 | 37.6 | 30.3 | 35.5 | 38.4 |
| Zhao et al. CVPR'19 [48] | 37.8 | 49.4 | 37.6 | 40.9 | 45.1 | 41.4 | 40.1 | 48.3 | 50.1 | 42.2 | 53.5 | 44.3 | 40.5 | 47.3 | 39.0 | 43.8 |
| Pavillo et al. CVPR'19 [35] | 35.2 | 40.2 | 32.7 | 35.7 | 38.2 | 45.5 | 40.6 | 36.1 | 48.8 | 47.3 | 37.8 | 39.7 | 38.7 | 27.8 | 29.5 | 37.8 |
| Ours (n=243 GT) | 34.5 | 37.1 | 33.6 | 34.2 | 32.9 | 37.1 | 39.6 | 35.8 | 40.7 | 41.4 | 33.0 | 33.8 | 33.0 | 26.6 | 26.9 | 34.7 |
+
+Table 1: Protocol#1 with MPJPE (mm): Reconstruction error on Human3.6M. Top-table: input 2D joints are acquired by detection. Bottom-table: input 2D joints with ground-truth. (CPN) - cascaded pyramid network; (GT) - ground-truth.
+
+